@camera.ui/server 0.0.70 → 0.0.71

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

@@ -0,0 +1,169 @@
+import time
+from typing import Any, Protocol
+
+from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
+from _camera_ui_tools.camera_ui_sdk import (
+    Observable,
+    SensorLike,
+    SensorPropertyChangeData,
+    SensorType,
+    Subject,
+)
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.typings import SensorRefreshedState, StoredSensorData
+
+
+class SensorProxy(SensorLike):
+    def __init__(
+        self, data: StoredSensorData, proxy: RPCClient, owner_namespace: str, camera_id: str
+    ) -> None:
+        self._id = data["id"]
+        self._type = data["type"]
+        self._name = data["name"]
+        self._display_name = data.get("displayName", data["name"])
+        self._owner_id = data["pluginId"]
+        self._camera_id = camera_id
+        self._proxy = proxy
+        self._properties: dict[str, Any] = dict(data.get("properties", {}))
+        self._capabilities: list[str] = list(data.get("capabilities", []))
+        self._rpc_proxy = proxy.create_proxy(owner_namespace)
+        self._property_changed_subject: Subject[SensorPropertyChangeData] = Subject()
+        self._capabilities_changed_subject: Subject[list[str]] = Subject()
+        self._event_subscription: CloseHandler | None = None
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def type(self) -> SensorType:
+        return self._type
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def displayName(self) -> str:
+        return self._display_name
+
+    @displayName.setter
+    def displayName(self, value: str) -> None:
+        self._display_name = value
+
+    @property
+    def pluginId(self) -> str:
+        return self._owner_id
+
+    @property
+    def capabilities(self) -> list[str]:
+        return self._capabilities.copy()
+
+    def hasCapability(self, capability: str) -> bool:
+        return capability in self._capabilities
+
+    def getValue(self, property: str) -> Any | None:
+        return self._properties.get(property)
+
+    def getValues(self) -> dict[str, Any]:
+        return self._properties.copy()
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        await self._rpc_proxy.updateValue(property, value)
+
+    @property
+    def onPropertyChanged(self) -> Observable[SensorPropertyChangeData]:
+        return self._property_changed_subject.as_observable()
+
+    @property
+    def onCapabilitiesChanged(self) -> Observable[list[str]]:
+        return self._capabilities_changed_subject.as_observable()
+
+    def _update_cached_value(self, property: str, value: Any, timestamp: int | None = None) -> None:
+        self._properties[property] = value
+        self._property_changed_subject.next(
+            {"property": property, "value": value, "timestamp": timestamp or int(time.time() * 1000)}
+        )
+
+    def _set_display_name(self, display_name: str) -> None:
+        self._display_name = display_name
+
+    def _update_capabilities(self, capabilities: list[str]) -> None:
+        self._capabilities = capabilities
+        self._capabilities_changed_subject.next(capabilities)
+
+    def _apply_refreshed_state(self, state: SensorRefreshedState) -> None:
+        self._capabilities = list(state["capabilities"])
+        if "displayName" in state:
+            self._display_name = state["displayName"]
+        for key, value in state.get("properties", {}).items():
+            self._update_cached_value(key, value)
+
+    async def _subscribe_to_events(self) -> None:
+        if self._event_subscription is not None:
+            return  # Already subscribed
+
+        namespace = NamespaceManager.sensor_event_namespaces(self._camera_id, self._id)
+        self._event_subscription = await self._proxy.subscribe(
+            namespace.sensor_subject, self._handle_sensor_event
+        )
+
+    async def _unsubscribe_from_events(self) -> None:
+        if self._event_subscription is not None:
+            await self._event_subscription()
+            self._event_subscription = None
+
+    def _handle_sensor_event(self, event: dict[str, Any]) -> None:
+        event_type = event.get("type")
+        data = event.get("data", {})
+
+        if event_type == "property:changed":
+            self._update_cached_value(data.get("property"), data.get("value"), data.get("timestamp"))
+
+        elif event_type == "sensor:capabilities:changed":
+            self._update_capabilities(data.get("capabilities", []))
+
+        elif event_type == "sensor:displayName:changed":
+            self._set_display_name(data.get("displayName", self._name))
+
+    def to_stored_data(self) -> StoredSensorData:
+        data: StoredSensorData = {
+            "id": self._id,
+            "type": self._type,
+            "name": self._name,
+            "displayName": self._display_name,
+            "pluginId": self._owner_id,
+            "properties": self.getValues(),
+            "capabilities": self._capabilities,
+        }
+
+        return data
+
+    @property
+    def is_available(self) -> bool:
+        return self._id != ""
+
+
+class SensorControllerInterface(Protocol):
+    async def registerSensor(self, sensor: dict[str, Any], plugin_id: str) -> bool: ...
+    async def unregisterSensor(self, sensor_id: str) -> None: ...
+    async def updatePropertyValues(self, sensor_id: str, properties: dict[str, Any]) -> None: ...
+    async def updateCapabilities(self, sensor_id: str, capabilities: list[str]) -> None: ...
+    async def getPropertyValue(self, sensor_id: str, property: str) -> Any: ...
+    async def getAllPropertyValues(self, sensor_id: str) -> dict[str, Any]: ...
+    async def getSensorState(self, sensor_id: str) -> SensorRefreshedState: ...
+    async def getSensorStates(self) -> dict[str, SensorRefreshedState]: ...
+    async def getSensors(self, plugin_id: str | None = None) -> list[StoredSensorData]: ...
+    async def getSensor(self, sensor_id: str, plugin_id: str | None = None) -> StoredSensorData | None: ...
+    async def getSensorByType(
+        self, sensor_type: SensorType, plugin_id: str | None = None
+    ) -> StoredSensorData | None: ...
+    async def setDisplayName(self, sensor_id: str, display_name: str) -> None: ...
+
+
+class DetectionCoordinatorRPC(Protocol):
+    async def reportSensorWrite(
+        self, sensor_id: str, sensor_type: SensorType, properties: dict[str, Any]
+    ) -> None: ...
+
+    async def unregisterSensor(self, sensor_id: str) -> None: ...

package/dist/server/src/plugins/runtime/python/rpc/typings.py

@@ -0,0 +1,56 @@
+from typing import Protocol, TypedDict
+
+from _camera_ui_tools.camera_ui_sdk import (
+    Camera,
+    CreateDownloadOptions,
+    CreateStreamDownloadOptions,
+    DiscoveredCamera,
+    DownloadToken,
+    PluginInterface,
+    ProbeConfig,
+    ProbeStream,
+)
+from _camera_ui_tools.camera_ui_sdk.internal import SensorJSON
+
+from ..typings import PluginInfo, SensorRefreshedState
+
+
+class RefreshedStates(TypedDict):
+    camera: Camera
+    cameraState: bool
+    frameWorkerState: bool
+    sensorStates: dict[str, SensorRefreshedState]
+
+
+class CoreManagerInterface(Protocol):
+    async def getFFmpegPath(self) -> str: ...
+    async def getServerAddresses(self) -> list[str]: ...
+    async def getPlugin(self, pluginName: str) -> PluginInfo | None: ...
+    async def getPluginsByInterface(self, interfaceName: PluginInterface) -> list[PluginInfo]: ...
+
+
+class DeviceManagerInterface(Protocol):
+    async def getCamera(self, camera_name_or_id: str, plugin_id: str) -> Camera | None: ...
+
+
+class CameraDeviceInterface(Protocol):
+    async def refreshStates(self) -> RefreshedStates: ...
+    async def connect(self) -> None: ...
+    async def disconnect(self) -> None: ...
+    async def snapshot(self, source_id: str, force_new: bool = False) -> bytes | None: ...
+    async def probeStream(
+        self, source_id: str, probe_config: ProbeConfig | None = None, refresh: bool = False
+    ) -> ProbeStream | None: ...
+    async def streamUrl(self, source_id: str) -> str | None: ...
+    async def registerSensor(self, sensor_json: SensorJSON, plugin_id: str) -> bool: ...
+    def unregisterSensor(self, sensor_id: str) -> None: ...
+
+
+class DiscoveryManagerInterface(Protocol):
+    async def pushDiscoveredCameras(self, plugin_id: str, cameras: list[DiscoveredCamera]) -> None: ...
+
+
+class DownloadManagerInterface(Protocol):
+    async def createDownload(self, options: CreateDownloadOptions) -> DownloadToken: ...
+    async def createStreamDownload(self, options: CreateStreamDownloadOptions) -> DownloadToken: ...
+    async def deleteDownload(self, token: str) -> None: ...

package/dist/server/src/plugins/runtime/python/schema.py

@@ -1,17 +1,53 @@
-from typing import Any, Optional, Union, cast
+from typing import TypeGuard, cast
 
-from _camera_ui_tools.camera_ui_types import (
+from _camera_ui_tools.camera_ui_sdk import (
     JsonSchema,
+    JsonSchemaArray,
+    JsonSchemaBoolean,
+    JsonSchemaButton,
+    JsonSchemaEnum,
+    JsonSchemaNumber,
+    JsonSchemaString,
+    JsonSchemaSubmit,
     JsonSchemaWithoutCallbacks,
-    JsonSchemaWithoutCallbacksAndKey,
+    JsonSchemaWithoutKey,
 )
 
+SchemaDefaultValue = str | int | float | bool | list[str] | list[int] | list[float] | list[bool] | None
 
-# Generate default value for a schema field
-def generate_default_value(schema: JsonSchema) -> Any:
+
+def is_string_type(schema: JsonSchema) -> TypeGuard[JsonSchemaString]:
+    return schema.get("type") == "string" and "enum" not in schema
+
+
+def is_number_type(schema: JsonSchema) -> TypeGuard[JsonSchemaNumber]:
+    return schema.get("type") == "number"
+
+
+def is_boolean_type(schema: JsonSchema) -> TypeGuard[JsonSchemaBoolean]:
+    return schema.get("type") == "boolean"
+
+
+def is_enum_type(schema: JsonSchema) -> TypeGuard[JsonSchemaEnum]:
+    return schema.get("type") == "string" and "enum" in schema
+
+
+def is_array_type(schema: JsonSchema) -> TypeGuard[JsonSchemaArray]:
+    return schema.get("type") == "array"
+
+
+def is_button_type(schema: JsonSchema) -> TypeGuard[JsonSchemaButton]:
+    return schema.get("type") == "button"
+
+
+def is_submit_type(schema: JsonSchema) -> TypeGuard[JsonSchemaSubmit]:
+    return schema.get("type") == "submit"
+
+
+def generate_default_value(schema: JsonSchema) -> SchemaDefaultValue:
     # Return explicit default if provided
     if "defaultValue" in schema:
-        return schema["defaultValue"]
+        return cast(SchemaDefaultValue, schema["defaultValue"])
 
     # Generate default based on type
     match schema["type"]:
@@ -32,13 +68,12 @@ def generate_default_value(schema: JsonSchema) -> Any:
             return None
 
 
-# Generate a config object from schema definitions
-def generate_config_from_schemas(schemas: list[JsonSchema]) -> dict[str, Any]:
-    config: dict[str, Any] = {}
+def generate_config_from_schemas(schemas: list[JsonSchema]) -> dict[str, SchemaDefaultValue]:
+    config: dict[str, SchemaDefaultValue] = {}
 
     for schema in schemas:
         # Skip button and submit types as they don't have values
-        if schema["type"] == "button" or schema["type"] == "submit":
+        if is_button_type(schema) or is_submit_type(schema):
             continue
 
         config[schema["key"]] = generate_default_value(schema)
@@ -46,7 +81,9 @@ def generate_config_from_schemas(schemas: list[JsonSchema]) -> dict[str, Any]:
     return config
 
 
-def get_value_by_key(config: Optional[dict[str, Any]] = None, key: str = "") -> Any:
+def get_value_by_key(
+    config: dict[str, SchemaDefaultValue] | None = None, key: str = ""
+) -> SchemaDefaultValue:
     if config is None:
         config = {}
 
@@ -66,25 +103,24 @@ def get_value_by_key(config: Optional[dict[str, Any]] = None, key: str = "") ->
         else:
             keys.append(part)
 
-    current: Any = config
+    current: SchemaDefaultValue | dict[str, SchemaDefaultValue] = config
     for k in keys:
-        if current is None or not isinstance(current, (dict, list)):
+        if current is None or not isinstance(current, dict | list):
             return None
 
         if isinstance(current, dict):
-            current = cast(Any, current.get(k))
+            current = current.get(k)  # type: ignore[assignment]
         elif k.isdigit():
             index = int(k)
-            current = cast(Any, current[index] if 0 <= index < len(current) else None)
+            current = current[index] if 0 <= index < len(current) else None  # type: ignore[index,assignment]
         else:
             return None
 
-    return current
+    return cast(SchemaDefaultValue, current)
 
 
-# Remove callback functions from schema - useful for serialization
 def remove_callbacks_from_schema(
-    schema: Union[JsonSchema, JsonSchemaWithoutCallbacks, JsonSchemaWithoutCallbacksAndKey],
+    schema: JsonSchema | JsonSchemaWithoutCallbacks | JsonSchemaWithoutKey,
 ) -> JsonSchemaWithoutCallbacks:
     rest = {k: v for k, v in schema.items() if k not in ["onSet", "onGet", "onClick"]}
 
@@ -94,6 +130,5 @@ def remove_callbacks_from_schema(
     return cast(JsonSchemaWithoutCallbacks, rest)
 
 
-# Remove callbacks from all schemas
 def remove_callbacks_from_schemas(schemas: list[JsonSchema]) -> list[JsonSchemaWithoutCallbacks]:
     return [remove_callbacks_from_schema(schema) for schema in schemas]

package/dist/server/src/plugins/runtime/python/storage.py

@@ -1,48 +1,49 @@
 import asyncio
 import inspect
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from contextlib import suppress
 from copy import deepcopy
-from typing import Any, Callable, Optional, TypeVar, Union, cast
+from typing import Any, Literal, cast
 
 from deepdiff.diff import DeepDiff
 from lmdbm import Lmdb
-from typing_extensions import Literal, overload
 
 from _camera_ui_tools.camera_ui_common import ObjectPath, merge, merge_with
-from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
-from _camera_ui_tools.camera_ui_rpc_client.utils.rpc import rpc
-from _camera_ui_tools.camera_ui_types import (
-    V1,
+from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient, RPCMethod
+from _camera_ui_tools.camera_ui_sdk import (
+    API_EVENT,
     FormSubmitResponse,
     JsonSchema,
     PluginAPI,
     SchemaConfig,
 )
-from _camera_ui_tools.camera_ui_types import DeviceStorage as DeviceStorageInterface
+from _camera_ui_tools.camera_ui_sdk import DeviceStorage as DeviceStorageInterface
 from plugins.runtime.python.namespaces import (
     NamespaceManager,
-    PluginAndPluginCameraNamespaces,
 )
 from plugins.runtime.python.schema import (
     generate_config_from_schemas,
     get_value_by_key,
+    is_button_type,
+    is_submit_type,
     remove_callbacks_from_schemas,
 )
-from plugins.runtime.python.typings import API_EVENT, PluginInfo
+from plugins.runtime.python.typings import PluginInfo
 
-P = TypeVar("P", str, int, float, bool, dict[Any, Any], list[Any], None)
+ConfigDict = dict[str, Any]
 
-TKey = Union[str, int, None]
+OnSetCallback = Callable[[Any, Any], Awaitable[None] | None]
+OnGetCallback = Callable[[], Awaitable[Any] | Any]
+OnClickCallback = Callable[[Any], Awaitable[FormSubmitResponse | None] | FormSubmitResponse | None]
 
 
 def merge2(
     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
-    stack: list[Any],
+    key: str | int | None,
+    source_object: Any,
+    target_object: Any,
+    stack: list[dict[Any, Any]],
 ) -> Any:
     if isinstance(source, list):
         return target
@@ -55,13 +56,14 @@ class DeviceStorage(DeviceStorageInterface):
     def __init__(
         self,
         api: PluginAPI,
-        proxy: ClientInstance,
+        proxy: RPCClient,
         plugin: PluginInfo,
         plugin_db: Lmdb[Literal["config"], dict[str, Any]],
-        instance: Any,
         device_id: str,
-        schemas: Optional[list[JsonSchema]] = [],
+        schemas: list[JsonSchema] | None = [],
         is_plugin_storage: bool = False,
+        sensor_id: str | None = None,
+        camera_id: str | None = None,
     ) -> None:
         if schemas is None:
             schemas = []
@@ -73,27 +75,28 @@ class DeviceStorage(DeviceStorageInterface):
         self.__proxy = proxy
         self.__plugin = plugin
         self.__plugin_db = plugin_db
-        self.__instance = instance
         self.__device_id = device_id
         self.__is_plugin_storage = is_plugin_storage
+        self.__sensor_id = sensor_id
+        self.__camera_id = camera_id
+        self.__close_proxy: CloseHandler | None = None
+
+        if self.__sensor_id is not None and self.__camera_id is not None:
+            sensor_ns = NamespaceManager.plugin_sensor_namespaces(
+                plugin["id"], self.__camera_id, self.__sensor_id
+            )
+            self.__storage_namespace = sensor_ns.sensor_storage_rpc
+        elif self.__is_plugin_storage:
+            plugin_ns = NamespaceManager.plugin_namespaces(plugin["id"])
+            self.__storage_namespace = plugin_ns.plugin_storage_rpc
+        else:
+            camera_ns = NamespaceManager.plugin_camera_namespaces(plugin["id"], self.__device_id)
+            self.__storage_namespace = camera_ns.camera_storage_rpc
 
-        namespaces: PluginAndPluginCameraNamespaces = {
-            **NamespaceManager.plugin_camera_namespaces(plugin["id"], device_id),
-            **NamespaceManager.plugin_namespaces(plugin["id"]),
-        }
-
-        self.__storage_namespace = (
-            namespaces["cameraStorageRpc"] if not is_plugin_storage else namespaces["pluginStorageRpc"]
-        )
-
-        self.__api.once(API_EVENT.SHUTDOWN.value, self.__close)
+        self.__api.once(API_EVENT.SHUTDOWN, self.__close)
 
-    @overload
-    async def getValue(self, key: str) -> Union[V1, None]: ...
-    @overload
-    async def getValue(self, key: str, default_value: V1) -> V1: ...
-    @rpc(public=True)
-    async def getValue(self, key: str, default_value: Optional[V1] = None) -> Union[V1, None]:
+    @RPCMethod
+    async def getValue(self, key: str, default_value: Any | None = None) -> Any:
         schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
         config_value = ObjectPath.get(self.values, key)
         schema_default_value = (
@@ -124,7 +127,7 @@ class DeviceStorage(DeviceStorageInterface):
 
         return None
 
-    @rpc(public=True)
+    @RPCMethod
     async def setValue(self, key: str, new_value: Any) -> None:
         schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
 
@@ -147,8 +150,8 @@ class DeviceStorage(DeviceStorageInterface):
             if self.__contains_storable_schema(schema):
                 self.save()
 
-    @rpc(public=True)
-    async def submitValue(self, key: str, new_value: Any) -> Union[FormSubmitResponse, None]:
+    @RPCMethod
+    async def submitValue(self, key: str, new_value: Any) -> FormSubmitResponse | None:
         schema: Any = next((schema for schema in self.schemas if schema["key"] == key), None)
 
         if schema and schema["type"] == "submit":
@@ -166,19 +169,24 @@ class DeviceStorage(DeviceStorageInterface):
 
         return None
 
-    @rpc(public=True)
+    @RPCMethod
+    def setInternalValue(self, key: str, value: Any) -> None:
+        ObjectPath.set(self.values, key, value)
+        self.save()
+
+    @RPCMethod
     def hasValue(self, key: str) -> bool:
         config_value = ObjectPath.get(self.values, key)
         return config_value is not None
 
-    @rpc(public=True)
+    @RPCMethod
     async def getConfig(self) -> SchemaConfig:
         await self.__resolve_on_get_functions(self.schemas)
         filtered_schema: Any = remove_callbacks_from_schemas(self.schemas)
         schema_config: SchemaConfig = {"schema": filtered_schema, "config": self.values}
         return schema_config
 
-    @rpc(public=True)
+    @RPCMethod
     async def setConfig(self, new_config: dict[str, Any]) -> None:
         old_config = deepcopy(self.values)
         self.values = merge_with(self.values, new_config, merge)
@@ -186,7 +194,7 @@ class DeviceStorage(DeviceStorageInterface):
         await self.__trigger_on_set_for_changes(old_config, self.values)
         self.save()
 
-    @rpc(public=True)
+    @RPCMethod
     async def addSchema(self, schema: JsonSchema) -> None:
         should_save = False
 
@@ -205,7 +213,7 @@ class DeviceStorage(DeviceStorageInterface):
         if should_save:
             self.save()
 
-    @rpc(public=True)
+    @RPCMethod
     def removeSchema(self, key: str) -> None:
         schema = next((schema for schema in self.schemas if schema["key"] == key), None)
         self.schemas = [s for s in self.schemas if s["key"] != key]
@@ -214,7 +222,7 @@ class DeviceStorage(DeviceStorageInterface):
         if schema and self.__contains_storable_schema(schema):
             self.save()
 
-    @rpc(public=True)
+    @RPCMethod
     async def changeSchema(self, key: str, new_schema: dict[str, Any]) -> None:
         new_schema["key"] = key
         schema = next((schema for schema in self.schemas if schema["key"] == new_schema["key"]), None)
@@ -227,17 +235,17 @@ class DeviceStorage(DeviceStorageInterface):
             if self.__contains_storable_schema(schema):
                 self.save()
 
-    @rpc(public=True)
-    def getSchema(self, key: str) -> Optional[JsonSchema]:
+    @RPCMethod
+    def getSchema(self, key: str) -> JsonSchema | None:
         return next((schema for schema in self.schemas if schema["key"] == key), None)
 
-    @rpc(public=True)
+    @RPCMethod
     def hasSchema(self, key: str) -> bool:
         return any(schema["key"] == key for schema in self.schemas)
 
-    @rpc(public=True)
+    @RPCMethod
     async def destroy(self) -> None:
-        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.__close)
+        self.__api.removeListener(API_EVENT.SHUTDOWN, self.__close)
         config: Any = cast(dict[str, Any], self.__plugin_db.get("config") or {})
         if self.__device_id in config:
             del config[self.__device_id]
@@ -255,29 +263,33 @@ class DeviceStorage(DeviceStorageInterface):
         config[self.__device_id] = storable_config
         self.__plugin_db.update({"config": config})
 
+    def defineSchemas(self, schemas: list[JsonSchema]) -> None:
+        self.schemas = schemas
+        self.__initializeStorage()
+
     # Internal method
-    def update_schema(self, instance: Any, schemas: list[JsonSchema] = []) -> None:
-        self.__instance = instance
+    def update_schema(self, schemas: list[JsonSchema] = []) -> None:
         self.schemas = schemas
         self.__initializeStorage()
 
     # Internal method
     async def register_storage(self) -> None:
-        await self.__proxy.register_rpc_handler(self.__storage_namespace, self)
+        self.__close_proxy = await self.__proxy.register_handler(self.__storage_namespace, self)
 
     # Internal method
     async def unregister_storage(self) -> None:
-        await self.__proxy.unregister_rpc_handler(self.__storage_namespace)
+        if self.__close_proxy:
+            await self.__close_proxy()
 
     async def __resolve_on_get_functions(
         self,
-        schemas: Union[JsonSchema, list[JsonSchema]],
+        schemas: JsonSchema | list[JsonSchema],
     ) -> None:
         if not isinstance(schemas, list):
             schemas = [schemas]
 
         for schema in schemas:
-            if schema["type"] != "button" and schema["type"] != "submit" and "onGet" in schema:
+            if not is_button_type(schema) and not is_submit_type(schema) and "onGet" in schema:
                 schema_value = await self.getValue(schema["key"])
                 if schema_value is not None:
                     ObjectPath.set(self.values, schema["key"], schema_value)
@@ -285,9 +297,9 @@ class DeviceStorage(DeviceStorageInterface):
     async def __trigger_on_set_for_changes(
         self, old_config: dict[str, Any], new_config: dict[str, Any]
     ) -> None:
-        tasks: list[Awaitable[Union[None, Any]]] = []
+        tasks: list[Awaitable[None | Any]] = []
 
-        for config_key, _ in new_config.items():
+        for config_key in list(new_config.keys()):
             old_value: Any = get_value_by_key(old_config, config_key) or {}
             new_value: Any = new_config[config_key]
 
@@ -298,10 +310,8 @@ class DeviceStorage(DeviceStorageInterface):
                     if on_set_function:
 
                         async def process_on_set(
-                            func: Union[
-                                Callable[[Any, Any], Awaitable[Union[None, Any]]],
-                                Callable[[Any, Any], Union[None, Any]],
-                            ],
+                            func: Callable[[Any, Any], Awaitable[None | Any]]
+                            | Callable[[Any, Any], None | Any],
                             new_val: Any,
                             old_val: Any,
                         ) -> None:
@@ -320,23 +330,31 @@ class DeviceStorage(DeviceStorageInterface):
     def __filter_storable_values(
         self,
         schemas: list[JsonSchema],
-        result: dict[str, Any] = {},
-    ) -> dict[str, Any]:
+        result: ConfigDict | None = None,
+    ) -> ConfigDict:
+        if result is None:
+            result = {}
+
         for schema in schemas:
-            if schema["type"] == "button" or schema["type"] == "submit":
+            if is_button_type(schema) or is_submit_type(schema):
                 continue
 
             if "store" in schema and schema["store"]:
                 config_value = get_value_by_key(self.values, schema["key"])
                 ObjectPath.set(result, schema["key"], config_value)
 
+        # Preserve internal values (prefixed with '_') that have no schema
+        for key, value in self.values.items():
+            if key.startswith("_"):
+                result[key] = value
+
         return result
 
     def __contains_storable_schema(
         self,
         schema: JsonSchema,
     ) -> bool:
-        if schema["type"] == "button" or schema["type"] == "submit":
+        if is_button_type(schema) or is_submit_type(schema):
             return False
 
         return bool("store" in schema and schema["store"])