coding-client 1.21.2__py3-none-any.whl

coding_client/interfaces/cache_interface.py

@@ -0,0 +1,179 @@
+"""
+Cache interface for breaking circular dependencies.
+
+This module provides abstract interfaces for cache operations to prevent
+circular dependencies between analysis_cache and language processing modules.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    # TODO: service-specific import removed
+    # from ..processing.languages.base import ParseResult
+    pass
+
+
+class IAnalysisCache(ABC):
+    """Abstract interface for analysis cache operations."""
+
+    @abstractmethod
+    async def get_cached_result(self, file_path: Path, content: str) -> Any | None:
+        """Get cached analysis result if available and valid.
+
+        Args:
+            file_path: Path to the source file
+            content: Current file content
+
+        Returns:
+            Cached ParseResult if available, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    async def cache_result(self, file_path: Path, content: str, parse_result: Any) -> None:
+        """Cache an analysis result.
+
+        Args:
+            file_path: Path to the source file
+            content: File content that was analyzed
+            parse_result: Analysis result to cache
+        """
+        pass
+
+
+class ICacheManager(ABC):
+    """Abstract interface for Redis-based cache manager operations."""
+
+    @abstractmethod
+    async def get(self, key: str) -> Any | None:
+        """Get a value from cache.
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Cached value or None if not found
+        """
+        ...
+
+    @abstractmethod
+    async def set(self, key: str, value: Any, ttl: int | None = None) -> bool:
+        """Set a value in cache.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+            ttl: Time-to-live in seconds
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def delete(
+        self, key: str, record_eviction: bool = True, eviction_reason: str = "manual"
+    ) -> bool:
+        """Delete a value from cache.
+
+        Args:
+            key: Cache key
+            record_eviction: Whether to record this deletion as an eviction
+            eviction_reason: Reason for eviction
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def delete_pattern(self, pattern: str) -> int:
+        """Delete keys matching a pattern.
+
+        Args:
+            pattern: Key pattern (e.g., "container:*")
+
+        Returns:
+            Number of keys deleted
+        """
+        ...
+
+    @abstractmethod
+    async def get_or_compute(
+        self, key: str, compute_func: Callable[[], Any], ttl: int | None = None
+    ) -> Any:
+        """Get from cache or compute and cache.
+
+        Args:
+            key: Cache key
+            compute_func: Function to compute value if not cached
+            ttl: Time-to-live in seconds
+
+        Returns:
+            Cached or computed value
+        """
+        ...
+
+    @abstractmethod
+    def get_stats(self) -> dict[str, int]:
+        """Get cache statistics.
+
+        Returns:
+            Dictionary with hits, misses, errors counts
+        """
+        ...
+
+    @abstractmethod
+    async def clear_stats(self) -> None:
+        """Reset cache statistics."""
+        ...
+
+    @abstractmethod
+    async def get_container_stats(self, container_name: str) -> dict[str, Any]:
+        """Get cache statistics for a specific container.
+
+        Args:
+            container_name: Name of the container to get stats for
+
+        Returns:
+            Dictionary with hit_count, miss_count, size, entry_count
+        """
+        ...
+
+    @abstractmethod
+    async def clear_container_cache(self, container_name: str) -> int:
+        """Clear all cache entries for a specific container.
+
+        Args:
+            container_name: Name of the container whose cache should be cleared
+
+        Returns:
+            Number of cache entries deleted
+        """
+        ...
+
+    @abstractmethod
+    async def get_container_keys(
+        self, container_name: str, limit: int = 100, offset: int = 0
+    ) -> list[str]:
+        """Get paginated list of cache keys for a specific container.
+
+        Args:
+            container_name: Name of the container to get keys for
+            limit: Maximum number of keys to return
+            offset: Number of keys to skip
+
+        Returns:
+            List of cache key strings
+        """
+        ...
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the cache manager and clean up resources."""
+        ...

coding_client/interfaces/container_interface.py

@@ -0,0 +1,49 @@
+"""
+Container interface for breaking circular dependencies.
+
+This module provides abstract interfaces for container operations to prevent
+circular dependencies between container_manager and graph_service modules.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Protocol
+
+
+class ContainerInfo(Protocol):
+    """Protocol for container information objects."""
+
+    container_name: str
+    code_graph_id: str
+    status: str
+    api_endpoint: str | None
+
+
+class IContainerManager(ABC):
+    """Abstract interface for container management operations."""
+
+    @abstractmethod
+    def get_container_for_graph(self, code_graph_id: str) -> ContainerInfo | None:
+        """Get container information for a specific code graph ID.
+
+        Args:
+            code_graph_id: The code graph identifier
+
+        Returns:
+            ContainerInfo if found, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    def list_containers(self) -> list[ContainerInfo]:
+        """List all containers.
+
+        Returns:
+            List of ContainerInfo objects
+        """
+        pass
+
+
+# Type alias for container manager instances
+ContainerManagerType = IContainerManager

coding_client/interfaces/docker_interface.py

@@ -0,0 +1,283 @@
+"""
+Docker Service interface for breaking circular dependencies.
+
+This module provides abstract interfaces for Docker container operations to prevent
+circular dependencies and enable dependency injection.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from models.container import ContainerInfo, GitHubRepoRequest
+
+
+class IDockerService(ABC):
+    """Abstract interface for Docker container operations."""
+
+    @abstractmethod
+    def is_docker_available(self) -> bool:
+        """Check if Docker is available and accessible.
+
+        Returns:
+            True if Docker is available, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    def retry_docker_connection(self) -> bool:
+        """Attempt to reconnect to Docker if it wasn't available initially.
+
+        Returns:
+            True if reconnection succeeded, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def create_container(
+        self, request: GitHubRepoRequest, env_vars: dict[str, str] | None = None
+    ) -> ContainerInfo:
+        """Create and start a Docker container for GitHub repository.
+
+        Args:
+            request: GitHub repository provisioning request
+            env_vars: Optional environment variables from secret store
+
+        Returns:
+            ContainerInfo with container details
+        """
+        ...
+
+    @abstractmethod
+    async def remove_container(self, container: ContainerInfo) -> bool:
+        """Remove existing container and cleanup.
+
+        Args:
+            container: Container info to remove
+
+        Returns:
+            True if removal succeeded, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def remove_container_by_name(self, container_name: str) -> bool:
+        """Remove a container by its name and clean up resources.
+
+        Args:
+            container_name: Name of the container to remove
+
+        Returns:
+            True if removal succeeded, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def remove_container_by_id(self, docker_id: str, force: bool = True) -> None:
+        """Remove a container by ID.
+
+        Args:
+            docker_id: Docker container ID
+            force: Force removal even if running
+        """
+        ...
+
+    @abstractmethod
+    async def start_container(self, docker_id: str) -> None:
+        """Start a container by ID.
+
+        Args:
+            docker_id: Docker container ID
+        """
+        ...
+
+    @abstractmethod
+    async def stop_container(self, docker_id: str, timeout: int = 10) -> None:
+        """Stop a container by ID.
+
+        Args:
+            docker_id: Docker container ID
+            timeout: Timeout in seconds before force kill
+        """
+        ...
+
+    @abstractmethod
+    async def list_containers(self) -> list[ContainerInfo]:
+        """List all managed containers with real-time status verification.
+
+        Returns:
+            List of ContainerInfo objects
+        """
+        ...
+
+    @abstractmethod
+    async def find_container_by_name(self, container_name: str) -> ContainerInfo | None:
+        """Find container by container_name.
+
+        Args:
+            container_name: Name of the container to find
+
+        Returns:
+            ContainerInfo if found, None otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def find_existing_container(self, repo_url: str) -> ContainerInfo | None:
+        """Find existing container by repository URL.
+
+        Args:
+            repo_url: Repository URL to search for
+
+        Returns:
+            ContainerInfo if found, None otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def initialize_code_graph(
+        self,
+        container: ContainerInfo,
+        analysis_settings: dict[str, Any] | None = None,
+    ) -> ContainerInfo:
+        """Manually initialize the code graph by calling the container's initialization endpoint.
+
+        Args:
+            container: Container info to initialize graph for
+            analysis_settings: Optional analysis configuration
+
+        Returns:
+            Updated ContainerInfo
+        """
+        ...
+
+    @abstractmethod
+    async def read_container_file(
+        self,
+        container_name: str,
+        file_path: str,
+        offset: int = 0,
+        length: int | None = None,
+    ) -> dict[str, Any]:
+        """Read file from container using docker exec.
+
+        Args:
+            container_name: Name of the container
+            file_path: Path to the file inside the container
+            offset: Starting offset for reading
+            length: Number of bytes to read
+
+        Returns:
+            Dictionary with file content and metadata
+        """
+        ...
+
+    @abstractmethod
+    async def list_container_directory(
+        self, container_name: str, path: str = "", recursive: bool = False
+    ) -> list[dict[str, Any]]:
+        """List directory contents in container.
+
+        Args:
+            container_name: Name of the container
+            path: Directory path to list
+            recursive: Whether to list recursively
+
+        Returns:
+            List of directory entries
+        """
+        ...
+
+    @abstractmethod
+    async def exec_in_container(
+        self,
+        docker_id: str,
+        command: list[str],
+        timeout: int = 30,
+        environment: dict[str, str] | None = None,
+        user: str | None = None,
+    ) -> dict[str, Any]:
+        """Execute command in container and return structured result.
+
+        Args:
+            docker_id: Docker container ID or name
+            command: Command to execute as list of strings
+            timeout: Execution timeout in seconds
+            environment: Optional environment variables
+            user: Optional user to run command as
+
+        Returns:
+            Dictionary with exit_code, stdout, stderr, execution_time, timeout
+        """
+        ...
+
+    @abstractmethod
+    async def create_file_in_container(
+        self, docker_id: str, file_path: str, content: str, mode: str = "w"
+    ) -> bool:
+        """Create file with content in container.
+
+        Args:
+            docker_id: Docker container ID or name
+            file_path: Path to create file at
+            content: Content to write
+            mode: Write mode ('w' for write, 'a' for append)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    @abstractmethod
+    async def get_container_stats(self, docker_id: str) -> dict[str, Any]:
+        """Get resource usage statistics for container.
+
+        Args:
+            docker_id: Docker container ID or name
+
+        Returns:
+            Dictionary with resource statistics
+        """
+        ...
+
+    @abstractmethod
+    def get_language_container_image(self, language: str) -> str:
+        """Get appropriate container image for language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Docker image name for the language
+        """
+        ...
+
+    @abstractmethod
+    async def create_test_container(self, config: dict[str, Any]) -> str:
+        """Create container specifically for test execution.
+
+        Args:
+            config: Container configuration
+
+        Returns:
+            Container ID
+        """
+        ...
+
+    @abstractmethod
+    async def install_tools_in_container(
+        self, docker_id: str, tools: list[str], language: str = "python"
+    ) -> bool:
+        """Install testing/quality tools in container.
+
+        Args:
+            docker_id: Docker container ID or name
+            tools: List of tool names to install
+            language: Programming language for tool installation
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...

coding_client/interfaces/graph_interface.py

@@ -0,0 +1,28 @@
+"""
+Graph interface for breaking circular dependencies.
+
+This module provides abstract interfaces for graph operations to prevent
+circular dependencies between graph_service and container_manager modules.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class IGraphService(ABC):
+    """Abstract interface for graph service operations."""
+
+    @abstractmethod
+    async def delete_graph(self, graph_id: str, force: bool = False) -> dict[str, Any]:
+        """Delete a graph and all associated data.
+
+        Args:
+            graph_id: Unique identifier of the graph to delete
+            force: If True, force deletion even for containerized graphs
+
+        Returns:
+            Dict containing deletion results
+        """
+        pass

coding_client/interfaces/security_interface.py

@@ -0,0 +1,72 @@
+"""
+Security Service interface for breaking circular dependencies.
+
+This module provides abstract interfaces for security validation operations to prevent
+circular dependencies and enable dependency injection.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from models.security import (
+        SecurityValidationRequest,
+        SecurityValidationResult,
+    )
+
+
+class ISecurityService(ABC):
+    """Abstract interface for security validation operations."""
+
+    @abstractmethod
+    async def validate_code_security(
+        self, request: SecurityValidationRequest
+    ) -> SecurityValidationResult:
+        """Main security validation method with comprehensive analysis.
+
+        Args:
+            request: Security validation request containing code and configuration
+
+        Returns:
+            SecurityValidationResult with safety status, violations, and risk score
+        """
+        ...
+
+    @abstractmethod
+    async def generate_sandbox_config(self, language: str, security_level: str) -> dict[str, Any]:
+        """Generate sandbox configuration based on language and security level.
+
+        Args:
+            language: Programming language for sandbox configuration
+            security_level: Security level (low, medium, high, critical)
+
+        Returns:
+            Dictionary containing sandbox configuration
+        """
+        ...
+
+    @abstractmethod
+    def get_dangerous_patterns(self, language: str) -> list[dict[str, Any]]:
+        """Get dangerous code patterns for a specific language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            List of pattern dictionaries with pattern, severity, description
+        """
+        ...
+
+    @abstractmethod
+    def get_sandbox_config(self, language: str) -> dict[str, Any] | None:
+        """Get default sandbox configuration for a language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Sandbox configuration dictionary or None if not configured
+        """
+        ...

coding_client/interfaces/webhook_interface.py

@@ -0,0 +1,67 @@
+"""
+Webhook interface for breaking circular dependencies.
+
+This module provides abstract interfaces for webhook event handling to prevent
+circular dependencies between webhook handler and endpoint modules.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class IWebhookEventHandler(ABC):
+    """Abstract interface for webhook event handlers."""
+
+    @abstractmethod
+    async def analyze_pull_request_changes(
+        self, repo_name: str, pr_number: int, trigger: str
+    ) -> None:
+        """Analyze changes in a pull request and provide feedback.
+
+        Args:
+            repo_name: Repository name (owner/repo)
+            pr_number: Pull request number
+            trigger: What triggered the analysis
+        """
+        pass
+
+    @abstractmethod
+    async def analyze_repository_changes(
+        self, repo_name: str, branch: str, commits: list
+    ) -> dict[str, Any]:
+        """Analyze changes from push events.
+
+        Args:
+            repo_name: Repository name (owner/repo)
+            branch: Branch name
+            commits: List of commits
+
+        Returns:
+            Analysis results dictionary
+        """
+        pass
+
+
+class WebhookEventHandlerRegistry:
+    """Registry for webhook event handlers to enable dependency injection."""
+
+    _handlers: dict[str, IWebhookEventHandler] = {}
+
+    @classmethod
+    def register(cls, name: str, handler: IWebhookEventHandler) -> None:
+        """Register a webhook event handler."""
+        cls._handlers[name] = handler
+
+    @classmethod
+    def get_handler(cls, name: str) -> IWebhookEventHandler | None:
+        """Get a registered webhook event handler."""
+        return cls._handlers.get(name)
+
+    @classmethod
+    def get(cls, name: str) -> IWebhookEventHandler:
+        """Get a registered webhook event handler (with error if not found)."""
+        if name not in cls._handlers:
+            raise ValueError(f"No handler registered with name: {name}")
+        return cls._handlers[name]