axis 66__tar.gz → 67__tar.gz

{axis-66 → axis-67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 66
+Version: 67
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -12,21 +12,23 @@ 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.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.13.0
+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.1; extra == "requirements"
 Requires-Dist: httpx==0.28.1; extra == "requirements"
-Requires-Dist: orjson==3.11.5; extra == "requirements"
-Requires-Dist: packaging==25.0; extra == "requirements"
-Requires-Dist: xmltodict==1.0.2; extra == "requirements"
+Requires-Dist: orjson==3.11.7; 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.19.1; extra == "requirements-test"
 Requires-Dist: pytest==9.0.2; extra == "requirements-test"
@@ -34,8 +36,8 @@ 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.0.0; extra == "requirements-test"
 Requires-Dist: respx==0.22.0; extra == "requirements-test"
-Requires-Dist: ruff==0.14.10; extra == "requirements-test"
-Requires-Dist: types-xmltodict==v1.0.1.20250920; extra == "requirements-test"
+Requires-Dist: ruff==0.15.6; 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-66 → axis-67}/axis/__main__.py

@@ -3,27 +3,35 @@
 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,
+    is_companion: bool = False,
+) -> axis.device.AxisDevice:
     """Create a Axis device."""
-    session = AsyncClient(verify=False)  # noqa: S501
+    session = create_session()
     device = AxisDevice(
         Configuration(
             session,
@@ -32,6 +40,7 @@ async def axis_device(
             username=username,
             password=password,
             is_companion=is_companion,
+            web_proto=web_proto,
         )
     )
 
@@ -58,12 +67,24 @@ 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,
 ) -> 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,
+    )
 
     if not device:
         LOGGER.error("Couldn't connect to Axis device")
@@ -86,16 +107,32 @@ 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()
+
+
 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("-D", "--debug", action="store_true")
@@ -125,6 +162,7 @@ if __name__ == "__main__":
                 port=args.port,
                 params=args.params,
                 events=args.events,
+                web_proto=WebProtocol(args.proto),
             )
         )
 

{axis-66 → axis-67}/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-67}/axis/interfaces/api_handler.py

@@ -73,11 +73,11 @@ 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
     skip_support_check = False
 
-    def __init__(self, vapix: "Vapix") -> None:
+    def __init__(self, vapix: Vapix) -> None:
         """Initialize API items."""
         super().__init__()
         self.vapix = vapix

{axis-66 → axis-67}/axis/interfaces/parameters/param_cgi.py

@@ -1,9 +1,9 @@
 """Axis Vapix parameter management."""
 
-from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, TypedDict
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
 
     class _DetectResultType(TypedDict):
         encoding: str
@@ -34,7 +34,7 @@ class Params(ApiHandler[Any]):
 
     api_id = ApiId.PARAM_CGI
 
-    def __init__(self, vapix: "Vapix") -> None:
+    def __init__(self, vapix: Vapix) -> None:
         """Initialize parameter classes."""
         super().__init__(vapix)
 

{axis-66 → axis-67}/axis/interfaces/parameters/param_handler.py

@@ -5,10 +5,11 @@ Generalises parameter specific handling like
 - Defining parameter group
 """
 
-from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from .param_cgi import Params
 
 from ...models.parameters.param_cgi import ParameterGroup, ParamItemT
@@ -21,7 +22,7 @@ class ParamHandler(ApiHandler[ParamItemT]):
     parameter_group: ParameterGroup
     parameter_item: type[ParamItemT]
 
-    def __init__(self, param_handler: "Params") -> None:
+    def __init__(self, param_handler: Params) -> None:
         """Initialize API items."""
         super().__init__(param_handler.vapix)
         param_handler.subscribe(self._update_params_callback, self.parameter_group)

{axis-66 → axis-67}/axis/interfaces/vapix.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
+import aiohttp
 import httpx
 
 from ..errors import RequestError, raise_error
+from ..models.configuration import AuthScheme
 from ..models.pwdgrp_cgi import SecondaryGroup
 from .api_discovery import ApiDiscoveryHandler
 from .applications import ApplicationsHandler
@@ -32,6 +34,8 @@ from .user_groups import UserGroups
 from .view_areas import ViewAreaHandler
 
 if TYPE_CHECKING:
+    from aiohttp import BasicAuth as AiohttpBasicAuth, ClientSession
+
     from ..device import AxisDevice
     from ..models.api import ApiRequest
     from ..models.stream_profile import StreamProfile
@@ -45,10 +49,24 @@ TIME_OUT = 15
 class Vapix:
     """Vapix parameter request."""
 
+    auth: object
+
     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)
+        self._http_client = self._client_name()
+        self._aiohttp_digest_middleware: Any | None = None
+
+        if self._http_client == "aiohttp":
+            if device.config.auth_scheme == AuthScheme.BASIC:
+                self.auth = self._aiohttp_basic_auth()
+            else:
+                self.auth = None
+                self._aiohttp_digest_middleware = self._aiohttp_digest_middleware_obj()
+        elif device.config.auth_scheme == AuthScheme.BASIC:
+            self.auth = httpx.BasicAuth(device.config.username, device.config.password)
+        else:
+            self.auth = httpx.DigestAuth(device.config.username, device.config.password)
 
         self.users = Users(self)
         self.user_groups = UserGroups(self)
@@ -256,21 +274,44 @@ class Vapix:
         data: dict[str, str] | None = None,
         headers: dict[str, str] | None = None,
         params: dict[str, str] | None = None,
+    ) -> bytes:
+        """Make a request to the device."""
+        return await self._request(
+            method=method,
+            path=path,
+            content=content,
+            data=data,
+            headers=headers,
+            params=params,
+            allow_auto_basic_retry=True,
+        )
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        content: bytes | None = None,
+        data: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        params: dict[str, str] | None = None,
+        allow_auto_basic_retry: bool = False,
     ) -> bytes:
         """Make a request to the device."""
         url = self.device.config.url + path
         LOGGER.debug("%s, %s, '%s', '%s', '%s'", method, url, content, data, params)
 
         try:
-            response = await self.device.config.session.request(
-                method,
-                url,
+            (
+                status_code,
+                response_headers,
+                response_content,
+            ) = await self._perform_request(
+                method=method,
+                url=url,
                 content=content,
                 data=data,
                 headers=headers,
                 params=params,
-                auth=self.auth,
-                timeout=TIME_OUT,
             )
 
         except httpx.TimeoutException as errt:
@@ -287,18 +328,197 @@ class Vapix:
             message = f"Unknown error: {err}"
             raise RequestError(message) from err
 
-        try:
-            response.raise_for_status()
+        except TimeoutError as errt:
+            message = "Timeout"
+            raise RequestError(message) from errt
 
-        except httpx.HTTPStatusError as errh:
-            LOGGER.debug("%s, %s", response, errh)
-            raise_error(response.status_code)
+        except Exception as err:
+            if aiohttp is not None and isinstance(err, aiohttp.ClientConnectionError):
+                LOGGER.debug("%s", err)
+                message = f"Connection error: {err}"
+                raise RequestError(message) from err
+            if aiohttp is not None and isinstance(err, aiohttp.ClientError):
+                LOGGER.debug("%s", err)
+                message = f"Unknown error: {err}"
+                raise RequestError(message) from err
+            raise
+
+        if status_code >= 400:
+            if self._should_retry_with_basic(response_headers, allow_auto_basic_retry):
+                self.auth = self._basic_auth()
+                self._aiohttp_digest_middleware = None
+                return await self._request(
+                    method=method,
+                    path=path,
+                    content=content,
+                    data=data,
+                    headers=headers,
+                    params=params,
+                    allow_auto_basic_retry=False,
+                )
+
+            LOGGER.debug("status=%s headers=%s", status_code, response_headers)
+            raise_error(status_code)
 
         LOGGER.debug(
             "Response (from %s %s): %s",
             self.device.config.host,
             path,
-            response.content,
+            response_content,
+        )
+
+        return response_content
+
+    async def _perform_request(
+        self,
+        method: str,
+        url: str,
+        content: bytes | None,
+        data: dict[str, str] | None,
+        headers: dict[str, str] | None,
+        params: dict[str, str] | None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Execute request and normalize responses from supported HTTP clients."""
+        if self._http_client == "aiohttp":
+            return await self._perform_aiohttp_request(
+                method=method,
+                url=url,
+                content=content,
+                data=data,
+                headers=headers,
+                params=params,
+            )
+        return await self._perform_httpx_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            headers=headers,
+            params=params,
+        )
+
+    async def _perform_httpx_request(
+        self,
+        method: str,
+        url: str,
+        content: bytes | None,
+        data: dict[str, str] | None,
+        headers: dict[str, str] | None,
+        params: dict[str, str] | None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Execute request with a httpx session."""
+        session = self._httpx_session()
+        response = await session.request(
+            method,
+            url,
+            content=content,
+            data=data,
+            headers=headers,
+            params=params,
+            auth=self._httpx_auth(),
+            timeout=TIME_OUT,
+        )
+        return response.status_code, dict(response.headers), response.content
+
+    async def _perform_aiohttp_request(
+        self,
+        method: str,
+        url: str,
+        content: bytes | None,
+        data: dict[str, str] | None,
+        headers: dict[str, str] | None,
+        params: dict[str, str] | None,
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Execute request with an aiohttp session."""
+        request_data: bytes | dict[str, str] | None = (
+            content if content is not None else data
+        )
+        session = self._aiohttp_session()
+        request_kwargs: dict[str, Any] = {
+            "data": request_data,
+            "headers": headers,
+            "params": params,
+            "auth": self._aiohttp_auth(),
+            "timeout": TIME_OUT,
+        }
+        if middlewares := self._aiohttp_middlewares():
+            request_kwargs["middlewares"] = middlewares
+
+        async with session.request(method, url, **request_kwargs) as response:
+            response_content = await response.read()
+            return response.status, dict(response.headers), response_content
+
+    def _httpx_session(self) -> httpx.AsyncClient:
+        """Return session cast to a httpx client."""
+        return cast("httpx.AsyncClient", self.device.config.session)
+
+    def _aiohttp_session(self) -> ClientSession:
+        """Return session cast to an aiohttp client."""
+        return cast("ClientSession", self.device.config.session)
+
+    def _httpx_auth(self) -> httpx.Auth | None:
+        """Return auth cast for httpx requests."""
+        return cast("httpx.Auth | None", self.auth)
+
+    def _aiohttp_auth(self) -> AiohttpBasicAuth | None:
+        """Return auth cast for aiohttp requests."""
+        return cast("AiohttpBasicAuth | None", self.auth)
+
+    def _aiohttp_middlewares(self) -> tuple[Any, ...] | None:
+        """Return aiohttp middlewares used for auth challenges."""
+        if self._aiohttp_digest_middleware is None:
+            return None
+        return (self._aiohttp_digest_middleware,)
+
+    def _aiohttp_digest_middleware_obj(self) -> Any | None:
+        """Create aiohttp digest middleware when available and relevant."""
+        if self.device.config.auth_scheme == AuthScheme.BASIC:
+            return None
+
+        middleware_cls = getattr(aiohttp, "DigestAuthMiddleware", None)
+        if middleware_cls is None:
+            LOGGER.debug("aiohttp DigestAuthMiddleware unavailable, digest disabled")
+            return None
+
+        return middleware_cls(
+            login=self.device.config.username,
+            password=self.device.config.password,
+        )
+
+    def _basic_auth(self) -> object:
+        """Create basic auth object for configured HTTP client."""
+        if self._http_client == "aiohttp":
+            return self._aiohttp_basic_auth()
+        return httpx.BasicAuth(self.device.config.username, self.device.config.password)
+
+    def _aiohttp_basic_auth(self) -> object:
+        """Create aiohttp basic auth object."""
+        return aiohttp.BasicAuth(
+            self.device.config.username, self.device.config.password
         )
 
-        return response.content
+    def _client_name(self) -> str:
+        """Return normalized client name from configured session object."""
+        if isinstance(self.device.config.session, aiohttp.ClientSession):
+            return "aiohttp"
+        return "httpx"
+
+    def _should_retry_with_basic(
+        self, headers: dict[str, str], allow_auto_basic_retry: bool
+    ) -> bool:
+        """Return if request should retry once with basic authentication."""
+        if not allow_auto_basic_retry:
+            return False
+
+        if self.device.config.auth_scheme != AuthScheme.AUTO:
+            return False
+
+        if self._http_client == "httpx" and not isinstance(self.auth, httpx.DigestAuth):
+            return False
+
+        expected_auth = ""
+        for header_name, header_value in headers.items():
+            if header_name.lower() == "www-authenticate":
+                expected_auth = header_value.lower()
+                break
+        return "basic" in expected_auth

{axis-66 → axis-67}/axis/models/api_discovery.py

@@ -77,7 +77,7 @@ class ApiId(enum.StrEnum):
     UNKNOWN = "unknown"
 
     @classmethod
-    def _missing_(cls, value: object) -> "ApiId":
+    def _missing_(cls, value: object) -> ApiId:
         """Set default enum member if an unknown value is provided."""
         LOGGER.info("Unsupported API discovery ID '%s'", value)
         return ApiId.UNKNOWN
@@ -95,7 +95,7 @@ class ApiStatus(enum.StrEnum):
     UNKNOWN = "unknown"
 
     @classmethod
-    def _missing_(cls, value: object) -> "ApiStatus":
+    def _missing_(cls, value: object) -> ApiStatus:
         """Set default enum member if an unknown value is provided."""
         LOGGER.debug("Unsupported API discovery status '%s'", value)
         return ApiStatus.UNKNOWN

axis-67/axis/models/configuration.py

@@ -0,0 +1,87 @@
+"""Python library to enable Axis devices to integrate with Home Assistant."""
+
+from dataclasses import KW_ONLY, dataclass
+import enum
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from aiohttp import ClientSession
+    from httpx import AsyncClient
+
+    type HTTPSession = AsyncClient | ClientSession
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+class AuthScheme(enum.StrEnum):
+    """Supported HTTP authentication schemes."""
+
+    AUTO = "auto"
+    BASIC = "basic"
+    DIGEST = "digest"
+
+    @classmethod
+    def _missing_(cls, value: object) -> AuthScheme:
+        """Set default enum member if an unknown value is provided."""
+        LOGGER.debug("Unsupported auth scheme '%s'", value)
+        return AuthScheme.AUTO
+
+
+class WebProtocol(enum.StrEnum):
+    """Supported web protocols."""
+
+    HTTP = "http"
+    HTTPS = "https"
+
+    @classmethod
+    def _missing_(cls, value: object) -> WebProtocol:
+        """Set default enum member if an unknown value is provided."""
+        LOGGER.debug("Unsupported web protocol '%s'", value)
+        return WebProtocol.HTTP
+
+
+@dataclass
+class Configuration:
+    """Device configuration.
+
+    A port value of 0 means use the default port for the configured protocol.
+    """
+
+    session: HTTPSession
+    host: str
+    _: KW_ONLY
+    username: str
+    password: str
+    port: int = 0
+    web_proto: WebProtocol = WebProtocol.HTTP
+    verify_ssl: bool = False
+    is_companion: bool = False
+    auth_scheme: AuthScheme = AuthScheme.AUTO
+
+    def __post_init__(self) -> None:
+        """Normalize auth and protocol values to enums and resolve default port."""
+        self.web_proto = WebProtocol(self.web_proto)
+        self._validate_host()
+        if self.port == 0:
+            self.port = 443 if self.web_proto == WebProtocol.HTTPS else 80
+        self.auth_scheme = AuthScheme(self.auth_scheme)
+
+    def _validate_host(self) -> None:
+        """Validate that host is a plain hostname or IP address."""
+        if not self.host or self.host.strip() != self.host:
+            msg = "Host must be a non-empty hostname or IP address"
+            raise ValueError(msg)
+
+        if "://" in self.host or any(char in self.host for char in ("/", "?", "#")):
+            msg = (
+                "Host must not include scheme, path, query, or fragment; "
+                "use host, web_proto, and port separately"
+            )
+            raise ValueError(msg)
+
+    @property
+    def url(self) -> str:
+        """Represent device base url."""
+        return f"{self.web_proto}://{self.host}:{self.port}"