axis 69__tar.gz → 71__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 69
+Version: 71
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -19,25 +19,22 @@ 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"
+Requires-Dist: types-xmltodict==v1.0.1.20260508; extra == "requirements-test"
 Provides-Extra: requirements-dev
 Requires-Dist: pre-commit==4.6.0; extra == "requirements-dev"
 Dynamic: license-file

{axis-69 → axis-71}/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-71}/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-71}/axis/interfaces/mqtt.py

@@ -42,6 +42,8 @@ def mqtt_json_to_event(msg: bytes | bytearray | memoryview | str) -> dict[str, A
             source, source_idx = next(iter(source_dict.items()))
         if data_dict := msg_message.get("data"):
             data_type, data_value = next(iter(data_dict.items()))
+            if "active" in data_dict:
+                data_type, data_value = "active", data_dict["active"]
 
     return {
         "topic": topic,

{axis-69 → axis-71}/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-71}/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-71}/axis/models/event.py

@@ -91,6 +91,9 @@ TOPIC_TO_STATE = {
     EventTopic.RELAY: "active",
 }
 
+KNOWN_FALSE_STATES = {"", "0", "false", "inactive", "low", "off"}
+KNOWN_TRUE_STATES = {"1", "active", "high", "on", "true"}
+
 EVENT_OPERATION = "operation"
 EVENT_SOURCE = "source"
 EVENT_SOURCE_IDX = "source_idx"
@@ -138,6 +141,28 @@ def extract_name_value(
     return item.get("Name", ""), item.get("Value", "")
 
 
+def is_tripped(value: object, topic_base: EventTopic, event_type: object) -> bool:
+    """Return whether an event value should be considered active/tripped."""
+    if (expected_state := TOPIC_TO_STATE.get(topic_base)) is not None:
+        return str(value) == expected_state
+
+    value_text = str(value).strip()
+    state = value_text.casefold()
+
+    if state in KNOWN_FALSE_STATES:
+        return False
+
+    if state in KNOWN_TRUE_STATES:
+        return True
+
+    if str(event_type).casefold() == "active":
+        return False
+
+    # Non-empty semantic values (for example classification values like "human")
+    # are treated as stateless event triggers.
+    return bool(value_text)
+
+
 @dataclass
 class Event:
     """Event data from Axis device."""
@@ -166,6 +191,7 @@ class Event:
         topic = data.get(EVENT_TOPIC, "")
         source = data.get(EVENT_SOURCE, "")
         source_idx = data.get(EVENT_SOURCE_IDX, "")
+        event_type = data.get(EVENT_TYPE, "")
         value = data.get(EVENT_VALUE, "")
 
         if (topic_base := EventTopic(topic)) is EventTopic.UNKNOWN:
@@ -181,7 +207,7 @@ class Event:
             data=data,
             group=TOPIC_TO_GROUP.get(topic_base, EventGroup.NONE),
             id=source_idx,
-            is_tripped=value == TOPIC_TO_STATE.get(topic_base, "1"),
+            is_tripped=is_tripped(value, topic_base, event_type),
             operation=operation,
             source=source,
             state=value,

{axis-69 → axis-71}/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-71}/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.
 
@@ -71,6 +113,8 @@ def _parse_ws_notification(notification: dict[str, Any]) -> dict[str, Any]:
 
     source, source_idx = next(iter(source_dict.items()), ("", ""))
     data_type, data_value = next(iter(data_dict.items()), ("", ""))
+    if "active" in data_dict:
+        data_type, data_value = "active", data_dict["active"]
 
     return {
         EVENT_TOPIC: topic,
@@ -135,12 +179,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 +201,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 +229,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 +403,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-71}/axis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 69
+Version: 71
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -19,25 +19,22 @@ 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"
+Requires-Dist: types-xmltodict==v1.0.1.20260508; extra == "requirements-test"
 Provides-Extra: requirements-dev
 Requires-Dist: pre-commit==4.6.0; extra == "requirements-dev"
 Dynamic: license-file

{axis-69 → axis-71}/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-71}/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
+types-xmltodict==v1.0.1.20260508

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name        = "axis"
-version     = "69"
+version     = "71"
 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,20 +30,18 @@ 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",
+    "types-xmltodict==v1.0.1.20260508",
 ]
 requirements-dev = [
     "pre-commit==4.6.0"