neuroglia-python 0.6.12__tar.gz → 0.6.14__tar.gz

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroglia-python
-Version: 0.6.12
+Version: 0.6.14
 Summary: Port from .NET to Python of the Neuroglia Framework
 License: Apache
 License-File: LICENSE

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "neuroglia-python"
-version = "0.6.12"
+version = "0.6.14"
 description = "Port from .NET to Python of the Neuroglia Framework"
 authors = ["Charles d'Avernas <charles.davernas@neuroglia.io>", "Bruno van de Werve <bvandewe@gmail.com>"]
 license = "Apache"

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/src/neuroglia/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
 ]
 
 # Framework metadata
-__version__ = "0.6.11"
+__version__ = "0.6.14"
 __author__ = "Neuroglia Team"
 __email__ = "team@neuroglia.io"
 __license__ = "Apache"

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/src/neuroglia/data/infrastructure/event_sourcing/event_sourcing_repository.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Generic, Optional
+from typing import TYPE_CHECKING, Generic, Optional
 
 from neuroglia.data.abstractions import DomainEvent, TAggregate, TKey
 from neuroglia.data.infrastructure.abstractions import Repository
@@ -11,6 +11,9 @@ from neuroglia.data.infrastructure.event_sourcing.abstractions import (
 )
 from neuroglia.hosting.abstractions import ApplicationBuilderBase
 
+if TYPE_CHECKING:
+    from neuroglia.mediation.mediator import Mediator
+
 
 @dataclass
 class EventSourcingRepositoryOptions(Generic[TAggregate, TKey]):
@@ -20,8 +23,9 @@ class EventSourcingRepositoryOptions(Generic[TAggregate, TKey]):
 class EventSourcingRepository(Generic[TAggregate, TKey], Repository[TAggregate, TKey]):
     """Represents an event sourcing repository implementation"""
 
-    def __init__(self, eventstore: EventStore, aggregator: Aggregator):
+    def __init__(self, eventstore: EventStore, aggregator: Aggregator, mediator: Optional["Mediator"] = None):
         """Initialize a new event sourcing repository"""
+        super().__init__(mediator)  # Pass mediator to base class for event publishing
         self._eventstore = eventstore
         self._aggregator = aggregator
 
@@ -40,33 +44,51 @@ class EventSourcingRepository(Generic[TAggregate, TKey], Repository[TAggregate,
         events = await self._eventstore.read_async(stream_id, StreamReadDirection.FORWARDS, 0)
         return self._aggregator.aggregate(events, self.__orig_class__.__args__[0])
 
-    async def add_async(self, aggregate: TAggregate) -> TAggregate:
+    async def _do_add_async(self, aggregate: TAggregate) -> TAggregate:
         """Adds and persists the specified aggregate"""
         stream_id = self._build_stream_id_for(aggregate.id())
         events = aggregate._pending_events
         if len(events) < 1:
-            raise Exception()
+            raise Exception("No pending events to persist")
         encoded_events = [self._encode_event(e) for e in events]
         await self._eventstore.append_async(stream_id, encoded_events)
         aggregate.state.state_version = events[-1].aggregate_version
         aggregate.clear_pending_events()
         return aggregate
 
-    async def update_async(self, aggregate: TAggregate) -> TAggregate:
-        """Perists the changes made to the specified aggregate"""
+    async def _do_update_async(self, aggregate: TAggregate) -> TAggregate:
+        """Persists the changes made to the specified aggregate"""
         stream_id = self._build_stream_id_for(aggregate.id())
         events = aggregate._pending_events
         if len(events) < 1:
-            raise Exception()
+            raise Exception("No pending events to persist")
         encoded_events = [self._encode_event(e) for e in events]
         await self._eventstore.append_async(stream_id, encoded_events, aggregate.state.state_version)
         aggregate.state.state_version = events[-1].aggregate_version
         aggregate.clear_pending_events()
         return aggregate
 
-    async def remove_async(self, id: TKey) -> None:
+    async def _do_remove_async(self, id: TKey) -> None:
         """Removes the aggregate root with the specified key, if any"""
-        raise NotImplementedError()
+        raise NotImplementedError("Event sourcing repositories do not support hard deletes")
+
+    async def _publish_domain_events(self, entity: TAggregate) -> None:
+        """
+        Override base class event publishing for event-sourced aggregates.
+
+        Event sourcing repositories DO NOT publish events directly because:
+        1. Events are already persisted to the EventStore
+        2. ReadModelReconciliator subscribes to EventStore and publishes ALL events
+        3. Publishing here would cause DOUBLE PUBLISHING (once here, once from ReadModelReconciliator)
+
+        For event-sourced aggregates:
+        - Events are persisted to EventStore by _do_add_async/_do_update_async
+        - ReadModelReconciliator.on_event_record_stream_next_async() publishes via mediator
+        - This ensures single, reliable event publishing from the source of truth (EventStore)
+
+        State-based repositories still use the base class _publish_domain_events() correctly.
+        """
+        # Do nothing - ReadModelReconciliator handles event publishing from EventStore
 
     def _build_stream_id_for(self, aggregate_id: TKey):
         """Builds a new stream id for the specified aggregate"""

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/src/neuroglia/data/infrastructure/event_sourcing/read_model_reconciliator.py

@@ -1,8 +1,14 @@
 import asyncio
-from dataclasses import dataclass
 import logging
+from dataclasses import dataclass
+
 from rx.core.typing import Disposable
-from neuroglia.data.infrastructure.event_sourcing.abstractions import AckableEventRecord, EventRecord, EventStore, EventStoreOptions
+
+from neuroglia.data.infrastructure.event_sourcing.abstractions import (
+    EventRecord,
+    EventStore,
+    EventStoreOptions,
+)
 from neuroglia.dependency_injection.service_provider import ServiceProviderBase
 from neuroglia.hosting.abstractions import HostedService
 from neuroglia.mediation.mediator import Mediator
@@ -11,25 +17,25 @@ from neuroglia.reactive import AsyncRx
 
 @dataclass
 class ReadModelConciliationOptions:
-    ''' Represents the options used to configure the application's read model reconciliation features '''
+    """Represents the options used to configure the application's read model reconciliation features"""
 
     consumer_group: str
-    ''' Gets the name of the group of consumers the application's read model is maintained by '''
+    """ Gets the name of the group of consumers the application's read model is maintained by """
 
 
 class ReadModelReconciliator(HostedService):
-    ''' Represents the service used to reconciliate the read model by streaming and handling events recorded on the application's event store '''
+    """Represents the service used to reconciliate the read model by streaming and handling events recorded on the application's event store"""
 
     _service_provider: ServiceProviderBase
-    ''' Gets the current service provider '''
+    """ Gets the current service provider """
 
     _mediator: Mediator
 
     _event_store_options: EventStoreOptions
-    ''' Gets the options used to configure the event store '''
+    """ Gets the options used to configure the event store """
 
     _event_store: EventStore
-    ''' Gets the service used to persist and stream domain events '''
+    """ Gets the service used to persist and stream domain events """
 
     _subscription: Disposable
 
@@ -46,8 +52,21 @@ class ReadModelReconciliator(HostedService):
         self._subscription.dispose()
 
     async def subscribe_async(self):
-        observable = await self._event_store.observe_async(f'$ce-{self._event_store_options.database_name}', self._event_store_options.consumer_group)
-        self._subscription = AsyncRx.subscribe(observable, lambda e: asyncio.run(self.on_event_record_stream_next_async(e)))
+        observable = await self._event_store.observe_async(f"$ce-{self._event_store_options.database_name}", self._event_store_options.consumer_group)
+
+        # Get the current event loop to schedule tasks on
+        loop = asyncio.get_event_loop()
+
+        def on_next(e):
+            """Schedule the async handler on the main event loop without closing it."""
+            try:
+                # Use call_soon_threadsafe to schedule the coroutine on the main loop
+                # This prevents creating/closing new event loops which breaks Motor
+                loop.call_soon_threadsafe(lambda: asyncio.create_task(self.on_event_record_stream_next_async(e)))
+            except RuntimeError as ex:
+                logging.warning(f"Event loop closed, skipping event: {type(e.data).__name__ if hasattr(e, 'data') else 'unknown'} - {ex}")
+
+        self._subscription = AsyncRx.subscribe(observable, on_next)
 
     async def on_event_record_stream_next_async(self, e: EventRecord):
         try:

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/src/neuroglia/data/infrastructure/mongo/mongo_repository.py

@@ -2,7 +2,7 @@ import ast
 from ast import NodeVisitor, expr
 from dataclasses import dataclass
 from inspect import isclass
-from typing import Any, Generic, Optional
+from typing import TYPE_CHECKING, Any, Generic, List, Optional
 
 import pymongo
 from pymongo import MongoClient
@@ -23,6 +23,9 @@ from neuroglia.expressions.javascript_expression_translator import (
 from neuroglia.hosting.abstractions import ApplicationBuilderBase
 from neuroglia.serialization.json import JsonSerializer
 
+if TYPE_CHECKING:
+    from neuroglia.mediation.mediator import Mediator
+
 
 @dataclass
 class MongoRepositoryOptions(Generic[TEntity, TKey]):
@@ -130,8 +133,10 @@ class MongoRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         options: MongoRepositoryOptions[TEntity, TKey],
         mongo_client: MongoClient,
         serializer: JsonSerializer,
+        mediator: Optional["Mediator"] = None,
     ):
         """Initializes a new Mongo repository"""
+        super().__init__(mediator)  # Pass mediator to base Repository class
         self._options = options
         self._mongo_client = mongo_client
         self._mongo_database = self._mongo_client[self._options.database_name]
@@ -209,7 +214,8 @@ class MongoRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         entity = self._serializer.deserialize_from_text(json, self._get_entity_type())
         return entity
 
-    async def add_async(self, entity: TEntity) -> TEntity:
+    async def _do_add_async(self, entity: TEntity) -> TEntity:
+        """Template method implementation for adding an entity to MongoDB"""
         entity_id = self._get_id(entity)
         if entity_id is None:
             raise Exception(f"Cannot add {self._get_entity_type().__name__} without an ID")
@@ -220,7 +226,8 @@ class MongoRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         self._get_mongo_collection().insert_one(attributes_dictionary)
         return entity
 
-    async def update_async(self, entity: TEntity) -> TEntity:
+    async def _do_update_async(self, entity: TEntity) -> TEntity:
+        """Template method implementation for updating an entity in MongoDB"""
         entity_id = self._get_id(entity)
         if entity_id is None:
             raise Exception(f"Cannot update {self._get_entity_type().__name__} without an ID")
@@ -235,7 +242,8 @@ class MongoRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]
         self._get_mongo_collection().replace_one(query_filter, attributes_dictionary)
         return entity
 
-    async def remove_async(self, id: TKey) -> None:
+    async def _do_remove_async(self, id: TKey) -> None:
+        """Template method implementation for removing an entity from MongoDB"""
         if not await self.contains_async(id) is not None:
             raise Exception(f"Failed to find a {self._get_entity_type().__name__} with the specified id '{id}'")
         self._get_mongo_collection().delete_one({"id": id})

{neuroglia_python-0.6.12 → neuroglia_python-0.6.14}/src/neuroglia/data/queryable.py

@@ -4,7 +4,7 @@ import os
 from abc import ABC, abstractclassmethod
 from ast import Attribute, Name, NodeTransformer, expr
 from collections.abc import Callable
-from typing import Any, Generic, Optional, TypeVar
+from typing import Any, Generic, List, Optional, TypeVar
 
 T = TypeVar("T")
 """ Represents the type of data associated to a queryable """