comfygit-core 0.2.0__py3-none-any.whl

comfygit_core/infrastructure/sqlite_manager.py

@@ -0,0 +1,156 @@
+"""Generic SQLite database operations utility."""
+
+import sqlite3
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from ..logging.logging_config import get_logger
+from ..models.exceptions import ComfyDockError
+
+logger = get_logger(__name__)
+
+
+class SQLiteManager:
+    """Generic SQLite database manager with connection management."""
+
+    def __init__(self, db_path: Path):
+        """Initialize SQLite manager.
+        
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = db_path
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    @contextmanager
+    def get_connection(self) -> Generator[sqlite3.Connection, None, None]:
+        """Get database connection with context management.
+        
+        Yields:
+            SQLite connection with row factory enabled
+            
+        Raises:
+            ComfyDockError: If database connection fails
+        """
+        conn = None
+        try:
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row
+            yield conn
+        except sqlite3.Error as e:
+            logger.error(f"Database error: {e}")
+            raise ComfyDockError(f"Database operation failed: {e}")
+        finally:
+            if conn:
+                conn.close()
+
+    def execute_query(self, query: str, params: tuple = ()) -> list[dict[str, Any]]:
+        """Execute SELECT query and return results.
+        
+        Args:
+            query: SQL SELECT query
+            params: Query parameters
+            
+        Returns:
+            List of dictionaries representing rows
+            
+        Raises:
+            ComfyDockError: If query execution fails
+        """
+        with self.get_connection() as conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute(query, params)
+                rows = cursor.fetchall()
+                return [dict(row) for row in rows]
+            except sqlite3.Error as e:
+                logger.error(f"Query execution failed: {query} with params {params}: {e}")
+                raise ComfyDockError(f"Query execution failed: {e}")
+
+    def execute_write(self, query: str, params: tuple = ()) -> int:
+        """Execute INSERT/UPDATE/DELETE query.
+        
+        Args:
+            query: SQL write query
+            params: Query parameters
+            
+        Returns:
+            Number of affected rows
+            
+        Raises:
+            ComfyDockError: If write operation fails
+        """
+        with self.get_connection() as conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute(query, params)
+                conn.commit()
+                return cursor.rowcount
+            except sqlite3.Error as e:
+                logger.error(f"Write operation failed: {query} with params {params}: {e}")
+                conn.rollback()
+                raise ComfyDockError(f"Write operation failed: {e}")
+
+    def create_table(self, schema: str) -> None:
+        """Create table using schema SQL.
+        
+        Args:
+            schema: CREATE TABLE SQL statement
+            
+        Raises:
+            ComfyDockError: If table creation fails
+        """
+        with self.get_connection() as conn:
+            try:
+                cursor = conn.cursor()
+                cursor.execute(schema)
+                conn.commit()
+                logger.debug("Table schema ensured")
+            except sqlite3.Error as e:
+                logger.error(f"Table creation failed: {schema}: {e}")
+                raise ComfyDockError(f"Table creation failed: {e}")
+
+    def begin_transaction(self) -> sqlite3.Connection:
+        """Begin a transaction and return connection for manual management.
+        
+        Returns:
+            SQLite connection with transaction started
+            
+        Note:
+            Caller is responsible for commit/rollback and closing connection
+        """
+        try:
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row
+            conn.execute("BEGIN")
+            return conn
+        except sqlite3.Error as e:
+            logger.error(f"Transaction start failed: {e}")
+            raise ComfyDockError(f"Transaction start failed: {e}")
+
+    def table_exists(self, table_name: str) -> bool:
+        """Check if table exists in database.
+        
+        Args:
+            table_name: Name of table to check
+            
+        Returns:
+            True if table exists, False otherwise
+        """
+        query = "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+        results = self.execute_query(query, (table_name,))
+        return len(results) > 0
+
+    def get_table_info(self, table_name: str) -> list[dict[str, Any]]:
+        """Get table schema information.
+        
+        Args:
+            table_name: Name of table
+            
+        Returns:
+            List of column information dictionaries
+        """
+        query = f"PRAGMA table_info({table_name})"
+        return self.execute_query(query)

comfygit_core/integrations/__init__.py

@@ -0,0 +1,7 @@
+"""Integration modules for external tools and services."""
+
+from .uv_command import UVCommand
+
+__all__ = [
+    'UVCommand',
+]

comfygit_core/integrations/uv_command.py

@@ -0,0 +1,318 @@
+"""Pure UV command wrapper with no business logic."""
+
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..logging.logging_config import get_logger
+from ..models.exceptions import UVCommandError, UVNotInstalledError
+from ..utils.common import run_command
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CommandResult:
+    """Result of a UV command execution."""
+    stdout: str
+    stderr: str
+    returncode: int
+    success: bool
+
+    @classmethod
+    def from_completed_process(cls, result) -> "CommandResult":
+        return cls(
+            stdout=result.stdout,
+            stderr=result.stderr,
+            returncode=result.returncode,
+            success=result.returncode == 0
+        )
+
+
+class UVCommand:
+    """Pure wrapper around UV CLI commands. No business logic or pyproject.toml manipulation."""
+
+    DEFAULT_TIMEOUT = None  # no timeout
+
+    def __init__(
+        self,
+        binary_path: Path | None = None,
+        project_env: Path | None = None,
+        cache_dir: Path | None = None,
+        python_install_dir: Path | None = None,
+        link_mode: str | None = "hardlink",
+        cwd: Path | None = None,
+        torch_backend: str | None = None,
+    ):
+        self._binary = self._check_uv_installed(binary_path)
+        self.timeout = self.DEFAULT_TIMEOUT
+        self._project_env = project_env
+        self._cache_dir = cache_dir
+        self._python_install_dir = python_install_dir
+        self._link_mode = link_mode
+        self._cwd = cwd
+        self._torch_backend = torch_backend
+        self._base_env = self._setup_base_environment()
+
+    def _check_uv_installed(self, binary_path: Path | None) -> str:
+        # Explicit path takes priority
+        if binary_path and binary_path.is_file():
+            return str(binary_path)
+
+        # Try UV from Python package (installed with comfydock)
+        try:
+            from uv import find_uv_bin
+            binary = find_uv_bin()
+            logger.debug(f"Using UV from package: {binary}")
+            return binary
+        except ImportError:
+            logger.debug("UV package not found in current environment")
+        except FileNotFoundError as e:
+            logger.warning(f"UV package found but binary missing: {e}")
+
+        # Fallback to system UV
+        binary = shutil.which("uv")
+        if binary is None:
+            raise UVNotInstalledError(
+                "uv is not installed. Install comfydock with: pip install comfygit"
+            )
+
+        logger.warning(
+            f"Using system UV from PATH: {binary}. "
+            f"This may cause version compatibility issues. "
+            f"Recommended: pip install --force-reinstall comfydock-cli"
+        )
+        return binary
+
+    def _setup_base_environment(self) -> dict[str, str]:
+        env = os.environ.copy()
+        env.update({
+            "UV_NO_PROGRESS": "1",
+            "NO_COLOR": "1",
+            "VIRTUAL_ENV": "",
+        })
+
+        if self._project_env:
+            env["UV_PROJECT_ENVIRONMENT"] = str(self._project_env)
+        if self._cache_dir:
+            env["UV_CACHE_DIR"] = str(self._cache_dir)
+        if self._python_install_dir:
+            env["UV_PYTHON_INSTALL_DIR"] = str(self._python_install_dir)
+        if self._link_mode:
+            env["UV_LINK_MODE"] = self._link_mode
+        if self._torch_backend:
+            env["UV_TORCH_BACKEND"] = self._torch_backend
+
+        return env
+
+    def _build_command(self, base: list[str], **options) -> list[str]:
+        cmd = [self._binary] + base
+
+        flag_map = {
+            'python': '--python',
+            'index_url': '--index-url',
+            'frozen': '--frozen',
+            'dry_run': '--dry-run',
+            'no_sync': '--no-sync',
+            'name': '--name',
+            'no_workspace': '--no-workspace',
+            'bare': '--bare',
+            'raw': '--raw',
+            'dev': '--dev',
+            'group': '--group',
+            'editable': '--editable',
+            'bounds': '--bounds',
+            'prerelease': '--prerelease',
+            'all_groups': '--all-groups',
+            'no_default_groups': '--no-default-groups',
+            'seed': '--seed',
+            'upgrade': '--upgrade',
+            'no_install_project': '--no-install-project',
+            'no_deps': '--no-deps',
+            'compile_bytecode': '--compile-bytecode',
+            'quiet': '--quiet',
+        }
+
+        for key, value in options.items():
+            if value is None or value is False:
+                continue
+
+            flag = flag_map.get(key)
+            if flag:
+                if isinstance(value, bool):
+                    cmd.append(flag)
+                elif isinstance(value, list):
+                    # Handle list values that need multiple flags (e.g., --group x --group y)
+                    for item in value:
+                        cmd.extend([flag, str(item)])
+                else:
+                    cmd.extend([flag, str(value)])
+
+        return cmd
+
+    def _execute(self, cmd: list[str], expect_failure: bool = False, verbose: bool = False) -> CommandResult:
+        try:
+            env = self._base_env.copy()
+            if verbose:
+                # Show full output with progress and summary
+                env.pop("UV_NO_PROGRESS", None)
+                env.pop("NO_COLOR", None)
+                result = run_command(cmd, cwd=self._cwd, timeout=self.timeout, env=env, capture_output=False)
+            else:
+                # Default: quiet mode (capture output, only show on error)
+                result = run_command(cmd, cwd=self._cwd, timeout=self.timeout, env=self._base_env, capture_output=True)
+
+            if result.returncode == 0 or expect_failure:
+                return CommandResult.from_completed_process(result)
+            else:
+                raise UVCommandError(
+                    f"UV command failed with code {result.returncode}",
+                    command=cmd,
+                    stderr=result.stderr,
+                    stdout=result.stdout,
+                    returncode=result.returncode
+                )
+        except subprocess.TimeoutExpired:
+            raise TimeoutError(f"UV command timed out after {self.timeout}s: {' '.join(cmd)}")
+        except UVCommandError:
+            raise
+        except Exception as e:
+            raise UVCommandError(f"Failed to execute UV command: {e}", command=cmd) from e
+
+    # ===== Project Management Commands =====
+
+    def init(self, name: str | None = None, python: str | None = None, **flags) -> CommandResult:
+        cmd = self._build_command(["init"], name=name, python=python, **flags)
+        return self._execute(cmd)
+
+    def add(self, packages: list[str] | None = None, requirements_file: Path | None = None, **flags) -> CommandResult:
+        if requirements_file:
+            cmd = self._build_command(["add", "-r", str(requirements_file)], **flags)
+        else:
+            cmd = self._build_command(["add"] + (packages or []), **flags)
+        return self._execute(cmd)
+
+    def remove(self, packages: list[str], **flags) -> CommandResult:
+        cmd = self._build_command(["remove"] + packages, **flags)
+        return self._execute(cmd)
+
+    def sync(self, verbose: bool = False, **flags) -> CommandResult:
+        cmd = self._build_command(["sync"], **flags)
+        return self._execute(cmd, verbose=verbose)
+
+    def lock(self, **flags) -> CommandResult:
+        cmd = self._build_command(["lock"], **flags)
+        return self._execute(cmd, expect_failure=flags.get('dry_run', False))
+
+    def run(self, command: list[str], **flags) -> CommandResult:
+        cmd = self._build_command(["run"] + command, **flags)
+        return self._execute(cmd)
+
+    # ===== Virtual Environment Management =====
+
+    def venv(self, path: Path, **flags) -> CommandResult:
+        cmd = self._build_command(["venv", str(path)], **flags)
+        return self._execute(cmd)
+
+    # ===== Pip Compatibility =====
+
+    def pip_install(self, packages: list[str] | None = None, requirements_file: Path | None = None,
+                   python: Path | None = None, torch_backend: str | None = None,
+                   verbose: bool = False, **flags) -> CommandResult:
+        cmd = [self._binary, "pip", "install"]
+
+        if python:
+            cmd.extend(["--python", str(python)])
+
+        if torch_backend:
+            cmd.extend(["--torch-backend", torch_backend])
+
+        for key, value in flags.items():
+            if value is None or value is False:
+                continue
+            flag = f"--{key.replace('_', '-')}"
+            if isinstance(value, bool):
+                cmd.append(flag)
+            else:
+                cmd.extend([flag, str(value)])
+
+        if requirements_file:
+            cmd.extend(["-r", str(requirements_file)])
+        elif packages:
+            cmd.extend(packages)
+
+        return self._execute(cmd, verbose=verbose)
+
+    def pip_show(self, package: str, python: Path, **flags) -> CommandResult:
+        cmd = [self._binary, "pip", "show", "--python", str(python), package]
+        return self._execute(cmd)
+
+    def pip_list(self, python: Path, **flags) -> CommandResult:
+        cmd = [self._binary, "pip", "list", "--python", str(python)]
+        return self._execute(cmd)
+
+    def pip_freeze(self, python: Path, **flags) -> CommandResult:
+        cmd = [self._binary, "pip", "freeze", "--python", str(python)]
+        return self._execute(cmd)
+
+    def pip_compile(self, input_file: Path | None = None, output_file: Path | None = None, **flags) -> CommandResult:
+        cmd = [self._binary, "pip", "compile"]
+
+        if input_file:
+            cmd.append(str(input_file))
+
+        if output_file:
+            cmd.extend(["-o", str(output_file)])
+
+        for key, value in flags.items():
+            if value is None or value is False:
+                continue
+            flag = f"--{key.replace('_', '-')}"
+            if isinstance(value, bool):
+                cmd.append(flag)
+            else:
+                cmd.extend([flag, str(value)])
+
+        return self._execute(cmd)
+
+    # ===== Tool Management =====
+
+    def tool_run(self, tool: str, args: list[str] | None = None, **flags) -> CommandResult:
+        cmd = self._build_command(["tool", "run", tool] + (args or []), **flags)
+        return self._execute(cmd)
+
+    def tool_install(self, tool: str, **flags) -> CommandResult:
+        cmd = self._build_command(["tool", "install", tool], **flags)
+        return self._execute(cmd)
+
+    # ===== Python Management =====
+
+    def python_install(self, version: str, **flags) -> CommandResult:
+        cmd = self._build_command(["python", "install", version], **flags)
+        return self._execute(cmd)
+
+    def python_list(self, **flags) -> CommandResult:
+        cmd = self._build_command(["python", "list"], **flags)
+        return self._execute(cmd)
+
+    # ===== Utility =====
+
+    def version(self) -> str:
+        result = self._execute([self._binary, "--version"])
+        return result.stdout.strip().split()[-1]
+
+    @property
+    def binary(self) -> str:
+        return self._binary
+
+    @property
+    def python_executable(self) -> Path:
+        if not self._project_env:
+            raise ValueError("No project environment configured")
+        # TODO: Make this more robust and cross-platform
+        if sys.platform == "win32":
+            return self._project_env / "Scripts" / "python.exe"
+        return self._project_env / "bin" / "python"

comfygit_core/logging/logging_config.py

@@ -0,0 +1,15 @@
+"""Core logging utilities for ComfyDock."""
+
+import logging
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance for the given module.
+    
+    Args:
+        name: Module name (typically __name__)
+        
+    Returns:
+        Configured logger instance
+    """
+    return logging.getLogger(name)