Pub/Sub workshop Demo¶
This notebook is part of my MESS Design Workshop PubSub {DRAFT}
A complete PubSub demo in python¶
For instruction to run, or see it as a slideshow, see: http://mess.softwarebetermaken.nl/en/latest/SoftwareCompetence/DesignWorkShops/PubSub/demo/index.html {Draft}
Notes (in slides-mode):
- Use the spacebar to forward to the next slide after selecting (clicking) in this frame.
- Or, click the outer-edge to open in a new window/tab. And use 'F' for full-window mode
The Demo¶
Some demos in python
- A complete implementation
- A Topic class
- With a subscribe and a publish method
- Several "demo" subscribers
- They just print ...
- Real functionality is left to the reader
- Both in function-style and in OO-style
- And, in the mixture
- They just print ...
Use it, by publishing to all
- Life, interactive; in IPython (& Jupyter) notebook
- Revealjs slides, generated from above
Both, the notebook & slides are downloadable
The basics: A Topic class¶
- A simple
Topicclass - And a trivial function that is use to subscribe
class Topic():
def __init__(self, name=None, initial_value=None):
self.name = "" if name is None else str(name)
self._callbacks = []
self._value = initial_value
def subscribe(self, callback):
if not callback in self._callbacks:
self._callbacks.append(callback)
def publish(self, value, force=False):
if force or self._value != value:
self._call_callbacks(value)
self._value = value
def _call_callbacks(self, new_value):
for cb in self._callbacks:
cb(new_value, self)
def __str__(self):
return "<<%s: '%s' at 0X%x>>" % (
self.__class__.__name__, self.name, id(self))
def demo(val, topic):
print("Demo:: Topic: %s has new value: %s" %(topic, val))
Note: You can ignore the dunder methods, Topic.__init__() and Topic.__str__() for now
Demo 1: Simple use¶
- Create a topic
- Subscribe
demo - Publish a value
t1=Topic("demo 1")
t1.subscribe(demo)
t1.publish("HOI")
Using a Topic is trivial:
Once a topic is created and a callback is registerd, that function is called whenever a new value is pubished.
topic.publish(data) kind of act as callback(data, topic), for all callbacks in a loop
1a: This pub/sub is smart¶
- It will not distribute the same value twice.
- Unless it is asked to do so (
force)
# Only a changed value will be published
t1.publish("AGAIN")
t1.publish("AGAIN")
# Unless we 'force' it
t1.publish("FORCE", force=True) # This force is needed, as it isn't "again" ...
t1.publish("FORCE", force=True)
# Unless we 'force' it
t1.publish("SMART", force=False) # You see ...
t1.publish("SMART", force=True)
1b: Even more smartness¶
This Topic will not subscribe the same function again
t1.publish("I'm so smart")
# `demo` is already registered above
t1.subscribe(demo) # will silently be ingnored
t1.publish("As I call demo only once")
Demo 2: Multi-use¶
Now with multiple subscribers
- We create (another) Topic:
t2 - And a handfull of (again, trivial) demo-callbacs
And subscribe all callbacks to the same t2 Topic ...
Then, all are executed as when publish() is called (once).
It is so easy :-)
t2= Topic("demo2")
def demo_2(val, topic):
print("Demo 2:: Topic: %s has new value: %s" %(topic, val))
def demo_3(val, topic):
print("Demo 3:: Topic: %s has new value: %s" %(topic, val))
def demo_4(val, topic):
print("Demo 4:: Topic: %s has new value: %s" %(topic, val))
t2.subscribe(demo)
t2.subscribe(demo_2)
t2.subscribe(demo_3)
t2.subscribe(demo_4)
t2.publish("ALL")
t2.publish("again")
Surely, we can add more subscribers, and publish more often ...
Demo 3: OO subscribers¶
You can also subscribe methods, when you prefer an OO style. This works the same as with functions: just register the method.
- We will define a class with a demo-callback
- And register it to a new Topic:
t3
Notes:
- Python will automatically remember the object (
self). - Here, we use a trick (
self._no) to show (which of the) many instances are used.
class Demo:
_stat_count=0
def __init__(self):
self._no = Demo._stat_count # make them unique
Demo._stat_count+=1
def demo(self, val, topic):
print("%s got '%s' from topic %s" %(
self, val, topic))
def __str__(self):
return "<<%s: ._no=%d at 0X%x>>" % (
self.__class__.__name__, self._no, id(self))
Note: Again, you may ignore the dunder methods, Demo.__init__() and ``Demo.__str__()
o = Demo()
t3 = Topic("OO Demo")
t3.subscribe(o.demo)
t3.publish("class")
Demo4: Mix and Match¶
You can mix-&-match all the several uses:
- Classic functions and objects
- Register many callbacks
- In this demo, we use a loop to quckly define many callback.
- Subscribe after a publication
4.1 many subscribers¶
t4 = Topic("four-10-plys")
t4.subscribe(demo)
for x in range(10): # Quicly create/subscribe 10 Demo-instances
t4.subscribe(Demo().demo)
t4.subscribe(demo_4)
t4.subscribe(demo_3)
t4.subscribe(demo_2)
t4.publish('Yes')
4.2 : Subscribe after 1st publish¶
t42 = Topic()
t42.subscribe(demo)
t42.publish("fist")
# Now add subscribe another callback
t42. subscribe(demo_2)
t42.publish("more and more")
Back to the main presentation
import datetime, pytz
print("These slides are generated at:", datetime.datetime.now(pytz.timezone('Europe/Amsterdam')))
#EoF