ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/core/proxy.py

@@ -1,143 +0,0 @@
-"""Core proxy abstractions for handling HTTP and WebSocket connections."""
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
-
-from ccproxy.core.types import ProxyRequest, ProxyResponse
-
-
-if TYPE_CHECKING:
-    from ccproxy.core.http import HTTPClient
-
-
-class BaseProxy(ABC):
-    """Abstract base class for all proxy implementations."""
-
-    @abstractmethod
-    async def forward(self, request: ProxyRequest) -> ProxyResponse:
-        """Forward a request and return the response.
-
-        Args:
-            request: The proxy request to forward
-
-        Returns:
-            The proxy response
-
-        Raises:
-            ProxyError: If the request cannot be forwarded
-        """
-        pass
-
-    @abstractmethod
-    async def close(self) -> None:
-        """Close any resources held by the proxy."""
-        pass
-
-
-class HTTPProxy(BaseProxy):
-    """HTTP proxy implementation using HTTPClient abstractions."""
-
-    def __init__(self, http_client: "HTTPClient") -> None:
-        """Initialize with an HTTP client.
-
-        Args:
-            http_client: The HTTP client to use for requests
-        """
-        self.http_client = http_client
-
-    async def forward(self, request: ProxyRequest) -> ProxyResponse:
-        """Forward an HTTP request using the HTTP client.
-
-        Args:
-            request: The proxy request to forward
-
-        Returns:
-            The proxy response
-
-        Raises:
-            ProxyError: If the request cannot be forwarded
-        """
-        from ccproxy.core.errors import ProxyError
-        from ccproxy.core.http import HTTPError
-
-        try:
-            # Convert ProxyRequest to HTTP client format
-            body_bytes = None
-            if request.body is not None:
-                if isinstance(request.body, bytes):
-                    body_bytes = request.body
-                elif isinstance(request.body, str):
-                    body_bytes = request.body.encode("utf-8")
-                elif isinstance(request.body, dict):
-                    import json
-
-                    body_bytes = json.dumps(request.body).encode("utf-8")
-
-            # Make the HTTP request
-            status_code, headers, response_body = await self.http_client.request(
-                method=request.method.value,
-                url=request.url,
-                headers=request.headers,
-                body=body_bytes,
-                timeout=request.timeout,
-            )
-
-            # Convert response body to appropriate format
-            body: str | bytes | dict[str, Any] | None = response_body
-            if response_body:
-                # Try to decode as JSON if content-type suggests it
-                content_type = headers.get("content-type", "").lower()
-                if "application/json" in content_type:
-                    try:
-                        import json
-
-                        body = json.loads(response_body.decode("utf-8"))
-                    except (json.JSONDecodeError, UnicodeDecodeError):
-                        # Keep as bytes if JSON parsing fails
-                        body = response_body
-                elif "text/" in content_type:
-                    try:
-                        body = response_body.decode("utf-8")
-                    except UnicodeDecodeError:
-                        # Keep as bytes if text decoding fails
-                        body = response_body
-
-            return ProxyResponse(
-                status_code=status_code,
-                headers=headers,
-                body=body,
-            )
-
-        except HTTPError as e:
-            raise ProxyError(f"HTTP request failed: {e}") from e
-        except Exception as e:
-            raise ProxyError(f"Unexpected error during HTTP request: {e}") from e
-
-    async def close(self) -> None:
-        """Close HTTP proxy resources."""
-        await self.http_client.close()
-
-
-class WebSocketProxy(BaseProxy):
-    """WebSocket proxy implementation placeholder."""
-
-    async def forward(self, request: ProxyRequest) -> ProxyResponse:
-        """Forward a WebSocket request."""
-        raise NotImplementedError("WebSocketProxy.forward not yet implemented")
-
-    async def close(self) -> None:
-        """Close WebSocket proxy resources."""
-        pass
-
-
-@runtime_checkable
-class ProxyProtocol(Protocol):
-    """Protocol defining the proxy interface."""
-
-    async def forward(self, request: ProxyRequest) -> ProxyResponse:
-        """Forward a request and return the response."""
-        ...
-
-    async def close(self) -> None:
-        """Close any resources held by the proxy."""
-        ...

ccproxy/core/validators.py

@@ -1,288 +0,0 @@
-"""Generic validation utilities for the CCProxy API."""
-
-import re
-from pathlib import Path
-from typing import Any
-from urllib.parse import urlparse
-
-from ccproxy.core.constants import EMAIL_PATTERN, URL_PATTERN, UUID_PATTERN
-
-
-class ValidationError(Exception):
-    """Base class for validation errors."""
-
-    pass
-
-
-def validate_email(email: str) -> str:
-    """Validate email format.
-
-    Args:
-        email: Email address to validate
-
-    Returns:
-        The validated email address
-
-    Raises:
-        ValidationError: If email format is invalid
-    """
-    if not isinstance(email, str):
-        raise ValidationError("Email must be a string")
-
-    if not re.match(EMAIL_PATTERN, email):
-        raise ValidationError(f"Invalid email format: {email}")
-
-    return email.strip().lower()
-
-
-def validate_url(url: str) -> str:
-    """Validate URL format.
-
-    Args:
-        url: URL to validate
-
-    Returns:
-        The validated URL
-
-    Raises:
-        ValidationError: If URL format is invalid
-    """
-    if not isinstance(url, str):
-        raise ValidationError("URL must be a string")
-
-    if not re.match(URL_PATTERN, url):
-        raise ValidationError(f"Invalid URL format: {url}")
-
-    try:
-        parsed = urlparse(url)
-        if not parsed.scheme or not parsed.netloc:
-            raise ValidationError(f"Invalid URL format: {url}")
-    except Exception as e:
-        raise ValidationError(f"Invalid URL format: {url}") from e
-
-    return url.strip()
-
-
-def validate_uuid(uuid_str: str) -> str:
-    """Validate UUID format.
-
-    Args:
-        uuid_str: UUID string to validate
-
-    Returns:
-        The validated UUID string
-
-    Raises:
-        ValidationError: If UUID format is invalid
-    """
-    if not isinstance(uuid_str, str):
-        raise ValidationError("UUID must be a string")
-
-    if not re.match(UUID_PATTERN, uuid_str.lower()):
-        raise ValidationError(f"Invalid UUID format: {uuid_str}")
-
-    return uuid_str.strip().lower()
-
-
-def validate_path(path: str | Path, must_exist: bool = True) -> Path:
-    """Validate file system path.
-
-    Args:
-        path: Path to validate
-        must_exist: Whether the path must exist
-
-    Returns:
-        The validated Path object
-
-    Raises:
-        ValidationError: If path is invalid
-    """
-    if isinstance(path, str):
-        path = Path(path)
-    elif not isinstance(path, Path):
-        raise ValidationError("Path must be a string or Path object")
-
-    if must_exist and not path.exists():
-        raise ValidationError(f"Path does not exist: {path}")
-
-    return path.resolve()
-
-
-def validate_port(port: int | str) -> int:
-    """Validate port number.
-
-    Args:
-        port: Port number to validate
-
-    Returns:
-        The validated port number
-
-    Raises:
-        ValidationError: If port is invalid
-    """
-    if isinstance(port, str):
-        try:
-            port = int(port)
-        except ValueError as e:
-            raise ValidationError(f"Port must be a valid integer: {port}") from e
-
-    if not isinstance(port, int):
-        raise ValidationError(f"Port must be an integer: {port}")
-
-    if port < 1 or port > 65535:
-        raise ValidationError(f"Port must be between 1 and 65535: {port}")
-
-    return port
-
-
-def validate_timeout(timeout: float | int | str) -> float:
-    """Validate timeout value.
-
-    Args:
-        timeout: Timeout value to validate
-
-    Returns:
-        The validated timeout value
-
-    Raises:
-        ValidationError: If timeout is invalid
-    """
-    if isinstance(timeout, str):
-        try:
-            timeout = float(timeout)
-        except ValueError as e:
-            raise ValidationError(f"Timeout must be a valid number: {timeout}") from e
-
-    if not isinstance(timeout, int | float):
-        raise ValidationError(f"Timeout must be a number: {timeout}")
-
-    if timeout < 0:
-        raise ValidationError(f"Timeout must be non-negative: {timeout}")
-
-    return float(timeout)
-
-
-def validate_non_empty_string(value: str, name: str = "value") -> str:
-    """Validate that a string is not empty.
-
-    Args:
-        value: String value to validate
-        name: Name of the field for error messages
-
-    Returns:
-        The validated string
-
-    Raises:
-        ValidationError: If string is empty or not a string
-    """
-    if not isinstance(value, str):
-        raise ValidationError(f"{name} must be a string")
-
-    if not value.strip():
-        raise ValidationError(f"{name} cannot be empty")
-
-    return value.strip()
-
-
-def validate_dict(value: Any, required_keys: list[str] | None = None) -> dict[str, Any]:
-    """Validate dictionary and required keys.
-
-    Args:
-        value: Value to validate as dictionary
-        required_keys: List of required keys
-
-    Returns:
-        The validated dictionary
-
-    Raises:
-        ValidationError: If not a dictionary or missing required keys
-    """
-    if not isinstance(value, dict):
-        raise ValidationError("Value must be a dictionary")
-
-    if required_keys:
-        missing_keys = [key for key in required_keys if key not in value]
-        if missing_keys:
-            raise ValidationError(f"Missing required keys: {missing_keys}")
-
-    return value
-
-
-def validate_list(
-    value: Any, min_length: int = 0, max_length: int | None = None
-) -> list[Any]:
-    """Validate list and length constraints.
-
-    Args:
-        value: Value to validate as list
-        min_length: Minimum list length
-        max_length: Maximum list length
-
-    Returns:
-        The validated list
-
-    Raises:
-        ValidationError: If not a list or length constraints are violated
-    """
-    if not isinstance(value, list):
-        raise ValidationError("Value must be a list")
-
-    if len(value) < min_length:
-        raise ValidationError(f"List must have at least {min_length} items")
-
-    if max_length is not None and len(value) > max_length:
-        raise ValidationError(f"List cannot have more than {max_length} items")
-
-    return value
-
-
-def validate_choice(value: Any, choices: list[Any], name: str = "value") -> Any:
-    """Validate that value is one of the allowed choices.
-
-    Args:
-        value: Value to validate
-        choices: List of allowed choices
-        name: Name of the field for error messages
-
-    Returns:
-        The validated value
-
-    Raises:
-        ValidationError: If value is not in choices
-    """
-    if value not in choices:
-        raise ValidationError(f"{name} must be one of {choices}, got: {value}")
-
-    return value
-
-
-def validate_range(
-    value: float | int,
-    min_value: float | int | None = None,
-    max_value: float | int | None = None,
-    name: str = "value",
-) -> float | int:
-    """Validate that a numeric value is within a specified range.
-
-    Args:
-        value: Numeric value to validate
-        min_value: Minimum allowed value
-        max_value: Maximum allowed value
-        name: Name of the field for error messages
-
-    Returns:
-        The validated value
-
-    Raises:
-        ValidationError: If value is outside the allowed range
-    """
-    if not isinstance(value, int | float):
-        raise ValidationError(f"{name} must be a number")
-
-    if min_value is not None and value < min_value:
-        raise ValidationError(f"{name} must be at least {min_value}")
-
-    if max_value is not None and value > max_value:
-        raise ValidationError(f"{name} must be at most {max_value}")
-
-    return value

ccproxy/models/errors.py

@@ -1,42 +0,0 @@
-"""Error response models for Anthropic API compatibility."""
-
-from typing import Annotated, Any, Literal
-
-from pydantic import BaseModel, Field
-
-
-class ErrorDetail(BaseModel):
-    """Error detail information."""
-
-    type: Annotated[str, Field(description="Error type identifier")]
-    message: Annotated[str, Field(description="Human-readable error message")]
-
-
-class AnthropicError(BaseModel):
-    """Anthropic API error response format."""
-
-    type: Annotated[Literal["error"], Field(description="Error type")] = "error"
-    error: Annotated[ErrorDetail, Field(description="Error details")]
-
-
-# Note: Specific error model classes were removed as they were unused.
-# Error responses are now forwarded directly from the upstream Claude API
-# to preserve the exact error format and headers.
-
-
-def create_error_response(
-    error_type: str, message: str, status_code: int = 500
-) -> tuple[dict[str, Any], int]:
-    """
-    Create a standardized error response.
-
-    Args:
-        error_type: Type of error (e.g., "invalid_request_error")
-        message: Human-readable error message
-        status_code: HTTP status code
-
-    Returns:
-        Tuple of (error_dict, status_code)
-    """
-    error_response = AnthropicError(error=ErrorDetail(type=error_type, message=message))
-    return error_response.model_dump(), status_code