Popular recipes tagged "metaclass" but not "chainmap"

Emulating super() in Python 3.x using Python 2.7 (Python)

2016-07-31T04:03:29-07:00

Python recipe 580694 by sunqingyao (beginner, descriptor, metaclass, oop, python2).

Depending on the name of the first argument, self.__sup or cls.__sup behaves like super() in Python 3, while this code is written in Python 2.7.

It works for both ordinary methods and class methods(static methods don't use super()). See my code for detailed examples:

dynamically changing encoder (for json) with metaclass (class factory) (Python)

2013-10-24T11:31:44-07:00

Python recipe 578696 by - (class_factory, encode, json, metaclass, metaclasses).

The json.dumps need to be feed with some class (cls =someClass) but what if we want to change the class dynamically? This example can be done by declaring the listOfClasses in class level of course, but the idea is to be changeable. This can be done by the class factory function encoderFacory

A simple enum type (Python)

2013-02-13T06:53:38-08:00

Python recipe 578455 by Eric Snow (enum, metaclass). Revision 2.

Inspired by various threads[1] on the python-ideas list, here's a simple enum type. Enums are generated either via the class syntax or via Enum.make().

class Breakfast(Enum):
    SPAM, HAM, EGGS
    BACON, SAUSAGE

Breakfast = Enum.make("SPAM HAM EGGS BACON SAUSAGE")

Here are some of the features:

Enum:

inheriting from an enum inherits copies of its values.
the export() method allows for exposing an enum's values in another namespace.

Enum Values:

the underlying values within an enum are essentially useless, diminishing the temptation to rely on them.
identity is equality, like with None, True, and False.
enum values support bitwise operations within the same enum.
the result of a bitwise operation is always the same object given the same inputs.

[1] see http://mail.python.org/pipermail/python-ideas/2013-January/019003.html

Performance boost with metaclasses (Python)

2013-02-17T10:58:13-08:00

Python recipe 578460 by Martin Schoepf (metaclass, performance).

Consider a highly dynamic system where a lot of objects are created and destroyed. If the objects are complex and have a lot of default values the following recipe may improve the performance. The more default values you have the more you will gain from it.

A metaclass that hides details of the attribute name when called. (Python)

2012-08-31T09:53:59-07:00

Python recipe 578249 by Chaobin Tang (唐超斌) (metaclass, python). Revision 2.

In cases, where getting an attribute will expose to the client code the detail of the very attribute name, which could be changeable over time. This NamedAndCachedAttributeType is intended to hide this detail by mapping the real attribute name to another name that is maintained by the class itself. By doing so, the content provider(this class) and the client code(the caller) establish a deal that the changes of names are taken care of by the provider itself. Second, the value is set as a class variable once it is first retreived, as being cached.

threadbox.py (Python)

2012-10-09T22:40:09-07:00

Python recipe 578152 by Stephen Chappell (metaclass, threading). Revision 2.

Provide a way to run instance methods on a single thread.

This module allows hierarchical classes to be cloned so that their instances run on one thread. Method calls are automatically routed through a special execution engine. This is helpful when building thread-safe GUI code.

METACLASS AND DEEPCOPY (Python)

2012-02-26T15:43:01-08:00

Python recipe 578053 by thonpy (deepcopy, equal, list, metaclass, sign).

I would like to solve this excercise: Traditionally object-oriented programming provides two different modes for cloning an instance or a structured data type: shallow and deep copy. The former has the effect to clone exclusively the external shell and not its content originating a quite fastidious aliasing effect. The latter, instead, copies the shell and its content recursively creating two completely separate copies of the instance.

As you know, Python's programs suffer of the aliasing effect when you copy an instance of a class or a structured type (e.g., a list) with the = operator. As showed in the following example:

l=[0,1,2] mylist=l mylist[2] = ’B’ mylist [1, 2, ’B’] l [1, 2, ’B’

The exercise consists of defining a meta-class which implements the deep copy on the assignment operator and binding this to the standard class list. Such that the following behavior can be yielded

Bunch class created from attributes in class (Python)

2011-12-31T18:03:02-08:00

Python recipe 577999 by Fabio Zadrozny (attributes, bunch, metaclass). Revision 3.

Provide a way to construct class __init__, __slots__, __eq__, __ne__, __repr__ for the class and makes explicit which attributes each instance will have (and providing defaults).

The __main__ session shows an example of how it should be used.

Make a Class Available in its Own Definition Body! (Python)

2011-09-15T05:36:36-07:00

Python recipe 577867 by Eric Snow (class, metaclass).

This may sound too good to be true, but see for yourself. No time machines involved. Just plug in this metaclass and look for __newclass__ in your class body. It's not perfect, but the problematic corner cases are more bark than bite.

Using Metaclasses and Class Decorators to Inherit Function Docstrings (Python)

2011-06-11T00:59:35-07:00

Python recipe 577743 by Eric Snow (decorator, decorators, docstring, inheritance, metaclass, metaclasses). Revision 4.

You'll find three different approaches to copying the method's docstring to the overriding method on a child class.

The function decorator approach is limited by the fact that you have to know the class when you call the decorator, so it can't be used inside a class body. However, recipe #577746 provides a function decorator that does not have this limitation.

Make the New Class Available During the Execution of its Body (Python)

2011-08-12T23:44:46-07:00

Python recipe 577744 by Eric Snow (class, metaclass).

When a class object is created, normally the class body is exec'ed first and then the class object is generated with that resulting namespace.

This recipe lets you flip that around, and then make the class object available to the class body during execution.

Auto Named Decriptors (Python)

2010-10-19T22:55:16-07:00

Python recipe 577426 by Aloys Baillet (automatically, constants, descriptors, metaclass, name, string). Revision 3.

Using named Descriptors? Tired of duplicating the name of the instance in a string? A small metaclass can solve this.

argdeclare: declarative interface to argparse (Python)

2010-03-02T00:05:40-08:00

Python recipe 576935 by Shakeeb Alireza (argparse, cmdln, commandline, getopt, metaclass, option). Revision 5.

This is an implementation of the interface provided by the cmdln module but using argparse to provide the option/arg heavy parsing.

An example of usage is provided in the test function, which should produce the following from the command line:

$ python argdeclare.py --help

usage: argdeclare.py [-h] [-v] {uninstall,install,delete} ...

a description of the test app

optional arguments:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit

subcommands:
  valid subcommands

  {uninstall,install,delete}
                        additional help
    delete              help text for delete subcmd
    install             help text for install subcmd
    uninstall           help text for uninstall subcmd

$ python argdeclare.py install --help

usage: argdeclare.py install [-h] [-t TYPE] [--log] [-f] package

positional arguments:
  package               package to be (un)installed

optional arguments:
  -h, --help            show this help message and exit
  -t TYPE, --type TYPE  specify type of package
  --log, -l             log is on
  -f, --force           force through installation

enjoy!

Alias class attributes (Python)

2009-06-01T01:19:55-07:00

Python recipe 576787 by Euan Goddard (alias, attribute, class, descriptor, metaclass).

The alias metaclass allows a declarative way of creating aliases to attributes on a class. The main purpose of which is to adapt classes for duck-typing (see doc-string for me detail).