airbyte-agent-greenhouse 0.17.48__py3-none-any.whl

airbyte_agent_greenhouse/_vendored/connector_sdk/http/__init__.py

@@ -0,0 +1,37 @@
+"""HTTP abstraction layer for the Airbyte SDK.
+
+This package provides a client-agnostic HTTP interface that allows the SDK to work
+with different HTTP client implementations (httpx, aiohttp, etc.) while maintaining
+a consistent API.
+"""
+
+from .config import ClientConfig, ConnectionLimits, TimeoutConfig
+from .exceptions import (
+    AuthenticationError,
+    HTTPClientError,
+    HTTPStatusError,
+    NetworkError,
+    RateLimitError,
+    TimeoutError,
+)
+from .protocols import HTTPClientProtocol, HTTPResponseProtocol
+from .response import HTTPResponse
+
+__all__ = [
+    # Configuration
+    "ClientConfig",
+    "ConnectionLimits",
+    "TimeoutConfig",
+    # Protocols
+    "HTTPClientProtocol",
+    "HTTPResponseProtocol",
+    # Response
+    "HTTPResponse",
+    # Exceptions
+    "HTTPClientError",
+    "HTTPStatusError",
+    "AuthenticationError",
+    "RateLimitError",
+    "NetworkError",
+    "TimeoutError",
+]

airbyte_agent_greenhouse/_vendored/connector_sdk/http/adapters/__init__.py

@@ -0,0 +1,9 @@
+"""HTTP client adapter implementations.
+
+This package contains implementations of HTTPClientProtocol for different
+HTTP client libraries.
+"""
+
+from .httpx_adapter import HTTPXClient
+
+__all__ = ["HTTPXClient"]

airbyte_agent_greenhouse/_vendored/connector_sdk/http/adapters/httpx_adapter.py

@@ -0,0 +1,251 @@
+"""HTTPX adapter implementing the HTTP client protocol."""
+
+from typing import Any
+
+import httpx
+
+from ..config import ClientConfig, ConnectionLimits, TimeoutConfig
+from ..exceptions import (
+    AuthenticationError,
+    HTTPStatusError,
+    NetworkError,
+    RateLimitError,
+    TimeoutError,
+)
+from ..protocols import HTTPResponseProtocol
+from ..response import HTTPResponse
+
+
+class HTTPXClient:
+    """HTTPX-based implementation of the HTTP client protocol.
+
+    This adapter wraps httpx.AsyncClient and provides the HTTPClientProtocol interface,
+    allowing httpx to be swapped out for a different HTTP client in the future.
+    """
+
+    def __init__(self, config: ClientConfig | None = None) -> None:
+        """Initialize the HTTPX client adapter.
+
+        Args:
+            config: Client configuration. If None, uses default configuration.
+        """
+        self.config = config or ClientConfig()
+        self._client: httpx.AsyncClient | None = None
+
+    def _create_client(self) -> httpx.AsyncClient:
+        """Create and configure the httpx AsyncClient.
+
+        Returns:
+            Configured httpx.AsyncClient instance.
+        """
+        # Convert SDK config to httpx config
+        limits = self._convert_limits(self.config.limits)  # type: ignore
+        timeout = self._convert_timeout(self.config.timeout)  # type: ignore
+
+        return httpx.AsyncClient(
+            base_url=self.config.base_url or "",
+            timeout=timeout,
+            limits=limits,
+            follow_redirects=self.config.follow_redirects,
+        )
+
+    def _convert_limits(self, limits: ConnectionLimits) -> httpx.Limits:
+        """Convert SDK ConnectionLimits to httpx.Limits.
+
+        Args:
+            limits: SDK connection limits configuration
+
+        Returns:
+            httpx.Limits instance
+        """
+        return httpx.Limits(
+            max_connections=limits.max_connections,
+            max_keepalive_connections=limits.max_keepalive_connections,
+        )
+
+    def _convert_timeout(self, timeout: TimeoutConfig) -> httpx.Timeout:
+        """Convert SDK TimeoutConfig to httpx.Timeout.
+
+        Args:
+            timeout: SDK timeout configuration
+
+        Returns:
+            httpx.Timeout instance
+        """
+        return httpx.Timeout(
+            connect=timeout.connect,
+            read=timeout.read,
+            write=timeout.write,
+            pool=timeout.pool,
+        )
+
+    def _convert_response(self, httpx_response: httpx.Response, *, stream: bool = False) -> HTTPResponse:
+        """Convert httpx.Response to SDK HTTPResponse.
+
+        Args:
+            httpx_response: The httpx response object
+            stream: Whether the response should be treated as streaming (do not eagerly read body)
+
+        Returns:
+            HTTPResponse wrapping the httpx response
+        """
+        return HTTPResponse(
+            status_code=httpx_response.status_code,
+            headers=dict(httpx_response.headers),
+            # When streaming, avoid eagerly reading the body
+            content=b"" if stream else httpx_response.content,
+            _original_response=httpx_response,
+        )
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        data: dict[str, Any] | str | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> HTTPResponseProtocol:
+        """Execute an HTTP request using httpx.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            url: The URL to request
+            params: Query parameters to append to the URL
+            json: JSON data to send in the request body
+            data: Form data or raw string to send in the request body
+            headers: HTTP headers to include in the request
+            **kwargs: Additional httpx-specific parameters
+
+        Returns:
+            HTTPResponse with the response data.
+
+        Raises:
+            HTTPStatusError: For 4xx or 5xx HTTP status codes
+            AuthenticationError: For 401 or 403 status codes
+            RateLimitError: For 429 status codes
+            TimeoutError: For timeout errors
+            NetworkError: For network/connection errors
+        """
+        if self._client is None:
+            self._client = self._create_client()
+
+        # Extract stream parameter (not supported by httpx.request directly)
+        stream = kwargs.pop("stream", False)
+
+        try:
+            # Execute the request
+            httpx_response = await self._client.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json,
+                data=data,
+                headers=headers,
+                **kwargs,
+            )
+
+            # Convert to SDK response
+            response = self._convert_response(httpx_response, stream=stream)
+
+            # Check for HTTP errors and wrap them
+            if httpx_response.status_code >= 400:
+                await self._handle_http_error(httpx_response, response)
+
+            return response
+
+        except httpx.TimeoutException as e:
+            raise TimeoutError(
+                message=f"Request timed out: {e}",
+                timeout_type=None,  # httpx doesn't provide specific timeout type
+                original_error=e,
+            ) from e
+
+        except (httpx.ConnectError, httpx.NetworkError) as e:
+            raise NetworkError(
+                message=f"Network error: {e}",
+                original_error=e,
+            ) from e
+
+    async def _handle_http_error(self, httpx_response: httpx.Response, sdk_response: HTTPResponse) -> None:
+        """Handle HTTP error responses by raising appropriate SDK exceptions.
+
+        Args:
+            httpx_response: The original httpx response
+            sdk_response: The converted SDK response
+
+        Raises:
+            AuthenticationError: For 401 or 403 status codes
+            RateLimitError: For 429 status codes
+            HTTPStatusError: For other 4xx or 5xx status codes
+        """
+        status_code = httpx_response.status_code
+
+        # Try to get error message from response
+        try:
+            error_data = httpx_response.json()
+            error_message = error_data.get("message") or error_data.get("error") or str(error_data)
+        except Exception:
+            error_message = httpx_response.text or f"HTTP {status_code} error"
+
+        # Raise specific exceptions based on status code
+        if status_code in (401, 403):
+            raise AuthenticationError(
+                message=f"Authentication failed: {error_message} (HTTP {status_code})",
+                status_code=status_code,
+                response=sdk_response,
+            )
+
+        if status_code == 429:
+            # Try to parse Retry-After header
+            retry_after = None
+            if "retry-after" in httpx_response.headers:
+                try:
+                    retry_after = int(httpx_response.headers["retry-after"])
+                except ValueError:
+                    pass
+
+            error_msg = f"Rate limit exceeded: {error_message}"
+            if retry_after:
+                error_msg += f" (retry after {retry_after}s)"
+
+            raise RateLimitError(
+                message=error_msg,
+                retry_after=retry_after,
+                response=sdk_response,
+            )
+
+        # Generic HTTP error
+        raise HTTPStatusError(
+            status_code=status_code,
+            message=error_message,
+            response=sdk_response,
+        )
+
+    async def aclose(self) -> None:
+        """Close the HTTP client and cleanup resources."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> "HTTPXClient":
+        """Enter async context manager.
+
+        Returns:
+            The client instance.
+        """
+        if self._client is None:
+            self._client = self._create_client()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Exit async context manager and cleanup resources.
+
+        Args:
+            exc_type: Exception type if an exception occurred
+            exc_val: Exception value if an exception occurred
+            exc_tb: Exception traceback if an exception occurred
+        """
+        await self.aclose()

airbyte_agent_greenhouse/_vendored/connector_sdk/http/config.py

@@ -0,0 +1,98 @@
+"""Configuration classes for HTTP clients."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..constants import (
+    DEFAULT_CONNECT_TIMEOUT,
+    DEFAULT_MAX_CONNECTIONS,
+    DEFAULT_MAX_KEEPALIVE_CONNECTIONS,
+    DEFAULT_POOL_TIMEOUT,
+    DEFAULT_READ_TIMEOUT,
+    DEFAULT_WRITE_TIMEOUT,
+)
+
+
+@dataclass
+class ConnectionLimits:
+    """Configuration for HTTP connection pooling limits.
+
+    This replaces httpx.Limits and provides a client-agnostic way to configure
+    connection pooling behavior.
+    """
+
+    max_connections: int = DEFAULT_MAX_CONNECTIONS
+    """Maximum number of concurrent connections to allow."""
+
+    max_keepalive_connections: int = DEFAULT_MAX_KEEPALIVE_CONNECTIONS
+    """Maximum number of connections to keep alive in the pool."""
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.max_connections < 1:
+            raise ValueError("max_connections must be at least 1")
+        if self.max_keepalive_connections < 0:
+            raise ValueError("max_keepalive_connections must be non-negative")
+        if self.max_keepalive_connections > self.max_connections:
+            raise ValueError("max_keepalive_connections cannot exceed max_connections")
+
+
+@dataclass
+class TimeoutConfig:
+    """Configuration for HTTP request timeouts.
+
+    This replaces httpx.Timeout and provides a client-agnostic way to configure
+    timeout behavior for different phases of the HTTP request.
+    """
+
+    connect: float | None = DEFAULT_CONNECT_TIMEOUT
+    """Timeout for establishing a connection (seconds). None means no timeout."""
+
+    read: float | None = DEFAULT_READ_TIMEOUT
+    """Timeout for reading response data (seconds). None means no timeout."""
+
+    write: float | None = DEFAULT_WRITE_TIMEOUT
+    """Timeout for writing request data (seconds). None means no timeout."""
+
+    pool: float | None = DEFAULT_POOL_TIMEOUT
+    """Timeout for acquiring a connection from the pool (seconds). None means no timeout."""
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        for name, value in [
+            ("connect", self.connect),
+            ("read", self.read),
+            ("write", self.write),
+            ("pool", self.pool),
+        ]:
+            if value is not None and value <= 0:
+                raise ValueError(f"{name} timeout must be positive or None")
+
+
+@dataclass
+class ClientConfig:
+    """Overall configuration for an HTTP client.
+
+    This provides a complete, client-agnostic configuration for HTTP clients
+    that can be mapped to any underlying HTTP client implementation.
+    """
+
+    timeout: TimeoutConfig | None = None
+    """Timeout configuration. If None, uses default timeouts."""
+
+    limits: ConnectionLimits | None = None
+    """Connection pooling limits. If None, uses default limits."""
+
+    base_url: str | None = None
+    """Optional base URL to prepend to all requests."""
+
+    follow_redirects: bool = True
+    """Whether to automatically follow HTTP redirects."""
+
+    def __post_init__(self) -> None:
+        """Set default values for None fields."""
+        if self.timeout is None:
+            self.timeout = TimeoutConfig()
+        if self.limits is None:
+            self.limits = ConnectionLimits()

airbyte_agent_greenhouse/_vendored/connector_sdk/http/exceptions.py

@@ -0,0 +1,119 @@
+"""HTTP-related exceptions for the Airbyte SDK."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .response import HTTPResponse
+
+
+class HTTPClientError(Exception):
+    """Base exception for HTTP client errors."""
+
+    pass
+
+
+class HTTPStatusError(HTTPClientError):
+    """Raised when an HTTP response has a 4xx or 5xx status code.
+
+    This is the base exception for status code errors and is raised by
+    HTTPResponse.raise_for_status().
+    """
+
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        response: "HTTPResponse | None" = None,
+    ) -> None:
+        """Initialize HTTP status error.
+
+        Args:
+            status_code: The HTTP status code (e.g., 404, 500)
+            message: Error message describing the issue
+            response: Optional HTTPResponse object for accessing details
+        """
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class AuthenticationError(HTTPStatusError):
+    """Raised when authentication credentials are missing or invalid (401, 403)."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int = 401,
+        response: "HTTPResponse | None" = None,
+    ) -> None:
+        """Initialize authentication error.
+
+        Args:
+            message: Error message describing the authentication issue
+            status_code: HTTP status code (401 or 403)
+            response: Optional HTTPResponse object for accessing details
+        """
+        super().__init__(status_code=status_code, message=message, response=response)
+
+
+class RateLimitError(HTTPStatusError):
+    """Raised when API rate limit is exceeded (429 response)."""
+
+    def __init__(
+        self,
+        message: str,
+        retry_after: int | None = None,
+        response: "HTTPResponse | None" = None,
+    ) -> None:
+        """Initialize rate limit error.
+
+        Args:
+            message: Error message describing the rate limit
+            retry_after: Seconds to wait before retrying (from Retry-After header)
+            response: Optional HTTPResponse object for accessing details
+        """
+        super().__init__(status_code=429, message=message, response=response)
+        self.retry_after = retry_after
+
+
+class NetworkError(HTTPClientError):
+    """Raised when network connection fails.
+
+    This includes connection errors, DNS resolution failures, and other
+    network-level issues.
+    """
+
+    def __init__(self, message: str, original_error: Exception | None = None) -> None:
+        """Initialize network error.
+
+        Args:
+            message: Error message describing the network issue
+            original_error: Optional original exception from the HTTP client
+        """
+        super().__init__(message)
+        self.original_error = original_error
+
+
+class TimeoutError(HTTPClientError):
+    """Raised when a request times out.
+
+    This can occur during connection establishment, reading the response,
+    or writing the request.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        timeout_type: str | None = None,
+        original_error: Exception | None = None,
+    ) -> None:
+        """Initialize timeout error.
+
+        Args:
+            message: Error message describing the timeout
+            timeout_type: Optional type of timeout (connect, read, write, pool)
+            original_error: Optional original exception from the HTTP client
+        """
+        super().__init__(message)
+        self.timeout_type = timeout_type
+        self.original_error = original_error

airbyte_agent_greenhouse/_vendored/connector_sdk/http/protocols.py

@@ -0,0 +1,114 @@
+"""HTTP client and response protocols for abstracting HTTP client implementations."""
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class HTTPResponseProtocol(Protocol):
+    """Protocol defining the interface for HTTP responses.
+
+    This protocol abstracts the response interface, allowing different HTTP clients
+    to provide responses that work with the SDK.
+    """
+
+    @property
+    def status_code(self) -> int:
+        """The HTTP status code of the response."""
+        ...
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """The response headers as a dictionary."""
+        ...
+
+    async def json(self) -> Any:
+        """Parse the response body as JSON.
+
+        Returns:
+            The parsed JSON data (dict, list, or primitive).
+
+        Raises:
+            ValueError: If the response body is not valid JSON.
+        """
+        ...
+
+    async def text(self) -> str:
+        """Get the response body as text.
+
+        Returns:
+            The response body decoded as a string.
+        """
+        ...
+
+    def raise_for_status(self) -> None:
+        """Raise an exception if the response status indicates an error.
+
+        Raises:
+            Exception: For 4xx or 5xx status codes.
+        """
+        ...
+
+
+@runtime_checkable
+class HTTPClientProtocol(Protocol):
+    """Protocol defining the interface for HTTP clients.
+
+    This protocol abstracts the HTTP client interface, allowing the SDK to work with
+    different HTTP client implementations (httpx, aiohttp, etc.).
+    """
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        data: dict[str, Any] | str | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> HTTPResponseProtocol:
+        """Execute an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            url: The URL to request
+            params: Query parameters to append to the URL
+            json: JSON data to send in the request body
+            data: Form data or raw string to send in the request body
+            headers: HTTP headers to include in the request
+            **kwargs: Additional client-specific parameters
+
+        Returns:
+            An HTTPResponseProtocol implementation with the response data.
+
+        Raises:
+            Exception: For network errors, timeouts, or other request failures.
+        """
+        ...
+
+    async def aclose(self) -> None:
+        """Close the HTTP client and cleanup resources.
+
+        This should be called when the client is no longer needed to properly
+        cleanup connections and resources.
+        """
+        ...
+
+    async def __aenter__(self) -> "HTTPClientProtocol":
+        """Enter async context manager.
+
+        Returns:
+            The client instance.
+        """
+        ...
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Exit async context manager and cleanup resources.
+
+        Args:
+            exc_type: Exception type if an exception occurred
+            exc_val: Exception value if an exception occurred
+            exc_tb: Exception traceback if an exception occurred
+        """
+        ...