axis 69__tar.gz → 70__tar.gz

{axis-69 → axis-70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 69
+Version: 70
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -19,23 +19,20 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12
 Requires-Dist: faust-cchardet>=2.1.18
-Requires-Dist: httpx>=0.26
 Requires-Dist: orjson>3.9
 Requires-Dist: packaging>23
 Requires-Dist: xmltodict>=0.13.0
 Provides-Extra: requirements
 Requires-Dist: aiohttp==3.13.5; extra == "requirements"
-Requires-Dist: httpx==0.28.1; extra == "requirements"
-Requires-Dist: orjson==3.11.8; extra == "requirements"
+Requires-Dist: orjson==3.11.9; extra == "requirements"
 Requires-Dist: packaging==26.2; extra == "requirements"
 Requires-Dist: xmltodict==1.0.4; extra == "requirements"
 Provides-Extra: requirements-test
-Requires-Dist: mypy==1.20.2; extra == "requirements-test"
+Requires-Dist: mypy==2.0.0; extra == "requirements-test"
 Requires-Dist: pytest==9.0.3; extra == "requirements-test"
 Requires-Dist: pytest-aiohttp==1.1.0; extra == "requirements-test"
 Requires-Dist: pytest-asyncio==1.3.0; extra == "requirements-test"
 Requires-Dist: pytest-cov==7.1.0; extra == "requirements-test"
-Requires-Dist: respx==0.23.1; extra == "requirements-test"
 Requires-Dist: ruff==0.15.12; extra == "requirements-test"
 Requires-Dist: types-xmltodict==v1.0.1.20260408; extra == "requirements-test"
 Provides-Extra: requirements-dev

{axis-69 → axis-70}/axis/__main__.py

@@ -113,11 +113,7 @@ async def main(
         device.stream.stop()
 
     finally:
-        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)
+        await close_session(device.config.session)
         device.stream.stop()
 
 

{axis-69 → axis-70}/axis/interfaces/aiohttp_digest.py

@@ -35,7 +35,7 @@ class AiohttpDigestAuth:
         """Return if aiohttp requests should use library-managed digest auth.
 
         Args:
-            http_client: Name of HTTP client ("aiohttp" or "httpx").
+            http_client: Name of HTTP client.
             has_basic_auth: Whether basic auth is configured.
 
         Returns:

{axis-69 → axis-70}/axis/interfaces/vapix.py

@@ -7,7 +7,6 @@ import logging
 from typing import TYPE_CHECKING, Any, cast
 
 import aiohttp
-import httpx
 
 from ..errors import RequestError, raise_error
 from ..models.configuration import AuthScheme
@@ -55,20 +54,14 @@ class Vapix:
     def __init__(self, device: AxisDevice) -> None:
         """Store local reference to device config."""
         self.device = device
-        self._http_client = self._client_name()
         self._aiohttp_digest_middleware: Any | None = None
         self._aiohttp_digest_auth = AiohttpDigestAuth(device)
 
-        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)
+        if device.config.auth_scheme == AuthScheme.BASIC:
+            self.auth = self._aiohttp_basic_auth()
         else:
-            self.auth = httpx.DigestAuth(device.config.username, device.config.password)
+            self.auth = None
+            self._aiohttp_digest_middleware = self._aiohttp_digest_middleware_obj()
 
         # Grouped handlers are registered in handler-construction order.
         # Handlers with empty handler_groups are intentionally excluded.
@@ -327,20 +320,6 @@ class Vapix:
                 params=params,
             )
 
-        except httpx.TimeoutException as errt:
-            message = "Timeout"
-            raise RequestError(message) from errt
-
-        except httpx.TransportError as errc:
-            LOGGER.debug("%s", errc)
-            message = f"Connection error: {errc}"
-            raise RequestError(message) from errc
-
-        except httpx.RequestError as err:
-            LOGGER.debug("%s", err)
-            message = f"Unknown error: {err}"
-            raise RequestError(message) from err
-
         except TimeoutError as errt:
             message = "Timeout"
             raise RequestError(message) from errt
@@ -391,17 +370,8 @@ class Vapix:
         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(
+        """Execute request and normalize responses."""
+        return await self._perform_aiohttp_request(
             method=method,
             url=url,
             content=content,
@@ -410,29 +380,6 @@ class Vapix:
             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,
@@ -449,8 +396,7 @@ class Vapix:
         session = self._aiohttp_session()
 
         if (
-            self._http_client == "aiohttp"
-            and not self._aiohttp_auth()
+            not self._aiohttp_auth()
             and self.device.config.auth_scheme != AuthScheme.BASIC
         ):
             return await self._aiohttp_digest_auth.perform_request(
@@ -471,17 +417,9 @@ class Vapix:
             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)
+        return self.device.config.session
 
     def _aiohttp_auth(self) -> AiohttpBasicAuth | None:
         """Return auth cast for aiohttp requests."""
@@ -509,10 +447,8 @@ class Vapix:
         )
 
     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)
+        """Create basic auth object."""
+        return self._aiohttp_basic_auth()
 
     def _aiohttp_basic_auth(self) -> object:
         """Create aiohttp basic auth object."""
@@ -520,12 +456,6 @@ class Vapix:
             self.device.config.username, self.device.config.password
         )
 
-    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:
@@ -536,9 +466,6 @@ class Vapix:
         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":

{axis-69 → axis-70}/axis/models/configuration.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from aiohttp import ClientSession
-    from httpx import AsyncClient
 
-    type HTTPSession = AsyncClient | ClientSession
+    type HTTPSession = ClientSession
 
 
 LOGGER = logging.getLogger(__name__)

{axis-69 → axis-70}/axis/stream_manager.py

@@ -37,6 +37,7 @@ class StreamManager:
         self.background_tasks: set[asyncio.Task[None]] = set()
         self.retry_timer: asyncio.TimerHandle | None = None
         self._starting = False
+        self._websocket_temporarily_disabled = False
 
     @property
     def stream_url(self) -> str:
@@ -84,6 +85,11 @@ class StreamManager:
         """Use websocket transport when event websocket API is available."""
         if not self.event:
             return False
+        if (
+            self._websocket_temporarily_disabled
+            and not self.device.config.websocket_force
+        ):
+            return False
         if self.device.config.websocket_force:
             return True
         return (
@@ -91,6 +97,25 @@ class StreamManager:
             and WebSocketClient.supported_by_device(self.device)
         )
 
+    def _handle_websocket_failure(self) -> None:
+        """Disable websocket for runtime when TLS certificate validation fails."""
+        if self.device.config.websocket_force:
+            return
+
+        if self.stream is None:
+            return
+
+        if not getattr(self.stream, "should_disable_runtime_websocket", False):
+            return
+
+        if not self._websocket_temporarily_disabled:
+            _LOGGER.warning(
+                "Disabling websocket events for %s until restart after certificate verification failure",
+                self.device.config.host,
+            )
+
+        self._websocket_temporarily_disabled = True
+
     @property
     def _is_stream_stopped(self) -> bool:
         """Return True when stream is missing or currently stopped."""
@@ -124,6 +149,7 @@ class StreamManager:
             self.device.event.handler(self.data)
 
         elif signal == Signal.FAILED:
+            self._handle_websocket_failure()
             self.retry()
 
         if signal in (Signal.PLAYING, Signal.FAILED):

{axis-69 → axis-70}/axis/websocket.py

@@ -13,7 +13,9 @@ from __future__ import annotations
 
 import asyncio
 from collections import deque
+import enum
 import logging
+import ssl
 from time import time
 from typing import TYPE_CHECKING, Any
 
@@ -48,6 +50,46 @@ RECEIVE_TIMEOUT = (
 BUFFER_SIZE = 200
 
 
+class WebSocketFailureReason(enum.StrEnum):
+    """Classified websocket startup failure reason."""
+
+    NONE = "none"
+    SSL_CERTIFICATE = "ssl_certificate"
+    OTHER = "other"
+
+
+def _walk_exception_chain(err: BaseException) -> list[BaseException]:
+    """Return exceptions in causal chain for robust error classification."""
+    chain: list[BaseException] = []
+    seen: set[int] = set()
+    current: BaseException | None = err
+
+    while current is not None and id(current) not in seen:
+        chain.append(current)
+        seen.add(id(current))
+        current = current.__cause__ or current.__context__
+
+    return chain
+
+
+def _classify_connect_error(err: BaseException) -> WebSocketFailureReason:
+    """Classify websocket connect failure for fallback decisions."""
+    for exc in _walk_exception_chain(err):
+        if isinstance(
+            exc,
+            (
+                ssl.SSLCertVerificationError,
+                aiohttp.ClientConnectorCertificateError,
+            ),
+        ):
+            return WebSocketFailureReason.SSL_CERTIFICATE
+
+        if "CERTIFICATE_VERIFY_FAILED" in str(exc):
+            return WebSocketFailureReason.SSL_CERTIFICATE
+
+    return WebSocketFailureReason.OTHER
+
+
 def _parse_ws_notification(notification: dict[str, Any]) -> dict[str, Any]:
     """Parse a VAPIX events:notify notification into the internal event dict format.
 
@@ -135,12 +177,14 @@ class WebSocketClient:
         self._data: deque[dict[str, Any]] = deque(maxlen=BUFFER_SIZE)
 
         self._ws_session: aiohttp.ClientSession | None = None
+        self._owns_ws_session = False
         self._ws: aiohttp.ClientWebSocketResponse | None = None
         self._receiver_task: asyncio.Task[None] | None = None
         self._close_task: asyncio.Task[None] | None = None
         self._stopped = False
         self._starting = False
         self._start_time: float | None = None
+        self._last_failure_reason = WebSocketFailureReason.NONE
 
     @classmethod
     def supported_by_device(cls, device: AxisDevice) -> bool:
@@ -155,6 +199,11 @@ class WebSocketClient:
         except IndexError:
             return {}
 
+    @property
+    def should_disable_runtime_websocket(self) -> bool:
+        """Return true if websocket should be disabled for this runtime."""
+        return self._last_failure_reason == WebSocketFailureReason.SSL_CERTIFICATE
+
     async def _get_session_token(self) -> str | None:
         """Obtain a short-lived session token for websocket authentication.
 
@@ -178,32 +227,39 @@ class WebSocketClient:
         self._stopped = False
         self.session.state = State.STARTING
         self._start_time = time()
+        self._last_failure_reason = WebSocketFailureReason.NONE
 
         try:
             if self._close_task is not None:
                 await asyncio.shield(self._close_task)
 
             token = await self._get_session_token()
+            self._ws_session = self.device.config.session
+            self._owns_ws_session = False
+
+            ws_connect_kwargs: dict[str, Any] = {
+                "heartbeat": HEARTBEAT_INTERVAL,
+                "timeout": self._ws_timeout,
+            }
+            if not self.device.config.verify_ssl:
+                ws_connect_kwargs["ssl"] = False
+
             if token:
                 connect_url = f"{self.url}&wssession={token}"
-                self._ws_session = aiohttp.ClientSession()
             else:
                 # Fall back to HTTP Basic auth in the upgrade handshake.
                 connect_url = self.url
-                self._ws_session = aiohttp.ClientSession(
-                    auth=aiohttp.BasicAuth(
-                        self.device.config.username,
-                        self.device.config.password,
-                    ),
+                ws_connect_kwargs["auth"] = aiohttp.BasicAuth(
+                    self.device.config.username,
+                    self.device.config.password,
                 )
 
             self._ws = await self._ws_session.ws_connect(
-                connect_url,
-                heartbeat=HEARTBEAT_INTERVAL,
-                timeout=self._ws_timeout,
+                connect_url, **ws_connect_kwargs
             )
         except (aiohttp.ClientError, TimeoutError, OSError) as err:
             _LOGGER.warning("Websocket connect failed: %s", err)
+            self._last_failure_reason = _classify_connect_error(err)
             await self._close()
             self.session.state = State.STOPPED
             self._signal(Signal.FAILED)
@@ -345,9 +401,11 @@ class WebSocketClient:
             await self._ws.close()
             self._ws = None
 
-        if self._ws_session is not None:
+        if self._ws_session is not None and self._owns_ws_session:
             await self._ws_session.close()
-            self._ws_session = None
+
+        self._ws_session = None
+        self._owns_ws_session = False
 
     def _signal(self, signal: Signal) -> None:
         """Invoke the signal callback, swallowing any exceptions."""

{axis-69 → axis-70}/axis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 69
+Version: 70
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -19,23 +19,20 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.12
 Requires-Dist: faust-cchardet>=2.1.18
-Requires-Dist: httpx>=0.26
 Requires-Dist: orjson>3.9
 Requires-Dist: packaging>23
 Requires-Dist: xmltodict>=0.13.0
 Provides-Extra: requirements
 Requires-Dist: aiohttp==3.13.5; extra == "requirements"
-Requires-Dist: httpx==0.28.1; extra == "requirements"
-Requires-Dist: orjson==3.11.8; extra == "requirements"
+Requires-Dist: orjson==3.11.9; extra == "requirements"
 Requires-Dist: packaging==26.2; extra == "requirements"
 Requires-Dist: xmltodict==1.0.4; extra == "requirements"
 Provides-Extra: requirements-test
-Requires-Dist: mypy==1.20.2; extra == "requirements-test"
+Requires-Dist: mypy==2.0.0; extra == "requirements-test"
 Requires-Dist: pytest==9.0.3; extra == "requirements-test"
 Requires-Dist: pytest-aiohttp==1.1.0; extra == "requirements-test"
 Requires-Dist: pytest-asyncio==1.3.0; extra == "requirements-test"
 Requires-Dist: pytest-cov==7.1.0; extra == "requirements-test"
-Requires-Dist: respx==0.23.1; extra == "requirements-test"
 Requires-Dist: ruff==0.15.12; extra == "requirements-test"
 Requires-Dist: types-xmltodict==v1.0.1.20260408; extra == "requirements-test"
 Provides-Extra: requirements-dev

{axis-69 → axis-70}/axis.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ tests/test_api_handler.py
 tests/test_auth_scheme.py
 tests/test_basic_device_info.py
 tests/test_configuration.py
+tests/test_conftest.py
 tests/test_device.py
 tests/test_event.py
 tests/test_event_instances.py

{axis-69 → axis-70}/axis.egg-info/requires.txt

@@ -1,14 +1,12 @@
 aiohttp>=3.12
 faust-cchardet>=2.1.18
-httpx>=0.26
 orjson>3.9
 packaging>23
 xmltodict>=0.13.0
 
 [requirements]
 aiohttp==3.13.5
-httpx==0.28.1
-orjson==3.11.8
+orjson==3.11.9
 packaging==26.2
 xmltodict==1.0.4
 
@@ -16,11 +14,10 @@ xmltodict==1.0.4
 pre-commit==4.6.0
 
 [requirements-test]
-mypy==1.20.2
+mypy==2.0.0
 pytest==9.0.3
 pytest-aiohttp==1.1.0
 pytest-asyncio==1.3.0
 pytest-cov==7.1.0
-respx==0.23.1
 ruff==0.15.12
 types-xmltodict==v1.0.1.20260408

{axis-69 → axis-70}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name        = "axis"
-version     = "69"
+version     = "70"
 license     = {text = "MIT"}
 description = "A Python library for communicating with devices from Axis Communications"
 readme      = "README.md"
@@ -22,7 +22,6 @@ requires-python = ">=3.14.0"
 dependencies    = [
     "aiohttp>=3.12",
     "faust-cchardet>=2.1.18",
-    "httpx>=0.26",
     "orjson>3.9",
     "packaging>23",
     "xmltodict>=0.13.0",
@@ -31,18 +30,16 @@ dependencies    = [
 [project.optional-dependencies]
 requirements = [
     "aiohttp==3.13.5",
-    "httpx==0.28.1",
-    "orjson==3.11.8",
+    "orjson==3.11.9",
     "packaging==26.2",
     "xmltodict==1.0.4",
 ]
 requirements-test = [
-    "mypy==1.20.2",
+    "mypy==2.0.0",
     "pytest==9.0.3",
     "pytest-aiohttp==1.1.0",
     "pytest-asyncio==1.3.0",
     "pytest-cov==7.1.0",
-    "respx==0.23.1",
     "ruff==0.15.12",
     "types-xmltodict==v1.0.1.20260408",
 ]

{axis-69 → axis-70}/tests/test_api_discovery.py

@@ -4,22 +4,9 @@ pytest --cov-report term-missing --cov=axis.api_discovery tests/test_api_discove
 """
 
 import json
-from typing import TYPE_CHECKING
-
-import pytest
 
 from axis.models.api_discovery import ApiId, ApiStatus
 
-if TYPE_CHECKING:
-    from axis.device import AxisDevice
-    from axis.interfaces.api_discovery import ApiDiscoveryHandler
-
-
-@pytest.fixture
-def api_discovery(axis_device: AxisDevice) -> ApiDiscoveryHandler:
-    """Return the api_discovery mock object."""
-    return axis_device.vapix.api_discovery
-
 
 async def test_api_id_enum():
     """Verify API ID of unsupported type."""
@@ -31,11 +18,13 @@ async def test_api_status_enum():
     assert ApiStatus("unsupported") is ApiStatus.UNKNOWN
 
 
-async def test_get_api_list(respx_mock, api_discovery: ApiDiscoveryHandler):
+async def test_get_api_list(http_route_mock, axis_device):
     """Test get_api_list call."""
-    route = respx_mock.post("/axis-cgi/apidiscovery.cgi").respond(
+    route = http_route_mock.post("/axis-cgi/apidiscovery.cgi").respond(
         json=GET_API_LIST_RESPONSE,
     )
+    api_discovery = axis_device.vapix.api_discovery
+
     assert api_discovery.supported
     await api_discovery.update()
 
@@ -59,11 +48,13 @@ async def test_get_api_list(respx_mock, api_discovery: ApiDiscoveryHandler):
     assert item.version == "1.0"
 
 
-async def test_get_supported_versions(respx_mock, api_discovery: ApiDiscoveryHandler):
+async def test_get_supported_versions(http_route_mock, axis_device):
     """Test get_supported_versions."""
-    route = respx_mock.post("/axis-cgi/apidiscovery.cgi").respond(
+    route = http_route_mock.post("/axis-cgi/apidiscovery.cgi").respond(
         json=GET_SUPPORTED_VERSIONS_RESPONSE,
     )
+    api_discovery = axis_device.vapix.api_discovery
+
     response = await api_discovery.get_supported_versions()
 
     assert route.called