fluidattacks_cloudflare_sdk 0.1.0__py3-none-any.whl

fluidattacks_cloudflare_sdk/__init__.py

@@ -0,0 +1,17 @@
+"""Cloudflare SDK for fluidattacks observes."""
+
+from fa_purity import Unsafe
+
+from fluidattacks_cloudflare_sdk._client import Token
+from fluidattacks_cloudflare_sdk._logger import set_logger
+from fluidattacks_cloudflare_sdk.core import AccountId, GatewayId
+
+__version__ = "0.1.0"
+
+Unsafe.compute(set_logger(__name__, __version__))
+
+__all__ = [
+    "AccountId",
+    "GatewayId",
+    "Token",
+]

fluidattacks_cloudflare_sdk/_client/__init__.py

@@ -0,0 +1,19 @@
+"""Private connection package for the Cloudflare SDK."""
+
+from dataclasses import dataclass
+
+from fluidattacks_cloudflare_sdk._client._client import CloudflareClient
+from fluidattacks_cloudflare_sdk._client._core import Client, Token
+
+
+@dataclass(frozen=True)
+class CloudflareClientFactory:
+    """Factory for a Cloudflare Client."""
+
+    @staticmethod
+    def new(token: Token) -> Client:
+        """Build a Client from a Token."""
+        return CloudflareClient.new(token).client
+
+
+__all__ = ["Client", "CloudflareClientFactory", "Token"]

fluidattacks_cloudflare_sdk/_client/_client.py

@@ -0,0 +1,30 @@
+"""Private Cloudflare client; builds the public Client."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from cloudflare import Cloudflare
+
+from fluidattacks_cloudflare_sdk._client._core import Client
+
+if TYPE_CHECKING:
+    from fluidattacks_cloudflare_sdk._client._core import Token
+
+
+@dataclass(frozen=True)
+class CloudflareClient:
+    """Private class holding the raw Cloudflare connection."""
+
+    _cloudflare: Cloudflare
+
+    @staticmethod
+    def new(token: Token) -> CloudflareClient:
+        """Build a CloudflareClient from a Token."""
+        return CloudflareClient(Cloudflare(api_token=token.raw))
+
+    @property
+    def client(self) -> Client:
+        """Return the opaque Client."""
+        return Client(self._cloudflare)

fluidattacks_cloudflare_sdk/_client/_core.py

@@ -0,0 +1,23 @@
+"""Core types for the private Cloudflare connection package."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cloudflare import Cloudflare
+
+
+@dataclass(frozen=True)
+class Token:
+    """Cloudflare API token."""
+
+    raw: str
+
+
+@dataclass(frozen=True)
+class Client:
+    """Opaque Cloudflare connection; raw field is SDK-internal."""
+
+    client: Cloudflare

fluidattacks_cloudflare_sdk/_logger.py

@@ -0,0 +1,30 @@
+"""Logger configuration for the Cloudflare SDK."""
+
+from fa_purity import (
+    Cmd,
+)
+from fluidattacks_utils_logger import (
+    set_main_log,
+)
+from fluidattacks_utils_logger.env import (
+    current_app_env,
+    observes_debug,
+)
+from fluidattacks_utils_logger.handlers import (
+    LoggingConf,
+)
+
+
+def set_logger(root_name: str, version: str) -> Cmd[None]:
+    """Configure structured logging for the SDK."""
+    app_env = current_app_env()
+    debug = observes_debug()
+    conf = app_env.map(
+        lambda env: LoggingConf(
+            app_name="observes_cloudflare",
+            app_type="sdk",
+            app_version=version,
+            release_stage=env,
+        ),
+    )
+    return debug.bind(lambda d: conf.bind(lambda c: set_main_log(root_name, c, d)))

fluidattacks_cloudflare_sdk/ai_gateway/__init__.py

@@ -0,0 +1,56 @@
+"""AI Gateway sub-package for the Cloudflare SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from fluidattacks_cloudflare_sdk._client import CloudflareClientFactory
+from fluidattacks_cloudflare_sdk.ai_gateway._client import list_logs
+from fluidattacks_cloudflare_sdk.ai_gateway.core import (
+    AiGatewayClient,
+    EndDate,
+    LogRecord,
+    LogsOrderBy,
+    LogsQuery,
+    StartDate,
+)
+
+if TYPE_CHECKING:
+    from fluidattacks_cloudflare_sdk._client import Client, Token
+    from fluidattacks_cloudflare_sdk.core import AccountId, GatewayId
+
+
+def _from_client(
+    cloudflare: Client,
+    account_id: AccountId,
+    gateway_id: GatewayId,
+) -> AiGatewayClient:
+    return AiGatewayClient(
+        list_logs=lambda q: list_logs(cloudflare, account_id, gateway_id, q),
+    )
+
+
+@dataclass(frozen=True)
+class AiGatewayClientFactory:
+    """Factory for AiGatewayClient."""
+
+    @staticmethod
+    def new(
+        token: Token,
+        account_id: AccountId,
+        gateway_id: GatewayId,
+    ) -> AiGatewayClient:
+        """Build an AiGatewayClient from a token and identifiers."""
+        return _from_client(CloudflareClientFactory.new(token), account_id, gateway_id)
+
+
+__all__ = [
+    "AiGatewayClient",
+    "AiGatewayClientFactory",
+    "EndDate",
+    "LogRecord",
+    "LogsOrderBy",
+    "LogsQuery",
+    "StartDate",
+]

fluidattacks_cloudflare_sdk/ai_gateway/_client.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from cloudflare import NOT_GIVEN
+from fa_purity import Cmd, FrozenList, Result, ResultE, Unsafe, cast_exception
+
+from fluidattacks_cloudflare_sdk.ai_gateway._decode import decode_log
+from fluidattacks_cloudflare_sdk.ai_gateway.core import (
+    LogRecord,
+    LogsOrderBy,
+    LogsQuery,
+)
+
+if TYPE_CHECKING:
+    from fluidattacks_cloudflare_sdk._client import Client
+    from fluidattacks_cloudflare_sdk.core import AccountId, GatewayId
+
+LOG = logging.getLogger(__name__)
+
+
+def list_logs(
+    cloudflare: Client,
+    account_id: AccountId,
+    gateway_id: GatewayId,
+    query: LogsQuery,
+) -> Cmd[ResultE[FrozenList[LogRecord]]]:
+    _order = query.order_by.value_or(LogsOrderBy.default())
+    _start = query.start.map(lambda s: s.raw.date_time.strftime("%Y-%m-%dT%H:%M:%SZ")).value_or(
+        NOT_GIVEN
+    )
+    _end = query.end.map(lambda e: e.raw.date_time.strftime("%Y-%m-%dT%H:%M:%SZ")).value_or(
+        NOT_GIVEN
+    )
+
+    def _action() -> ResultE[FrozenList[LogRecord]]:
+        try:
+            LOG.info("fetching ai gateway logs for gateway %s", gateway_id.raw)
+            first_page = cloudflare.client.ai_gateway.logs.list(
+                gateway_id.raw,
+                account_id=account_id.raw,
+                start_date=_start,
+                end_date=_end,
+                order_by=_order.field,
+                order_by_direction=_order.direction,
+            )
+            items: list[LogRecord] = []
+            for page in first_page.iter_pages():
+                page_records = page.result
+                items.extend(
+                    decode_log(raw).alt(Unsafe.raise_exception).to_union() for raw in page_records
+                )
+                LOG.info(
+                    "page fetched: %d records (%d total so far)",
+                    len(page_records),
+                    len(items),
+                )
+            LOG.info(
+                "finished: %d log records from gateway %s",
+                len(items),
+                gateway_id.raw,
+            )
+            return Result.success(tuple(items))
+        except Exception as err:
+            LOG.exception("failed to fetch ai gateway logs")
+            return Result.failure(err, FrozenList[LogRecord]).alt(cast_exception)
+
+    return Cmd.wrap_impure(_action)

fluidattacks_cloudflare_sdk/ai_gateway/_decode.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from fa_purity import Maybe
+from fa_purity.date_time import DatetimeUTC
+
+from fluidattacks_cloudflare_sdk.ai_gateway.core import LogRecord
+
+if TYPE_CHECKING:
+    from cloudflare.types.ai_gateway import LogListResponse
+    from fa_purity import ResultE
+
+
+def decode_log(raw: LogListResponse) -> ResultE[LogRecord]:
+    return DatetimeUTC.assert_utc(raw.created_at).map(
+        lambda created_at: LogRecord(
+            id=raw.id,
+            cached=raw.cached,
+            created_at=created_at,
+            duration=raw.duration,
+            model=raw.model,
+            path=raw.path,
+            provider=raw.provider,
+            success=raw.success,
+            tokens_in=Maybe.from_optional(raw.tokens_in),
+            tokens_out=Maybe.from_optional(raw.tokens_out),
+            cost=Maybe.from_optional(raw.cost),
+            custom_cost=Maybe.from_optional(raw.custom_cost),
+            metadata=Maybe.from_optional(raw.metadata),
+            model_type=Maybe.from_optional(raw.ai_model_type),
+            request_content_type=Maybe.from_optional(raw.request_content_type),
+            request_type=Maybe.from_optional(raw.request_type),
+            response_content_type=Maybe.from_optional(raw.response_content_type),
+            status_code=Maybe.from_optional(raw.status_code),
+            step=Maybe.from_optional(raw.step),
+        )
+    )

fluidattacks_cloudflare_sdk/ai_gateway/core.py

@@ -0,0 +1,98 @@
+"""Domain types and client interface for the Cloudflare AI Gateway resource."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from fa_purity import Maybe
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from fa_purity import Cmd, FrozenList, ResultE
+    from fa_purity.date_time import DatetimeUTC
+
+
+LogsOrderByField = Literal["created_at", "provider", "model", "model_type", "success", "cached"]
+LogsOrderByDirection = Literal["asc", "desc"]
+
+
+@dataclass(frozen=True)
+class StartDate:
+    """Inclusive lower bound for AI Gateway log queries."""
+
+    raw: DatetimeUTC
+
+
+@dataclass(frozen=True)
+class EndDate:
+    """Exclusive upper bound for AI Gateway log queries."""
+
+    raw: DatetimeUTC
+
+
+@dataclass(frozen=True)
+class LogsOrderBy:
+    """Ordering configuration for AI Gateway log queries."""
+
+    field: LogsOrderByField
+    direction: LogsOrderByDirection
+
+    @staticmethod
+    def default() -> LogsOrderBy:
+        """Default ordering: created_at ascending."""
+        return LogsOrderBy(field="created_at", direction="asc")
+
+
+@dataclass(frozen=True)
+class LogsQuery:
+    """Filter and ordering options for AI Gateway log queries."""
+
+    start: Maybe[StartDate]
+    end: Maybe[EndDate]
+    order_by: Maybe[LogsOrderBy]
+
+    @staticmethod
+    def all() -> LogsQuery:
+        """Query with no filters and default ordering."""
+        return LogsQuery(
+            start=Maybe.empty(),
+            end=Maybe.empty(),
+            order_by=Maybe.some(LogsOrderBy.default()),
+        )
+
+
+@dataclass(frozen=True)
+class LogRecord:
+    """A single AI Gateway request log entry."""
+
+    id: str
+    cached: bool
+    created_at: DatetimeUTC
+    duration: int
+    model: str
+    path: str
+    provider: str
+    success: bool
+    tokens_in: Maybe[int]
+    tokens_out: Maybe[int]
+    cost: Maybe[float]
+    custom_cost: Maybe[bool]
+    metadata: Maybe[str]
+    model_type: Maybe[str]
+    request_content_type: Maybe[str]
+    request_type: Maybe[str]
+    response_content_type: Maybe[str]
+    status_code: Maybe[int]
+    step: Maybe[int]
+
+
+@dataclass(frozen=True)
+class AiGatewayClient:
+    """Interface for Cloudflare AI Gateway operations."""
+
+    list_logs: Callable[
+        [LogsQuery],
+        Cmd[ResultE[FrozenList[LogRecord]]],
+    ]

fluidattacks_cloudflare_sdk/core.py

@@ -0,0 +1,19 @@
+"""Shared identifiers for the Cloudflare SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class AccountId:
+    """Cloudflare account identifier."""
+
+    raw: str
+
+
+@dataclass(frozen=True)
+class GatewayId:
+    """Cloudflare AI Gateway identifier."""
+
+    raw: str

fluidattacks_cloudflare_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: fluidattacks_cloudflare_sdk
+Version: 0.1.0
+Summary: cloudflare SDK
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Requires-Dist: cloudflare >=4.0.0, <5.0.0
+Requires-Dist: fa-purity >=2.5.0, <3.0.0
+Requires-Dist: fluidattacks-etl-utils >=4.0.0, <5.0.0
+Requires-Dist: fluidattacks-utils-logger >=3.0.0, <4.0.0

fluidattacks_cloudflare_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fluidattacks_cloudflare_sdk/__init__.py,sha256=KL6tU7dsWVlnUGTHSKjA1ShqunAoj7xfWQdClzAileM,394
+fluidattacks_cloudflare_sdk/_logger.py,sha256=VT7XgefbXm816YCaqhFinc9jQ4YdBlEgGmuwiRblctA,770
+fluidattacks_cloudflare_sdk/core.py,sha256=Xx23kBk89CWNwujUG0WWJVI4rqujjdoAHNCfYIxxEt4,319
+fluidattacks_cloudflare_sdk/_client/__init__.py,sha256=v9RbjQM0J-1ep1mn5PS4p3QyZ-iYFQCA2gays0uqNOw,542
+fluidattacks_cloudflare_sdk/_client/_client.py,sha256=aVXCWrnHfEV85TEPqm1BCJk9HQd7sdf54knQn2EwGCM,796
+fluidattacks_cloudflare_sdk/_client/_core.py,sha256=0bL4mzNG5AASbaGWHukHiam1bsZFR_hOIIzy5qWHEgM,441
+fluidattacks_cloudflare_sdk/ai_gateway/__init__.py,sha256=EeS4VE96M3_eUmnJ4zPLIduVHx_odt9Ay_RbzTi6kAc,1390
+fluidattacks_cloudflare_sdk/ai_gateway/_client.py,sha256=27YwWF48d5rLUsuZtSZfaS-jsYLCGuQRcLnCeT-YrIk,2351
+fluidattacks_cloudflare_sdk/ai_gateway/_decode.py,sha256=JGq2pI5nlQ_WzsXAULqcMleHiNLlLjiG209Q_W1WiDU,1424
+fluidattacks_cloudflare_sdk/ai_gateway/core.py,sha256=E8deYCxjnxjU1dqy5iyQ8ndIeNwzAxnZGBW2bUOhzIo,2321
+fluidattacks_cloudflare_sdk-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+fluidattacks_cloudflare_sdk-0.1.0.dist-info/METADATA,sha256=9RnmbIMJ_K4yAHl75E8XF_1LpKmYL2Ws-RP6RoUljFk,371
+fluidattacks_cloudflare_sdk-0.1.0.dist-info/RECORD,,

fluidattacks_cloudflare_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any