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

onvif/cli/__init__.py

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

onvif/cli/interactive/__init__.py

@@ -0,0 +1,5 @@
+"""ONVIF Interactive Shell."""
+
+from onvif.cli.interactive.shell import InteractiveShell
+
+__all__ = ["InteractiveShell"]

onvif/cli/interactive/context.py

@@ -0,0 +1,55 @@
+"""ONVIF Interactive Shell context."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from onvif.client import ONVIFClient
+
+
+@dataclass
+class ShellContext:  # pylint: disable=too-many-instance-attributes
+    """Store shared state for the interactive shell."""
+
+    UNSET = object()
+
+    client: ONVIFClient
+    args: object
+
+    current_service: object | None = None
+    current_service_name: str | None = None
+    stored_data: dict[str, Any] = field(
+        default_factory=dict
+    )  # For storing command results
+    stored_metadata: dict[str, dict[str, Any]] = field(
+        default_factory=dict
+    )  # For storing metadata about stored data (service, method
+
+    last_result: Any = field(default=UNSET, repr=False)
+    last_method: str | None = None
+    last_service_name: str | None = None
+    last_operation_timestamp: datetime | None = None
+
+    base_commands: list[str] = field(
+        default_factory=lambda: [
+            "capabilities",
+            "caps",
+            "services",
+            "help",
+            "exit",
+            "store",
+            "rm",
+            "show",
+            "cls",
+            "clear",
+            "info",
+            "debug",
+            "ls",
+            "cd",
+            "shortcuts",
+            "desc",
+            "type",
+        ]
+    )
+
+    device_info_text: str | None = None

onvif/cli/interactive/information.py

@@ -0,0 +1,175 @@
+"""Information commands implementation."""
+
+import cmd
+from typing import Callable
+
+from requests.exceptions import RequestException
+from zeep.exceptions import TransportError
+
+from onvif.cli.helpers.messages import INTERACTIVE_HELP, INTERACTIVE_SHORTCUTS
+from onvif.cli.utils import (
+    colorize,
+    format_capabilities_as_services,
+    format_services_list,
+)
+from onvif.utils.exceptions import ONVIFOperationException
+
+from .context import ShellContext
+
+
+class InformationCommands:
+    """Provide information commands."""
+
+    context: ShellContext
+    _handle_connection_error: Callable[..., None]
+
+    def do_help(self, arg):
+        """Show help information."""
+        if arg:
+            cmd.Cmd.do_help(self, arg)
+        else:
+            print(INTERACTIVE_HELP)
+
+    def do_shortcuts(self, _line):
+        """Show available shortcuts."""
+        print(INTERACTIVE_SHORTCUTS)
+
+    def do_info(self, _line):
+        """Show connection and device information."""
+        # Build connection and CLI options info
+        options_info = []
+
+        # Connection options
+        if hasattr(self.context.args, "https") and self.context.args.https:
+            options_info.append(f"  Use HTTPS     : {colorize('True', 'green')}")
+
+        if (
+            hasattr(self.context.args, "no_verify_ssl")
+            and self.context.args.no_verify_ssl
+        ):
+            options_info.append(f"  Verify SSL    : {colorize('False', 'red')}")
+
+        if (
+            hasattr(self.context.args, "timeout") and self.context.args.timeout != 10
+        ):  # 10 is default
+            options_info.append(
+                f"  Timeout       : {colorize(f'{self.context.args.timeout}s', 'yellow')}"
+            )
+
+        # CLI options
+        if hasattr(self.context.args, "debug") and self.context.args.debug:
+            options_info.append(f"  Debug Mode    : {colorize('True', 'green')}")
+
+        if hasattr(self.context.args, "no_patch") and self.context.args.no_patch:
+            options_info.append(f"  ZeepPatcher   : {colorize('Disabled', 'red')}")
+
+        if hasattr(self.context.args, "wsdl") and self.context.args.wsdl:
+            options_info.append(
+                f"  Custom WSDL   : {colorize(self.context.args.wsdl, 'yellow')}"
+            )
+
+        if (
+            hasattr(self.context.args, "health_check_interval")
+            and self.context.args.health_check_interval != 10
+        ):  # 10 is default
+            options_info.append(
+                f"  Health Check  : every {colorize(f'{self.context.args.health_check_interval}s', 'yellow')}"
+            )
+
+        # Format options info
+        options_display = ""
+        if options_info:
+            options_display = "\n" + "\n".join(options_info)
+
+        # Display connection and device information using stored data
+        print(
+            f"\n{colorize('[ONVIF Terminal Client]', 'yellow')}"
+            f"\n  Connected to  : "
+            f"{colorize(f'{self.context.args.host}:{self.context.args.port}', 'yellow')}"
+            f"\n  Auth Method   : "
+            f"{colorize('HTTP Digest' if self.context.args.digest else 'WS-UsernameToken', 'yellow')}"
+            f"{options_display}{self.context.device_info_text}"
+        )
+        print()  # Extra newline for spacing
+
+    def do_capabilities(self, _line):
+        """Show device capabilities in service format."""
+        try:
+            if (
+                hasattr(self.context.client, "capabilities")
+                and self.context.client.capabilities
+            ):
+                result = self.context.client.capabilities
+            else:
+                result = self.context.client.devicemgmt().GetCapabilities(
+                    Category="All"
+                )
+
+            self.context.stored_data["capabilities"] = result
+            self.context.stored_metadata["capabilities"] = {
+                "service": "devicemgmt",
+                "method": "GetCapabilities",
+            }
+
+            # Use special formatting for capabilities
+            output = format_capabilities_as_services(result)
+            print(output)
+        except ONVIFOperationException as e:
+            if isinstance(e.original_exception, (RequestException, TransportError)):
+                self._handle_connection_error()
+            else:
+                print(f"{colorize('Error:', 'red')} {e}")
+
+    def do_caps(self, line):
+        """Show device capabilities (alias for 'capabilities')"""
+        return self.do_capabilities(line)
+
+    def do_services(self, _line):
+        """Show available ONVIF services in service format."""
+        try:
+            if (
+                hasattr(self.context.client, "services")
+                and self.context.client.services
+            ):
+                result = self.context.client.services
+            else:
+                result = self.context.client.devicemgmt().GetServices(
+                    IncludeCapability=False
+                )
+
+            self.context.stored_data["services"] = result
+            self.context.stored_metadata["services"] = {
+                "service": "devicemgmt",
+                "method": "GetServices",
+            }
+
+            # Use special formatting for services
+            output = format_services_list(result)
+            print(output)
+        except ONVIFOperationException as e:
+            if isinstance(e.original_exception, (RequestException, TransportError)):
+                self._handle_connection_error()
+            else:
+                print(f"{colorize('Error:', 'red')} {e}")
+
+    def do_debug(self, _line):
+        """Show debug information."""
+        if self.context.client.xml_plugin:
+            if self.context.last_method and self.context.last_operation_timestamp:
+                print(f"{colorize('Last Operation:', 'cyan')}")
+                print(
+                    f"  operation: {self.context.last_service_name}.{self.context.last_method}()"
+                )
+                print(
+                    f"  timestamp: {self.context.last_operation_timestamp.strftime('%Y-%m-%d %H:%M:%S')}\n"
+                )
+
+            print(f"{colorize('Last SOAP Request:', 'cyan')}")
+            print(self.context.client.xml_plugin.last_sent_xml or "None")
+            print(f"\n{colorize('Last SOAP Response:', 'cyan')}")
+            print(self.context.client.xml_plugin.last_received_xml or "None")
+        else:
+            print(f"{colorize('Debug mode not enabled', 'yellow')}")
+            print(
+                f"Start CLI with {colorize('--debug', 'white')} flag to enable XML capture"
+            )

onvif/cli/interactive/navigation.py

@@ -0,0 +1,185 @@
+"""Navigation commands implementation."""
+
+import traceback
+from typing import Callable
+
+from onvif.cli.utils import (
+    colorize,
+    get_device_available_services,
+    get_service_methods,
+    get_service_required_args,
+    parse_json_params,
+)
+
+from .context import ShellContext
+
+
+class NavigationCommands:
+    """Provide navigation commands."""
+
+    context: ShellContext
+    _display_grid: Callable[..., None]
+    update_prompt: Callable[[], None]
+
+    def do_ls(self, _line):
+        """List available commands/services like TAB completion."""
+        if self.context.current_service:
+            # In service mode - show available methods
+            methods = get_service_methods(self.context.current_service)
+            # Add helper commands in service mode
+            methods.extend([colorize("type", "yellow"), colorize("desc", "yellow")])
+            if methods:
+                # Use the same display format as TAB completion
+                self._display_grid(methods)
+            else:
+                print("No methods available")
+        else:
+            # In root mode - show device-specific services and commands
+            services = get_device_available_services(self.context.client)
+            commands = self.context.base_commands
+            all_items = services + commands
+
+            if all_items:
+                # Use the same display format as TAB completion
+                self._display_grid(all_items)
+            else:
+                print("No commands available")
+
+    def do_cd(self, line):
+        """Change to service directory (alias for entering service)"""
+        if not line:
+            print("Usage: cd <service_name>")
+            available_services = get_device_available_services(self.context.client)
+            colored_services = [colorize(svc, "cyan") for svc in available_services]
+            print(f"Available services: {', '.join(colored_services)}")
+            return None
+        return self.do_enter_service(line)
+
+    def complete_cd(self, text, _line, _begidx, _endidx):
+        """Autocomplete service names for cd command."""
+        services = get_device_available_services(self.context.client)
+        return [s for s in services if s.lower().startswith(text.lower())]
+
+    def do_up(self, _line):
+        """Exit current service mode (go up one level)"""
+        if self.context.current_service:
+            print(
+                f"{colorize('Exited service:', 'yellow')} "
+                f"{colorize(f'{self.context.current_service_name}', 'cyan')}"
+            )
+            self.context.current_service = None
+            self.context.current_service_name = None
+            self.update_prompt()
+        else:
+            print("Not in service mode")
+
+    # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+    def do_enter_service(self, line):
+        """Enter service mode with optional arguments for services that require them."""
+        # Parse service name and arguments
+        parts = line.split(None, 1)
+        service_name = parts[0] if parts else ""
+        args_str = parts[1] if len(parts) > 1 else ""
+
+        available_services = get_device_available_services(self.context.client)
+        if service_name not in available_services:
+            print(f"{colorize('Error:', 'red')} Unknown service '{service_name}'")
+            colored_services = [colorize(svc, "cyan") for svc in available_services]
+            print(f"Available services: {', '.join(colored_services)}")
+            return
+
+        try:
+            # Check if this service requires arguments
+            required_args = get_service_required_args(service_name)
+
+            if required_args:
+                # Service requires arguments
+                if not args_str:
+                    # No arguments provided, show help
+                    print(
+                        f"{colorize('Error:', 'red')} Service '{service_name}' requires arguments"
+                    )
+                    print(
+                        f"{colorize('Usage:', 'yellow')} {service_name} "
+                        f"{' '.join([f'{arg}=<value>' for arg in required_args])}"
+                    )
+                    print(
+                        f"{colorize('Example:', 'yellow')} "
+                        f"{service_name} {required_args[0]}=$subscription"
+                    )
+                    return
+
+                # Parse arguments
+                try:
+                    parsed_args = parse_json_params(args_str)
+                except (OSError, AttributeError, ValueError, TypeError) as e:
+                    print(f"{colorize('Error parsing arguments:', 'red')} {e}")
+                    return
+
+                # Check if all required arguments are provided
+                missing_args = [arg for arg in required_args if arg not in parsed_args]
+                if missing_args:
+                    print(
+                        f"{colorize('Error:', 'red')} "
+                        f"Missing required arguments: {', '.join(missing_args)}"
+                    )
+                    print(
+                        f"{colorize('Usage:', 'yellow')} {service_name} "
+                        f"{' '.join([f'{arg}=<value>' for arg in required_args])}"
+                    )
+                    return
+
+                # Resolve stored references in arguments
+                for arg_name in required_args:
+                    arg_value = parsed_args[arg_name]
+                    if isinstance(arg_value, str) and arg_value.startswith("$"):
+                        # Resolve stored reference
+                        reference = arg_value[1:]  # Remove $ prefix
+                        resolved_value = self._resolve_stored_reference(reference)
+                        if resolved_value is None:
+                            print(
+                                f"{colorize('Error:', 'red')} "
+                                f"Could not resolve reference '{arg_value}'"
+                            )
+                            return
+                        parsed_args[arg_name] = resolved_value
+
+                # Call service method with arguments
+                service_method = getattr(self.context.client, service_name)
+                service = service_method(**parsed_args)
+            else:
+                # Service doesn't require arguments
+                service = getattr(self.context.client, service_name)()
+
+            self.context.current_service = service
+            self.context.current_service_name = service_name
+            self.update_prompt()
+
+            print(
+                f"{colorize('Entered service:', 'yellow')} {colorize(service_name, 'cyan')}"
+            )
+
+            # Show available methods
+            methods = get_service_methods(service)
+            methods_preview = ", ".join(methods[:10])
+            if len(methods) > 10:
+                print(
+                    f"{colorize('Available methods:', 'yellow')} {methods_preview} ... "
+                    f"and {colorize(f'{len(methods) - 10} more.', 'yellow')}"
+                )
+                print(
+                    f"Type {colorize('ls', 'cyan')}/press "
+                    f"<{colorize('TAB', 'yellow')}> to see all."
+                )
+            else:
+                print(f"{colorize('Available methods:', 'yellow')} {methods_preview}")
+            print(f"Type {colorize('up', 'cyan')} to exit service mode.")
+
+        except (OSError, RuntimeError, ValueError, AttributeError) as e:
+            print(f"{colorize('Error entering service:', 'red')} {e}")
+            if self.context.args.debug:
+                traceback.print_exc()
+
+    def do_exit_service(self, line):
+        """Exit current service mode (alias for 'up')"""
+        return self.do_up(line)

onvif/cli/interactive/reference.py

@@ -0,0 +1,204 @@
+"""Reference commands implementation."""
+
+import json
+import re
+
+from onvif.cli.utils import colorize
+
+from .context import ShellContext
+
+
+class ReferenceCommands:
+    """Provide stored-reference commands."""
+
+    context: ShellContext
+
+    def do_store(self, line):
+        """Store last result with a name: store <name>."""
+        if not line:
+            print("Usage: store <name>")
+            return
+
+        if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", line):
+            print(
+                f"{colorize('Error:', 'red')} Invalid name '{line}'. "
+                "Only letters, numbers, and underscores allowed, "
+                "and must not start with a number."
+            )
+            return
+
+        if line in self.context.stored_data:
+            print(
+                f"{colorize('Error:', 'red')} Name '{line}' already exists. "
+                "Use a different name or remove it first."
+            )
+            return
+
+        UNSET = object()  # pylint: disable=invalid-name
+
+        if self.context.last_result is UNSET:
+            print(f"{colorize('Error:', 'red')} No result to store")
+            return
+
+        self.context.stored_data[line] = self.context.last_result
+
+        metadata = {}
+
+        if self.context.last_service_name:
+            metadata["service"] = self.context.last_service_name
+
+        if self.context.last_method:
+            metadata["method"] = self.context.last_method
+
+        self.context.stored_metadata[line] = metadata
+
+        service = metadata.get("service", "unknown")
+        method = metadata.get("method", "unknown")
+
+        print(
+            f"{colorize('Stored result as:', 'green')} "
+            f"{colorize('$' + line, 'yellow')} - "
+            f"{colorize(service, 'cyan')}.{colorize(method, 'white')}()"
+        )
+
+    def do_show(self, line):
+        """Show stored data: show <name> or show <name>.<attribute> or show
+        <name>[index]"""
+        if not line:
+            print(colorize("Stored data:", "green"))
+            for name in self.context.stored_data:
+                # Get metadata if available
+                metadata = self.context.stored_metadata.get(name, {})
+                service = metadata.get("service", "unknown")
+                method = metadata.get("method", "unknown")
+
+                # Format: name - service.method()
+                info = (
+                    f"{colorize('$'+name, 'yellow')} - "
+                    f"{colorize(service, 'cyan')}.{colorize(method, 'white')}()"
+                )
+                print(f"  {info}")
+            return
+
+        # Parse accessor expression (e.g., profiles[0].token or profiles.Token)
+        result = self._resolve_stored_reference(line)
+        if result is not None:
+            print(str(result))
+        else:
+            print(f"{colorize('Error:', 'red')} Cannot resolve '{line}'")
+
+    def _substitute_stored_references(self, params_str: str) -> str:
+        """Substitute $variable references in parameter string with stored data.
+
+        Args:
+            params_str: Parameter string that may contain $variable references
+
+        Returns:
+            Parameter string with substituted values
+        """
+        # Find all $variable references (e.g., $profiles[0].token)
+        pattern = (
+            r"\$([a-zA-Z_][a-zA-Z0-9_]*(?:\[[0-9]+\])?(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)"
+        )
+
+        def replace_reference(match):
+            reference = match.group(1)
+            value = self._resolve_stored_reference(reference)
+
+            if value is None:
+                print(f"{colorize('Warning:', 'yellow')} Cannot resolve ${reference}")
+                return match.group(0)  # Keep original if not found
+
+            # Convert value to string representation suitable for JSON
+            # Use json.dumps to serialize values correctly for JSON parsing.
+            # This preserves numbers, booleans, nulls, arrays and objects.
+            try:
+                return json.dumps(value)
+            except (TypeError, KeyError, ValueError, RuntimeError):
+                # Fall back to string-quoting for anything not serializable
+                return json.dumps(str(value))
+
+        return re.sub(pattern, replace_reference, params_str)
+
+    def _resolve_stored_reference(self, reference: str):
+        """Resolve stored data reference like 'profiles[0].token' or 'profiles.Token'.
+
+        Args:
+            reference: String reference like 'profiles[0]' or 'profiles.Token'
+
+        Returns:
+            Resolved value or None if not found
+        """
+        # Parse the reference - e.g., "profiles[0].token" or "services.Namespace"
+        # Split by dots and brackets
+        parts = re.split(r"\.|\[|\]", reference)
+        parts = [p for p in parts if p]  # Remove empty strings
+
+        if not parts:
+            return None
+
+        # Start with the stored variable name
+        var_name = parts[0]
+        if var_name not in self.context.stored_data:
+            return None
+
+        current = self.context.stored_data[var_name]
+
+        # Navigate through the rest of the path
+        for part in parts[1:]:
+            try:
+                # Check if it's an integer index
+                if part.isdigit():
+                    index = int(part)
+                    if isinstance(current, (list, tuple)):
+                        current = current[index]
+                    else:
+                        # Try to convert to list if it's iterable
+                        try:
+                            current = list(current)[index]
+                        except (TypeError, IndexError):
+                            return None
+                else:
+                    # It's an attribute name
+                    if hasattr(current, part):
+                        current = getattr(current, part)
+                    elif isinstance(current, dict) and part in current:
+                        current = current[part]
+                    else:
+                        return None
+            except (IndexError, AttributeError, KeyError, TypeError):
+                return None
+
+        return current
+
+    def complete_show(self, text, line, _begidx, _endidx):
+        """Autocomplete stored variable names for show command."""
+        # Get the part being completed
+        parts = line.split()
+        if len(parts) <= 1 or (len(parts) == 2 and not line.endswith(" ")):
+            # Completing the variable name
+            return [name for name in self.context.stored_data if name.startswith(text)]
+        return []
+
+    def do_rm(self, line):
+        """Remove stored data: rm <name>"""
+        if not line:
+            print("Usage: rm <name>")
+            return
+        if line in self.context.stored_data:
+            del self.context.stored_data[line]
+            if line in self.context.stored_metadata:
+                del self.context.stored_metadata[line]
+            print(f"{colorize('Removed:', 'yellow')} {colorize('$'+line, 'cyan')}")
+        else:
+            print(f"{colorize('Error:', 'red')} No stored data named '{line}'")
+
+    def complete_rm(self, text, _line, _begidx, _endidx):
+        """Autocomplete stored variable names for rm command."""
+        return [name for name in self.context.stored_data if name.startswith(text)]
+
+    def do_cls(self, _line):
+        """Clear stored data."""
+        self.context.stored_data.clear()
+        self.context.stored_metadata.clear()
+        print(f"{colorize('Cleared all stored data', 'yellow')}")