onvif-python 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

onvif/cli/interactive.py

@@ -173,6 +173,9 @@ class InteractiveShell(cmd.Cmd):
         if hasattr(args, "no_patch") and args.no_patch:
             options_info.append(f"  ZeepPatcher   : {colorize('Disabled', 'red')}")
 
+        if hasattr(args, "wsdl") and args.wsdl:
+            options_info.append(f"  Custom WSDL   : {colorize(args.wsdl, 'yellow')}")
+
         if (
             hasattr(args, "health_check_interval") and args.health_check_interval != 10
         ):  # 10 is default
@@ -191,7 +194,7 @@ class InteractiveShell(cmd.Cmd):
             "  / __ \\/ | / / |  / /  _/ ____/",
             " / / / /  |/ /| | / // // /_    ",
             "/ /_/ / /|  / | |/ // // __/    ",
-            "\\____/_/ |_/  |___/___/_/  v0.1.8",
+            "\\____/_/ |_/  |___/___/_/  v0.2.0",
             "                                ",
         ]
 
@@ -602,6 +605,8 @@ class InteractiveShell(cmd.Cmd):
         if self.current_service:
             # In service mode - suggest methods
             methods = get_service_methods(self.current_service)
+            # Add helper commands in service mode
+            methods.extend([colorize("type", "yellow"), colorize("desc", "yellow")])
             for method in methods:
                 if method.lower().startswith(partial_cmd.lower()):
                     suggestions.append(method)
@@ -627,6 +632,8 @@ class InteractiveShell(cmd.Cmd):
         if self.current_service:
             # Complete method names in service mode
             methods = get_service_methods(self.current_service)
+            # Add helper commands in service mode
+            methods.extend([colorize("type", "yellow"), colorize("desc", "yellow")])
             completions = [
                 method for method in methods if method.lower().startswith(text.lower())
             ]
@@ -839,6 +846,8 @@ class InteractiveShell(cmd.Cmd):
         if self.current_service:
             # In service mode - show available methods
             methods = get_service_methods(self.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)
@@ -875,6 +884,7 @@ class InteractiveShell(cmd.Cmd):
             print(
                 f"{colorize('Error:', 'red')} Method '{method_name}' not found in service '{self.current_service_name}'."
             )
+            print(f"Use {colorize('ls', 'yellow')} to see available methods.")
             return
 
         doc_info = get_method_documentation(self.current_service, method_name)
@@ -913,8 +923,8 @@ class InteractiveShell(cmd.Cmd):
         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()
+        """Show input and output types for a method. Usage: type <method_name>"""
+        method_name = line.strip()
 
         if not self.current_service:
             print(
@@ -923,18 +933,18 @@ class InteractiveShell(cmd.Cmd):
             print(f"Enter a service first (e.g., {colorize('devicemgmt', 'yellow')})")
             return
 
-        if not operation_name:
-            print("Usage: type <operation_name>")
+        if not method_name:
+            print("Usage: type <method_name>")
             return
 
-        if not hasattr(self.current_service, operation_name):
+        if not hasattr(self.current_service, method_name):
             print(
-                f"{colorize('Error:', 'red')} Operation '{operation_name}' not found in service '{self.current_service_name}'."
+                f"{colorize('Error:', 'red')} Method '{method_name}' not found in service '{self.current_service_name}'."
             )
-            print(f"Use {colorize('ls', 'yellow')} to see available operations.")
+            print(f"Use {colorize('ls', 'yellow')} to see available methods.")
             return
 
-        type_info = get_operation_type_info(self.current_service, operation_name)
+        type_info = get_operation_type_info(self.current_service, method_name)
 
         if type_info:
             # Helper function to display parameters recursively with tree-style indentation
@@ -1065,7 +1075,7 @@ class InteractiveShell(cmd.Cmd):
             print()  # Add newline for spacing
         else:
             print(
-                f"{colorize('Error:', 'red')} Could not retrieve type information for '{operation_name}'."
+                f"{colorize('Error:', 'red')} Could not retrieve type information for '{method_name}'."
             )
 
     def complete_type(self, text, line, begidx, endidx):
@@ -1268,6 +1278,11 @@ class InteractiveShell(cmd.Cmd):
         if hasattr(self.args, "no_patch") and self.args.no_patch:
             options_info.append(f"  ZeepPatcher   : {colorize('Disabled', 'red')}")
 
+        if hasattr(self.args, "wsdl") and self.args.wsdl:
+            options_info.append(
+                f"  Custom WSDL   : {colorize(self.args.wsdl, 'yellow')}"
+            )
+
         if (
             hasattr(self.args, "health_check_interval")
             and self.args.health_check_interval != 10
@@ -1385,7 +1400,7 @@ class InteractiveShell(cmd.Cmd):
             super().do_help(line)
         else:
             help_text = f"""
-{colorize('ONVIF Interactive Shell — v0.1.8', 'cyan')}\n{colorize('https://github.com/nirsimetri/onvif-python', 'white')}
+{colorize('ONVIF Interactive Shell — v0.2.0', 'cyan')}\n{colorize('https://github.com/nirsimetri/onvif-python', 'white')}
 
 {colorize('Basic Commands:', 'yellow')}
   capabilities, caps       - Show device capabilities

onvif/cli/main.py

@@ -4,6 +4,10 @@ import argparse
 import sys
 import warnings
 import getpass
+import sqlite3
+import os
+import shutil
+from datetime import datetime
 from typing import Any, Optional, Tuple
 
 from ..client import ONVIFClient
@@ -17,19 +21,24 @@ def create_parser():
     """Create argument parser for ONVIF CLI"""
     parser = argparse.ArgumentParser(
         prog="onvif",
-        description=f"{colorize('ONVIF Terminal Client', 'yellow')} — v0.1.8\nhttps://github.com/nirsimetri/onvif-python",
+        description=f"{colorize('ONVIF Terminal Client', 'yellow')} — v0.2.0\nhttps://github.com/nirsimetri/onvif-python",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=f"""
 Examples:
+  # Product search
+  {colorize('onvif', 'yellow')} --search c210
+  {colorize('onvif', 'yellow')} -s "axis camera"
+  {colorize('onvif', 'yellow')} --search hikvision --page 2 --per-page 5
+
   # Discover ONVIF devices on network
   {colorize('onvif', 'yellow')} --discover --username admin --password admin123 --interactive
   {colorize('onvif', 'yellow')} media GetProfiles --discover --username admin
   {colorize('onvif', 'yellow')} -d -i
 
   # Discover with filtering
-  {colorize('onvif', 'yellow')} --discover --search ptz --interactive
-  {colorize('onvif', 'yellow')} -d -s "C210" -i
-  {colorize('onvif', 'yellow')} -d -s "audio_encoder" -u admin -p admin123 -i
+  {colorize('onvif', 'yellow')} --discover --filter ptz --interactive
+  {colorize('onvif', 'yellow')} -d -f "C210" -i
+  {colorize('onvif', 'yellow')} -d -f "audio_encoder" -u admin -p admin123 -i
 
   # Direct command execution
   {colorize('onvif', 'yellow')} devicemgmt GetCapabilities Category=All --host 192.168.1.17 --port 8000 --username admin --password admin123
@@ -66,10 +75,29 @@ Examples:
         action="store_true",
         help="Discover ONVIF devices on the network using WS-Discovery",
     )
+    parser.add_argument(
+        "--filter",
+        "-f",
+        help="Filter discovered devices by types or scopes (case-insensitive substring match)",
+    )
+
+    # Product search
     parser.add_argument(
         "--search",
         "-s",
-        help="Filter discovered devices by types or scopes (case-insensitive substring match)",
+        help="Search ONVIF products database by model or company (e.g., 'c210', 'hikvision')",
+    )
+    parser.add_argument(
+        "--page",
+        type=int,
+        default=1,
+        help="Page number for search results (default: 1)",
+    )
+    parser.add_argument(
+        "--per-page",
+        type=int,
+        default=20,
+        help="Number of results per page (default: 20)",
     )
 
     # Connection options
@@ -133,6 +161,277 @@ Examples:
     return parser
 
 
+def search_products(search_term: str, page: int = 1, per_page: int = 20) -> None:
+    """Search ONVIF products database and display results in table format with pagination.
+
+    Args:
+        search_term: Search term to match against model, post_title, and company_name fields
+        page: Page number (1-based)
+        per_page: Number of results per page
+    """
+    # Get the database path relative to the script location
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    db_path = os.path.join(current_dir, "..", "db", "products.db")
+    db_path = os.path.normpath(db_path)
+
+    if not os.path.exists(db_path):
+        print(f"{colorize('Error:', 'red')} Products database not found at {db_path}")
+        sys.exit(1)
+
+    # Validate pagination parameters
+    if page < 1:
+        print(f"{colorize('Error:', 'red')} Page number must be 1 or greater")
+        sys.exit(1)
+
+    if per_page < 1 or per_page > 100:
+        print(f"{colorize('Error:', 'red')} Per-page must be between 1 and 100")
+        sys.exit(1)
+
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+
+        # First, get total count for pagination info
+        count_query = """
+        SELECT COUNT(*)
+        FROM onvif_products
+        WHERE LOWER(model) LIKE LOWER(?)
+           OR LOWER(post_title) LIKE LOWER(?)
+           OR LOWER(company_name) LIKE LOWER(?)
+        """
+
+        search_pattern = f"%{search_term}%"
+        cursor.execute(count_query, (search_pattern, search_pattern, search_pattern))
+        total_count = cursor.fetchone()[0]
+
+        if total_count == 0:
+            print(
+                f"{colorize('No products found matching:', 'yellow')} {colorize(search_term, 'white')}"
+            )
+            return
+
+        # Calculate pagination
+        total_pages = (total_count + per_page - 1) // per_page  # Ceiling division
+        if page > total_pages:
+            print(
+                f"{colorize('Error:', 'red')} Page {page} does not exist. Total pages: {total_pages}"
+            )
+            return
+
+        offset = (page - 1) * per_page
+
+        # Search query with pagination
+        query = """
+        SELECT ID, test_date, post_title, product_firmware_version,
+               product_profiles, product_category, type,
+               company_name
+        FROM onvif_products
+        WHERE LOWER(model) LIKE LOWER(?)
+           OR LOWER(post_title) LIKE LOWER(?)
+           OR LOWER(company_name) LIKE LOWER(?)
+        ORDER BY test_date DESC
+        LIMIT ? OFFSET ?
+        """
+
+        cursor.execute(
+            query, (search_pattern, search_pattern, search_pattern, per_page, offset)
+        )
+        results = cursor.fetchall()
+
+        # Display results in table format
+        start_result = offset + 1
+        end_result = min(offset + per_page, total_count)
+        print(
+            f"\n{colorize(f'Found {total_count} product(s) matching:', 'green')} {colorize(search_term, 'white')}"
+        )
+        print(
+            f"{colorize(f'Showing {start_result}-{end_result} of {total_count} results', 'cyan')}"
+        )
+        print()
+
+        # Table headers
+        headers = [
+            "ID",
+            "Test Date",
+            "Model",
+            "Firmware",
+            "Profiles",
+            "Category",
+            "Type",
+            "Company",
+        ]
+
+        # Get terminal width for adaptive formatting
+        try:
+            terminal_width = shutil.get_terminal_size().columns
+        except Exception:
+            terminal_width = 120  # fallback width
+
+        # Calculate minimum column widths
+        min_col_widths = [max(len(str(header)), 8) for header in headers]
+
+        # Calculate actual content widths (without truncation first)
+        actual_widths = [0] * len(headers)
+        for row in results:
+            for i, value in enumerate(row):
+                if value:
+                    if i == 1:  # Date column - calculate formatted date width
+                        str_value = str(value)
+                        if "T" in str_value:
+                            date_part = str_value.split("T")[0]
+                            time_part = str_value.split("T")[1].split(".")[0]
+                            if "+" in time_part:
+                                time_part = time_part.split("+")[0]
+                            elif "Z" in time_part:
+                                time_part = time_part.replace("Z", "")
+                            formatted_date = f"{date_part} {time_part}"
+                            actual_widths[i] = max(
+                                actual_widths[i], len(formatted_date)
+                            )
+                        else:
+                            actual_widths[i] = max(actual_widths[i], len(str_value))
+                    else:
+                        actual_widths[i] = max(actual_widths[i], len(str(value)))
+
+        # Combine minimum widths with actual content widths
+        col_widths = [
+            max(min_col_widths[i], actual_widths[i]) for i in range(len(headers))
+        ]
+
+        # Calculate space needed for separators (3 chars per separator: " | ")
+        separator_space = (len(headers) - 1) * 3
+        total_content_width = sum(col_widths)
+        total_needed_width = total_content_width + separator_space
+
+        # If table is too wide for terminal, apply smart truncation
+        if total_needed_width > terminal_width:
+            available_width = terminal_width - separator_space
+
+            # Priority columns that should not be truncated (ID, Date)
+            protected_cols = {0, 1}  # ID and Date columns
+            protected_width = sum(col_widths[i] for i in protected_cols)
+
+            # Width available for other columns
+            remaining_width = available_width - protected_width
+
+            # Columns that can be truncated
+            truncatable_cols = [
+                i for i in range(len(headers)) if i not in protected_cols
+            ]
+
+            if remaining_width > 0 and truncatable_cols:
+                # Calculate proportional allocation for truncatable columns
+                current_truncatable_width = sum(col_widths[i] for i in truncatable_cols)
+
+                for i in truncatable_cols:
+                    if current_truncatable_width > 0:
+                        # Proportional allocation
+                        proportion = col_widths[i] / current_truncatable_width
+                        new_width = int(remaining_width * proportion)
+
+                        # Ensure minimum width
+                        col_widths[i] = max(new_width, min_col_widths[i])
+                    else:
+                        col_widths[i] = min_col_widths[i]
+
+        # Print header
+        header_line = " | ".join(
+            header.ljust(col_widths[i]) for i, header in enumerate(headers)
+        )
+        print(colorize(header_line, "yellow"))
+        print(colorize("-" * len(header_line), "white"))
+
+        # Print data rows
+        for row in results:
+            formatted_row = []
+            for i, value in enumerate(row):
+                if value is None:
+                    formatted_value = ""
+                else:
+                    str_value = str(value)
+
+                    # Special formatting for date column (index 1)
+                    if i == 1 and value:  # Date column
+                        try:
+                            # Handle ISO format with timezone
+                            if "T" in str_value:
+                                # Parse ISO format: 2024-08-15T17:53:12.9154121+08:00
+                                # Extract just the date and time part before timezone
+                                date_part = str_value.split("T")[0]
+                                time_part = str_value.split("T")[1].split(".")[
+                                    0
+                                ]  # Remove microseconds
+                                if "+" in time_part:
+                                    time_part = time_part.split("+")[0]
+                                elif "Z" in time_part:
+                                    time_part = time_part.replace("Z", "")
+                                formatted_value = f"{date_part} {time_part}"
+                            elif (
+                                len(str_value) == 19 and " " in str_value
+                            ):  # Already in correct format
+                                formatted_value = str_value
+                            elif len(str_value) == 10:  # Just date, add time
+                                formatted_value = f"{str_value} 00:00:00"
+                            else:
+                                # Try to parse common formats
+                                try:
+                                    parsed_date = datetime.strptime(
+                                        str_value, "%Y-%m-%d %H:%M:%S"
+                                    )
+                                    formatted_value = parsed_date.strftime(
+                                        "%Y-%m-%d %H:%M:%S"
+                                    )
+                                except ValueError:
+                                    try:
+                                        parsed_date = datetime.strptime(
+                                            str_value, "%Y-%m-%d"
+                                        )
+                                        formatted_value = parsed_date.strftime(
+                                            "%Y-%m-%d 00:00:00"
+                                        )
+                                    except ValueError:
+                                        formatted_value = (
+                                            str_value  # Keep original if parsing fails
+                                        )
+                        except Exception:
+                            formatted_value = str_value  # Keep original if any error
+                    else:
+                        # Apply truncation based on calculated column width
+                        max_width = col_widths[i]
+                        if len(str_value) > max_width:
+                            formatted_value = str_value[: max_width - 3] + "..."
+                        else:
+                            formatted_value = str_value
+
+                formatted_row.append(formatted_value.ljust(col_widths[i]))
+
+            print(" | ".join(formatted_row))
+
+        # Display pagination information
+        print()
+        newline = "\n" if total_pages == 1 else ""
+        print(f"{colorize(f'Page {page} of {total_pages}', 'cyan')} {newline}")
+
+        # Show navigation hints
+        nav_hints = []
+        if page > 1:
+            nav_hints.append(f"Previous: --page {page - 1}")
+        if page < total_pages:
+            nav_hints.append(f"Next: --page {page + 1}")
+
+        if nav_hints:
+            print(f"{colorize('Navigation:', 'white')} {' | '.join(nav_hints)}\n")
+
+        conn.close()
+
+    except sqlite3.Error as e:
+        print(f"{colorize('Database error:', 'red')} {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"{colorize('Error:', 'red')} {e}")
+        sys.exit(1)
+
+
 def main():
     """Main CLI entry point"""
     # Setup custom warning format for cleaner output
@@ -149,11 +448,21 @@ def main():
 
     # Show ONVIF CLI version
     if args.version:
-        print(colorize("0.1.8", "yellow"))
+        print(colorize("0.2.0", "yellow"))
+        sys.exit(0)
+
+    # Handle product search
+    if args.search:
+        search_products(args.search, args.page, args.per_page)
         sys.exit(0)
 
     # Validate arguments early (before discovery)
-    if not args.interactive and (not args.service or not args.method):
+    # Skip validation if search mode is active
+    if (
+        not args.search
+        and 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"
         )
@@ -165,15 +474,15 @@ def main():
                 f"{colorize('--discover', 'white')} cannot be used with {colorize('--host', 'white')}"
             )
 
-        # Discover devices (pass --https flag to prioritize HTTPS XAddrs and search term)
+        # Discover devices (pass --https flag to prioritize HTTPS XAddrs and filter term)
         devices = discover_devices(
-            timeout=4, prefer_https=args.https, search=args.search
+            timeout=4, prefer_https=args.https, filter_term=args.filter
         )
 
         if not devices:
-            if args.search:
+            if args.filter:
                 print(
-                    f"{colorize('No devices found matching search:', 'red')} {colorize(args.search, 'white')}"
+                    f"{colorize('No devices found matching filter:', 'red')} {colorize(args.filter, 'white')}"
                 )
             else:
                 print(colorize("No ONVIF devices discovered. Exiting.", "red"))
@@ -192,22 +501,22 @@ def main():
         # 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:
+    # Validate that host is provided (either via --host or --discover) unless using --search
+    if not args.search and not args.host:
         parser.error(
             f"Either {colorize('--host', 'white')} or {colorize('--discover', 'white')} must be specified"
         )
 
-    # Handle username prompt
-    if not args.username:
+    # Handle username prompt (skip for search mode)
+    if not args.search and not args.username:
         try:
             args.username = input("Enter username: ")
         except (EOFError, KeyboardInterrupt):
             print("\nUsername entry cancelled.")
             sys.exit(1)
 
-    # Handle password securely if not provided
-    if not args.password:
+    # Handle password securely if not provided (skip for search mode)
+    if not args.search and not args.password:
         try:
             args.password = getpass.getpass(
                 f"Enter password for {colorize(f'{args.username}@{args.host}', 'yellow')}: "
@@ -216,6 +525,10 @@ def main():
             print("\nPassword entry cancelled.")
             sys.exit(1)
 
+    # Skip ONVIF client creation for search mode
+    if args.search:
+        return
+
     try:
         # Create ONVIF client
         client = ONVIFClient(
@@ -296,14 +609,14 @@ def execute_command(
 
 
 def discover_devices(
-    timeout: int = 4, prefer_https: bool = False, search: Optional[str] = None
+    timeout: int = 4, prefer_https: bool = False, filter_term: Optional[str] = None
 ) -> 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
-        search: Optional search term to filter devices by types or scopes
+        filter_term: Optional search term to filter devices by types or scopes
 
     Returns:
         List of discovered devices with connection info
@@ -315,11 +628,11 @@ def discover_devices(
     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 search:
-        print(f"Filter: {colorize(search, 'yellow')}")
+    if filter_term:
+        print(f"Filter: {colorize(filter_term, 'yellow')}")
     print()
 
-    devices = discovery.discover(prefer_https=prefer_https, search=search)
+    devices = discovery.discover(prefer_https=prefer_https, search=filter_term)
 
     return devices
 
@@ -346,15 +659,22 @@ def select_device_interactive(devices: list) -> Optional[Tuple[str, int, bool]]:
             else colorize("HTTP", "white")
         )
         print(f"\n{idx_str} {colorize(host_port, 'yellow')} ({protocol_indicator})")
-        print(f"    [id] {device['epr']}")
+
+        # 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"    [id] {epr_display}")
 
         if device["xaddrs"]:
-            xaddrs_str = " ".join(device["xaddrs"])
-            print(f"    [xaddrs] {xaddrs_str}")
+            xaddrs_parts = [f"[{xaddr}]" for xaddr in device["xaddrs"]]
+            print(f"    [xaddrs] {' '.join(xaddrs_parts)}")
 
         if device["types"]:
-            types_str = " ".join(device["types"])
-            print(f"    [types] {types_str}")
+            types_parts = [f"[{t}]" for t in device["types"]]
+            print(f"    [types] {' '.join(types_parts)}")
 
         if device["scopes"]:
             scope_parts = []

onvif/cli/utils.py

@@ -213,8 +213,8 @@ def get_service_methods(service_obj) -> list:
     methods = []
     for attr_name in dir(service_obj):
         if not attr_name.startswith("_") and callable(getattr(service_obj, attr_name)):
-            # Skip operator attribute
-            if attr_name != "operator":
+            # Skip helper methods
+            if attr_name not in ["type", "desc", "operations"]:
                 methods.append(attr_name)
     return sorted(methods)
 
@@ -354,13 +354,6 @@ def get_method_documentation(service_obj, method_name: str) -> Optional[Dict[str
     return None
 
 
-def truncate_output(text: str, max_length: int = 1000) -> str:
-    """Truncate output if too long"""
-    if len(text) <= max_length:
-        return text
-    return text[:max_length] + f"\n... (truncated, {len(text)} total chars)"
-
-
 def colorize(text: str, color: str) -> str:
     """Add color to text for terminal output"""
     # Enable ANSI colors on Windows