vortexpy 4.0.7__tar.gz → 4.0.10__tar.gz

{vortexpy-4.0.7 → vortexpy-4.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vortexpy
-Version: 4.0.7
+Version: 4.0.10
 Summary: Synertys observable, routable, data serialisation and transport code.
 Author-email: Synerty <contact@synerty.com>
 Project-URL: Homepage, https://github.com/Synerty/vortexpy

{vortexpy-4.0.7 → vortexpy-4.0.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.0.7"
+version = "4.0.10"
 authors = [{name = "Synerty", email = "contact@synerty.com"}]
 description = "Synertys observable, routable, data serialisation and transport code."
 keywords = [

{vortexpy-4.0.7 → vortexpy-4.0.10}/vortex/__init__.py

@@ -7,4 +7,4 @@
  * Support : support@synerty.com
 """
 
-__version__ = '4.0.7'
+__version__ = '4.0.10'

vortexpy-4.0.10/vortex/event_bus/TupleChangeEventABC.py

@@ -0,0 +1,15 @@
+import json
+from abc import ABCMeta
+
+
+class TupleChangeEventABC(metaclass=ABCMeta):
+    __eventType__ = None
+
+    @classmethod
+    def eventType(cls) -> str:
+        return cls.__eventType__
+
+    def __repr__(self):
+        return json.dumps(
+            {"class": self.__class__.__name__, "fields": self.__dict__}
+        )

{vortexpy-4.0.7/vortex/handler → vortexpy-4.0.10/vortex/event_bus}/TupleChangeEventBus.py

@@ -8,12 +8,9 @@ import pytz
 from twisted.internet import reactor
 from twisted.internet.defer import inlineCallbacks
 
-from vortex.Tuple import Tuple
-from vortex.TupleSelector import (
-    TupleSelector,
-    InvalidTupleSelectorNameException,
-)
-from vortex.handler.TupleChangeEventBusObserverABC import (
+from vortex.TupleSelector import TupleSelector
+from vortex.event_bus.TupleChangeEventABC import TupleChangeEventABC
+from vortex.event_bus.TupleChangeEventBusObserverABC import (
     TupleChangeEventBusObserverABC,
 )
 
@@ -22,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 class TupleChangeEventBus:
     def __init__(self):
-        self._weakObserversForAllTupleSelectorNames: WeakSet[
+        self._weakObserversForAllTupleChangeEventABCNames: WeakSet[
             TupleChangeEventBusObserverABC
         ] = WeakSet([])
 
@@ -30,11 +27,11 @@ class TupleChangeEventBus:
             str, WeakSet[TupleChangeEventBusObserverABC]
         ] = defaultdict(lambda: WeakSet([]))
 
-    def notifyMany(self, tupleSelectors: list[TupleSelector]) -> None:
-        for tupleSelector in tupleSelectors:
-            self.notify(tupleSelector)
+    def notifyMany(self, events: list[TupleChangeEventABC]) -> None:
+        for event in events:
+            self.notify(event)
 
-    def notify(self, tupleSelector: TupleSelector) -> None:
+    def notify(self, event: TupleChangeEventABC) -> None:
         """
         Notify
 
@@ -49,7 +46,8 @@ class TupleChangeEventBus:
         however, see best practices.
 
         BEST PRACTICE: Only notify the bus of precisely
-        the data that has changed, as close to the code that changes it as possible.
+        the data that has changed, as close to the code that changes it as
+         possible.
 
         Do not notify the bus of tuple selectors that need updating.
 
@@ -60,8 +58,8 @@ class TupleChangeEventBus:
 
         For example. If you have two tuple selectors:
 
-        1) TupleSelector(MyTuple, {id:1})
-        2) TupleSelector(ListOfMyTuples)
+        1) TupleChangeEventABC(MyTuple, {id:1})
+        2) TupleChangeEventABC(ListOfMyTuples)
 
         TupleChangeEventBus.notify should be called for MyTuple
         just after changes are committed.
@@ -72,11 +70,11 @@ class TupleChangeEventBus:
         A typical observer's method might look like this:
 
         ```python
-            def notifyFromBus(self, tupleSelector: TupleSelector) -> None:
-                if tupleSelector.isForTuple(MyTuple):
-                    self.tupleDataObservable.notifyOfTupleUpdate(tupleSelector)
+            def notifyFromBus(self, event: TupleChangeEventABC) -> None:
+                if event.isForTuple(MyTuple):
+                    self.tupleDataObservable.notifyOfTupleUpdate(event)
                     self.tupleDataObservable.notifyOfTupleUpdate(
-                        TupleSelector(ListOfMyTuples)
+                        TupleChangeEventABC(ListOfMyTuples)
                     )
                     return
 
@@ -84,73 +82,111 @@ class TupleChangeEventBus:
 
         ```
 
-        :param tupleSelector: The tuple selector that describes the tuple
+        :param event: The tuple selector that describes the tuple
         that has been changed. This change might be created, updated, or
         deleted.
         :return:
         """
-        weakSets = [self._weakObserversForAllTupleSelectorNames]
+        weakSets = [self._weakObserversForAllTupleChangeEventABCNames]
 
-        if tupleSelector.name in self._weakObserversBySelectorName:
-            weakSets.append(
-                self._weakObserversBySelectorName[tupleSelector.name]
-            )
+        eventName = event.eventType()
+
+        if eventName in self._weakObserversBySelectorName:
+            weakSets.append(list(self._weakObserversBySelectorName[eventName]))
 
         for weakSet in weakSets:
             for item in weakSet:
                 if not item:
                     continue
 
-                reactor.callLater(0, self._notify, item, tupleSelector)
+                # noinspection PyUnresolvedReferences
+                reactor.callLater(0, self._notify, item, event)
 
     @inlineCallbacks
-    def _notify(self, observable, tupleSelector):
+    def _notify(
+        self,
+        observable: TupleChangeEventBusObserverABC,
+        event: TupleChangeEventABC,
+    ):
         try:
             startDate = datetime.now(pytz.utc)
-            yield observable.notifyFromBus(tupleSelector)
+            yield observable.notifyFromBus(event)
 
             # A blocking call taking more than 100ms is BAD
             # Otherwise a call taking more than a 1s is just poor performance.
             secondsTaken = (datetime.now(pytz.utc) - startDate).total_seconds()
             if 0.1 < secondsTaken:
                 logger.debug(
-                    "notifyFromBus took %s for %s, tupleSelector %s",
+                    "notifyFromBus took %s for %s, event %s",
                     secondsTaken,
                     observable.__class__.__name__,
-                    tupleSelector.toJsonStr(),
+                    event,
                 )
 
         except Exception as e:
             logger.error(
-                "Observable %s raised an error when being called with tupleSelector %s",
+                "Observable %s raised an error"
+                " when being called with event %s",
                 observable.__class__.__name__,
-                tupleSelector,
+                event,
             )
             logger.exception(e)
 
     def addObserver(
         self,
         observer: TupleChangeEventBusObserverABC,
-        tupleSelectorNameOrClass: Optional[
-            Union[str, Type[Tuple], Tuple]
+        eventNameOrClass: Optional[
+            Union[
+                str,
+                Type[TupleChangeEventABC],
+                TupleChangeEventABC,
+            ]
         ] = None,
     ) -> None:
         assert isinstance(
             observer, TupleChangeEventBusObserverABC
         ), "observer must be a TupleChangeEventBusObserverABC"
 
-        if tupleSelectorNameOrClass is None:
-            self._weakObserversForAllTupleSelectorNames.add(observer)
+        if eventNameOrClass is None:
+            self._weakObserversForAllTupleChangeEventABCNames.add(observer)
             return
 
-        try:
-            tupleSelectorName = TupleSelector.nameFromTuple(
-                tupleSelectorNameOrClass
+        eventName = self._nameFromEvent(eventNameOrClass)
+
+        self._weakObserversBySelectorName[eventName].add(observer)
+
+    # noinspection PyMethodMayBeStatic
+    def _nameFromEvent(
+        self,
+        nameOrTuple: Optional[
+            Union[str, Type[TupleChangeEventABC], TupleChangeEventABC]
+        ],
+    ) -> Optional[str]:
+        # When the TupleSelector is reconstructed / deserialize,
+        # it's constructed with
+        # no arguments
+        if nameOrTuple is None:
+            return None
+
+        if isinstance(nameOrTuple, str):
+            name = nameOrTuple
+
+        elif isinstance(nameOrTuple, TupleChangeEventABC):
+            name = nameOrTuple.eventType()
+
+        elif issubclass(nameOrTuple, TupleChangeEventABC):
+            name = nameOrTuple.eventType()
+
+        else:
+            raise Exception(
+                "Argument should be of type "
+                "Union[str, Type[TupleChangeEventABC], TupleChangeEventABC]"
             )
-        except InvalidTupleSelectorNameException:
+
+        if name == TupleSelector.tupleName():
             raise Exception(
-                "tupleSelectorNameOrClass is not valid."
-                " Maybe you need to add __tupleType__ to your custom TupleSelector class."
+                "We've found the name of TupleSelector.tupleType(),"
+                "which means we've been passed a TupleSelector."
             )
 
-        self._weakObserversBySelectorName[tupleSelectorName].add(observer)
+        return name

vortexpy-4.0.10/vortex/event_bus/TupleChangeEventBusObserverABC.py

@@ -0,0 +1,11 @@
+from abc import ABCMeta, abstractmethod
+
+from vortex.event_bus.TupleChangeEventABC import TupleChangeEventABC
+
+
+class TupleChangeEventBusObserverABC(metaclass=ABCMeta):
+    @abstractmethod
+    def notifyFromBus(self, event: TupleChangeEventABC) -> None:
+        raise NotImplementedError(
+            "TupleChangeEventBusObserverABC.notifyFromBus"
+        )

{vortexpy-4.0.7 → vortexpy-4.0.10}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vortexpy
-Version: 4.0.7
+Version: 4.0.10
 Summary: Synertys observable, routable, data serialisation and transport code.
 Author-email: Synerty <contact@synerty.com>
 Project-URL: Homepage, https://github.com/Synerty/vortexpy

{vortexpy-4.0.7 → vortexpy-4.0.10}/vortexpy.egg-info/SOURCES.txt

@@ -52,11 +52,13 @@ vortex/data_loader/TupleDataLoaderDelegate.py
 vortex/data_loader/TupleDataLoaderTupleABC.py
 vortex/data_loader/TupleDataLoaderTuples.py
 vortex/data_loader/__init__.py
+vortex/event_bus/TupleChangeEventABC.py
+vortex/event_bus/TupleChangeEventBus.py
+vortex/event_bus/TupleChangeEventBusObserverABC.py
+vortex/event_bus/__init__.py
 vortex/handler/TupleActionProcessor.py
 vortex/handler/TupleActionProcessorProxy.py
 vortex/handler/TupleActionProcessorTestHandler.py
-vortex/handler/TupleChangeEventBus.py
-vortex/handler/TupleChangeEventBusObserverABC.py
 vortex/handler/TupleDataActionClient.py
 vortex/handler/TupleDataObservableCache.py
 vortex/handler/TupleDataObservableHandler.py

vortexpy-4.0.7/vortex/handler/TupleChangeEventBusObserverABC.py

@@ -1,12 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-from vortex.TupleSelector import TupleSelector
-
-
-class TupleChangeEventBusObserverABC(metaclass=ABCMeta):
-    @abstractmethod
-    def notifyFromBus(
-        self,
-        tupleSelector: TupleSelector,
-    ) -> None:
-        pass

{vortexpy-4.0.7 → vortexpy-4.0.10}/vortex/TupleSelector.py

@@ -52,10 +52,10 @@ class TupleSelector(Tuple):
         if isinstance(nameOrTuple, str):
             name = nameOrTuple
 
-        elif issubclass(nameOrTuple, Tuple):
+        elif isinstance(nameOrTuple, Tuple):
             name = nameOrTuple.tupleType()
 
-        elif isinstance(nameOrTuple, Tuple):
+        elif issubclass(nameOrTuple, Tuple):
             name = nameOrTuple.tupleType()
 
         else: