onvif-python 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

onvif/__init__.py

@@ -1,29 +1,29 @@
-"""ONVIF Python."""
-
-from onvif.cli import main as ONVIFCLI
-from onvif.client import ONVIFClient
-from onvif.operator import CacheMode
-from onvif.utils import (
-    ONVIFWSDL,
-    ONVIFDiscovery,
-    ONVIFOperationException,
-    ONVIFParser,
-    ZeepPatcher,
-    ignore_unsupported,
-    is_action_not_supported,
-    safe_call,
-)
-
-__all__ = [
-    "ONVIFClient",
-    "CacheMode",
-    "ONVIFWSDL",
-    "ONVIFOperationException",
-    "ZeepPatcher",
-    "ONVIFCLI",
-    "ONVIFDiscovery",
-    "ONVIFParser",
-    "ignore_unsupported",
-    "is_action_not_supported",
-    "safe_call",
-]
+"""ONVIF Python."""
+
+from onvif.cli import main as ONVIFCLI
+from onvif.client import ONVIFClient
+from onvif.operator import CacheMode
+from onvif.utils import (
+    ONVIFWSDL,
+    ONVIFDiscovery,
+    ONVIFOperationException,
+    ONVIFParser,
+    ZeepPatcher,
+    ignore_unsupported,
+    is_action_not_supported,
+    safe_call,
+)
+
+__all__ = [
+    "ONVIFClient",
+    "CacheMode",
+    "ONVIFWSDL",
+    "ONVIFOperationException",
+    "ZeepPatcher",
+    "ONVIFCLI",
+    "ONVIFDiscovery",
+    "ONVIFParser",
+    "ignore_unsupported",
+    "is_action_not_supported",
+    "safe_call",
+]

onvif/cli/__init__.py

@@ -1,5 +1,5 @@
-"""ONVIF CLI."""
-
-from onvif.cli.main import main
-
-__all__ = ["main"]
+"""ONVIF CLI."""
+
+from onvif.cli.main import main
+
+__all__ = ["main"]

onvif/cli/__main__.py

@@ -1,7 +1,7 @@
-#!/usr/bin/env python3
-"""ONVIF CLI entry point for python -m onvif.cli."""
-
-from onvif.cli.main import main
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""ONVIF CLI entry point for python -m onvif.cli."""
+
+from onvif.cli.main import main
+
+if __name__ == "__main__":
+    main()

onvif/cli/helpers/__init__.py

@@ -1,21 +1,21 @@
-"""ONVIF CLI helpers."""
-
-from onvif.cli.helpers.discovery import discover_devices, select_device_interactive
-from onvif.cli.helpers.execution import execute_command, setup_warning_format
-from onvif.cli.helpers.files import save_output_to_file
-from onvif.cli.helpers.products import search_products
-from onvif.cli.helpers.wsdl_parser import (
-    get_method_documentation,
-    get_operation_type_info,
-)
-
-__all__ = [
-    "search_products",
-    "save_output_to_file",
-    "discover_devices",
-    "select_device_interactive",
-    "execute_command",
-    "setup_warning_format",
-    "get_method_documentation",
-    "get_operation_type_info",
-]
+"""ONVIF CLI helpers."""
+
+from onvif.cli.helpers.discovery import discover_devices, select_device_interactive
+from onvif.cli.helpers.execution import execute_command, setup_warning_format
+from onvif.cli.helpers.files import save_output_to_file
+from onvif.cli.helpers.products import search_products
+from onvif.cli.helpers.wsdl_parser import (
+    get_method_documentation,
+    get_operation_type_info,
+)
+
+__all__ = [
+    "search_products",
+    "save_output_to_file",
+    "discover_devices",
+    "select_device_interactive",
+    "execute_command",
+    "setup_warning_format",
+    "get_method_documentation",
+    "get_operation_type_info",
+]

onvif/cli/helpers/discovery.py

@@ -1,156 +1,181 @@
-"""ONVIF discovery helpers."""
-
-from datetime import datetime
-
-from onvif.cli.utils import colorize
-from onvif.utils import ONVIFDiscovery
-
-
-def discover_devices(
-    timeout: int = 4,
-    interface: str | None = None,
-    prefer_https: bool = False,
-    filter_term: str | None = None,
-) -> list:
-    """Discover ONVIF devices on the network using WS-Discovery.
-
-    Args:
-        timeout (int): Discovery timeout in seconds
-        interface (str | None): Network interface to use for discovery
-        prefer_https (bool): If True, prioritize HTTPS XAddrs when available
-        filter_term (str | None): Optional search term to filter devices by types or scopes (case-insensitive)
-
-    Returns:
-        List of discovered devices with connection info
-    """
-    # Use ONVIFDiscovery class
-    discovery = ONVIFDiscovery(timeout=timeout, interface=interface)
-
-    print(f"\n{colorize('Discovering ONVIF devices on network...', 'yellow')}")
-    print(f"Network interface: {colorize(discovery.get_local_ip(), 'white')}")
-    print(f"Timeout: {timeout}s")
-    if filter_term:
-        print(f"Filter: {colorize(filter_term, 'yellow')}")
-    print()
-
-    devices = discovery.discover(prefer_https=prefer_https, search=filter_term)
-
-    return devices
-
-
-# pylint: disable=too-many-locals,too-many-statements,too-many-branches
-def select_device_interactive(devices: list) -> tuple[str, int, bool] | None:
-    """Display devices and allow user to select one interactively.
-
-    Args:
-        devices (list): Discovered devices
-
-    Returns:
-        Tuple of (host, port, use_https) or None if cancelled
-    """
-    if not devices:
-        print(f"\n{colorize('No ONVIF devices found.', 'red')}")
-        return None
-
-    print(f"{colorize(f'Found {len(devices)} ONVIF device(s):', 'green')}")
-
-    for idx, device in enumerate(devices, 1):
-        idx_str = colorize(f"[{idx}]", "yellow")
-        protocol = "https" if device.get("use_https", False) else "http"
-        host_port = f"{device['host']}:{device['port']}"
-        protocol_indicator = (
-            colorize("🔒 HTTPS", "green")
-            if device.get("use_https", False)
-            else colorize("HTTP", "white")
-        )
-        print(f"\n{idx_str} {colorize(host_port, 'yellow')} ({protocol_indicator})")
-
-        # Remove uuid: or urn:uuid: prefix from EPR
-        epr_display = device["epr"]
-        if epr_display.startswith("urn:uuid:"):
-            epr_display = epr_display.replace("urn:uuid:", "")
-        elif epr_display.startswith("uuid:"):
-            epr_display = epr_display.replace("uuid:", "")
-        print(f"    [uuid] {epr_display}")
-
-        if device.get("hostname"):
-            print(f"    [hostname] {device["hostname"]}")
-
-        if device.get("xaddrs"):
-            xaddrs_parts = [f"[{xaddr}]" for xaddr in device["xaddrs"]]
-            print(f"    [xaddrs] {' '.join(xaddrs_parts)}")
-
-        if device.get("date_time"):
-            utc = (
-                datetime.fromisoformat(device["date_time"].get("utc")).strftime(
-                    "%H:%M:%S %d-%m-%Y"
-                )
-                if device["date_time"].get("utc")
-                else ""
-            )
-            local = (
-                datetime.fromisoformat(device["date_time"].get("local")).strftime(
-                    "%H:%M:%S %d-%m-%Y"
-                )
-                if device["date_time"].get("local")
-                else ""
-            )
-            print(
-                f"    [date_time]"
-                f'{" [UTC: " + utc + "]" if utc else ""}'
-                f'{" [Local: " + local + "]" if local else ""}'
-            )
-
-        if device.get("types"):
-            types_parts = [f"[{t}]" for t in device["types"]]
-            print(f"    [types] {' '.join(types_parts)}")
-
-        if device.get("services"):
-            service = [colorize(f"[{t}]", "cyan") for t in device["services"]]
-            print(f"    [services] {' '.join(service)}")
-
-        if device.get("scopes"):
-            scope_parts = []
-            for scope in device["scopes"]:
-                # Remove the prefix "onvif://www.onvif.org/" if present
-                if scope.startswith("onvif://www.onvif.org/"):
-                    simplified = scope.replace("onvif://www.onvif.org/", "")
-                    scope_parts.append(f"[{simplified}]")
-                else:
-                    # Keep other scopes as-is (e.g., http:123)
-                    scope_parts.append(f"[{scope}]")
-
-            if scope_parts:
-                print(f"    [scopes] {' '.join(scope_parts)}")
-
-    # Simple selection (without arrow keys for cross-platform compatibility)
-    while True:
-        try:
-            selection = input(
-                f"\nSelect device number {colorize(f'1-{len(devices)}', 'white')} or {colorize('q', 'white')} to quit: "
-            )
-
-            if selection.lower() == "q":
-                return None
-
-            idx = int(selection)
-            if 1 <= idx <= len(devices):
-                selected = devices[idx - 1]
-                protocol = "https" if selected.get("use_https", False) else "http"
-                host_port = f"{selected['host']}:{selected['port']}"
-                print(
-                    f"\n{colorize('Selected:', 'green')} {colorize(protocol, 'cyan')}://{colorize(host_port, 'yellow')}"
-                )
-
-                return (
-                    selected["host"],
-                    selected["port"],
-                    selected.get("use_https", False),
-                )
-
-            print(colorize("Invalid selection. Please try again.", "red"))
-
-        except ValueError:
-            print(colorize("Invalid input. Please enter a number.", "red"))
-        except (EOFError, KeyboardInterrupt):
-            return None
+"""ONVIF discovery helpers."""
+
+from datetime import datetime
+
+from onvif.cli.utils import colorize
+from onvif.utils import ONVIFDiscovery
+
+
+def discover_devices(
+    timeout: int = 4,
+    interface: str | None = None,
+    prefer_https: bool = False,
+    filter_term: str | None = None,
+) -> list:
+    """Discover ONVIF devices on the network using WS-Discovery.
+
+    Args:
+        timeout (int): Discovery timeout in seconds
+        interface (str | None): Network interface to use for discovery
+        prefer_https (bool): If True, prioritize HTTPS XAddrs when available
+        filter_term (str | None): Optional search term to filter devices by
+            types or scopes (case-insensitive)
+
+    Returns:
+        List of discovered devices with connection info
+    """
+    # Use ONVIFDiscovery class
+    discovery = ONVIFDiscovery(timeout=timeout, interface=interface)
+
+    print(f"\n{colorize('Discovering ONVIF devices on network...', 'yellow')}")
+    print(f"Network interface: {colorize(discovery.get_local_ip(), 'white')}")
+    print(f"Timeout: {timeout}s")
+    if filter_term:
+        print(f"Filter: {colorize(filter_term, 'yellow')}")
+    print()
+
+    devices = discovery.discover(prefer_https=prefer_https, search=filter_term)
+
+    return devices
+
+
+def select_device_interactive(devices: list) -> tuple[str, int, bool] | None:
+    """Display devices and allow user to select one interactively.
+
+    Args:
+        devices (list): Discovered devices
+
+    Returns:
+        Tuple of (host, port, use_https) or None if cancelled
+    """
+    if not devices:
+        print(f"\n{colorize('No ONVIF devices found.', 'red')}")
+        return None
+
+    print(f"{colorize(f'Found {len(devices)} ONVIF device(s):', 'green')}")
+
+    for idx, device in enumerate(devices, 1):
+        protocol = "https" if device.get("use_https", False) else "http"
+        host_port = f"{device['host']}:{device['port']}"
+        protocol_indicator = (
+            colorize("🔒 HTTPS", "green")
+            if device.get("use_https", False)
+            else colorize("HTTP", "white")
+        )
+        print(
+            f"\n{colorize(f'[{idx}]', 'yellow')} {colorize(host_port, 'yellow')} ({protocol_indicator})"
+        )
+
+        # Remove uuid: or urn:uuid: prefix from EPR
+        epr_display = device["epr"]
+        if epr_display.startswith("urn:uuid:"):
+            epr_display = epr_display.replace("urn:uuid:", "")
+        elif epr_display.startswith("uuid:"):
+            epr_display = epr_display.replace("uuid:", "")
+        print(f"    [uuid] {epr_display}")
+
+        _print_optional_field("hostname", device.get("hostname"))
+
+        _print_optional_field(
+            "xaddrs",
+            " ".join(f"[{xaddr}]" for xaddr in device.get("xaddrs", [])),
+        )
+
+        if device.get("date_time"):
+            utc = (
+                datetime.fromisoformat(device["date_time"].get("utc")).strftime(
+                    "%H:%M:%S %d-%m-%Y"
+                )
+                if device["date_time"].get("utc")
+                else ""
+            )
+            local = (
+                datetime.fromisoformat(device["date_time"].get("local")).strftime(
+                    "%H:%M:%S %d-%m-%Y"
+                )
+                if device["date_time"].get("local")
+                else ""
+            )
+            print(
+                f"    [date_time]"
+                f'{" [UTC: " + utc + "]" if utc else ""}'
+                f'{" [Local: " + local + "]" if local else ""}'
+            )
+
+        _print_optional_field(
+            "types",
+            " ".join(f"[{device_type}]" for device_type in device.get("types", [])),
+        )
+
+        _print_optional_field(
+            "services",
+            " ".join(f"[{service}]" for service in device.get("services", [])),
+            "cyan",
+        )
+
+        if device.get("scopes"):
+            scope_parts = []
+            for scope in device["scopes"]:
+                # Remove the prefix "onvif://www.onvif.org/" if present
+                if scope.startswith("onvif://www.onvif.org/"):
+                    simplified = scope.replace("onvif://www.onvif.org/", "")
+                    scope_parts.append(f"[{simplified}]")
+                else:
+                    # Keep other scopes as-is (e.g., http:123)
+                    scope_parts.append(f"[{scope}]")
+
+            if scope_parts:
+                print(f"    [scopes] {' '.join(scope_parts)}")
+
+    return _process_device_selection(protocol, devices)
+
+
+def _print_optional_field(
+    label: str,
+    value: object,
+    color: str | None = None,
+) -> None:
+    """Print an optional device field when it has a value."""
+    if not value:
+        return
+
+    if color:
+        value = colorize(str(value), color)
+
+    print(f"    [{label}] {value}")
+
+
+def _process_device_selection(protocol, devices):
+    """Simple selection (without arrow keys for cross-platform compatibility)"""
+    while True:
+        try:
+            selection = input(
+                f"\nSelect device number {colorize(f'1-{len(devices)}', 'white')} "
+                f"or {colorize('q', 'white')} to quit: "
+            )
+
+            if selection.lower() == "q":
+                return None
+
+            idx = int(selection)
+            if 1 <= idx <= len(devices):
+                selected = devices[idx - 1]
+                protocol = "https" if selected.get("use_https", False) else "http"
+                host_port = f"{selected['host']}:{selected['port']}"
+                print(
+                    f"\n{colorize('Selected:', 'green')} {colorize(protocol, 'cyan')}:"
+                    f"//{colorize(host_port, 'yellow')}"
+                )
+
+                return (
+                    selected["host"],
+                    selected["port"],
+                    selected.get("use_https", False),
+                )
+
+            print(colorize("Invalid selection. Please try again.", "red"))
+
+        except ValueError:
+            print(colorize("Invalid input. Please enter a number.", "red"))
+        except (EOFError, KeyboardInterrupt):
+            return None

onvif/cli/helpers/execution.py

@@ -1,57 +1,57 @@
-"""ONVIF command execution helpers."""
-
-import warnings
-from typing import Any
-
-from onvif.cli.utils import colorize, parse_json_params
-from onvif.client import ONVIFClient
-
-
-def execute_command(
-    client: ONVIFClient,
-    service_name: str,
-    method_name: str,
-    params_str: str | None = None,
-) -> Any:
-    """Execute a single ONVIF command.
-
-    Args:
-        client (ONVIFClient): ONVIFClient instance
-        service_name (str): Selected service for command execution
-        method_name (str): Method to execute by service
-        params_str (str | None): Provided params for method execution
-
-    Returns:
-        The operation response printed in terminal
-    """
-    # Get service instance
-    try:
-        service = getattr(client, service_name.lower())()
-    except AttributeError as e:
-        raise ValueError(f"{colorize('Unknown service:', 'red')} {service_name}") from e
-
-    # Get method
-    try:
-        method = getattr(service, method_name)
-    except AttributeError as e:
-        raise ValueError(
-            f"{colorize('Unknown method', 'red')} '{method_name}' for service '{service_name}'"
-        ) from e
-
-    # Parse parameters
-    params = parse_json_params(params_str) if params_str else {}
-
-    # Execute method
-    return method(**params)
-
-
-def setup_warning_format() -> None:
-    """Setup custom warning format to show clean, concise warnings."""
-
-    def custom_warning_format(
-        message, category, filename, lineno, line=None
-    ):  # pylint: disable=unused-argument
-        # Show only the warning message without file path and line number
-        return f"{category.__name__}: {message}\n"
-
-    warnings.formatwarning = custom_warning_format
+"""ONVIF command execution helpers."""
+
+import warnings
+from typing import Any
+
+from onvif.cli.utils import colorize, parse_json_params
+from onvif.client import ONVIFClient
+
+
+def execute_command(
+    client: ONVIFClient,
+    service_name: str,
+    method_name: str,
+    params_str: str | None = None,
+) -> Any:
+    """Execute a single ONVIF command.
+
+    Args:
+        client (ONVIFClient): ONVIFClient instance
+        service_name (str): Selected service for command execution
+        method_name (str): Method to execute by service
+        params_str (str | None): Provided params for method execution
+
+    Returns:
+        The operation response printed in terminal
+    """
+    # Get service instance
+    try:
+        service = getattr(client, service_name.lower())()
+    except AttributeError as e:
+        raise ValueError(f"{colorize('Unknown service:', 'red')} {service_name}") from e
+
+    # Get method
+    try:
+        method = getattr(service, method_name)
+    except AttributeError as e:
+        raise ValueError(
+            f"{colorize('Unknown method', 'red')} '{method_name}' for service '{service_name}'"
+        ) from e
+
+    # Parse parameters
+    params = parse_json_params(params_str) if params_str else {}
+
+    # Execute method
+    return method(**params)
+
+
+def setup_warning_format() -> None:
+    """Setup custom warning format to show clean, concise warnings."""
+
+    def custom_warning_format(
+        message, category, filename, lineno, line=None
+    ):  # pylint: disable=unused-argument
+        # Show only the warning message without file path and line number
+        return f"{category.__name__}: {message}\n"
+
+    warnings.formatwarning = custom_warning_format