axis 59__tar.gz → 61__tar.gz

{axis-59 → axis-61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: axis
-Version: 59
+Version: 61
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -12,9 +12,9 @@ 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: Programming Language :: Python :: 3.12
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.11.0
+Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 Provides-Extra: requirements
 Provides-Extra: requirements_test

{axis-59 → axis-61}/axis/__main__.py

@@ -20,7 +20,7 @@ async def axis_device(
     host: str, port: int, username: str, password: str
 ) -> axis.device.AxisDevice:
     """Create a Axis device."""
-    session = AsyncClient(verify=False)
+    session = AsyncClient(verify=False)  # noqa: S501
     device = axis.device.AxisDevice(
         axis.models.configuration.Configuration(
             session, host, port=port, username=username, password=password

{axis-59 → axis-61}/axis/errors.py

@@ -36,10 +36,15 @@ class PathNotFound(AxisException):
     """Path not found."""
 
 
-ERRORS = {401: Unauthorized, 403: Forbidden, 404: PathNotFound, 405: MethodNotAllowed}
+ERRORS = {
+    401: Unauthorized,
+    403: Forbidden,
+    404: PathNotFound,
+    405: MethodNotAllowed,
+}
 
 
 def raise_error(error: int) -> None:
     """Raise error."""
     cls = ERRORS.get(error, AxisException)
-    raise cls(f"{error}")
+    raise cls(error)

{axis-59 → axis-61}/axis/interfaces/api_handler.py

@@ -1,6 +1,5 @@
 """API handler class and base class for an API endpoint."""
 
-from abc import ABC
 from collections.abc import (
     Callable,
     ItemsView,
@@ -26,7 +25,7 @@ UnsubscribeType = Callable[[], None]
 ID_FILTER_ALL = "*"
 
 
-class SubscriptionHandler(ABC):
+class SubscriptionHandler:
     """Manage subscription and notification to subscribers."""
 
     def __init__(self) -> None:

{axis-59 → axis-61}/axis/interfaces/applications/motion_guard.py

@@ -2,7 +2,7 @@
 
 AXIS Motion Guard is a video motion detection application that detects
 and triggers an alarm whenever an object, such as a person or vehicle,
-moves within predefined areas in a camera’s field of view.
+moves within predefined areas in a camera's field of view.
 """
 
 from ...models.applications.application import ApplicationName

{axis-59 → axis-61}/axis/interfaces/light_control.py

@@ -67,62 +67,60 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_light_information(self) -> dict[str, LightInformation]:
         """List the light control information."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetLightInformationRequest(api_version=self.api_version)
+            GetLightInformationRequest(api_version=self.default_api_version)
         )
         return GetLightInformationResponse.decode(bytes_data).data
 
     async def get_service_capabilities(self) -> ServiceCapabilities:
         """List the light control information."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetServiceCapabilitiesRequest(api_version=self.api_version)
+            GetServiceCapabilitiesRequest(api_version=self.default_api_version)
         )
         return GetServiceCapabilitiesResponse.decode(bytes_data).data
 
     async def activate_light(self, light_id: str) -> None:
         """Activate the light."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
-            ActivateLightRequest(api_version=self.api_version, light_id=light_id)
+            ActivateLightRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
 
     async def deactivate_light(self, light_id: str) -> None:
         """Deactivate the light."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
-            DeactivateLightRequest(api_version=self.api_version, light_id=light_id)
+            DeactivateLightRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
 
     async def enable_light(self, light_id: str) -> None:
         """Activate the light."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
-            EnableLightRequest(api_version=self.api_version, light_id=light_id)
+            EnableLightRequest(api_version=self.default_api_version, light_id=light_id)
         )
 
     async def disable_light(self, light_id: str) -> None:
         """Deactivate the light."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
-            DisableLightRequest(api_version=self.api_version, light_id=light_id)
+            DisableLightRequest(api_version=self.default_api_version, light_id=light_id)
         )
 
     async def get_light_status(self, light_id: str) -> bool:
         """Get light status if its on or off."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetLightStatusRequest(api_version=self.api_version, light_id=light_id)
+            GetLightStatusRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
         return GetLightStatusResponse.decode(bytes_data).data
 
     async def set_automatic_intensity_mode(self, light_id: str, enabled: bool) -> None:
         """Enable the automatic light intensity control."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetAutomaticIntensityModeRequest(
-                api_version=self.api_version,
+                api_version=self.default_api_version,
                 light_id=light_id,
                 enabled=enabled,
             )
@@ -130,18 +128,18 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_valid_intensity(self, light_id: str) -> Range:
         """Get valid intensity range for light."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetValidIntensityRequest(api_version=self.api_version, light_id=light_id)
+            GetValidIntensityRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
         return GetValidIntensityResponse.decode(bytes_data).data
 
     async def set_manual_intensity(self, light_id: str, intensity: int) -> None:
         """Manually sets the intensity."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetManualIntensityRequest(
-                api_version=self.api_version,
+                api_version=self.default_api_version,
                 light_id=light_id,
                 intensity=intensity,
             )
@@ -149,9 +147,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_manual_intensity(self, light_id: str) -> int:
         """Enable the automatic light intensity control."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetManualIntensityRequest(api_version=self.api_version, light_id=light_id)
+            GetManualIntensityRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
         return GetManualIntensityResponse.decode(bytes_data).data
 
@@ -159,10 +158,9 @@ class LightHandler(ApiHandler[LightInformation]):
         self, light_id: str, led_id: int, intensity: int
     ) -> None:
         """Manually sets the intensity for an individual LED."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetIndividualIntensityRequest(
-                api_version=self.api_version,
+                api_version=self.default_api_version,
                 light_id=light_id,
                 led_id=led_id,
                 intensity=intensity,
@@ -171,10 +169,9 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_individual_intensity(self, light_id: str, led_id: int) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
             GetIndividualIntensityRequest(
-                api_version=self.api_version,
+                api_version=self.default_api_version,
                 light_id=light_id,
                 led_id=led_id,
             )
@@ -183,9 +180,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_current_intensity(self, light_id: str) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
-            GetCurrentIntensityRequest(api_version=self.api_version, light_id=light_id)
+            GetCurrentIntensityRequest(
+                api_version=self.default_api_version, light_id=light_id
+            )
         )
         return GetCurrentIntensityResponse.decode(bytes_data).data
 
@@ -195,21 +193,19 @@ class LightHandler(ApiHandler[LightInformation]):
         """Automatically control the angle of illumination.
 
         Using this mode means that the angle of illumination
-        is the same as the camera’s angle of view.
+        is the same as the camera's angle of view.
         """
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetAutomaticAngleOfIlluminationModeRequest(
-                api_version=self.api_version, light_id=light_id, enabled=enabled
+                api_version=self.default_api_version, light_id=light_id, enabled=enabled
             )
         )
 
     async def get_valid_angle_of_illumination(self, light_id: str) -> list[Range]:
         """List the valid angle of illumination values."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
             GetValidAngleOfIlluminationRequest(
-                api_version=self.api_version, light_id=light_id
+                api_version=self.default_api_version, light_id=light_id
             )
         )
         return GetValidAngleOfIlluminationResponse.decode(bytes_data).data
@@ -220,12 +216,11 @@ class LightHandler(ApiHandler[LightInformation]):
         """Set the manual angle of illumination.
 
         This is useful when the angle of illumination needs
-        to be different from the camera’s view angle.
+        to be different from the camera's view angle.
         """
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetManualAngleOfIlluminationModeRequest(
-                api_version=self.api_version,
+                api_version=self.default_api_version,
                 light_id=light_id,
                 angle_of_illumination=angle_of_illumination,
             )
@@ -233,20 +228,18 @@ class LightHandler(ApiHandler[LightInformation]):
 
     async def get_manual_angle_of_illumination(self, light_id: str) -> int:
         """Get the angle of illumination."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
             GetManualAngleOfIlluminationRequest(
-                api_version=self.api_version, light_id=light_id
+                api_version=self.default_api_version, light_id=light_id
             )
         )
         return GetManualAngleOfIlluminationResponse.decode(bytes_data).data
 
     async def get_current_angle_of_illumination(self, light_id: str) -> int:
         """Receive the current angle of illumination."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
             GetCurrentAngleOfIlluminationRequest(
-                api_version=self.api_version, light_id=light_id
+                api_version=self.default_api_version, light_id=light_id
             )
         )
         return GetCurrentAngleOfIlluminationResponse.decode(bytes_data).data
@@ -255,25 +248,22 @@ class LightHandler(ApiHandler[LightInformation]):
         self, light_id: str, enabled: bool
     ) -> None:
         """Enable automatic synchronization with the day/night mode."""
-        assert isinstance(self.api_version, str)
         await self.vapix.api_request(
             SetLightSynchronizeDayNightModeRequest(
-                api_version=self.api_version, light_id=light_id, enabled=enabled
+                api_version=self.default_api_version, light_id=light_id, enabled=enabled
             )
         )
 
     async def get_light_synchronization_day_night_mode(self, light_id: str) -> bool:
         """Check if the automatic synchronization is enabled with the day/night mode."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(
             GetLightSynchronizeDayNightModeRequest(
-                api_version=self.api_version, light_id=light_id
+                api_version=self.default_api_version, light_id=light_id
             )
         )
         return GetLightSynchronizeDayNightModeResponse.decode(bytes_data).data
 
     async def get_supported_versions(self) -> list[str]:
         """List supported API versions."""
-        assert isinstance(self.api_version, str)
         bytes_data = await self.vapix.api_request(GetSupportedVersionsRequest())
         return GetSupportedVersionsResponse.decode(bytes_data).data

{axis-59 → axis-61}/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-59 → axis-61}/axis/interfaces/port_management.py

@@ -45,7 +45,7 @@ class IoPortManagement(ApiHandler[Port]):
         * Configuring the states and what constitutes a normal
             and triggered state respectively.
             This will make triggers activate in either open or closed circuits.
-        The reason the change is treated as a nice name is because it doesn’t
+        The reason the change is treated as a nice name is because it doesn't
           affect the underlying behavior of the port.
         Devices with configurable ports can change the direction
           to either input or output.

{axis-59 → axis-61}/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,11 +9,8 @@ from typing import TYPE_CHECKING, Any
 import httpx
 
 from ..errors import RequestError, raise_error
-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,
 )
@@ -40,6 +39,9 @@ from .view_areas import ViewAreaHandler
 
 if TYPE_CHECKING:
     from ..device import AxisDevice
+    from ..models.api import ApiRequest
+    from ..models.stream_profile import StreamProfile
+    from .api_handler import ApiHandler
 
 LOGGER = logging.getLogger(__name__)
 
@@ -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)
@@ -274,16 +276,19 @@ class Vapix:
                 timeout=TIME_OUT,
             )
 
-        except httpx.TimeoutException:
-            raise RequestError("Timeout")
+        except httpx.TimeoutException as errt:
+            message = "Timeout"
+            raise RequestError(message) from errt
 
         except httpx.TransportError as errc:
             LOGGER.debug("%s", errc)
-            raise RequestError(f"Connection error: {errc}")
+            message = f"Connection error: {errc}"
+            raise RequestError(message) from errc
 
         except httpx.RequestError as err:
             LOGGER.debug("%s", err)
-            raise RequestError(f"Unknown error: {err}")
+            message = f"Unknown error: {err}"
+            raise RequestError(message) from err
 
         try:
             response.raise_for_status()

{axis-59 → axis-61}/axis/interfaces/view_areas.py

@@ -1,6 +1,6 @@
 """View area API.
 
-The View Area API makes it possible to define the subsections of a camera’s full view
+The View Area API makes it possible to define the subsections of a camera's full view
 as individual, virtual channels. This means that a wide angle and/or high resolution
 camera can provide multiple video streams at a lower resolution where each stream
 covers a specific region of interest. The API is also able to simplify the installation

{axis-59 → axis-61}/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"],