delegate-events 0.0.0__tar.gz

delegate_events-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dagrofa BI
+
+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.

delegate_events-0.0.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: delegate-events
+Version: 0.0.0
+Summary: Python implementation of the Event Pattern
+Author-email: Anders Madsen <anders.madsen@alphavue.com>
+License: MIT
+Project-URL: repository, https://github.com/apmadsen/delegate-events
+Keywords: windows,linux,delegates,events
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: delegate-pattern==0.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.3; extra == "test"
+Requires-Dist: pytest-cov>=6.1; extra == "test"
+Dynamic: license-file
+
+[![Test](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml)
+[![Stable Version](https://img.shields.io/pypi/v/delegate-events?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/delegate-events/releases)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/delegate-events?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/delegate-events)
+[![PyPI Downloads](https://static.pepy.tech/badge/delegate-events/week)](https://pepy.tech/projects/delegate-events)
+
+# delegate-events: Python implementation of the Event Pattern.
+
+delegate-events provides a basic implementation of the well-known Event or Pub/Sub Pattern, and is built on top of the `delegate-pattern` package which handles the delegation part.
+
+## Example
+
+```python
+from delegate.pattern import delegate
+from delegate.events import Channel, Event
+
+class OnSomethingEvent(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+class Class1:
+    on_something = delegate(Channel[OnSomethingEvent])
+
+inst = Class1()
+msg_queue: list[Event] = []
+
+def fn(publisher, event: OnSomethingEvent):
+    msg_queue.append(event)
+
+inst.on_something.subscribe(fn)
+inst.on_something.fire(OnSomethingEvent("Something", "some other thing"))
+
+str(msg_queue[0]) # => "Something happened because of some other thing"
+```
+
+# API
+
+## Event class
+The `Event` class is the base class of all events. Events are the classes holding the event information, when an event is fired, thus, when subclassed, should contain properties/fields of the event information.
+
+#### Example
+```python
+from delegate.events import Event
+
+class OnSomething(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+```
+
+## Channel class
+The `Channel` class is the event channel returned by the delegate, and its jobs are handling subscriptions and firing of events.
+
+### Channel.subscribe(handler: _Callable[[object, T\<Event>], None]_)
+
+The `subscribe` function subscribes a handler function to the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+#### Example
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+```
+
+
+### Channel.unsubscribe(handler: _Callable[[object, T\<Event>], None]_)
+The `unsubscribe` function unsubscribes a handler function from the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+channel.unsubscribe(handler)
+```
+
+### Channel.fire(event: _T\<Event>_, *, ttl: _float | None = 0_) -> _bool_ function
+The `fire` function fires the event, invoking all subscribed handlers. The function returns True if event was successfully sent and takes 1 argument:
+- event: `Event`
+
+and 1 optional keyword argument:
+- ttl: `float | None` the time-to-live (seconds) of the event.
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+msg_queue: list[Event] = []
+
+def handler(sender: object, event: OnSomethingEvent) -> None:
+    msg_queue.append(event)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => False
+channel.fire(OnSomethingEvent("Something", "some other thing"), ttl=10) # => False - event stays in queue and will be sent if subcrribed to within 10 seconds though
+
+channel.subscribe(handler)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => True
+
+len(msg_queue) # => 2
+```

delegate_events-0.0.0/README.md

@@ -0,0 +1,122 @@
+[![Test](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml)
+[![Stable Version](https://img.shields.io/pypi/v/delegate-events?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/delegate-events/releases)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/delegate-events?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/delegate-events)
+[![PyPI Downloads](https://static.pepy.tech/badge/delegate-events/week)](https://pepy.tech/projects/delegate-events)
+
+# delegate-events: Python implementation of the Event Pattern.
+
+delegate-events provides a basic implementation of the well-known Event or Pub/Sub Pattern, and is built on top of the `delegate-pattern` package which handles the delegation part.
+
+## Example
+
+```python
+from delegate.pattern import delegate
+from delegate.events import Channel, Event
+
+class OnSomethingEvent(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+class Class1:
+    on_something = delegate(Channel[OnSomethingEvent])
+
+inst = Class1()
+msg_queue: list[Event] = []
+
+def fn(publisher, event: OnSomethingEvent):
+    msg_queue.append(event)
+
+inst.on_something.subscribe(fn)
+inst.on_something.fire(OnSomethingEvent("Something", "some other thing"))
+
+str(msg_queue[0]) # => "Something happened because of some other thing"
+```
+
+# API
+
+## Event class
+The `Event` class is the base class of all events. Events are the classes holding the event information, when an event is fired, thus, when subclassed, should contain properties/fields of the event information.
+
+#### Example
+```python
+from delegate.events import Event
+
+class OnSomething(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+```
+
+## Channel class
+The `Channel` class is the event channel returned by the delegate, and its jobs are handling subscriptions and firing of events.
+
+### Channel.subscribe(handler: _Callable[[object, T\<Event>], None]_)
+
+The `subscribe` function subscribes a handler function to the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+#### Example
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+```
+
+
+### Channel.unsubscribe(handler: _Callable[[object, T\<Event>], None]_)
+The `unsubscribe` function unsubscribes a handler function from the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+channel.unsubscribe(handler)
+```
+
+### Channel.fire(event: _T\<Event>_, *, ttl: _float | None = 0_) -> _bool_ function
+The `fire` function fires the event, invoking all subscribed handlers. The function returns True if event was successfully sent and takes 1 argument:
+- event: `Event`
+
+and 1 optional keyword argument:
+- ttl: `float | None` the time-to-live (seconds) of the event.
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+msg_queue: list[Event] = []
+
+def handler(sender: object, event: OnSomethingEvent) -> None:
+    msg_queue.append(event)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => False
+channel.fire(OnSomethingEvent("Something", "some other thing"), ttl=10) # => False - event stays in queue and will be sent if subcrribed to within 10 seconds though
+
+channel.subscribe(handler)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => True
+
+len(msg_queue) # => 2
+```

delegate_events-0.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "delegate-events"
+version = "0.0.0"
+description = "Python implementation of the Event Pattern"
+keywords = ["windows", "linux", "delegates", "events"]
+readme = "README.md"
+authors = [
+    { name = "Anders Madsen", email = "anders.madsen@alphavue.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Development Status :: 6 - Mature",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed"
+]
+dependencies = [
+    "delegate-pattern==0.0.0"
+]
+requires-python = ">=3.10"
+
+[project.urls]
+repository = "https://github.com/apmadsen/delegate-events"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.3",
+    "pytest-cov>=6.1",
+]
+
+[tool.setuptools-git-versioning]
+enabled = true
+
+[build-system]
+requires = ["setuptools >= 77.0.3", "setuptools-git-versioning >= 2.1.0"]
+build-backend = "setuptools.build_meta"

delegate_events-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

delegate_events-0.0.0/src/delegate/events/__init__.py

@@ -0,0 +1,13 @@
+from delegate.events.core.channel_closed_error import ChannelClosedError
+from delegate.events.core.channel import Channel
+from delegate.events.core.event import Event
+from delegate.events.core.handler_already_subscribed_error import HandlerAlreadySubscribedError
+from delegate.events.core.handler_not_subscribed_error import HandlerNotSubscribedError
+
+__all__ = (
+    'Channel',
+    'Event',
+    'ChannelClosedError',
+    'HandlerAlreadySubscribedError',
+    'HandlerNotSubscribedError',
+)

delegate_events-0.0.0/src/delegate/events/core/channel.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+from typing import Generic, TypeVar, MutableSequence, Callable, cast, overload
+from datetime import datetime, timedelta
+from threading import RLock
+from weakref import ref
+
+from delegate.events.core.channel_closed_error import ChannelClosedError
+from delegate.events.core.event import Event
+from delegate.events.core.queued_event import QueuedEvent
+from delegate.events.core.handler_already_subscribed_error import HandlerAlreadySubscribedError
+from delegate.events.core.handler_not_subscribed_error import HandlerNotSubscribedError
+
+T = TypeVar("T", bound=Event, contravariant=True)
+class Channel(Generic[T]):
+    __slots__ = [ "__publisher", "__subscribers", "__queue", "__queue_lock", "__weakref__", "__closed" ]
+
+    @overload
+    def __init__(self) -> None:
+        """
+        Creates a channel without a publisher. This is meant for testing purposes.
+        """
+        ...
+    @overload
+    def __init__(self, delegator: object) -> None:
+        """
+        Creates a delegate channel for specific publisher (delegator).
+        """
+        ...
+    def __init__(self, delegator: object | None = None):
+        self.__publisher = ref(delegator) if delegator is not None else None
+        self.__subscribers: MutableSequence[Callable[[object, T], None]] = []
+        self.__queue: MutableSequence[QueuedEvent] = []
+        self.__queue_lock = RLock()
+        self.__closed = False
+
+    def subscribe(self, handler: Callable[[object, T], None]) -> None:
+        """
+        Subscribes to the event channel.
+
+        Args:
+            handler (Callable[[object, T], None]): The event handler
+        """
+        if self.__closed:
+            raise ChannelClosedError
+
+        if handler in self.__subscribers:
+            raise HandlerAlreadySubscribedError
+
+        self.__subscribers.append(handler)
+
+        with self.__queue_lock:
+            for event in self.__queue:
+                if not event.expired:
+                    self.fire(cast(T, event.event))
+            self.__queue.clear()
+
+
+    def unsubscribe(self, handler: Callable[[object, T], None]) -> None:
+        """
+        Unsubscribes handler from event channel.
+
+        Args:
+            handler (Callable[[object, T], None]): The event handler
+        """
+        if self.__closed:
+            raise ChannelClosedError
+
+        if handler not in self.__subscribers:
+            raise HandlerNotSubscribedError
+
+        self.__subscribers.remove(handler)
+
+    def fire(self, event: T, *, ttl: float | None = 0) -> bool:
+        """
+        Fires the event, invoking all subscribed handlers
+
+        Args:
+            event (Event): The event
+            ttl (float, optional): The time (seconds) the event may live in the queue while awaiting subcriptions
+        Returns:
+            bool: Returns True when event was successfully sent to one or more subscribers.
+        """
+        if self.__closed:
+            raise ChannelClosedError
+
+        if not self.__subscribers:
+            if ttl:
+                with self.__queue_lock:
+                    self.__queue.append(QueuedEvent(event, datetime.now() + timedelta(seconds = ttl)))
+
+            return False
+
+        for subscriber in self.__subscribers:
+            subscriber(self.__publisher() if self.__publisher else None, event)
+
+        return True
+
+    def close(self) -> None:
+        """
+        Closes the channel.
+
+        Raises:
+            ChannelClosedError: _description_
+        """
+        if self.__closed:
+            raise ChannelClosedError
+
+        self.__closed = True
+        self.__subscribers.clear()
+        self.__queue.clear()
+
+    def __iadd__(self, handler: Callable[[object, T], None]) -> Channel[T]:
+        self.subscribe(handler)
+        return self
+
+    def __isub__(self, handler: Callable[[object, T], None]) -> Channel[T]:
+        self.unsubscribe(handler)
+        return self

delegate_events-0.0.0/src/delegate/events/core/channel_closed_error.py

@@ -0,0 +1,5 @@
+class ChannelClosedError(Exception):
+    """
+    The ChannelClosedError exception is raised when accessing functions etc. on a closed channel.
+    """
+    pass

delegate_events-0.0.0/src/delegate/events/core/event.py

@@ -0,0 +1,7 @@
+
+class Event:
+    __slots__ = [ ]
+
+
+
+

delegate_events-0.0.0/src/delegate/events/core/handler_already_subscribed_error.py

@@ -0,0 +1,6 @@
+
+class HandlerAlreadySubscribedError(Exception):
+    """
+    The HandlerAlreadySubscribedError exception is raised when an event handler is already subscribed to the channel.
+    """
+    pass

delegate_events-0.0.0/src/delegate/events/core/handler_not_subscribed_error.py

@@ -0,0 +1,6 @@
+
+class HandlerNotSubscribedError(Exception):
+    """
+    The HandlerNotSubscribedError exception is raised when an event handler is not subscribed to the channel.
+    """
+    pass

delegate_events-0.0.0/src/delegate/events/core/queued_event.py

@@ -0,0 +1,18 @@
+from datetime import datetime
+
+from delegate.events.core.event import Event
+
+class QueuedEvent:
+    __slots__ = [ "__event", "__expires" ]
+
+    def __init__(self, event: Event, expires: datetime) -> None:
+        self.__event = event
+        self.__expires = expires
+
+    @property
+    def event(self) -> Event:
+        return self.__event
+
+    @property
+    def expired(self) -> bool:
+        return self.__expires < datetime.now()

delegate_events-0.0.0/src/delegate_events.egg-info/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: delegate-events
+Version: 0.0.0
+Summary: Python implementation of the Event Pattern
+Author-email: Anders Madsen <anders.madsen@alphavue.com>
+License: MIT
+Project-URL: repository, https://github.com/apmadsen/delegate-events
+Keywords: windows,linux,delegates,events
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: delegate-pattern==0.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.3; extra == "test"
+Requires-Dist: pytest-cov>=6.1; extra == "test"
+Dynamic: license-file
+
+[![Test](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/delegate-events/actions/workflows/python-test-coverage.yml)
+[![Stable Version](https://img.shields.io/pypi/v/delegate-events?label=stable&sort=semver&color=blue)](https://github.com/apmadsen/delegate-events/releases)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/delegate-events?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/delegate-events)
+[![PyPI Downloads](https://static.pepy.tech/badge/delegate-events/week)](https://pepy.tech/projects/delegate-events)
+
+# delegate-events: Python implementation of the Event Pattern.
+
+delegate-events provides a basic implementation of the well-known Event or Pub/Sub Pattern, and is built on top of the `delegate-pattern` package which handles the delegation part.
+
+## Example
+
+```python
+from delegate.pattern import delegate
+from delegate.events import Channel, Event
+
+class OnSomethingEvent(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+class Class1:
+    on_something = delegate(Channel[OnSomethingEvent])
+
+inst = Class1()
+msg_queue: list[Event] = []
+
+def fn(publisher, event: OnSomethingEvent):
+    msg_queue.append(event)
+
+inst.on_something.subscribe(fn)
+inst.on_something.fire(OnSomethingEvent("Something", "some other thing"))
+
+str(msg_queue[0]) # => "Something happened because of some other thing"
+```
+
+# API
+
+## Event class
+The `Event` class is the base class of all events. Events are the classes holding the event information, when an event is fired, thus, when subclassed, should contain properties/fields of the event information.
+
+#### Example
+```python
+from delegate.events import Event
+
+class OnSomething(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+```
+
+## Channel class
+The `Channel` class is the event channel returned by the delegate, and its jobs are handling subscriptions and firing of events.
+
+### Channel.subscribe(handler: _Callable[[object, T\<Event>], None]_)
+
+The `subscribe` function subscribes a handler function to the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+#### Example
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+```
+
+
+### Channel.unsubscribe(handler: _Callable[[object, T\<Event>], None]_)
+The `unsubscribe` function unsubscribes a handler function from the channel. The function takes 1 argument:
+- handler: `Callable[[object, Event], None]`
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+def handler(sender: object, args: OnSomethingEvent) -> None:
+    pass
+
+channel.subscribe(handler)
+channel.unsubscribe(handler)
+```
+
+### Channel.fire(event: _T\<Event>_, *, ttl: _float | None = 0_) -> _bool_ function
+The `fire` function fires the event, invoking all subscribed handlers. The function returns True if event was successfully sent and takes 1 argument:
+- event: `Event`
+
+and 1 optional keyword argument:
+- ttl: `float | None` the time-to-live (seconds) of the event.
+
+```python
+from delegate.events import Channel
+
+channel = Channel[OnSomethingEvent]()
+
+msg_queue: list[Event] = []
+
+def handler(sender: object, event: OnSomethingEvent) -> None:
+    msg_queue.append(event)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => False
+channel.fire(OnSomethingEvent("Something", "some other thing"), ttl=10) # => False - event stays in queue and will be sent if subcrribed to within 10 seconds though
+
+channel.subscribe(handler)
+
+channel.fire(OnSomethingEvent("Something", "some other thing")) # => True
+
+len(msg_queue) # => 2
+```

delegate_events-0.0.0/src/delegate_events.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/delegate/events/__init__.py
+src/delegate/events/core/channel.py
+src/delegate/events/core/channel_closed_error.py
+src/delegate/events/core/event.py
+src/delegate/events/core/handler_already_subscribed_error.py
+src/delegate/events/core/handler_not_subscribed_error.py
+src/delegate/events/core/queued_event.py
+src/delegate_events.egg-info/PKG-INFO
+src/delegate_events.egg-info/SOURCES.txt
+src/delegate_events.egg-info/dependency_links.txt
+src/delegate_events.egg-info/requires.txt
+src/delegate_events.egg-info/top_level.txt
+tests/test_channel.py

delegate_events-0.0.0/src/delegate_events.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

delegate_events-0.0.0/src/delegate_events.egg-info/requires.txt

@@ -0,0 +1,5 @@
+delegate-pattern==0.0.0
+
+[test]
+pytest>=8.3
+pytest-cov>=6.1

delegate_events-0.0.0/src/delegate_events.egg-info/top_level.txt

@@ -0,0 +1 @@
+delegate

delegate_events-0.0.0/tests/test_channel.py

@@ -0,0 +1,304 @@
+# pyright: basic
+from typing import Any
+from time import sleep
+import gc
+from weakref import ref
+from pytest import raises as assert_raises, fixture
+
+from delegate.pattern import delegate
+from delegate.events import Event, Channel, HandlerNotSubscribedError, HandlerAlreadySubscribedError, ChannelClosedError
+
+class Event1(Event):
+    def __init__(self, arg1: str, arg2: int):
+        self.arg1 = arg1
+        self.arg2 = arg2
+
+class Event2(Event):
+    def __init__(self, arg1: str, arg2: int):
+        self.arg1 = arg1
+        self.arg2 = arg2
+
+class OnSomethingEvent(Event):
+    def __init__(self, what: str, why: str):
+        self.what = what
+        self.why = why
+
+    def __str__(self):
+        return f"{self.what} happened because of {self.why}"
+
+
+def test_channel_basics():
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    inst = Class1()
+    msg_queue: list[tuple[object, Event]] = []
+
+    def fn(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    inst.event1.subscribe(fn)
+    inst.event1.fire(Event1("msg",1))
+
+    assert len(msg_queue) == 1
+    assert msg_queue[0][0] is inst
+
+
+def test_channel_closing():
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    inst = Class1()
+
+    def fn(publisher, event: Event1):
+        pass
+
+    inst.event1.close()
+
+    with assert_raises(ChannelClosedError):
+        inst.event1.close()
+
+    with assert_raises(ChannelClosedError):
+        inst.event1.subscribe(fn)
+
+    with assert_raises(ChannelClosedError):
+        inst.event1.unsubscribe(fn)
+
+    with assert_raises(ChannelClosedError):
+        inst.event1.fire(Event1("msg",2))
+
+
+def test_garbage_collection():
+    class Event3(Event):
+        def __init__(self, arg1: str, arg2: int):
+            self.arg1 = arg1
+            self.arg2 = arg2
+
+    class Class1:
+        event3 = delegate(Channel[Event3])
+
+
+
+    inst = Class1()
+    channel = ref(inst.event3)
+    refs_before_gc = len(gc.get_referrers(channel()))
+
+    inst = None
+    del Class1
+    del Event3
+
+    gc.collect()
+    gc.collect()
+    gc.collect()
+
+    assert refs_before_gc > 0
+    assert channel() is None
+
+
+def test_multiple_channels():
+
+    class Class1:
+        event1 = delegate(Channel[Event1])
+        event2 = delegate(Channel[Event2])
+
+    inst = Class1()
+    msg_queue: list[tuple[object, Event]] = []
+
+    def fn(publisher, event: Event):
+        msg_queue.append((publisher, event))
+
+    inst.event1.subscribe(fn)
+    inst.event2.subscribe(fn)
+
+    inst.event1.fire(Event1("msg",1))
+    inst.event2.fire(Event2("msg",2))
+
+    assert len(msg_queue) == 2
+    assert msg_queue[0][0] is inst
+    assert isinstance(msg_queue[0][1], Event1)
+    assert msg_queue[1][0] is inst
+    assert isinstance(msg_queue[1][1], Event2)
+    x=0
+
+
+
+def test_subscriptions():
+
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    inst = Class1()
+    msg_queue: list[tuple[object, Event1]] = []
+
+    def fn1(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    def fn2(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    inst.event1.subscribe(fn1)
+
+    with assert_raises(HandlerAlreadySubscribedError):
+        inst.event1.subscribe(fn1)
+
+    inst.event1.unsubscribe(fn1)
+
+    with assert_raises(HandlerNotSubscribedError):
+        inst.event1.unsubscribe(fn1)
+
+    inst.event1 += fn1
+    inst.event1 += fn2
+
+    inst.event1.fire(Event1("msg",1))
+
+    assert len(msg_queue) == 2
+    assert msg_queue[0][0] is inst
+    assert msg_queue[1][0] is inst
+    assert msg_queue[0][1] is msg_queue[1][1] # events should be same instance
+
+    inst.event1 -= fn2
+    inst.event1.fire(Event1("msg",2))
+
+    assert len(msg_queue) == 3
+    assert msg_queue[2][1].arg2 ==2
+
+
+def test_event_queue():
+
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    inst = Class1()
+    msg_queue: list[tuple[object, Event1]] = []
+
+    def fn(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    inst.event1.fire(Event1("msg",1)) # this msg will not be received because it has no ttl
+    inst.event1.fire(Event1("msg",2), ttl=60)
+    inst.event1.subscribe(fn)
+
+    assert len(msg_queue) == 1
+    assert msg_queue[0][0] is inst
+
+    inst = Class1()
+    msg_queue.clear()
+
+    inst.event1.fire(Event1("msg",1), ttl=0.001) # this msg will not be received because it has no ttl
+    sleep(0.01)
+    inst.event1.subscribe(fn)
+
+    assert len(msg_queue) == 0
+
+def test_multiple_instances_of_same_class():
+
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    inst1 = Class1()
+    inst2 = Class1()
+
+    msg_queue: list[tuple[object, Event1]] = []
+
+    def fn(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    inst1.event1.subscribe(fn)
+    inst2.event1.subscribe(fn)
+
+    inst1.event1.fire(Event1("msg",1))
+    inst2.event1.fire(Event1("msg",2))
+
+    assert len(msg_queue) == 2
+    assert msg_queue[0][0] is inst1
+    assert msg_queue[0][1].arg2 == 1
+    assert msg_queue[1][0] is inst2
+    assert msg_queue[1][1].arg2 == 2
+
+
+
+def test_instances_of_different_classes():
+
+    class Class1:
+        event1 = delegate(Channel[Event1])
+
+    class Class2:
+        event1 = delegate(Channel[Event1])
+
+    inst1 = Class1()
+    inst2 = Class2()
+
+    msg_queue: list[tuple[object, Event1]] = []
+
+    def fn(publisher, event: Event1):
+        msg_queue.append((publisher, event))
+
+    inst1.event1.subscribe(fn)
+    inst2.event1.subscribe(fn)
+
+    inst1.event1.fire(Event1("msg",1))
+    inst2.event1.fire(Event1("msg",2))
+
+    assert len(msg_queue) == 2
+    assert msg_queue[0][0] is inst1
+    assert msg_queue[0][1].arg2 == 1
+    assert msg_queue[1][0] is inst2
+    assert msg_queue[1][1].arg2 == 2
+
+def test_readme_example1():
+    from delegate.pattern import delegate
+    from delegate.events import Channel, Event
+
+    class OnSomethingEvent(Event):
+        def __init__(self, what: str, why: str):
+            self.what = what
+            self.why = why
+
+        def __str__(self):
+            return f"{self.what} happened because of {self.why}"
+
+    class Class1:
+        on_something = delegate(Channel[OnSomethingEvent])
+
+    inst = Class1()
+    msg_queue: list[Event] = []
+
+    def fn(publisher, event: OnSomethingEvent):
+        msg_queue.append(event)
+
+    inst.on_something.subscribe(fn)
+    inst.on_something.fire(OnSomethingEvent("Something", "some other thing"))
+
+    event_msg = str(msg_queue[0]) # => "Something happened because of some other thing"
+    assert str(event_msg) == "Something happened because of some other thing"
+
+
+def test_readme_example2():
+    from delegate.events import Channel
+
+    channel = Channel[OnSomethingEvent]()
+
+    def handler(sender: object, event: OnSomethingEvent) -> None:
+        pass
+
+    channel.subscribe(handler)
+    assert True == channel.fire(OnSomethingEvent("Something", "some other thing"))
+
+
+def test_readme_example3():
+    from delegate.events import Channel
+
+    channel = Channel[OnSomethingEvent]()
+
+    msg_queue: list[Event] = []
+
+    def handler(sender: object, event: OnSomethingEvent) -> None:
+        msg_queue.append(event)
+
+    assert False == channel.fire(OnSomethingEvent("Something", "some other thing")) # -> False
+    assert False == channel.fire(OnSomethingEvent("Something", "some other thing"), ttl=10) # -> False - event stays in queue for 10 seconds though
+
+    channel.subscribe(handler)
+
+    assert True == channel.fire(OnSomethingEvent("Something", "some other thing")) # -> True
+    assert len(msg_queue) == 2