Pythonのイベントシステム
Pythonのイベントシステムは何ですか？私はすでに pydispatcher を知っていますが、他に何が見つかるか、または一般的に使用されているのだろうかと思っていましたか？
大きなフレームワークの一部であるイベントマネージャーには興味がありません。簡単に拡張できる小さなベアボーンソリューションを使用したいです。
ここでの回答に記載されているさまざまなイベントシステムのまとめ：
イベントシステムの最も基本的なスタイルは、「ハンドラメソッドのバッグ」です。これは、 Observerパターン の単純な実装です。基本的に、ハンドラーメソッド（呼び出し可能オブジェクト）は配列に格納され、イベントが発生するとそれぞれ呼び出されます。
- zope.event は、これがどのように機能するかを示しています（ Lennartの答え を参照）。注：この例では、ハンドラー引数もサポートしていません。
- LongPokeの「呼び出し可能リスト」 実装は、
listをサブクラス化することにより、そのようなイベントシステムを非常に最小限に実装できることを示しています。 - spassigのEventHook （Michael Foordのイベントパターン）は簡単な実装です。
- JosipのValued Lessonsイベントクラス は基本的に同じですが、
setの代わりにlistを使用してバッグを格納し、両方とも妥当な追加である__call__を実装します。 - PyNotify は概念が似ており、変数と条件の追加の概念も提供します（「変数変更イベント」）。
- axel は、基本的にスレッド化、エラー処理などに関連する機能を備えたバッグオブハンドラーです。
これらのイベントシステムの欠点は、実際のイベントオブジェクト（またはハンドラーリスト）にしかハンドラーを登録できないことです。そのため、登録時にイベントがすでに存在している必要があります。
これが、イベントシステムの2番目のスタイルである publish-subscribe pattern が存在する理由です。ここでは、ハンドラーはイベントオブジェクト（またはハンドラーリスト）ではなく、中央のディスパッチャーに登録されます。また、通知者はディスパッチャとのみ通信します。何をリッスンするか、何を公開するかは、名前（文字列）以外の「シグナル」によって決定されます。
- blinker には、自動切断や送信者に基づくフィルタリングなど、気の利いた機能があります。
- PyPubSub 一見すると、とても簡単です。
- PyDispatcher は、多対多の発行などに関して柔軟性を強調しているようです。
- louie は、TwistedおよびPyQt固有のサポートを含むプラグインインフラストラクチャを提供するPyDispatcherを改良したものです。 2016年1月以降、メンテナンスを失ったようです。
- Django.dispatch は、書き換えられたPyDispatcherであり、「インターフェイスはより制限されていますが、パフォーマンスは向上しています」。
- Qtのシグナルとスロットは PyQt または PySide から利用できます。それらは、同じスレッドで使用される場合はコールバックとして、または2つの異なるスレッド間のイベント（イベントループを使用）として機能します。信号とスロットには、
QObjectから派生したクラスのオブジェクトでのみ機能するという制限があります。
注： threading.Event は、上記の意味では「イベントシステム」ではありません。これは、あるスレッドが別のスレッドがEventオブジェクトを「シグナル」するまで待機するスレッド同期システムです。
注：上記にはまだ含まれていません pypydispatcher 、 python-dispatch 、および pluggy の「フックシステム」も興味深いかもしれません。
私はこのようにしていました：
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)
しかし、私が見た他のすべてのものと同様に、このための自動生成されたpydocはなく、署名もありません。
イベントパターン でMichael Foordから提案されたEventHookを使用します。
EventHooksをクラスに追加するだけです：
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()
オブジェクトからすべてのリスナーをMichaelsクラスに削除する機能を追加すると、次のようになります。
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 -= theHandler
zope.event を使用します。それはあなたが想像できる最も裸の骨です。 :-)実際、完全なソースコードは次のとおりです。
subscribers = []
def notify(event):
for subscriber in subscribers:
subscriber(event)
たとえば、プロセス間でメッセージを送信できないことに注意してください。それはメッセージングシステムではなく、単なるイベントシステムであり、それ以上でもそれ以下でもありません。
Valued Lessons でこの小さなスクリプトを見つけました。私が求めているのは、適切なシンプルさ/電力比を持っているようです。 Peter Thatcherは、次のコードの著者です（ライセンスは記載されていません）。
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()
pymitter （ pypi ）をご覧ください。その小さな単一ファイル（〜250 loc）アプローチ「名前空間、ワイルドカード、TTLの提供」。
基本的な例を次に示します。
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"
EventManagerクラスを作成しました（最後のコード）。構文は次のとおりです。
#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()
次に例を示します。
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')
出力：
最初の敬礼
挨拶オスカー
こんにちはオスカーあいさつを削除する
こんにちはオスカー
EventMangerコード：
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)
これが正常に機能する最小限の設計です。あなたがしなければならないことは、クラスでObserverを単純に継承し、その後observe(event_name, callback_fn)を使用して特定のイベントをリッスンすることです。その特定のイベントがコード内のどこかで発生するたびに（つまり、Event('USB connected')）、対応するコールバックが発生します。
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)
例：
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')
Longpokeのミニマルなアプローチのバリエーションを作成し、呼び出し先と呼び出し元の両方の署名も保証します。
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.__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()
PyQtでコードを作成する場合、QTソケット/シグナルパラダイムを使用します。Djangoでも同じです
非同期I/Oを実行している場合、ネイティブ選択モジュールを使用します
SAX pythonパーサーを使用している場合、SAXが提供するイベントAPIを使用しています。だから、私は基本的なAPIの犠牲者のようです:-)
たぶん、イベントフレームワーク/モジュールに何を期待するかを自問する必要があります。私の個人的な好みは、QTのSocket/Signalパラダイムを使用することです。詳細については、こちらをご覧ください こちら
考慮すべき別の モジュール があります。より要求の厳しいアプリケーションには実行可能な選択肢のようです。
Py-notifyは、Observerプログラミングパターンを実装するためのツールを提供するPythonパッケージです。これらのツールには、信号、条件、変数が含まれます。
シグナルは、シグナルが発行されたときに呼び出されるハンドラーのリストです。条件は基本的に、条件の状態が変化したときに放出されるシグナルと結合したブール変数です。これらは、標準の論理演算子（not、andなど）を使用して複合条件に結合できます。条件とは異なり、変数はブール値だけでなくPythonオブジェクトを保持できますが、組み合わせることはできません。
イベントのマージや再試行など、より複雑なことをしたい場合は、Observableパターンとそれを実装する成熟したライブラリを使用できます。 https://github.com/ReactiveX/RxPY オブザーバブルは、JavascriptおよびJavaで非常に一般的であり、一部の非同期タスクで使用すると非常に便利です。
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())
出力：
Received Alpha
Received Beta
Received Gamma
Received Delta
Received Epsilon
Done!
buslane モジュールを試すことができます。
このライブラリにより、メッセージベースのシステムの実装が容易になります。コマンド（単一ハンドラー）およびイベント（0または複数のハンドラー）アプローチをサポートします。 BuslaneはPythonタイプの注釈を使用して、ハンドラーを適切に登録します。
簡単な例：
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='[email protected]',
password='secret',
)
command_bus = CommandBus()
command_bus.register(handler=RegisterUserCommandHandler())
command_bus.execute(command=RegisterUserCommand(
email='[email protected]',
password='secret',
))
バスレーンをインストールするには、単にpipを使用します。
$ pip install buslane
プロセスまたはネットワークの境界を越えて機能するイベントバスが必要な場合は、 PyMQ を試してください。現在、pub/sub、メッセージキュー、および同期RPCをサポートしています。デフォルトバージョンはRedisバックエンド上で動作するため、実行中のRedisサーバーが必要です。テスト用のメモリ内バックエンドもあります。独自のバックエンドを作成することもできます。
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')
システムを初期化するには：
from pymq.provider.redis import RedisConfig
# starts a new thread with a Redis event loop
pymq.init(RedisConfig())
# main application control loop
pymq.shutdown()
免責事項：私はこのライブラリの著者です
少し前に、私はあなたに役立つかもしれないライブラリを書きました。これにより、ローカルリスナとグローバルリスナ、それらを登録する複数の異なる方法、実行優先度などを設定できます。
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 second
ご覧ください pyeventdispatcher