foldset-fastapi 0.1.0__tar.gz

foldset_fastapi-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Dependencies
+node_modules
+.pnpm-store
+
+# Build outputs
+dist
+# TODO: Remove these exceptions once packages are published to npm.
+# Currently committing dist/ because Vercel doesn't run prepare scripts
+# for git dependencies properly.
+!packages/typescript/nextjs/dist
+!packages/typescript/core/dist
+build
+.next
+out
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Debug logs
+npm-debug.log*
+pnpm-debug.log*
+
+# TypeScript
+*.tsbuildinfo
+
+# Misc
+*.log
+.cache

foldset_fastapi-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: foldset-fastapi
+Version: 0.1.0
+Summary: FastAPI middleware for Foldset payment gating
+Project-URL: Homepage, https://foldset.com
+Project-URL: Documentation, https://docs.foldset.com
+Project-URL: Repository, https://github.com/foldset/sdks
+Author-email: Foldset <team@foldset.com>
+License-Expression: MIT
+Keywords: agents,ai,fastapi,foldset,micropayments,middleware
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: foldset>=0.1.0
+Requires-Dist: starlette>=0.27.0

foldset_fastapi-0.1.0/foldset_fastapi/__init__.py

@@ -0,0 +1,4 @@
+from .middleware import FoldsetMiddleware
+from foldset.types import FoldsetOptions
+
+__all__ = ["FoldsetMiddleware", "FoldsetOptions"]

foldset_fastapi-0.1.0/foldset_fastapi/adapter.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+from foldset.types import RequestAdapter
+from starlette.requests import Request
+
+
+class FastAPIAdapter(RequestAdapter):
+    def __init__(self, request: Request) -> None:
+        self._request = request
+        self._body: Any | None = None
+
+    def get_ip_address(self) -> str | None:
+        forwarded = self.get_header("x-forwarded-for")
+        if forwarded:
+            return forwarded.split(",")[0].strip()
+        if self._request.client:
+            return self._request.client.host
+        return None
+
+    def get_header(self, name: str) -> str | None:
+        return self._request.headers.get(name)
+
+    def get_method(self) -> str:
+        return self._request.method
+
+    def get_path(self) -> str:
+        return self._request.url.path
+
+    def get_url(self) -> str:
+        return str(self._request.url)
+
+    def get_host(self) -> str:
+        return self._request.url.hostname or ""
+
+    def get_accept_header(self) -> str:
+        return self.get_header("accept") or ""
+
+    def get_user_agent(self) -> str:
+        return self.get_header("user-agent") or ""
+
+    def get_query_params(self) -> dict[str, str | list[str]] | None:
+        result: dict[str, str | list[str]] = {}
+        for key, value in self._request.query_params.multi_items():
+            existing = result.get(key)
+            if existing is None:
+                result[key] = value
+            elif isinstance(existing, list):
+                existing.append(value)
+            else:
+                result[key] = [existing, value]
+        return result
+
+    def get_query_param(self, name: str) -> str | list[str] | None:
+        params = self.get_query_params()
+        if params:
+            return params.get(name)
+        return None
+
+    async def get_body(self) -> Any:
+        if self._body is None:
+            try:
+                self._body = await self._request.json()
+            except Exception:
+                self._body = None
+        return self._body

foldset_fastapi-0.1.0/foldset_fastapi/middleware.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from foldset import WorkerCore, report_error
+from foldset.types import FoldsetOptions
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+
+from .adapter import FastAPIAdapter
+
+from importlib.metadata import version as _pkg_version
+
+PACKAGE_VERSION = _pkg_version("foldset-fastapi")
+
+
+def _set_headers(response: Response, headers: dict[str, str]) -> None:
+    for key, value in headers.items():
+        response.headers[key] = value
+
+
+class FoldsetMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app: Any, options: FoldsetOptions) -> None:
+        super().__init__(app)
+        self._options = FoldsetOptions(
+            api_key=options.api_key,
+            redis_credentials=options.redis_credentials,
+            platform="fastapi",
+            sdk_version=PACKAGE_VERSION,
+        )
+        self._disabled = not options.api_key
+        if self._disabled:
+            import warnings
+            warnings.warn("[foldset] No API key provided, middleware disabled")
+
+    async def dispatch(
+        self, request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        if self._disabled:
+            return await call_next(request)
+
+        try:
+            core = await WorkerCore.from_options(self._options)
+            adapter = FastAPIAdapter(request)
+            result = await core.process_request(adapter)
+
+            if result.type == "health-check":
+                response = Response(
+                    content=result.response.body,
+                    status_code=result.response.status,
+                    media_type="application/json",
+                )
+                _set_headers(response, result.response.headers)
+                return response
+
+            if result.type == "no-payment-required":
+                response = await call_next(request)
+                if result.headers:
+                    _set_headers(response, result.headers)
+                return response
+
+            if result.type == "payment-error":
+                response = Response(
+                    content=result.response.body,
+                    status_code=result.response.status,
+                )
+                _set_headers(response, result.response.headers)
+                return response
+
+            if result.type == "payment-verified":
+                response = await call_next(request)
+
+                settlement = await core.process_settlement(
+                    adapter,
+                    result.payment_payload,
+                    result.payment_requirements,
+                    response.status_code,
+                    result.metadata.request_id,
+                )
+
+                if settlement.success:
+                    _set_headers(response, settlement.headers)
+                else:
+                    response = Response(
+                        content=json.dumps({
+                            "error": "Settlement failed",
+                            "details": settlement.error_reason,
+                        }),
+                        status_code=402,
+                        media_type="application/json",
+                    )
+
+                return response
+
+        except Exception as error:
+            # On any error, allow the request through rather than blocking the user.
+            await report_error(self._options.api_key, error, FastAPIAdapter(request))
+            return await call_next(request)
+
+        return await call_next(request)

foldset_fastapi-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "foldset-fastapi"
+version = "0.1.0"
+description = "FastAPI middleware for Foldset payment gating"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "Foldset", email = "team@foldset.com" }]
+keywords = ["foldset", "fastapi", "middleware", "micropayments", "ai", "agents"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Framework :: FastAPI",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+dependencies = [
+    "foldset>=0.1.0",
+    "fastapi>=0.100.0",
+    "starlette>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://foldset.com"
+Documentation = "https://docs.foldset.com"
+Repository = "https://github.com/foldset/sdks"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["foldset_fastapi"]