Popular recipes tagged "observer"

Observer Pattern (Python)

2013-03-09T10:03:10-08:00

Python recipe 578484 by Mauro B. Bianc (cascade, observer, oop, pattern, patterns, setattr, __setattr__). Revision 2.

This is a Python implementation of the observer pattern described by Gamma et. al. It defines a one-to many dependency between objects so that when one object changes state, all its dependents (i.e. observers) are notified and updated automatically.

My adaptation gets rid of the need to use specific functions to set the data (and to call Notify) and allows you to be notified for ANY attribute you set. It is possible to specify a list of attributes which should not trigger a notification. In case you need the opposite, it is very easy to invert the behavior of the code.

The example should output: Creating data1 without notification for attrs name & surname
Creating data2 without notification for attr age
Setting data1.name=Heather - Notification unnecessary
Setting data1.num=333 - Notification expected
Observer1: Subject Heather has updated attr num to 333
Setting data2.name=Molly - Notification expected
Observer2: Subject Molly has updated attr name to Molly
Setting data2.age=28 - Notification unnecessary
Setting data2.eyecolor=blue - Notification expected
Observer2: Subject Molly has updated attr eyecolor to blue

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

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.

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

Observer Design Pattern for python gevent coroutine package (Python)

2010-12-08T08:33:30-08:00

Python recipe 577491 by Andrey Nikishaev (event, gevent, observer, python).

This is simple implementation of the observer design pattern. Acting as a registration hub, it fires events when requested. Also i have gevent.Timeout like interface in situations when you need to run event-method in the same greenlet. Example:

e = Observer()
ev = e.wait('kill')
try:
    gevent.sleep(3)
except FiredEvent:
    print 'Fired!'
else:
    print 'Not Fired!'
finally:
    ev.cancel()

But rememeber, if you are using subscribe method, event-method will be executed in another greenlet.

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

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.

Flexible observer pattern implementation (Python)

2012-12-06T19:23:11-08:00

Python recipe 576962 by Glenn Eychaner (event, observer, pattern, publish, subscribe, threadsafe). Revision 16.

A simple, flexible, general-purpose observer pattern.

Observers can be callable objects or objects with a particular named method (handle_notify() by default). Events can be any object, and observers can select which events they are interested in receiving. Support for a number of different types of lightweight event objects is included.

Yet another signal/slot implementation in Python (Python)

2008-09-01T23:21:28-07:00

Python recipe 576477 by Thiago Marcos P. Santos (observer, publish, signal, slot, subscribe, weakref).

This code snippet was based on the nice recipe 439356 made by Patrick Chasco. My implementation supports only class methods callbacks. I'm keeping the idea of use weakrefs to avoid the interpreter keep the object allocated because the signal is registered (i.e. the signal object holds a reference to callback method). IMO the usage of WeakValueDictionary made the code smaller and clear and also are maintenance-free (when the object is collect by the garbage collector the signal is automatically unregistered).