axis 60__tar.gz → 61__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: axis
-Version: 60
+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-60 → 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-60 → 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-60 → 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-60 → 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-60 → 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-60 → 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-60 → axis-61}/axis/interfaces/vapix.py

@@ -9,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,
 )
@@ -42,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__)
 
@@ -276,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-60 → 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-60 → axis-61}/axis/models/mqtt.py

@@ -341,7 +341,7 @@ class ClientConfig:
     """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.
+    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.
@@ -359,7 +359,7 @@ class ClientConfig:
     """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.
+    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.
     """

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

@@ -182,8 +182,8 @@ class PropertyParam(ParamItem):
         return cls(
             id="properties",
             api_http_version=data["API"]["HTTP"]["Version"],
-            api_metadata=data["API"]["Metadata"]["Metadata"],
-            api_metadata_version=data["API"]["Metadata"]["Version"],
+            api_metadata=data["API"].get("Metadata", {}).get("Metadata", "no"),
+            api_metadata_version=data["API"].get("Metadata", {}).get("Version", "0.0"),
             api_ptz_presets_version=data["API"]
             .get("PTZ", {})
             .get("Presets", {})

{axis-60 → axis-61}/axis/rtsp.py

@@ -361,11 +361,11 @@ class RTSPSession:
         """RFC 2617."""
         from hashlib import md5
 
-        ha1 = f"{self.username}:{self.realm}:{self.password}"
-        HA1 = md5(ha1.encode("UTF-8")).hexdigest()
-        ha2 = f"{self.method}:{self.url}"
-        HA2 = md5(ha2.encode("UTF-8")).hexdigest()
-        encrypt_response = f"{HA1}:{self.nonce}:{HA2}"
+        _ha1 = f"{self.username}:{self.realm}:{self.password}"
+        ha1 = md5(_ha1.encode("UTF-8")).hexdigest()
+        _ha2 = f"{self.method}:{self.url}"
+        ha2 = md5(_ha2.encode("UTF-8")).hexdigest()
+        encrypt_response = f"{ha1}:{self.nonce}:{ha2}"
         response = md5(encrypt_response.encode("UTF-8")).hexdigest()
 
         digest_auth = "Digest "
@@ -399,12 +399,12 @@ class RTSPMethods:
         """Define message methods."""
         self.session = session
         self.message_methods: dict[str, Callable[[], str]] = {
-            "OPTIONS": self.OPTIONS,
-            "DESCRIBE": self.DESCRIBE,
-            "SETUP": self.SETUP,
-            "PLAY": self.PLAY,
-            "KEEP-ALIVE": self.KEEP_ALIVE,
-            "TEARDOWN": self.TEARDOWN,
+            "OPTIONS": self.options,
+            "DESCRIBE": self.describe,
+            "SETUP": self.setup,
+            "PLAY": self.play,
+            "KEEP-ALIVE": self.keep_alive,
+            "TEARDOWN": self.teardown,
         }
 
     @property
@@ -414,11 +414,11 @@ class RTSPMethods:
         _LOGGER.debug(message)
         return message
 
-    def KEEP_ALIVE(self) -> str:
+    def keep_alive(self) -> str:
         """Keep-Alive messages doesn't need authentication."""
-        return self.OPTIONS(False)
+        return self.options(False)
 
-    def OPTIONS(self, authenticate: bool = True) -> str:
+    def options(self, authenticate: bool = True) -> str:
         """Request options device supports."""
         message = f"OPTIONS {self.session.url} RTSP/1.0\r\n"
         message += self.sequence
@@ -428,7 +428,7 @@ class RTSPMethods:
         message += "\r\n"
         return message
 
-    def DESCRIBE(self) -> str:
+    def describe(self) -> str:
         """Request description of what services RTSP server make available."""
         message = f"DESCRIBE {self.session.url} RTSP/1.0\r\n"
         message += self.sequence
@@ -438,7 +438,7 @@ class RTSPMethods:
         message += "\r\n"
         return message
 
-    def SETUP(self) -> str:
+    def setup(self) -> str:
         """Set up stream transport."""
         message = f"SETUP {self.session.control_url} RTSP/1.0\r\n"
         message += self.sequence
@@ -448,7 +448,7 @@ class RTSPMethods:
         message += "\r\n"
         return message
 
-    def PLAY(self) -> str:
+    def play(self) -> str:
         """RTSP session is ready to send data."""
         message = f"PLAY {self.session.url} RTSP/1.0\r\n"
         message += self.sequence
@@ -458,7 +458,7 @@ class RTSPMethods:
         message += "\r\n"
         return message
 
-    def TEARDOWN(self) -> str:
+    def teardown(self) -> str:
         """Tell device to tear down session."""
         message = f"TEARDOWN {self.session.url} RTSP/1.0\r\n"
         message += self.sequence
@@ -471,7 +471,7 @@ class RTSPMethods:
     @property
     def sequence(self) -> str:
         """Generate sequence string."""
-        return f"CSeq: {str(self.session.sequence)}\r\n"
+        return f"CSeq: {self.session.sequence}\r\n"
 
     @property
     def authentication(self) -> str:

{axis-60 → axis-61}/axis/stream_manager.py

@@ -1,13 +1,14 @@
 """Python library to enable Axis devices to integrate with Home Assistant."""
 
 import asyncio
-from collections.abc import Callable
 import logging
 from typing import TYPE_CHECKING
 
 from .rtsp import RTSPClient, Signal, State
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from .device import AxisDevice
 
 _LOGGER = logging.getLogger(__name__)

{axis-60 → axis-61}/axis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: axis
-Version: 60
+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-60 → axis-61}/axis.egg-info/requires.txt

@@ -19,6 +19,6 @@ pytest-aiohttp==1.0.5
 pytest-asyncio==0.23.6
 pytest-cov==5.0.0
 respx==0.21.1
-ruff==0.3.4
+ruff==0.3.5
 types-orjson==3.6.2
 types-xmltodict==v0.13.0.3