Latest recipes tagged "metaprogramming"

Python AsciiColor and video attributes (Python)

2014-07-24T04:25:53-07:00

Python recipe 578908 by Mike 'Fuzzy' Partin (ascii, color, dynamic_method, metaprogramming, python). Revision 5.

This is a subclass of a standard str object that adds methods for applying color, and video attributes to text.

Class-only Methods (Python)

2013-03-08T17:00:53-08:00

Python recipe 578486 by Eric Snow (metaprogramming).

We use the classmethod builtin to tie methods to the class rather than the instance. This is really useful for a variety of things, like alternate contructors. However, sometimes you don't want to expose the method on the instances, just on the class.

For instance, it usually doesn't make a lot of sense to have direct access to alternate constructors from instances; the main constructor, via the __call__ method, is only available on the class. Why? So that instances call implement their own call semantics. This is similar to why the methods (and other class attributes) on namedtuples all have names starting with an underscore.

To restrict a method just to the class, currently you must use a metaclass. Most people consider this black magic so they just use @classmethod. Furthermore, implementing a metaclass is simply more verbose than decorating a method with classmethod. Plus you have to deal with things like metaclass conflicts and the fact that metaclasses are inherited.

So...here is a sibling to classmethod that makes a method class-only without introducing metaclass complexity. You use it the same way as you would classmethod.

A Class Decorator that Adds a copy() Method (Python)

2013-02-14T20:43:20-08:00

Python recipe 578457 by Eric Snow (metaprogramming).

Here's a class decorator that adds a rudimentary copy() method onto the decorated class. Use it like this:

@copiable
class SomethingDifferent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

or like this:

@copiable("a b c")
class SomethingDifferent:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

s = SomethingDifferent(1,2,3)
sc = s.copy()
assert vars(s) == vars(sc)

(Python 3.3)

A class decorator for creating named tuples (Python)

2013-02-14T19:58:13-08:00

Python recipe 578456 by Eric Snow (metaprogramming, namedtuple). Revision 3.

This class decorator factory is useful for replacing the following:

class MyTuple(namedtuple('MyTuple', "a b c")):
    """Something special."""
    @classmethod
    def from_defaults(cls, a, b=None, c=5):
        return cls(a, b, c)

or even:

class MyTuple(namedtuple('MyTuple', "a b c")):
    """Something special."""
    def __new__(cls, a, b=None, c=5):
        return super().__new__(cls, a, b, c)

with this:

@as_namedtuple("a b c", None, c=5)
class MyTuple:
    """Something special."""

I found that I often subclass named tuples to add on some functionality or even just a nice docstring. Plus with the class syntax there's no missing that a class is bound to the name (and it's a little easier to search for the definition). When you subclass a named tuple the boilerplate involved really jumps out.

One of the main reasons Adding support for defaults to namedtuple would mitigate the need for that functionality here, but I'm not going to hold my breath on that.

One nice (though minor) thing is that you don't have to repeat the name when defining the namedtuple.

Object snoop - experiment with Python special methods (Python)

2010-09-05T17:54:50-07:00

Python recipe 577383 by Wai Yip Tung (metaprogramming, methods, object).

In Python, classes can define their own behavior with respect to language operators. For example, if a class defines __getitem__(), then x[i], where x is an instance of the clas, will be execute by a call to x.__getitem__(i).

While Python has an extensive documentation on the special methods, reading a specification may not be the best way to reveal the intricate details. object_snoop allows user to observe how Python expressions and statements are translated into special method calls. object_snoop defines most special methods. It simple print a trace and returns a fixed but sensible result. Users are invited to build complex expressions to experiment how Python special methods work.

Docstring inheritance decorator (Python)

2009-07-28T13:42:32-07:00

Python recipe 576862 by Shai Berger (decorator, descriptor, docstring, inheritance, metaprogramming).

In many cases, a subclass overrides a method in a parent class, just to change its implementation; in such cases, it would be nice to preserve the overridden method's docstring. The decorator below can be used to achieve this without explicit reference to the parent class. It does this by replacing the function with a descriptor, which accesses the parent class when the method is accessed as an attribute.

Subclass function (Python)

2009-03-23T00:48:54-07:00

Python recipe 576697 by Peter Russell (class, metaprogramming, subclass). Revision 4.

Do not use this function - instead use the built in type(name, bases, dict) constructor This is a function that builds a subclass of some base classes. I wrote it while unaware that type could be used as a constructor.