Popular recipes tagged "abc"

namedtuple.abc - abstract base class + mix-in for named tuples (Python)

2011-04-02T02:07:00-07:00

Python recipe 577629 by Jan Kaliszewski (abc, collections, dry, inheritance, namedtuple, shortcuts). Revision 7.

If you need

to define named tuple subclasses (including reusable abstract ones), adding/overriding some methods, in a convenient way;
to have the named tuple ABC (abstract base class) for isinstance/issubclass tests;
or simply would like to define your named tuple classes in a class-syntax-based and DRY way (without repeating type names...)

-- this recipe is for you.

Validating classes and objects against an Abstract Base Class (Python)

2011-05-21T19:14:19-07:00

Python recipe 577711 by Eric Snow (abc, validation). Revision 4.

Abstract Bases Classes in Python provide great features for describing interfaces programmatically. By default a subclass is validated against all its ABC parents at instantiation time (in object.__new__). This recipe aims to provide for validation against an ABC of:

any class at definition time (including subclasses and registered classes),
any object at any time.

I have included an example of the reason I did all this. It allows you to implement an ABC in the instance rather than the class.

If the classes argument to validate is None then it tries to build the list of classes from the object's MRO. If the ABCMeta.register method facilitated an __implements__ list on classes, we could also use that to validate against the registered "base" classes.

The code I have provided is for Python 3, but it should work in 2.7 with a little modification.

This code borrows from Lib/abc.py and objects/typeobject.c

Adding implements to subclasses during ABCMeta.register (Python)

2011-08-13T03:49:26-07:00

Python recipe 577712 by Eric Snow (abc).

This is an extension to the abc.ABCMeta class. It is related to recipe 577711.

Basically it has ABCMeta.register add __implements__ to any subclass that gets registered.

Immutable Type Hierarchies (Python)

2010-10-11T23:32:31-07:00

Python recipe 577424 by Aaron Sterling (abc, hierarchy, immutable). Revision 4.

Allows for type hierarchies of immutable types by faking inheritance using dict updates and abc's.

Component architecture through data descriptors and function decorators (Python)

2009-07-23T11:13:48-07:00

Python recipe 576852 by Danny G (abc, abstract_base_class, component, interface, plugin). Revision 5.

My desire was to design a class with defined attributes that when assigned on instances, would expand the instance's functionality. In other words if I create an instance of class A, then assign a 'component' attribute upon that instance, I should be able to call methods of the component object through the original instance. I believe this is somewhat similar to interfaces and abstract base classes (and I read up on both a bit), but I want to rely more on introspection of the object to see what it can do versus confining it to a set interface.

Components and Abilities (different implementation of Component architecture) (Python)

2009-07-23T13:26:32-07:00

Python recipe 576854 by Danny G (abc, ability, abstract_base_class, component, descriptor, dynamic, interface, plugin). Revision 6.

I define a 'Component' as an attribute (typing optional) that instances can assign objects to. Nothing special there, but their usefulness comes in with 'Abilities'. If a class inherits from 'ClassWithAbilities', it will be given a special attribute 'abilities' that will grow/shrink when other classes with abilities are assigned to an instances attributes. It increases/decreases the functionality of the instance depending on what objects are assigned to it. All of these abilities are accessed through the 'abilities' attribute. This is a redesign of Recipe 576852, but I believe is different enough to warrant a new recipe.