liquid-api 0.2.0__tar.gz → 0.3.0__tar.gz

{liquid_api-0.2.0 → liquid_api-0.3.0}/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to Liquid will be documented in this file.
 
+## [0.3.0] - 2026-04-13
+
+### Added
+- Published to PyPI as `liquid-api` (`pip install liquid-api`)
+- PyPI metadata: keywords, classifiers, project URLs
+- `managed_http_client()` shared context manager for discovery strategies
+- `_EndpointSyncResult` TypedDict for type-safe sync results
+- OSS launch materials: README revamp, CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md, CHANGELOG.md
+- Issue templates (bug report, feature request), PR template
+- 10 good first issues for new contributors (#3-#12)
+- Blog post draft and launch post templates (HN, Reddit, Twitter)
+- PEP 541 request for `liquid` package name
+
+### Changed
+- Extracted `discovery/utils.py` with shared `infer_service_name()`, `parse_llm_endpoints_response()`, `managed_http_client()`
+- Refactored `SyncEngine.run()` — extracted `_sync_endpoint()`, reduced nesting 4→2 levels
+- Refactored `Liquid.repair_adapter()` — extracted `_emit_repair_event()`
+- Extracted `_has_full_page()` helper in pagination, eliminating duplication
+- Moved inline imports (`json`, `base64`) to top-level
+- Standardized HTTP client management across all discovery strategies
+
+### Removed
+- `ReDiscoveryNeededError` exception (dead code, use `ReDiscoveryNeeded` event instead)
+
 ## [0.2.0] - 2026-04-13
 
 ### Added

{liquid_api-0.2.0 → liquid_api-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-api
-Version: 0.2.0
+Version: 0.3.0
 Summary: AI discovers APIs. Code syncs data. No adapters to write.
 Project-URL: Homepage, https://github.com/ertad-family/liquid
 Project-URL: Documentation, https://github.com/ertad-family/liquid/blob/main/docs/QUICKSTART.md

{liquid_api-0.2.0 → liquid_api-0.3.0}/docs/EXTENDING.md

@@ -153,7 +153,6 @@ LiquidError
 │   ├── RateLimitError      — 429 response (has retry_after)
 │   ├── ServiceDownError    — 5xx response
 │   └── EndpointGoneError   — 404/410 response
-├── ReDiscoveryNeededError  — persistent failures threshold exceeded
 └── VaultError              — credential storage failures
 ```
 

liquid_api-0.3.0/docs/pep541-request.md

@@ -0,0 +1,50 @@
+# PEP 541 — Request to Transfer PyPI Package Name `liquid`
+
+## How to Submit
+
+File an issue at: https://github.com/pypi/support/issues/new?template=pep541-702.yml
+
+## Request Details
+
+**Package name:** `liquid`
+
+**PyPI URL:** https://pypi.org/project/liquid/
+
+**Your PyPI username:** *(your username)*
+
+**Your package URL:** https://pypi.org/project/liquid-api/
+
+**Your GitHub repo:** https://github.com/ertad-family/liquid
+
+### Justification
+
+The `liquid` package on PyPI meets PEP 541 criteria for an abandoned project:
+
+1. **No meaningful releases**: Only version 0.0.1, published September 26, 2013 (over 12 years ago)
+2. **No project description**: "The author of this package has not provided a project description"
+3. **Planning status**: Classified as "Development Status :: 1 - Planning" — never progressed beyond planning
+4. **No activity**: The associated GitHub repository (https://github.com/refnode/liquid) has had no commits or activity in years
+5. **No dependencies or functionality**: The package contains no meaningful code
+
+### Our Project
+
+**liquid-api** (https://pypi.org/project/liquid-api/) is an actively developed Python library for programmatic API discovery and adapter generation. We are currently publishing under `liquid-api` but our import name is `liquid`, which creates a confusing mismatch:
+
+```bash
+pip install liquid-api    # install command
+from liquid import Liquid  # import name
+```
+
+Transferring the `liquid` name would:
+- Eliminate the install-vs-import name mismatch
+- Give the name to an actively maintained project with 210 tests, full documentation, and regular releases
+- Serve the Python community better than an abandoned placeholder
+
+### Contact Attempts
+
+*(Before submitting, attempt to contact the current owner `refnode` via GitHub or email. Document your attempt here, even if there's no response after 2-4 weeks.)*
+
+**Steps to take:**
+1. Open an issue at https://github.com/refnode/liquid asking to transfer the PyPI name
+2. Wait 4 weeks for a response
+3. If no response, submit the PEP 541 request with proof of the contact attempt

{liquid_api-0.2.0 → liquid_api-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "liquid-api"
-version = "0.2.0"
+version = "0.3.0"
 description = "AI discovers APIs. Code syncs data. No adapters to write."
 readme = "README.md"
 license = "AGPL-3.0-only"

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/__init__.py

@@ -1,6 +1,6 @@
 """Liquid — AI discovers APIs. Code syncs data. No adapters to write."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 from liquid.client import Liquid
 from liquid.exceptions import (
@@ -12,7 +12,6 @@ from liquid.exceptions import (
     LiquidError,
     MappingError,
     RateLimitError,
-    ReDiscoveryNeededError,
     ServiceDownError,
     SyncRuntimeError,
     VaultError,
@@ -50,7 +49,6 @@ __all__ = [
     "MappedRecord",
     "MappingError",
     "RateLimitError",
-    "ReDiscoveryNeededError",
     "ServiceDownError",
     "SyncConfig",
     "SyncResult",

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/auth/manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import logging
 from typing import TYPE_CHECKING, Any
 
@@ -43,8 +44,6 @@ class AuthManager:
                 case "basic":
                     username = await self.vault.get(f"{vault_key}/username")
                     password = await self.vault.get(f"{vault_key}/password")
-                    import base64
-
                     encoded = base64.b64encode(f"{username}:{password}".encode()).decode()
                     return {"Authorization": f"Basic {encoded}"}
                 case _:

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/client.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 from typing import TYPE_CHECKING, Any
 
 import httpx
@@ -26,6 +27,7 @@ from liquid.sync.mapper import RecordMapper
 
 if TYPE_CHECKING:
     from liquid.events import EventHandler
+    from liquid.models.schema import SchemaDiff
     from liquid.models.sync import SyncResult
     from liquid.protocols import DataSink, KnowledgeStore, LLMBackend, Vault
     from liquid.sync.retry import RetryPolicy
@@ -145,21 +147,13 @@ class Liquid:
         Returns AdapterConfig if auto_approve=True and all mappings are confident,
         otherwise returns MappingReview for human review.
         """
-        from liquid.events import AdapterRepaired
 
         new_schema = await self.discover(config.schema_.source_url)
         diff = diff_schemas(config.schema_, new_schema)
 
         if not diff.has_breaking_changes:
             updated = config.model_copy(update={"schema_": new_schema, "version": config.version + 1})
-            if self.event_handler:
-                await self.event_handler.handle(
-                    AdapterRepaired(
-                        adapter_id=config.config_id,
-                        diff=diff,
-                        auto_approved=True,
-                    )
-                )
+            await self._emit_repair_event(config.config_id, diff)
             return updated
 
         proposals = await self._mapping_proposer.propose(
@@ -173,28 +167,26 @@ class Liquid:
 
         if auto_approve and all(m.confidence >= confidence_threshold for m in proposals):
             review.approve_all()
-            mappings = review.finalize()
             updated = AdapterConfig(
                 config_id=config.config_id,
                 schema=new_schema,
                 auth_ref=config.auth_ref,
-                mappings=mappings,
+                mappings=review.finalize(),
                 sync=config.sync,
                 verified_by=config.verified_by,
                 version=config.version + 1,
             )
-            if self.event_handler:
-                await self.event_handler.handle(
-                    AdapterRepaired(
-                        adapter_id=config.config_id,
-                        diff=diff,
-                        auto_approved=True,
-                    )
-                )
+            await self._emit_repair_event(config.config_id, diff)
             return updated
 
         return review
 
+    async def _emit_repair_event(self, adapter_id: str, diff: SchemaDiff) -> None:
+        if self.event_handler:
+            from liquid.events import AdapterRepaired
+
+            await self.event_handler.handle(AdapterRepaired(adapter_id=adapter_id, diff=diff, auto_approved=True))
+
     async def learn_from_review(
         self,
         schema: APISchema,
@@ -202,8 +194,6 @@ class Liquid:
         review: MappingReview,
     ) -> None:
         """Record corrections from a mapping review for future learning."""
-        import json
-
         corrections = review.corrections()
         if corrections:
             await self._mapping_learner.record_corrections(

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/discovery/browser.py

@@ -13,7 +13,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from liquid.exceptions import DiscoveryError
-from liquid.models.schema import APISchema, AuthRequirement, Endpoint
+from liquid.models.schema import APISchema
 
 if TYPE_CHECKING:
     from liquid.protocols import LLMBackend
@@ -126,50 +126,14 @@ class BrowserDiscovery:
         return self._parse_response(response.content or "{}", url, captured)
 
     def _parse_response(self, content: str, url: str, captured: list[dict[str, Any]]) -> APISchema:
-        import json
-        from urllib.parse import urlparse
+        from liquid.discovery.utils import parse_llm_endpoints_response
 
-        try:
-            data = json.loads(content)
-        except json.JSONDecodeError:
-            data = {}
-
-        endpoints: list[Endpoint] = []
-        for ep in data.get("endpoints", []):
-            if isinstance(ep, dict) and "path" in ep:
-                endpoints.append(
-                    Endpoint(
-                        path=ep["path"],
-                        method=ep.get("method", "GET").upper(),
-                        description=ep.get("description", ""),
-                    )
-                )
-
-        if not endpoints:
-            # Fallback: create endpoints from captured URLs
-            seen_paths: set[str] = set()
-            for c in captured:
-                parsed = urlparse(c["url"])
-                if parsed.path not in seen_paths:
-                    seen_paths.add(parsed.path)
-                    endpoints.append(
-                        Endpoint(
-                            path=parsed.path,
-                            method=c["method"],
-                            description=f"Captured via browser ({c['status']})",
-                        )
-                    )
-
-        auth_type = data.get("auth_type", "custom")
-        valid_types = {"oauth2", "api_key", "bearer", "basic", "custom"}
-        if auth_type not in valid_types:
-            auth_type = "custom"
-        tier = "A" if auth_type in ("oauth2", "bearer") else "C"
+        service_name, endpoints, auth = parse_llm_endpoints_response(content, url, fallback_probes=captured)
 
         return APISchema(
             source_url=url,
-            service_name=data.get("service_name", urlparse(url).hostname or "Unknown"),
+            service_name=service_name,
             discovery_method="browser",
             endpoints=endpoints,
-            auth=AuthRequirement(type=auth_type, tier=tier),
+            auth=auth,
         )

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/discovery/graphql.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-import httpx
+import httpx  # noqa: TC002
 
 from liquid.exceptions import DiscoveryError
 from liquid.models.schema import (
@@ -51,15 +51,13 @@ class GraphQLDiscovery:
         self._external_client = http_client
 
     async def discover(self, url: str) -> APISchema | None:
-        client = self._external_client or httpx.AsyncClient()
-        try:
+        from liquid.discovery.utils import managed_http_client
+
+        async with managed_http_client(self._external_client) as client:
             introspection = await self._run_introspection(client, url)
             if introspection is None:
                 return None
             return self._parse_introspection(introspection, url)
-        finally:
-            if not self._external_client:
-                await client.aclose()
 
     async def _run_introspection(
         self,
@@ -156,15 +154,11 @@ class GraphQLDiscovery:
             return {"type": "string", "title": name}
         return {"type": "object"}
 
-    def _infer_service_name(self, url: str) -> str:
-        from urllib.parse import urlparse
+    @staticmethod
+    def _infer_service_name(url: str) -> str:
+        from liquid.discovery.utils import infer_service_name
 
-        parsed = urlparse(url)
-        host = parsed.hostname or "unknown"
-        parts = host.split(".")
-        if len(parts) >= 2:
-            return parts[-2].capitalize()
-        return host.capitalize()
+        return infer_service_name(url)
 
 
 def _scalar_to_json_type(name: str) -> str:

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/discovery/mcp.py

@@ -148,12 +148,8 @@ class MCPDiscovery:
             )
         return params
 
-    def _infer_service_name(self, url: str) -> str:
-        from urllib.parse import urlparse
-
-        parsed = urlparse(url)
-        host = parsed.hostname or "unknown"
-        parts = host.split(".")
-        if len(parts) >= 2:
-            return parts[-2].capitalize()
-        return host.capitalize()
+    @staticmethod
+    def _infer_service_name(url: str) -> str:
+        from liquid.discovery.utils import infer_service_name
+
+        return infer_service_name(url)

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/discovery/openapi.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-import httpx
+import httpx  # noqa: TC002
 import yaml
 
 from liquid.exceptions import DiscoveryError
@@ -39,7 +39,9 @@ class OpenAPIDiscovery:
         self._external_client = http_client
 
     async def discover(self, url: str) -> APISchema | None:
-        async with self._get_client() as client:
+        from liquid.discovery.utils import managed_http_client
+
+        async with managed_http_client(self._external_client) as client:
             spec = await self._find_spec(client, url)
             if spec is None:
                 return None
@@ -206,22 +208,3 @@ class OpenAPIDiscovery:
         if "page" in param_names or "page_number" in param_names:
             return PaginationType.PAGE_NUMBER
         return None
-
-    def _get_client(self) -> httpx.AsyncClient:
-        if self._external_client:
-
-            class _NoOpContext:
-                async def __aenter__(self):
-                    return self
-
-                async def __aexit__(self, *args):
-                    pass
-
-                def __getattr__(self, name):
-                    return getattr(self._client, name)
-
-                def __init__(self, client):
-                    self._client = client
-
-            return _NoOpContext(self._external_client)  # type: ignore[return-value]
-        return httpx.AsyncClient()

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/discovery/rest_heuristic.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
-import httpx
+import httpx  # noqa: TC002
 
 from liquid.exceptions import DiscoveryError
-from liquid.models.schema import APISchema, AuthRequirement, Endpoint
+from liquid.models.schema import APISchema
 
 if TYPE_CHECKING:
     from liquid.protocols import LLMBackend
@@ -47,20 +47,19 @@ class RESTHeuristicDiscovery:
         self._external_client = http_client
 
     async def discover(self, url: str) -> APISchema | None:
-        client = self._external_client or httpx.AsyncClient()
-        try:
-            found_endpoints = await self._probe_endpoints(client, url)
-            if not found_endpoints:
-                return None
-
-            return await self._interpret_with_llm(url, found_endpoints)
-        except DiscoveryError:
-            raise
-        except Exception as e:
-            raise DiscoveryError(f"REST heuristic discovery failed: {e}") from e
-        finally:
-            if not self._external_client:
-                await client.aclose()
+        from liquid.discovery.utils import managed_http_client
+
+        async with managed_http_client(self._external_client) as client:
+            try:
+                found_endpoints = await self._probe_endpoints(client, url)
+                if not found_endpoints:
+                    return None
+
+                return await self._interpret_with_llm(url, found_endpoints)
+            except DiscoveryError:
+                raise
+            except Exception as e:
+                raise DiscoveryError(f"REST heuristic discovery failed: {e}") from e
 
     async def _probe_endpoints(
         self,
@@ -117,41 +116,14 @@ class RESTHeuristicDiscovery:
         return self._parse_llm_response(response.content or "{}", url, probed)
 
     def _parse_llm_response(self, content: str, url: str, probed: list[dict]) -> APISchema:
-        import json
-
-        try:
-            data = json.loads(content)
-        except json.JSONDecodeError:
-            data = {}
-
-        endpoints = []
-        for ep in data.get("endpoints", []):
-            if isinstance(ep, dict) and "path" in ep:
-                endpoints.append(
-                    Endpoint(
-                        path=ep["path"],
-                        method=ep.get("method", "GET").upper(),
-                        description=ep.get("description", ""),
-                    )
-                )
-
-        if not endpoints:
-            endpoints = [
-                Endpoint(path=p["path"], method="GET", description=f"Discovered via probe ({p['status']})")
-                for p in probed
-            ]
-
-        auth_type = data.get("auth_type", "custom")
-        valid_auth_types = {"oauth2", "api_key", "bearer", "basic", "custom"}
-        if auth_type not in valid_auth_types:
-            auth_type = "custom"
-
-        tier = "A" if auth_type in ("oauth2", "bearer") else "C"
+        from liquid.discovery.utils import parse_llm_endpoints_response
+
+        service_name, endpoints, auth = parse_llm_endpoints_response(content, url, fallback_probes=probed)
 
         return APISchema(
             source_url=url,
-            service_name=data.get("service_name", "Unknown"),
+            service_name=service_name,
             discovery_method="rest_heuristic",
             endpoints=endpoints,
-            auth=AuthRequirement(type=auth_type, tier=tier),
+            auth=auth,
         )

liquid_api-0.3.0/src/liquid/discovery/utils.py

@@ -0,0 +1,89 @@
+"""Shared utilities for discovery strategies."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import AsyncIterator  # noqa: TC003
+from contextlib import asynccontextmanager
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from liquid.models.schema import AuthRequirement, Endpoint
+
+logger = logging.getLogger(__name__)
+
+
+def infer_service_name(url: str) -> str:
+    """Extract a human-readable service name from a URL."""
+    parsed = urlparse(url)
+    host = parsed.hostname or "unknown"
+    parts = host.split(".")
+    if len(parts) >= 2:
+        return parts[-2].capitalize()
+    return host.capitalize()
+
+
+def parse_llm_endpoints_response(
+    content: str,
+    url: str,
+    fallback_probes: list[dict[str, Any]] | None = None,
+) -> tuple[str, list[Endpoint], AuthRequirement]:
+    """Parse LLM JSON response containing service_name, endpoints, and auth_type.
+
+    Returns (service_name, endpoints, auth_requirement).
+    Falls back to probed endpoints if LLM response is invalid.
+    """
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError:
+        data = {}
+
+    endpoints: list[Endpoint] = []
+    for ep in data.get("endpoints", []):
+        if isinstance(ep, dict) and "path" in ep:
+            endpoints.append(
+                Endpoint(
+                    path=ep["path"],
+                    method=ep.get("method", "GET").upper(),
+                    description=ep.get("description", ""),
+                )
+            )
+
+    if not endpoints and fallback_probes:
+        for probe in fallback_probes:
+            path = probe.get("path") or probe.get("url", "")
+            if "://" in path:
+                path = urlparse(path).path
+            endpoints.append(
+                Endpoint(
+                    path=path,
+                    method=probe.get("method", "GET"),
+                    description=f"Discovered via probe ({probe.get('status', '?')})",
+                )
+            )
+
+    auth_type = data.get("auth_type", "custom")
+    valid_auth_types = {"oauth2", "api_key", "bearer", "basic", "custom"}
+    if auth_type not in valid_auth_types:
+        auth_type = "custom"
+    tier = "A" if auth_type in ("oauth2", "bearer") else "C"
+
+    service_name = data.get("service_name") or infer_service_name(url)
+
+    return service_name, endpoints, AuthRequirement(type=auth_type, tier=tier)
+
+
+@asynccontextmanager
+async def managed_http_client(external: httpx.AsyncClient | None = None) -> AsyncIterator[httpx.AsyncClient]:
+    """Yield the external client if provided, otherwise create and auto-close a new one."""
+    if external:
+        yield external
+    else:
+        client = httpx.AsyncClient()
+        try:
+            yield client
+        finally:
+            await client.aclose()

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/exceptions.py

@@ -43,9 +43,5 @@ class EndpointGoneError(SyncRuntimeError):
     pass
 
 
-class ReDiscoveryNeededError(LiquidError):
-    pass
-
-
 class VaultError(LiquidError):
     pass

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/sync/engine.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from datetime import UTC, datetime
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypedDict
 
 from liquid.events import ReDiscoveryNeeded, SyncCompleted, SyncFailed
 from liquid.exceptions import SyncRuntimeError
@@ -21,6 +21,14 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+class _EndpointSyncResult(TypedDict):
+    fetched: int
+    mapped: int
+    delivered: int
+    errors: list[SyncError]
+    cursor: str | None
+
+
 class SyncEngine:
     def __init__(
         self,
@@ -59,51 +67,12 @@ class SyncEngine:
                 )
                 continue
 
-            try:
-                page_cursor = current_cursor
-                while True:
-                    fetch_result = await with_retry(
-                        lambda ep=endpoint, c=page_cursor: self.fetcher.fetch(
-                            endpoint=ep,
-                            base_url=config.schema_.source_url,
-                            auth_ref=config.auth_ref,
-                            cursor=c,
-                        ),
-                        self.retry_policy,
-                    )
-
-                    total_fetched += len(fetch_result.records)
-
-                    mapped_records = self.mapper.map_batch(fetch_result.records, ep_path)
-                    total_mapped += len(mapped_records)
-
-                    delivery = await self.sink.deliver(mapped_records)
-                    total_delivered += delivery.delivered
-
-                    if delivery.errors:
-                        for err_msg in delivery.errors:
-                            errors.append(
-                                SyncError(
-                                    type=SyncErrorType.DELIVERY_ERROR,
-                                    message=err_msg,
-                                    endpoint=ep_path,
-                                )
-                            )
-
-                    page_cursor = fetch_result.next_cursor
-                    current_cursor = page_cursor
-                    if page_cursor is None:
-                        break
-
-            except SyncRuntimeError as e:
-                error_type = _classify_error(e)
-                errors.append(
-                    SyncError(
-                        type=error_type,
-                        message=str(e),
-                        endpoint=ep_path,
-                    )
-                )
+            ep_result = await self._sync_endpoint(endpoint, ep_path, config, current_cursor)
+            total_fetched += ep_result["fetched"]
+            total_mapped += ep_result["mapped"]
+            total_delivered += ep_result["delivered"]
+            errors.extend(ep_result["errors"])
+            current_cursor = ep_result["cursor"]
 
         result = SyncResult(
             adapter_id=config.config_id,
@@ -119,6 +88,54 @@ class SyncEngine:
         await self._handle_result(result, config)
         return result
 
+    async def _sync_endpoint(
+        self,
+        endpoint: Endpoint,
+        ep_path: str,
+        config: AdapterConfig,
+        cursor: str | None,
+    ) -> _EndpointSyncResult:
+        """Sync a single endpoint with pagination."""
+        fetched = 0
+        mapped = 0
+        delivered = 0
+        errors: list[SyncError] = []
+        page_cursor = cursor
+
+        try:
+            while True:
+                fetch_result = await with_retry(
+                    lambda ep=endpoint, c=page_cursor: self.fetcher.fetch(
+                        endpoint=ep,
+                        base_url=config.schema_.source_url,
+                        auth_ref=config.auth_ref,
+                        cursor=c,
+                    ),
+                    self.retry_policy,
+                )
+
+                fetched += len(fetch_result.records)
+                mapped_records = self.mapper.map_batch(fetch_result.records, ep_path)
+                mapped += len(mapped_records)
+
+                delivery = await self.sink.deliver(mapped_records)
+                delivered += delivery.delivered
+
+                if delivery.errors:
+                    errors.extend(
+                        SyncError(type=SyncErrorType.DELIVERY_ERROR, message=msg, endpoint=ep_path)
+                        for msg in delivery.errors
+                    )
+
+                page_cursor = fetch_result.next_cursor
+                if page_cursor is None:
+                    break
+
+        except SyncRuntimeError as e:
+            errors.append(SyncError(type=_classify_error(e), message=str(e), endpoint=ep_path))
+
+        return {"fetched": fetched, "mapped": mapped, "delivered": delivered, "errors": errors, "cursor": page_cursor}
+
     async def _handle_result(self, result: SyncResult, config: AdapterConfig) -> None:
         if not self.event_handler:
             return

{liquid_api-0.2.0 → liquid_api-0.3.0}/src/liquid/sync/pagination.py

@@ -52,12 +52,10 @@ class OffsetPagination:
         return {self.offset_param: offset, self.limit_param: self.limit}
 
     def extract_next_cursor(self, response: httpx.Response) -> str | None:
-        data = response.json()
-        records = data if isinstance(data, list) else data.get("data", data.get("results", []))
-        if isinstance(records, list) and len(records) >= self.limit:
-            current_offset = int(response.request.url.params.get(self.offset_param, "0"))
-            return str(current_offset + self.limit)
-        return None
+        if not _has_full_page(response, self.limit):
+            return None
+        current_offset = int(response.request.url.params.get(self.offset_param, "0"))
+        return str(current_offset + self.limit)
 
 
 class PageNumberPagination:
@@ -71,12 +69,10 @@ class PageNumberPagination:
         return {self.page_param: page, self.per_page_param: self.per_page}
 
     def extract_next_cursor(self, response: httpx.Response) -> str | None:
-        data = response.json()
-        records = data if isinstance(data, list) else data.get("data", data.get("results", []))
-        if isinstance(records, list) and len(records) >= self.per_page:
-            current_page = int(response.request.url.params.get(self.page_param, "1"))
-            return str(current_page + 1)
-        return None
+        if not _has_full_page(response, self.per_page):
+            return None
+        current_page = int(response.request.url.params.get(self.page_param, "1"))
+        return str(current_page + 1)
 
 
 class LinkHeaderPagination:
@@ -91,6 +87,13 @@ class LinkHeaderPagination:
         return match.group(1) if match else None
 
 
+def _has_full_page(response: httpx.Response, page_size: int) -> bool:
+    """Check if the response contains a full page of records (more pages likely)."""
+    data = response.json()
+    records = data if isinstance(data, list) else data.get("data", data.get("results", []))
+    return isinstance(records, list) and len(records) >= page_size
+
+
 def _extract_nested(data: dict[str, Any], path: str) -> Any:
     parts = path.split(".")
     current: Any = data

{liquid_api-0.2.0 → liquid_api-0.3.0}/tests/test_discovery/test_rest_heuristic.py

@@ -75,4 +75,4 @@ class TestRESTHeuristicDiscovery:
 
         assert result is not None
         assert len(result.endpoints) > 0
-        assert result.service_name == "Unknown"
+        assert result.service_name == "Test"  # inferred from api.test.com

{liquid_api-0.2.0 → liquid_api-0.3.0}/tests/test_exceptions.py

@@ -9,7 +9,6 @@ from liquid.exceptions import (
     LiquidError,
     MappingError,
     RateLimitError,
-    ReDiscoveryNeededError,
     ServiceDownError,
     SyncRuntimeError,
     VaultError,
@@ -22,7 +21,6 @@ def test_hierarchy_liquid_error_catches_all():
         AuthSetupError,
         MappingError,
         SyncRuntimeError,
-        ReDiscoveryNeededError,
         VaultError,
     ]
     for exc_class in all_errors:

{liquid_api-0.2.0 → liquid_api-0.3.0}/tests/test_smoke.py

@@ -2,4 +2,4 @@ from liquid import __version__
 
 
 def test_version():
-    assert __version__ == "0.2.0"
+    assert __version__ == "0.3.0"