Welches Ereignissystem für Python verwenden Sie? Ich kenne Pydispatcher bereits , habe mich aber gefragt, was sonst noch zu finden ist oder häufig verwendet wird.
Ich interessiere mich nicht für Event-Manager, die Teil großer Frameworks sind, sondern verwende lieber eine kleine Bare-Bones-Lösung, die ich problemlos erweitern kann.
Antworten:
Ab Juni 2020 sind dies die ereignisbezogenen Pakete, die auf PyPI verfügbar sind und nach dem letzten Veröffentlichungsdatum sortiert sind.
1.0.1 : Juni 20200.13.1 : Juni 2020 (Beta)2.0 : September 20190.1.2 : Februar 20194.0.3 : Januar 20194.4 : 20180.2.3a0 : 20180.0.5 : 20182.1.2 : 20170.0.7 : 20161.4 : 20152.0.5 : 20150.2.3 : 20141.0 : 20120.3.1 : 2008Das sind viele Bibliotheken zur Auswahl, die eine sehr unterschiedliche Terminologie verwenden (Ereignisse, Signale, Handler, Methodenversand, Hooks, ...).
Ich versuche, einen Überblick über die oben genannten Pakete sowie die in den Antworten hier genannten Techniken zu behalten.
Zunächst einige Begriffe ...
Der grundlegendste Stil des Ereignissystems ist die 'Bag of Handler-Methode', die eine einfache Implementierung des Observer-Musters darstellt .
Grundsätzlich werden die Handler-Methoden (Callables) in einem Array gespeichert und jeweils aufgerufen, wenn das Ereignis 'ausgelöst' wird.
Der Nachteil von Observer-Ereignissystemen besteht darin, dass Sie die Handler nur für das tatsächliche Ereignisobjekt (oder die Handlerliste) registrieren können. Zum Zeitpunkt der Registrierung muss die Veranstaltung also bereits vorhanden sein.
Aus diesem Grund gibt es den zweiten Stil von Ereignissystemen: das Publish-Subscribe-Muster . Hier registrieren sich die Handler nicht für ein Ereignisobjekt (oder eine Handlerliste), sondern für einen zentralen Dispatcher. Auch die Benachrichtiger sprechen nur mit dem Dispatcher. Was zu hören oder zu veröffentlichen ist, wird durch 'Signal' bestimmt, das nichts weiter als ein Name (Zeichenfolge) ist.
Könnte auch von Interesse sein: das Mediator-Muster .
Ein 'Hook'-System wird üblicherweise im Zusammenhang mit Anwendungs-Plugins verwendet. Die Anwendung enthält feste Integrationspunkte (Hooks), und jedes Plugin kann eine Verbindung zu diesem Hook herstellen und bestimmte Aktionen ausführen.
Hinweis: threading.Event ist kein 'Ereignissystem' im obigen Sinne. Es ist ein Thread-Synchronisationssystem, bei dem ein Thread wartet, bis ein anderer Thread das Ereignisobjekt "signalisiert".
Netzwerk-Messaging-Bibliotheken verwenden häufig auch den Begriff "Ereignisse". manchmal sind diese im Konzept ähnlich; manchmal nicht. Sie können natürlich Thread-, Prozess- und Computergrenzen überschreiten. Siehe zB pyzmq , pymq , Twisted , Tornado , gevent , eventlet .
Wenn Sie in Python einen Verweis auf eine Methode oder ein Objekt halten, wird sichergestellt, dass dieser nicht vom Garbage Collector gelöscht wird. Dies kann wünschenswert sein, kann aber auch zu Speicherverlusten führen: Die verknüpften Handler werden niemals bereinigt.
Einige Ereignissysteme verwenden schwache Referenzen anstelle regulärer Referenzen, um dies zu lösen.
Ereignissysteme im Beobachterstil:
list.setanstelle von a list, um die Tasche zu speichern, und implementiert Geräte, __call__die beide sinnvolle Ergänzungen sind.pydispatch.Dispatcher.Publish-Subscribe-Bibliotheken:
Andere:
pytestPlugins verwendet wird .QObject.Ich habe es so gemacht:
class Event(list):
"""Event subscription.
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
Example Usage:
>>> def f(x):
... print 'f(%s)' % x
>>> def g(x):
... print 'g(%s)' % x
>>> e = Event()
>>> e()
>>> e.append(f)
>>> e(123)
f(123)
>>> e.remove(f)
>>> e()
>>> e += (f, g)
>>> e(10)
f(10)
g(10)
>>> del e[0]
>>> e(2)
g(2)
"""
def __call__(self, *args, **kwargs):
for f in self:
f(*args, **kwargs)
def __repr__(self):
return "Event(%s)" % list.__repr__(self)Wie bei allem anderen, was ich gesehen habe, gibt es dafür kein automatisch generiertes Pydoc und keine Signaturen, was wirklich scheiße ist.
_bag_of_handlersdie eine Liste ist. Die Add-Methode der Klasse wäre einfach self._bag_of_handlers.append(some_callable). Die Feuermethode der Klasse würde eine Schleife durch die Tasche der Handler durchlaufen und die bereitgestellten Argumente und Warnungen an die Handler weitergeben und jeweils nacheinander ausführen.
Wir verwenden einen EventHook, wie von Michael Foord in seinem Event-Muster vorgeschlagen :
Fügen Sie einfach EventHooks zu Ihren Klassen hinzu mit:
class MyBroadcaster()
def __init__():
self.onChange = EventHook()
theBroadcaster = MyBroadcaster()
# add a listener to the event
theBroadcaster.onChange += myFunction
# remove listener from the event
theBroadcaster.onChange -= myFunction
# fire event
theBroadcaster.onChange.fire()Wir haben die Funktionalität hinzugefügt, um alle Listener von einem Objekt zur Michaels-Klasse zu entfernen.
class EventHook(object):
def __init__(self):
self.__handlers = []
def __iadd__(self, handler):
self.__handlers.append(handler)
return self
def __isub__(self, handler):
self.__handlers.remove(handler)
return self
def fire(self, *args, **keywargs):
for handler in self.__handlers:
handler(*args, **keywargs)
def clearObjectHandlers(self, inObject):
for theHandler in self.__handlers:
if theHandler.im_self == inObject:
self -= theHandlerself.__handlers = [h for h in self._handlers if getattr(h, 'im_self', False) != obj]
Ich benutze zope.event . Es sind die nacktesten Knochen, die Sie sich vorstellen können. :-) Tatsächlich ist hier der vollständige Quellcode:
subscribers = []
def notify(event):
for subscriber in subscribers:
subscriber(event)Beachten Sie, dass Sie beispielsweise keine Nachrichten zwischen Prozessen senden können. Es ist kein Nachrichtensystem, nur ein Ereignissystem, nicht mehr und nicht weniger.
Ich habe dieses kleine Skript in Valued Lessons gefunden . Es scheint genau das richtige Verhältnis von Einfachheit und Leistung zu haben, nach dem ich suche. Peter Thatcher ist der Autor des folgenden Codes (es wird keine Lizenzierung erwähnt).
class Event:
def __init__(self):
self.handlers = set()
def handle(self, handler):
self.handlers.add(handler)
return self
def unhandle(self, handler):
try:
self.handlers.remove(handler)
except:
raise ValueError("Handler is not handling this event, so cannot unhandle it.")
return self
def fire(self, *args, **kargs):
for handler in self.handlers:
handler(*args, **kargs)
def getHandlerCount(self):
return len(self.handlers)
__iadd__ = handle
__isub__ = unhandle
__call__ = fire
__len__ = getHandlerCount
class MockFileWatcher:
def __init__(self):
self.fileChanged = Event()
def watchFiles(self):
source_path = "foo"
self.fileChanged(source_path)
def log_file_change(source_path):
print "%r changed." % (source_path,)
def log_file_change2(source_path):
print "%r changed!" % (source_path,)
watcher = MockFileWatcher()
watcher.fileChanged += log_file_change2
watcher.fileChanged += log_file_change
watcher.fileChanged -= log_file_change2
watcher.watchFiles()Hier ist ein minimales Design, das gut funktionieren sollte. Was Sie tun müssen, ist einfach Observerin einer Klasse zu erben und anschließend zu verwenden observe(event_name, callback_fn), um auf ein bestimmtes Ereignis zu warten. Immer wenn dieses bestimmte Ereignis irgendwo im Code ausgelöst wird (dh Event('USB connected')), wird der entsprechende Rückruf ausgelöst .
class Observer():
_observers = []
def __init__(self):
self._observers.append(self)
self._observed_events = []
def observe(self, event_name, callback_fn):
self._observed_events.append({'event_name' : event_name, 'callback_fn' : callback_fn})
class Event():
def __init__(self, event_name, *callback_args):
for observer in Observer._observers:
for observable in observer._observed_events:
if observable['event_name'] == event_name:
observable['callback_fn'](*callback_args)Beispiel:
class Room(Observer):
def __init__(self):
print("Room is ready.")
Observer.__init__(self) # DON'T FORGET THIS
def someone_arrived(self, who):
print(who + " has arrived!")
# Observe for specific event
room = Room()
room.observe('someone arrived', room.someone_arrived)
# Fire some events
Event('someone left', 'John')
Event('someone arrived', 'Lenard') # will output "Lenard has arrived!"
Event('someone Farted', 'Lenard')Ich habe eine EventManagerKlasse erstellt (Code am Ende). Die Syntax lautet wie folgt:
#Create an event with no listeners assigned to it
EventManager.addEvent( eventName = [] )
#Create an event with listeners assigned to it
EventManager.addEvent( eventName = [fun1, fun2,...] )
#Create any number event with listeners assigned to them
EventManager.addEvent( eventName1 = [e1fun1, e1fun2,...], eventName2 = [e2fun1, e2fun2,...], ... )
#Add or remove listener to an existing event
EventManager.eventName += extra_fun
EventManager.eventName -= removed_fun
#Delete an event
del EventManager.eventName
#Fire the event
EventManager.eventName()Hier ist ein Beispiel:
def hello(name):
print "Hello {}".format(name)
def greetings(name):
print "Greetings {}".format(name)
EventManager.addEvent( salute = [greetings] )
EventManager.salute += hello
print "\nInitial salute"
EventManager.salute('Oscar')
print "\nNow remove greetings"
EventManager.salute -= greetings
EventManager.salute('Oscar')Ausgabe:
Erster Gruß
Grüße Oscar
Hallo OscarEntfernen Sie jetzt Grüße
Hallo Oscar
EventManger-Code:
class EventManager:
class Event:
def __init__(self,functions):
if type(functions) is not list:
raise ValueError("functions parameter has to be a list")
self.functions = functions
def __iadd__(self,func):
self.functions.append(func)
return self
def __isub__(self,func):
self.functions.remove(func)
return self
def __call__(self,*args,**kvargs):
for func in self.functions : func(*args,**kvargs)
@classmethod
def addEvent(cls,**kvargs):
"""
addEvent( event1 = [f1,f2,...], event2 = [g1,g2,...], ... )
creates events using **kvargs to create any number of events. Each event recieves a list of functions,
where every function in the list recieves the same parameters.
Example:
def hello(): print "Hello ",
def world(): print "World"
EventManager.addEvent( salute = [hello] )
EventManager.salute += world
EventManager.salute()
Output:
Hello World
"""
for key in kvargs.keys():
if type(kvargs[key]) is not list:
raise ValueError("value has to be a list")
else:
kvargs[key] = cls.Event(kvargs[key])
cls.__dict__.update(kvargs)Sie können einen Blick auf Pymitter ( Pypi ) werfen . Es handelt sich um einen kleinen Single-File-Ansatz (~ 250 loc), der "Namespaces, Platzhalter und TTL bereitstellt".
Hier ist ein einfaches Beispiel:
from pymitter import EventEmitter
ee = EventEmitter()
# decorator usage
@ee.on("myevent")
def handler1(arg):
print "handler1 called with", arg
# callback usage
def handler2(arg):
print "handler2 called with", arg
ee.on("myotherevent", handler2)
# emit
ee.emit("myevent", "foo")
# -> "handler1 called with foo"
ee.emit("myotherevent", "bar")
# -> "handler2 called with bar"Ich habe eine Variation von Longpokes minimalistischem Ansatz gemacht, die auch die Signaturen sowohl für Anrufer als auch für Anrufer sicherstellt:
class EventHook(object):
'''
A simple implementation of the Observer-Pattern.
The user can specify an event signature upon inizializazion,
defined by kwargs in the form of argumentname=class (e.g. id=int).
The arguments' types are not checked in this implementation though.
Callables with a fitting signature can be added with += or removed with -=.
All listeners can be notified by calling the EventHook class with fitting
arguments.
>>> event = EventHook(id=int, data=dict)
>>> event += lambda id, data: print("%d %s" % (id, data))
>>> event(id=5, data={"foo": "bar"})
5 {'foo': 'bar'}
>>> event = EventHook(id=int)
>>> event += lambda wrong_name: None
Traceback (most recent call last):
...
ValueError: Listener must have these arguments: (id=int)
>>> event = EventHook(id=int)
>>> event += lambda id: None
>>> event(wrong_name=0)
Traceback (most recent call last):
...
ValueError: This EventHook must be called with these arguments: (id=int)
'''
def __init__(self, **signature):
self._signature = signature
self._argnames = set(signature.keys())
self._handlers = []
def _kwargs_str(self):
return ", ".join(k+"="+v.__name__ for k, v in self._signature.items())
def __iadd__(self, handler):
params = inspect.signature(handler).parameters
valid = True
argnames = set(n for n in params.keys())
if argnames != self._argnames:
valid = False
for p in params.values():
if p.kind == p.VAR_KEYWORD:
valid = True
break
if p.kind not in (p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY):
valid = False
break
if not valid:
raise ValueError("Listener must have these arguments: (%s)"
% self._kwargs_str())
self._handlers.append(handler)
return self
def __isub__(self, handler):
self._handlers.remove(handler)
return self
def __call__(self, *args, **kwargs):
if args or set(kwargs.keys()) != self._argnames:
raise ValueError("This EventHook must be called with these " +
"keyword arguments: (%s)" % self._kwargs_str())
for handler in self._handlers[:]:
handler(**kwargs)
def __repr__(self):
return "EventHook(%s)" % self._kwargs_str()Wenn ich in pyQt codiere, verwende ich das QT-Sockets / Signal-Paradigma, dasselbe gilt für Django
Wenn ich asynchrone E / A-Vorgänge durchführe, verwenden Sie das native Auswahlmodul
Wenn ich einen SAX-Python-Parser verwende, verwende ich die von SAX bereitgestellte Ereignis-API. Es sieht also so aus, als wäre ich Opfer der zugrunde liegenden API :-)
Vielleicht sollten Sie sich fragen, was Sie von Event Framework / Modul erwarten. Meine persönliche Präferenz ist die Verwendung des Socket / Signal-Paradigmas von QT. Weitere Infos dazu finden Sie hier
Hier ist ein weiteres Modul zur Prüfung. Es scheint eine gute Wahl für anspruchsvollere Anwendungen zu sein.
Py-notify ist ein Python-Paket, das Tools zum Implementieren des Observer-Programmiermusters bietet. Diese Tools umfassen Signale, Bedingungen und Variablen.
Signale sind Listen von Handlern, die aufgerufen werden, wenn ein Signal ausgegeben wird. Bedingungen sind im Grunde boolesche Variablen, die mit einem Signal gekoppelt sind, das ausgegeben wird, wenn sich der Zustandszustand ändert. Sie können unter Verwendung von logischen Standardoperatoren (nicht und usw.) zu zusammengesetzten Bedingungen kombiniert werden. Im Gegensatz zu Bedingungen können Variablen jedes Python-Objekt enthalten, nicht nur Boolesche Werte, sondern können auch nicht kombiniert werden.
Wenn Sie kompliziertere Dinge wie das Zusammenführen von Ereignissen oder das Wiederholen von Ereignissen ausführen möchten, können Sie das Observable-Muster und eine ausgereifte Bibliothek verwenden, die dies implementiert. https://github.com/ReactiveX/RxPY . Observables sind in Javascript und Java sehr verbreitet und für einige asynchrone Aufgaben sehr praktisch.
from rx import Observable, Observer
def push_five_strings(observer):
observer.on_next("Alpha")
observer.on_next("Beta")
observer.on_next("Gamma")
observer.on_next("Delta")
observer.on_next("Epsilon")
observer.on_completed()
class PrintObserver(Observer):
def on_next(self, value):
print("Received {0}".format(value))
def on_completed(self):
print("Done!")
def on_error(self, error):
print("Error Occurred: {0}".format(error))
source = Observable.create(push_five_strings)
source.subscribe(PrintObserver())AUSGABE :
Received Alpha
Received Beta
Received Gamma
Received Delta
Received Epsilon
Done!Wenn Sie einen Eventbus benötigen, der über Prozess- oder Netzwerkgrenzen hinweg funktioniert, können Sie PyMQ ausprobieren . Derzeit werden Pub / Sub, Nachrichtenwarteschlangen und synchroner RPC unterstützt. Die Standardversion funktioniert auf einem Redis-Backend, sodass Sie einen laufenden Redis-Server benötigen. Es gibt auch ein In-Memory-Backend zum Testen. Sie können auch Ihr eigenes Backend schreiben.
import pymq
# common code
class MyEvent:
pass
# subscribe code
@pymq.subscriber
def on_event(event: MyEvent):
print('event received')
# publisher code
pymq.publish(MyEvent())
# you can also customize channels
pymq.subscribe(on_event, channel='my_channel')
pymq.publish(MyEvent(), channel='my_channel')So initialisieren Sie das System:
from pymq.provider.redis import RedisConfig
# starts a new thread with a Redis event loop
pymq.init(RedisConfig())
# main application control loop
pymq.shutdown()Haftungsausschluss: Ich bin der Autor dieser Bibliothek
Sie können das buslaneModul ausprobieren .
Diese Bibliothek erleichtert die Implementierung eines nachrichtenbasierten Systems. Es unterstützt den Ansatz von Befehlen (einzelner Handler) und Ereignissen (0 oder mehrere Handler). Buslane verwendet Anmerkungen vom Typ Python, um den Handler ordnungsgemäß zu registrieren.
Einfaches Beispiel:
from dataclasses import dataclass
from buslane.commands import Command, CommandHandler, CommandBus
@dataclass(frozen=True)
class RegisterUserCommand(Command):
email: str
password: str
class RegisterUserCommandHandler(CommandHandler[RegisterUserCommand]):
def handle(self, command: RegisterUserCommand) -> None:
assert command == RegisterUserCommand(
email='john@lennon.com',
password='secret',
)
command_bus = CommandBus()
command_bus.register(handler=RegisterUserCommandHandler())
command_bus.execute(command=RegisterUserCommand(
email='john@lennon.com',
password='secret',
))Verwenden Sie zum Installieren der Busbahn einfach pip:
$ pip install buslaneVor einiger Zeit habe ich eine Bibliothek geschrieben, die für Sie nützlich sein könnte. Es ermöglicht Ihnen lokale und globale Listener, verschiedene Arten der Registrierung, Ausführungspriorität usw.
from pyeventdispatcher import register
register("foo.bar", lambda event: print("second"))
register("foo.bar", lambda event: print("first "), -100)
dispatch(Event("foo.bar", {"id": 1}))
# first secondSchauen Sie sich pyeventdispatcher an