@camera.ui/server 2.1.0 → 2.1.2

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/cold.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class ColdProperty(StrEnum):
+    """Property names of a cold sensor."""
+
+    Detected = "detected"
+    """Whether abnormal cold is detected."""
+
+
+class ColdSensorProperties(TypedDict):
+    """Property values of a cold sensor."""
+
+    detected: bool
+
+
+class ColdPropertyChangeData(TypedDict):
+    """Property change payload emitted on ColdSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a ColdProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class ColdSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a cold sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Cold
+
+    @property
+    def onPropertyChanged(self) -> Observable[ColdPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[ColdProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class ColdSensor(Sensor[ColdSensorProperties, TStorage, str], Generic[TStorage]):
+    """Cold alarm sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Cold Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({ColdProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Cold
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report abnormal cold detection state.
+
+        Args:
+            value: True when cold is currently detected.
+
+        Example:
+            ```python
+            cold.setDetected(True)
+            ```
+        """
+        self._write_state({ColdProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/gas.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class GasProperty(StrEnum):
+    """Property names of a gas sensor."""
+
+    Detected = "detected"
+    """Whether gas is detected."""
+
+
+class GasSensorProperties(TypedDict):
+    """Property values of a gas sensor."""
+
+    detected: bool
+
+
+class GasPropertyChangeData(TypedDict):
+    """Property change payload emitted on GasSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a GasProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class GasSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a gas sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Gas
+
+    @property
+    def onPropertyChanged(self) -> Observable[GasPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[GasProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class GasSensor(Sensor[GasSensorProperties, TStorage, str], Generic[TStorage]):
+    """Gas detector sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Gas Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({GasProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Gas
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report gas detection state.
+
+        Args:
+            value: True when gas is currently detected.
+
+        Example:
+            ```python
+            gas.setDetected(True)
+            ```
+        """
+        self._write_state({GasProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/heat.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class HeatProperty(StrEnum):
+    """Property names of a heat sensor."""
+
+    Detected = "detected"
+    """Whether abnormal heat is detected."""
+
+
+class HeatSensorProperties(TypedDict):
+    """Property values of a heat sensor."""
+
+    detected: bool
+
+
+class HeatPropertyChangeData(TypedDict):
+    """Property change payload emitted on HeatSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a HeatProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class HeatSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a heat sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Heat
+
+    @property
+    def onPropertyChanged(self) -> Observable[HeatPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[HeatProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class HeatSensor(Sensor[HeatSensorProperties, TStorage, str], Generic[TStorage]):
+    """Heat alarm sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Heat Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({HeatProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Heat
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report abnormal heat detection state.
+
+        Args:
+            value: True when heat is currently detected.
+
+        Example:
+            ```python
+            heat.setDetected(True)
+            ```
+        """
+        self._write_state({HeatProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/illuminance.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class IlluminanceProperty(StrEnum):
+    """Property names of an illuminance sensor."""
+
+    Current = "current"
+    """Current illuminance in lux."""
+
+
+class IlluminanceInfoProperties(TypedDict):
+    """Property values of an illuminance sensor."""
+
+    current: float
+
+
+class IlluminancePropertyChangeData(TypedDict):
+    """Property change payload emitted on IlluminanceInfoLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a IlluminanceProperty value."""
+    value: float
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class IlluminanceInfoLike(SensorLike, Protocol):
+    """Read-only proxy interface for an illuminance sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Illuminance
+
+    @property
+    def onPropertyChanged(self) -> Observable[IlluminancePropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[IlluminanceProperty.Current]) -> float | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class IlluminanceInfo(Sensor[IlluminanceInfoProperties, TStorage, str], Generic[TStorage]):
+    """Illuminance info sensor. Reports current light level in lux."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Illuminance", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({IlluminanceProperty.Current.value: 0})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Illuminance
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Info
+
+    @property
+    def current(self) -> float:
+        value = self.props.current
+        return float(value) if value is not None else 0.0
+
+    def setCurrent(self, value: float) -> None:
+        """Report a new illuminance reading. Clamped to [0, 200000] lx.
+
+        Args:
+            value: Illuminance reading in lux.
+
+        Example:
+            ```python
+            illuminance.setCurrent(120)
+            ```
+        """
+        self._write_state({IlluminanceProperty.Current.value: max(0, min(200000, value))})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/power.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class PowerProperty(StrEnum):
+    """Property names of a power sensor."""
+
+    Detected = "detected"
+    """Whether power is detected."""
+
+
+class PowerSensorProperties(TypedDict):
+    """Property values of a power sensor."""
+
+    detected: bool
+
+
+class PowerPropertyChangeData(TypedDict):
+    """Property change payload emitted on PowerSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a PowerProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class PowerSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a power sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Power
+
+    @property
+    def onPropertyChanged(self) -> Observable[PowerPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[PowerProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class PowerSensor(Sensor[PowerSensorProperties, TStorage, str], Generic[TStorage]):
+    """Power detection sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Power Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({PowerProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Power
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report power detection state.
+
+        Args:
+            value: True when power is currently detected.
+
+        Example:
+            ```python
+            power.setDetected(True)
+            ```
+        """
+        self._write_state({PowerProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/problem.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class ProblemProperty(StrEnum):
+    """Property names of a problem sensor."""
+
+    Detected = "detected"
+    """Whether a problem is detected."""
+
+
+class ProblemSensorProperties(TypedDict):
+    """Property values of a problem sensor."""
+
+    detected: bool
+
+
+class ProblemPropertyChangeData(TypedDict):
+    """Property change payload emitted on ProblemSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a ProblemProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class ProblemSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a problem sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Problem
+
+    @property
+    def onPropertyChanged(self) -> Observable[ProblemPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[ProblemProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class ProblemSensor(Sensor[ProblemSensorProperties, TStorage, str], Generic[TStorage]):
+    """Generic problem/fault sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Problem Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({ProblemProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Problem
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report the problem state.
+
+        Args:
+            value: True when problem is currently detected.
+
+        Example:
+            ```python
+            problem.setDetected(True)
+            ```
+        """
+        self._write_state({ProblemProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""

package/dist/server/src/_camera_ui_tools/camera_ui_sdk/sensor/tamper.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Any, Generic, Literal, Protocol, overload, runtime_checkable
+
+from typing_extensions import TypedDict, TypeVar
+
+from ..observable import Observable
+from .base import Sensor, SensorCategory, SensorLike, SensorType
+
+
+class TamperProperty(StrEnum):
+    """Property names of a tamper sensor."""
+
+    Detected = "detected"
+    """Whether tampering is detected."""
+
+
+class TamperSensorProperties(TypedDict):
+    """Property values of a tamper sensor."""
+
+    detected: bool
+
+
+class TamperPropertyChangeData(TypedDict):
+    """Property change payload emitted on TamperSensorLike.onPropertyChanged."""
+
+    property: str
+    """Name of the changed property, a TamperProperty value."""
+    value: bool
+    """New value of the property."""
+
+
+TStorage = TypeVar("TStorage", bound=Mapping[str, Any], default=dict[str, Any])
+
+
+@runtime_checkable
+class TamperSensorLike(SensorLike, Protocol):
+    """Read-only proxy interface for a tamper sensor."""
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Tamper
+
+    @property
+    def onPropertyChanged(self) -> Observable[TamperPropertyChangeData]: ...
+
+    @overload
+    def getValue(self, property: Literal[TamperProperty.Detected]) -> bool | None: ...
+    @overload
+    def getValue(self, property: str) -> object | None: ...
+
+
+class TamperSensor(Sensor[TamperSensorProperties, TStorage, str], Generic[TStorage]):
+    """Tamper sensor."""
+
+    _requires_frames = False
+
+    def __init__(self, name: str = "Tamper Sensor", *, native_id: str | None = None) -> None:
+        super().__init__(name, native_id=native_id)
+        self._write_state({TamperProperty.Detected.value: False})
+
+    @property
+    def type(self) -> SensorType:
+        return SensorType.Tamper
+
+    @property
+    def category(self) -> SensorCategory:
+        return SensorCategory.Sensor
+
+    @property
+    def detected(self) -> bool:
+        return bool(self.props.detected)
+
+    def setDetected(self, value: bool) -> None:
+        """Report tampering detection state.
+
+        Args:
+            value: True when tamper is currently detected.
+
+        Example:
+            ```python
+            tamper.setDetected(True)
+            ```
+        """
+        self._write_state({TamperProperty.Detected.value: value})
+
+    async def updateValue(self, property: str, value: Any) -> None:
+        """Read-only sensor: external writes are ignored."""