onvif-python 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

onvif/cli/interactive.py

@@ -21,6 +21,7 @@ from .utils import (
     format_capabilities_as_services,
     format_services_list,
     get_method_documentation,
+    get_operation_type_info,
 )
 
 
@@ -61,6 +62,7 @@ class InteractiveShell(cmd.Cmd):
             "pwd",
             "shortcuts",
             "desc",
+            "type",
         ]
 
         # For background health check
@@ -179,7 +181,7 @@ class InteractiveShell(cmd.Cmd):
             "  / __ \\/ | / / |  / /  _/ ____/",
             " / / / /  |/ /| | / // // /_    ",
             "/ /_/ / /|  / | |/ // // __/    ",
-            "\\____/_/ |_/  |___/___/_/  v0.1.2",
+            "\\____/_/ |_/  |___/___/_/  v0.1.3",
             "                                ",
         ]
 
@@ -766,8 +768,9 @@ class InteractiveShell(cmd.Cmd):
 
         if not self.current_service:
             print(
-                f"{colorize('Error:', 'red')} This command can only be used within a service context."
+                f"{colorize('Error:', 'red')} You must be in a service mode to use 'desc'."
             )
+            print(f"Enter a service first (e.g., {colorize('devicemgmt', 'yellow')})")
             return
 
         if not method_name:
@@ -808,8 +811,175 @@ class InteractiveShell(cmd.Cmd):
                 f"No documentation or parameter info found for method '{method_name}'."
             )
 
-    def help_desc(self):
-        print(self.do_desc.__doc__)
+    def complete_desc(self, text, line, begidx, endidx):
+        """Autocomplete method names for desc command"""
+        if not self.current_service:
+            return []
+        methods = get_service_methods(self.current_service)
+        return [m for m in methods if m.lower().startswith(text.lower())]
+
+    def do_type(self, line):
+        """Show input and output types for an operation. Usage: type <operation_name>"""
+        operation_name = line.strip()
+
+        if not self.current_service:
+            print(
+                f"{colorize('Error:', 'red')} You must be in a service mode to use 'type'."
+            )
+            print(f"Enter a service first (e.g., {colorize('d', 'yellow')})")
+            return
+
+        if not operation_name:
+            print(f"Usage: {colorize('type <operation_name>', 'yellow')}")
+            return
+
+        if not hasattr(self.current_service, operation_name):
+            print(
+                f"{colorize('Error:', 'red')} Operation '{operation_name}' not found in service '{self.current_service_name}'."
+            )
+            print(f"Use {colorize('ls', 'yellow')} to see available operations.")
+            return
+
+        type_info = get_operation_type_info(self.current_service, operation_name)
+
+        if type_info:
+            # Helper function to display parameters recursively with tree-style indentation
+            def display_params(params, prefix_lines=None, is_root_level=False):
+                """
+                Display parameters with tree-style formatting.
+
+                Args:
+                    params: List of parameter dictionaries
+                    prefix_lines: List of strings representing the tree prefix for each line
+                    is_root_level: If True, don't show tree characters at this level
+                """
+                if prefix_lines is None:
+                    prefix_lines = []
+
+                for idx, param in enumerate(params):
+                    is_last = idx == len(params) - 1
+
+                    # Determine tree characters (only if not root level)
+                    if is_root_level:
+                        tree_branch = ""
+                        tree_continue = ""
+                    else:
+                        if is_last:
+                            tree_branch = "└── "
+                            tree_continue = "    "
+                        else:
+                            tree_branch = "├── "
+                            tree_continue = "│   "
+
+                    # Determine prefix symbol: + for attributes, - for elements
+                    prefix_symbol = "+" if param.get("is_attribute", False) else "-"
+
+                    # Format occurrences based on type
+                    occurs = ""
+                    if param.get("is_attribute", False):
+                        # For attributes: only show "required" if use="required"
+                        # Default for attributes is optional (no label needed)
+                        if param["minOccurs"] == "1":  # This means use="required"
+                            occurs = f" - {colorize('required', 'yellow')}"
+                        # If minOccurs == "0", it's optional (default), so no label
+                    else:
+                        # For elements: show unbounded, optional, or required
+                        if param["maxOccurs"] == "unbounded":
+                            occurs = f" - {colorize('unbounded', 'magenta')}"
+                        elif param["minOccurs"] == "0":
+                            occurs = f" - {colorize('optional', 'green')}"
+                        else:
+                            occurs = f" - {colorize('required', 'yellow')}"
+
+                    # Format type
+                    type_str = f"[{param['type']}]" if param["type"] else ""
+
+                    # Build the current line prefix from all previous levels
+                    current_prefix = "".join(prefix_lines)
+
+                    # Add spacing for root level items
+                    if is_root_level:
+                        current_prefix = "  "
+
+                    # Display parameter name with tree structure, prefix, occurrence, and type
+                    # Only add semicolon separator if there's an occurrence label
+                    separator = ";" if occurs else ""
+                    param_line = f"{current_prefix}{tree_branch}{prefix_symbol}{colorize(param['name'], 'white')}{occurs}{separator} {colorize(type_str, 'cyan')}"
+                    print(param_line)
+
+                    # Display documentation if available
+                    if param.get("documentation"):
+                        doc_lines = param["documentation"].split("\n")
+                        for doc_line in doc_lines:
+                            if doc_line.strip():
+                                # Add tree continuation for documentation
+                                if is_root_level:
+                                    doc_prefix = "  "
+                                else:
+                                    doc_prefix = current_prefix + tree_continue
+                                wrapped_doc = textwrap.fill(
+                                    doc_line.strip(),
+                                    width=96,  # Slightly less to account for tree chars
+                                    initial_indent=doc_prefix + "  ",
+                                    subsequent_indent=doc_prefix + "  ",
+                                )
+                                print(colorize(wrapped_doc, "reset"))
+
+                    # Display children recursively with updated prefix
+                    if param.get("children"):
+                        if is_root_level:
+                            # Start tree structure from children
+                            new_prefix_lines = ["  "]
+                        else:
+                            new_prefix_lines = prefix_lines + [tree_continue]
+                        display_params(
+                            param["children"], new_prefix_lines, is_root_level=False
+                        )
+
+            # Display Input
+            if type_info["input"]:
+                input_msg = type_info["input"]
+                print(f"\n{colorize('Input:', 'cyan')}")
+                msg_name = f"[{input_msg['name']}]"
+                print(f"{colorize(msg_name, 'yellow')}")
+
+                if input_msg["parameters"]:
+                    display_params(input_msg["parameters"], is_root_level=True)
+                else:
+                    print(f"  {colorize('(no parameters)', 'reset')}")
+            else:
+                print(
+                    f"\n{colorize('Input:', 'cyan')} {colorize('(not defined)', 'reset')}"
+                )
+
+            # Display Output
+            if type_info["output"]:
+                output_msg = type_info["output"]
+                print(f"\n{colorize('Output:', 'cyan')}")
+                msg_name = f"[{output_msg['name']}]"
+                print(f"{colorize(msg_name, 'yellow')}")
+
+                if output_msg["parameters"]:
+                    display_params(output_msg["parameters"], is_root_level=True)
+                else:
+                    print(f"  {colorize('(no parameters)', 'reset')}")
+            else:
+                print(
+                    f"\n{colorize('Output:', 'cyan')} {colorize('(not defined)', 'reset')}"
+                )
+
+            print()  # Add newline for spacing
+        else:
+            print(
+                f"{colorize('Error:', 'red')} Could not retrieve type information for '{operation_name}'."
+            )
+
+    def complete_type(self, text, line, begidx, endidx):
+        """Autocomplete method names for type command"""
+        if not self.current_service:
+            return []
+        methods = get_service_methods(self.current_service)
+        return [m for m in methods if m.lower().startswith(text.lower())]
 
     def do_cd(self, line):
         """Change to service directory (alias for entering service)"""
@@ -821,6 +991,11 @@ class InteractiveShell(cmd.Cmd):
             return
         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.client)
+        return [s for s in services if s.lower().startswith(text.lower())]
+
     def do_pwd(self, line):
         """Show current service context"""
         if self.current_service_name:
@@ -844,7 +1019,11 @@ class InteractiveShell(cmd.Cmd):
   up                       - Go up one level
   pwd                      - Show current context
   clear                    - Clear terminal screen
-  desc <method>            - Show method documentation in service mode
+  help <command>           - Show help for a command
+
+{colorize('Service Mode Commands:', 'yellow')}
+  desc <method>            - Show method documentation
+  type <method>            - Show input/output types from WSDL
 
 {colorize('Quick Access:', 'yellow')}
   caps                     - Show capabilities (same as 'capabilities')
@@ -925,6 +1104,10 @@ class InteractiveShell(cmd.Cmd):
         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.stored_data.keys() if name.startswith(text)]
+
     def do_show(self, line):
         """Show stored data: show <name> or show <name>.<attribute> or show <name>[index]"""
         if not line:
@@ -947,6 +1130,15 @@ class InteractiveShell(cmd.Cmd):
         else:
             print(f"{colorize('Error:', 'red')} Cannot resolve '{line}'")
 
+    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.stored_data.keys() if name.startswith(text)]
+        return []
+
     def do_clear(self, line):
         """Clear terminal screen"""
         import os
@@ -1109,7 +1301,11 @@ class InteractiveShell(cmd.Cmd):
   up                       - Exit current service mode (go up one level)
   pwd                      - Show current service context
   clear                    - Clear terminal screen
-  desc <method>            - Show method documentation in service mode
+  help <command>           - Show help for a specific command
+
+{colorize('Service Mode Commands:', 'yellow')}
+  desc <method>            - Show method documentation
+  type <method>            - Show input/output types from WSDL
 
 {colorize('Method Execution:', 'yellow')}
   <method>                 - Execute method without parameters

onvif/cli/main.py

@@ -2,6 +2,7 @@
 
 import argparse
 import sys
+import warnings
 import getpass
 from typing import Any, Optional, Tuple
 
@@ -111,6 +112,9 @@ Examples:
 
 def main():
     """Main CLI entry point"""
+    # Setup custom warning format for cleaner output
+    setup_warning_format()
+
     parser = create_parser()
 
     # Check if no arguments provided at all
@@ -127,8 +131,8 @@ def main():
                 f"{colorize('--discover', 'white')} cannot be used with {colorize('--host', 'white')}"
             )
 
-        # Discover devices
-        devices = discover_devices(timeout=4)
+        # Discover devices (pass --https flag to prioritize HTTPS XAddrs)
+        devices = discover_devices(timeout=4, prefer_https=args.https)
 
         if not devices:
             print(f"\n{colorize('No ONVIF devices discovered. Exiting.', 'red')}")
@@ -141,8 +145,11 @@ def main():
             print(f"{colorize('Device selection cancelled.', 'cyan')}")
             sys.exit(0)
 
-        # Set host and port from selected device
-        args.host, args.port = selected
+        # Set host, port, and HTTPS from selected device
+        args.host, args.port, device_use_https = selected
+
+        # Use device's detected protocol (already filtered by prefer_https in discover_devices)
+        # No need to override - device info already has correct protocol based on --https flag
 
     # Validate that host is provided (either via --host or --discover)
     if not args.host:
@@ -253,8 +260,16 @@ def execute_command(
     return method(**params)
 
 
-def discover_devices(timeout: int = 4) -> list:
-    """Discover ONVIF devices on the network using WS-Discovery."""
+def discover_devices(timeout: int = 4, prefer_https: bool = False) -> list:
+    """Discover ONVIF devices on the network using WS-Discovery.
+
+    Args:
+        timeout: Discovery timeout in seconds
+        prefer_https: If True, prioritize HTTPS XAddrs when available
+
+    Returns:
+        List of discovered devices with connection info
+    """
     import socket
     import uuid
     import xml.etree.ElementTree as ET
@@ -360,6 +375,7 @@ def discover_devices(timeout: int = 4) -> list:
                 "xaddrs": [],
                 "host": None,
                 "port": 80,
+                "use_https": False,  # Auto-detect HTTPS from XAddrs
             }
 
             epr = probe_match.find(".//wsa:EndpointReference/wsa:Address", namespaces)
@@ -384,17 +400,39 @@ def discover_devices(timeout: int = 4) -> list:
             if xaddrs_elem is not None and xaddrs_elem.text:
                 device_info["xaddrs"] = xaddrs_elem.text.split()
 
-                # Extract host and port from first XAddr
+                # Extract host, port, and protocol from XAddrs
+                # Use prefer_https parameter to decide which XAddr to use
                 if device_info["xaddrs"]:
-                    xaddr = device_info["xaddrs"][0]
+                    # Select XAddr based on prefer_https flag
+                    if prefer_https:
+                        # Try to find HTTPS XAddr first if prefer_https=True
+                        https_xaddr = next(
+                            (
+                                x
+                                for x in device_info["xaddrs"]
+                                if x.startswith("https://")
+                            ),
+                            None,
+                        )
+                        xaddr = https_xaddr or device_info["xaddrs"][0]
+                    else:
+                        # Use first XAddr (usually HTTP) if prefer_https=False
+                        xaddr = device_info["xaddrs"][0]
+
                     if "://" in xaddr:
+                        # Detect protocol
+                        protocol = xaddr.split("://")[0]
+                        device_info["use_https"] = protocol == "https"
+
+                        # Extract host and port
                         parts = xaddr.split("://")[1].split("/")[0]
                         if ":" in parts:
                             device_info["host"] = parts.split(":")[0]
                             device_info["port"] = int(parts.split(":")[1])
                         else:
                             device_info["host"] = parts
-                            device_info["port"] = 80
+                            # Set default port based on protocol
+                            device_info["port"] = 443 if protocol == "https" else 80
 
             if device_info["host"]:
                 devices.append(device_info)
@@ -405,8 +443,12 @@ def discover_devices(timeout: int = 4) -> list:
     return devices
 
 
-def select_device_interactive(devices: list) -> Optional[Tuple[str, int]]:
-    """Display devices and allow user to select one interactively."""
+def select_device_interactive(devices: list) -> Optional[Tuple[str, int, bool]]:
+    """Display devices and allow user to select one interactively.
+
+    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
@@ -415,8 +457,14 @@ def select_device_interactive(devices: list) -> Optional[Tuple[str, int]]:
 
     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']}"
-        print(f"\n{idx_str} {colorize(host_port, 'yellow')}")
+        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})")
         print(f"    [id] {device['epr']}")
 
         if device["xaddrs"]:
@@ -454,11 +502,16 @@ def select_device_interactive(devices: list) -> Optional[Tuple[str, int]]:
             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(host_port, 'yellow')}"
+                    f"\n{colorize('Selected:', 'green')} {colorize(protocol, 'cyan')}://{colorize(host_port, 'yellow')}"
+                )
+                return (
+                    selected["host"],
+                    selected["port"],
+                    selected.get("use_https", False),
                 )
-                return (selected["host"], selected["port"])
             else:
                 print(f"{colorize('Invalid selection. Please try again.', 'red')}")
 
@@ -468,5 +521,15 @@ def select_device_interactive(devices: list) -> Optional[Tuple[str, int]]:
             return None
 
 
+def setup_warning_format():
+    """Setup custom warning format to show clean, concise warnings"""
+
+    def custom_warning_format(message, category, filename, lineno, line=None):
+        # Show only the warning message without file path and line number
+        return f"{category.__name__}: {message}\n"
+
+    warnings.formatwarning = custom_warning_format
+
+
 if __name__ == "__main__":
     main()