python-dispatch 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

pydispatch/__init__.py

@@ -15,5 +15,59 @@ if sys.version_info < (3, 6): # pragma: no cover
                   'After version 0.1.x, `python-dispatch` will only support Python 3.6 or greater.',
                   UserWarning)
 
-from pydispatch.dispatch import Dispatcher, Event
+from pydispatch.dispatch import *
+from pydispatch.dispatch import _GLOBAL_DISPATCHER
 from pydispatch.properties import *
+from pydispatch import decorators
+from pydispatch.decorators import *
+
+
+def register_event(*names):
+    """Register event (or events) on the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.register_event`
+    .. versionadded:: 0.2.2
+    """
+    _GLOBAL_DISPATCHER.register_event(*names)
+    decorators._post_register_hook(*names)
+
+def bind(**kwargs):
+    """Subscribe callbacks to events on the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.bind`
+    .. versionadded:: 0.2.2
+    """
+    _GLOBAL_DISPATCHER.bind(**kwargs)
+
+def unbind(*args):
+    """Unbind callbacks from events on the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.unbind`
+    .. versionadded:: 0.2.2
+    """
+    _GLOBAL_DISPATCHER.unbind(*args)
+
+def bind_async(loop, **kwargs):
+    """Bind async callbacks to events on the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.bind_async`
+    .. versionadded:: 0.2.2
+    """
+    _GLOBAL_DISPATCHER.bind_async(loop, **kwargs)
+
+def emit(name, *args, **kwargs):
+    """Dispatch the event with the given *name* on the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.emit`
+    .. versionadded:: 0.2.2
+    """
+    return _GLOBAL_DISPATCHER.emit(name, *args, **kwargs)
+
+def get_dispatcher_event(name):
+    """Retrieve the :class:`~.dispatch.Event` object by the given name
+    from the :ref:`global-dispatcher`
+
+    .. seealso:: :meth:`.Dispatcher.get_dispatcher_event`
+    .. versionadded:: 0.2.2
+    """
+    return _GLOBAL_DISPATCHER.get_dispatcher_event(name)

pydispatch/aioutils.py

@@ -1,12 +1,25 @@
+import sys
 import asyncio
 import threading
-from _weakref import ref
-from _weakrefset import _IterationGuard
+from weakref import ref
+from _weakref import _remove_dead_weakref # type: ignore[import]
+if sys.version_info < (3, 14):
+    from _weakrefset import _IterationGuard
+else:
+    # _IterationGuard was removed in Python 3.14. We define a no-op version here
+    class _IterationGuard:
+        def __init__(self, obj):
+            pass
+        def __enter__(self):
+            pass
+        def __exit__(self, *args):
+            pass
+
 
 from pydispatch.utils import (
     WeakMethodContainer,
+    isfunction,
     get_method_vars,
-    _remove_dead_weakref,
 )
 
 
@@ -191,6 +204,12 @@ class AioWeakMethodContainer(WeakMethodContainer):
                     _remove_dead_weakref(self.data, wr.key)
                     self._on_weakref_fin(wr.key)
         self._remove = remove
+
+        # `_pending_removals` and `_iterating` were removed in Python 3.14.
+        # To maintain compatibility with earlier versions, we reintroduce them here.
+        self._pending_removals = []
+        self._iterating = set()
+
         self.event_loop_map = {}
     def add_method(self, loop, callback):
         """Add a coroutine function
@@ -200,9 +219,13 @@ class AioWeakMethodContainer(WeakMethodContainer):
                 on which to schedule callbacks
             callback: The :term:`coroutine function` to add
         """
-        f, obj = get_method_vars(callback)
-        wrkey = (f, id(obj))
-        self[wrkey] = obj
+        if isfunction(callback):
+            wrkey = ('function', id(callback))
+            self[wrkey] = callback
+        else:
+            f, obj = get_method_vars(callback)
+            wrkey = (f, id(obj))
+            self[wrkey] = obj
         self.event_loop_map[wrkey] = loop
     def iter_instances(self):
         """Iterate over the stored objects
@@ -221,8 +244,11 @@ class AioWeakMethodContainer(WeakMethodContainer):
         """
         for wrkey, obj in self.iter_instances():
             f, obj_id = wrkey
+            if f == 'function':
+                m = self[wrkey]
+            else:
+                m = getattr(obj, f.__name__)
             loop = self.event_loop_map[wrkey]
-            m = getattr(obj, f.__name__)
             yield loop, m
     def _on_weakref_fin(self, key):
         if key in self.event_loop_map:

pydispatch/decorators.py

@@ -0,0 +1,135 @@
+from typing import Union, Iterable, Iterator, Callable
+import asyncio
+
+import pydispatch
+from .dispatch import DoesNotExistError, _GLOBAL_DISPATCHER
+from .utils import iscoroutinefunction, WeakMethodContainer
+
+__all__ = ('receiver',)
+
+class CallbackCache:
+    def __init__(self):
+        self.cache = {}
+
+    def add(self, name: str, func: Callable):
+        wr_contain = self.cache.get(name)
+        if wr_contain is None:
+            wr_contain = WeakMethodContainer()
+            self.cache[name] = wr_contain
+        wr_contain.add_method(func)
+
+    def get(self, name: str) -> Iterator[Callable]:
+        wr_contain = self.cache.get(name)
+        if wr_contain is not None:
+            del self.cache[name]
+            yield from wr_contain.iter_methods()
+        yield from []
+
+    def __contains__(self, name: str) -> bool:
+        return name in self.cache
+
+
+_CACHED_CALLBACKS = CallbackCache()
+
+
+def receiver(
+    event_name: Union[str, Iterable[str]],
+    cache: bool = False,
+    auto_register: bool = False
+):
+    """Decorator to bind a function or method to the :ref:`global-dispatcher`
+
+    Examples:
+
+        >>> import pydispatch
+
+        >>> pydispatch.register_event('foo')
+
+        >>> @pydispatch.receiver('foo')
+        ... def on_foo(value, **kwargs):
+        ...     print(f'on_foo: "{value}"')
+
+        >>> pydispatch.emit('foo', 'spam')
+        on_foo: "spam"
+
+        Using the *cache* argument
+
+        >>> @pydispatch.receiver('bar', cache=True)
+        ... def on_bar(value, **kwargs):
+        ...     print(f'on_bar: "{value}"')
+
+        >>> pydispatch.register_event('bar')
+        >>> pydispatch.emit('bar', 'eggs')
+        on_bar: "eggs"
+
+        Using *auto_register*
+
+        >>> @pydispatch.receiver('baz', auto_register=True)
+        ... def on_baz(value, **kwargs):
+        ...     print(f'on_baz: "{value}"')
+
+        >>> pydispatch.emit('baz', 'ham')
+        on_baz: "ham"
+
+        Receiving multiple events
+
+        >>> @pydispatch.receiver(['event_one', 'event_two'], auto_register=True)
+        ... def on_event_one_or_two(value, **kwargs):
+        ...     print(value)
+
+        >>> pydispatch.emit('event_one', 1)
+        1
+        >>> pydispatch.emit('event_two', 2)
+        2
+
+
+    Arguments:
+        event_name: Event name (or names) to bind the callback to.
+            Can be a string or an :term:`iterable` of strings
+        cache: If the event does not exist yet and this is ``True``,
+            the callback will be held in a cache until it has been registered.
+            If ``False``, a :class:`~.DoesNotExistError` will be raised.
+            (Default is ``False``)
+        auto_register: If the event does not exist and this is ``True``,
+            it will be registered on the :ref:`global-dispatcher`.
+            (Default is ``False``)
+
+    .. versionadded:: 0.2.2
+    """
+    def _decorator(func: Callable):
+        is_async = iscoroutinefunction(func)
+
+        if isinstance(event_name, str):
+            event_names = [event_name]
+        else:
+            event_names = event_name
+        bind_kwargs = {ev:func for ev in event_names}
+        if auto_register or cache:
+            for name in event_names:
+                if not _GLOBAL_DISPATCHER._has_event(name):
+                    if auto_register:
+                        pydispatch.register_event(name)
+                    elif cache:
+                        _CACHED_CALLBACKS.add(name, func)
+                        del bind_kwargs[name]
+        if len(bind_kwargs):
+            if is_async:
+                bind_kwargs['__aio_loop__'] = asyncio.get_event_loop()
+            pydispatch.bind(**bind_kwargs)
+        return func
+    return _decorator
+
+
+def _post_register_hook(*names):
+    """Called in :func:`pydispatch.register_event` to search for cached callbacks
+    """
+    for name in names:
+        if name not in _CACHED_CALLBACKS:
+            continue
+        bind_kwargs = {name:cb for cb in _CACHED_CALLBACKS.get(name)}
+        is_async = any((iscoroutinefunction(cb) for cb in bind_kwargs.values()))
+        if is_async:
+            loop = asyncio.get_event_loop()
+            pydispatch.bind_async(loop, **bind_kwargs)
+        else:
+            pydispatch.bind(**bind_kwargs)

pydispatch/dispatch.py

@@ -9,6 +9,51 @@ from pydispatch.properties import Property
 import asyncio
 from pydispatch.aioutils import AioWeakMethodContainer, AioEventWaiters
 
+__all__ = (
+    'DoesNotExistError', 'ExistsError', 'EventExistsError',
+    'PropertyExistsError', 'Event', 'Dispatcher',
+)
+
+
+class DoesNotExistError(KeyError):
+    """Raised when binding to an :class:`Event` or :class:`~.properties.Property`
+    that does not exist
+
+    .. versionadded:: 0.2.2
+    """
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return f'Event "{self.name}" not registered'
+
+
+class ExistsError(RuntimeError):
+    """Raised when registering an event name that already exists
+    as either a normal :class:`Event` or :class:`~.properies.Property`
+
+    .. versionadded:: 0.2.2
+    """
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return f'"{self.name}" already exists'
+
+class EventExistsError(ExistsError):
+    """Raised when registering an event name that already exists
+    as an :class:`Event`
+
+    .. versionadded:: 0.2.2
+    """
+
+
+class PropertyExistsError(ExistsError):
+    """Raised when registering an event name that already exists
+    as a :class:`~.properties.Property`
+
+    .. versionadded:: 0.2.2
+    """
 
 
 class Event(object):
@@ -108,10 +153,20 @@ class Dispatcher(object):
 
         Args:
             *names (str): Name or names of the events to register
+
+        Raises:
+            EventExistsError: If an event with the given name already exists
+            PropertyExistsError: If a property with the given name already exists
+
+        .. versionchanged:: 0.2.2
+            :class:`ExistsError` exceptions are raised when attempting to
+            register an event or property that already exists
         """
         for name in names:
             if name in self.__events:
-                continue
+                raise EventExistsError(name)
+            elif name in self.__property_events:
+                raise PropertyExistsError(name)
             self.__events[name] = Event(name)
     def bind(self, **kwargs):
         """Subscribes to events or to :class:`~pydispatch.properties.Property` updates
@@ -140,6 +195,8 @@ class Dispatcher(object):
             argument ``"__aio_loop__"`` (an instance of
             :class:`asyncio.BaseEventLoop`)
 
+            >>> import asyncio
+
             >>> class Foo(Dispatcher):
             ...     _events_ = ['test_event']
 
@@ -152,18 +209,28 @@ class Dispatcher(object):
             ...     async def on_foo_test_event(self, *args, **kwargs):
             ...         self.got_foo_event.set()
 
-            >>> loop = asyncio.get_event_loop()
-            >>> foo = Foo()
-            >>> bar = Bar()
-            >>> foo.bind(test_event=bar.on_foo_test_event, __aio_loop__=loop)
-            >>> fut = asyncio.ensure_future(bar.wait_for_foo())
+            >>> async def main():
+            ...     loop = asyncio.get_running_loop()
+            ...     foo = Foo()
+            ...     bar = Bar()
+            ...     foo.bind(test_event=bar.on_foo_test_event, __aio_loop__=loop)
+            ...     fut = asyncio.create_task(bar.wait_for_foo())
+            ...     foo.emit('test_event')
+            ...     await fut
 
-            >>> foo.emit('test_event')
-            >>> loop.run_until_complete(fut)
+            >>> asyncio.run(main())
             got foo!
 
             This can also be done using :meth:`bind_async`.
 
+            Raises:
+                DoesNotExistError: If attempting to bind to an event or
+                    property that has not been registered
+
+            .. versionchanged:: 0.2.2
+                :class:`DoesNotExistError` is now raised when binding to
+                non-existent events or properties
+
             .. versionadded:: 0.1.0
 
         """
@@ -174,7 +241,10 @@ class Dispatcher(object):
             if name in props:
                 e = props[name]
             else:
-                e = events[name]
+                try:
+                    e = events[name]
+                except KeyError:
+                    raise DoesNotExistError(name)
             e.add_listener(cb, __aio_loop__=aio_loop)
     def unbind(self, *args):
         """Unsubscribes from events or :class:`~pydispatch.properties.Property` updates
@@ -224,10 +294,21 @@ class Dispatcher(object):
             name (str): The name of the :class:`Event` to dispatch
             *args (Optional): Positional arguments to be sent to listeners
             **kwargs (Optional): Keyword arguments to be sent to listeners
+
+        Raises:
+            DoesNotExistError: If attempting to emit an event or
+                property that has not been registered
+
+        .. versionchanged:: 0.2.2
+            :class:`DoesNotExistError` is now raised if the event or property
+            does not exist
         """
         e = self.__property_events.get(name)
         if e is None:
-            e = self.__events[name]
+            try:
+                e = self.__events[name]
+            except KeyError:
+                raise DoesNotExistError(name)
         return e(*args, **kwargs)
     def get_dispatcher_event(self, name):
         """Retrieves an Event object by name
@@ -239,11 +320,21 @@ class Dispatcher(object):
         Returns:
             The :class:`Event` instance for the event or property definition
 
+        Raises:
+            DoesNotExistError: If no event or property with the given name exists
+
+        .. versionchanged:: 0.2.2
+            :class:`DoesNotExistError` is now raised if the event or property
+            does not exist
+
         .. versionadded:: 0.1.0
         """
         e = self.__property_events.get(name)
         if e is None:
-            e = self.__events[name]
+            try:
+                e = self.__events[name]
+            except KeyError:
+                raise DoesNotExistError(name)
         return e
     def emission_lock(self, name):
         """Holds emission of events and dispatches the last event on release
@@ -279,9 +370,26 @@ class Dispatcher(object):
             The context manager is re-entrant, meaning that multiple calls to
             this method within nested context scopes are possible.
 
+        Raises:
+            DoesNotExistError: If no event or property with the given name exists
+
+        .. versionchanged:: 0.2.2
+            :class:`DoesNotExistError` is now raised if the event or property
+            does not exist
+
         .. _PEP 492: https://www.python.org/dev/peps/pep-0492/#asynchronous-context-managers-and-async-with
         """
-        e = self.__property_events.get(name)
-        if e is None:
-            e = self.__events[name]
+        e = self.get_dispatcher_event(name)
         return e.emission_lock
+
+
+class _GlobalDispatcher(Dispatcher):
+    def _has_event(self, name):
+        try:
+            self.get_dispatcher_event(name)
+        except KeyError:
+            return False
+        return True
+
+
+_GLOBAL_DISPATCHER = _GlobalDispatcher()

pydispatch/utils.py

@@ -1,6 +1,6 @@
 import weakref
-from weakref import ref, _remove_dead_weakref
-from _weakref import ref
+from weakref import ref
+from _weakref import _remove_dead_weakref # type: ignore[import]
 import types
 import asyncio
 
@@ -9,6 +9,9 @@ def get_method_vars(m):
     obj = m.__self__
     return f, obj
 
+def isfunction(m):
+    return isinstance(m, types.FunctionType)
+
 def iscoroutinefunction(obj):
     return asyncio.iscoroutinefunction(obj)
 
@@ -28,7 +31,7 @@ class WeakMethodContainer(weakref.WeakValueDictionary):
         Args:
             m: The instance method or function to store
         """
-        if isinstance(m, types.FunctionType):
+        if isfunction(m):
             self['function', id(m)] = m
         else:
             f, obj = get_method_vars(m)
@@ -40,7 +43,7 @@ class WeakMethodContainer(weakref.WeakValueDictionary):
         Args:
             m: The instance method or function to remove
         """
-        if isinstance(m, types.FunctionType) and not iscoroutinefunction(m):
+        if isfunction(m):
             wrkey = ('function', id(m))
         else:
             f, obj = get_method_vars(m)
@@ -111,6 +114,12 @@ class InformativeWVDict(weakref.WeakValueDictionary):
                     _remove_dead_weakref(self.data, wr.key)
                     self._data_del_callback(wr.key)
         self._remove = remove
+
+        # `_pending_removals` and `_iterating` were removed in Python 3.14.
+        # To maintain compatibility with earlier versions, we reintroduce them here.
+        self._pending_removals = []
+        self._iterating = set()
+
         self.data = InformativeDict()
         self.data.del_callback = self._data_del_callback
     def _data_del_callback(self, key):

{python_dispatch-0.2.1.dist-info → python_dispatch-0.2.3.dist-info}/METADATA

@@ -1,38 +1,38 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-dispatch
-Version: 0.2.1
-Summary: Lightweight Event Handling
-Home-page: https://github.com/nocarryr/python-dispatch
+Version: 0.2.3
+Summary: Lightweight Event Handling Library for Python
+Keywords: event,properties,dispatch
 Author: Matthew Reid
-Author-email: matt@nomadic-recording.com
-License: MIT
-Project-URL: Documentation, https://python-dispatch.readthedocs.io
-Project-URL: Source, https://github.com/nocarryr/python-dispatch
-Project-URL: Tracker, https://github.com/nocarryr/python-dispatch/issues
-Keywords: event properties dispatch
-Platform: any
+Author-email: Matthew Reid <matt@nomadic-recording.com>
+License-Expression: MIT
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: importlib-metadata ; python_full_version < '3.8'
+Requires-Python: >=3.8
+Project-URL: Documentation, https://python-dispatch.readthedocs.io/
+Project-URL: Download, https://pypi.org/project/python-dispatch/
+Project-URL: Source, https://github.com/nocarryr/python-dispatch
+Project-URL: Tracker, https://github.com/nocarryr/python-dispatch/issues
 Description-Content-Type: text/markdown
-License-File: LICENSE.txt
 
 # python-dispatch
 Lightweight event handling for Python
 
-[![Build Status](https://travis-ci.org/nocarryr/python-dispatch.svg?branch=master)](https://travis-ci.org/nocarryr/python-dispatch)[![Coverage Status](https://coveralls.io/repos/github/nocarryr/python-dispatch/badge.svg?branch=master)](https://coveralls.io/github/nocarryr/python-dispatch?branch=master)[![PyPI version](https://badge.fury.io/py/python-dispatch.svg)](https://badge.fury.io/py/python-dispatch)[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nocarryr/python-dispatch/master/LICENSE.txt)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/nocarryr/python-dispatch/ci.yml)[![Coverage Status](https://coveralls.io/repos/github/nocarryr/python-dispatch/badge.svg?branch=master)](https://coveralls.io/github/nocarryr/python-dispatch?branch=master)[![PyPI version](https://badge.fury.io/py/python-dispatch.svg)](https://badge.fury.io/py/python-dispatch)[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nocarryr/python-dispatch/master/LICENSE.txt)
 
 ## Description
 This is an implementation of the "Observer Pattern" with inspiration from the

python_dispatch-0.2.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+pydispatch/__init__.py,sha256=qt4QDOYq_QGq0bMZizAvnhhzLr7LkZe9PBHilTjc74Y,2190
+pydispatch/aioutils.py,sha256=tv-ddi8tMwqtOJGNqONYb2Y-PKXyOJG4wsX3EzmgBsw,9848
+pydispatch/decorators.py,sha256=FFts0T9wvTVAgC9KGZSkpn_Nneecl1gAzufgP6nI4iQ,4213
+pydispatch/dispatch.py,sha256=Jbb7bl7kdsXlfQsCM8Jehui7qpSH1GhawEgPLk-lyAo,13508
+pydispatch/properties.py,sha256=Pt4J32bqz3xT5BwmIO3Idl8vmkNbei2R0g_Vqwi7RH0,13138
+pydispatch/utils.py,sha256=ubuGYHi0rxNS_Dbhqftfyr6yANS0OlaB6Ni9_x_kEP4,6535
+python_dispatch-0.2.3.dist-info/WHEEL,sha256=ZyFSCYkV2BrxH6-HRVRg3R9Fo7MALzer9KiPYqNxSbo,79
+python_dispatch-0.2.3.dist-info/METADATA,sha256=S1e1HF_lMN-gVv80kfCMUgbLVTNtLNslwkaW1A6NMsA,5802
+python_dispatch-0.2.3.dist-info/RECORD,,

python_dispatch-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.18
+Root-Is-Purelib: true
+Tag: py3-none-any

python_dispatch-0.2.1.dist-info/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2016 Matthew Reid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

python_dispatch-0.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-pydispatch/__init__.py,sha256=Lqfmw_j-YoJOJyRoSHc4VnPUoDF5PFqTCvSlR0RFs9I,615
-pydispatch/aioutils.py,sha256=M4n_H0NsuW0NpnCtU2y7FVWXtXA_JqQSMTWGJgELVY0,9027
-pydispatch/dispatch.py,sha256=xJvz6-0kEbgoh7LJJKqwZHc-yUrTYIEBwpxw8AC79G4,10265
-pydispatch/properties.py,sha256=Pt4J32bqz3xT5BwmIO3Idl8vmkNbei2R0g_Vqwi7RH0,13138
-pydispatch/utils.py,sha256=VYM6dNcBBGKpREOtmEZwO-xfJr41dsuyIfBKv8HtrBw,6292
-python_dispatch-0.2.1.dist-info/LICENSE.txt,sha256=muuSBeZ0K6AotNoWadQaHzGO9CtXBFBemAsXRL170tA,1069
-python_dispatch-0.2.1.dist-info/METADATA,sha256=63HpIqPlkRW5NPdWmsdKJBnfeNCayjPdSi2hjaeXOHo,5558
-python_dispatch-0.2.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-python_dispatch-0.2.1.dist-info/top_level.txt,sha256=BW69gM2IyIPfFk8J13eRwxzVlic046roE3WH5bya5BI,11
-python_dispatch-0.2.1.dist-info/RECORD,,

python_dispatch-0.2.1.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

python_dispatch-0.2.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-pydispatch