@camera.ui/server 0.0.70 → 0.0.71

package/dist/server/src/plugins/runtime/python/proxy/core_manager.py

@@ -1,126 +1,125 @@
-import asyncio
-from typing import Any, Optional
+from __future__ import annotations
 
-from pyeecui.asyncio import AsyncIOEventEmitter
+import asyncio
+from typing import TYPE_CHECKING, Any, TypedDict
 
-from _camera_ui_tools.camera_ui_common.logger_service.logger import LoggerService
-from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
-from _camera_ui_tools.camera_ui_rpc_client.base.rpc import RPCConnection
-from _camera_ui_tools.camera_ui_rpc_client.typings import Message
-from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
-from _camera_ui_tools.camera_ui_types import (
+from _camera_ui_tools.camera_ui_common import LoggerService
+from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
+from _camera_ui_tools.camera_ui_sdk import (
+    API_EVENT,
+    BasePlugin,
     CoreManager,
-    CuiPlugin,
-    FfmpegArgs,
-    HWAccelOptions,
-    IceServer,
+    CoreManagerEvent,
+    Observable,
+    PluginInterface,
+    Subject,
 )
-from _camera_ui_tools.camera_ui_types import PluginAPI as PluginAPIInterface
-from plugins.runtime.python.namespaces import CoreManagerPluginNamespaces, NamespaceManager
-from plugins.runtime.python.typings import API_EVENT, CoreManagerInterface, PluginInfo
+from plugins.runtime.python.namespaces import CoreManagerNamespaces, NamespaceManager, PluginNamespaces
+from plugins.runtime.python.rpc.typings import CoreManagerInterface
+from plugins.runtime.python.typings import PluginInfo
+
+if TYPE_CHECKING:
+    from plugins.runtime.python.plugin_api import PluginAPI
+
+
+class RPCConnection(TypedDict):
+    proxy: BasePlugin
+    close: CloseHandler
 
 
-class CoreManagerProxy(AsyncIOEventEmitter, CoreManager):
+class CoreManagerProxy(CoreManager):
     def __init__(
         self,
-        proxy: ClientInstance,
-        api: PluginAPIInterface,
+        proxy: RPCClient,
+        api: PluginAPI,
         logger: LoggerService,
         plugin: PluginInfo,
     ):
-        super().__init__()
-
         self.__initialized = False
 
-        self.__api = api
+        self.__api: PluginAPI = api
         self.__proxy = proxy
         self.__logger = logger
         self.__plugin = plugin
+        self.__close_subscription: CloseHandler | None = None
 
-        self.__subscription: Optional[SubscriptionWrapper] = None
-        self.__namespaces: CoreManagerPluginNamespaces = {
-            **NamespaceManager.core_manager_namespaces(),
-            **NamespaceManager.plugin_namespaces(self.__plugin["id"]),
-        }
+        self.__namespaces: tuple[CoreManagerNamespaces, PluginNamespaces] = (
+            NamespaceManager.core_manager_namespaces(),
+            NamespaceManager.plugin_namespaces(self.__plugin["id"]),
+        )
 
         self.__rpc_connections: dict[str, RPCConnection] = {}
+        self.__event_subject: Subject[CoreManagerEvent] = Subject()
 
         self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
 
+    @property
+    def __core_manager_proxy(self) -> CoreManagerInterface:
+        return self.__proxy.create_proxy(
+            self.__namespaces[0].core_manager_rpc,
+            CoreManagerInterface,
+        )
+
+    @property
+    def onEvent(self) -> Observable[CoreManagerEvent]:
+        return self.__event_subject.as_observable()
+
     async def init(self) -> None:
         if self.__initialized:
             return
 
         self.__initialized = True
-        self.__subscription = await self.__proxy.subscribe(
-            self.__namespaces["coreManagerSubject"], self.__on_event_message
+        self.__close_subscription = await self.__proxy.subscribe(
+            self.__namespaces[0].core_manager_subject,
+            self.__on_event_message,
         )
 
-    async def connect_to_plugin(self, plugin_name: str) -> Optional[CuiPlugin]:
+    async def connectToPlugin(self, pluginName: str) -> BasePlugin | None:
         try:
-            core_manager_proxy = await self.__core_manager_proxy()
-            plugin = await core_manager_proxy.getPlugin(plugin_name)
+            plugin = await self.__core_manager_proxy.getPlugin(pluginName)
 
             if not plugin:
                 return None
 
             namespaces = NamespaceManager.plugin_namespaces(plugin["id"])
-            rpc_connection: Optional[RPCConnection] = None
 
-            if namespaces["pluginChildRpc"] in self.__rpc_connections:
-                rpc_connection = self.__rpc_connections[namespaces["pluginChildRpc"]]
-                await rpc_connection.connect()
-            else:
-                rpc_connection = await self.__proxy.create_rpc_connection(namespaces["pluginChildRpc"])
-                self.__rpc_connections[namespaces["pluginChildRpc"]] = rpc_connection
+            rpc_connection: RPCConnection
 
-            return rpc_connection.create_proxy(CuiPlugin)
-        except:  # noqa
+            if namespaces.plugin_child_rpc in self.__rpc_connections:
+                rpc_connection = self.__rpc_connections[namespaces.plugin_child_rpc]
+            else:
+                rpc_connection = await self.__proxy.create_proxy(namespaces.plugin_child_rpc)
+                self.__rpc_connections[namespaces.plugin_child_rpc] = rpc_connection
+            return rpc_connection["proxy"]
+        except Exception:
             return None
 
-    async def get_ffmpeg_path(self) -> str:
-        core_manager_proxy = await self.__core_manager_proxy()
-        return await core_manager_proxy.getFFmpegPath()
-
-    async def get_hwaccel_info(self, options: HWAccelOptions) -> list[FfmpegArgs]:
-        core_manager_proxy = await self.__core_manager_proxy()
-        return await core_manager_proxy.getHwaccelInfo(options)
+    async def getFFmpegPath(self) -> str:
+        return await self.__core_manager_proxy.getFFmpegPath()
 
-    async def get_ice_servers(self) -> list[IceServer]:
-        core_manager_proxy = await self.__core_manager_proxy()
-        return await core_manager_proxy.getIceServers()
+    async def getServerAddresses(self) -> list[str]:
+        return await self.__core_manager_proxy.getServerAddresses()
 
-    async def get_server_addresses(self) -> list[str]:
-        core_manager_proxy = await self.__core_manager_proxy()
-        return await core_manager_proxy.getServerAddresses()
+    async def getPluginsByInterface(self, interfaceName: PluginInterface) -> list[PluginInfo]:
+        return await self.__core_manager_proxy.getPluginsByInterface(interfaceName)
 
-    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
-        pass
-
-    async def __core_manager_proxy(self) -> CoreManagerInterface:
-        return await self.__proxy.create_rpc_proxy(CoreManagerInterface, self.__namespaces["coreManagerRpc"])
-
-    async def __on_event_message(self, event: Message[Any]) -> None:
-        message = event["data"]
-        type = message.get("type")
-        data = message.get("data", {})
-        system = data.get("system", {})
-
-        if type == "systemUpdated":
-            super().emit(type, system)
+    async def __on_event_message(self, event: dict[str, Any]) -> None:
+        event_type = event.get("type")
+        if not event_type:
+            return
+        data = event.get("data")
+        self.__event_subject.next({"type": event_type, "data": data})
 
     async def __close(self) -> None:
         self.__initialized = False
-        self.cancel()
-        self.remove_all_listeners()
-        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
-        if self.__subscription:
-            await self.__subscription.unsubscribe()
-            self.__subscription = None
+        self.__event_subject.complete()
+        self.__api.removeListener(API_EVENT.SHUTDOWN.value, self.__close)
+        if self.__close_subscription:
+            await self.__close_subscription()
+            self.__close_subscription = None
         await self.__disconnect_rpc()
 
     async def __disconnect_rpc(self) -> None:
-        await self.__proxy.disconnect_rpc_connection(self.__namespaces["coreManagerRpc"])
         await asyncio.gather(
-            *[rpc_connection.disconnect() for rpc_connection in self.__rpc_connections.values()]
+            *[rpc_connection["close"]() for rpc_connection in self.__rpc_connections.values()]
         )

package/dist/server/src/plugins/runtime/python/proxy/device_manager.py

@@ -1,144 +1,138 @@
-import asyncio
-from typing import Any, Optional, Union, cast
+from __future__ import annotations
 
-from pyeecui.asyncio import AsyncIOEventEmitter
+import asyncio
+from typing import TYPE_CHECKING, Any
 
 from _camera_ui_tools.camera_ui_common import (
     LoggerService,
 )
-from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
-from _camera_ui_tools.camera_ui_rpc_client.typings import Message
-from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
-from _camera_ui_tools.camera_ui_types import (
+from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
+from _camera_ui_tools.camera_ui_sdk import (
+    API_EVENT,
+    BasePlugin,
     Camera,
-    CameraConfig,
-    CameraExtension,
     DeviceManager,
-    DeviceManagerEventType,
-    PartialCameraConfig,
+    DiscoveredCamera,
 )
-from _camera_ui_tools.camera_ui_types import PluginAPI as PluginAPIInterface
 from plugins.runtime.python.namespaces import (
-    DeviceManagerPluginNamespaces,
+    DeviceManagerNamespaces,
+    DiscoveryManagerNamespaces,
     NamespaceManager,
+    PluginNamespaces,
 )
+from plugins.runtime.python.rpc.typings import DeviceManagerInterface, DiscoveryManagerInterface
 from plugins.runtime.python.storage_controller import StorageController
-from plugins.runtime.python.typings import API_EVENT, DeviceManagerInterface, PluginInfo
+from plugins.runtime.python.typings import PluginInfo
 
 from .camera_device import CameraDeviceProxy
 
+if TYPE_CHECKING:
+    from plugins.runtime.python.plugin_api import PluginAPI
+
 
-class DeviceManagerProxy(AsyncIOEventEmitter, DeviceManager):  # type: ignore
+class DeviceManagerProxy(DeviceManager):
     def __init__(
         self,
-        proxy: ClientInstance,
-        api: PluginAPIInterface,
+        proxy: RPCClient,
+        api: PluginAPI,
         storage_controller: StorageController,
         logger: LoggerService,
         plugin: PluginInfo,
     ):
-        super().__init__()
-
         self.__initialized = False
+        self.__plugin_instance: BasePlugin | None = None
 
-        self.__api = api
+        self.__api: PluginAPI = api
         self.__proxy = proxy
         self.__storage_controller = storage_controller
         self.__logger = logger
         self.__plugin = plugin
+        self.__close_request: CloseHandler | None = None
 
         self.__devices: dict[str, CameraDeviceProxy] = {}
-        self.__requests: Optional[SubscriptionWrapper] = None
-        self.__namespaces: DeviceManagerPluginNamespaces = {
-            **NamespaceManager.device_manager_namespaces(),
-            **NamespaceManager.plugin_namespaces(self.__plugin["id"]),
-        }
+        self.__namespaces: tuple[DeviceManagerNamespaces, PluginNamespaces, DiscoveryManagerNamespaces] = (
+            NamespaceManager.device_manager_namespaces(),
+            NamespaceManager.plugin_namespaces(self.__plugin["id"]),
+            NamespaceManager.discovery_manager_namespaces(),
+        )
 
         self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
 
+    @property
+    def __device_manager_proxy(self) -> DeviceManagerInterface:
+        return self.__proxy.create_proxy(self.__namespaces[0].device_manager_rpc, DeviceManagerInterface)
+
+    @property
+    def __discovery_manager_proxy(self) -> DiscoveryManagerInterface:
+        return self.__proxy.create_proxy(
+            self.__namespaces[2].discovery_manager_rpc, DiscoveryManagerInterface
+        )
+
+    def set_plugin(self, plugin: BasePlugin) -> None:
+        self.__plugin_instance = plugin
+
     async def init(self) -> None:
         if self.__initialized:
             return
 
         self.__initialized = True
-        self.__requests = await self.__proxy.handle_request(
-            self.__namespaces["pluginDeviceManagerSubject"], self.__on_event_message
+        self.__close_request = await self.__proxy.on_request(
+            self.__namespaces[1].plugin_device_manager_subject, self.__on_event_message
         )
 
-    async def get_camera(self, camera_id_or_name: str) -> Optional[CameraDeviceProxy]:
-        camera_device = await self.__get_camera_device(camera_id_or_name)
+    async def getCamera(self, cameraIdOrName: str) -> CameraDeviceProxy | None:
+        camera_device = await self.__get_camera_device(cameraIdOrName)
 
         if not camera_device:
-            device_manager_proxy = await self.__device_manager_proxy()
-            camera = await device_manager_proxy.getCamera(camera_id_or_name, self.__plugin["id"])
+            camera = await self.__device_manager_proxy.getCamera(cameraIdOrName, self.__plugin["id"])
 
             if camera:
                 camera_device = await self.__get_camera_device(camera)
 
         return camera_device
 
-    async def create_camera(self, camera_config: CameraConfig) -> CameraDeviceProxy:
-        device_manager_proxy = await self.__device_manager_proxy()
-        camera = await device_manager_proxy.createCamera(camera_config, self.__plugin["id"])
-        camera_device = cast(CameraDeviceProxy, await self.__get_camera_device(camera))
-        return camera_device
+    async def pushDiscoveredCameras(self, cameras: list[DiscoveredCamera]) -> None:
+        await self.__discovery_manager_proxy.pushDiscoveredCameras(self.__plugin["id"], cameras)
 
-    async def update_camera(
-        self, camera_id_or_name: str, camera_config: PartialCameraConfig
-    ) -> CameraDeviceProxy:
-        device_manager_proxy = await self.__device_manager_proxy()
-        camera = await device_manager_proxy.updateCamera(
-            camera_id_or_name, camera_config, self.__plugin["id"]
-        )
-        camera_device = cast(CameraDeviceProxy, await self.__get_camera_device(camera))
-        return camera_device
-
-    async def remove_camera(self, camera_id_or_name: str) -> None:
-        device_manager_proxy = await self.__device_manager_proxy()
-        camera = await device_manager_proxy.getCamera(camera_id_or_name, self.__plugin["id"])
-
-        if camera:
-            await device_manager_proxy.removeCamera(camera_id_or_name, self.__plugin["id"])
-            del self.__devices[camera["_id"]]
-
-    def emit(self, event: str, *args: Any, **kwargs: Any) -> Any:
-        pass
-
-    async def configure_cameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
+    async def configureCameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
         await asyncio.gather(*[self.__get_camera_device(camera_device) for camera_device in camera_devices])
 
-    async def __device_manager_proxy(self) -> DeviceManagerInterface:
-        return await self.__proxy.create_rpc_proxy(
-            DeviceManagerInterface, self.__namespaces["deviceManagerRpc"]
-        )
-
-    async def __on_event_message(self, event: Message[Any]) -> None:
-        if not self.__initialized:
+    async def __on_event_message(self, event: Any) -> None:
+        if not self.__plugin_instance:
+            self.__logger.warn("Plugin instance not set, cannot handle lifecycle event")
             return
 
-        message = event["data"]
-        type: DeviceManagerEventType = message.get("type")
-        data = message.get("data", {})
-        camera: Camera = data.get("camera")
-        extension: CameraExtension = data.get("extension")
+        event_type = event.get("type")
+        data = event.get("data", {})
 
-        if type == "cameraSelected":
+        if event_type == "cameraAdded":
+            camera: Camera = data.get("camera")
             camera_device = await self.__get_camera_device(camera)
-            super().emit(type, camera_device, extension)
-        elif type == "cameraDeselected":
-            camera_device = self.__devices.get(camera["_id"])
-            super().emit(type, camera["_id"], extension)
 
+            if camera_device:
+                # Call plugin lifecycle callback
+                await self.__plugin_instance.onCameraAdded(camera_device)
+
+        elif event_type == "cameraReleased":
+            camera_id: str = data.get("cameraId")
+
+            # Call plugin lifecycle callback
+            await self.__plugin_instance.onCameraReleased(camera_id)
+
+            # Cleanup
+            camera_device = self.__devices.get(camera_id)
             if camera_device:
                 await camera_device.cleanup()
 
-            await self.__remove_camera_storage(camera["_id"])
-            del self.__devices[camera["_id"]]
+            await self.__remove_camera_storage(camera_id)
+
+            if camera_id in self.__devices:
+                del self.__devices[camera_id]
 
     async def __get_camera_device(
-        self, camera_or_id: Union[Camera, CameraDeviceProxy, str]
-    ) -> Optional[CameraDeviceProxy]:
-        camera_device: Optional[CameraDeviceProxy] = None
+        self, camera_or_id: Camera | CameraDeviceProxy | str
+    ) -> CameraDeviceProxy | None:
+        camera_device: CameraDeviceProxy | None = None
 
         if isinstance(camera_or_id, str):
             id = camera_or_id
@@ -159,11 +153,12 @@ class DeviceManagerProxy(AsyncIOEventEmitter, DeviceManager):  # type: ignore
                 camera_device = self.__devices[camera["_id"]]
             else:
                 camera_logger = self.__logger.create_logger(
-                    {"suffix": camera["name"], "logger_id": camera["_id"]}
+                    {"suffix": camera["name"], "target_id": camera["_id"], "target_type": "camera"}
                 )
                 camera_device = CameraDeviceProxy(
                     self.__proxy,
                     self.__api,
+                    self.__storage_controller,
                     camera,
                     self.__plugin,
                     camera_logger,
@@ -178,20 +173,13 @@ class DeviceManagerProxy(AsyncIOEventEmitter, DeviceManager):  # type: ignore
         return camera_device
 
     async def __create_camera_storage(self, camera_id: str) -> None:
-        await self.__storage_controller.create_storage("camera", camera_id)
+        await self.__storage_controller.createStorage("camera", camera_id)
 
     async def __remove_camera_storage(self, camera_id: str) -> None:
-        await self.__storage_controller.remove_storage("camera", camera_id)
+        await self.__storage_controller.removeStorage("camera", camera_id)
 
     async def __close(self) -> None:
         self.__initialized = False
-        self.cancel()
-        self.remove_all_listeners()
-        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
-        if self.__requests:
-            await self.__requests.unsubscribe()
-            self.__requests = None
-        await self.__disconnect_rpc()
-
-    async def __disconnect_rpc(self) -> None:
-        await self.__proxy.disconnect_rpc_connection(self.__namespaces["deviceManagerRpc"])
+        self.__api.removeListener(API_EVENT.SHUTDOWN.value, self.__close)
+        if self.__close_request:
+            await self.__close_request()

package/dist/server/src/plugins/runtime/python/proxy/download_manager.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from _camera_ui_tools.camera_ui_rpc import RPCClient
+from _camera_ui_tools.camera_ui_sdk import (
+    CreateDownloadOptions,
+    CreateStreamDownloadOptions,
+    DownloadManager,
+    DownloadToken,
+)
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.rpc.typings import DownloadManagerInterface
+
+
+class DownloadManagerProxy(DownloadManager):
+    def __init__(self, proxy: RPCClient) -> None:
+        self.__proxy = proxy
+        self.__namespaces = NamespaceManager.download_manager_namespaces()
+
+    @property
+    def __download_manager_proxy(self) -> DownloadManagerInterface:
+        return self.__proxy.create_proxy(
+            self.__namespaces.download_manager_rpc,
+            DownloadManagerInterface,
+        )
+
+    async def createDownload(self, options: CreateDownloadOptions) -> DownloadToken:
+        return await self.__download_manager_proxy.createDownload(options)
+
+    async def createStreamDownload(self, options: CreateStreamDownloadOptions) -> DownloadToken:
+        return await self.__download_manager_proxy.createStreamDownload(options)
+
+    async def deleteDownload(self, token: str) -> None:
+        return await self.__download_manager_proxy.deleteDownload(token)

package/dist/server/src/plugins/runtime/python/proxy/notification_manager.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+from _camera_ui_tools.camera_ui_rpc import RPCClient
+from _camera_ui_tools.camera_ui_sdk import Notification, NotificationManager
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.typings import PluginInfo
+
+
+class _PublishEnvelope(TypedDict):
+    pluginId: str
+    pluginName: str
+    notification: Notification
+
+
+class NotificationManagerProxy(NotificationManager):
+    def __init__(self, proxy: RPCClient, plugin: PluginInfo) -> None:
+        self.__proxy = proxy
+        self.__plugin = plugin
+        self.__namespaces = NamespaceManager.notification_manager_namespaces()
+
+    async def publish(self, notification: Notification) -> None:
+        if not notification.get("title"):
+            raise ValueError("notification.title is required")
+        envelope: _PublishEnvelope = {
+            "pluginId": self.__plugin["id"],
+            "pluginName": self.__plugin["name"],
+            "notification": notification,
+        }
+        await self.__proxy.publish(self.__namespaces.notifications_publish_subject, envelope)