Top-rated recipes tagged "descriptor"

Observer pattern implemented with Descriptor class (Python)

2010-03-13T11:53:18-08:00

Python recipe 576979 by Rodney Drenth (descriptor, observer, publish, subscribe). Revision 5.

The observer pattern is implemented using an observable descriptor. One creates instances of observable in a class, which allows observers to subscribe to changes in the observable. Assigning a value to the observable causes the suscribers to be notified. An observable can subscribe to another observable, in which case changes to the second propagate to subscribers of the first. The subscribe method returns a Subscription object. When this object is deleted or becomes unreferenced, the subscription is cancelled.

Item Properties (Python)

2012-05-09T23:24:55-07:00

Python recipe 577703 by Ian Kelly (decorator, descriptor, oop, property). Revision 2.

A property variation that allows property access using an index or key.

dualmethod descriptor (Python)

2010-02-06T20:54:45-08:00

Python recipe 577030 by Steven D'Aprano (decorator, descriptor, method). Revision 3.

This descriptor can be used to decorate methods, similar to the built-ins classmethod and staticmethod. It enables the caller to call methods on either the class or an instance, and the first argument passed to the method will be the class or the instance respectively.

This differs from classmethods, which always passes the class, and staticmethods, which don't pass either.

Like all descriptors, you can only use this in new-style classes.

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.

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:

Observer pattern implemented with Descriptor class (Python)

2012-02-14T23:43:53-08:00

Python recipe 578038 by Rodney Drenth (descriptor, observer, publish, reactive, subscribe).

This version compatible with Python 3.0 Example uses unittest to help in understanding the functionality.

Lazy Dynamic Binding on Classes (You'll Never Go Back) (Python)

2011-08-12T23:42:27-07:00

Python recipe 577745 by Eric Snow (decorator, decorators, descriptor, descriptors). Revision 4.

This recipe provides a descriptor class and a decorator to make the deferred binding. Before the first access to that name, the __dict__ of the class will have the descriptor object. After that first access it will have whatever was returned by the first access.

One big advantage of deferring the binding is that the class object will be available at that time and can be passed to the object. During normal class creation the class body is exec'd before the class object is created, so the objects bound there can't be passed the class.

Recipe #577746 provides a concrete example of how the deferred_binder can be used.

Threadsafe observer pattern implemented as descriptor (Python)

2010-03-13T12:17:11-08:00

Python recipe 577106 by Rodney Drenth (descriptor, observer, publish, subscribe, threads).

This is a threadsafe version of recipe 576979. A publish-subscribe (observer) pattern is implemented as a descriptor. Assigning a value notifies the observers. Uses recipe 577105 as synchlock.py and recipe 576979 as Observer.py

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.

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).

Bound Inner Classes (Python)

2013-12-10T02:36:25-08:00

Python recipe 577070 by Larry Hastings (class_decorator, descriptor). Revision 8.

This recipe provides the class decorator BoundInnerClass. The decorator makes inner classes symmetric with method calls. Functions declared inside classes become "methods", and when you call them through an object they automatically get a reference to "self". The BoundInnerClass decorator makes this work for inner classes: an inner class decorated with BoundInnerClass gets a reference to that same (now "outer") object passed in automatically to the inner class's __init__.

The recipe works unchanged in Python 2.6 and 3.1, and is licensed using the Zlib license.