interloper-api 0.22.0__tar.gz → 0.23.0__tar.gz

{interloper_api-0.22.0 → interloper_api-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: interloper-api
-Version: 0.22.0
+Version: 0.23.0
 Summary: Interloper FastAPI routes
 Author: Guillaume Onfroy
 Author-email: Guillaume Onfroy <guillaume@digitlcloud.com>

{interloper_api-0.22.0 → interloper_api-0.23.0}/pyproject.toml

@@ -3,7 +3,7 @@
 # ###############
 [project]
 name = "interloper-api"
-version = "0.22.0"
+version = "0.23.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 authors = [{ name = "Guillaume Onfroy", email = "guillaume@digitlcloud.com" }]

{interloper_api-0.22.0 → interloper_api-0.23.0}/src/interloper_api/dependencies.py

@@ -63,18 +63,20 @@ def get_store() -> Store:
     return _store
 
 
-def get_catalog() -> dict[str, Any]:
-    """Return the global catalog as a serialized dict.
+def get_catalog() -> Catalog:
+    """Return the global ``Catalog`` instance.
+
+    Routes that need the serialized form call ``.dump()`` themselves.
 
     Returns:
-        Mapping from component key to serialized definition.
+        The Catalog instance.
 
     Raises:
         RuntimeError: If the catalog has not been set.
     """
     if _catalog is None:
         raise RuntimeError("Catalog not initialized. Call set_catalog() first.")
-    return _catalog.dump()
+    return _catalog
 
 
 def get_auth_config() -> Any:

{interloper_api-0.22.0 → interloper_api-0.23.0}/src/interloper_api/routes/catalog.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 from typing import Any
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException
+from interloper.catalog.base import Catalog
 
 from interloper_api.dependencies import get_catalog
 
@@ -12,13 +13,13 @@ router = APIRouter()
 
 
 @router.get("/")
-def list_catalog(catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+def list_catalog(catalog: Catalog = Depends(get_catalog)) -> dict[str, Any]:
     """Return the full catalog."""
-    return catalog
+    return catalog.dump()
 
 
 @router.get("/{key}")
-def get_definition(key: str, catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+def get_definition(key: str, catalog: Catalog = Depends(get_catalog)) -> dict[str, Any]:
     """Return a single component definition by key.
 
     Args:
@@ -28,19 +29,18 @@ def get_definition(key: str, catalog: dict[str, Any] = Depends(get_catalog)) ->
     Raises:
         HTTPException: If the key is not found.
     """
-    from fastapi import HTTPException
-
-    if key not in catalog:
+    defn = catalog.get(key)
+    if defn is None:
         raise HTTPException(status_code=404, detail=f"Component '{key}' not found in catalog")
-    return catalog[key]
+    return defn.model_dump(mode="json")
 
 
 @router.get("/kind/{kind}")
-def list_by_kind(kind: str, catalog: dict[str, Any] = Depends(get_catalog)) -> dict[str, Any]:
+def list_by_kind(kind: str, catalog: Catalog = Depends(get_catalog)) -> dict[str, Any]:
     """Return all catalog entries matching a kind (source, asset, resource, destination).
 
     Args:
         kind: The component kind to filter by.
         catalog: Injected catalog.
     """
-    return {k: v for k, v in catalog.items() if v.get("kind") == kind}
+    return {k: v.model_dump(mode="json") for k, v in catalog.components.items() if v.kind == kind}

interloper_api-0.23.0/src/interloper_api/routes/external/__init__.py

@@ -0,0 +1,40 @@
+"""External provider API routes.
+
+FetchField options are resolved by a single generic endpoint (``resolve``);
+there are no per-provider routes. Each connector exposes its lookups as
+``@fetch_field_provider`` methods on its connection class, which the resolver calls.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+from fastapi import APIRouter, HTTPException
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def handle_error(error: Exception, context: str) -> None:
+    """Map external API errors to appropriate HTTP responses."""
+    logger.error("Error %s: %s", context, error)
+
+    if isinstance(error, httpx.HTTPStatusError):
+        status = error.response.status_code
+        if status in (401, 403):
+            raise HTTPException(status_code=status, detail=f"Authorization failed while {context}.")
+        if status == 404:
+            raise HTTPException(status_code=404, detail=f"Resource not found while {context}.")
+
+    if isinstance(error, HTTPException):
+        raise error
+
+    raise HTTPException(status_code=500, detail=f"Failed {context}.")
+
+
+# Import and register the resolver after helpers are defined.
+from interloper_api.routes.external.resolve import sub_router as resolve_router  # noqa: E402
+
+router.include_router(resolve_router)

interloper_api-0.23.0/src/interloper_api/routes/external/resolve.py

@@ -0,0 +1,88 @@
+"""Generic FetchField resolver.
+
+Replaces the hand-written per-provider ``/external/<provider>/<x>`` routes
+for fields declared with ``FetchField(provider="<slot>.<method>")``. One
+endpoint resolves any such field by:
+
+1. Looking up the component definition in the catalog (authoritative — the
+   provider reference comes from the server's schema, never the client).
+2. Importing the component class and reading the resource class in ``<slot>``.
+3. Instantiating that resource from the credentials the form already holds.
+4. Calling the ``@fetch_field_provider`` method ``<method>`` on it.
+
+The ``@fetch_field_provider`` marker is the allowlist: only methods opted in that
+way may be invoked, so the browser cannot call arbitrary attributes.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from interloper.catalog.base import Catalog
+from interloper.resource.fields import is_fetch_field_provider
+from interloper.utils.concurrency import invoke
+from interloper.utils.imports import import_from_path
+from interloper_db import Profile
+from pydantic import BaseModel
+
+from interloper_api.dependencies import get_catalog, require_viewer
+from interloper_api.routes.external import handle_error
+
+sub_router = APIRouter()
+
+
+class ResolveRequest(BaseModel):
+    """A request to resolve one provider-backed FetchField's options."""
+
+    component_key: str
+    field: str
+    # Credentials per resource slot, e.g. {"connection": {"access_token": ...}}.
+    deps: dict[str, dict[str, Any]] = {}
+
+
+@sub_router.post("/resolve")
+async def resolve_fetch_field(
+    body: ResolveRequest,
+    catalog: Catalog = Depends(get_catalog),
+    _user: Profile = Depends(require_viewer),
+) -> list[dict[str, Any]]:
+    """Resolve the options for a ``FetchField(provider=...)`` field."""
+    defn = catalog.get(body.component_key)
+    if defn is None:
+        raise HTTPException(status_code=404, detail=f"Unknown component '{body.component_key}'")
+
+    # Read the provider from the server's own schema, so the client cannot
+    # redirect the call to an arbitrary method.
+    prop = getattr(defn, "config_schema", {}).get("properties", {}).get(body.field, {})
+    provider = prop.get("x-fetch", {}).get("provider")
+    if not provider:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Field '{body.field}' on '{body.component_key}' is not a provider-backed FetchField",
+        )
+    slot, _, method = str(provider).partition(".")
+
+    component_cls = import_from_path(defn.path)
+    resource_cls = getattr(component_cls, "resource_types", {}).get(slot)
+    if resource_cls is None:
+        raise HTTPException(status_code=400, detail=f"Resource slot '{slot}' not found on '{body.component_key}'")
+
+    # Only pass through fields the resource actually declares — the form may
+    # carry extra markers (e.g. an internal id) that the model would reject.
+    raw = body.deps.get(slot, {})
+    creds = {k: v for k, v in raw.items() if k in resource_cls.model_fields}
+    resource = resource_cls(**creds)
+
+    fn = getattr(resource, method, None)
+    if not is_fetch_field_provider(fn):
+        # Should never happen — validated at catalog build — but guard anyway.
+        raise HTTPException(status_code=403, detail=f"'{provider}' is not a fetch provider")
+    assert fn is not None  # narrowed by the is_fetch_field_provider guard above
+
+    try:
+        result = await invoke(fn)
+    except Exception as exc:
+        handle_error(exc, f"resolving {body.component_key}.{body.field}")
+        return []
+    return list(result or [])

{interloper_api-0.22.0 → interloper_api-0.23.0}/src/interloper_api/routes/resources.py

@@ -6,6 +6,7 @@ from typing import Any
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
+from interloper.catalog.base import Catalog
 from interloper.errors import NotFoundError
 from interloper_db import Profile, Store
 from interloper_db.models import Resource
@@ -84,7 +85,7 @@ def _load_authorized_resource(resource_id: UUID, user: Profile, store: Store, *,
 
 @router.get("/kinds")
 def list_resource_kinds(
-    catalog: dict[str, Any] = Depends(get_catalog),
+    catalog: Catalog = Depends(get_catalog),
 ) -> list[str]:
     """Return distinct resource kinds from the catalog.
 
@@ -92,7 +93,7 @@ def list_resource_kinds(
     (source, asset, destination). Currently this yields kinds like
     ``connection`` and ``config``.
     """
-    kinds = {defn["kind"] for defn in catalog.values() if defn.get("kind") and defn["kind"] not in _NON_RESOURCE_KINDS}
+    kinds = {defn.kind for defn in catalog.components.values() if defn.kind and defn.kind not in _NON_RESOURCE_KINDS}
     return sorted(kinds)
 
 

interloper_api-0.22.0/src/interloper_api/routes/external/__init__.py

@@ -1,56 +0,0 @@
-"""External provider API routes for FetchField resolution.
-
-Each submodule contains routes for a specific external provider.
-The combined ``router`` is re-exported here so ``app.py`` can
-import it unchanged.
-"""
-
-from __future__ import annotations
-
-import logging
-
-import httpx
-from fastapi import APIRouter, HTTPException
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-
-def handle_error(error: Exception, context: str) -> None:
-    """Map external API errors to appropriate HTTP responses."""
-    logger.error("Error %s: %s", context, error)
-
-    if isinstance(error, httpx.HTTPStatusError):
-        status = error.response.status_code
-        if status in (401, 403):
-            raise HTTPException(status_code=status, detail=f"Authorization failed while {context}.")
-        if status == 404:
-            raise HTTPException(status_code=404, detail=f"Resource not found while {context}.")
-
-    if isinstance(error, HTTPException):
-        raise error
-
-    raise HTTPException(status_code=500, detail=f"Failed {context}.")
-
-
-# Import and register sub-routers after helpers are defined.
-from interloper_api.routes.external.amazon_ads import sub_router as amazon_ads_router  # noqa: E402
-from interloper_api.routes.external.criteo import sub_router as criteo_router  # noqa: E402
-from interloper_api.routes.external.facebook_ads import sub_router as facebook_ads_router  # noqa: E402
-from interloper_api.routes.external.google_ads import sub_router as google_ads_router  # noqa: E402
-from interloper_api.routes.external.google_cloud import sub_router as google_cloud_router  # noqa: E402
-from interloper_api.routes.external.impact import sub_router as impact_router  # noqa: E402
-from interloper_api.routes.external.pinterest_ads import sub_router as pinterest_ads_router  # noqa: E402
-from interloper_api.routes.external.snapchat_ads import sub_router as snapchat_ads_router  # noqa: E402
-from interloper_api.routes.external.tiktok_ads import sub_router as tiktok_ads_router  # noqa: E402
-
-router.include_router(amazon_ads_router)
-router.include_router(criteo_router)
-router.include_router(facebook_ads_router)
-router.include_router(google_ads_router)
-router.include_router(google_cloud_router)
-router.include_router(impact_router)
-router.include_router(pinterest_ads_router)
-router.include_router(snapchat_ads_router)
-router.include_router(tiktok_ads_router)

interloper_api-0.22.0/src/interloper_api/routes/external/amazon_ads.py

@@ -1,82 +0,0 @@
-"""Amazon Ads external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_API_URLS: dict[str, str] = {
-    "EU": "https://advertising-api-eu.amazon.com",
-    "FE": "https://advertising-api-fe.amazon.com",
-    "NA": "https://advertising-api.amazon.com",
-}
-
-_AUTH_URLS: dict[str, str] = {
-    "EU": "https://api.amazon.co.uk",
-    "FE": "https://api.amazon.co.jp",
-    "NA": "https://api.amazon.com",
-}
-
-
-class AmazonAdsConnectionRequest(BaseModel):
-    """Amazon Ads connection credentials (matches AmazonAdsConnection fields)."""
-
-    location: str = "NA"
-    client_id: str
-    client_secret: str
-    refresh_token: str
-
-
-@sub_router.post("/amazon-ads/profiles")
-async def amazon_ads_profiles(
-    body: AmazonAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Amazon Ads advertising profiles for a connection."""
-    api_url = _API_URLS.get(body.location, _API_URLS["NA"])
-    auth_url = _AUTH_URLS.get(body.location, _AUTH_URLS["NA"])
-
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            token_resp = await client.post(
-                f"{auth_url}/auth/o2/token",
-                data={
-                    "grant_type": "refresh_token",
-                    "refresh_token": body.refresh_token,
-                    "client_id": body.client_id,
-                    "client_secret": body.client_secret,
-                },
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-            )
-            token_resp.raise_for_status()
-            access_token = token_resp.json()["access_token"]
-
-            profiles_resp = await client.get(
-                f"{api_url}/v2/profiles",
-                headers={
-                    "Authorization": f"Bearer {access_token}",
-                    "Amazon-Advertising-API-ClientId": body.client_id,
-                },
-            )
-            profiles_resp.raise_for_status()
-            profiles = profiles_resp.json()
-
-        return [
-            {
-                "profile_id": str(p["profileId"]),
-                "name": f"{p['accountInfo']['name']} ({p['countryCode']})",
-                "account_id": p["accountInfo"]["id"],
-                "country_code": p["countryCode"],
-            }
-            for p in profiles
-        ]
-    except Exception as exc:
-        handle_error(exc, "fetching Amazon Ads profiles")
-        return []  # unreachable, but satisfies type checker

interloper_api-0.22.0/src/interloper_api/routes/external/criteo.py

@@ -1,68 +0,0 @@
-"""Criteo external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://api.criteo.com"
-_TOKEN_URL = f"{_BASE_URL}/oauth2/token"
-_ADVERTISERS_URL = f"{_BASE_URL}/2025-04/advertisers/me"
-
-
-class CriteoConnectionRequest(BaseModel):
-    """Criteo connection credentials (matches CriteoConnection fields)."""
-
-    client_id: str
-    client_secret: str
-    refresh_token: str
-
-
-async def _get_access_token(client: httpx.AsyncClient, body: CriteoConnectionRequest) -> str:
-    """Exchange the refresh token for an access token."""
-    resp = await client.post(
-        _TOKEN_URL,
-        data={
-            "grant_type": "refresh_token",
-            "client_id": body.client_id,
-            "client_secret": body.client_secret,
-            "refresh_token": body.refresh_token,
-        },
-    )
-    resp.raise_for_status()
-    return resp.json()["access_token"]
-
-
-async def _list_advertisers(client: httpx.AsyncClient, body: CriteoConnectionRequest) -> list[dict[str, str]]:
-    """List the advertisers the connection can access, sorted by name."""
-    token = await _get_access_token(client, body)
-    resp = await client.get(_ADVERTISERS_URL, headers={"Authorization": f"Bearer {token}"})
-    resp.raise_for_status()
-
-    advertisers = resp.json().get("data", [])
-    results = [
-        {"id": a["id"], "name": a.get("attributes", {}).get("advertiserName") or a["id"]}
-        for a in advertisers
-    ]
-    return sorted(results, key=lambda a: a["name"].lower())
-
-
-@sub_router.post("/criteo/advertisers")
-async def criteo_advertisers(
-    body: CriteoConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch the Criteo advertisers accessible by the connection."""
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            return await _list_advertisers(client, body)
-    except Exception as exc:
-        handle_error(exc, "fetching Criteo advertisers")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/facebook_ads.py

@@ -1,55 +0,0 @@
-"""Facebook Ads external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://graph.facebook.com/v21.0"
-
-
-class FacebookAdsConnectionRequest(BaseModel):
-    """Facebook Ads connection credentials (matches FacebookAdsConnection fields)."""
-
-    access_token: str
-    app_id: str = ""
-    app_secret: str = ""
-
-
-@sub_router.post("/facebook-ads/accounts")
-async def facebook_ads_accounts(
-    body: FacebookAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Facebook Ads ad accounts accessible by the connection."""
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            resp = await client.get(
-                f"{_BASE_URL}/me/adaccounts",
-                params={
-                    "access_token": body.access_token,
-                    "fields": "account_id,name,account_status",
-                    "limit": "500",
-                },
-            )
-            resp.raise_for_status()
-            data = resp.json().get("data", [])
-
-        return [
-            {
-                "account_id": acct["account_id"],
-                "name": f"{acct.get('name', acct['account_id'])}",
-            }
-            for acct in data
-            if acct.get("account_status") == 1  # ACTIVE only
-        ]
-    except Exception as exc:
-        handle_error(exc, "fetching Facebook Ads accounts")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/google_ads.py

@@ -1,104 +0,0 @@
-"""Google Ads external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_TOKEN_URL = "https://oauth2.googleapis.com/token"
-_BASE_URL = "https://googleads.googleapis.com/v20"
-
-
-class GoogleAdsConnectionRequest(BaseModel):
-    """Google Ads connection credentials (matches GoogleAdsConnection fields)."""
-
-    client_id: str
-    client_secret: str
-    developer_token: str
-    refresh_token: str
-
-
-async def _get_access_token(client: httpx.AsyncClient, body: GoogleAdsConnectionRequest) -> str:
-    """Exchange the refresh token for an access token."""
-    resp = await client.post(
-        _TOKEN_URL,
-        data={
-            "grant_type": "refresh_token",
-            "refresh_token": body.refresh_token,
-            "client_id": body.client_id,
-            "client_secret": body.client_secret,
-        },
-    )
-    resp.raise_for_status()
-    return resp.json()["access_token"]
-
-
-def _auth_headers(access_token: str, developer_token: str) -> dict[str, str]:
-    return {
-        "Authorization": f"Bearer {access_token}",
-        "developer-token": developer_token,
-    }
-
-
-@sub_router.post("/google-ads/customers")
-async def google_ads_customers(
-    body: GoogleAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Google Ads customer accounts accessible by the connection."""
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            access_token = await _get_access_token(client, body)
-            headers = _auth_headers(access_token, body.developer_token)
-
-            # Step 1: List accessible customer resource names.
-            list_resp = await client.get(
-                f"{_BASE_URL}/customers:listAccessibleCustomers",
-                headers=headers,
-            )
-            list_resp.raise_for_status()
-            resource_names: list[str] = list_resp.json().get("resourceNames", [])
-
-            # Step 2: Fetch descriptive name for each customer.
-            results: list[dict[str, str]] = []
-            for rn in resource_names:
-                # rn is like "customers/1234567890"
-                customer_id = rn.split("/")[-1]
-                query = (
-                    "SELECT customer.id, customer.descriptive_name, customer.status "
-                    "FROM customer LIMIT 1"
-                )
-                try:
-                    search_resp = await client.post(
-                        f"{_BASE_URL}/{rn}/googleAds:searchStream",
-                        headers=headers,
-                        json={"query": query},
-                    )
-                    search_resp.raise_for_status()
-                    batches = search_resp.json()
-                    for batch in batches:
-                        for row in batch.get("results", []):
-                            customer = row.get("customer", {})
-                            name = customer.get("descriptiveName", customer_id)
-                            results.append({
-                                "customer_id": customer_id,
-                                "name": f"{name} ({customer_id})",
-                            })
-                except httpx.HTTPStatusError:
-                    # Some customers may not be queryable (suspended, etc.)
-                    results.append({
-                        "customer_id": customer_id,
-                        "name": customer_id,
-                    })
-
-        return results
-    except Exception as exc:
-        handle_error(exc, "fetching Google Ads customers")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/google_cloud.py

@@ -1,167 +0,0 @@
-"""Google Cloud external API routes."""
-
-from __future__ import annotations
-
-import json
-import time
-from typing import Any
-
-import httpx
-from fastapi import APIRouter, Depends, HTTPException
-from google.auth import crypt, jwt
-from interloper_db import Profile
-from pydantic import BaseModel, field_validator
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_TOKEN_URL = "https://oauth2.googleapis.com/token"
-# BigQuery's own projects.list: returns the projects the credential holds a
-# BigQuery role on -- exactly the candidates for a BigQuery destination --
-# and only requires the BigQuery API, which is necessarily enabled wherever
-# the destination can work (unlike the Cloud Resource Manager API, which is
-# frequently disabled).
-_PROJECTS_URL = "https://bigquery.googleapis.com/bigquery/v2/projects"
-_SCOPE = "https://www.googleapis.com/auth/bigquery.readonly"
-
-
-class GoogleCloudConnectionRequest(BaseModel):
-    """Google Cloud connection credentials (matches GoogleCloudConnection fields)."""
-
-    service_account_key: str
-
-    @field_validator("service_account_key", mode="before")
-    @classmethod
-    def _serialize_key(cls, v: object) -> object:
-        if isinstance(v, dict):
-            return json.dumps(v)
-        return v
-
-    @property
-    def key_info(self) -> dict[str, Any]:
-        """The parsed service account key.
-
-        Returns:
-            The key as a dict.
-
-        Raises:
-            HTTPException: If the key is not valid JSON.
-        """
-        try:
-            return json.loads(self.service_account_key)
-        except json.JSONDecodeError:
-            raise HTTPException(status_code=400, detail="service_account_key is not valid JSON.")
-
-
-def _make_assertion(key_info: dict[str, Any]) -> str:
-    """Build a signed JWT-bearer assertion for the service account.
-
-    Only the signing comes from google-auth; the token exchange itself goes
-    through httpx like every other external route.
-
-    Args:
-        key_info: The parsed service account key.
-
-    Returns:
-        The signed JWT assertion.
-    """
-    signer = crypt.RSASigner.from_service_account_info(key_info)
-    now = int(time.time())
-    payload = {
-        "iss": key_info["client_email"],
-        "scope": _SCOPE,
-        "aud": _TOKEN_URL,
-        "iat": now,
-        "exp": now + 600,
-    }
-    return jwt.encode(signer, payload).decode()
-
-
-async def _get_access_token(client: httpx.AsyncClient, key_info: dict[str, Any]) -> str:
-    """Exchange a service account JWT assertion for an access token."""
-    resp = await client.post(
-        _TOKEN_URL,
-        data={
-            "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
-            "assertion": _make_assertion(key_info),
-        },
-    )
-    resp.raise_for_status()
-    return resp.json()["access_token"]
-
-
-async def _list_projects(client: httpx.AsyncClient, access_token: str) -> list[dict[str, str]]:
-    """List the projects the credential has BigQuery access to, following pagination.
-
-    Returns:
-        Project options with ``project_id`` and a display ``name``.
-    """
-    results: list[dict[str, str]] = []
-    page_token: str | None = None
-    while True:
-        params: dict[str, str] = {"maxResults": "500"}
-        if page_token:
-            params["pageToken"] = page_token
-        resp = await client.get(
-            _PROJECTS_URL,
-            params=params,
-            headers={"Authorization": f"Bearer {access_token}"},
-        )
-        resp.raise_for_status()
-        data = resp.json()
-        for project in data.get("projects", []):
-            project_id = project["id"]
-            name = project.get("friendlyName") or project_id
-            results.append({"project_id": project_id, "name": f"{name} ({project_id})"})
-        page_token = data.get("nextPageToken")
-        if not page_token:
-            break
-    return sorted(results, key=lambda p: p["name"].lower())
-
-
-def _upstream_detail(exc: httpx.HTTPStatusError) -> str:
-    """Extract the human-readable error message from a Google error response.
-
-    The token endpoint answers ``{"error": ..., "error_description": ...}``;
-    the Cloud Resource Manager answers ``{"error": {"message": ...}}``.
-
-    Returns:
-        Google's error message, or the raw body as a fallback.
-    """
-    try:
-        payload = exc.response.json()
-    except ValueError:
-        return exc.response.text[:200]
-    error = payload.get("error")
-    if isinstance(error, dict):
-        return str(error.get("message") or error)
-    description = payload.get("error_description")
-    return str(description or error or exc.response.text[:200])
-
-
-@sub_router.post("/google-cloud/projects")
-async def google_cloud_projects(
-    body: GoogleCloudConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch the Google Cloud projects accessible by the connection."""
-    key_info = body.key_info
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            access_token = await _get_access_token(client, key_info)
-            return await _list_projects(client, access_token)
-    except httpx.HTTPStatusError as exc:
-        # Surface Google's own message (e.g. "Cloud Resource Manager API has
-        # not been used in project ...", "Invalid JWT Signature.") so the
-        # form error is actionable, instead of the generic handle_error text.
-        status = exc.response.status_code
-        detail = _upstream_detail(exc)
-        raise HTTPException(
-            status_code=status if status in (401, 403, 404) else 502,
-            detail=f"Google Cloud error while fetching projects: {detail}",
-        )
-    except Exception as exc:
-        handle_error(exc, "fetching Google Cloud projects")
-        return []  # unreachable, but satisfies type checker

interloper_api-0.22.0/src/interloper_api/routes/external/impact.py

@@ -1,54 +0,0 @@
-"""Impact external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://api.impact.com"
-
-
-class ImpactConnectionRequest(BaseModel):
-    """Impact connection credentials (matches ImpactConnection fields)."""
-
-    account_sid: str
-    auth_token: str
-
-
-@sub_router.post("/impact/programs")
-async def impact_programs(
-    body: ImpactConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Impact programs (campaigns) accessible by the connection."""
-    try:
-        programs: list[dict[str, str]] = []
-        async with httpx.AsyncClient(
-            timeout=30,
-            auth=httpx.BasicAuth(body.account_sid, body.auth_token),
-            headers={"Accept": "application/json"},
-        ) as client:
-            page, num_pages = 1, 1
-            while page <= num_pages:
-                resp = await client.get(
-                    f"{_BASE_URL}/Advertisers/{body.account_sid}/Campaigns",
-                    params={"Page": page},
-                )
-                resp.raise_for_status()
-                data = resp.json()
-                num_pages = int(data["@numpages"])
-                for campaign in data.get("Campaigns", []):
-                    programs.append({"Id": campaign["Id"], "Name": campaign.get("Name", campaign["Id"])})
-                page += 1
-
-        return programs
-    except Exception as exc:
-        handle_error(exc, "fetching Impact programs")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/pinterest_ads.py

@@ -1,77 +0,0 @@
-"""Pinterest Ads external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://api.pinterest.com/v5"
-
-
-class PinterestAdsConnectionRequest(BaseModel):
-    """Pinterest Ads connection credentials (matches PinterestAdsConnection fields)."""
-
-    client_id: str
-    client_secret: str
-    refresh_token: str
-
-
-async def _get_access_token(body: PinterestAdsConnectionRequest) -> str:
-    """Exchange refresh token for an access token using HTTP Basic auth."""
-    async with httpx.AsyncClient(timeout=30) as client:
-        resp = await client.post(
-            f"{_BASE_URL}/oauth/token",
-            auth=(body.client_id, body.client_secret),
-            data={
-                "grant_type": "refresh_token",
-                "refresh_token": body.refresh_token,
-            },
-        )
-        resp.raise_for_status()
-        return resp.json()["access_token"]
-
-
-@sub_router.post("/pinterest-ads/accounts")
-async def pinterest_ads_accounts(
-    body: PinterestAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Pinterest Ads ad accounts accessible by the connection."""
-    try:
-        token = await _get_access_token(body)
-        headers = {"Authorization": f"Bearer {token}"}
-
-        accounts: list[dict[str, str]] = []
-        bookmark: str | None = None
-
-        async with httpx.AsyncClient(timeout=30, headers=headers) as client:
-            while True:
-                params: dict[str, str] = {"page_size": "100"}
-                if bookmark:
-                    params["bookmark"] = bookmark
-
-                resp = await client.get(f"{_BASE_URL}/ad_accounts", params=params)
-                resp.raise_for_status()
-                data = resp.json()
-
-                for acct in data.get("items", []):
-                    accounts.append({
-                        "id": acct["id"],
-                        "name": acct.get("name", acct["id"]),
-                    })
-
-                bookmark = data.get("bookmark")
-                if not bookmark:
-                    break
-
-        return accounts
-    except Exception as exc:
-        handle_error(exc, "fetching Pinterest Ads accounts")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/snapchat_ads.py

@@ -1,86 +0,0 @@
-"""Snapchat Ads external API routes."""
-
-from __future__ import annotations
-
-import httpx
-from fastapi import APIRouter, Depends
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://adsapi.snapchat.com/v1"
-_TOKEN_URL = "https://accounts.snapchat.com/login/oauth2/access_token"
-
-
-class SnapchatAdsConnectionRequest(BaseModel):
-    """Snapchat Ads connection credentials (matches SnapchatAdsConnection fields)."""
-
-    client_id: str
-    client_secret: str
-    refresh_token: str
-
-
-async def _get_access_token(body: SnapchatAdsConnectionRequest) -> str:
-    """Exchange refresh token for an access token."""
-    async with httpx.AsyncClient(timeout=30) as client:
-        resp = await client.post(
-            _TOKEN_URL,
-            data={
-                "grant_type": "refresh_token",
-                "client_id": body.client_id,
-                "client_secret": body.client_secret,
-                "refresh_token": body.refresh_token,
-            },
-        )
-        resp.raise_for_status()
-        return resp.json()["access_token"]
-
-
-@sub_router.post("/snapchat-ads/ad-accounts")
-async def snapchat_ads_accounts(
-    body: SnapchatAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch Snapchat Ads ad accounts accessible by the connection.
-
-    Flow: authenticate → list organizations → list ad accounts per org.
-    """
-    try:
-        token = await _get_access_token(body)
-        headers = {"Authorization": f"Bearer {token}"}
-
-        async with httpx.AsyncClient(timeout=30, headers=headers) as client:
-            # 1. Get organizations
-            org_resp = await client.get(f"{_BASE_URL}/me/organizations")
-            org_resp.raise_for_status()
-            orgs = org_resp.json().get("organizations", [])
-
-            # 2. Get ad accounts for each organization
-            accounts: list[dict[str, str]] = []
-            for org_wrapper in orgs:
-                org = org_wrapper.get("organization", {})
-                org_id = org.get("id")
-                if not org_id:
-                    continue
-
-                acct_resp = await client.get(f"{_BASE_URL}/organizations/{org_id}/adaccounts")
-                acct_resp.raise_for_status()
-                ad_accounts = acct_resp.json().get("adaccounts", [])
-
-                for acct_wrapper in ad_accounts:
-                    acct = acct_wrapper.get("adaccount", {})
-                    if acct.get("status") != "ACTIVE":
-                        continue
-                    accounts.append({
-                        "id": acct["id"],
-                        "name": acct.get("name", acct["id"]),
-                    })
-
-        return accounts
-    except Exception as exc:
-        handle_error(exc, "fetching Snapchat Ads ad accounts")
-        return []

interloper_api-0.22.0/src/interloper_api/routes/external/tiktok_ads.py

@@ -1,70 +0,0 @@
-"""TikTok Ads external API routes."""
-
-from __future__ import annotations
-
-import os
-
-import httpx
-from fastapi import APIRouter, Depends, HTTPException
-from interloper_db import Profile
-from pydantic import BaseModel
-
-from interloper_api.dependencies import require_viewer
-from interloper_api.routes.external import handle_error
-
-sub_router = APIRouter()
-
-_BASE_URL = "https://business-api.tiktok.com/open_api/v1.3"
-_ADVERTISERS_URL = f"{_BASE_URL}/oauth2/advertiser/get/"
-
-
-class TiktokAdsConnectionRequest(BaseModel):
-    """TikTok Ads connection credentials (matches TiktokAdsConnection fields)."""
-
-    access_token: str
-
-
-async def _list_advertisers(
-    client: httpx.AsyncClient,
-    access_token: str,
-    app_id: str,
-    secret: str,
-) -> list[dict[str, str]]:
-    """List the advertisers the access token can access, sorted by name."""
-    resp = await client.get(
-        _ADVERTISERS_URL,
-        params={"app_id": app_id, "secret": secret},
-        headers={"Access-Token": access_token},
-    )
-    resp.raise_for_status()
-    body = resp.json()
-    if body.get("code") != 0:
-        raise HTTPException(status_code=502, detail=f"TikTok API error: {body.get('message')}")
-
-    advertisers = body.get("data", {}).get("list", [])
-    results = [
-        {"advertiser_id": a["advertiser_id"], "name": a.get("advertiser_name") or a["advertiser_id"]}
-        for a in advertisers
-    ]
-    return sorted(results, key=lambda a: a["name"].lower())
-
-
-@sub_router.post("/tiktok-ads/advertisers")
-async def tiktok_ads_advertisers(
-    body: TiktokAdsConnectionRequest,
-    _user: Profile = Depends(require_viewer),
-) -> list[dict[str, str]]:
-    """Fetch the TikTok advertisers accessible by the connection.
-
-    Listing advertisers needs the connector app's ``app_id`` / ``secret`` — read
-    from the provider-scoped environment (``TIKTOK_CLIENT_ID`` /
-    ``TIKTOK_CLIENT_SECRET``) — alongside the connection's access token.
-    """
-    try:
-        app_id = os.environ.get("TIKTOK_CLIENT_ID", "")
-        secret = os.environ.get("TIKTOK_CLIENT_SECRET", "")
-        async with httpx.AsyncClient(timeout=30) as client:
-            return await _list_advertisers(client, body.access_token, app_id, secret)
-    except Exception as exc:
-        handle_error(exc, "fetching TikTok Ads advertisers")
-        return []