liquid-api 0.2.0__py3-none-any.whl

liquid/sync/fetcher.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx  # noqa: TC002
+
+from liquid.exceptions import (
+    AuthError,
+    EndpointGoneError,
+    RateLimitError,
+    ServiceDownError,
+)
+from liquid.models.schema import Endpoint  # noqa: TC001
+from liquid.protocols import Vault  # noqa: TC001
+from liquid.sync.pagination import NoPagination, PaginationStrategy
+from liquid.sync.selector import RecordSelector
+
+
+class FetchResult:
+    __slots__ = ("next_cursor", "raw_response", "records")
+
+    def __init__(self, records: list[dict[str, Any]], next_cursor: str | None, raw_response: httpx.Response) -> None:
+        self.records = records
+        self.next_cursor = next_cursor
+        self.raw_response = raw_response
+
+
+class Fetcher:
+    def __init__(
+        self,
+        http_client: httpx.AsyncClient,
+        vault: Vault,
+        pagination: PaginationStrategy | None = None,
+        selector: RecordSelector | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> None:
+        self.http_client = http_client
+        self.vault = vault
+        self.pagination = pagination or NoPagination()
+        self.selector = selector or RecordSelector()
+        self.extra_headers = extra_headers or {}
+
+    async def fetch(
+        self,
+        endpoint: Endpoint,
+        base_url: str,
+        auth_ref: str,
+        cursor: str | None = None,
+    ) -> FetchResult:
+        auth_value = await self.vault.get(auth_ref)
+        headers = {**self.extra_headers, "Authorization": f"Bearer {auth_value}"}
+
+        params = self.pagination.get_request_params(cursor)
+
+        url = f"{base_url.rstrip('/')}{endpoint.path}"
+        response = await self.http_client.request(
+            method=endpoint.method,
+            url=url,
+            params=params,
+            headers=headers,
+        )
+
+        _check_response(response)
+
+        data = response.json()
+        records = self.selector.select(data)
+        next_cursor = self.pagination.extract_next_cursor(response)
+
+        return FetchResult(records=records, next_cursor=next_cursor, raw_response=response)
+
+
+def _check_response(response: httpx.Response) -> None:
+    if response.is_success:
+        return
+
+    status = response.status_code
+    text = response.text[:500]
+
+    if status == 401 or status == 403:
+        raise AuthError(f"Auth failed ({status}): {text}")
+    if status == 429:
+        retry_after = response.headers.get("retry-after")
+        raise RateLimitError(
+            f"Rate limited: {text}",
+            retry_after=float(retry_after) if retry_after else None,
+        )
+    if status == 404 or status == 410:
+        raise EndpointGoneError(f"Endpoint gone ({status}): {text}")
+    if status >= 500:
+        raise ServiceDownError(f"Server error ({status}): {text}")
+
+    response.raise_for_status()

liquid/sync/mapper.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Any
+
+from liquid.exceptions import FieldNotFoundError
+from liquid.models import FieldMapping, MappedRecord
+from liquid.sync.transform import UnsafeExpressionError, evaluate
+
+
+class RecordMapper:
+    def __init__(self, mappings: list[FieldMapping]) -> None:
+        self.mappings = mappings
+
+    def map_record(self, record: dict[str, Any], source_endpoint: str = "") -> MappedRecord:
+        mapped: dict[str, Any] = {}
+        errors: list[str] = []
+
+        for mapping in self.mappings:
+            try:
+                value = _extract_path(record, mapping.source_path)
+            except KeyError as e:
+                raise FieldNotFoundError(f"Field not found: {mapping.source_path}") from e
+
+            if mapping.transform:
+                try:
+                    value = evaluate(mapping.transform, value)
+                except UnsafeExpressionError as e:
+                    errors.append(f"Transform error for {mapping.source_path}: {e}")
+                    continue
+
+            mapped[mapping.target_field] = value
+
+        return MappedRecord(
+            source_endpoint=source_endpoint,
+            source_data=record,
+            mapped_data=mapped,
+            mapping_errors=errors or None,
+        )
+
+    def map_batch(self, records: list[dict[str, Any]], source_endpoint: str = "") -> list[MappedRecord]:
+        return [self.map_record(r, source_endpoint) for r in records]
+
+
+def _extract_path(data: Any, path: str) -> Any:
+    """Extract value from nested dict using dot-notation path.
+
+    Supports:
+    - "field" -> data["field"]
+    - "nested.field" -> data["nested"]["field"]
+    - "items[].price" -> [item["price"] for item in data["items"]]
+    """
+    parts = path.split(".")
+    current: Any = data
+
+    for part in parts:
+        if part.endswith("[]"):
+            key = part[:-2]
+            if key:
+                if not isinstance(current, dict) or key not in current:
+                    raise KeyError(path)
+                current = current[key]
+            if not isinstance(current, list):
+                raise KeyError(path)
+            remaining = ".".join(parts[parts.index(part) + 1 :])
+            if remaining:
+                return [_extract_path(item, remaining) for item in current]
+            return current
+        else:
+            if not isinstance(current, dict) or part not in current:
+                raise KeyError(path)
+            current = current[part]
+
+    return current

liquid/sync/pagination.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Protocol, runtime_checkable
+
+import httpx  # noqa: TC002
+
+
+@runtime_checkable
+class PaginationStrategy(Protocol):
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        """Return query params to add for this page."""
+        ...
+
+    def extract_next_cursor(self, response: httpx.Response) -> str | None:
+        """Extract next cursor from response. Returns None if no more pages."""
+        ...
+
+
+class NoPagination:
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        return {}
+
+    def extract_next_cursor(self, response: httpx.Response) -> str | None:
+        return None
+
+
+class CursorPagination:
+    def __init__(self, cursor_param: str = "cursor", response_cursor_path: str = "next_cursor") -> None:
+        self.cursor_param = cursor_param
+        self.response_cursor_path = response_cursor_path
+
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        if cursor is None:
+            return {}
+        return {self.cursor_param: cursor}
+
+    def extract_next_cursor(self, response: httpx.Response) -> str | None:
+        data = response.json()
+        value = _extract_nested(data, self.response_cursor_path)
+        return str(value) if value else None
+
+
+class OffsetPagination:
+    def __init__(self, offset_param: str = "offset", limit_param: str = "limit", limit: int = 100) -> None:
+        self.offset_param = offset_param
+        self.limit_param = limit_param
+        self.limit = limit
+
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        offset = int(cursor) if cursor else 0
+        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
+
+
+class PageNumberPagination:
+    def __init__(self, page_param: str = "page", per_page_param: str = "per_page", per_page: int = 100) -> None:
+        self.page_param = page_param
+        self.per_page_param = per_page_param
+        self.per_page = per_page
+
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        page = int(cursor) if cursor else 1
+        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
+
+
+class LinkHeaderPagination:
+    _LINK_RE = re.compile(r'<([^>]+)>;\s*rel="next"')
+
+    def get_request_params(self, cursor: str | None) -> dict[str, Any]:
+        return {}
+
+    def extract_next_cursor(self, response: httpx.Response) -> str | None:
+        link_header = response.headers.get("link", "")
+        match = self._LINK_RE.search(link_header)
+        return match.group(1) if match else None
+
+
+def _extract_nested(data: dict[str, Any], path: str) -> Any:
+    parts = path.split(".")
+    current: Any = data
+    for part in parts:
+        if isinstance(current, dict):
+            current = current.get(part)
+        else:
+            return None
+    return current

liquid/sync/retry.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable  # noqa: TC003
+from dataclasses import dataclass, field
+
+from liquid.exceptions import RateLimitError, ServiceDownError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RetryPolicy:
+    max_retries: int = 3
+    base_delay: float = 1.0
+    max_delay: float = 60.0
+    exponential_base: float = 2.0
+    retryable_exceptions: tuple[type[Exception], ...] = field(
+        default_factory=lambda: (RateLimitError, ServiceDownError)
+    )
+
+
+async def with_retry[T](fn: Callable[[], Awaitable[T]], policy: RetryPolicy) -> T:
+    last_exception: Exception | None = None
+
+    for attempt in range(policy.max_retries + 1):
+        try:
+            return await fn()
+        except policy.retryable_exceptions as e:
+            last_exception = e
+            if attempt == policy.max_retries:
+                break
+
+            delay = _compute_delay(e, attempt, policy)
+            logger.warning("Retry %d/%d after %.1fs: %s", attempt + 1, policy.max_retries, delay, e)
+            await asyncio.sleep(delay)
+
+    raise last_exception  # type: ignore[misc]
+
+
+def _compute_delay(exc: Exception, attempt: int, policy: RetryPolicy) -> float:
+    if isinstance(exc, RateLimitError) and exc.retry_after is not None:
+        return min(exc.retry_after, policy.max_delay)
+
+    delay = policy.base_delay * (policy.exponential_base**attempt)
+    return min(delay, policy.max_delay)

liquid/sync/selector.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class RecordSelector:
+    """Extracts records from nested JSON responses by a configurable path.
+
+    Example: RecordSelector("data.orders") extracts response["data"]["orders"].
+    """
+
+    def __init__(self, path: str | None = None) -> None:
+        self.path = path
+
+    def select(self, data: Any) -> list[dict[str, Any]]:
+        if self.path is None:
+            if isinstance(data, list):
+                return data
+            return [data] if isinstance(data, dict) else []
+
+        current: Any = data
+        for part in self.path.split("."):
+            if isinstance(current, dict):
+                current = current.get(part)
+            else:
+                return []
+
+        if isinstance(current, list):
+            return current
+        if isinstance(current, dict):
+            return [current]
+        return []

liquid/sync/transform.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import ast
+from typing import Any
+
+_ALLOWED_BUILTINS = {"int", "float", "str", "bool", "abs", "round", "len", "min", "max"}
+
+_builtins_ref = __builtins__ if isinstance(__builtins__, dict) else vars(__builtins__)
+_SAFE_BUILTINS = {name: _builtins_ref[name] for name in _ALLOWED_BUILTINS}
+
+
+class UnsafeExpressionError(Exception):
+    pass
+
+
+def evaluate(expression: str, value: Any) -> Any:
+    """Evaluate a transform expression safely using AST whitelisting.
+
+    Only allows: arithmetic, comparisons, attribute access on `value`,
+    subscript access on `value`, and a whitelist of builtins.
+    """
+    try:
+        tree = ast.parse(expression, mode="eval")
+    except SyntaxError as e:
+        raise UnsafeExpressionError(f"Invalid expression syntax: {expression}") from e
+
+    _validate_node(tree.body)
+
+    code = compile(tree, "<transform>", "eval")
+    try:
+        return eval(code, {"__builtins__": _SAFE_BUILTINS}, {"value": value})
+    except Exception as e:
+        raise UnsafeExpressionError(f"Expression evaluation failed: {e}") from e
+
+
+def _validate_node(node: ast.AST) -> None:
+    match node:
+        case ast.Expression(body=body):
+            _validate_node(body)
+
+        case ast.Constant():
+            pass
+
+        case ast.Name(id=name):
+            if name not in {"value", *_ALLOWED_BUILTINS}:
+                raise UnsafeExpressionError(f"Forbidden name: {name}")
+
+        case ast.UnaryOp(operand=operand):
+            _validate_node(operand)
+
+        case ast.BinOp(left=left, right=right):
+            _validate_node(left)
+            _validate_node(right)
+
+        case ast.BoolOp(values=values):
+            for v in values:
+                _validate_node(v)
+
+        case ast.Compare(left=left, comparators=comparators):
+            _validate_node(left)
+            for c in comparators:
+                _validate_node(c)
+
+        case ast.IfExp(test=test, body=body, orelse=orelse):
+            _validate_node(test)
+            _validate_node(body)
+            _validate_node(orelse)
+
+        case ast.Attribute(value=attr_value):
+            _validate_node(attr_value)
+
+        case ast.Subscript(value=sub_value, slice=slice_):
+            _validate_node(sub_value)
+            _validate_node(slice_)
+
+        case ast.Index(value=idx_value):
+            _validate_node(idx_value)
+
+        case ast.Call(func=func, args=args, keywords=keywords):
+            _validate_node(func)
+            for arg in args:
+                _validate_node(arg)
+            for kw in keywords:
+                _validate_node(kw.value)
+
+        case ast.List(elts=elts) | ast.Tuple(elts=elts) | ast.Set(elts=elts):
+            for elt in elts:
+                _validate_node(elt)
+
+        case ast.Dict(keys=keys, values=values):
+            for k in keys:
+                if k is not None:
+                    _validate_node(k)
+            for v in values:
+                _validate_node(v)
+
+        case ast.Slice(lower=lower, upper=upper, step=step):
+            for part in (lower, upper, step):
+                if part is not None:
+                    _validate_node(part)
+
+        case _:
+            raise UnsafeExpressionError(f"Forbidden AST node: {type(node).__name__}")

liquid_api-0.2.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: liquid-api
+Version: 0.2.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
+Project-URL: Repository, https://github.com/ertad-family/liquid
+Project-URL: Issues, https://github.com/ertad-family/liquid/issues
+Project-URL: Changelog, https://github.com/ertad-family/liquid/blob/main/CHANGELOG.md
+License-Expression: AGPL-3.0-only
+Keywords: adapter,ai,api,discovery,graphql,llm,mcp,openapi,sync
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40; extra == 'browser'
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <h1 align="center">Liquid</h1>
+  <p align="center"><strong>AI discovers APIs. Code syncs data. No adapters to write.</strong></p>
+</p>
+
+<p align="center">
+  <a href="https://github.com/ertad-family/liquid/actions"><img src="https://img.shields.io/badge/tests-210%20passed-brightgreen" alt="Tests"></a>
+  <a href="https://github.com/ertad-family/liquid/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-AGPL--3.0-blue" alt="License"></a>
+  <img src="https://img.shields.io/badge/python-3.12%2B-blue" alt="Python">
+  <img src="https://img.shields.io/badge/version-0.2.0-orange" alt="Version">
+</p>
+
+---
+
+Point Liquid at any URL. AI discovers the API, proposes field mappings to your data model, and generates a deterministic adapter. After human approval, sync runs on schedule with **zero LLM calls**.
+
+```
+URL  ──→  AI discovers API  ──→  Human verifies mapping  ──→  Deterministic sync
+          (once)                  (one-time review)             (forever, no LLM)
+```
+
+## The Problem
+
+Connecting to external APIs requires custom code per service. 50 services = 50 adapters. Each with unique endpoints, auth flows, pagination, and data models. Writing and maintaining them doesn't scale.
+
+## The Solution
+
+```python
+from liquid import Liquid, SyncConfig
+from liquid._defaults import InMemoryVault, CollectorSink
+
+client = Liquid(llm=my_llm, vault=InMemoryVault(), sink=CollectorSink())
+
+# 1. AI discovers the API (once)
+schema = await client.discover("https://api.shopify.com")
+
+# 2. AI proposes field mappings → human reviews
+review = await client.propose_mappings(schema, {"amount": "float", "date": "datetime"})
+review.approve_all()
+
+# 3. Create adapter config
+config = await client.create_adapter(
+    schema=schema,
+    auth_ref="vault/shopify",
+    mappings=review.finalize(),
+    sync_config=SyncConfig(endpoints=["/orders"], schedule="0 */6 * * *"),
+)
+
+# 4. Deterministic sync — no AI, runs forever
+result = await client.sync(config)
+print(f"Synced {result.records_delivered} records")
+```
+
+## How Discovery Works
+
+Liquid tries the cheapest method first, falls through on failure:
+
+| Priority | Strategy | When it works | AI needed? |
+|----------|----------|---------------|------------|
+| 1 | **MCP** | Service publishes an MCP server | No |
+| 2 | **OpenAPI** | Has `/openapi.json` or `/swagger.json` | No |
+| 3 | **GraphQL** | Has `/graphql` with introspection | No |
+| 4 | **REST Heuristic** | REST API without spec | Yes (once) |
+| 5 | **Browser** | No API at all — capture network traffic | Yes (once) |
+
+## Key Features
+
+**Progressive Discovery** — MCP → OpenAPI → GraphQL → REST → Browser. Cheapest first.
+
+**Selective Re-mapping** — When APIs change, `repair_adapter()` diffs schemas and re-maps only broken fields. Working mappings stay untouched.
+
+**Safe Transforms** — Field transforms like `value * -1` or `value.lower()` are evaluated via AST whitelisting. No `eval()`, no injection risk.
+
+**Pluggable Pagination** — Cursor, offset, page number, link header. Each is a strategy, not a switch/case.
+
+**Learning System** — Corrections improve future proposals. Connect Shopify for the 51st time → mapping is instant.
+
+**Auth Classification** — Detects OAuth (Tier A), app registration (Tier B), or manual credentials (Tier C). Returns structured escalation info.
+
+## Installation
+
+```bash
+pip install liquid               # core
+pip install liquid[mcp]          # + MCP server discovery
+pip install liquid[browser]      # + Playwright browser discovery
+```
+
+## Architecture
+
+```
+┌─────────────┐    ┌──────────────┐    ┌────────────────┐    ┌─────────────┐
+│  Discovery   │──→│  Auth Setup  │──→│  Field Mapping  │──→│ Sync Engine │
+│  (AI, once)  │   │ (AI + human) │   │ (AI + human)    │   │ (code, loop)│
+└─────────────┘    └──────────────┘    └────────────────┘    └─────────────┘
+```
+
+**Liquid is a library, not a framework.** You control when to discover, how to present mappings, where to store configs, and what to do with synced data.
+
+### Extension Points (Protocols)
+
+| Protocol | Purpose | You provide |
+|----------|---------|-------------|
+| `Vault` | Credential storage | Postgres, AWS Secrets Manager, etc. |
+| `LLMBackend` | AI provider | Claude, GPT, Llama, any LLM |
+| `DataSink` | Where data goes | Database, queue, webhook, file |
+| `KnowledgeStore` | Shared mappings | Redis, central registry, or disabled |
+
+## Auto-Repair on API Changes
+
+When an API breaks your adapter:
+
+```python
+result = await client.repair_adapter(config, target_model, auto_approve=True)
+# Re-discovers → diffs schemas → selectively re-maps broken fields
+# Returns updated AdapterConfig or MappingReview for human review
+```
+
+## Liquid vs Alternatives
+
+| | Liquid | Airbyte | Nango | Custom code |
+|---|---|---|---|---|
+| **New service** | `discover(url)` | Write connector YAML | Write TypeScript sync | Write adapter from scratch |
+| **AI involvement** | Discovery only, then deterministic | None | AI-generated code | None |
+| **Auth handling** | Classifies & escalates | Per-connector | Managed OAuth | Manual |
+| **When API changes** | `repair_adapter()` | Update connector | Update sync code | Debug & fix |
+| **Runtime LLM calls** | Zero | Zero | Zero | N/A |
+| **Self-hosted** | Yes (library) | Yes (platform) | Yes (platform) | Yes |
+| **License** | AGPL-3.0 | ELv2 | AGPL-3.0 | Yours |
+
+## Documentation
+
+- [Quick Start Guide](docs/QUICKSTART.md)
+- [Architecture](docs/ARCHITECTURE.md)
+- [Extending Liquid](docs/EXTENDING.md)
+- [Contributing](CONTRIBUTING.md)
+
+## Contributing
+
+We welcome contributions! Check out our [contributing guide](CONTRIBUTING.md) and browse [good first issues](https://github.com/ertad-family/liquid/labels/good%20first%20issue).
+
+## License
+
+AGPL-3.0. Commercial licenses available — [contact us](mailto:hello@ertad.com).

liquid_api-0.2.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+liquid/__init__.py,sha256=P9IR_VrYoBp6CWxm74H0rOxlJDv0elkvelSo5OtBFZw,1213
+liquid/_defaults.py,sha256=6qMXFM58BMyrfacuxKFGHz-6__X3GwQDE5-l0HHdAmY,1911
+liquid/client.py,sha256=DPOx9emu88OJwy81Rh_BePaXQARnGq5d3puIxlBZK6A,7725
+liquid/events.py,sha256=r7nzsObdikTulvBi_d1mH1ET2K7JheY5yq_1R225n50,795
+liquid/exceptions.py,sha256=jmSAQnUARWHJv6c8tmxn2TrQcKXbhzilWaaY4jqsdKs,783
+liquid/protocols.py,sha256=mcZaLcEM-flix3C-MRKCJFPQpbmH0nxEw6p_Y2ZQxuE,961
+liquid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+liquid/auth/__init__.py,sha256=3yWTthUbXyfQyhngDnf0x9OYNY_WNZPJKTzVqnBDlQA,188
+liquid/auth/classifier.py,sha256=d5kU58dnqxFwF8ZlgdSDyfBGWv-JfJA5ppIejJEsPDk,2727
+liquid/auth/manager.py,sha256=5__i4EhqaIs2K9-zr026N96UCUdCt_l2wVAb8fkiJfM,4313
+liquid/discovery/__init__.py,sha256=zS3DV6GCE065ZL4mxbve9C8RNetF06WMzHJND3tA9qo,600
+liquid/discovery/base.py,sha256=fGBWgeaKcRAl3zH8Q42j4b7UQSZ34epjk6SWiH-pHH4,1973
+liquid/discovery/browser.py,sha256=tj1EderVz7L_FpBaTYYC-hNBH6UMZElWiqYJ4oWfXtM,6506
+liquid/discovery/diff.py,sha256=ypUPIhuThb71XGT312opRwscGDY_CEkTFPYr0Ujcq78,2408
+liquid/discovery/graphql.py,sha256=e6lwsmLn09N04CCReaSPiNVh0cxk1xPrg2KbWEI6OiI,5920
+liquid/discovery/mcp.py,sha256=eVBA6qX2TydTXx4n6M6Fh4lVazEdmHXdbEn7YrlKRaI,5458
+liquid/discovery/openapi.py,sha256=qO_4L3hvFzEnB0vFPTJa5CtBhhhNbSMNjBZ73eXpamc,8349
+liquid/discovery/rest_heuristic.py,sha256=LG_OqvA7aPxjsVPFvwBmOKZDyfaD2pJytq6qrFL8Mig,4942
+liquid/mapping/__init__.py,sha256=5Mrfdl3A94_U5HXuChIWxMZUQTKFI18Yq9SvqEF3WaM,234
+liquid/mapping/learning.py,sha256=75R3vHlcM9DP9MDexX-PCeZaZgEWwWupikI1EkXXV5Y,1961
+liquid/mapping/proposer.py,sha256=nd2ZeOoyS-fnrE1pkzUBkvPzyeaQQ22UHZ3F15jzYrc,5394
+liquid/mapping/reviewer.py,sha256=5mBqFZcP1hXHbAU5FyAIqqLKFZZpmAUj_Zw_Lt7Tt4U,3027
+liquid/models/__init__.py,sha256=w75ZYdLy1Nw3xWOVq0hG-jhmrqdAYI1pzIYBhyyPZcQ,808
+liquid/models/adapter.py,sha256=THedZbokZhBqR9Ib9yf3TLuNf2UStJpQfczdwNpfUEQ,882
+liquid/models/llm.py,sha256=i8WJqKOyGX2ulsQ6JDDKxnqBjgaK6dm0gh2UT3728Tc,914
+liquid/models/schema.py,sha256=_DtqCDdBWVeDlBFmXdUo0PW9S5Pdc8ZQIku5OI3Wy0Y,2422
+liquid/models/sync.py,sha256=pr7i9HqCLrIirOqeDb92jAEwKRMDOOh9HEw7AUbiusQ,876
+liquid/sync/__init__.py,sha256=6DsVA608bJA8po89T02yJOHdud3HB50dITgqQhighnQ,731
+liquid/sync/auto_repair.py,sha256=AHEkC047On6iNcSklSJ_FkZ_iQFclk7poc-kMR_Az60,2190
+liquid/sync/engine.py,sha256=qUpHekEOH3fZuSQBlE7BDtBEgVVTXWCP4KK46swl11s,6279
+liquid/sync/fetcher.py,sha256=e6ze0Ss3L1Kdc6NGHNodIy6XTZwj2-nwgnzLM-MqB2I,2826
+liquid/sync/mapper.py,sha256=MFbr7G6FWpTjDTnsLY60UcaD-YfuSqbLuGtSklyf6AI,2499
+liquid/sync/pagination.py,sha256=e6QhiPPq5LJM2BrDV9hugXnPMCWaLEGo7Y5Siq1-fdE,3728
+liquid/sync/retry.py,sha256=aIfj67K4GHCZW0a63KzEuUeT8ekk0JbIpgJpqvuIyRU,1486
+liquid/sync/selector.py,sha256=4uMBnfKqQSQ03WpHowGTaXjVW6xV0wcvvu8sC1dpCw4,897
+liquid/sync/transform.py,sha256=bSiwzW-rDLDbtBbN-R77zz2P7vbJ51hgWoT2rFLw9Eo,3238
+liquid_api-0.2.0.dist-info/METADATA,sha256=wWmA0Ef5MKwvr5oHDonrH5y9gxYsFR908kOh8sdhgoc,7641
+liquid_api-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+liquid_api-0.2.0.dist-info/RECORD,,

liquid_api-0.2.0.dist-info/WHEEL

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