axis 67__tar.gz → 68__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis
-Version: 67
+Version: 68
 Summary: A Python library for communicating with devices from Axis Communications
 Author-email: Robert Svensson <Kane610@users.noreply.github.com>
 License: MIT
@@ -24,22 +24,75 @@ 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: aiohttp==3.13.5; extra == "requirements"
 Requires-Dist: httpx==0.28.1; extra == "requirements"
-Requires-Dist: orjson==3.11.7; extra == "requirements"
+Requires-Dist: orjson==3.11.8; 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: mypy==1.20.0; extra == "requirements-test"
 Requires-Dist: pytest==9.0.2; 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.0.0; extra == "requirements-test"
+Requires-Dist: pytest-cov==7.1.0; extra == "requirements-test"
 Requires-Dist: respx==0.22.0; extra == "requirements-test"
-Requires-Dist: ruff==0.15.6; extra == "requirements-test"
+Requires-Dist: ruff==0.15.9; 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
+
 Python project to set up a connection towards Axis Communications devices and to subscribe to specific events on the metadatastream.
+
+## Development setup
+
+`uv` is required for development setup:
+
+```bash
+uv python install 3.14
+uv sync --python 3.14 --all-extras
+```
+
+Or run the bootstrap script, which installs `uv` if needed and provisions Python 3.14 automatically:
+
+```bash
+./setup.sh
+```
+
+Dependencies are locked via `uv.lock`. Regenerate lock data when dependency inputs change:
+
+```bash
+uv lock
+```
+
+Run checks with `uv`:
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy axis
+uv run pytest
+```
+
+Initial `ty` support is configured as an opt-in check and does not replace `mypy`:
+
+```bash
+uvx ty check
+```
+
+## Initialization architecture
+
+Vapix initialization is phase-based and driven by handler metadata:
+
+- `API_DISCOVERY`: handlers initialized after API discovery.
+- `PARAM_CGI_FALLBACK`: handlers that may initialize from parameter support when not listed in discovery.
+- `APPLICATION`: handlers initialized after applications are loaded.
+
+Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
+
+Example fallback policy:
+
+- `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
+- In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.

axis-68/README.md

@@ -0,0 +1,54 @@
+# axis
+
+Python project to set up a connection towards Axis Communications devices and to subscribe to specific events on the metadatastream.
+
+## Development setup
+
+`uv` is required for development setup:
+
+```bash
+uv python install 3.14
+uv sync --python 3.14 --all-extras
+```
+
+Or run the bootstrap script, which installs `uv` if needed and provisions Python 3.14 automatically:
+
+```bash
+./setup.sh
+```
+
+Dependencies are locked via `uv.lock`. Regenerate lock data when dependency inputs change:
+
+```bash
+uv lock
+```
+
+Run checks with `uv`:
+
+```bash
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy axis
+uv run pytest
+```
+
+Initial `ty` support is configured as an opt-in check and does not replace `mypy`:
+
+```bash
+uvx ty check
+```
+
+## Initialization architecture
+
+Vapix initialization is phase-based and driven by handler metadata:
+
+- `API_DISCOVERY`: handlers initialized after API discovery.
+- `PARAM_CGI_FALLBACK`: handlers that may initialize from parameter support when not listed in discovery.
+- `APPLICATION`: handlers initialized after applications are loaded.
+
+Handlers declare phase membership through `handler_groups` and may customize phase eligibility through `should_initialize_in_group`.
+
+Example fallback policy:
+
+- `LightHandler` participates in both `API_DISCOVERY` and `PARAM_CGI_FALLBACK`.
+- In `PARAM_CGI_FALLBACK`, it initializes only when not listed in API discovery and listed in parameters.

{axis-67 → axis-68}/axis/__main__.py

@@ -28,10 +28,12 @@ async def axis_device(
     username: str,
     password: str,
     web_proto: WebProtocol,
+    stream_mode: str = "rtsp",
     is_companion: bool = False,
 ) -> axis.device.AxisDevice:
     """Create a Axis device."""
     session = create_session()
+    websocket_enabled, websocket_force = websocket_flags_from_mode(stream_mode)
     device = AxisDevice(
         Configuration(
             session,
@@ -41,6 +43,8 @@ async def axis_device(
             password=password,
             is_companion=is_companion,
             web_proto=web_proto,
+            websocket_enabled=websocket_enabled,
+            websocket_force=websocket_force,
         )
     )
 
@@ -74,6 +78,7 @@ async def main(
     params: bool,
     events: bool,
     web_proto: WebProtocol,
+    stream_mode: str,
 ) -> None:
     """CLI method for library."""
     LOGGER.info("Connecting to Axis device")
@@ -84,6 +89,7 @@ async def main(
         username,
         password,
         web_proto=web_proto,
+        stream_mode=stream_mode,
     )
 
     if not device:
@@ -126,6 +132,15 @@ async def close_session(session: aiohttp.ClientSession) -> None:
     await session.close()
 
 
+def websocket_flags_from_mode(stream_mode: str) -> tuple[bool, bool]:
+    """Translate CLI stream mode to websocket enable/force flags."""
+    if stream_mode == "auto":
+        return True, False
+    if stream_mode == "event":
+        return True, True
+    return False, False
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("host", type=str)
@@ -135,6 +150,11 @@ if __name__ == "__main__":
     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(
+        "--stream-mode",
+        choices=["auto", "rtsp", "event"],
+        default="rtsp",
+    )
     parser.add_argument("-D", "--debug", action="store_true")
     args = parser.parse_args()
 
@@ -163,6 +183,7 @@ if __name__ == "__main__":
                 params=args.params,
                 events=args.events,
                 web_proto=WebProtocol(args.proto),
+                stream_mode=args.stream_mode,
             )
         )
 

{axis-67 → axis-68}/axis/interfaces/api_handler.py

@@ -8,6 +8,7 @@ from collections.abc import (
     Sequence,
     ValuesView,
 )
+import enum
 from typing import TYPE_CHECKING, Generic, final
 
 from ..errors import Forbidden, PathNotFound, Unauthorized
@@ -25,6 +26,14 @@ UnsubscribeType = Callable[[], None]
 ID_FILTER_ALL = "*"
 
 
+class HandlerGroup(enum.Enum):
+    """Group handlers by initialization phase in Vapix."""
+
+    API_DISCOVERY = "api_discovery"
+    PARAM_CGI_FALLBACK = "param_cgi_fallback"
+    APPLICATION = "application"
+
+
 class SubscriptionHandler:
     """Manage subscription and notification to subscribers."""
 
@@ -75,12 +84,14 @@ class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
 
     api_id: ApiId | None = None
     default_api_version: str | None = None
+    handler_groups: tuple[HandlerGroup, ...] = ()
     skip_support_check = False
 
     def __init__(self, vapix: Vapix) -> None:
         """Initialize API items."""
         super().__init__()
         self.vapix = vapix
+        self.vapix._register_handler(self)
         self._items: dict[str, ApiItemT] = {}
         self.initialized = False
 
@@ -101,6 +112,10 @@ class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
         """Is API listed in parameters."""
         return False
 
+    def should_initialize_in_group(self, group: HandlerGroup) -> bool:
+        """Return whether handler should initialize in the given group."""
+        return True
+
     async def _api_request(self) -> dict[str, ApiItemT]:
         """Get API data method defined by subclass."""
         raise NotImplementedError
@@ -134,15 +149,41 @@ class ApiHandler(SubscriptionHandler, Generic[ApiItemT]):
         return self.initialized
 
     @property
-    def api_version(self) -> str | None:
-        """Latest API version supported."""
-        if (
-            self.api_id is not None
-            and (discovery_item := self.vapix.api_discovery.get(self.api_id))
-            is not None
-        ):
-            return discovery_item.version
-        return self.default_api_version
+    def api_version(self) -> str:
+        """Latest API version supported.
+
+        Returns the API version in this order of precedence:
+        1. Version from device discovery (dynamic, device-specific)
+        2. Handler's default_api_version (static, library-defined)
+        3. Empty string "" (for handlers without discovery support)
+
+        Note: This property always returns a string (never None). Handlers that don't
+        support API versioning (no api_id) return empty string, which is safe because
+        they don't send api_version in their requests.
+
+        Returns:
+            str: API version (e.g., "1.0", "1.1") or empty string if not available.
+
+        """
+        discovery_version = self._get_api_discovery_version()
+        if discovery_version is not None:
+            return discovery_version
+        return self.default_api_version or ""
+
+    def _get_api_discovery_version(self) -> str | None:
+        """Get API version from discovery data when available."""
+        if self.api_id is None:
+            return None
+
+        discovery_item = self.vapix.api_discovery.get(self.api_id)
+        if discovery_item is None:
+            return None
+
+        discovery_version = getattr(discovery_item, "version", None)
+        if isinstance(discovery_version, str):
+            return discovery_version
+
+        return None
 
     def items(self) -> ItemsView[str, ApiItemT]:
         """Return items."""

{axis-67 → axis-68}/axis/interfaces/applications/application_handler.py

@@ -4,13 +4,14 @@ from abc import abstractmethod
 
 from ...models.api import ApiItemT
 from ...models.applications.application import ApplicationName, ApplicationStatus
-from ..api_handler import ApiHandler
+from ..api_handler import ApiHandler, HandlerGroup
 
 
 class ApplicationHandler(ApiHandler[ApiItemT]):
     """Generic application handler."""
 
     app_name: ApplicationName
+    handler_groups = (HandlerGroup.APPLICATION,)
 
     @property
     def supported(self) -> bool:

{axis-67 → axis-68}/axis/interfaces/basic_device_info.py

@@ -14,7 +14,7 @@ from ..models.basic_device_info import (
     GetSupportedVersionsRequest,
     GetSupportedVersionsResponse,
 )
-from .api_handler import ApiHandler
+from .api_handler import ApiHandler, HandlerGroup
 
 
 class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
@@ -22,6 +22,7 @@ class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
 
     api_id = ApiId.BASIC_DEVICE_INFO
     default_api_version = API_VERSION
+    handler_groups = (HandlerGroup.API_DISCOVERY,)
 
     async def _api_request(self) -> dict[str, DeviceInformation]:
         """Get default data of basic device information."""
@@ -29,9 +30,8 @@ class BasicDeviceInfoHandler(ApiHandler[DeviceInformation]):
 
     async def get_all_properties(self) -> dict[str, DeviceInformation]:
         """List all properties of basic device info."""
-        discovery_item = self.vapix.api_discovery[self.api_id]
         bytes_data = await self.vapix.api_request(
-            GetAllPropertiesRequest(discovery_item.version)
+            GetAllPropertiesRequest(self.api_version)
         )
         response = GetAllPropertiesResponse.decode(bytes_data)
         return {"0": response.data}

{axis-67 → axis-68}/axis/interfaces/light_control.py

@@ -45,7 +45,7 @@ from ..models.light_control import (
     SetManualAngleOfIlluminationModeRequest,
     SetManualIntensityRequest,
 )
-from .api_handler import ApiHandler
+from .api_handler import ApiHandler, HandlerGroup
 
 
 class LightHandler(ApiHandler[LightInformation]):
@@ -53,6 +53,10 @@ class LightHandler(ApiHandler[LightInformation]):
 
     api_id = ApiId.LIGHT_CONTROL
     default_api_version = API_VERSION
+    handler_groups = (
+        HandlerGroup.API_DISCOVERY,
+        HandlerGroup.PARAM_CGI_FALLBACK,
+    )
 
     @property
     def listed_in_parameters(self) -> bool:
@@ -61,6 +65,12 @@ class LightHandler(ApiHandler[LightInformation]):
             return prop.light_control
         return False
 
+    def should_initialize_in_group(self, group: HandlerGroup) -> bool:
+        """Return whether handler should initialize in the given group."""
+        if group is HandlerGroup.PARAM_CGI_FALLBACK:
+            return not self.listed_in_api_discovery and self.listed_in_parameters
+        return True
+
     async def _api_request(self) -> dict[str, LightInformation]:
         """Get default data of stream profiles."""
         return await self.get_light_information()
@@ -68,51 +78,45 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_light_information(self) -> dict[str, LightInformation]:
         """List the light control information."""
         bytes_data = await self.vapix.api_request(
-            GetLightInformationRequest(api_version=self.default_api_version)
+            GetLightInformationRequest(api_version=self.api_version)
         )
         return GetLightInformationResponse.decode(bytes_data).data
 
     async def get_service_capabilities(self) -> ServiceCapabilities:
         """List the light control information."""
         bytes_data = await self.vapix.api_request(
-            GetServiceCapabilitiesRequest(api_version=self.default_api_version)
+            GetServiceCapabilitiesRequest(api_version=self.api_version)
         )
         return GetServiceCapabilitiesResponse.decode(bytes_data).data
 
     async def activate_light(self, light_id: str) -> None:
         """Activate the light."""
         await self.vapix.api_request(
-            ActivateLightRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            ActivateLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def deactivate_light(self, light_id: str) -> None:
         """Deactivate the light."""
         await self.vapix.api_request(
-            DeactivateLightRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            DeactivateLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def enable_light(self, light_id: str) -> None:
         """Activate the light."""
         await self.vapix.api_request(
-            EnableLightRequest(api_version=self.default_api_version, light_id=light_id)
+            EnableLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def disable_light(self, light_id: str) -> None:
         """Deactivate the light."""
         await self.vapix.api_request(
-            DisableLightRequest(api_version=self.default_api_version, light_id=light_id)
+            DisableLightRequest(api_version=self.api_version, light_id=light_id)
         )
 
     async def get_light_status(self, light_id: str) -> bool:
         """Get light status if its on or off."""
         bytes_data = await self.vapix.api_request(
-            GetLightStatusRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetLightStatusRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetLightStatusResponse.decode(bytes_data).data
 
@@ -120,7 +124,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Enable the automatic light intensity control."""
         await self.vapix.api_request(
             SetAutomaticIntensityModeRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 enabled=enabled,
             )
@@ -129,9 +133,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_valid_intensity(self, light_id: str) -> Range:
         """Get valid intensity range for light."""
         bytes_data = await self.vapix.api_request(
-            GetValidIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetValidIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetValidIntensityResponse.decode(bytes_data).data
 
@@ -139,7 +141,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Manually sets the intensity."""
         await self.vapix.api_request(
             SetManualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 intensity=intensity,
             )
@@ -148,9 +150,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_manual_intensity(self, light_id: str) -> int:
         """Enable the automatic light intensity control."""
         bytes_data = await self.vapix.api_request(
-            GetManualIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetManualIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetManualIntensityResponse.decode(bytes_data).data
 
@@ -160,7 +160,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Manually sets the intensity for an individual LED."""
         await self.vapix.api_request(
             SetIndividualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 led_id=led_id,
                 intensity=intensity,
@@ -171,7 +171,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Receives the intensity from the setIndividualIntensity request."""
         bytes_data = await self.vapix.api_request(
             GetIndividualIntensityRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 led_id=led_id,
             )
@@ -181,9 +181,7 @@ class LightHandler(ApiHandler[LightInformation]):
     async def get_current_intensity(self, light_id: str) -> int:
         """Receives the intensity from the setIndividualIntensity request."""
         bytes_data = await self.vapix.api_request(
-            GetCurrentIntensityRequest(
-                api_version=self.default_api_version, light_id=light_id
-            )
+            GetCurrentIntensityRequest(api_version=self.api_version, light_id=light_id)
         )
         return GetCurrentIntensityResponse.decode(bytes_data).data
 
@@ -197,7 +195,9 @@ class LightHandler(ApiHandler[LightInformation]):
         """
         await self.vapix.api_request(
             SetAutomaticAngleOfIlluminationModeRequest(
-                api_version=self.default_api_version, light_id=light_id, enabled=enabled
+                api_version=self.api_version,
+                light_id=light_id,
+                enabled=enabled,
             )
         )
 
@@ -205,7 +205,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """List the valid angle of illumination values."""
         bytes_data = await self.vapix.api_request(
             GetValidAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetValidAngleOfIlluminationResponse.decode(bytes_data).data
@@ -220,7 +220,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """
         await self.vapix.api_request(
             SetManualAngleOfIlluminationModeRequest(
-                api_version=self.default_api_version,
+                api_version=self.api_version,
                 light_id=light_id,
                 angle_of_illumination=angle_of_illumination,
             )
@@ -230,7 +230,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Get the angle of illumination."""
         bytes_data = await self.vapix.api_request(
             GetManualAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetManualAngleOfIlluminationResponse.decode(bytes_data).data
@@ -239,7 +239,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Receive the current angle of illumination."""
         bytes_data = await self.vapix.api_request(
             GetCurrentAngleOfIlluminationRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetCurrentAngleOfIlluminationResponse.decode(bytes_data).data
@@ -250,7 +250,9 @@ class LightHandler(ApiHandler[LightInformation]):
         """Enable automatic synchronization with the day/night mode."""
         await self.vapix.api_request(
             SetLightSynchronizeDayNightModeRequest(
-                api_version=self.default_api_version, light_id=light_id, enabled=enabled
+                api_version=self.api_version,
+                light_id=light_id,
+                enabled=enabled,
             )
         )
 
@@ -258,7 +260,7 @@ class LightHandler(ApiHandler[LightInformation]):
         """Check if the automatic synchronization is enabled with the day/night mode."""
         bytes_data = await self.vapix.api_request(
             GetLightSynchronizeDayNightModeRequest(
-                api_version=self.default_api_version, light_id=light_id
+                api_version=self.api_version, light_id=light_id
             )
         )
         return GetLightSynchronizeDayNightModeResponse.decode(bytes_data).data

{axis-67 → axis-68}/axis/interfaces/mqtt.py

@@ -20,23 +20,28 @@ from ..models.mqtt import (
     GetEventPublicationConfigRequest,
     GetEventPublicationConfigResponse,
 )
-from .api_handler import ApiHandler
+from .api_handler import ApiHandler, HandlerGroup
 
 DEFAULT_TOPICS = ["//."]
 
 
 def mqtt_json_to_event(msg: bytes | bytearray | memoryview | str) -> dict[str, Any]:
-    """Convert JSON message from MQTT to event format."""
+    """Convert JSON message from MQTT to event format.
+
+    Returns None if required keys are missing.
+    """
     message = orjson.loads(msg)
-    topic = message["topic"].replace("onvif", "tns1").replace("axis", "tnsaxis")
+    topic = source = source_idx = data_type = data_value = ""
 
-    source = source_idx = ""
-    if message["message"]["source"]:
-        source, source_idx = next(iter(message["message"]["source"].items()))
+    if "topic" in message:
+        topic = message["topic"].replace("onvif", "tns1").replace("axis", "tnsaxis")
 
-    data_type = data_value = ""
-    if message["message"]["data"]:
-        data_type, data_value = next(iter(message["message"]["data"].items()))
+    msg_message = message.get("message", {})
+    if isinstance(msg_message, dict):
+        if source_dict := msg_message.get("source"):
+            source, source_idx = next(iter(source_dict.items()))
+        if data_dict := msg_message.get("data"):
+            data_type, data_value = next(iter(data_dict.items()))
 
     return {
         "topic": topic,
@@ -52,31 +57,32 @@ class MqttClientHandler(ApiHandler[Any]):
 
     api_id = ApiId.MQTT_CLIENT
     default_api_version = API_VERSION
+    handler_groups = (HandlerGroup.API_DISCOVERY,)
 
     async def configure_client(self, client_config: ClientConfig) -> None:
         """Configure MQTT Client."""
         await self.vapix.api_request(
             ConfigureClientRequest(
-                api_version=self.default_api_version, client_config=client_config
+                api_version=self.api_version, client_config=client_config
             )
         )
 
     async def activate(self) -> None:
         """Activate MQTT Client."""
         await self.vapix.api_request(
-            ActivateClientRequest(api_version=self.default_api_version)
+            ActivateClientRequest(api_version=self.api_version)
         )
 
     async def deactivate(self) -> None:
         """Deactivate MQTT Client."""
         await self.vapix.api_request(
-            DeactivateClientRequest(api_version=self.default_api_version)
+            DeactivateClientRequest(api_version=self.api_version)
         )
 
     async def get_client_status(self) -> ClientConfigStatus:
         """Get MQTT Client status."""
         bytes_data = await self.vapix.api_request(
-            GetClientStatusRequest(api_version=self.default_api_version)
+            GetClientStatusRequest(api_version=self.api_version)
         )
         response = GetClientStatusResponse.decode(bytes_data)
         return response.data
@@ -84,7 +90,7 @@ class MqttClientHandler(ApiHandler[Any]):
     async def get_event_publication_config(self) -> EventPublicationConfig:
         """Get MQTT Client event publication config."""
         bytes_data = await self.vapix.api_request(
-            GetEventPublicationConfigRequest(api_version=self.default_api_version)
+            GetEventPublicationConfigRequest(api_version=self.api_version)
         )
         response = GetEventPublicationConfigResponse.decode(bytes_data)
         return response.data
@@ -99,6 +105,6 @@ class MqttClientHandler(ApiHandler[Any]):
         config = EventPublicationConfig(event_filter_list=event_filters)
         await self.vapix.api_request(
             ConfigureEventPublicationRequest(
-                api_version=self.default_api_version, config=config
+                api_version=self.api_version, config=config
             )
         )