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

package/dist/server/src/polyglot/python/camera_ui_types/__init__.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta, abstractmethod
 from collections.abc import AsyncGenerator, Awaitable, Coroutine
-from typing import Any, Callable, Generic, Optional, TypeVar, Union, overload, runtime_checkable
+from typing import Any, Callable, Generic, Optional, Union, overload, runtime_checkable
 
 from PIL import Image
 from reactivex import Observable
@@ -9,6 +9,7 @@ from typing_extensions import (
     NotRequired,
     Protocol,
     TypedDict,
+    TypeVar,
 )
 
 Callback = Union[
@@ -18,7 +19,7 @@ Callback = Union[
 
 
 # schema
-JsonSchemaType = Literal["string", "number", "boolean", "object", "array"]
+JsonSchemaType = Literal["string", "number", "boolean", "object", "array", "button"]
 
 
 class JsonBaseSchema(TypedDict):
@@ -32,59 +33,12 @@ class JsonBaseSchema(TypedDict):
     group: NotRequired[Optional[str]]
     defaultValue: NotRequired[Optional[Union[str, int, bool]]]
     store: NotRequired[Optional[bool]]
-
-
-class PluginJsonBaseSchema(JsonBaseSchema):
     onSet: NotRequired[
         Union[Callable[[Any, Any], Awaitable[Union[None, Any]]], Callable[[Any, Any], Union[None, Any]]]
-    ]
-    onGet: NotRequired[Union[Callable[[], Awaitable[Union[Any, None]]], Callable[[], Union[Any, None]]]]
-
-
-class PluginJsonSchemaString(PluginJsonBaseSchema):
-    type: Literal["string"]
-    format: NotRequired[str]
-    minLength: NotRequired[int]
-    maxLength: NotRequired[int]
-
-
-class PluginJsonSchemaNumber(PluginJsonBaseSchema):
-    type: Literal["number"]
-    minimum: NotRequired[int]
-    maximum: NotRequired[int]
-    step: NotRequired[float]
-
-
-class PluginJsonSchemaBoolean(PluginJsonBaseSchema):
-    type: Literal["boolean"]
-
-
-class PluginJsonSchemaEnum(PluginJsonBaseSchema):
-    type: Literal["string"]
-    enum: list[str]
-    multiple: NotRequired[bool]
-
-
-class PluginJsonSchemaObject(PluginJsonBaseSchema):
-    type: Literal["object"]
-    opened: NotRequired[bool]
-    properties: NotRequired["PluginJsonSchemaForm"]
-
-
-PluginJsonSchema = Union[
-    PluginJsonSchemaString,
-    PluginJsonSchemaNumber,
-    PluginJsonSchemaBoolean,
-    PluginJsonSchemaEnum,
-    PluginJsonSchemaObject,
-]
-
-
-PluginJsonSchemaForm = dict[str, PluginJsonSchema]
-
-
-class PluginRootSchema(TypedDict):
-    schema: PluginJsonSchemaForm
+    ]  # only for plugins
+    onGet: NotRequired[
+        Union[Callable[[], Awaitable[Union[Any, None]]], Callable[[], Union[Any, None]]]
+    ]  # only for plugins
 
 
 class JsonSchemaString(JsonBaseSchema):
@@ -113,25 +67,29 @@ class JsonSchemaEnum(JsonBaseSchema):
     multiple: NotRequired[bool]
 
 
+class JsonSchemaButton(JsonBaseSchema):
+    type: Literal["button"]
+
+
 class JsonSchemaObject(JsonBaseSchema):
     type: Literal["object"]
     opened: NotRequired[bool]
     properties: NotRequired["JsonSchemaForm"]
 
 
-class JsonSchemaButton(TypedDict):
+class JsonSchemaArray(JsonBaseSchema):
+    type: Literal["array"]
+    opened: NotRequired[bool]
+    items: NotRequired["JsonSchema"]
+
+
+class JsonSchemaObjectButton(TypedDict):
     label: str
     onSubmit: str
 
 
 class JsonSchemaObjectWithButtons(JsonSchemaObject):
-    buttons: tuple[JsonSchemaButton, NotRequired[JsonSchemaButton]]
-
-
-class JsonSchemaArray(JsonBaseSchema):
-    type: Literal["array"]
-    opened: NotRequired[bool]
-    items: NotRequired["JsonSchema"]
+    buttons: list[JsonSchemaObjectButton]
 
 
 JsonSchema = Union[
@@ -142,6 +100,7 @@ JsonSchema = Union[
     JsonSchemaObject,
     JsonSchemaObjectWithButtons,
     JsonSchemaArray,
+    JsonSchemaButton,
 ]
 
 
@@ -153,8 +112,8 @@ class RootSchema(TypedDict):
 
 
 class SchemaConfig(TypedDict):
-    rootSchema: PluginRootSchema
-    config: dict[str, Union[str, int, bool]]
+    rootSchema: RootSchema
+    config: dict[str, Any]
 
 
 # camera object
@@ -240,12 +199,12 @@ class DetectionZone(TypedDict):
 
 
 class CameraInformation(TypedDict):
-    model: str
-    manufacturer: str
-    hardware: str
-    serialNumber: str
-    firmwareVersion: str
-    supportUrl: str
+    model: NotRequired[str]
+    manufacturer: NotRequired[str]
+    hardware: NotRequired[str]
+    serialNumber: NotRequired[str]
+    firmwareVersion: NotRequired[str]
+    supportUrl: NotRequired[str]
 
 
 class MotionDetectionSettings(TypedDict):
@@ -1037,47 +996,52 @@ class DeviceManager(Protocol):
 
 # camera storage
 P = TypeVar("P")
+CS = TypeVar("CS", default=dict[str, Any])
 
 
 @runtime_checkable
-class CameraStorage(Protocol):
-    values: dict[str, Any]
+class CameraStorage(Protocol, Generic[CS]):
+    values: CS
+    schema: JsonSchemaForm
 
-    async def initialize_storage(self) -> None: ...
+    async def initializeStorage(self) -> None: ...
     @overload
-    def get_value(self, path: str) -> Union[Awaitable[P], P, None]: ...
+    def getValue(self, path: str) -> Union[Awaitable[P], P, None]: ...
     @overload
-    def get_value(self, path: str, default_value: P) -> Union[Awaitable[P], P]: ...
-    def get_value(self, path: str, default_value: Optional[P] = None) -> Union[Awaitable[P], P, None]: ...
-    async def set_value(self, path: str, new_value: Any) -> None: ...
-    def has_value(self, path: str) -> bool: ...
+    def getValue(self, path: str, default_value: P) -> Union[Awaitable[P], P]: ...
+    def getValue(self, path: str, default_value: Optional[P] = None) -> Union[Awaitable[P], P, None]: ...
+    async def setValue(self, path: str, new_value: Any) -> None: ...
+    def hasValue(self, path: str) -> bool: ...
     async def getConfig(self) -> SchemaConfig: ...
-    async def setConfig(self, new_config: dict[str, Any]) -> None: ...
+    async def setConfig(self, new_config: CS) -> None: ...
     @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: ...
-    def remove_schema(self, path: str) -> None: ...
-    async def change_schema(self, path: str, new_schema: dict[str, Any]) -> None: ...
-    def get_schema(self, path: str) -> Optional[PluginJsonSchema]: ...
-    def has_schema(self, path: str) -> bool: ...
+    def removeSchema(self, path: str) -> None: ...
+    async def changeSchema(self, path: str, new_schema: dict[str, Any]) -> None: ...
+    def getSchema(self, path: str) -> Optional[JsonSchema]: ...
+    def hasSchema(self, path: str) -> bool: ...
+
+
+SC = TypeVar("SC", default=CameraStorage[dict[str, Any]], covariant=True)
 
 
 # StorageController
 @runtime_checkable
-class StorageController(Protocol):
+class StorageController(Protocol[SC]):
     def create_camera_storage(
         self,
         instance: Any,
         camera_id: str,
-        schema: Optional[PluginJsonSchemaForm] = None,
-    ) -> CameraStorage: ...
-    def get_camera_storage(self, camera_id: str) -> Optional[CameraStorage]: ...
+        schema: Optional[JsonSchemaForm] = None,
+    ) -> SC: ...
+    def get_camera_storage(self, camera_id: str) -> Optional[SC]: ...
     def remove_camera_storage(self, camera_id: str) -> None: ...
 
 
@@ -1123,13 +1087,15 @@ class PluginConfigService(Protocol):
 # Plugin API
 APIEventType = Literal["finishLaunching", "shutdown"]
 
+PA = TypeVar("PA", bound=CameraStorage[Any], default=CameraStorage[Any])
+
 
 @runtime_checkable
-class PluginAPI(Protocol):
+class PluginAPI(Protocol[PA]):
     storage_path: str
     config_file: str
     config_service: PluginConfigService
-    storage_controller: StorageController
+    storage_controller: StorageController[PA]
     device_manager: DeviceManager
 
     def on(self, event: APIEventType, listener: Callback) -> "PluginAPI": ...

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: