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

onvif/cli/interactive.py

@@ -3,6 +3,8 @@
 import cmd
 import sys
 import socket
+import ssl
+import os
 import threading
 import textwrap
 from datetime import datetime
@@ -21,6 +23,7 @@ from .utils import (
     format_capabilities_as_services,
     format_services_list,
     get_method_documentation,
+    get_operation_type_info,
 )
 
 
@@ -61,6 +64,7 @@ class InteractiveShell(cmd.Cmd):
             "pwd",
             "shortcuts",
             "desc",
+            "type",
         ]
 
         # For background health check
@@ -179,7 +183,7 @@ class InteractiveShell(cmd.Cmd):
             "  / __ \\/ | / / |  / /  _/ ____/",
             " / / / /  |/ /| | / // // /_    ",
             "/ /_/ / /|  / | |/ // // __/    ",
-            "\\____/_/ |_/  |___/___/_/  v0.1.2",
+            "\\____/_/ |_/  |___/___/_/  v0.1.4",
             "                                ",
         ]
 
@@ -218,22 +222,39 @@ class InteractiveShell(cmd.Cmd):
         self._health_check_thread.start()
 
     def _periodic_health_check(self):
-        """Periodically checks device connection using a TCP socket ping."""
-        # Wait a moment before the first check to allow the shell to display the intro
+        """Periodically checks device connection using TCP or TLS depending on mode."""
+        # Wait before first check to allow intro to finish
         self._stop_health_check.wait(10.0)
+
         while not self._stop_health_check.is_set():
             sock = None
             try:
-                # Create a socket and set a short timeout
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.settimeout(3)  # 3-second timeout for the connection attempt
+                sock = socket.create_connection(
+                    (self.args.host, self.args.port), timeout=5.0
+                )
+
+                # If HTTPS, perform a short TLS handshake check
+                if getattr(self.args, "https", False):
+                    context = ssl.create_default_context()
+                    context.check_hostname = False
+                    context.verify_mode = ssl.CERT_NONE
+
+                    with context.wrap_socket(
+                        sock, server_hostname=self.args.host
+                    ) as ssock:
+                        ssock.settimeout(5)
+                        # Try a minimal handshake
+                        ssock.do_handshake()
+
+                # If we reach here, the connection (and TLS if applicable) succeeded
+                pass
 
-                # Try to connect to the host and port
-                sock.connect((self.args.host, self.args.port))
             except (
                 socket.timeout,
                 ConnectionRefusedError,
                 socket.gaierror,
+                ssl.SSLError,
+                ssl.SSLEOFError,
                 OSError,
             ) as e:
                 # Connection failed, trigger exit
@@ -242,7 +263,7 @@ class InteractiveShell(cmd.Cmd):
                     file=sys.stderr,
                 )
                 print(
-                    f"{colorize('Error:', 'red')} TCP check failed - {e}",
+                    f"{colorize('Error:', 'red')} Health check failed: {e}",
                     file=sys.stderr,
                 )
                 print(
@@ -251,15 +272,13 @@ class InteractiveShell(cmd.Cmd):
                 )
                 # Forcibly exit the entire process. This is necessary to interrupt
                 # the blocking input() call in the main thread.
-                import os
-
                 os._exit(1)
             finally:
                 # Ensure the socket is always closed
                 if sock:
                     sock.close()
 
-            # Wait for the next interval or until stopped
+            # Wait before next check or stop signal
             self._stop_health_check.wait(5.0)  # Check every 5 seconds
 
     def _handle_connection_error(self, e):
@@ -766,8 +785,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 +828,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 +1008,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 +1036,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 +1121,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,10 +1147,17 @@ 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
-
         # Clear screen for both Windows and Unix-like systems
         os.system("cls" if os.name == "nt" else "clear")
 
@@ -1093,7 +1300,7 @@ class InteractiveShell(cmd.Cmd):
             super().do_help(line)
         else:
             help_text = f"""
-{colorize('ONVIF Interactive Shell Commands -', 'cyan')}\n{colorize('https://github.com/nirsimetri/onvif-python', 'white')}
+{colorize('ONVIF Interactive Shell Commands - v0.1.4', 'cyan')}\n{colorize('https://github.com/nirsimetri/onvif-python', 'white')}
 
 {colorize('Basic Commands:', 'yellow')}
   capabilities, caps       - Show device capabilities
@@ -1109,7 +1316,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
 
@@ -15,7 +16,7 @@ def create_parser():
     """Create argument parser for ONVIF CLI"""
     parser = argparse.ArgumentParser(
         prog="onvif",
-        description=f"{colorize('ONVIF Terminal Client', 'yellow')} —\nhttps://github.com/nirsimetri/onvif-python",
+        description=f"{colorize('ONVIF Terminal Client', 'yellow')} — v0.1.4\nhttps://github.com/nirsimetri/onvif-python",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=f"""
 Examples:
@@ -106,11 +107,19 @@ Examples:
         "params", nargs="*", help="Method parameters as Simple Parameter or JSON string"
     )
 
+    # ONVI CLI
+    parser.add_argument(
+        "--version", "-v", action="store_true", help="Show ONVIF CLI version and exit"
+    )
+
     return parser
 
 
 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
@@ -120,6 +129,17 @@ def main():
 
     args = parser.parse_intermixed_args()
 
+    # Show ONVIF CLI version
+    if args.version:
+        print(colorize("0.1.4", "yellow"))
+        sys.exit(0)
+
+    # Validate arguments early (before discovery)
+    if not args.interactive and (not args.service or not args.method):
+        parser.error(
+            f"Either {colorize('--interactive', 'white')}/{colorize('-i', 'white')} mode or {colorize('service/method', 'white')} must be specified"
+        )
+
     # Handle discovery mode
     if args.discover:
         if args.host:
@@ -127,8 +147,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 +161,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:
@@ -168,12 +191,6 @@ def main():
             print("\nPassword entry cancelled.")
             sys.exit(1)
 
-    # Validate arguments
-    if not args.interactive and (not args.service or not args.method):
-        parser.error(
-            f"Either {colorize('--interactive', 'white')}/{colorize('-i', 'white')} mode or {colorize('service/method', 'white')} must be specified"
-        )
-
     try:
         # Create ONVIF client
         client = ONVIFClient(
@@ -253,8 +270,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 +385,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 +410,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 +453,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 +467,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 +512,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 +531,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()