@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/rpc.py

@@ -0,0 +1,177 @@
+import inspect
+from collections.abc import Mapping
+from functools import wraps
+from typing import Any, Callable, Literal, TypedDict, cast
+
+
+class RPCMetadata(TypedDict):
+    name: str
+    type: Literal["async", "asyncGenerator"]
+
+
+class RPCMethod(RPCMetadata):
+    public: bool
+    method: Callable[..., Any]
+
+
+def rpc(public: bool = True, name: str | None = None) -> Callable[..., Any]:
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        is_async_gen = inspect.isasyncgenfunction(func)
+        is_gen = inspect.isgeneratorfunction(func)
+        is_async = inspect.iscoroutinefunction(func)
+
+        if is_async_gen:
+
+            @wraps(func)
+            async def wrapper_async_gen(*args: Any, **kwargs: Any) -> Any:
+                if len(args) >= 2 and args[0] == args[1]:
+                    async for item in func(args[0], *args[2:], **kwargs):
+                        yield item
+                else:
+                    async for item in func(*args, **kwargs):
+                        yield item
+
+            setattr(wrapper_async_gen, "_rpc_config", {"name": name or func.__name__, "public": public})  # noqa: B010
+            return wrapper_async_gen
+
+        elif is_gen:
+
+            @wraps(func)
+            async def wrapper_gen(*args: Any, **kwargs: Any) -> Any:
+                if len(args) >= 2 and args[0] == args[1]:
+                    for item in func(args[0], *args[2:], **kwargs):
+                        yield item
+                else:
+                    for item in func(*args, **kwargs):
+                        yield item
+
+            setattr(wrapper_gen, "_rpc_config", {"name": name or func.__name__, "public": public})  # noqa: B010
+            return wrapper_gen
+
+        elif is_async:
+
+            @wraps(func)
+            async def wrapper_async(*args: Any, **kwargs: Any) -> Any:
+                if len(args) >= 2 and args[0] == args[1]:
+                    return await func(args[0], *args[2:], **kwargs)
+                return await func(*args, **kwargs)
+
+            setattr(wrapper_async, "_rpc_config", {"name": name or func.__name__, "public": public})  # noqa: B010
+            return wrapper_async
+
+        else:
+
+            @wraps(func)
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                if len(args) >= 2 and args[0] == args[1]:
+                    return func(args[0], *args[2:], **kwargs)
+                return func(*args, **kwargs)
+
+            setattr(wrapper, "_rpc_config", {"name": name or func.__name__, "public": public})  # noqa: B010
+            return wrapper
+
+    return decorator
+
+
+class MethodExtractor:
+    @staticmethod
+    def extract_methods(handler: dict[str, Callable[..., Any]] | object) -> dict[str, RPCMethod]:
+        methods: dict[str, RPCMethod] = {}
+
+        def is_valid_method(name: str, method: Any) -> bool:
+            return (
+                callable(method)
+                and not name.startswith("_")
+                and not name.startswith("#")
+                and name != "__init__"
+                and not hasattr(object, name)
+            )
+
+        def process_method(name: str, method: Any) -> None:
+            if not is_valid_method(name, method):
+                return
+
+            # Check for RPC metadata
+            rpc_config = getattr(method, "_rpc_config", None)
+
+            if rpc_config:  # noqa: SIM102
+                # Only add if public
+                if rpc_config["public"]:
+                    methods[rpc_config["name"]] = {
+                        "name": rpc_config["name"],
+                        "public": True,
+                        "type": MethodExtractor.get_method_type(method),
+                        "method": method,
+                    }
+            # else:
+            #     # Convention-based fallback
+            #     methods[name] = {
+            #         "name": name,
+            #         "public": True,
+            #         "type": MethodExtractor.get_method_type(method),
+            #         "method": method,
+            # }
+
+        if isinstance(handler, Mapping):
+            handler = cast(Mapping[str, Callable[..., Any]], handler)
+            for name, method in handler.items():
+                process_method(name, method)
+        else:
+            # Get methods from object itself
+            for name, method in inspect.getmembers(handler, predicate=inspect.ismethod):
+                process_method(name, method)
+
+            # Get methods from prototype (if it's a class instance)
+            for name, _ in inspect.getmembers(handler.__class__, predicate=inspect.isfunction):
+                if name not in methods:
+                    bound_method = getattr(handler, name)
+                    process_method(name, bound_method)
+
+        # Add discover method
+        async def _discover(*args: list[Any]) -> dict[str, RPCMetadata]:
+            method_types: dict[str, RPCMetadata] = {
+                name: {"name": m["name"], "type": m["type"]}
+                for name, m in MethodExtractor.extract_methods(handler).items()
+            }
+            return method_types
+
+        methods["_discover"] = {
+            "name": "_discover",
+            "public": True,
+            "type": "async",
+            "method": _discover,
+        }
+
+        return methods
+
+    @staticmethod
+    def is_async_function(fn: Any) -> bool:
+        if not fn:
+            return False
+        return inspect.iscoroutinefunction(fn) or inspect.iscoroutine(fn) or inspect.isawaitable(fn)
+
+    @staticmethod
+    def is_generator_function(fn: Any) -> bool:
+        if not fn:
+            return False
+        return inspect.isgeneratorfunction(fn)
+
+    @staticmethod
+    def is_async_generator_function(fn: Any) -> bool:
+        if not fn:
+            return False
+        return inspect.isasyncgenfunction(fn)
+
+    @staticmethod
+    def get_method_type(fn: Any) -> Literal["async", "asyncGenerator"]:
+        if inspect.ismethod(fn):
+            fn = fn.__func__
+
+        if MethodExtractor.is_async_generator_function(fn):
+            return "asyncGenerator"
+        if MethodExtractor.is_generator_function(fn):
+            return "asyncGenerator"
+        if MethodExtractor.is_async_function(fn):
+            return "async"
+
+        return "async"

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/subscriptions.py

@@ -0,0 +1,24 @@
+from collections.abc import Awaitable
+from contextlib import suppress
+from typing import Any, Callable, Protocol
+
+
+class Unsubscribable(Protocol):
+    async def unsubscribe(self) -> None: ...
+
+
+class SubscriptionWrapper(Unsubscribable):
+    _subject: str
+    _handler_id: str
+    _unsubscribe_fn: Callable[[str, str], Awaitable[Any]]
+
+    def __init__(
+        self, subject: str, handler_id: str, unsubscribe_fn: Callable[[str, str], Awaitable[Any]]
+    ) -> None:
+        self._subject = subject
+        self._handler_id = handler_id
+        self._unsubscribe_fn = unsubscribe_fn
+
+    async def unsubscribe(self) -> None:
+        with suppress(Exception):
+            await self._unsubscribe_fn(self._subject, self._handler_id)

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/tasks.py

@@ -0,0 +1,39 @@
+import asyncio
+from collections.abc import Coroutine
+from typing import Any
+
+
+class TaskSet:
+    tasks: set[asyncio.Task[Any]]
+    name: str | None
+
+    def __init__(self, name: str | None = None) -> None:
+        self.tasks = set[asyncio.Task[Any]]()
+        self.name = name
+
+    def log_prefix(self) -> str:
+        return f"[{self.name}]"
+
+    def add(self, coroutine: Coroutine[Any, Any, Any]) -> asyncio.Task[Any]:
+        task = asyncio.create_task(coroutine, name=self.name)
+        self.tasks.add(task)
+        task.add_done_callback(lambda _: self.remove(task))
+
+        return task
+
+    def remove(self, task: asyncio.Task[Any] | None) -> None:
+        if task and task in self.tasks:
+            if not task.cancelled():
+                task.cancel()
+
+            self.tasks.remove(task)
+
+    def remove_all(self) -> None:
+        tasks = self.tasks.copy()
+        for task in tasks:
+            self.remove(task)
+
+        self.tasks.clear()
+
+    def __await__(self) -> Any:
+        return asyncio.gather(*self.tasks).__await__()

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/uid.py

@@ -0,0 +1,37 @@
+import binascii
+import os
+import threading
+from typing import Any
+
+_BUFFER_SIZE_BYTES = 256
+_buffer: bytes = b""
+_idx = 0
+_LOCK: Any = threading.Lock()
+
+
+def _replenish_buffer():
+    global _buffer, _idx
+    _buffer = os.urandom(_BUFFER_SIZE_BYTES)
+    _idx = 0
+
+
+def uid(length: int = 11) -> str:
+    global _idx, _buffer
+    if length <= 0:
+        return ""
+
+    bytes_needed = (length + 1) // 2
+
+    with _LOCK:
+        if not _buffer or _idx + bytes_needed > _BUFFER_SIZE_BYTES:
+            _replenish_buffer()
+
+        start_index = _idx
+        end_index = start_index + bytes_needed
+        random_bytes = _buffer[start_index:end_index]
+
+        _idx = end_index
+
+    hex_string = binascii.hexlify(random_bytes).decode("ascii")
+
+    return hex_string[:length]

package/dist/server/src/_camera_ui_tools/camera_ui_rpc_client/utils/validate.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from ..base.errors import ERROR_CODES, ErrorFactory
+from ..typings import AuthConfig, ClientConnectionOptions, Metadata
+
+
+class ValidationUtils:
+    """Utility class for validation operations"""
+
+    @staticmethod
+    def validate_metadata(metadata: Metadata) -> None:
+        """
+        Validate metadata structure and content.
+
+        Args:
+            metadata: Metadata object to validate
+
+        Raises:
+            ConfigError: If validation fails
+        """
+        if "id" not in metadata or not metadata["id"]:
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "Invalid ID in metadata",
+                    "code": ERROR_CODES.CONFIG.INVALID,
+                    "metadata": {"metadata": metadata},
+                },
+            )
+
+        if "name" not in metadata or not metadata["name"]:
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "Invalid name in metadata",
+                    "code": ERROR_CODES.CONFIG.INVALID,
+                    "metadata": {"metadata": metadata},
+                },
+            )
+
+    @staticmethod
+    def validate_connection_options(options: ClientConnectionOptions) -> None:
+        """
+        Validate connection options.
+
+        Args:
+            options: ConnectionOptions object to validate
+
+        Raises:
+            ConfigError: If validation fails
+        """
+        ValidationUtils.validate_metadata(options["metadata"])
+
+        if not options["endpoints"] or len(options["endpoints"]) == 0:
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "No NATS endpoints provided",
+                    "code": ERROR_CODES.CONFIG.INVALID,
+                    "metadata": {"endpoints": options["endpoints"]},
+                },
+            )
+
+        if not options["auth"]:
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "No authentication configuration provided",
+                    "code": ERROR_CODES.AUTH.INVALID_CREDENTIALS,
+                },
+            )
+
+        # Validate auth config
+        ValidationUtils._validate_client_auth(options["auth"])
+
+    @staticmethod
+    def _validate_client_auth(auth: AuthConfig) -> None:
+        """
+        Validate client authentication configuration.
+
+        Args:
+            auth: AuthConfig object to validate
+
+        Raises:
+            ConfigError: If validation fails
+        """
+        ValidationUtils._validate_auth_credentials(auth)
+
+    @staticmethod
+    def _validate_auth_credentials(auth: AuthConfig) -> None:
+        """
+        Validate authentication credentials.
+
+        Args:
+            auth: AuthConfig object to validate
+            context: Context string for error messages
+
+        Raises:
+            ConfigError: If validation fails
+        """
+        if not isinstance(auth["user"], str) or not auth["user"]:  # type: ignore
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "Invalid username provided",
+                    "code": ERROR_CODES.AUTH.INVALID_CREDENTIALS,
+                    "metadata": {"provided": {"user": auth["user"]}},
+                },
+            )
+
+        if not isinstance(auth["password"], str) or not auth["password"]:  # type: ignore
+            raise ErrorFactory.config.invalid(
+                None,
+                {
+                    "description": "Invalid password provided",
+                    "code": ERROR_CODES.AUTH.INVALID_CREDENTIALS,
+                    "metadata": {"provided": {"password": "***"}},
+                },
+            )