Latest recipes by Eric Snow

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.

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

ChainedList and ChainedListView: Exposing Multiple Lists as a Single Sequence (Python)

2012-07-03T21:00:02-07:00

Python recipe 578190 by Eric Snow (lists, wrapper).

Handy for composing lists without losing the underlying indepedence. The "lists" don't actually have to be lists, though for ChainedList they must be mutable.

A generic factory factory. (Python)

2012-06-11T23:31:11-07:00

Python recipe 578165 by Eric Snow (factory).

Factories are useful for producing objects without having to store certain data on the objects' type. Instances of this factory class are factories that can produce

A Simpler Namespace Class (Python)

2013-02-14T17:42:24-08:00

Python recipe 578141 by Eric Snow (namespaces, object). Revision 3.

A very simple, attribute-based namespace type (and one offspring). Everyone's written one of these...

Tracking and Manipulating the Python Import State (Python)

2012-04-22T07:27:29-07:00

Python recipe 578107 by Eric Snow (import).

This is a rough analog to the import engine described in PEP 406. Here I've called it ImportState.The focus here is on using it as a context manager to limit changes to the import state to a block of code (in a with statement). Differences from PEP 406 are described below.

A MutableMapping that Can Use Unhashable Objects as Keys (Python)

2012-04-04T20:36:59-07:00

Python recipe 578096 by Eric Snow .

The catch is that the unhashable objects aren't actually stored in the mapping. Only their IDs are. Thus you must also store the actual objects somewhere else.

A Script that Adds a Directory to sys.path Permanently (Python)

2012-02-16T23:15:11-08:00

Python recipe 578043 by Eric Snow (script, sys_path).

This script takes advantage of PEP 370, "Per user site-packages directory". It manages .pth files, which are are non-volatile (unlike manually adding to sys.path). See http://docs.python.org/library/site.html.

Emulate Keyword-Only Arguments in Python 2 (Python)

2011-11-03T18:31:52-07:00

Python recipe 577940 by Eric Snow (argument, keyword_only, kwonly, parameter).

Python 3 introduced a useful feature: keyword-only arguments. In order to get the same effect in Python 2, you must use **kwargs in your parameter list. Then, at the beginning of your function body you must manually extract what would be the keyword-only arguments once you upgrade to 3.

This recipe helps reduce the boilerplate to a single function call. You still don't get those parameters in your "def" clause (where they are more obvious), but at least it reduces the clutter.

Simple Lock Classes Based on threading.Lock() (Python)

2011-10-19T21:26:39-07:00

Python recipe 577914 by Eric Snow (lock, locking).

Nothing fancy here. Locks can take many forms. Here are a few.

A Protocol for Making Objects Immutable (Python)

2011-10-07T03:59:45-07:00

Python recipe 577895 by Eric Snow (freeze, immutable, mutable, unfreeze).

Python already provides immutable versions of many of the mutable built-in types. Dict is the notable exception. Regardless, here is a protocol that objects may implement that facilitates turning immutable object mutable and vice-versa.

See What the Builtins Are (Python)

2011-11-04T22:44:09-07:00

Python recipe 577888 by Eric Snow (builtins). Revision 3.

The built-ins are all those functions, constants, and types that are there when you need them most, like list, any, and None. This recipe is a simple way of looking at the built-ins. Check below for a thorough explanation.

A Simple Namespace Class (Python)

2011-10-03T21:12:41-07:00

Python recipe 577887 by Eric Snow (dict, namespaces). Revision 3.

"Namespaces are one honking great idea -- let's do more of those!" -- The Zen of Python

For when you want a simple, easy namespace, but you don't want it cluttered up with Python's object machinery.

Inspect a PYC File (Python)

2011-09-29T20:07:10-07:00

Python recipe 577880 by Eric Snow (bytecode, inspection, pyc). Revision 3.

This is a revamp of a recipe that Ned Batchelder posted on his blog a few years ago (thanks Ned!). That page is pretty insightful, recipe aside.

This recipe works for all versions of Python back to 2.4 (at least). Warning: using one version of Python to inspect a pyc file from another Python version may not work too well.

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.

Mixins by Inheritance vs. by Decorator...Let's Try Decorators (Python)

2011-08-12T15:29:21-07:00

Python recipe 577824 by Eric Snow (decorators, mixins).

Using mixin classes via inheritance has its pros and cons. Here is an easy alternative via a decorator. As a bonus, you can mix in attributes from any object, not just classes.

Turn a Function Into a Class (Python)

2011-10-05T18:38:43-07:00

Python recipe 577822 by Eric Snow (classes, functions).

The only catch is that the function has to return locals() at the end. And it doesn't do the __prepare__ part of 3.x metaclasses.

Turn @some_decorator() into @some_decorator (Python)

2011-08-04T18:48:36-07:00

Python recipe 577820 by Eric Snow (decorators).

A decorator factory is a function that returns a decorator based on the arguments you pass in. Sometimes you make a decorator factory to cover uncommon use cases. In that case you'll probably use default arguments to cover your common case.

The problem with this, however, is that you still have to use the call syntax (with no arguments) to get the common-use-case decorator, as demonstrated in the recipe title. This recipe effectively makes it so that your decorator factory and your common-use-case decorator have the same name (and actually the same object).