Pagination and synchronization

from datetime import datetime, timedelta, timezone
from urllib.parse import urlsplit
import requests

PAYWISE_API_URL = "https://api-sandbox.paywise.de"
PAYWISE_API_KEY = "pw_sbx_your_api_key"
SYNC_HIGH_WATER = "2026-08-31T10:00:00Z"
SYNC_OVERLAP_SECONDS = "300"
SYNC_SWEEPS = "2"

base_url = PAYWISE_API_URL
base_parts = urlsplit(base_url)
if (
    base_parts.scheme != "https"
    or not base_parts.hostname
    or base_parts.username is not None
    or base_parts.password is not None
):
    raise ValueError("PAYWISE_API_URL must use HTTPS")
api_origin = (base_parts.hostname.lower(), base_parts.port or 443)
page_budget = 5
headers = {"Authorization": f"Bearer {PAYWISE_API_KEY}"}

def parse_aware_instant(value):
    try:
        instant = datetime.fromisoformat(value.replace("Z", "+00:00"))
    except (AttributeError, TypeError, ValueError) as error:
        raise ValueError(f"Invalid RFC3339 timestamp: {value!r}") from error
    if instant.tzinfo is None or instant.utcoffset() is None:
        raise ValueError(f"Timestamp must include a timezone offset: {value!r}")
    return instant

committed_high_water = parse_aware_instant(SYNC_HIGH_WATER)
overlap = timedelta(seconds=int(SYNC_OVERLAP_SECONDS))
sweep_count = int(SYNC_SWEEPS)
if overlap <= timedelta(0) or not 1 <= sweep_count <= 10:
    raise ValueError("Use a positive overlap and one to ten bounded sweeps")

versions = set()
resources_by_id = {}
resource_instants_by_id = {}
for _ in range(sweep_count):
    lower_bound = (committed_high_water - overlap).astimezone(timezone.utc)
    next_url = f"{base_url}/v2/debtors/"
    params = {
        "updated_since": lower_bound.isoformat().replace("+00:00", "Z"),
        "limit": 100,
    }
    greatest_applied = committed_high_water
    seen_urls = set()
    pages_read = 0
    while next_url:
        next_parts = urlsplit(next_url)
        next_origin = (
            next_parts.hostname.lower() if next_parts.hostname else "",
            next_parts.port or (443 if next_parts.scheme == "https" else None),
        )
        if (
            next_parts.scheme != "https"
            or next_origin != api_origin
            or next_parts.username is not None
            or next_parts.password is not None
        ):
            raise RuntimeError("Refusing a pagination URL outside the API HTTPS origin")
        if next_url in seen_urls:
            raise RuntimeError("Pagination cycle detected")
        if pages_read >= page_budget:
            raise RuntimeError("Pagination page budget exhausted")
        seen_urls.add(next_url)
        pages_read += 1
        page_response = requests.get(
            next_url, headers=headers, params=params, timeout=(5, 30)
        )
        if page_response.status_code != 200:
            page_response.raise_for_status()
            raise RuntimeError(f"Expected 200, received {page_response.status_code}")
        page = page_response.json()
        for row in page["results"]:
            resource_id = row["id"]
            updated_at = row["updated_at"]
            observed = parse_aware_instant(updated_at)
            version = (resource_id, updated_at)
            if version not in versions:
                versions.add(version)
                current_instant = resource_instants_by_id.get(resource_id)
                if current_instant is None or observed > current_instant:
                    resources_by_id[resource_id] = row
                    resource_instants_by_id[resource_id] = observed
            greatest_applied = max(greatest_applied, observed)
        next_url = page.get("next")
        params = None
    committed_high_water = greatest_applied

WORKFLOW_RESULT = {
    "sweeps": sweep_count,
    "resource_ids": sorted(resources_by_id),
    "versions": [list(version) for version in sorted(versions)],
    "selected_references": {
        resource_id: row.get("your_reference")
        for resource_id, row in sorted(resources_by_id.items())
    },
    "committed_high_water": committed_high_water.isoformat(),
}