airbyte-agent-stripe 0.5.28__py3-none-any.whl

airbyte_agent_stripe/_vendored/connector_sdk/performance/metrics.py

@@ -0,0 +1,93 @@
+"""Performance metrics tracking."""
+
+import time
+from contextlib import asynccontextmanager
+from typing import Dict, Optional
+
+
+class PerformanceMonitor:
+    """Monitor and track performance metrics for operations."""
+
+    def __init__(self):
+        """Initialize performance monitor."""
+        self._metrics: Dict[str, Dict[str, float]] = {}
+
+    def record(self, metric_name: str, duration: float):
+        """Record a metric.
+
+        Args:
+            metric_name: Name of the metric
+            duration: Duration in seconds
+        """
+        if metric_name not in self._metrics:
+            self._metrics[metric_name] = {
+                "count": 0,
+                "total": 0.0,
+                "min": float("inf"),
+                "max": 0.0,
+            }
+
+        metrics = self._metrics[metric_name]
+        metrics["count"] += 1
+        metrics["total"] += duration
+        metrics["min"] = min(metrics["min"], duration)
+        metrics["max"] = max(metrics["max"], duration)
+
+    def get_stats(self, metric_name: str) -> Optional[Dict[str, float]]:
+        """Get statistics for a metric.
+
+        Args:
+            metric_name: Name of the metric
+
+        Returns:
+            Dictionary with count, total, mean, min, max or None if metric not found
+        """
+        if metric_name not in self._metrics:
+            return None
+
+        metrics = self._metrics[metric_name]
+        return {
+            "count": metrics["count"],
+            "total": metrics["total"],
+            "mean": metrics["total"] / metrics["count"] if metrics["count"] > 0 else 0.0,
+            "min": metrics["min"] if metrics["min"] != float("inf") else 0.0,
+            "max": metrics["max"],
+        }
+
+    def get_all_stats(self) -> Dict[str, Dict[str, float]]:
+        """Get statistics for all metrics.
+
+        Returns:
+            Dictionary mapping metric names to their statistics
+        """
+        return {name: self.get_stats(name) for name in self._metrics.keys()}
+
+    def reset(self, metric_name: Optional[str] = None):
+        """Reset metrics.
+
+        Args:
+            metric_name: Specific metric to reset, or None to reset all
+        """
+        if metric_name:
+            if metric_name in self._metrics:
+                del self._metrics[metric_name]
+        else:
+            self._metrics.clear()
+
+    @asynccontextmanager
+    async def track(self, metric_name: str):
+        """Context manager for tracking operation duration.
+
+        Args:
+            metric_name: Name of the metric to track
+
+        Example:
+            async with monitor.track("api_call"):
+                result = await some_async_operation()
+        """
+        start_time = time.time()
+        try:
+            yield
+        finally:
+            duration = time.time() - start_time
+            self.record(metric_name, duration)

airbyte_agent_stripe/_vendored/connector_sdk/schema/__init__.py

@@ -0,0 +1,75 @@
+"""
+Pydantic 2 schema models for OpenAPI 3.0 connector specifications.
+
+This package provides strongly-typed Pydantic models that mirror the OpenAPI 3.0
+specification while supporting Airbyte-specific extensions.
+
+Usage:
+    import yaml
+    from . import OpenAPIConnector
+
+    with open('connector.yaml') as f:
+        data = yaml.safe_load(f)
+
+    connector = OpenAPIConnector(**data)
+    print(connector.list_resources())
+"""
+
+from .base import Contact, Info, License, Server, ServerVariable
+from .components import (
+    Components,
+    Header,
+    MediaType,
+    Parameter,
+    RequestBody,
+    Response,
+    Schema,
+)
+from .connector import ExternalDocs, OpenAPIConnector, Tag
+from .extensions import PaginationConfig, RateLimitConfig, RetryConfig
+from .operations import Operation, PathItem
+from .security import (
+    AirbyteAuthConfig,
+    AuthConfigFieldSpec,
+    AuthConfigOption,
+    OAuth2Flow,
+    OAuth2Flows,
+    SecurityRequirement,
+    SecurityScheme,
+)
+
+__all__ = [
+    # Root model
+    "OpenAPIConnector",
+    "Tag",
+    "ExternalDocs",
+    # Base models
+    "Info",
+    "Server",
+    "ServerVariable",
+    "Contact",
+    "License",
+    # Security models
+    "SecurityScheme",
+    "SecurityRequirement",
+    "OAuth2Flow",
+    "OAuth2Flows",
+    "AirbyteAuthConfig",
+    "AuthConfigOption",
+    "AuthConfigFieldSpec",
+    # Component models
+    "Components",
+    "Schema",
+    "Parameter",
+    "RequestBody",
+    "Response",
+    "MediaType",
+    "Header",
+    # Operation models
+    "PathItem",
+    "Operation",
+    # Extension models (for future use)
+    "PaginationConfig",
+    "RateLimitConfig",
+    "RetryConfig",
+]

airbyte_agent_stripe/_vendored/connector_sdk/schema/base.py

@@ -0,0 +1,161 @@
+"""
+Base OpenAPI 3.1 models: Info, Server, Contact, License.
+
+References:
+- https://spec.openapis.org/oas/v3.1.0#info-object
+- https://spec.openapis.org/oas/v3.1.0#server-object
+"""
+
+from enum import StrEnum
+from typing import Dict, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic_core import Url
+
+from .extensions import RetryConfig
+
+
+class ExampleQuestions(BaseModel):
+    """
+    Example questions for AI connector documentation.
+
+    Used to generate supported_questions.md and unsupported_questions.md files
+    that appear in the connector's README.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    supported: list[str] = Field(
+        default_factory=list,
+        description="Example questions the connector can handle",
+    )
+    unsupported: list[str] = Field(
+        default_factory=list,
+        description="Example questions the connector cannot handle",
+    )
+
+
+class Contact(BaseModel):
+    """
+    Contact information for the API.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#contact-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    name: Optional[str] = None
+    url: Optional[str] = None
+    email: Optional[str] = None
+
+
+class License(BaseModel):
+    """
+    License information for the API.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#license-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    name: str
+    url: Optional[str] = None
+
+
+class DocUrlType(StrEnum):
+    API_DEPRECATIONS = "api_deprecations"
+    API_REFERENCE = "api_reference"
+    API_RELEASE_HISTORY = "api_release_history"
+    AUTHENTICATION_GUIDE = "authentication_guide"
+    CHANGELOG = "changelog"
+    DATA_MODEL_REFERENCE = "data_model_reference"
+    DEVELOPER_COMMUNITY = "developer_community"
+    MIGRATION_GUIDE = "migration_guide"
+    OPENAPI_SPEC = "openapi_spec"
+    OTHER = "other"
+    PERMISSIONS_SCOPES = "permissions_scopes"
+    RATE_LIMITS = "rate_limits"
+    SQL_REFERENCE = "sql_reference"
+    STATUS_PAGE = "status_page"
+
+
+class DocUrl(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    url: str
+    type: DocUrlType
+    title: Optional[str] = None
+
+    @field_validator("url")
+    def validate_url(cls, v):
+        Url(v)
+        return v
+
+
+class Info(BaseModel):
+    """
+    API metadata information.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#info-object
+
+    Extensions:
+    - x-airbyte-connector-name: Name of the connector (Airbyte extension)
+    - x-airbyte-connector-id: UUID of the connector (Airbyte extension)
+    - x-airbyte-external-documentation-urls: List of external documentation URLs (Airbyte extension)
+    - x-airbyte-retry-config: Retry configuration for transient errors (Airbyte extension)
+    - x-airbyte-example-questions: Example questions for AI connector README (Airbyte extension)
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    title: str
+    version: str
+    description: Optional[str] = None
+    terms_of_service: Optional[str] = Field(None, alias="termsOfService")
+    contact: Optional[Contact] = None
+    license: Optional[License] = None
+
+    # Airbyte extension
+    x_airbyte_connector_name: Optional[str] = Field(None, alias="x-airbyte-connector-name")
+    x_airbyte_connector_id: Optional[UUID] = Field(None, alias="x-airbyte-connector-id")
+    x_airbyte_external_documentation_urls: list[DocUrl] = Field(..., alias="x-airbyte-external-documentation-urls")
+    x_airbyte_retry_config: Optional[RetryConfig] = Field(None, alias="x-airbyte-retry-config")
+    x_airbyte_example_questions: Optional[ExampleQuestions] = Field(None, alias="x-airbyte-example-questions")
+
+
+class ServerVariable(BaseModel):
+    """
+    Variable for server URL templating.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#server-variable-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    enum: Optional[list[str]] = None
+    default: str
+    description: Optional[str] = None
+
+
+class Server(BaseModel):
+    """
+    Server URL and variable definitions.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#server-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    url: str
+    description: Optional[str] = None
+    variables: Dict[str, ServerVariable] = Field(default_factory=dict)
+
+    @field_validator("url")
+    @classmethod
+    def validate_url(cls, v: str) -> str:
+        """Validate that server URL is properly formatted."""
+        if not v:
+            raise ValueError("Server URL cannot be empty")
+        # Allow both absolute URLs and relative paths
+        return v

airbyte_agent_stripe/_vendored/connector_sdk/schema/components.py

@@ -0,0 +1,238 @@
+"""
+Component models for OpenAPI 3.1: Schema, Parameter, RequestBody, Response, Components.
+
+References:
+- https://spec.openapis.org/oas/v3.1.0#components-object
+- https://spec.openapis.org/oas/v3.1.0#schema-object
+- https://spec.openapis.org/oas/v3.1.0#parameter-object
+"""
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .security import SecurityScheme
+
+
+class Schema(BaseModel):
+    """
+    JSON Schema definition for data models.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#schema-object
+
+    Note: Uses Dict[str, Any] for properties to support nested schemas and $ref.
+    Reference resolution happens at runtime in config_loader.py.
+
+    Extensions:
+    - x-airbyte-resource-name: Name of the resource this schema represents (Airbyte extension)
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    # Core JSON Schema fields
+    type: Optional[str] = None
+    format: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    default: Optional[Any] = None
+    example: Optional[Any] = None
+
+    # Object properties
+    properties: Dict[str, Any] = Field(default_factory=dict)  # May contain $ref
+    required: List[str] = Field(default_factory=list)
+    additional_properties: Optional[Any] = Field(None, alias="additionalProperties")
+
+    # Array properties
+    items: Optional[Any] = None  # May be Schema or $ref
+
+    # Validation
+    enum: Optional[List[Any]] = None
+    min_length: Optional[int] = Field(None, alias="minLength")
+    max_length: Optional[int] = Field(None, alias="maxLength")
+    minimum: Optional[float] = None
+    maximum: Optional[float] = None
+    pattern: Optional[str] = None
+
+    # Composition
+    all_of: Optional[List[Any]] = Field(None, alias="allOf")
+    any_of: Optional[List[Any]] = Field(None, alias="anyOf")
+    one_of: Optional[List[Any]] = Field(None, alias="oneOf")
+    not_: Optional[Any] = Field(None, alias="not")
+
+    # Metadata
+    nullable: Optional[bool] = Field(None, deprecated="Use type union with null instead (OpenAPI 3.1)")
+    read_only: Optional[bool] = Field(None, alias="readOnly")
+    write_only: Optional[bool] = Field(None, alias="writeOnly")
+    deprecated: Optional[bool] = None
+
+    # Airbyte extension
+    x_airbyte_entity_name: Optional[str] = Field(None, alias="x-airbyte-entity-name")
+
+
+class Parameter(BaseModel):
+    """
+    Operation parameter definition.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#parameter-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    name: str
+    in_: Literal["query", "header", "path", "cookie"] = Field(alias="in")
+    description: Optional[str] = None
+    required: Optional[bool] = None
+    deprecated: Optional[bool] = None
+    allow_empty_value: Optional[bool] = Field(None, alias="allowEmptyValue")
+
+    # Schema can be inline or reference
+    schema_: Optional[Dict[str, Any]] = Field(None, alias="schema")
+
+    # Style and examples
+    style: Optional[str] = None
+    explode: Optional[bool] = None
+    example: Optional[Any] = None
+    examples: Optional[Dict[str, Any]] = None
+
+
+class MediaType(BaseModel):
+    """
+    Media type object for request/response content.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#media-type-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    schema_: Optional[Dict[str, Any]] = Field(None, alias="schema")
+    example: Optional[Any] = None
+    examples: Optional[Dict[str, Any]] = None
+    encoding: Optional[Dict[str, Any]] = None
+
+
+class GraphQLBodyConfig(BaseModel):
+    """
+    GraphQL body type configuration for x-airbyte-body-type extension.
+
+    Used when x-airbyte-body-type.type = "graphql"
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    type: Literal["graphql"] = Field(..., description="Body type identifier (must be 'graphql')")
+    query: str = Field(
+        ...,
+        description="GraphQL query or mutation string with optional template placeholders (e.g., {{ variable }})",
+    )
+    variables: Optional[Dict[str, Any]] = Field(
+        None,
+        description="Variables to substitute in the GraphQL query using template syntax (e.g., {{ param_name }})",
+    )
+    operationName: Optional[str] = Field(None, description="Operation name for queries with multiple operations")
+    default_fields: Optional[Union[str, List[str]]] = Field(
+        None,
+        description="Default fields to select if not provided in request parameters. Can be a string or array of field names.",
+    )
+
+
+# Union type for all body type configs (extensible for future types like XML, SOAP, etc.)
+BodyTypeConfig = Union[GraphQLBodyConfig]
+
+
+class PathOverrideConfig(BaseModel):
+    """
+    Path override configuration for x-airbyte-path-override extension.
+
+    Used when the OpenAPI path differs from the actual HTTP endpoint path.
+    Common for GraphQL APIs where multiple resources share the same endpoint (e.g., /graphql).
+
+    Example:
+        OpenAPI path: /graphql:repositories (for uniqueness)
+        Actual HTTP path: /graphql (configured here)
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    path: str = Field(
+        ...,
+        description=("Actual HTTP path to use for requests (e.g., '/graphql'). " "Must start with '/'"),
+    )
+
+
+class RequestBody(BaseModel):
+    """
+    Request body definition.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#request-body-object
+
+    Airbyte Extensions:
+    See connector_sdk.extensions for documentation:
+    - AIRBYTE_BODY_TYPE: Body type and configuration (nested structure)
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    description: Optional[str] = None
+    content: Dict[str, MediaType] = Field(default_factory=dict)
+    required: Optional[bool] = None
+
+    # Airbyte extensions for GraphQL support
+    # See connector_sdk.extensions for AIRBYTE_BODY_TYPE constant
+    x_airbyte_body_type: Optional[BodyTypeConfig] = Field(
+        None,
+        alias="x-airbyte-body-type",  # AIRBYTE_BODY_TYPE
+        description=(
+            "Body type and configuration. Contains 'type' field (e.g., 'graphql') " "and type-specific configuration (query, variables, etc.)."
+        ),
+    )
+
+
+class Header(BaseModel):
+    """
+    Header definition.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#header-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    description: Optional[str] = None
+    required: Optional[bool] = None
+    deprecated: Optional[bool] = None
+    schema_: Optional[Dict[str, Any]] = Field(None, alias="schema")
+    example: Optional[Any] = None
+
+
+class Response(BaseModel):
+    """
+    Response definition.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#response-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    description: str
+    headers: Optional[Dict[str, Header]] = None
+    content: Optional[Dict[str, MediaType]] = None
+    links: Optional[Dict[str, Any]] = None
+
+
+class Components(BaseModel):
+    """
+    Reusable component definitions.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#components-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    schemas: Dict[str, Schema] = Field(default_factory=dict)
+    responses: Dict[str, Response] = Field(default_factory=dict)
+    parameters: Dict[str, Parameter] = Field(default_factory=dict)
+    examples: Optional[Dict[str, Any]] = None
+    request_bodies: Dict[str, RequestBody] = Field(default_factory=dict, alias="requestBodies")
+    headers: Optional[Dict[str, Header]] = None
+    security_schemes: Dict[str, SecurityScheme] = Field(default_factory=dict, alias="securitySchemes")
+    links: Optional[Dict[str, Any]] = None
+    callbacks: Optional[Dict[str, Any]] = None

airbyte_agent_stripe/_vendored/connector_sdk/schema/connector.py

@@ -0,0 +1,131 @@
+"""
+Root OpenAPI 3.1 connector specification model.
+
+References:
+- https://spec.openapis.org/oas/v3.1.0#openapi-object
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from ..constants import OPENAPI_VERSION_PREFIX
+
+from .base import Info, Server
+from .components import Components
+from .operations import PathItem
+from .security import SecurityRequirement
+
+
+class Tag(BaseModel):
+    """
+    Tag metadata for grouping operations.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#tag-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    name: str
+    description: str | None = None
+    external_docs: dict[str, Any] | None = Field(None, alias="externalDocs")
+
+
+class ExternalDocs(BaseModel):
+    """
+    External documentation reference.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#external-documentation-object
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+    description: str | None = None
+    url: str
+
+
+class OpenAPIConnector(BaseModel):
+    """
+    Root OpenAPI 3.1 connector specification.
+
+    OpenAPI Reference: https://spec.openapis.org/oas/v3.1.0#openapi-object
+
+    This is the top-level model that represents a complete OpenAPI 3.1 specification
+    for an Airbyte connector. It enforces strict validation (extra='forbid') to catch
+    typos and unknown extensions.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid", validate_default=True)
+
+    # Required fields
+    openapi: str
+    info: Info
+    paths: dict[str, PathItem] = Field(default_factory=dict)
+
+    # Optional fields
+    servers: list[Server] = Field(default_factory=list)
+    components: Components | None = None
+    security: list[SecurityRequirement] | None = None
+    tags: list[Tag] | None = None
+    external_docs: ExternalDocs | None = Field(None, alias="externalDocs")
+
+    @field_validator("openapi")
+    @classmethod
+    def validate_openapi_version(cls, v: str) -> str:
+        """Validate that OpenAPI version is 3.1.x."""
+        if not v.startswith(OPENAPI_VERSION_PREFIX):
+            raise ValueError(f"OpenAPI version must be {OPENAPI_VERSION_PREFIX}x, got: {v}")
+        return v
+
+    def get_entity_operations(self, entity_name: str) -> list[tuple[str, str, Any]]:
+        """
+        Get all operations for a specific entity.
+
+        Args:
+            entity_name: The x-airbyte-entity value to filter by
+
+        Returns:
+            List of tuples: (path, method, operation)
+        """
+        results = []
+        for path, path_item in self.paths.items():
+            for method in [
+                "get",
+                "post",
+                "put",
+                "patch",
+                "delete",
+                "options",
+                "head",
+                "trace",
+            ]:
+                operation = getattr(path_item, method, None)
+                if operation and operation.x_airbyte_entity == entity_name:
+                    results.append((path, method, operation))
+        return results
+
+    def list_entities(self) -> list[str]:
+        """
+        List all unique entity names defined in x-airbyte-entity extensions.
+
+        Returns:
+            Sorted list of unique entity names
+        """
+        entities = set()
+        for path_item in self.paths.values():
+            for method in [
+                "get",
+                "post",
+                "put",
+                "patch",
+                "delete",
+                "options",
+                "head",
+                "trace",
+            ]:
+                operation = getattr(path_item, method, None)
+                if operation and operation.x_airbyte_entity:
+                    entities.add(operation.x_airbyte_entity)
+        return sorted(entities)