@camera.ui/server 0.0.10 → 0.0.11-alpha.2

package/dist/server/src/polyglot/python/plugins/camera_storage.py

@@ -6,10 +6,10 @@ from pathlib import Path
 from typing import Any, Optional, TypeVar, Union, cast
 
 from camera_ui_types import (
-    PluginJsonBaseSchema,
-    PluginJsonSchema,
-    PluginJsonSchemaForm,
-    PluginRootSchema,
+    JsonBaseSchema,
+    JsonSchema,
+    JsonSchemaForm,
+    RootSchema,
     SchemaConfig,
 )
 from deepdiff import DeepDiff
@@ -62,15 +62,15 @@ class CameraStorage:
         api: PluginAPI,
         instance: Any,
         camera_id: str,
-        schema: Optional[PluginJsonSchemaForm] = None,
+        schema: Optional[JsonSchemaForm] = None,
     ) -> None:
         if schema is None:
             schema = {}
         self.__api = api
         self.__instance = instance
         self.__camera_id = camera_id
-        self.__schema: PluginJsonSchemaForm = schema or {}
-        self.__values: dict[str, Any] = {}
+        self.schema: JsonSchemaForm = schema or {}
+        self.values: dict[str, Any] = {}
 
         db_path = Path(api.storage_path) / "volume"
         self.__db: Lmdb[Literal["config"], dict[str, Any]] = JsonLmdb.open(file=str(db_path), flag="c")
@@ -78,11 +78,7 @@ class CameraStorage:
         self.__api.device_manager.once("cameraDeselected", self.__deselected)
         self.__api.once("shutdown", self.__close)
 
-    @property
-    def values(self) -> dict[str, Any]:
-        return self.__values
-
-    def initialize_storage(self) -> None:
+    def initializeStorage(self) -> None:
         """
         Initialize the storage.
         This will load the configuration from the database.
@@ -96,17 +92,17 @@ class CameraStorage:
         except:  # noqa: E722
             pass
 
-        schema_config = generate_json_from_root_schema({"schema": self.__schema})
+        schema_config = generate_json_from_root_schema({"schema": self.schema})
 
-        self.__values = merge_with(schema_config, camera_config, merge, [])
+        self.values = merge_with(schema_config, camera_config, merge, [])
 
         self.__save_db()
 
     @overload
-    async def get_value(self, path: str) -> Union[Any, None]: ...
+    async def getValue(self, path: str) -> Union[Any, None]: ...
     @overload
-    async def get_value(self, path: str, default_value: P) -> P: ...
-    async def get_value(self, path: str, default_value: Optional[P] = None) -> Union[P, None]:
+    async def getValue(self, path: str, default_value: P) -> P: ...
+    async def getValue(self, path: str, default_value: Optional[P] = None) -> Union[P, None]:
         """
         Get a value from the configuration by its key/path.
         If the schema has an onGet function, the onGet function will be called.
@@ -119,8 +115,8 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: PluginJsonBaseSchema = ObjectPath.get(self.__schema, schema_path)
-        config_value = ObjectPath.get(self.__values, path)
+        schema: JsonBaseSchema = ObjectPath.get(self.schema, schema_path)
+        config_value = ObjectPath.get(self.values, path)
 
         if schema:
             on_get_function = schema.get("onGet", None)
@@ -136,7 +132,7 @@ class CameraStorage:
             else:
                 return default_value
 
-    async def set_value(self, path: str, new_value: Any) -> None:
+    async def setValue(self, path: str, new_value: Any) -> None:
         """
         Set a new value for a given key/path in the configuration.
         If the schema of the value has an onSet function, and the value has changed, the onSet function will be called.
@@ -147,18 +143,18 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: PluginJsonSchema = ObjectPath.get(self.__schema, schema_path)
+        schema: JsonSchema = ObjectPath.get(self.schema, schema_path)
 
         if schema:
-            old_config = deepcopy(self.__values)
-            ObjectPath.set(self.__values, path, new_value)
+            old_config = deepcopy(self.values)
+            ObjectPath.set(self.values, path, new_value)
 
-            await self.__trigger_on_set_for_changes(old_config, self.__values)
+            await self.__trigger_on_set_for_changes(old_config, self.values)
 
             if self.__contains_storable_schema(schema):
                 self.__save_db()
 
-    def has_value(self, path: str) -> bool:
+    def hasValue(self, path: str) -> bool:
         """
         Check if a value exists by its config path/key.
 
@@ -166,7 +162,7 @@ class CameraStorage:
         :return: True if the value exists, false otherwise.
         """
 
-        config_value = ObjectPath.get(self.__values, path)
+        config_value = ObjectPath.get(self.values, path)
         return config_value is not None
 
     async def getConfig(self) -> SchemaConfig:
@@ -177,12 +173,12 @@ class CameraStorage:
         :return: The root schema and configuration.
         """
 
-        filtered_schema = remove_functions_from_schema_form(self.__schema)
-        root_schema: PluginRootSchema = {"schema": filtered_schema}
+        filtered_schema = remove_functions_from_schema_form(self.schema)
+        root_schema: RootSchema = {"schema": filtered_schema}
 
-        await self.__resolve_on_get_functions(self.__schema)
+        await self.__resolve_on_get_functions(self.schema)
 
-        return {"rootSchema": root_schema, "config": self.__values}
+        return {"rootSchema": root_schema, "config": self.values}
 
     async def setConfig(self, new_config: dict[str, Any]) -> None:
         """
@@ -192,20 +188,20 @@ class CameraStorage:
         :param new_config: The new configuration to set.
         """
 
-        old_config = deepcopy(self.__values)
-        self.__values = new_config
+        old_config = deepcopy(self.values)
+        self.values = new_config
 
-        await self.__trigger_on_set_for_changes(old_config, self.__values)
+        await self.__trigger_on_set_for_changes(old_config, self.values)
         self.__save_db()
 
     @overload
-    async def add_schema(self, schema_or_path: PluginJsonSchemaForm) -> None: ...
+    async def addSchema(self, schema_or_path: JsonSchemaForm) -> None: ...
     @overload
-    async def add_schema(self, schema_or_path: str, schema: PluginJsonSchema) -> None: ...
-    async def add_schema(
+    async def addSchema(self, schema_or_path: str, schema: JsonSchema) -> None: ...
+    async def addSchema(
         self,
-        schema_or_path: Union[PluginJsonSchemaForm, str],
-        schema: Optional[PluginJsonSchema] = None,
+        schema_or_path: Union[JsonSchemaForm, str],
+        schema: Optional[JsonSchema] = None,
     ) -> None:
         """
         Add a new schema to the existing schema.
@@ -222,7 +218,7 @@ class CameraStorage:
             path = schema_or_path
             schema_path = config_path_to_schema_path(path)
 
-            ObjectPath.set(self.__schema, schema_path, schema)
+            ObjectPath.set(self.schema, schema_path, schema)
 
             await self.__resolve_on_get_functions(schema, schema_path)
 
@@ -232,7 +228,7 @@ class CameraStorage:
         elif isinstance(schema_or_path, dict) and schema is None:
             new_schema = schema_or_path
 
-            self.__schema = merge_with(self.__schema, new_schema, merge, [])
+            self.schema = merge_with(self.schema, new_schema, merge, [])
 
             await self.__resolve_on_get_functions(new_schema)
 
@@ -240,12 +236,12 @@ class CameraStorage:
                 should_save = True
 
         else:
-            raise Exception("Invalid arguments for add_schema")
+            raise Exception("Invalid arguments for addSchema")
 
         if should_save:
             self.__save_db()
 
-    def remove_schema(self, path: str) -> None:
+    def removeSchema(self, path: str) -> None:
         """
         Remove a schema by its config path/key from the existing schema.
         It will also remove the value from the configuration.
@@ -255,16 +251,16 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+        schema: Optional[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
 
         if schema:
-            ObjectPath.delete(self.__schema, schema_path)
-            ObjectPath.delete(self.__values, path)
+            ObjectPath.delete(self.schema, schema_path)
+            ObjectPath.delete(self.values, path)
 
             if self.__contains_storable_schema(schema):
                 self.__remove_db()
 
-    async def change_schema(self, path: str, new_schema: dict[str, Any]) -> None:
+    async def changeSchema(self, path: str, new_schema: dict[str, Any]) -> None:
         """
         Change a schema by its config path/key from the existing schema.
         It will also change the value from the configuration.
@@ -275,18 +271,18 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+        schema: Optional[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
 
         if schema:
             merge_with(schema, new_schema, merge, [])
-            ObjectPath.set(self.__schema, schema_path, schema)
+            ObjectPath.set(self.schema, schema_path, schema)
 
             await self.__resolve_on_get_functions(schema, schema_path)
 
             if self.__contains_storable_schema(schema):
                 self.__save_db()
 
-    def get_schema(self, path: str) -> Optional[PluginJsonSchema]:
+    def getSchema(self, path: str) -> Optional[JsonSchema]:
         """
         Get a schema by its config path/key.
 
@@ -295,11 +291,11 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+        schema: Optional[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
 
         return schema
 
-    def has_schema(self, path: str) -> bool:
+    def hasSchema(self, path: str) -> bool:
         """
         Check if a schema exists by its config path/key.
 
@@ -308,13 +304,13 @@ class CameraStorage:
         """
 
         schema_path = config_path_to_schema_path(path)
-        schema: Optional[PluginJsonSchema] = ObjectPath.get(self.__schema, schema_path) or None
+        schema: Optional[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
 
         return schema is not None
 
     async def __resolve_on_get_functions(
         self,
-        schema: Union[PluginJsonSchemaForm, PluginJsonSchema],
+        schema: Union[JsonSchemaForm, JsonSchema],
         base_schema_path: str = "",
     ) -> None:
         if "onGet" in schema or "onSet" in schema:
@@ -326,7 +322,7 @@ class CameraStorage:
                     base_schema_path,
                 )
         else:
-            _schema = cast(PluginJsonSchemaForm, schema)
+            _schema = cast(JsonSchemaForm, schema)
 
             for key, value in _schema.items():
                 schema_path = f"{base_schema_path}.{key}" if base_schema_path else key
@@ -340,7 +336,7 @@ class CameraStorage:
 
     async def ___resolve_on_get_functions_for_object(
         self,
-        schema: PluginJsonSchemaForm,
+        schema: JsonSchemaForm,
         base_schema_path: str,
     ) -> None:
         for key, _ in schema.items():
@@ -349,10 +345,10 @@ class CameraStorage:
 
     async def __resolve_on_get_functions_for_schema(self, schema_path: str) -> None:
         config_path = schema_path_to_config_path(schema_path)
-        schema_value = await self.get_value(config_path)
+        schema_value = await self.getValue(config_path)
 
         if schema_value is not None:
-            ObjectPath.set(self.__values, config_path, schema_value)
+            ObjectPath.set(self.values, config_path, schema_value)
 
     async def __trigger_on_set_for_changes(
         self, old_config: dict[str, Any], new_config: dict[str, Any], path: str = ""
@@ -364,7 +360,7 @@ class CameraStorage:
 
             if DeepDiff(old_value, new_value, ignore_order=True) != {}:
                 schema_path = config_path_to_schema_path(new_path)
-                schema_item: Optional[PluginJsonBaseSchema] = get_value_by_path(self.__schema, schema_path)
+                schema_item: Optional[JsonBaseSchema] = get_value_by_path(self.schema, schema_path)
 
                 if schema_item:
                     on_set_function = schema_item.get("onSet", None)
@@ -380,12 +376,15 @@ class CameraStorage:
 
     def __filter_storable_values(
         self,
-        schema: PluginJsonSchemaForm,
+        schema: JsonSchemaForm,
         base_schema_path: str = "",
         result: dict[str, Any] = {},
     ) -> dict[str, Any]:
         for key, value in schema.items():
-            if "type" in value and value["type"] == "object":
+            if value["type"] == "button":
+                continue
+
+            if value["type"] == "object":
                 if "properties" in value:
                     s: Any = value["properties"]
                     path = f"{base_schema_path}.{key}" if base_schema_path else key
@@ -393,7 +392,7 @@ class CameraStorage:
             elif "store" in value and value["store"]:
                 schema_path = f"{base_schema_path}.{key}" if base_schema_path else key
                 config_path = schema_path_to_config_path(schema_path)
-                config_value = get_value_by_path(self.__values, config_path)
+                config_value = get_value_by_path(self.values, config_path)
 
                 ObjectPath.set(result, config_path, config_value)
 
@@ -401,30 +400,25 @@ class CameraStorage:
 
     def __contains_storable_schema(
         self,
-        schema: Union[PluginJsonSchemaForm, PluginJsonSchema],
+        schema: Union[JsonSchemaForm, JsonSchema],
     ) -> bool:
-        if "type" in schema and schema["type"] == "object":
-            if "type" in schema and schema["type"] == "object":
-                if "store" in schema and schema["store"]:
-                    return True
-                if "properties" in schema and schema["properties"]:
-                    for sub_schema in schema["properties"].values():
-                        sub: Any = sub_schema
-                        if self.__contains_storable_schema(sub):
-                            return True
-
-                return False
-
+        if schema["type"] == "boolean":
             return False
-        else:
-            return any(
-                self.__contains_storable_schema(sub_schema)  # type: ignore
-                for sub_schema in schema.values()
-            )
+
+        if "store" in schema and schema["store"]:
+            return True
+
+        if schema["type"] == "object" and "properties" in schema:
+            schema_values: Any = schema["properties"].values()
+            return any(self.__contains_storable_schema(sub_schema) for sub_schema in schema_values)
+        elif schema["type"] == "array" and "items" in schema:
+            return self.__contains_storable_schema(schema["items"])
+
+        return False
 
     def __save_db(self) -> None:
         config: Any = self.__db.get("config") or {}
-        storable_config = self.__filter_storable_values(self.__schema)
+        storable_config = self.__filter_storable_values(self.schema)
 
         config[self.__camera_id] = storable_config
 
@@ -443,4 +437,5 @@ class CameraStorage:
 
     def __close(self) -> None:
         with suppress(Exception):
+            self.__save_db()
             self.__db.close()

package/dist/server/src/polyglot/python/plugins/child.py

@@ -143,6 +143,9 @@ class PluginChild:
         if not self.message_queue:
             raise Exception("Message queue not initialized")
 
+        reply = message.copy()
+        reply["type"] = "reply"
+
         try:
             plugin = None
 
@@ -165,7 +168,7 @@ class PluginChild:
                 else:
                     response = method_to_call(*args)
 
-                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+                reply["response"] = response or {}
             elif camera_storage and hasattr(camera_storage, fn) and callable(getattr(camera_storage, fn)):
                 method_to_call = getattr(camera_storage, fn)
 
@@ -174,9 +177,9 @@ class PluginChild:
                 else:
                     response = method_to_call(*args)
 
-                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+                reply["response"] = response or {}
             else:
-                await self.message_queue.enqueue({**message, "type": "reply"})
+                raise Exception(f"Unknown function: {fn}")
         except Exception as e:
             deserialized_error: DeserializedError = {
                 "name": type(e).__name__,
@@ -184,7 +187,12 @@ class PluginChild:
                 "stack": traceback.format_exc(),
             }
 
-            await self.message_queue.enqueue({**message, "type": "reply", "error": deserialized_error})
+            reply["error"] = deserialized_error
+
+        if message["timeout"] == 0:
+            return
+        else:
+            await self.message_queue.enqueue(reply)
 
     async def on_worker_message(self, msg: Msg) -> None:
         if self.stopped:

package/dist/server/src/polyglot/python/plugins/constants.py

@@ -1,2 +1 @@
 NATS_SERVER_SUBJECT = "camera.ui-server"
-NATS_SIGNALING_SUBJECT = "camera.ui-signaling"

package/dist/server/src/polyglot/python/plugins/proxy/camera_device.py

@@ -1472,6 +1472,9 @@ class CameraDeviceProxy:
         if not self.message_queue:
             raise Exception("Message queue not initialized")
 
+        reply = message.copy()
+        reply["type"] = "reply"
+
         try:
             if (
                 message["client"] == "cameraDelegate"
@@ -1496,7 +1499,7 @@ class CameraDeviceProxy:
                 else:
                     response = method_to_call(*args)
 
-                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+                reply["response"] = response or {}
             elif message.get("client") == "cameraFn":
                 fn: Any = message.get("fn")
                 args = message.get("args", [])
@@ -1511,9 +1514,9 @@ class CameraDeviceProxy:
                 else:
                     response = method_to_call(*args)
 
-                await self.message_queue.enqueue({**message, "type": "reply", "response": response})
+                reply["response"] = response or {}
             else:
-                await self.message_queue.enqueue({**message, "type": "reply"})
+                raise Exception(f"Unknown client: {message['client']}")
 
         except Exception as e:
             deserialized_error: DeserializedError = {
@@ -1522,7 +1525,12 @@ class CameraDeviceProxy:
                 "stack": traceback.format_exc(),
             }
 
-            await self.message_queue.enqueue({**message, "type": "reply", "error": deserialized_error})
+            reply["error"] = deserialized_error
+
+        if reply["timeout"] == 0:
+            return
+        else:
+            await self.message_queue.enqueue(reply)
 
     async def __on_proxy_message(self, msg: Msg) -> None:
         if not self.initialized: