axis 58__tar.gz → 60__tar.gz

axis-60/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: axis
+Version: 60
+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.11
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+Provides-Extra: requirements
+Provides-Extra: requirements_test
+Provides-Extra: requirements_dev
+License-File: LICENSE
+
+Python project to set up a connection towards Axis Communications devices and to subscribe to specific events on the metadatastream.

{axis-58 → axis-60}/axis/__main__.py

@@ -22,7 +22,7 @@ async def axis_device(
     """Create a Axis device."""
     session = AsyncClient(verify=False)
     device = axis.device.AxisDevice(
-        axis.configuration.Configuration(
+        axis.models.configuration.Configuration(
             session, host, port=port, username=username, password=password
         )
     )

{axis-58 → axis-60}/axis/device.py

@@ -1,9 +1,9 @@
 """Python library to enable Axis devices to integrate with Home Assistant."""
 
-from .configuration import Configuration
-from .event_stream import EventManager
+from .interfaces.event_manager import EventManager
+from .interfaces.vapix import Vapix
+from .models.configuration import Configuration
 from .stream_manager import StreamManager
-from .vapix.vapix import Vapix
 
 
 class AxisDevice:
@@ -14,7 +14,7 @@ class AxisDevice:
         self.config = configuration
         self.vapix = Vapix(self)
         self.stream = StreamManager(self)
-        self.event = EventManager(self)
+        self.event = EventManager()
 
     def enable_events(self) -> None:
         """Enable events for stream."""

{axis-58/axis/vapix → axis-60/axis}/interfaces/api_handler.py

@@ -11,11 +11,11 @@ from collections.abc import (
 )
 from typing import TYPE_CHECKING, Generic, final
 
-from ...errors import Forbidden, PathNotFound, Unauthorized
+from ..errors import Forbidden, PathNotFound, Unauthorized
 
 if TYPE_CHECKING:
     from ..models.api_discovery import ApiId
-    from ..vapix import Vapix
+    from .vapix import Vapix
 
 from ..models.api import ApiItemT
 

axis-58/axis/event_stream.py → axis-60/axis/interfaces/event_manager.py

@@ -2,13 +2,9 @@
 
 from collections.abc import Callable
 import logging
-from typing import TYPE_CHECKING, Any
-
-from .models.event import Event, EventOperation, EventTopic
-
-if TYPE_CHECKING:
-    from .device import AxisDevice
+from typing import Any
 
+from ..models.event import Event, EventOperation, EventTopic
 
 SubscriptionCallback = Callable[[Event], None]
 SubscriptionType = tuple[
@@ -30,9 +26,8 @@ LOGGER = logging.getLogger(__name__)
 class EventManager:
     """Initialize new events and update states of existing events."""
 
-    def __init__(self, device: "AxisDevice") -> None:
+    def __init__(self) -> None:
         """Ready information about events."""
-        self.device = device
         self._known_topics: set[str] = set()
         self._subscribers: dict[str, list[SubscriptionType]] = {ID_FILTER_ALL: []}
 

{axis-58/axis/vapix → axis-60/axis}/interfaces/mqtt.py

@@ -6,6 +6,7 @@ import orjson
 
 from ..models.api_discovery import ApiId
 from ..models.mqtt import (
+    API_VERSION,
     ActivateClientRequest,
     ClientConfig,
     ClientConfigStatus,
@@ -21,8 +22,6 @@ from ..models.mqtt import (
 )
 from .api_handler import ApiHandler
 
-API_VERSION = "1.0"
-
 DEFAULT_TOPICS = ["//."]
 
 
@@ -56,41 +55,36 @@ class MqttClientHandler(ApiHandler[Any]):
 
     async def configure_client(self, client_config: ClientConfig) -> None:
         """Configure MQTT Client."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         await self.vapix.api_request(
             ConfigureClientRequest(
-                api_version=discovery_item.version, client_config=client_config
+                api_version=self.default_api_version, client_config=client_config
             )
         )
 
     async def activate(self) -> None:
         """Activate MQTT Client."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         await self.vapix.api_request(
-            ActivateClientRequest(api_version=discovery_item.version)
+            ActivateClientRequest(api_version=self.default_api_version)
         )
 
     async def deactivate(self) -> None:
         """Deactivate MQTT Client."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         await self.vapix.api_request(
-            DeactivateClientRequest(api_version=discovery_item.version)
+            DeactivateClientRequest(api_version=self.default_api_version)
         )
 
     async def get_client_status(self) -> ClientConfigStatus:
         """Get MQTT Client status."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         bytes_data = await self.vapix.api_request(
-            GetClientStatusRequest(api_version=discovery_item.version)
+            GetClientStatusRequest(api_version=self.default_api_version)
         )
         response = GetClientStatusResponse.decode(bytes_data)
         return response.data
 
     async def get_event_publication_config(self) -> EventPublicationConfig:
         """Get MQTT Client event publication config."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         bytes_data = await self.vapix.api_request(
-            GetEventPublicationConfigRequest(api_version=discovery_item.version)
+            GetEventPublicationConfigRequest(api_version=self.default_api_version)
         )
         response = GetEventPublicationConfigResponse.decode(bytes_data)
         return response.data
@@ -99,13 +93,12 @@ class MqttClientHandler(ApiHandler[Any]):
         self, topics: list[str] = DEFAULT_TOPICS
     ) -> None:
         """Configure MQTT Client event publication."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         event_filters = EventFilter.from_list(
             [{"topicFilter": topic} for topic in topics]
         )
         config = EventPublicationConfig(event_filter_list=event_filters)
         await self.vapix.api_request(
             ConfigureEventPublicationRequest(
-                api_version=discovery_item.version, config=config
+                api_version=self.default_api_version, config=config
             )
         )

{axis-58/axis/vapix → axis-60/axis}/interfaces/parameters/param_cgi.py

@@ -14,7 +14,7 @@ from .ptz import PtzParameterHandler
 from .stream_profile import StreamProfileParameterHandler
 
 if TYPE_CHECKING:
-    from ...vapix import Vapix
+    from ..vapix import Vapix
 
 
 class Params(ApiHandler[Any]):

{axis-58/axis/vapix → axis-60/axis/interfaces}/vapix.py

@@ -1,5 +1,7 @@
 """Python library to enable Axis devices to integrate with Home Assistant."""
 
+from __future__ import annotations
+
 import asyncio
 import logging
 from typing import TYPE_CHECKING, Any
@@ -7,36 +9,36 @@ from typing import TYPE_CHECKING, Any
 import httpx
 
 from ..errors import RequestError, raise_error
-from .interfaces.api_discovery import ApiDiscoveryHandler
-from .interfaces.api_handler import ApiHandler
-from .interfaces.applications import (
+from ..models.api import ApiRequest
+from ..models.pwdgrp_cgi import SecondaryGroup
+from ..models.stream_profile import StreamProfile
+from .api_discovery import ApiDiscoveryHandler
+from .api_handler import ApiHandler
+from .applications import (
     ApplicationsHandler,
 )
-from .interfaces.applications.fence_guard import FenceGuardHandler
-from .interfaces.applications.loitering_guard import (
+from .applications.fence_guard import FenceGuardHandler
+from .applications.loitering_guard import (
     LoiteringGuardHandler,
 )
-from .interfaces.applications.motion_guard import MotionGuardHandler
-from .interfaces.applications.object_analytics import (
+from .applications.motion_guard import MotionGuardHandler
+from .applications.object_analytics import (
     ObjectAnalyticsHandler,
 )
-from .interfaces.applications.vmd4 import Vmd4Handler
-from .interfaces.basic_device_info import BasicDeviceInfoHandler
-from .interfaces.event_instances import EventInstanceHandler
-from .interfaces.light_control import LightHandler
-from .interfaces.mqtt import MqttClientHandler
-from .interfaces.parameters.param_cgi import Params
-from .interfaces.pir_sensor_configuration import PirSensorConfigurationHandler
-from .interfaces.port_cgi import Ports
-from .interfaces.port_management import IoPortManagement
-from .interfaces.ptz import PtzControl
-from .interfaces.pwdgrp_cgi import Users
-from .interfaces.stream_profiles import StreamProfilesHandler
-from .interfaces.user_groups import UserGroups
-from .interfaces.view_areas import ViewAreaHandler
-from .models.api import ApiRequest
-from .models.pwdgrp_cgi import SecondaryGroup
-from .models.stream_profile import StreamProfile
+from .applications.vmd4 import Vmd4Handler
+from .basic_device_info import BasicDeviceInfoHandler
+from .event_instances import EventInstanceHandler
+from .light_control import LightHandler
+from .mqtt import MqttClientHandler
+from .parameters.param_cgi import Params
+from .pir_sensor_configuration import PirSensorConfigurationHandler
+from .port_cgi import Ports
+from .port_management import IoPortManagement
+from .ptz import PtzControl
+from .pwdgrp_cgi import Users
+from .stream_profiles import StreamProfilesHandler
+from .user_groups import UserGroups
+from .view_areas import ViewAreaHandler
 
 if TYPE_CHECKING:
     from ..device import AxisDevice
@@ -49,7 +51,7 @@ TIME_OUT = 15
 class Vapix:
     """Vapix parameter request."""
 
-    def __init__(self, device: "AxisDevice") -> None:
+    def __init__(self, device: AxisDevice) -> None:
         """Store local reference to device config."""
         self.device = device
         self.auth = httpx.DigestAuth(device.config.username, device.config.password)

{axis-58/axis/vapix → axis-60/axis}/models/event_instance.py

@@ -5,8 +5,8 @@ from typing import Any, Self
 
 import xmltodict
 
-from ...models.event import traverse
 from .api import ApiItem, ApiRequest, ApiResponse
+from .event import traverse
 
 EVENT_INSTANCE = (
     "http://www.w3.org/2003/05/soap-envelope:Envelope",

{axis-58/axis/vapix → axis-60/axis}/models/light_control.py

@@ -1,5 +1,7 @@
 """Light Control API data model."""
 
+from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import NotRequired, Self
 
@@ -225,14 +227,14 @@ class Range:
     high: int
 
     @classmethod
-    def from_dict(cls, data: RangeT) -> "Range":
+    def from_dict(cls, data: RangeT) -> Self:
         """Create range object from dict."""
-        return Range(low=data["low"], high=data["high"])
+        return cls(low=data["low"], high=data["high"])
 
     @classmethod
-    def from_list(cls, data: list[RangeT]) -> list["Range"]:
+    def from_list(cls, data: list[RangeT]) -> list[Self]:
         """Create range object from dict."""
-        return [Range.from_dict(range) for range in data]
+        return [cls.from_dict(range) for range in data]
 
 
 @dataclass
@@ -277,7 +279,7 @@ class GetLightInformationResponse(ApiResponse[dict[str, LightInformation]]):
             api_version=data["apiVersion"],
             context=data["context"],
             method=data["method"],
-            data=LightInformation.decode_to_dict(data["data"]["items"]),
+            data=LightInformation.decode_to_dict(data.get("data", {}).get("items", [])),
         )
 
 
@@ -294,9 +296,9 @@ class ServiceCapabilities:
     day_night_synchronize_support: bool
 
     @classmethod
-    def from_dict(cls, data: ServiceCapabilitiesT) -> "ServiceCapabilities":
+    def from_dict(cls, data: ServiceCapabilitiesT) -> Self:
         """Create service capabilities object from dict."""
-        return ServiceCapabilities(
+        return cls(
             automatic_intensity_support=data["automaticIntensitySupport"],
             manual_intensity_support=data["manualIntensitySupport"],
             get_current_intensity_support=data["getCurrentIntensitySupport"],

{axis-58/axis/vapix → axis-60/axis}/models/mqtt.py

@@ -1,5 +1,7 @@
 """MQTT Client api."""
 
+from __future__ import annotations
+
 from dataclasses import dataclass
 import enum
 from typing import Literal, NotRequired, Self
@@ -24,7 +26,7 @@ class MessageT(TypedDict):
 
     useDefault: bool
     message: NotRequired[str]
-    qos: NotRequired[int]
+    qos: NotRequired[Literal[0, 1, 2]]
     retain: NotRequired[bool]
     topic: NotRequired[str]
 
@@ -70,7 +72,7 @@ class ConfigT(TypedDict):
 class StatusT(TypedDict):
     """Represent a status object."""
 
-    connectionStatus: Literal["connected", "disconnected"]
+    connectionStatus: Literal["connected", "disconnected", "not connected"]
     state: Literal["active", "inactive"]
 
 
@@ -149,6 +151,14 @@ class ClientConnectionState(enum.StrEnum):
     CONNECTED = "connected"
     DISCONNECTED = "disconnected"
 
+    @classmethod
+    def _missing_(cls, value: object) -> ClientConnectionState:
+        """Set default enum member if an unknown value is provided.
+
+        Some firmwares report "not connected" instead of "disconnected".
+        """
+        return cls.DISCONNECTED
+
 
 class ServerProtocol(enum.StrEnum):
     """Connection protocols used in the server configuration."""
@@ -164,10 +174,35 @@ class Message:
     """Message description."""
 
     use_default: bool = True
+    """Specifies if the default configuration should be used.
+
+    If set to true, other options in this parameter will be discarded.
+    If set to false, topic, messages, retained and qos options are required and used.
+    """
     topic: str | None = None
+    """The topic that should be used with the message."""
     message: str | None = None
+    """The message that should be used with the message."""
     retain: bool | None = None
-    qos: int | None = None
+    """The retained option that should be used with the message."""
+    qos: Literal[0, 1, 2] | None = None
+    """The QoS option that should be used with the message."""
+
+    @classmethod
+    def from_dict(cls, data: MessageT) -> Self:
+        """Create message object from dict."""
+        return cls(
+            use_default=data["useDefault"],
+            topic=data.get("topic"),
+            message=data.get("message"),
+            retain=data.get("retain"),
+            qos=data.get("qos"),
+        )
+
+    @classmethod
+    def from_dict_or_none(cls, data: MessageT | None) -> Self | None:
+        """Create class instance if data is not None."""
+        return cls.from_dict(data) if data is not None else None
 
     def to_dict(self) -> MessageT:
         """Create json dict from object."""
@@ -188,15 +223,42 @@ class Server:
     """Represent server config."""
 
     host: str
+    """The Broker location, i.e. the Hostname or IP address."""
     protocol: ServerProtocol = ServerProtocol.TCP
+    """Contains the protocols used by params.server.
+
+    Possible values are:
+    - tcp: MQTT over TCP
+    - ssl: MQTT over SSL
+    - ws: MQTT over Websocket
+    - wss: MQTT over Websocket Secure
+    """
     alpn_protocol: str | None = None
+    """The ALPN protocol that should be used if the selected protocol was ssl or wss.
+
+    If the string value is empty the ALPN will not be used.
+    Default value is empty and the maximum length of the protocol is 255 bytes.
+    """
     basepath: str | None = None
+    """The path that should be used as a suffix for the constructed URL.
+
+    Will only be used for the ws and wss connections.
+    The default value is empty string.
+    """
     port: int | None = None
+    """The port that should be used.
+
+    Default values for the protocols are:
+    - tcp: 1883
+    - ssl: 8883
+    - ws: 80
+    - wss: 443
+    """
 
     @classmethod
-    def from_dict(cls, data: ServerT) -> "Server":
+    def from_dict(cls, data: ServerT) -> Self:
         """Create server object from dict."""
-        return Server(
+        return cls(
             host=data["host"],
             protocol=ServerProtocol(data["protocol"]),
             alpn_protocol=data.get("alpnProtocol"),
@@ -221,8 +283,31 @@ class Ssl:
     """Represent SSL config."""
 
     validate_server_cert: bool = False
+    """Specifies if the server certificate shall be validated."""
     ca_cert_id: str | None = None
+    """Specifies the CA Certificate that should be used to validate the server certificate.
+
+    The certificates are managed through the user interface or via ONVIF services.
+    """
     client_cert_id: str | None = None
+    """Specifies the client certificate and key that should be used.
+
+    The certificates are managed through the user interface or via ONVIF services.
+    """
+
+    @classmethod
+    def from_dict(cls, data: SslT) -> Self:
+        """Create client status object from dict."""
+        return cls(
+            validate_server_cert=data["validateServerCert"],
+            ca_cert_id=data.get("CACertID"),
+            client_cert_id=data.get("clientCertID"),
+        )
+
+    @classmethod
+    def from_dict_or_none(cls, data: SslT | None) -> Self | None:
+        """Create class instance if data is not None."""
+        return cls.from_dict(data) if data is not None else None
 
     def to_dict(self) -> SslT:
         """Create json dict from object."""
@@ -239,23 +324,90 @@ class ClientConfig:
     """Represent client config."""
 
     server: Server
+    """Contains the address and protocol related information."""
     activate_on_reboot: bool | None = None
     auto_reconnect: bool | None = None
+    """Specifies if the client should reconnect on an unintentional disconnect."""
     clean_session: bool | None = None
+    """This parameter controls the behavior during connection and disconnection time.
+
+    Affects both the client and the server when this parameters is true,
+    the state information is discarded when the client and server change state.
+    Setting the parameter to false means that the state information is kept.
+    """
     client_id: str | None = None
+    """The client identifier sent to the server when the client connects to it."""
     connect_message: Message | None = None
+    """Specifies if a message should be sent when a connection is established.
+
+    Contains options related to connect announcements.
+    If this object is not defined this message won’t be sent.
+    """
     connect_timeout: int | None = None
+    """The timed interval (in seconds) to allow a connect to finish.
+
+    The default value is 60.
+    """
+    device_topic_prefix: str | None = None
+    """Specifies a prefix on MQTT topics in various scenarios.
+
+    Such as when you want to configure the translation of events into MQTT messages
+    or prefix all published MQTT messages with a common prefix.
+    The default value is axis/{device serial number}.
+    """
     disconnect_message: Message | None = None
+    """Specifies if a message should be sent when the client is manually disconnected.
+
+    Contains options related to manual disconnect announcements.
+    If this object is not defined this message won’t be sent.
+    This message should not be confused with LWT,
+    as it is used when the connection is lost and managed by the broker.
+    """
     keep_alive_interval: int | None = None
+    """Defines the maximum time (in seconds).
+
+    Time intervalthat should pass without communication between the client and server.
+    At least one message will be sent over the network by the client
+    during each keep alive period and the interval makes it possible to detect
+    when the server is no longer available without having to
+    wait for the TCP/IP timeout.
+    The default value is 60."""
     last_will_testament: Message | None = None
+    """Contains the options related to LWT.
+
+    If LWT is not required, this parameter is not included.
+    """
     password: str | None = None
+    """The password that should be used for authentication."""
     ssl: Ssl | None = None
+    """Contains the options related to the SSL connection.
+
+    This object should only be present if the connection type is ssl or wss.
+    """
     username: str | None = None
+    """The user name that should be used for authentication and authorization."""
 
     @classmethod
-    def from_dict(cls, data: ConfigT) -> "ClientConfig":
+    def from_dict(cls, data: ConfigT) -> Self:
         """Create client status object from dict."""
-        return ClientConfig(server=Server.from_dict(data["server"]))
+        return cls(
+            server=Server.from_dict(data["server"]),
+            activate_on_reboot=data.get("activateOnReboot"),
+            auto_reconnect=data.get("autoReconnect"),
+            clean_session=data.get("cleanSession"),
+            client_id=data.get("clientId"),
+            connect_message=Message.from_dict_or_none(data.get("connectMessage")),
+            connect_timeout=data.get("connectTimeout"),
+            device_topic_prefix=data.get("deviceTopicPrefix"),
+            disconnect_message=Message.from_dict_or_none(data.get("disconnectMessage")),
+            keep_alive_interval=data.get("keepAliveInterval"),
+            last_will_testament=Message.from_dict_or_none(
+                data.get("lastWillTestament")
+            ),
+            password=data.get("password"),
+            ssl=Ssl.from_dict_or_none(data.get("ssl")),
+            username=data.get("username"),
+        )
 
     def to_dict(self) -> ConfigT:
         """Create json dict from object."""
@@ -293,14 +445,19 @@ class ClientStatus:
 
     connection_status: ClientConnectionState
     state: ClientState
+    active: bool
+    """The current state of the client. Possible values are active and inactive."""
+    connected: bool
+    """The current connection state of your client. Possible values are connected, disconnected."""
 
     @classmethod
-    def from_dict(cls, data: StatusT) -> "ClientStatus":
+    def from_dict(cls, data: StatusT) -> Self:
         """Create client status object from dict."""
-        # Note to investigate closer, documentation say lower case.
-        return ClientStatus(
+        return cls(
             connection_status=ClientConnectionState(data["connectionStatus"].lower()),
             state=ClientState(data["state"].lower()),
+            active=data["state"] == "active",
+            connected=data["connectionStatus"] == "connected",
         )
 
 
@@ -309,12 +466,14 @@ class ClientConfigStatus:
     """GetClientStatus response."""
 
     config: ClientConfig
+    """The Config of the MQTT client."""
     status: ClientStatus
+    """The Status of the MQTT client."""
 
     @classmethod
-    def from_dict(cls, data: ClientStatusDataT) -> "ClientConfigStatus":
+    def from_dict(cls, data: ClientStatusDataT) -> Self:
         """Create client config status object from dict."""
-        return ClientConfigStatus(
+        return cls(
             config=ClientConfig.from_dict(data["config"]),
             status=ClientStatus.from_dict(data["status"]),
         )
@@ -329,18 +488,18 @@ class EventFilter:
     retain: str | None = None
 
     @classmethod
-    def from_dict(cls, data: EventFilterT) -> "EventFilter":
+    def from_dict(cls, data: EventFilterT) -> Self:
         """Create event filter object from dict."""
-        return EventFilter(
+        return cls(
             topic_filter=data["topicFilter"],
             qos=data.get("qos"),
             retain=data.get("retain"),
         )
 
     @classmethod
-    def from_list(cls, data: list[EventFilterT]) -> "list[EventFilter]":
+    def from_list(cls, data: list[EventFilterT]) -> list[Self]:
         """Create event filter object from dict."""
-        return [EventFilter.from_dict(item) for item in data]
+        return [cls.from_dict(item) for item in data]
 
     def to_dict(self) -> EventFilterT:
         """Create json dict from object."""
@@ -352,7 +511,7 @@ class EventFilter:
         return data
 
     @classmethod
-    def to_list(cls, data: "list[EventFilter]") -> list[EventFilterT]:
+    def to_list(cls, data: list[EventFilter]) -> list[EventFilterT]:
         """Create json list from object."""
         return [item.to_dict() for item in data]
 
@@ -369,9 +528,9 @@ class EventPublicationConfig:
     event_filter_list: list[EventFilter] | None = None
 
     @classmethod
-    def from_dict(cls, data: EventPublicationConfigT) -> "EventPublicationConfig":
+    def from_dict(cls, data: EventPublicationConfigT) -> Self:
         """Create client config status object from dict."""
-        return EventPublicationConfig(
+        return cls(
             topic_prefix=data["topicPrefix"],
             custom_topic_prefix=data["customTopicPrefix"],
             append_event_topic=data["appendEventTopic"],

{axis-58/axis/vapix → axis-60/axis}/models/parameters/properties.py

@@ -188,8 +188,9 @@ class PropertyParam(ParamItem):
             .get("PTZ", {})
             .get("Presets", {})
             .get("Version", False),
-            embedded_development=data["EmbeddedDevelopment"]["Version"],
-            # embedded_development=data.get("EmbeddedDevelopment_Version", "0.0"),
+            embedded_development=data.get("EmbeddedDevelopment", {}).get(
+                "Version", "0.0"
+            ),
             firmware_build_date=data["Firmware"]["BuildDate"],
             firmware_build_number=data["Firmware"]["BuildNumber"],
             firmware_version=data["Firmware"]["Version"],