dtSpark 1.1.0a2__py3-none-any.whl → 1.1.0a6__py3-none-any.whl

dtSpark/daemon/action_monitor.py

@@ -156,26 +156,55 @@ class ActionChangeMonitor:
             current_ids.add(action_id)
 
             if action_id not in self._known_actions:
-                # New action detected
-                logger.info(f"New action detected: {action['name']} (ID: {action_id})")
-                self._known_actions[action_id] = version
-                if self.on_action_added:
-                    try:
-                        self.on_action_added(action)
-                    except Exception as e:
-                        logger.error(f"Error in on_action_added callback: {e}")
-
+                self._handle_new_action(action, version)
             elif self._known_actions[action_id] != version:
-                # Modified action detected
-                logger.info(f"Action modified: {action['name']} (ID: {action_id}, v{self._known_actions[action_id]} -> v{version})")
-                self._known_actions[action_id] = version
-                if self.on_action_modified:
-                    try:
-                        self.on_action_modified(action)
-                    except Exception as e:
-                        logger.error(f"Error in on_action_modified callback: {e}")
+                self._handle_modified_action(action, version)
 
         # Check for deleted actions
+        self._handle_deleted_actions(current_ids)
+
+    def _handle_new_action(self, action: Dict, version: int) -> None:
+        """
+        Process a newly detected action.
+
+        Args:
+            action: The action dictionary from the database
+            version: The action's version number
+        """
+        action_id = action['id']
+        logger.info(f"New action detected: {action['name']} (ID: {action_id})")
+        self._known_actions[action_id] = version
+        if self.on_action_added:
+            try:
+                self.on_action_added(action)
+            except Exception as e:
+                logger.error(f"Error in on_action_added callback: {e}")
+
+    def _handle_modified_action(self, action: Dict, version: int) -> None:
+        """
+        Process a modified action.
+
+        Args:
+            action: The action dictionary from the database
+            version: The action's new version number
+        """
+        action_id = action['id']
+        old_version = self._known_actions[action_id]
+        logger.info(f"Action modified: {action['name']} (ID: {action_id}, v{old_version} -> v{version})")
+        self._known_actions[action_id] = version
+        if self.on_action_modified:
+            try:
+                self.on_action_modified(action)
+            except Exception as e:
+                logger.error(f"Error in on_action_modified callback: {e}")
+
+    def _handle_deleted_actions(self, current_ids: set) -> None:
+        """
+        Process actions that have been deleted from the database.
+
+        Args:
+            current_ids: Set of action IDs currently present in the database
+        """
         deleted_ids = set(self._known_actions.keys()) - current_ids
         for action_id in deleted_ids:
             logger.info(f"Action deleted: ID {action_id}")

dtSpark/daemon/daemon_app.py

@@ -190,44 +190,9 @@ class DaemonApplication(AbstractApp):
             logger.info("Waiting for shutdown signal (SIGTERM/SIGINT)...")
             logger.info("=" * 60)
 
-            # Set up signal handlers for graceful shutdown
-            import signal
-
-            def signal_handler(signum, frame):
-                print(f"\nReceived signal {signum}, initiating shutdown...")
-                logger.info(f"Received signal {signum}, initiating shutdown...")
-                self._shutdown_event.set()
-
-            signal.signal(signal.SIGINT, signal_handler)
-            signal.signal(signal.SIGTERM, signal_handler)
-            if sys.platform == 'win32':
-                signal.signal(signal.SIGBREAK, signal_handler)
-
-            # Block until shutdown signal
-            # Use polling with timeout to allow signal processing on Windows
-            # Also check for stop signal file (Windows cross-console shutdown)
-            stop_signal_file = pid_file_path + '.stop'
-
-            while not self._shutdown_event.is_set():
-                try:
-                    # Check for stop signal file (used by 'daemon stop' on Windows)
-                    if os.path.exists(stop_signal_file):
-                        print("\nStop signal file detected, initiating shutdown...")
-                        logger.info("Stop signal file detected, initiating shutdown...")
-                        # Remove the signal file
-                        try:
-                            os.remove(stop_signal_file)
-                        except Exception:
-                            pass
-                        self._shutdown_event.set()
-                        break
-
-                    self._shutdown_event.wait(timeout=1.0)
-                except KeyboardInterrupt:
-                    print("\nKeyboard interrupt received, initiating shutdown...")
-                    logger.info("Keyboard interrupt received, initiating shutdown...")
-                    self._shutdown_event.set()
-                    break
+            # Set up signal handlers and wait for shutdown
+            self._setup_signal_handlers()
+            self._wait_for_shutdown(pid_file_path)
 
             print("Shutdown signal received")
             logger.info("Shutdown signal received")
@@ -245,6 +210,51 @@ class DaemonApplication(AbstractApp):
 
         return 0
 
+    def _setup_signal_handlers(self):
+        """Register OS signal handlers for graceful shutdown."""
+        import signal
+
+        def signal_handler(signum, frame):
+            print(f"\nReceived signal {signum}, initiating shutdown...")
+            logger.info(f"Received signal {signum}, initiating shutdown...")
+            self._shutdown_event.set()
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+        if sys.platform == 'win32':
+            signal.signal(signal.SIGBREAK, signal_handler)
+
+    def _wait_for_shutdown(self, pid_file_path: str):
+        """
+        Block until a shutdown signal is received.
+
+        Polls for stop signal file (Windows cross-console shutdown) and
+        handles keyboard interrupts.
+
+        Args:
+            pid_file_path: Path to the PID file (used to derive stop signal file path)
+        """
+        stop_signal_file = pid_file_path + '.stop'
+
+        while not self._shutdown_event.is_set():
+            try:
+                if os.path.exists(stop_signal_file):
+                    print("\nStop signal file detected, initiating shutdown...")
+                    logger.info("Stop signal file detected, initiating shutdown...")
+                    try:
+                        os.remove(stop_signal_file)
+                    except Exception:
+                        pass
+                    self._shutdown_event.set()
+                    break
+
+                self._shutdown_event.wait(timeout=1.0)
+            except KeyboardInterrupt:
+                print("\nKeyboard interrupt received, initiating shutdown...")
+                logger.info("Keyboard interrupt received, initiating shutdown...")
+                self._shutdown_event.set()
+                break
+
     def _initialise_components(self):
         """Initialise database, LLM manager, and scheduler components."""
         print("  - Initialising daemon components...")
@@ -288,92 +298,104 @@ class DaemonApplication(AbstractApp):
 
     def _configure_llm_providers(self):
         """Configure LLM providers based on settings."""
-        # AWS Bedrock
+        self._configure_aws_bedrock()
+        self._configure_anthropic_direct()
+        self._configure_ollama()
+
+        # Log summary of configured providers
+        providers = list(self.llm_manager.providers.keys())
+        if providers:
+            print(f"  - LLM providers configured: {', '.join(providers)}")
+            logger.info(f"LLM providers configured: {providers}")
+        else:
+            print("  - Warning: No LLM providers configured!")
+            logger.warning("No LLM providers configured - actions will fail to execute")
+
+    def _configure_aws_bedrock(self):
+        """Configure AWS Bedrock LLM provider if enabled."""
         aws_enabled = self._get_nested_setting('llm_providers.aws_bedrock.enabled', True)
-        if aws_enabled:
-            try:
-                from dtSpark.llm import BedrockService
-                from dtSpark.aws.authenticator import AWSAuthenticator
+        if not aws_enabled:
+            return
+
+        try:
+            from dtSpark.llm import BedrockService
+            from dtSpark.aws.authenticator import AWSAuthenticator
 
-                aws_region = self._get_nested_setting('llm_providers.aws_bedrock.region', 'us-east-1')
-                aws_profile = self._get_nested_setting('llm_providers.aws_bedrock.sso_profile', 'default')
-                request_timeout = self.settings.get('bedrock.request_timeout', 300)
+            aws_region = self._get_nested_setting('llm_providers.aws_bedrock.region', 'us-east-1')
+            aws_profile = self._get_nested_setting('llm_providers.aws_bedrock.sso_profile', 'default')
+            request_timeout = self.settings.get('bedrock.request_timeout', 300)
 
-                # Check for API key authentication
-                aws_access_key_id = self._get_nested_setting('llm_providers.aws_bedrock.access_key_id', None)
-                aws_secret_access_key = self._get_nested_setting('llm_providers.aws_bedrock.secret_access_key', None)
+            aws_access_key_id = self._get_nested_setting('llm_providers.aws_bedrock.access_key_id', None)
+            aws_secret_access_key = self._get_nested_setting('llm_providers.aws_bedrock.secret_access_key', None)
 
-                authenticator = AWSAuthenticator(
+            authenticator = AWSAuthenticator(
+                region=aws_region,
+                sso_profile=aws_profile,
+                access_key_id=aws_access_key_id,
+                secret_access_key=aws_secret_access_key
+            )
+
+            if authenticator.authenticate():
+                bedrock_service = BedrockService(
+                    session=authenticator.session,
                     region=aws_region,
-                    sso_profile=aws_profile,
-                    access_key_id=aws_access_key_id,
-                    secret_access_key=aws_secret_access_key
+                    request_timeout=request_timeout
                 )
+                self.llm_manager.register_provider(bedrock_service)
+                logger.info("AWS Bedrock provider configured")
 
-                if authenticator.authenticate():
-                    bedrock_service = BedrockService(
-                        session=authenticator.session,
-                        region=aws_region,
-                        request_timeout=request_timeout
-                    )
-                    self.llm_manager.register_provider(bedrock_service)
-                    logger.info("AWS Bedrock provider configured")
-
-            except Exception as e:
-                logger.warning(f"Failed to configure AWS Bedrock: {e}")
+        except Exception as e:
+            logger.warning(f"Failed to configure AWS Bedrock: {e}")
 
-        # Anthropic Direct
+    def _configure_anthropic_direct(self):
+        """Configure Anthropic Direct LLM provider if enabled."""
         anthropic_enabled = self._get_nested_setting('llm_providers.anthropic.enabled', False)
         logger.debug(f"Anthropic Direct enabled: {anthropic_enabled}")
-        if anthropic_enabled:
-            try:
-                from dtSpark.llm import AnthropicService
+        if not anthropic_enabled:
+            return
 
-                api_key = self._get_nested_setting('llm_providers.anthropic.api_key', None)
-                max_tokens = self.settings.get('bedrock.max_tokens', 8192)
+        try:
+            from dtSpark.llm import AnthropicService
 
-                # Log whether API key was found (don't log the actual key)
-                if api_key:
-                    logger.info(f"Anthropic API key found (starts with: {api_key[:10] if len(api_key) > 10 else 'SHORT'}...)")
-                else:
-                    logger.warning("Anthropic API key not found in settings")
+            api_key = self._get_nested_setting('llm_providers.anthropic.api_key', None)
+            max_tokens = self.settings.get('bedrock.max_tokens', 8192)
 
-                anthropic_service = AnthropicService(
-                    api_key=api_key,
-                    default_max_tokens=max_tokens
-                )
-                self.llm_manager.register_provider(anthropic_service)
-                print(f"  - Anthropic Direct provider configured")
-                logger.info("Anthropic Direct provider configured")
+            if api_key:
+                key_prefix = api_key[:10] if len(api_key) > 10 else 'SHORT'
+                logger.info("Anthropic API key found (starts with: %s...)", key_prefix)
+            else:
+                logger.warning("Anthropic API key not found in settings")
 
-            except Exception as e:
-                print(f"  - Warning: Failed to configure Anthropic Direct: {e}")
-                logger.warning(f"Failed to configure Anthropic Direct: {e}")
+            anthropic_service = AnthropicService(
+                api_key=api_key,
+                default_max_tokens=max_tokens
+            )
+            self.llm_manager.register_provider(anthropic_service)
+            print("  - Anthropic Direct provider configured")
+            logger.info("Anthropic Direct provider configured")
+
+        except Exception as e:
+            print(f"  - Warning: Failed to configure Anthropic Direct: {e}")
+            logger.warning(f"Failed to configure Anthropic Direct: {e}")
 
-        # Ollama
+    def _configure_ollama(self):
+        """Configure Ollama LLM provider if enabled."""
         ollama_enabled = self._get_nested_setting('llm_providers.ollama.enabled', False)
-        if ollama_enabled:
-            try:
-                from dtSpark.llm import OllamaService
+        if not ollama_enabled:
+            return
 
-                base_url = self._get_nested_setting('llm_providers.ollama.base_url', 'http://localhost:11434')
-                verify_ssl = self._get_nested_setting('llm_providers.ollama.verify_ssl', True)
+        try:
+            from dtSpark.llm import OllamaService
 
-                ollama_service = OllamaService(base_url=base_url, verify_ssl=verify_ssl)
-                self.llm_manager.register_provider(ollama_service)
-                logger.info("Ollama provider configured")
+            base_url = self._get_nested_setting('llm_providers.ollama.base_url', 'http://localhost:11434')
+            verify_ssl = self._get_nested_setting('llm_providers.ollama.verify_ssl', True)
 
-            except Exception as e:
-                logger.warning(f"Failed to configure Ollama: {e}")
+            ollama_service = OllamaService(base_url=base_url, verify_ssl=verify_ssl)
+            self.llm_manager.register_provider(ollama_service)
+            logger.info("Ollama provider configured")
 
-        # Log summary of configured providers
-        providers = list(self.llm_manager.providers.keys())
-        if providers:
-            print(f"  - LLM providers configured: {', '.join(providers)}")
-            logger.info(f"LLM providers configured: {providers}")
-        else:
-            print("  - Warning: No LLM providers configured!")
-            logger.warning("No LLM providers configured - actions will fail to execute")
+        except Exception as e:
+            logger.warning(f"Failed to configure Ollama: {e}")
 
     def _initialise_mcp(self):
         """Initialise MCP manager if enabled."""

dtSpark/daemon/daemon_manager.py

@@ -190,21 +190,39 @@ class DaemonManager:
         print(f"Stopping daemon (PID: {pid})...")
 
         # Send termination signal
+        signal_result = self._send_stop_signal(pid)
+        if signal_result is not None:
+            return signal_result
+
+        # Wait for graceful shutdown
+        for i in range(timeout):
+            if not self.pid_file.is_running():
+                print("Daemon stopped")
+                self._cleanup_stop_file()
+                return 0
+            time.sleep(1)
+            if (i + 1) % 5 == 0:
+                print(f"Waiting for shutdown... ({i + 1}/{timeout}s)")
+
+        # Process didn't stop gracefully - clean up and report
+        self._cleanup_stop_file()
+        return self._handle_stop_timeout(pid, timeout)
+
+    def _send_stop_signal(self, pid: int) -> Optional[int]:
+        """
+        Send a termination signal to the daemon process.
+
+        Args:
+            pid: Process ID of the daemon
+
+        Returns:
+            Exit code if the stop completed immediately (success or failure),
+            or None if the caller should wait for shutdown
+        """
         try:
             if sys.platform == 'win32':
-                # Windows: Create a stop signal file that the daemon checks
-                # This is more reliable than signals across console sessions
-                stop_file = str(self.pid_file.path) + '.stop'
-                try:
-                    with open(stop_file, 'w') as f:
-                        f.write(str(pid))
-                    print("Stop signal sent")
-                except Exception as e:
-                    print(f"Failed to create stop signal: {e}")
-                    # Fall back to taskkill /F if signal file fails
-                    subprocess.run(['taskkill', '/F', '/PID', str(pid)], capture_output=True)
+                self._send_stop_signal_windows(pid)
             else:
-                # Unix: SIGTERM for graceful shutdown
                 os.kill(pid, signal.SIGTERM)
         except ProcessLookupError:
             print("Daemon process not found")
@@ -216,19 +234,37 @@ class DaemonManager:
         except Exception as e:
             print(f"Error stopping daemon: {e}")
             return 1
+        return None
 
-        # Wait for graceful shutdown
-        for i in range(timeout):
-            if not self.pid_file.is_running():
-                print("Daemon stopped")
-                self._cleanup_stop_file()
-                return 0
-            time.sleep(1)
-            if (i + 1) % 5 == 0:
-                print(f"Waiting for shutdown... ({i + 1}/{timeout}s)")
+    def _send_stop_signal_windows(self, pid: int) -> None:
+        """
+        Send a stop signal on Windows using a signal file.
 
-        # Process didn't stop gracefully - clean up and report
-        self._cleanup_stop_file()
+        Falls back to taskkill if the signal file cannot be created.
+
+        Args:
+            pid: Process ID of the daemon
+        """
+        stop_file = str(self.pid_file.path) + '.stop'
+        try:
+            with open(stop_file, 'w') as f:
+                f.write(str(pid))
+            print("Stop signal sent")
+        except Exception as e:
+            print(f"Failed to create stop signal: {e}")
+            subprocess.run(['taskkill', '/F', '/PID', str(pid)], capture_output=True)
+
+    def _handle_stop_timeout(self, pid: int, timeout: int) -> int:
+        """
+        Handle the case where the daemon did not stop within the timeout.
+
+        Args:
+            pid: Process ID of the daemon
+            timeout: The timeout that was exceeded
+
+        Returns:
+            0 if force-terminated successfully, 1 otherwise
+        """
         print(f"Daemon did not stop within {timeout} seconds")
         if sys.platform == 'win32':
             print("Forcing termination...")

dtSpark/daemon/pid_file.py

@@ -108,8 +108,9 @@ class PIDFile:
             import ctypes
             kernel32 = ctypes.windll.kernel32
 
-            # PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
-            handle = kernel32.OpenProcess(0x1000, False, pid)
+            # Windows constant: PROCESS_QUERY_LIMITED_INFORMATION
+            process_query_limited_information = 0x1000
+            handle = kernel32.OpenProcess(process_query_limited_information, False, pid)
             if handle:
                 kernel32.CloseHandle(handle)
                 return True

dtSpark/database/autonomous_actions.py

@@ -1059,6 +1059,9 @@ def register_daemon(
         conn.commit()
         logging.info(f"Daemon re-registered: {daemon_id} (PID: {pid})")
         return True
+    except sqlite3.Error as e:
+        logging.error(f"Failed to register daemon {daemon_id}: {e}")
+        return False
 
 
 def update_daemon_heartbeat(

dtSpark/database/credential_prompt.py

@@ -31,10 +31,7 @@ def prompt_for_credentials(db_type: str, existing_credentials: Optional[Database
     db_type_lower = db_type.lower()
 
     # Start with existing credentials or create new
-    if existing_credentials:
-        creds = existing_credentials
-    else:
-        creds = DatabaseCredentials()
+    creds = existing_credentials if existing_credentials else DatabaseCredentials()
 
     # SQLite only needs path
     if db_type_lower == 'sqlite':
@@ -46,6 +43,23 @@ def prompt_for_credentials(db_type: str, existing_credentials: Optional[Database
         return creds
 
     # Display information panel
+    _display_connection_panel(console, db_type)
+
+    # Prompt for remote database credentials
+    _prompt_remote_credentials(console, creds, db_type_lower)
+
+    # MSSQL-specific: driver selection
+    if db_type_lower in ('mssql', 'sqlserver', 'mssqlserver'):
+        _prompt_mssql_driver(console, creds)
+
+    console.print()
+    logging.info(f"Database credentials collected for {db_type}")
+
+    return creds
+
+
+def _display_connection_panel(console: Console, db_type: str) -> None:
+    """Display the database connection setup information panel."""
     console.print()
     console.print(Panel(
         f"[bold cyan]Database Connection Setup[/bold cyan]\n\n"
@@ -56,78 +70,62 @@ def prompt_for_credentials(db_type: str, existing_credentials: Optional[Database
     ))
     console.print()
 
-    # Prompt for remote database credentials
+
+def _prompt_remote_credentials(console: Console, creds: DatabaseCredentials, db_type_lower: str) -> None:
+    """Prompt for remote database connection credentials (host, port, database, username, password, SSL)."""
     if not creds.host:
-        creds.host = Prompt.ask(
-            "Database host",
-            default="localhost"
-        )
+        creds.host = Prompt.ask("Database host", default="localhost")
 
     if not creds.port:
         default_ports = {
-            'mysql': 3306,
-            'mariadb': 3306,
-            'postgresql': 5432,
-            'mssql': 1433,
-            'sqlserver': 1433
+            'mysql': 3306, 'mariadb': 3306,
+            'postgresql': 5432, 'mssql': 1433, 'sqlserver': 1433,
         }
         default_port = default_ports.get(db_type_lower, 3306)
-
-        port_input = Prompt.ask(
-            "Database port",
-            default=str(default_port)
-        )
+        port_input = Prompt.ask("Database port", default=str(default_port))
         creds.port = int(port_input)
 
     if not creds.database:
-        creds.database = Prompt.ask(
-            "Database name",
-            default="dtawsbedrockcli"
-        )
+        creds.database = Prompt.ask("Database name", default="dtawsbedrockcli")
 
     if not creds.username:
         creds.username = Prompt.ask("Database username")
 
     if not creds.password:
-        # Use getpass for secure password input
         console.print("[cyan]Database password:[/cyan] ", end="")
         creds.password = getpass.getpass("")
 
-    # SSL option
-    use_ssl = Confirm.ask("Use SSL/TLS connection?", default=False)
-    creds.ssl = use_ssl
+    creds.ssl = Confirm.ask("Use SSL/TLS connection?", default=False)
 
-    # MSSQL-specific: driver selection
-    if db_type_lower in ('mssql', 'sqlserver', 'mssqlserver'):
-        if not creds.driver:
-            drivers = [
-                "ODBC Driver 17 for SQL Server",
-                "ODBC Driver 18 for SQL Server",
-                "SQL Server Native Client 11.0",
-                "Custom"
-            ]
 
-            console.print()
-            console.print("[bold cyan]Select ODBC driver:[/bold cyan]")
-            for i, driver in enumerate(drivers, 1):
-                console.print(f"  [{i}] {driver}")
-
-            choice = Prompt.ask(
-                "Driver selection",
-                choices=[str(i) for i in range(1, len(drivers) + 1)],
-                default="1"
-            )
+def _prompt_mssql_driver(console: Console, creds: DatabaseCredentials) -> None:
+    """Prompt for MSSQL ODBC driver selection if not already set."""
+    if creds.driver:
+        return
 
-            choice_idx = int(choice) - 1
-            if choice_idx == len(drivers) - 1:  # Custom
-                creds.driver = Prompt.ask("Enter custom ODBC driver name")
-            else:
-                creds.driver = drivers[choice_idx]
+    drivers = [
+        "ODBC Driver 17 for SQL Server",
+        "ODBC Driver 18 for SQL Server",
+        "SQL Server Native Client 11.0",
+        "Custom",
+    ]
 
     console.print()
-    logging.info(f"Database credentials collected for {db_type}")
-
-    return creds
+    console.print("[bold cyan]Select ODBC driver:[/bold cyan]")
+    for i, driver in enumerate(drivers, 1):
+        console.print(f"  [{i}] {driver}")
+
+    choice = Prompt.ask(
+        "Driver selection",
+        choices=[str(i) for i in range(1, len(drivers) + 1)],
+        default="1",
+    )
+
+    choice_idx = int(choice) - 1
+    if choice_idx == len(drivers) - 1:  # Custom
+        creds.driver = Prompt.ask("Enter custom ODBC driver name")
+    else:
+        creds.driver = drivers[choice_idx]
 
 
 def test_credentials(db_type: str, credentials: DatabaseCredentials) -> tuple[bool, Optional[str]]:

dtSpark/files/manager.py

@@ -306,17 +306,11 @@ class FileManager:
         if not dir_path.is_dir():
             raise NotADirectoryError(f"Not a directory: {directory_path}")
 
-        supported_files = []
-
-        if recursive:
-            # Recursively find all files
-            for file_path in dir_path.rglob('*'):
-                if file_path.is_file() and cls.is_supported(str(file_path)):
-                    supported_files.append(str(file_path.absolute()))
-        else:
-            # Only scan immediate directory
-            for file_path in dir_path.iterdir():
-                if file_path.is_file() and cls.is_supported(str(file_path)):
-                    supported_files.append(str(file_path.absolute()))
+        iterator = dir_path.rglob('*') if recursive else dir_path.iterdir()
+        supported_files = [
+            str(file_path.absolute())
+            for file_path in iterator
+            if file_path.is_file() and cls.is_supported(str(file_path))
+        ]
 
         return sorted(supported_files)

dtSpark/limits/__init__.py

@@ -2,7 +2,7 @@
 from .tokens import TokenManager, LimitStatus
 try:
     from .costs import CostManager
-except:
+except ImportError:
     CostManager = None
 
 __all__ = ['TokenManager', 'LimitStatus']