Skip to content

Python observer class to support data flow programming. Similar to py-notify but simpler. Provides a `Variable` class with support for blocking, and an `Algorithm` class that coalesces updates from blocked inputs

License

Notifications You must be signed in to change notification settings

danhorner/observer

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

10 Commits
 
 
 
 
 
 

Repository files navigation

observer

This is a small observer library. There are many, but this one meets my particular needs:

  • Straightforward encapsulation of Algorithms that run when input conditions are changed
  • Variables can be blocked to suppress updates until inputs have stabilized
    • Never worry about callback ordering
  • Observer syntax should be readable

See esp:

  • py-notify (Close, but I esp. want to coalesce updates)
  • trellis (Looks promising, if heavy)

Sneak Preview:

>>> def printVar(name):
...     def p(x):
...        print "%s: %r"%(name,x)
...     return p

Define a Variable:

     >>> v1=Variable(3)

Make a derived variable:

>>> v2= (v1+3)/5
>>> v2.observe(printVar("v2"))

Watch as changes propagate to the derived variable

>>> v1.value=27
v2: 6

It also works when combining two variables

>>> v3 = v2 * 2
>>> v3.observe(printVar("v3"))
>>> v1.value= 12
v2: 3
v3: 6

Read on to see how to implement a custom Algorithm: a transformation from inputs to outputs that is executed asynchronously as inputs change

Basic Objects

Observable exposes the special property value, which is implemented by get() and set(). It also implements observe()

>>> o=Observable(1)
>>> o.observe(printVar("o"))
>>> o.value=2
o: 2

Variable is like Observable, but updates can be suppressed using the blocked flag, which is also observable. This is the main building block of the module: blocking is essential to have updates propagate correctly when there are diamond-shaped Flows: v1->(v2,v3)->v4

>>> v=Variable()
>>> v.observe(printVar("v"))
>>> v.value=3
v: 3
>>> v.block()
>>> v.value=4
>>> v.value=5
>>> v.unblock()
v: 5

Variables can track other variables unidirectionally

>>> source=Variable(2)
>>> v.track_variable(source)
v: 2
>>> source.value=7
v: 7

Variables can be linked with other variables bidirectionally

>>> v_copy=Variable()
>>> v_copy.observe(printVar("v_copy"))
>>> linkVariables(v,v_copy)
v_copy: 7
>>> source.value="two places at once"
v: 'two places at once'
v_copy: 'two places at once'
>>> unlinkVariables(v,v_copy)

Algorithm is a container for variables that connects inputs to outputs

>>> class Inverter(Algorithm):
...     _inputs_=('input',)
...     _outputs_=('output',)
...     def update(self):
...         self.output.value=not self.input.value

>>> i=Inverter(enabled=False)
>>> i.output.observe(printVar("inverted"))
>>> i.enabled.set(True)
inverted: True
>>> i.input.value=True
inverted: False

These modules can be connected together to form a flow graph. The idea is to use the blocked flag to suppress processing until the parent data has stopped flapping about. There is also an enable flag which is useful to stop your algorithm from executing until the inputs are connected.

** Todo: ** I don't care about weak references for now. At some point I may add them, but ** Todo: ** Make block/unblock operations threadsafe

About

Python observer class to support data flow programming. Similar to py-notify but simpler. Provides a `Variable` class with support for blocking, and an `Algorithm` class that coalesces updates from blocked inputs

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages