eventspype 0.1.0__tar.gz

eventspype-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Gianluca Pagliara
+
+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.

eventspype-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: eventspype
+Version: 0.1.0
+Summary: A Python framework for building event-driven applications with a clean publisher-subscriber pattern implementation.
+Author: Gianluca Pagliara
+Author-email: pagliara.gianluca@gmail.com
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: async-timeout (>=5.0.1,<6.0.0)
+Requires-Dist: pytest-asyncio (>=0.21.1,<0.22.0)
+Description-Content-Type: text/markdown
+
+# Events Pypeline
+
+[![CI](https://github.com/gianlucapagliara/eventspype/actions/workflows/ci.yml/badge.svg)](https://github.com/gianlucapagliara/eventspype/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/gianlucapagliara/eventspype/branch/main/graph/badge.svg)](https://codecov.io/gh/gianlucapagliara/eventspype)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight and type-safe Python framework for building event-driven applications. eventspype provides a clean publisher-subscriber pattern implementation, making it easy to create decoupled and maintainable event-driven systems.
+
+## Features
+
+- 🎯 Type-safe publisher-subscriber pattern implementation
+- 🔄 Support for multiple publishers and subscribers
+- 🚀 Asynchronous event handling capabilities
+- 🛠️ Easy to use and integrate
+- 📦 Zero dependencies
+- 🔒 Thread-safe event distribution
+
+## Installation
+
+```bash
+# Using pip
+pip install eventspype
+
+# Using poetry
+poetry add eventspype
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

eventspype-0.1.0/README.md

@@ -0,0 +1,30 @@
+# Events Pypeline
+
+[![CI](https://github.com/gianlucapagliara/eventspype/actions/workflows/ci.yml/badge.svg)](https://github.com/gianlucapagliara/eventspype/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/gianlucapagliara/eventspype/branch/main/graph/badge.svg)](https://codecov.io/gh/gianlucapagliara/eventspype)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight and type-safe Python framework for building event-driven applications. eventspype provides a clean publisher-subscriber pattern implementation, making it easy to create decoupled and maintainable event-driven systems.
+
+## Features
+
+- 🎯 Type-safe publisher-subscriber pattern implementation
+- 🔄 Support for multiple publishers and subscribers
+- 🚀 Asynchronous event handling capabilities
+- 🛠️ Easy to use and integrate
+- 📦 Zero dependencies
+- 🔒 Thread-safe event distribution
+
+## Installation
+
+```bash
+# Using pip
+pip install eventspype
+
+# Using poetry
+poetry add eventspype
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

eventspype-0.1.0/eventspype/publishers/multi.py

@@ -0,0 +1,106 @@
+from typing import Any
+
+from ..subscribers.functional import FunctionalEventSubscriber
+from ..subscribers.subscriber import EventSubscriber
+from .publications import EventPublication
+from .publisher import EventPublisher
+
+
+class MultiPublisher:
+    """
+    A publisher that can handle multiple event types through different publications.
+    Each publication is handled by its own EventPublisher instance.
+    """
+
+    def __init__(self) -> None:
+        # Map of publications to their dedicated publishers
+        self._publishers: dict[EventPublication, EventPublisher] = {}
+        # Keep references to functional subscribers to prevent garbage collection
+        self._functional_subscribers: dict[Any, FunctionalEventSubscriber] = {}
+
+    # === Class Methods ===
+
+    @classmethod
+    def get_event_definitions(cls) -> dict[str, EventPublication]:
+        """Get all event publications defined in the class."""
+        result = {}
+        for name, value in cls.__dict__.items():
+            if isinstance(value, EventPublication):
+                result[name] = value
+        return result
+
+    def _get_or_create_publisher(self, publication: EventPublication) -> EventPublisher:
+        """Get or create a dedicated publisher for a publication."""
+        if publication not in self._publishers:
+            self._publishers[publication] = EventPublisher(publication)
+        return self._publishers[publication]
+
+    # === Subscriptions ===
+
+    def add_subscriber(
+        self, publication: EventPublication, subscriber: EventSubscriber
+    ) -> None:
+        """Add a subscriber for a specific publication."""
+        if publication not in self.get_event_definitions().values():
+            raise ValueError(f"Invalid publication: {publication}")
+
+        publisher = self._get_or_create_publisher(publication)
+        publisher.add_subscriber(subscriber)
+
+    def remove_subscriber(
+        self, publication: EventPublication, subscriber: EventSubscriber
+    ) -> None:
+        """Remove a subscriber for a specific publication."""
+        if publication not in self.get_event_definitions().values():
+            raise ValueError(f"Invalid publication: {publication}")
+
+        if publication not in self._publishers:
+            return
+
+        publisher = self._publishers[publication]
+        publisher.remove_subscriber(subscriber)
+
+        # Clean up empty publishers
+        if not publisher.get_subscribers():
+            del self._publishers[publication]
+
+    def add_subscriber_with_callback(
+        self, publication: EventPublication, callback: Any
+    ) -> None:
+        """Add a callback function as a subscriber for a specific publication."""
+        if publication not in self.get_event_definitions().values():
+            raise ValueError(f"Invalid publication: {publication}")
+
+        subscriber = FunctionalEventSubscriber(callback)
+        # Keep a reference to the subscriber
+        self._functional_subscribers[callback] = subscriber
+        self.add_subscriber(publication, subscriber)
+
+    def remove_subscriber_with_callback(
+        self, publication: EventPublication, callback: Any
+    ) -> None:
+        """Remove a callback function subscriber for a specific publication."""
+        if publication not in self.get_event_definitions().values():
+            raise ValueError(f"Invalid publication: {publication}")
+
+        if publication not in self._publishers:
+            return
+
+        # Get the subscriber from our references
+        if callback in self._functional_subscribers:
+            subscriber = self._functional_subscribers[callback]
+            self.remove_subscriber(publication, subscriber)
+            del self._functional_subscribers[callback]
+
+    # === Events ===
+
+    def trigger_event(self, publication: EventPublication, event: Any) -> None:
+        """Trigger an event for a specific publication."""
+        if publication not in self.get_event_definitions().values():
+            raise ValueError(f"Invalid publication: {publication}")
+
+        if publication not in self._publishers:
+            return
+
+        # Use the dedicated publisher to trigger the event
+        self._publishers[publication].trigger_event(event)

eventspype-0.1.0/eventspype/publishers/publications.py

@@ -0,0 +1,19 @@
+from enum import Enum
+from typing import Any
+
+
+class EventPublication:
+    def __init__(self, event_tag: Enum | int | str, event_class: Any) -> None:
+        self.original_tag = event_tag
+        self.event_class = event_class
+
+        if isinstance(event_tag, Enum):
+            event_tag = event_tag.value
+        if isinstance(event_tag, str):
+            event_tag = hash(event_tag.upper()) % 10**8
+        if not isinstance(event_tag, int):
+            raise ValueError(f"Invalid event tag: {event_tag}")
+        self.event_tag: int = event_tag
+
+    def __hash__(self) -> int:
+        return hash((self.event_tag, self.event_class))

eventspype-0.1.0/eventspype/publishers/publisher.py

@@ -0,0 +1,101 @@
+import logging
+import random
+import weakref
+from typing import Any
+
+from ..subscribers.subscriber import EventSubscriber
+from .publications import EventPublication
+
+
+class EventPublisher:
+    """
+    EventPublisher with weak references for a single event type. This avoids the lapsed subscriber problem by periodically
+    performing GC on dead event subscribers.
+
+    Dead subscriber cleanup is done by calling _remove_dead_subscribers(), which checks whether the subscriber weak references are
+    alive or not, and removes the dead ones. Each call to _remove_dead_subscribers() takes O(n).
+    """
+
+    ADD_SUBSCRIBER_GC_PROBABILITY = 0.005
+
+    def __init__(self, publication: EventPublication) -> None:
+        self._publication = publication
+        self._subscribers: set[weakref.ReferenceType[EventSubscriber]] = set()
+        self._logger: logging.Logger | None = None
+
+    @property
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    @property
+    def logger(self) -> logging.Logger:
+        if self._logger is None:
+            self._logger = logging.getLogger(__name__)
+        return self._logger
+
+    def add_subscriber(self, subscriber: EventSubscriber) -> None:
+        """Add a subscriber for this publisher's event."""
+        # Create weak reference to the subscriber
+        subscriber_ref = weakref.ref(subscriber)
+        self._subscribers.add(subscriber_ref)
+
+        # Randomly perform garbage collection
+        if random.random() < self.ADD_SUBSCRIBER_GC_PROBABILITY:
+            self._remove_dead_subscribers()
+
+    def remove_subscriber(self, subscriber: EventSubscriber) -> None:
+        """Remove a subscriber."""
+        # Create a temporary weak reference for comparison
+        subscriber_ref = weakref.ref(subscriber)
+
+        # Remove the subscriber if it exists
+        self._subscribers.discard(subscriber_ref)
+
+        # Clean up dead subscribers
+        self._remove_dead_subscribers()
+
+    def get_subscribers(self) -> list[EventSubscriber]:
+        """Get all active subscribers."""
+        self._remove_dead_subscribers()
+
+        # Return only the subscribers that are still alive
+        return [
+            subscriber
+            for subscriber in (ref() for ref in self._subscribers)
+            if subscriber is not None
+        ]
+
+    def trigger_event(self, message: Any) -> None:
+        """Trigger an event, notifying all subscribers with the given message."""
+        # Validate event type
+        if not isinstance(message, self._publication.event_class):
+            raise ValueError(
+                f"Invalid event type: expected {self._publication.event_class}, got {type(message)}"
+            )
+
+        self._remove_dead_subscribers()
+
+        # Make a copy of the subscribers to avoid modification during iteration
+        subscribers = self._subscribers.copy()
+
+        for subscriber_ref in subscribers:
+            subscriber = subscriber_ref()
+            if subscriber is None:
+                continue
+
+            try:
+                subscriber(message, self._publication.event_tag, self)
+            except Exception:
+                self._log_exception(message)
+
+    def _remove_dead_subscribers(self) -> None:
+        """Remove any dead subscribers."""
+        # Remove any dead references
+        self._subscribers = {ref for ref in self._subscribers if ref() is not None}
+
+    def _log_exception(self, arg: Any) -> None:
+        """Log any exceptions that occur during event processing."""
+        self.logger.error(
+            f"Unexpected error while processing event {self._publication.event_tag}.",
+            exc_info=True,
+        )

eventspype-0.1.0/eventspype/subscribers/functional.py

@@ -0,0 +1,16 @@
+from collections.abc import Callable
+from typing import Any
+
+from .subscriber import EventSubscriber
+
+
+class FunctionalEventSubscriber(EventSubscriber):
+    def __init__(
+        self,
+        callback: Callable[[Any, int, Any], Any],
+    ) -> None:
+        super().__init__()
+        self._callback = callback
+
+    def call(self, arg: Any, current_event_tag: int, current_event_caller: Any) -> None:
+        self._callback(arg, current_event_tag, current_event_caller)

eventspype-0.1.0/eventspype/subscribers/multi.py

@@ -0,0 +1,84 @@
+import logging
+from abc import abstractmethod
+from collections import defaultdict
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, TypeVar
+
+from ..publishers.publisher import EventPublisher
+from .subscriptions import EventSubscription
+
+T = TypeVar("T")
+
+
+class MultiSubscriber:
+    def __init__(self) -> None:
+        self._subscribers: dict[EventPublisher, dict[EventSubscription, Any]] = (
+            defaultdict(dict)
+        )
+
+    # === Class Methods ===
+
+    @classmethod
+    def get_event_definitions(cls) -> dict[str, EventSubscription]:
+        result = {}
+        for name, value in cls.__dict__.items():
+            if isinstance(value, EventSubscription):
+                result[name] = value
+        return result
+
+    # === Properties ===
+
+    @property
+    def subscribers(self) -> dict[EventPublisher, dict[EventSubscription, Any]]:
+        return self._subscribers
+
+    # === Subscriptions ===
+
+    def add_subscription(
+        self, subscription: EventSubscription, publisher: EventPublisher
+    ) -> None:
+        if subscription not in self.get_event_definitions().values():
+            raise ValueError("Subscription not defined in event definitions")
+
+        if subscription in self._subscribers[publisher]:
+            return
+
+        # Save the subscriber to prevent it from being garbage collected
+        self._subscribers[publisher][subscription] = subscription(publisher, self)
+
+    def remove_subscription(
+        self, subscription: EventSubscription, publisher: EventPublisher
+    ) -> None:
+        if subscription not in self.get_event_definitions().values():
+            raise ValueError("Subscription not defined in event definitions")
+
+        if subscription not in self._subscribers[publisher]:
+            return
+
+        subscribers = list(self._subscribers[publisher][subscription])
+        for subscriber in subscribers:
+            subscription.unsubscribe(publisher, subscriber)
+            self._subscribers[publisher][subscription].remove(subscriber)
+
+        del self._subscribers[publisher][subscription]
+
+    # === Decorators ===
+
+    @abstractmethod
+    def logger(self) -> logging.Logger:
+        raise NotImplementedError
+
+    @staticmethod
+    def log_event(
+        log_level: int = logging.INFO, log_prefix: str = "Event"
+    ) -> Callable[..., Callable[..., Any]]:
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            @wraps(func)
+            def wrapper(self: "MultiSubscriber", event: Any) -> Any:
+                self.logger().log(log_level, f"[{log_prefix}] {event}")
+                return func(self, event)
+
+            return wrapper
+
+        return decorator

eventspype-0.1.0/eventspype/subscribers/reporter.py

@@ -0,0 +1,80 @@
+import dataclasses
+import logging
+from typing import Any, Protocol, TypeVar, runtime_checkable
+
+from .subscriber import EventSubscriber
+
+
+@runtime_checkable
+class HasAsDict(Protocol):
+    def _asdict(self) -> dict[str, Any]: ...
+
+
+T = TypeVar("T")
+
+
+class ReportingEventSubscriber(EventSubscriber):
+    """
+    Event subscriber that logs events to a logger.
+    """
+
+    _logger: logging.Logger | None = None
+
+    def __init__(self, event_source: str | None = None) -> None:
+        super().__init__()
+        self.event_source = event_source
+
+    @classmethod
+    def logger(cls) -> logging.Logger:
+        if cls._logger is None:
+            cls._logger = logging.getLogger(__name__)
+        return cls._logger
+
+    def _get_event_name(self, obj: Any) -> str:
+        """Get the event name from an object safely."""
+        try:
+            return type(obj).__name__
+        except Exception:
+            return "UnknownEvent"
+
+    def call(
+        self,
+        event_object: Any,
+        current_event_tag: int,
+        current_event_caller: Any,
+    ) -> None:
+        """
+        Process and log an event.
+
+        Args:
+            event_object: The event object to log
+            current_event_tag: The tag of the current event
+            current_event_caller: The publisher that triggered the event
+        """
+        try:
+            # Convert event object to dictionary
+            if dataclasses.is_dataclass(type(event_object)):
+                event_dict = dataclasses.asdict(event_object)
+            elif isinstance(event_object, HasAsDict):
+                event_dict = event_object._asdict()
+            else:
+                event_dict = {"value": str(event_object)}
+
+            # Add event metadata
+            metadata: dict[str, Any] = {
+                "event_name": self._get_event_name(event_object),
+                "event_source": self.event_source,
+                "event_tag": current_event_tag,
+            }
+            event_dict.update(metadata)
+
+            # Log the event at INFO level
+            self.logger().info(
+                f"Event received: {event_dict}", extra={"event_data": event_dict}
+            )
+        except Exception:
+            self.logger().error(
+                "Error logging event.",
+                exc_info=True,
+                extra={"event_source": self.event_source},
+            )

eventspype-0.1.0/eventspype/subscribers/subscriber.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+from typing import Any
+
+
+class EventSubscriber:
+    def __call__(
+        self, arg: Any, current_event_tag: int, current_event_caller: Any
+    ) -> None:
+        self.call(arg, current_event_tag, current_event_caller)
+
+    @abstractmethod
+    def call(
+        self,
+        arg: Any,
+        current_event_tag: int,
+        current_event_caller: Any,
+    ) -> None:
+        raise NotImplementedError
+
+
+class OwnedEventSubscriber(EventSubscriber):
+    def __init__(self, owner: Any) -> None:
+        super().__init__()
+        self._owner = owner
+
+    @property
+    def owner(self) -> Any:
+        return self._owner

eventspype-0.1.0/eventspype/subscribers/subscriptions.py

@@ -0,0 +1,110 @@
+from collections.abc import Callable
+from enum import Enum
+from functools import partial
+from typing import Any, TypeVar
+
+from ..publishers.publisher import EventPublisher
+from .functional import FunctionalEventSubscriber
+
+T = TypeVar("T")
+
+
+class EventSubscription:
+    def __init__(
+        self,
+        publisher_class: Any,
+        event_tag: Any | list[Any],
+        callback: Callable[..., Any],
+        callback_with_subscriber: bool = True,
+    ) -> None:
+        self._publisher_class = publisher_class
+        self._event_tag = event_tag
+        self._callback = callback
+        self._callback_with_subscriber = callback_with_subscriber
+
+    def __call__(
+        self,
+        publisher: EventPublisher,
+        subscriber: Any | None = None,
+    ) -> list[FunctionalEventSubscriber]:
+        return self.subscribe(publisher, subscriber)
+
+    def __hash__(self) -> int:
+        return hash((self.publisher_class, self.event_tag_str, self.callback))
+
+    # === Properties ===
+
+    @property
+    def publisher_class(self) -> Any:
+        return self._publisher_class
+
+    @property
+    def event_tag(self) -> Any:
+        return self._event_tag
+
+    @property
+    def callback(self) -> Callable[..., Any]:
+        return self._callback
+
+    @property
+    def callback_with_subscriber(self) -> bool:
+        return self._callback_with_subscriber
+
+    @property
+    def event_tag_str(self) -> str:
+        tags = str(self.event_tag)
+        if isinstance(self.event_tag, list):
+            tags = ", ".join(sorted([str(tag) for tag in self.event_tag]))
+            tags = f"[{tags}]"
+        return tags
+
+    # === Subscriptions ===
+
+    def subscribe(
+        self, publisher: EventPublisher, subscriber: Any
+    ) -> list[FunctionalEventSubscriber]:
+        subscribers = []
+        tags = self._get_event_tags(self.event_tag)
+        for event_tag in tags:
+            subscribers.append(self._subscribe(publisher, event_tag, subscriber))
+        return subscribers
+
+    def unsubscribe(
+        self, publisher: EventPublisher, subscriber: FunctionalEventSubscriber
+    ) -> None:
+        tags = self._get_event_tags(self.event_tag)
+        for event_tag in tags:
+            self._unsubscribe(publisher, subscriber, event_tag)
+
+    def _get_event_tags(self, event_tag: Any) -> list[int | Enum]:
+        tags = event_tag if isinstance(event_tag, list) else [event_tag]
+        return [tag if isinstance(tag, Enum | int) else hash(self) for tag in tags]
+
+    def _subscribe(
+        self,
+        publisher: EventPublisher,
+        event_tag: Any,
+        subscriber: Any | None = None,
+    ) -> FunctionalEventSubscriber:
+        if not isinstance(publisher, self.publisher_class):
+            raise ValueError("Publisher type mismatch")
+
+        callback = self.callback
+        if self.callback_with_subscriber:
+            if subscriber is None:
+                raise ValueError("Subscriber is required for callback with subscriber")
+            callback = partial(self.callback, subscriber)
+
+        subscriber = FunctionalEventSubscriber(callback)
+        publisher.add_subscriber(subscriber)
+        return subscriber
+
+    def _unsubscribe(
+        self,
+        publisher: EventPublisher,
+        subscriber: FunctionalEventSubscriber,
+        event_tag: Any,
+    ) -> None:
+        if not isinstance(publisher, self.publisher_class):
+            raise ValueError("Publisher type mismatch")
+        publisher.remove_subscriber(subscriber)

eventspype-0.1.0/eventspype/subscribers/tracker.py

@@ -0,0 +1,111 @@
+import asyncio
+from collections import deque
+from typing import Any
+
+from async_timeout import timeout
+
+from .subscriber import EventSubscriber
+
+
+class TrackingEventSubscriber(EventSubscriber):
+    """
+    A subscriber that collects events and provides async waiting functionality.
+    """
+
+    def __init__(self, event_source: str | None = None, max_len: int = 50) -> None:
+        """
+        Initialize the event logger.
+
+        Args:
+            event_source: Optional source identifier for the events
+            max_len: Maximum number of events to keep in the log (default: 50)
+        """
+        super().__init__()
+        self._event_source = event_source
+        self._generic_collected_events: deque[Any] = deque(maxlen=max_len)
+        self._collected_events: dict[type[Any], deque[Any]] = {}
+        self._waiting: dict[asyncio.Event, type[Any]] = {}
+        self._wait_returns: dict[asyncio.Event, Any] = {}
+
+    @property
+    def event_log(self) -> list[Any]:
+        """Get all collected events as a list."""
+        return list(self._generic_collected_events)
+
+    @property
+    def event_source(self) -> str | None:
+        """Get the event source identifier."""
+        return self._event_source
+
+    def clear(self) -> None:
+        """Clear all collected events."""
+        self._generic_collected_events.clear()
+        self._collected_events.clear()
+
+    async def wait_for(
+        self, event_type: type[Any], timeout_seconds: float = 180
+    ) -> Any:
+        """
+        Wait for an event of a specific type to occur.
+
+        Args:
+            event_type: The type of event to wait for
+            timeout_seconds: How long to wait before timing out (default: 180 seconds)
+
+        Returns:
+            The event object when it occurs
+
+        Raises:
+            TimeoutError: If the event doesn't occur within timeout_seconds
+        """
+        notifier = asyncio.Event()
+        self._waiting[notifier] = event_type
+
+        try:
+            async with timeout(timeout_seconds):
+                await notifier.wait()
+
+            retval = self._wait_returns.get(notifier)
+            if notifier in self._wait_returns:
+                del self._wait_returns[notifier]
+            return retval
+        finally:
+            # Always clean up, even on timeout
+            if notifier in self._waiting:
+                del self._waiting[notifier]
+            if notifier in self._wait_returns:
+                del self._wait_returns[notifier]
+
+    def call(
+        self,
+        event_object: Any,
+        current_event_tag: int,
+        current_event_caller: Any,
+    ) -> None:
+        """
+        Process an event by logging it and notifying any waiters.
+
+        Args:
+            event_object: The event to process
+            current_event_tag: The tag of the current event
+            current_event_caller: The publisher that triggered the event
+        """
+        # Get the appropriate deque for this event type
+        event_type = type(event_object)
+        event_deque = self._collected_events.get(event_type)
+        if event_deque is None:
+            event_deque = self._generic_collected_events
+
+        # Log the event
+        event_deque.append(event_object)
+
+        # Notify any waiters for this event type
+        should_notify = []
+        for notifier, waiting_event_type in self._waiting.items():
+            if event_type is waiting_event_type:
+                should_notify.append(notifier)
+                self._wait_returns[notifier] = event_object
+
+        # Set the events after collecting them all
+        for notifier in should_notify:
+            notifier.set()

eventspype-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[tool.poetry]
+name = "eventspype"
+version = "0.1.0"
+description = "A Python framework for building event-driven applications with a clean publisher-subscriber pattern implementation."
+authors = ["Gianluca Pagliara <pagliara.gianluca@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.13"
+async-timeout = "^5.0.1"
+pytest-asyncio = "^0.21.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.3"
+pytest-cov = "^4.1.0"
+black = "^23.11.0"
+isort = "^5.12.0"
+mypy = "^1.7.0"
+safety = "^2.3.5"
+pre-commit = "^3.5.0"
+ruff = "^0.8.4"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py312']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+check_untyped_defs = true
+strict = true
+disallow_untyped_decorators = false
+ignore_missing_imports = true
+disable_error_code = ["misc"]
+exclude = ["tests/.*"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "C",   # flake8-comprehensions
+    "B",   # flake8-bugbear
+    "UP"   # pyupgrade
+]
+ignore = [
+    "E203",  # See https://github.com/psf/black/issues/315
+    "E501"   # Line too long (handled by black)
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]  # Ignore unused imports in __init__ files