venv added, updated

myenv/lib/python3.12/site-packages/reactivex/observer/__init__.py

@@ -0,0 +1,6 @@
+from .autodetachobserver import AutoDetachObserver
+from .observeonobserver import ObserveOnObserver
+from .observer import Observer
+from .scheduledobserver import ScheduledObserver
+
+__all__ = ["AutoDetachObserver", "ObserveOnObserver", "Observer", "ScheduledObserver"]

myenv/lib/python3.12/site-packages/reactivex/observer/autodetachobserver.py

@@ -0,0 +1,65 @@
+from typing import Optional, TypeVar
+
+from reactivex.disposable import SingleAssignmentDisposable
+from reactivex.internal import default_error, noop
+
+from .. import abc, typing
+
+_T_in = TypeVar("_T_in", contravariant=True)
+
+
+class AutoDetachObserver(abc.ObserverBase[_T_in]):
+    def __init__(
+        self,
+        on_next: Optional[typing.OnNext[_T_in]] = None,
+        on_error: Optional[typing.OnError] = None,
+        on_completed: Optional[typing.OnCompleted] = None,
+    ) -> None:
+        self._on_next = on_next or noop
+        self._on_error = on_error or default_error
+        self._on_completed = on_completed or noop
+
+        self._subscription = SingleAssignmentDisposable()
+        self.is_stopped = False
+
+    def on_next(self, value: _T_in) -> None:
+        if self.is_stopped:
+            return
+        self._on_next(value)
+
+    def on_error(self, error: Exception) -> None:
+        if self.is_stopped:
+            return
+        self.is_stopped = True
+
+        try:
+            self._on_error(error)
+        finally:
+            self.dispose()
+
+    def on_completed(self) -> None:
+        if self.is_stopped:
+            return
+        self.is_stopped = True
+
+        try:
+            self._on_completed()
+        finally:
+            self.dispose()
+
+    def set_disposable(self, value: abc.DisposableBase) -> None:
+        self._subscription.disposable = value
+
+    subscription = property(fset=set_disposable)
+
+    def dispose(self) -> None:
+        self.is_stopped = True
+        self._subscription.dispose()
+
+    def fail(self, exn: Exception) -> bool:
+        if self.is_stopped:
+            return False
+
+        self.is_stopped = True
+        self._on_error(exn)
+        return True

myenv/lib/python3.12/site-packages/reactivex/observer/observeonobserver.py

@@ -0,0 +1,19 @@
+from typing import TypeVar
+
+from .scheduledobserver import ScheduledObserver
+
+_T = TypeVar("_T")
+
+
+class ObserveOnObserver(ScheduledObserver[_T]):
+    def _on_next_core(self, value: _T) -> None:
+        super()._on_next_core(value)
+        self.ensure_active()
+
+    def _on_error_core(self, error: Exception) -> None:
+        super()._on_error_core(error)
+        self.ensure_active()
+
+    def _on_completed_core(self) -> None:
+        super()._on_completed_core()
+        self.ensure_active()

myenv/lib/python3.12/site-packages/reactivex/observer/observer.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Optional, TypeVar
+
+from reactivex import abc
+from reactivex.internal.basic import default_error, noop
+from reactivex.typing import OnCompleted, OnError, OnNext
+
+_T_in = TypeVar("_T_in", contravariant=True)
+
+if TYPE_CHECKING:
+    from reactivex.notification import Notification
+else:
+
+    class Notification:
+        pass
+
+
+class Observer(abc.ObserverBase[_T_in], abc.DisposableBase):
+    """Base class for implementations of the Observer class. This base
+    class enforces the grammar of observers where OnError and
+    OnCompleted are terminal messages.
+    """
+
+    def __init__(
+        self,
+        on_next: Optional[OnNext[_T_in]] = None,
+        on_error: Optional[OnError] = None,
+        on_completed: Optional[OnCompleted] = None,
+    ) -> None:
+        self.is_stopped = False
+        self._handler_on_next: OnNext[_T_in] = on_next or noop
+        self._handler_on_error: OnError = on_error or default_error
+        self._handler_on_completed: OnCompleted = on_completed or noop
+
+    def on_next(self, value: _T_in) -> None:
+        """Notify the observer of a new element in the sequence."""
+        if not self.is_stopped:
+            self._on_next_core(value)
+
+    def _on_next_core(self, value: _T_in) -> None:
+        """For Subclassing purpose. This method is called by `on_next()`
+        method until the observer is stopped.
+        """
+        self._handler_on_next(value)
+
+    def on_error(self, error: Exception) -> None:
+        """Notify the observer that an exception has occurred.
+
+        Args:
+            error: The error that occurred.
+        """
+
+        if not self.is_stopped:
+            self.is_stopped = True
+            self._on_error_core(error)
+
+    def _on_error_core(self, error: Exception) -> None:
+        """For Subclassing purpose. This method is called by `on_error()`
+        method until the observer is stopped.
+        """
+        self._handler_on_error(error)
+
+    def on_completed(self) -> None:
+        """Notifies the observer of the end of the sequence."""
+
+        if not self.is_stopped:
+            self.is_stopped = True
+            self._on_completed_core()
+
+    def _on_completed_core(self) -> None:
+        """For Subclassing purpose. This method is called by `on_completed()`
+        method until the observer is stopped.
+        """
+        self._handler_on_completed()
+
+    def dispose(self) -> None:
+        """Disposes the observer, causing it to transition to the
+        stopped state."""
+        self.is_stopped = True
+
+    def fail(self, exn: Exception) -> bool:
+        if not self.is_stopped:
+            self.is_stopped = True
+            self._on_error_core(exn)
+            return True
+
+        return False
+
+    def throw(self, error: Exception) -> None:
+        import traceback
+
+        traceback.print_stack()
+        raise error
+
+    def to_notifier(self) -> Callable[[Notification[_T_in]], None]:
+        """Creates a notification callback from an observer.
+
+        Returns the action that forwards its input notification to the
+        underlying observer."""
+
+        def func(notifier: Notification[_T_in]) -> None:
+            return notifier.accept(self)
+
+        return func
+
+    def as_observer(self) -> abc.ObserverBase[_T_in]:
+        """Hides the identity of an observer.
+
+        Returns an observer that hides the identity of the specified
+        observer.
+        """
+        return Observer(self.on_next, self.on_error, self.on_completed)

myenv/lib/python3.12/site-packages/reactivex/observer/scheduledobserver.py

@@ -0,0 +1,81 @@
+import threading
+from typing import Any, List, TypeVar
+
+from reactivex import abc, typing
+from reactivex.disposable import SerialDisposable
+
+from .observer import Observer
+
+_T_in = TypeVar("_T_in", contravariant=True)
+
+
+class ScheduledObserver(Observer[_T_in]):
+    def __init__(
+        self, scheduler: abc.SchedulerBase, observer: abc.ObserverBase[_T_in]
+    ) -> None:
+        super().__init__()
+
+        self.scheduler = scheduler
+        self.observer = observer
+
+        self.lock = threading.RLock()
+        self.is_acquired = False
+        self.has_faulted = False
+        self.queue: List[typing.Action] = []
+        self.disposable = SerialDisposable()
+
+        # Note to self: list append is thread safe
+        # http://effbot.org/pyfaq/what-kinds-of-global-value-mutation-are-thread-safe.htm
+
+    def _on_next_core(self, value: Any) -> None:
+        def action() -> None:
+            self.observer.on_next(value)
+
+        self.queue.append(action)
+
+    def _on_error_core(self, error: Exception) -> None:
+        def action() -> None:
+            self.observer.on_error(error)
+
+        self.queue.append(action)
+
+    def _on_completed_core(self) -> None:
+        def action() -> None:
+            self.observer.on_completed()
+
+        self.queue.append(action)
+
+    def ensure_active(self) -> None:
+        is_owner = False
+
+        with self.lock:
+            if not self.has_faulted and self.queue:
+                is_owner = not self.is_acquired
+                self.is_acquired = True
+
+        if is_owner:
+            self.disposable.disposable = self.scheduler.schedule(self.run)
+
+    def run(self, scheduler: abc.SchedulerBase, state: Any) -> None:
+        parent = self
+
+        with self.lock:
+            if parent.queue:
+                work = parent.queue.pop(0)
+            else:
+                parent.is_acquired = False
+                return
+
+        try:
+            work()
+        except Exception:
+            with self.lock:
+                parent.queue = []
+                parent.has_faulted = True
+            raise
+
+        self.scheduler.schedule(self.run)
+
+    def dispose(self) -> None:
+        super().dispose()
+        self.disposable.dispose()