axis 66__tar.gz → 68__tar.gz

axis-68/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: axis
+Version: 68
+Summary: A Python library for communicating with devices from Axis Communications
+Author-email: Robert Svensson <Kane610@users.noreply.github.com>
+License: MIT
+Project-URL: Source Code, https://github.com/Kane610/axis
+Project-URL: Bug Reports, https://github.com/Kane610/axis/issues
+Project-URL: Forum, https://community.home-assistant.io/t/axis-camera-component/
+Keywords: axis,vapix,homeassistant
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.14.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.12
+Requires-Dist: faust-cchardet>=2.1.18
+Requires-Dist: httpx>=0.26
+Requires-Dist: orjson>3.9
+Requires-Dist: packaging>23
+Requires-Dist: xmltodict>=0.13.0
+Provides-Extra: requirements
+Requires-Dist: aiohttp==3.13.5; extra == "requirements"
+Requires-Dist: httpx==0.28.1; extra == "requirements"
+Requires-Dist: orjson==3.11.8; extra == "requirements"
+Requires-Dist: packaging==26.0; extra == "requirements"
+Requires-Dist: xmltodict==1.0.4; extra == "requirements"
+Provides-Extra: requirements-test
+Requires-Dist: mypy==1.20.0; extra == "requirements-test"
+Requires-Dist: pytest==9.0.2; extra == "requirements-test"
+Requires-Dist: pytest-aiohttp==1.1.0; extra == "requirements-test"
+Requires-Dist: pytest-asyncio==1.3.0; extra == "requirements-test"
+Requires-Dist: pytest-cov==7.1.0; extra == "requirements-test"
+Requires-Dist: respx==0.22.0; extra == "requirements-test"
+Requires-Dist: ruff==0.15.9; extra == "requirements-test"
+Requires-Dist: types-xmltodict==v1.0.1.20260113; extra == "requirements-test"
+Provides-Extra: requirements-dev
+Requires-Dist: pre-commit==4.5.1; extra == "requirements-dev"
+Dynamic: license-file
+
+# axis
+
+Python project to set up a connection towards Axis Communications devices and to subscribe to specific events on the metadatastream.
+
+## Development setup
+
+`uv` is required for development setup:
+
+```bash
+uv python install 3.14
+uv sync --python 3.14 --all-extras
+```
+
+Or run the bootstrap script, which installs `uv` if needed and provisions Python 3.14 automatically:
+
+```bash
+./setup.sh
+```
+
+Dependencies are locked via `uv.lock`. Regenerate lock data when dependency inputs change:
+
+```bash
+uv lock
+```
+
+Run checks with `uv`:
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy axis
+uv run pytest
+```
+
+Initial `ty` support is configured as an opt-in check and does not replace `mypy`:
+
+```bash
+uvx ty check
+```
+
+## Initialization architecture
+
+Vapix initialization is phase-based and driven by handler metadata:
+
+- `API_DISCOVERY`: handlers initialized after API discovery.
+- `PARAM_CGI_FALLBACK`: handlers that may initialize from parameter support when not listed in discovery.
+- `APPLICATION`: handlers initialized after applications are loaded.
+
+Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
+
+Example fallback policy:
+
+- `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
+- In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.

axis-68/README.md

@@ -0,0 +1,54 @@
+# axis
+
+Python project to set up a connection towards Axis Communications devices and to subscribe to specific events on the metadatastream.
+
+## Development setup
+
+`uv` is required for development setup:
+
+```bash
+uv python install 3.14
+uv sync --python 3.14 --all-extras
+```
+
+Or run the bootstrap script, which installs `uv` if needed and provisions Python 3.14 automatically:
+
+```bash
+./setup.sh
+```
+
+Dependencies are locked via `uv.lock`. Regenerate lock data when dependency inputs change:
+
+```bash
+uv lock
+```
+
+Run checks with `uv`:
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy axis
+uv run pytest
+```
+
+Initial `ty` support is configured as an opt-in check and does not replace `mypy`:
+
+```bash
+uvx ty check
+```
+
+## Initialization architecture
+
+Vapix initialization is phase-based and driven by handler metadata:
+
+- `API_DISCOVERY`: handlers initialized after API discovery.
+- `PARAM_CGI_FALLBACK`: handlers that may initialize from parameter support when not listed in discovery.
+- `APPLICATION`: handlers initialized after applications are loaded.
+
+Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
+
+Example fallback policy:
+
+- `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
+- In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.

{axis-66 → axis-68}/axis/__main__.py

@@ -3,27 +3,37 @@
 import argparse
 import asyncio
 import logging
+from typing import TYPE_CHECKING
 
-from httpx import AsyncClient
+import aiohttp
 
 import axis
 from axis.device import AxisDevice
-from axis.models.configuration import Configuration
-from axis.models.event import Event
+from axis.models.configuration import Configuration, WebProtocol
+
+if TYPE_CHECKING:
+    from axis.models.event import Event
 
 LOGGER = logging.getLogger(__name__)
 
 
-def event_handler(event: Event) -> None:
+def event_handler(event: "Event") -> None:
     """Receive and print events from RTSP stream."""
     LOGGER.info(event)
 
 
 async def axis_device(
-    host: str, port: int, username: str, password: str, is_companion: bool = False
-) -> AxisDevice:
+    host: str,
+    port: int,
+    username: str,
+    password: str,
+    web_proto: WebProtocol,
+    stream_mode: str = "rtsp",
+    is_companion: bool = False,
+) -> axis.device.AxisDevice:
     """Create a Axis device."""
-    session = AsyncClient(verify=False)  # noqa: S501
+    session = create_session()
+    websocket_enabled, websocket_force = websocket_flags_from_mode(stream_mode)
     device = AxisDevice(
         Configuration(
             session,
@@ -32,6 +42,9 @@ async def axis_device(
             username=username,
             password=password,
             is_companion=is_companion,
+            web_proto=web_proto,
+            websocket_enabled=websocket_enabled,
+            websocket_force=websocket_force,
         )
     )
 
@@ -58,12 +71,26 @@ async def axis_device(
 
 
 async def main(
-    host: str, port: int, username: str, password: str, params: bool, events: bool
+    host: str,
+    port: int,
+    username: str,
+    password: str,
+    params: bool,
+    events: bool,
+    web_proto: WebProtocol,
+    stream_mode: str,
 ) -> None:
     """CLI method for library."""
     LOGGER.info("Connecting to Axis device")
 
-    device = await axis_device(host, port, username, password)
+    device = await axis_device(
+        host,
+        port,
+        username,
+        password,
+        web_proto=web_proto,
+        stream_mode=stream_mode,
+    )
 
     if not device:
         LOGGER.error("Couldn't connect to Axis device")
@@ -86,18 +113,48 @@ async def main(
         device.stream.stop()
 
     finally:
-        await device.config.session.aclose()
+        session = device.config.session
+        if not isinstance(session, aiohttp.ClientSession):
+            message = "Configured session is not an aiohttp ClientSession"
+            raise RuntimeError(message)
+        await close_session(session)
         device.stream.stop()
 
 
+def create_session() -> aiohttp.ClientSession:
+    """Create aiohttp session used for HTTP requests."""
+    connector = aiohttp.TCPConnector(ssl=False)
+    return aiohttp.ClientSession(connector=connector)
+
+
+async def close_session(session: aiohttp.ClientSession) -> None:
+    """Close aiohttp session."""
+    await session.close()
+
+
+def websocket_flags_from_mode(stream_mode: str) -> tuple[bool, bool]:
+    """Translate CLI stream mode to websocket enable/force flags."""
+    if stream_mode == "auto":
+        return True, False
+    if stream_mode == "event":
+        return True, True
+    return False, False
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("host", type=str)
     parser.add_argument("username", type=str)
     parser.add_argument("password", type=str)
-    parser.add_argument("-p", "--port", type=int, default=80)
+    parser.add_argument("-p", "--port", type=int, default=0)
+    parser.add_argument("--proto", type=str, default="http")
     parser.add_argument("--events", action="store_true")
     parser.add_argument("--params", action="store_true")
+    parser.add_argument(
+        "--stream-mode",
+        choices=["auto", "rtsp", "event"],
+        default="rtsp",
+    )
     parser.add_argument("-D", "--debug", action="store_true")
     args = parser.parse_args()
 
@@ -125,6 +182,8 @@ if __name__ == "__main__":
                 port=args.port,
                 params=args.params,
                 events=args.events,
+                web_proto=WebProtocol(args.proto),
+                stream_mode=args.stream_mode,
             )
         )
 

{axis-66 → axis-68}/axis/device.py

@@ -1,10 +1,14 @@
 """Python library to enable Axis devices to integrate with Home Assistant."""
 
+from typing import TYPE_CHECKING
+
 from .interfaces.event_manager import EventManager
 from .interfaces.vapix import Vapix
-from .models.configuration import Configuration
 from .stream_manager import StreamManager
 
+if TYPE_CHECKING:
+    from .models.configuration import Configuration
+
 
 class AxisDevice:
     """Creates a new Axis device.self."""

{axis-66 → axis-68}/axis/interfaces/api_handler.py

@@ -8,6 +8,7 @@ from collections.abc import (
     Sequence,
     ValuesView,
 )
+import enum
 from typing import TYPE_CHECKING, Generic, final
 
 from ..errors import Forbidden, PathNotFound, Unauthorized
@@ -25,6 +26,14 @@ UnsubscribeType = Callable[[], None]
 ID_FILTER_ALL = "*"
 
 
+class HandlerGroup(enum.Enum):
+    """Group handlers by initialization phase in Vapix."""
+
+    API_DISCOVERY = "api_discovery"
+    PARAM_CGI_FALLBACK = "param_cgi_fallback"
+    APPLICATION = "application"
+
+
 class SubscriptionHandler:
     """Manage subscription and notification to subscribers."""
 
@@ -73,14 +82,16 @@ class SubscriptionHandler:
 class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
     """Base class for a map of API Items."""
 
-    api_id: "ApiId | None" = None
+    api_id: ApiId | None = None
     default_api_version: str | None = None
+    handler_groups: tuple[HandlerGroup, ...] = ()
     skip_support_check = False
 
-    def __init__(self, vapix: "Vapix") -> None:
+    def __init__(self, vapix: Vapix) -> None:
         """Initialize API items."""
         super().__init__()
         self.vapix = vapix
+        self.vapix._register_handler(self)
         self._items: dict[str, ApiItemT] = {}
         self.initialized = False
 
@@ -101,6 +112,10 @@ class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
         """Is API listed in parameters."""
         return False
 
+    def should_initialize_in_group(self, group: HandlerGroup) -> bool:
+        """Return whether handler should initialize in the given group."""
+        return True
+
     async def _api_request(self) -> dict[str, ApiItemT]:
         """Get API data method defined by subclass."""
         raise NotImplementedError
@@ -134,15 +149,41 @@ class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
         return self.initialized
 
     @property
-    def api_version(self) -> str | None:
-        """Latest API version supported."""
-        if (
-            self.api_id is not None
-            and (discovery_item := self.vapix.api_discovery.get(self.api_id))
-            is not None
-        ):
-            return discovery_item.version
-        return self.default_api_version
+    def api_version(self) -> str:
+        """Latest API version supported.
+
+        Returns the API version in this order of precedence:
+        1. Version from device discovery (dynamic, device-specific)
+        2. Handler's default_api_version (static, library-defined)
+        3. Empty string "" (for handlers without discovery support)
+
+        Note: This property always returns a string (never None). Handlers that don't
+        support API versioning (no api_id) return empty string, which is safe because
+        they don't send api_version in their requests.
+
+        Returns:
+            str: API version (e.g., "1.0", "1.1") or empty string if not available.
+
+        """
+        discovery_version = self._get_api_discovery_version()
+        if discovery_version is not None:
+            return discovery_version
+        return self.default_api_version or ""
+
+    def _get_api_discovery_version(self) -> str | None:
+        """Get API version from discovery data when available."""
+        if self.api_id is None:
+            return None
+
+        discovery_item = self.vapix.api_discovery.get(self.api_id)
+        if discovery_item is None:
+            return None
+
+        discovery_version = getattr(discovery_item, "version", None)
+        if isinstance(discovery_version, str):
+            return discovery_version
+
+        return None
 
     def items(self) -> ItemsView[str, ApiItemT]:
         """Return items."""

{axis-66 → axis-68}/axis/interfaces/applications/application_handler.py

@@ -4,13 +4,14 @@ from abc import abstractmethod
 
 from ...models.api import ApiItemT
 from ...models.applications.application import ApplicationName, ApplicationStatus
-from ..api_handler import ApiHandler
+from ..api_handler import ApiHandler, HandlerGroup
 
 
 class ApplicationHandler(ApiHandler[ApiItemT]):
     """Generic application handler."""
 
     app_name: ApplicationName
+    handler_groups = (HandlerGroup.APPLICATION,)
 
     @property
     def supported(self) -> bool:

{axis-66 → axis-68}/axis/interfaces/basic_device_info.py

@@ -14,7 +14,7 @@ from ..models.basic_device_info import (
     GetSupportedVersionsRequest,
     GetSupportedVersionsResponse,
 )
-from .api_handler import ApiHandler
+from .api_handler import ApiHandler, HandlerGroup
 
 
 class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
@@ -22,6 +22,7 @@ class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
 
     api_id = ApiId.BASIC_DEVICE_INFO
     default_api_version = API_VERSION
+    handler_groups = (HandlerGroup.API_DISCOVERY,)
 
     async def _api_request(self) -> dict[str, DeviceInformation]:
         """Get default data of basic device information."""
@@ -29,9 +30,8 @@ class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
 
     async def get_all_properties(self) -> dict[str, DeviceInformation]:
         """List all properties of basic device info."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         bytes_data = await self.vapix.api_request(
-            GetAllPropertiesRequest(discovery_item.version)
+            GetAllPropertiesRequest(self.api_version)
         )
         response = GetAllPropertiesResponse.decode(bytes_data)
         return {"0": response.data}

{axis-66 → axis-68}/axis/interfaces/light_control.py

@@ -45,7 +45,7 @@ from ..models.light_control import (
     SetManualAngleOfIlluminationModeRequest,
     SetManualIntensityRequest,
 )
-from .api_handler import ApiHandler
+from .api_handler import ApiHandler, HandlerGroup
 
 
 class LightHandler(ApiHandler[LightInformation]):
@@ -53,6 +53,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     api_id = ApiId.LIGHT_CONTROL
     default_api_version = API_VERSION
+    handler_groups = (
+        HandlerGroup.API_DISCOVERY,
+        HandlerGroup.PARAM_CGI_FALLBACK,
+    )
 
     @property
     def listed_in_parameters(self) -> bool:
@@ -61,6 +65,12 @@ class LightHandler(ApiHandler[LightInformation]):
             return prop.light_control
         return False
 
+    def should_initialize_in_group(self, group: HandlerGroup) -> bool:
+        """Return whether handler should initialize in the given group."""
+        if group is HandlerGroup.PARAM_CGI_FALLBACK:
+            return not self.listed_in_api_discovery and self.listed_in_parameters
+        return True
+
     async def _api_request(self) -> dict[str, LightInformation]:
         """Get default data of stream profiles."""
         return await self.get_light_information()
@@ -68,51 +78,45 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_light_information(self) -> dict[str, LightInformation]:
         """List the light control information."""
         bytes_data = await self.vapix.api_request(
-            GetLightInformationRequest(api_version=self.default_api_version)
+            GetLightInformationRequest(api_version=self.api_version)
         )
         return GetLightInformationResponse.decode(bytes_data).data
 
     async def get_service_capabilities(self) -> ServiceCapabilities:
         """List the light control information."""
         bytes_data = await self.vapix.api_request(
-            GetServiceCapabilitiesRequest(api_version=self.default_api_version)
+            GetServiceCapabilitiesRequest(api_version=self.api_version)
         )
         return GetServiceCapabilitiesResponse.decode(bytes_data).data
 
     async def activate_light(self, light_id: str) -> None:
         """Activate the light."""
         await self.vapix.api_request(
-            ActivateLightRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            ActivateLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def deactivate_light(self, light_id: str) -> None:
         """Deactivate the light."""
         await self.vapix.api_request(
-            DeactivateLightRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            DeactivateLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def enable_light(self, light_id: str) -> None:
         """Activate the light."""
         await self.vapix.api_request(
-            EnableLightRequest(api_version=self.default_api_version, light_id=light_id)
+            EnableLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def disable_light(self, light_id: str) -> None:
         """Deactivate the light."""
         await self.vapix.api_request(
-            DisableLightRequest(api_version=self.default_api_version, light_id=light_id)
+            DisableLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def get_light_status(self, light_id: str) -> bool:
         """Get light status if its on or off."""
         bytes_data = await self.vapix.api_request(
-            GetLightStatusRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetLightStatusRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetLightStatusResponse.decode(bytes_data).data
 
@@ -120,7 +124,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Enable the automatic light intensity control."""
         await self.vapix.api_request(
             SetAutomaticIntensityModeRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 enabled=enabled,
             )
@@ -129,9 +133,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_valid_intensity(self, light_id: str) -> Range:
         """Get valid intensity range for light."""
         bytes_data = await self.vapix.api_request(
-            GetValidIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetValidIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetValidIntensityResponse.decode(bytes_data).data
 
@@ -139,7 +141,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Manually sets the intensity."""
         await self.vapix.api_request(
             SetManualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 intensity=intensity,
             )
@@ -148,9 +150,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_manual_intensity(self, light_id: str) -> int:
         """Enable the automatic light intensity control."""
         bytes_data = await self.vapix.api_request(
-            GetManualIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetManualIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetManualIntensityResponse.decode(bytes_data).data
 
@@ -160,7 +160,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Manually sets the intensity for an individual LED."""
         await self.vapix.api_request(
             SetIndividualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 led_id=led_id,
                 intensity=intensity,
@@ -171,7 +171,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Receives the intensity from the setIndividualIntensity request."""
         bytes_data = await self.vapix.api_request(
             GetIndividualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 led_id=led_id,
             )
@@ -181,9 +181,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_current_intensity(self, light_id: str) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
         bytes_data = await self.vapix.api_request(
-            GetCurrentIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetCurrentIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetCurrentIntensityResponse.decode(bytes_data).data
 
@@ -197,7 +195,9 @@ class LightHandler(ApiHandler[LightInformation]):
         """
         await self.vapix.api_request(
             SetAutomaticAngleOfIlluminationModeRequest(
-                api_version=self.default_api_version, light_id=light_id, enabled=enabled
+                api_version=self.api_version,
+                light_id=light_id,
+                enabled=enabled,
             )
         )
 
@@ -205,7 +205,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """List the valid angle of illumination values."""
         bytes_data = await self.vapix.api_request(
             GetValidAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetValidAngleOfIlluminationResponse.decode(bytes_data).data
@@ -220,7 +220,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """
         await self.vapix.api_request(
             SetManualAngleOfIlluminationModeRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 angle_of_illumination=angle_of_illumination,
             )
@@ -230,7 +230,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Get the angle of illumination."""
         bytes_data = await self.vapix.api_request(
             GetManualAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetManualAngleOfIlluminationResponse.decode(bytes_data).data
@@ -239,7 +239,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Receive the current angle of illumination."""
         bytes_data = await self.vapix.api_request(
             GetCurrentAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetCurrentAngleOfIlluminationResponse.decode(bytes_data).data
@@ -250,7 +250,9 @@ class LightHandler(ApiHandler[LightInformation]):
         """Enable automatic synchronization with the day/night mode."""
         await self.vapix.api_request(
             SetLightSynchronizeDayNightModeRequest(
-                api_version=self.default_api_version, light_id=light_id, enabled=enabled
+                api_version=self.api_version,
+                light_id=light_id,
+                enabled=enabled,
             )
         )
 
@@ -258,7 +260,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Check if the automatic synchronization is enabled with the day/night mode."""
         bytes_data = await self.vapix.api_request(
             GetLightSynchronizeDayNightModeRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetLightSynchronizeDayNightModeResponse.decode(bytes_data).data