@camera.ui/server 0.0.69 → 0.0.71-dev.0

package/dist/server/src/_camera_ui_tools/camera_ui_common/__init__.py

@@ -1,16 +1,24 @@
-from .camera_utils.utils import build_target_url
-from .common_utils.object_path import ObjectPath, Path
-from .common_utils.reactive import ReactiveProperty
-from .common_utils.signal_handler import SignalHandler, SignalHandlerOptions
-from .common_utils.subscribed import Subscribed
-from .common_utils.task import TaskSet
-from .common_utils.thread import to_thread
-from .common_utils.utils import make_sync, merge, merge_with
-from .logger_service.ansicolor import Ansicolor
-from .logger_service.logger import LoggerOptions, LoggerService
+# Common Utilities
+from .common_utils import (
+    Deferred,
+    ObjectPath,
+    Path,
+    ReactiveProperty,
+    SignalHandler,
+    SignalHandlerOptions,
+    Subscribed,
+    TaskSet,
+    make_sync,
+    merge,
+    merge_with,
+    to_thread,
+)
+
+# Logger Service
+from .logger_service import Ansicolor, LoggerOptions, LoggerService
 
 __all__ = [
-    "build_target_url",
+    "Deferred",
     "ObjectPath",
     "Path",
     "SignalHandler",

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/__init__.py

@@ -0,0 +1,23 @@
+from .object_path import ObjectPath, Path
+from .promise import Deferred
+from .reactive import ReactiveProperty
+from .signal_handler import SignalHandler, SignalHandlerOptions
+from .subscribed import Subscribed
+from .task import TaskSet
+from .thread import to_thread
+from .utils import make_sync, merge, merge_with
+
+__all__ = [
+    "Deferred",
+    "make_sync",
+    "merge",
+    "merge_with",
+    "ObjectPath",
+    "Path",
+    "ReactiveProperty",
+    "SignalHandler",
+    "SignalHandlerOptions",
+    "Subscribed",
+    "TaskSet",
+    "to_thread",
+]

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/object_path.py

@@ -1,17 +1,22 @@
+"""Object path utilities for nested object access."""
+
+from __future__ import annotations
+
 from collections.abc import Sequence
-from typing import Any, Optional, TypeVar, Union, cast
+from typing import Any, cast
 
-Path = Union[Sequence[Union[int, str]], str, int]
-T = TypeVar("T")
+Path = Sequence[int | str] | str | int
 
 
 def is_empty(value: list[int] | list[str] | Sequence[int | str] | None) -> bool:
+    """Check if a sequence is empty or None."""
     if value is None:
         return True
     return len(value) == 0
 
 
-def get_key(key: Union[str, int]) -> Union[int, str]:
+def get_key(key: str | int) -> int | str:
+    """Convert a string key to int if it's a digit."""
     if isinstance(key, int):
         return key
     if key.isdigit():
@@ -20,8 +25,11 @@ def get_key(key: Union[str, int]) -> Union[int, str]:
 
 
 class ObjectPath:
+    """Utility class for accessing and modifying nested objects."""
+
     @staticmethod
-    def delete(obj: Union[dict[Any, Any], list[Any]], path: Path) -> Union[dict[Any, Any], list[Any]]:
+    def delete(obj: dict[Any, Any] | list[Any], path: Path) -> dict[Any, Any] | list[Any]:
+        """Delete a value at the specified path."""
         if isinstance(path, int):
             path = [path]
         elif isinstance(path, str):
@@ -51,7 +59,8 @@ class ObjectPath:
         return obj
 
     @staticmethod
-    def has(obj: Union[dict[Any, Any], list[Any]], path: Path) -> bool:
+    def has(obj: dict[Any, Any] | list[Any], path: Path) -> bool:
+        """Check if a path exists in the object."""
         if isinstance(path, int):
             path = [path]
         elif isinstance(path, str):
@@ -60,12 +69,12 @@ class ObjectPath:
         if not path:
             return bool(obj)
 
-        current: Any = obj
+        current: dict[Any, Any] | list[Any] | None = obj
         for item in path:
             key = get_key(item)
 
             if isinstance(current, list):
-                if isinstance(key, int) and 0 <= key < len(cast(list[str], current)):
+                if isinstance(key, int) and 0 <= key < len(current):
                     current = current[key]
                 else:
                     return False
@@ -80,18 +89,18 @@ class ObjectPath:
         return True
 
     @staticmethod
-    def get(obj: Union[dict[Any, Any], list[Any]], path: Path, default_value: Any = None) -> Any:
-        # Handle leere Pfade
+    def get(obj: dict[Any, Any] | list[Any], path: Path, default_value: Any = None) -> Any:
+        """Get a value at the specified path."""
+        # Handle empty paths
         if isinstance(path, str) and not path or isinstance(path, Sequence) and not path:
             return obj
 
-        # Konvertiere einzelne Zahlen oder Strings in eine Liste
+        # Convert single numbers or strings to a list
         if isinstance(path, int):
             path = [path]
         elif isinstance(path, str):
             path = path.split(".")
 
-        # Ab hier wie gehabt
         current_path = get_key(path[0])
         next_obj = None
 
@@ -110,9 +119,8 @@ class ObjectPath:
         return ObjectPath.get(next_obj, path[1:], default_value)
 
     @staticmethod
-    def set(
-        obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any, do_not_replace: bool = False
-    ) -> Any:
+    def set(obj: dict[Any, Any] | list[Any], path: Path, value: Any, do_not_replace: bool = False) -> Any:
+        """Set a value at the specified path."""
         if isinstance(path, int):
             path = [path]
         elif isinstance(path, str):
@@ -147,7 +155,8 @@ class ObjectPath:
         return ObjectPath.set(obj[current_path], path[1:], value, do_not_replace)
 
     @staticmethod
-    def push(obj: Union[dict[Any, Any], list[Any]], path: Path, *items: Any) -> None:
+    def push(obj: dict[Any, Any] | list[Any], path: Path, *items: Any) -> None:
+        """Push items to an array at the specified path."""
         target = ObjectPath.get(obj, path)
         if not isinstance(target, list):
             target = []
@@ -156,10 +165,11 @@ class ObjectPath:
 
     @staticmethod
     def coalesce(
-        obj: Union[dict[Any, Any], list[Any]],
-        paths: Union[Path, list[Path]],
-        default_value: Optional[Any] = None,
+        obj: dict[Any, Any] | list[Any],
+        paths: Path | list[Path],
+        default_value: Any = None,
     ) -> Any:
+        """Return the first non-None value from the specified paths."""
         paths_list = paths if isinstance(paths, list) else [paths]
         for path in paths_list:
             value = ObjectPath.get(obj, path)
@@ -168,7 +178,8 @@ class ObjectPath:
         return default_value
 
     @staticmethod
-    def empty(obj: Union[dict[Any, Any], list[Any]], path: Path) -> Any:
+    def empty(obj: dict[Any, Any] | list[Any], path: Path) -> Any:
+        """Empty the value at the specified path."""
         value = ObjectPath.get(obj, path)
 
         if value is None:
@@ -186,11 +197,13 @@ class ObjectPath:
         return ObjectPath.set(obj, path, None)
 
     @staticmethod
-    def ensure_exists(obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any) -> Any:
+    def ensure_exists(obj: dict[Any, Any] | list[Any], path: Path, value: Any) -> Any:
+        """Ensure a value exists at the specified path."""
         return ObjectPath.set(obj, path, value, True)
 
     @staticmethod
-    def insert(obj: Union[dict[Any, Any], list[Any]], path: Path, value: Any, at: int = 0) -> None:
+    def insert(obj: dict[Any, Any] | list[Any], path: Path, value: Any, at: int = 0) -> None:
+        """Insert a value into an array at the specified path."""
         target = ObjectPath.get(obj, path)
         if not isinstance(target, list):
             target = []

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/promise.py

@@ -0,0 +1,41 @@
+"""Promise/Deferred utilities for async operations."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class Deferred(Generic[T]):
+    """A deferred promise that can be resolved or rejected externally."""
+
+    def __init__(self) -> None:
+        self._loop = asyncio.get_event_loop()
+        self._future: asyncio.Future[T] = self._loop.create_future()
+
+    @property
+    def promise(self) -> asyncio.Future[T]:
+        """The underlying future/promise."""
+        return self._future
+
+    @property
+    def is_done(self) -> bool:
+        """Whether the deferred has been resolved or rejected."""
+        return self._future.done()
+
+    def resolve(self, value: T) -> None:
+        """Resolve the deferred with a value."""
+        if not self._future.done():
+            self._future.set_result(value)
+
+    def reject(self, reason: Exception | None = None) -> None:
+        """Reject the deferred with an exception."""
+        if not self._future.done():
+            self._future.set_exception(reason or Exception("Rejected"))
+
+    def cancel(self, reason: str = "Cancelled") -> None:
+        """Cancel the deferred."""
+        if not self._future.done():
+            self._future.set_exception(asyncio.CancelledError(reason))

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/reactive.py

@@ -1,20 +1,24 @@
+"""Reactive property utilities."""
+
+from __future__ import annotations
+
 from copy import deepcopy
-from typing import Generic, Optional, TypeVar, Union, cast
+from typing import Generic, TypeVar, cast
 
-from camera_ui_python_types.hybrid_observer import HybridObservable
-from reactivex import operators as ops
-from reactivex.subject import BehaviorSubject
+from camera_ui_sdk import BehaviorSubject, Observable, ReplaySubject, distinct_until_changed, share
 
 T = TypeVar("T")
 
 
 class ReactiveProperty(Generic[T]):
+    """A reactive property that wraps a BehaviorSubject with observable access."""
+
     __subject: BehaviorSubject[T]
-    observable: HybridObservable[T]
+    observable: Observable[T]
 
     def __init__(
-        self, initial_value: Union[T, BehaviorSubject[T]], observable: Optional[HybridObservable[T]] = None
-    ):
+        self, initial_value: T | BehaviorSubject[T], observable: Observable[T] | None = None
+    ) -> None:
         if isinstance(initial_value, BehaviorSubject):
             self.__subject = cast(BehaviorSubject[T], initial_value)
         else:
@@ -26,17 +30,16 @@ class ReactiveProperty(Generic[T]):
     def value(self) -> T:
         val = self.__subject.value
 
-        if isinstance(val, (dict, list)) or hasattr(val, "__dict__"):
-            val = cast(T, val)
-            return deepcopy(val)
+        if isinstance(val, dict | list) or hasattr(val, "__dict__"):
+            return deepcopy(val)  # pyright: ignore[reportUnknownVariableType, reportUnknownArgumentType]
 
         return val
 
     def next(self, value: T) -> None:
-        self.__subject.on_next(value)
+        self.__subject.next(value)
 
     def complete(self) -> None:
-        self.__subject.on_completed()
+        self.__subject.complete()
 
-    def __create_state_observable(self, state_subject: BehaviorSubject[T]) -> HybridObservable[T]:
-        return HybridObservable(state_subject.pipe(ops.distinct_until_changed(), ops.share()))
+    def __create_state_observable(self, state_subject: BehaviorSubject[T]) -> Observable[T]:
+        return state_subject.pipe(distinct_until_changed(), share(lambda: ReplaySubject(1)))

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/signal_handler.py

@@ -1,14 +1,20 @@
+"""Signal handling utilities for graceful shutdown."""
+
+from __future__ import annotations
+
 import asyncio
 import contextlib
 import signal
 import traceback
-from collections.abc import Coroutine
-from typing import Any, Callable, TypedDict
+from collections.abc import Callable, Coroutine
+from typing import Any, TypedDict
 
-from camera_ui_python_types import LoggerService
+from camera_ui_sdk import LoggerService
 
 
 class SignalHandlerOptions(TypedDict):
+    """Options for configuring the signal handler."""
+
     display_name: str
     logger: LoggerService
     timeout_duration: int
@@ -16,6 +22,8 @@ class SignalHandlerOptions(TypedDict):
 
 
 class SignalHandler:
+    """Handles system signals for graceful shutdown."""
+
     display_name: str
     logger: LoggerService
     timeout_duration: int
@@ -23,7 +31,7 @@ class SignalHandler:
     is_shutting_down: bool
     shutdown_event: asyncio.Event
 
-    def __init__(self, options: SignalHandlerOptions):
+    def __init__(self, options: SignalHandlerOptions) -> None:
         self.display_name: str = options["display_name"]
         self.logger = options["logger"]
         self.timeout_duration = options.get("timeout_duration", 5)

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/subscribed.py

@@ -1,11 +1,22 @@
-from typing import Protocol
+"""Subscription management utilities."""
 
+from __future__ import annotations
 
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
 class Unsubscribable(Protocol):
-    def dispose(self) -> None: ...
+    """Protocol for objects that can be disposed/unsubscribed."""
+
+    def dispose(self) -> None:
+        """Dispose of the subscription."""
+        ...
 
 
 class Subscribed:
+    """Base class for managing subscriptions."""
+
     _subscriptions: list[Unsubscribable]
     _additional_subscriptions: list[Unsubscribable]
 
@@ -14,8 +25,10 @@ class Subscribed:
         self._additional_subscriptions = []
 
     def add_subscriptions(self, *subscriptions: Unsubscribable) -> None:
+        """Add subscriptions to be managed."""
         self._subscriptions.extend(subscriptions)
 
     def unsubscribe(self) -> None:
+        """Dispose all managed subscriptions."""
         for subscription in self._subscriptions:
             subscription.dispose()

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/task.py

@@ -1,13 +1,19 @@
+"""Task set utilities for managing async tasks."""
+
+from __future__ import annotations
+
 import asyncio
 from collections.abc import Coroutine
-from typing import Any, Optional
+from typing import Any
 
 
 class TaskSet:
+    """A set of async tasks that can be managed together."""
+
     tasks: set[asyncio.Task[Any]]
-    name: Optional[str]
+    name: str | None
 
-    def __init__(self, name: Optional[str] = None) -> None:
+    def __init__(self, name: str | None = None) -> None:
         self.tasks = set[asyncio.Task[Any]]()
         self.name = name
 

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/thread.py

@@ -1,10 +1,18 @@
+"""Thread utilities for running blocking operations."""
+
+from __future__ import annotations
+
 import asyncio
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any
+from typing import TypeVar
+
+T = TypeVar("T")
 
 toThreadExecutor: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="worker")
 
 
-async def to_thread(f: Any) -> Any:
+async def to_thread(f: Callable[[], T]) -> T:
+    """Run a blocking function in a thread pool."""
     loop = asyncio.get_running_loop()
     return await loop.run_in_executor(toThreadExecutor, f)

package/dist/server/src/_camera_ui_tools/camera_ui_common/common_utils/utils.py

@@ -1,11 +1,15 @@
+"""Common utility functions."""
+
+from __future__ import annotations
+
 import asyncio
 import copy
-from collections.abc import Coroutine
-from typing import Any, Callable, Optional, ParamSpec, TypeVar, Union, cast
+from collections.abc import Callable, Coroutine
+from typing import Any, ParamSpec, TypeVar, cast
 
-TSource = TypeVar("TSource", bound=Union[dict[Any, Any], list[Any], Any])
-TTarget = TypeVar("TTarget", bound=Union[dict[Any, Any], list[Any], Any])
-TKey = Union[str, int, None]
+TSource = TypeVar("TSource", bound=dict[Any, Any] | list[Any] | Any)
+TTarget = TypeVar("TTarget", bound=dict[Any, Any] | list[Any] | Any)
+TKey = str | int | None
 Customizer = Callable[[Any, Any, TKey, TSource, TTarget, list[dict[Any, Any]]], Any]
 
 R = TypeVar("R")
@@ -13,6 +17,8 @@ P = ParamSpec("P")
 
 
 def make_sync(async_func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, R]:
+    """Convert an async function to a sync function."""
+
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         try:
             loop = asyncio.get_running_loop()
@@ -27,10 +33,11 @@ def make_sync(async_func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, R]
 
 def merge_with(
     source_object: TSource,
-    target_object: Optional[TTarget],
-    customizer: Optional[Customizer[Any, Any]] = None,
-    stack: Optional[list[dict[Any, Any]]] = None,
-) -> Union[TSource, TTarget]:
+    target_object: TTarget | None,
+    customizer: Customizer[Any, Any] | None = None,
+    stack: list[dict[Any, Any]] | None = None,
+) -> TSource | TTarget:
+    """Merge target_object into source_object with optional customizer."""
     if stack is None:
         stack = []
 
@@ -41,9 +48,9 @@ def merge_with(
             else None
         )
         if customized_value is not None:
-            return cast(Union[TSource, TTarget], customized_value)
+            return cast(TSource | TTarget, customized_value)
         else:
-            return cast(Union[TSource, TTarget], source_object + target_object)
+            return cast(TSource | TTarget, source_object + target_object)
 
     if isinstance(source_object, dict) and isinstance(target_object, dict):
         for key in target_object:
@@ -82,10 +89,11 @@ def merge(
     source: Any,
     target: Any,
     key: TKey,
-    source_object: Union[dict[Any, Any], list[Any], Any],  # TSource
-    target_object: Union[dict[Any, Any], list[Any], Any],  # TTarget
+    source_object: dict[Any, Any] | list[Any] | Any,
+    target_object: dict[Any, Any] | list[Any] | Any,
     stack: list[Any],
 ) -> Any:
+    """Default merge customizer that replaces lists instead of concatenating."""
     if isinstance(source, list):
         return target
     return None

package/dist/server/src/_camera_ui_tools/camera_ui_common/logger_service/__init__.py

@@ -0,0 +1,8 @@
+from .ansicolor import Ansicolor
+from .logger import LoggerOptions, LoggerService
+
+__all__ = [
+    "Ansicolor",
+    "LoggerOptions",
+    "LoggerService",
+]