venv added, updated

myenv/lib/python3.12/site-packages/reactivex/observable/forkjoin.py

@@ -0,0 +1,72 @@
+from typing import Any, List, Optional, Tuple, cast
+
+from reactivex import Observable, abc
+from reactivex.disposable import CompositeDisposable, SingleAssignmentDisposable
+
+
+def fork_join_(*sources: Observable[Any]) -> Observable[Tuple[Any, ...]]:
+    """Wait for observables to complete and then combine last values
+    they emitted into a tuple. Whenever any of that observables completes
+    without emitting any value, result sequence will complete at that moment as well.
+
+    Examples:
+        >>> obs = reactivex.fork_join(obs1, obs2, obs3)
+
+    Returns:
+        An observable sequence containing the result of combining last element from
+        each source in given sequence.
+    """
+
+    parent = sources[0]
+
+    def subscribe(
+        observer: abc.ObserverBase[Tuple[Any, ...]],
+        scheduler: Optional[abc.SchedulerBase] = None,
+    ) -> abc.DisposableBase:
+        n = len(sources)
+        values = [None] * n
+        is_done = [False] * n
+        has_value = [False] * n
+
+        def done(i: int) -> None:
+            is_done[i] = True
+
+            if not has_value[i]:
+                observer.on_completed()
+                return
+
+            if all(is_done):
+                if all(has_value):
+                    observer.on_next(tuple(values))
+                    observer.on_completed()
+                else:
+                    observer.on_completed()
+
+        subscriptions: List[SingleAssignmentDisposable] = [
+            cast(SingleAssignmentDisposable, None)
+        ] * n
+
+        def _subscribe(i: int) -> None:
+            subscriptions[i] = SingleAssignmentDisposable()
+
+            def on_next(value: Any) -> None:
+                with parent.lock:
+                    values[i] = value
+                    has_value[i] = True
+
+            def on_completed() -> None:
+                with parent.lock:
+                    done(i)
+
+            subscriptions[i].disposable = sources[i].subscribe(
+                on_next, observer.on_error, on_completed, scheduler=scheduler
+            )
+
+        for i in range(n):
+            _subscribe(i)
+        return CompositeDisposable(subscriptions)
+
+    return Observable(subscribe)
+
+
+__all__ = ["fork_join_"]