eigenlake 0.2.0__py3-none-any.whl

eigenlake/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from .client import EigenLakeClient
+from . import schema
+
+__version__ = "0.2.0"
+
+
+def connect(
+    *,
+    url: str,
+    api_key: str | None = None,
+    timeout: float = 20.0,
+    retries: int = 2,
+) -> EigenLakeClient:
+    return EigenLakeClient(
+        url=url,
+        api_key=api_key,
+        timeout=timeout,
+        retries=retries,
+    )
+
+
+def connect_local(
+    *,
+    host: str = "http://localhost",
+    port: int = 8000,
+    api_key: str | None = None,
+    timeout: float = 20.0,
+    retries: int = 2,
+) -> EigenLakeClient:
+    return EigenLakeClient(
+        url=f"{host.rstrip('/')}:{int(port)}",
+        api_key=api_key,
+        timeout=timeout,
+        retries=retries,
+    )
+
+
+__all__ = [
+    "EigenLakeClient",
+    "__version__",
+    "connect",
+    "connect_local",
+    "schema",
+]

eigenlake/client.py

@@ -0,0 +1,532 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Iterator, List, Literal
+from urllib.parse import quote
+from uuid import uuid4
+
+from .transport import Transport
+
+
+def _q(value: str) -> str:
+    return quote(str(value), safe="")
+
+
+def _index_path(namespace: str, index: str) -> str:
+    return f"/v1/indexes/{_q(namespace)}/{_q(index)}"
+
+
+@dataclass
+class FailedRecord:
+    id: str
+    error: str
+
+
+class AddManyResult(list[str]):
+    def __init__(self, ids: Iterable[str], *, failed_records: List[FailedRecord] | None = None):
+        super().__init__(ids)
+        self.failed_records: List[FailedRecord] = failed_records or []
+
+    @property
+    def number_errors(self) -> int:
+        return len(self.failed_records)
+
+
+class IndexRecords:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+
+    def add(
+        self,
+        *,
+        properties: Dict[str, Any],
+        vector: List[float],
+        id: str | None = None,
+        on_duplicate: Literal["error", "replace", "skip"] = "error",
+        batch_size: int = 500,
+        max_workers: int = 1,
+    ) -> str:
+        payload = {
+            "properties": properties,
+            "vector": vector,
+            "uuid": id,
+            "on_duplicate": on_duplicate,
+            "batch_size": batch_size,
+            "max_workers": max_workers,
+        }
+        resp = self._h._t.post(f"{self._h._path}/records/insert", json=payload).json()
+        return str(resp["uuid"])
+
+    @staticmethod
+    def _normalize_record(record: Dict[str, Any]) -> Dict[str, Any]:
+        item = dict(record)
+        if "id" in item:
+            item["uuid"] = item.pop("id")
+        return item
+
+    @staticmethod
+    def _normalize_vector_item(item: Dict[str, Any]) -> Dict[str, Any]:
+        normalized = dict(item)
+        if "id" in normalized:
+            normalized["uuid"] = normalized.pop("id")
+        return normalized
+
+    def add_many(
+        self,
+        records: Iterable[dict[str, Any]],
+        *,
+        on_duplicate: Literal["error", "replace", "skip"] = "error",
+        on_error: Literal["raise", "continue"] = "raise",
+        batch_size: int = 500,
+        max_workers: int = 1,
+    ) -> AddManyResult:
+        payload = {
+            "objects": [self._normalize_record(record) for record in records],
+            "on_duplicate": on_duplicate,
+            "on_error": on_error,
+            "batch_size": batch_size,
+            "max_workers": max_workers,
+        }
+        resp = self._h._t.post(f"{self._h._path}/records/insert-many", json=payload).json()
+        failed = [
+            FailedRecord(id=str(item.get("uuid") or ""), error=str(item.get("error") or ""))
+            for item in (resp.get("failed_objects") or [])
+        ]
+        return AddManyResult(resp.get("uuids") or [], failed_records=failed)
+
+    def add_vectors(
+        self,
+        vectors: Iterable[dict[str, Any]],
+        *,
+        batch_size: int = 500,
+        max_workers: int = 1,
+    ) -> None:
+        payload = {
+            "vectors": [self._normalize_vector_item(item) for item in vectors],
+            "batch_size": batch_size,
+            "max_workers": max_workers,
+        }
+        self._h._t.post(f"{self._h._path}/records/insert-vectors", json=payload)
+
+    def get(self, id: str, *, return_data: bool = True, return_metadata: bool = True) -> dict[str, Any] | None:
+        payload = {
+            "uuid": id,
+            "return_data": return_data,
+            "return_metadata": return_metadata,
+        }
+        resp = self._h._t.post(f"{self._h._path}/records/get-by-id", json=payload).json()
+        return resp.get("object")
+
+    def exists(self, id: str) -> bool:
+        resp = self._h._t.get(f"{self._h._path}/records/exists/{_q(id)}").json()
+        return bool(resp.get("exists", False))
+
+    def remove(self, id: str, *, batch_size: int = 500) -> None:
+        self._h._t.delete(f"{self._h._path}/records/{_q(id)}", params={"batch_size": batch_size})
+
+    def remove_many(
+        self,
+        *,
+        filter: Dict[str, Any],
+        limit: int | None = None,
+        delete_sql_rows: bool = False,
+        on_missing: Literal["skip", "error"] = "skip",
+        batch_size: int = 500,
+        background: bool = True,
+    ) -> Dict[str, Any]:
+        payload = {
+            "where": filter,
+            "limit": limit,
+            "delete_patent_rows": delete_sql_rows,
+            "on_missing_keys": on_missing,
+            "batch_size": batch_size,
+            "background": background,
+        }
+        return self._h._t.post(f"{self._h._path}/records/delete-many", json=payload).json()
+
+    def remove_job(self, job_id: int) -> Dict[str, Any]:
+        return self._h._t.get(f"{self._h._path}/records/delete-jobs/{int(job_id)}").json()
+
+    def update(
+        self,
+        *,
+        id: str,
+        properties: Dict[str, Any] | None = None,
+        vector: List[float] | None = None,
+    ) -> None:
+        payload = {
+            "properties": properties,
+            "vector": vector,
+        }
+        self._h._t.patch(f"{self._h._path}/records/{_q(id)}", json=payload)
+
+    def replace(
+        self,
+        *,
+        id: str,
+        properties: Dict[str, Any],
+        vector: List[float] | None = None,
+    ) -> None:
+        payload = {
+            "properties": properties,
+            "vector": vector,
+        }
+        self._h._t.put(f"{self._h._path}/records/{_q(id)}", json=payload)
+
+    def list(
+        self,
+        *,
+        filter: Dict[str, Any],
+        limit: int = 100,
+        after: str | None = None,
+        with_vector: bool = False,
+        with_properties: bool = True,
+        on_missing: Literal["skip", "error"] = "skip",
+    ) -> Dict[str, Any]:
+        payload = {
+            "where": filter,
+            "limit": limit,
+            "after": after,
+            "include_vector": with_vector,
+            "include_properties": with_properties,
+            "on_missing_keys": on_missing,
+        }
+        return self._h._t.post(f"{self._h._path}/records/get-by-filter", json=payload).json()
+
+
+class IndexSearch:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+
+    def nearest(self, *, vector: List[float], limit: int = 10, filter: Dict[str, Any] | None = None):
+        payload = {
+            "vector": vector,
+            "top_k": limit,
+            "filter": filter,
+        }
+        return self._h._t.post(f"{self._h._path}/search/near-vector", json=payload).json()
+
+    def cluster(
+        self,
+        *,
+        filter: Dict[str, Any] | None = None,
+        limit: int = 1000,
+        algorithm: Literal["kmeans"] = "kmeans",
+        num_clusters: int | None = None,
+        distance_metric: Literal["cosine", "euclidean"] = "cosine",
+        text_fields: List[str] | None = None,
+        representatives_per_cluster: int = 3,
+    ) -> Dict[str, Any]:
+        payload = {
+            "filter": filter or {},
+            "limit": limit,
+            "algorithm": algorithm,
+            "num_clusters": num_clusters,
+            "distance_metric": distance_metric,
+            "text_fields": text_fields or [],
+            "representatives_per_cluster": representatives_per_cluster,
+        }
+        return self._h._t.post(f"{self._h._path}/search/cluster", json=payload).json()
+
+    def get(self, id: str, *, with_vector: bool = False) -> Dict[str, Any]:
+        params = {"include_vector": bool(with_vector)}
+        return self._h._t.get(f"{self._h._path}/search/object/{_q(id)}", params=params).json()
+
+    def list(
+        self,
+        *,
+        limit: int = 100,
+        offset: int = 0,
+        with_vector: bool = False,
+        with_properties: bool = True,
+        newest_first: bool = True,
+    ) -> Dict[str, Any]:
+        params = {
+            "limit": limit,
+            "offset": offset,
+            "include_vector": with_vector,
+            "include_properties": with_properties,
+            "newest_first": newest_first,
+        }
+        return self._h._t.get(f"{self._h._path}/search/objects", params=params).json()
+
+    def iterate(
+        self,
+        *,
+        page_size: int = 500,
+        with_vector: bool = False,
+        with_properties: bool = True,
+        newest_first: bool = True,
+    ) -> Iterator[dict[str, Any]]:
+        offset = 0
+        while True:
+            page = self.list(
+                limit=page_size,
+                offset=offset,
+                with_vector=with_vector,
+                with_properties=with_properties,
+                newest_first=newest_first,
+            )
+            objects = page.get("objects") or []
+            if not objects:
+                break
+            for obj in objects:
+                yield obj
+            offset = int(page.get("next_offset") or 0)
+
+
+class IndexSettings:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+
+    def _read(self) -> dict[str, Any]:
+        return self._h._t.get(f"{self._h._path}/settings").json()
+
+    def dimensions(self) -> int:
+        return int(self._read().get("dims", 0))
+
+    def schema(self) -> Dict[str, Any]:
+        return dict(self._read().get("schema") or {})
+
+    def shards(self) -> Dict[str, Any]:
+        return dict(self._read().get("shards") or {})
+
+
+class IndexManage:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+
+    def delete(self, *, ensure_remote: bool = True, drop_keys_table: bool = True):
+        params = {
+            "ensure_remote": ensure_remote,
+            "drop_keys_table": drop_keys_table,
+        }
+        return self._h._t.delete(self._h._path, params=params).json()
+
+    def remove_by_filter(
+        self,
+        *,
+        filter: Dict[str, Any],
+        limit_ids: int | None = None,
+        delete_sql_rows: bool = False,
+        on_missing: Literal["skip", "error"] = "skip",
+        batch_size: int = 500,
+        background: bool = True,
+    ) -> Dict[str, Any]:
+        payload = {
+            "where": filter,
+            "limit_object_ids": limit_ids,
+            "delete_sql_metadata_rows": delete_sql_rows,
+            "on_missing_keys": on_missing,
+            "batch_size": batch_size,
+            "background": background,
+        }
+        return self._h._t.post(f"{self._h._path}/manage/delete-by-filter", json=payload).json()
+
+
+class IndexBatch:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+        self.failed_records: List[FailedRecord] = []
+
+    def with_size(
+        self,
+        *,
+        batch_size: int = 200,
+        max_workers: int = 1,
+        on_error: Literal["raise", "continue"] = "continue",
+    ):
+        return _SizedBatchWriter(
+            manager=self,
+            batch_size=int(batch_size),
+            max_workers=int(max_workers),
+            on_error=on_error,
+        )
+
+
+class _SizedBatchWriter:
+    def __init__(
+        self,
+        *,
+        manager: IndexBatch,
+        batch_size: int,
+        max_workers: int,
+        on_error: Literal["raise", "continue"],
+    ):
+        self._m = manager
+        self._batch_size = max(1, batch_size)
+        self._max_workers = max(1, max_workers)
+        self._on_error = on_error
+
+        self._buffer: List[dict[str, Any]] = []
+        self.failed_records: List[FailedRecord] = []
+        self.number_errors: int = 0
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.flush()
+        self._m.failed_records = list(self.failed_records)
+        return False
+
+    def add(
+        self,
+        *,
+        properties: Dict[str, Any],
+        vector: List[float],
+        id: str | None = None,
+    ) -> str:
+        out_id = str(id) if id is not None else str(uuid4())
+        self._buffer.append(
+            {
+                "properties": properties,
+                "vector": vector,
+                "id": out_id,
+            }
+        )
+        if len(self._buffer) >= self._batch_size:
+            self.flush()
+        return out_id
+
+    def flush(self) -> None:
+        if not self._buffer:
+            return
+
+        payload = list(self._buffer)
+        self._buffer = []
+
+        try:
+            result = self._m._h.records.add_many(
+                payload,
+                on_duplicate="error",
+                on_error="continue",
+                batch_size=self._batch_size,
+                max_workers=self._max_workers,
+            )
+            self.number_errors += result.number_errors
+            self.failed_records.extend(result.failed_records)
+        except Exception as exc:
+            self.number_errors += len(payload)
+            self.failed_records.extend(
+                [FailedRecord(id=str(item.get("id") or ""), error=str(exc)) for item in payload]
+            )
+            if self._on_error == "raise":
+                raise
+
+
+class IndexAgent:
+    def __init__(self, handle: "IndexHandle"):
+        self._h = handle
+
+    def query(
+        self,
+        query: str,
+        *,
+        filter: Dict[str, Any] | None = None,
+        limit: int = 1000,
+        mode: Literal["auto", "cluster", "filter"] = "auto",
+        num_clusters: int | None = None,
+        text_fields: List[str] | None = None,
+        time_field: str = "created_at",
+        failure_field: str = "status",
+        failure_values: List[str] | None = None,
+        recent_days: int = 7,
+    ) -> Dict[str, Any]:
+        payload = {
+            "query": query,
+            "filter": filter or {},
+            "limit": limit,
+            "mode": mode,
+            "num_clusters": num_clusters,
+            "text_fields": text_fields or [],
+            "time_field": time_field,
+            "failure_field": failure_field,
+            "failure_values": failure_values or ["failure", "failed", "error"],
+            "recent_days": recent_days,
+        }
+        return self._h._t.post(f"{self._h._path}/agent/query", json=payload).json()
+
+
+class IndexHandle:
+    def __init__(self, transport: Transport, namespace: str, index: str):
+        self._t = transport
+        self._path = _index_path(namespace, index)
+
+        self.records = IndexRecords(self)
+        self.search = IndexSearch(self)
+        self.settings = IndexSettings(self)
+        self.manage = IndexManage(self)
+        self.batch = IndexBatch(self)
+        self.agent = IndexAgent(self)
+
+
+class IndexesNamespace:
+    def __init__(self, transport: Transport):
+        self._t = transport
+
+    def create_or_get(
+        self,
+        *,
+        namespace: str,
+        index: str,
+        dimensions: int,
+        schema: Dict[str, Any] | None = None,
+        index_options: Dict[str, Any] | None = None,
+        shard_count: int = 1,
+        record_id_property: str = "document_id",
+    ) -> IndexHandle:
+        shard_count = max(1, int(shard_count))
+        payload = {
+            "namespace": namespace,
+            "index": index,
+            "dimensions": int(dimensions),
+            "schema": schema,
+            "index_options": index_options,
+            "shard_count": shard_count,
+            "record_id_property": record_id_property,
+        }
+        self._t.post("/v1/indexes/get-or-create", json=payload)
+        return IndexHandle(self._t, namespace, index)
+
+    def open(self, *, namespace: str, index: str) -> IndexHandle:
+        self._t.get(_index_path(namespace, index))
+        return IndexHandle(self._t, namespace, index)
+
+    def ref(self, *, namespace: str, index: str) -> IndexHandle:
+        return IndexHandle(self._t, namespace, index)
+
+
+class EigenLakeClient:
+    def __init__(
+        self,
+        *,
+        url: str,
+        api_key: str | None = None,
+        timeout: float = 20.0,
+        retries: int = 2,
+    ):
+        self._transport = Transport(
+            base_url=url,
+            api_key=api_key,
+            timeout=timeout,
+            retries=retries,
+        )
+        self.indexes = IndexesNamespace(self._transport)
+
+    def ready(self) -> bool:
+        try:
+            payload = self._transport.get("/v1/health/ready").json()
+            return bool(payload.get("ready"))
+        except Exception:
+            return False
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "EigenLakeClient":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        self.close()
+        return False

eigenlake/errors.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+
+class EigenlakeError(Exception):
+    """Base error for the Eigenlake SDK."""
+
+
+class AuthenticationError(EigenlakeError):
+    pass
+
+
+class NotFoundError(EigenlakeError):
+    pass
+
+
+class ConflictError(EigenlakeError):
+    pass
+
+
+class ValidationError(EigenlakeError):
+    pass
+
+
+class APIError(EigenlakeError):
+    pass
+
+
+class NetworkError(EigenlakeError):
+    pass

eigenlake/py.typed

@@ -0,0 +1 @@
+

eigenlake/schema.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Field:
+    field_type: str
+    required: bool = False
+    filterable: bool = True
+    format: str | None = None
+    description: str | None = None
+    enum: list[Any] | None = None
+    minimum: int | float | None = None
+    maximum: int | float | None = None
+    min_length: int | None = None
+    max_length: int | None = None
+    pattern: str | None = None
+    items: dict[str, Any] | None = None
+    min_items: int | None = None
+    max_items: int | None = None
+    unique_items: bool = False
+
+    def to_json_schema(self) -> dict[str, Any]:
+        out: dict[str, Any] = {"type": self.field_type}
+        if self.format is not None:
+            out["format"] = self.format
+        if self.description is not None:
+            out["description"] = self.description
+        if self.enum is not None:
+            out["enum"] = list(self.enum)
+        if self.minimum is not None:
+            out["minimum"] = self.minimum
+        if self.maximum is not None:
+            out["maximum"] = self.maximum
+        if self.min_length is not None:
+            out["minLength"] = self.min_length
+        if self.max_length is not None:
+            out["maxLength"] = self.max_length
+        if self.pattern is not None:
+            out["pattern"] = self.pattern
+        if self.items is not None:
+            out["items"] = dict(self.items)
+        if self.min_items is not None:
+            out["minItems"] = self.min_items
+        if self.max_items is not None:
+            out["maxItems"] = self.max_items
+        if self.unique_items:
+            out["uniqueItems"] = True
+        return out
+
+
+def string(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    format: str | None = None,
+    description: str | None = None,
+    enum: list[str] | None = None,
+    min_length: int | None = None,
+    max_length: int | None = None,
+    pattern: str | None = None,
+) -> Field:
+    return Field(
+        field_type="string",
+        required=required,
+        filterable=filterable,
+        format=format,
+        description=description,
+        enum=list(enum) if enum is not None else None,
+        min_length=min_length,
+        max_length=max_length,
+        pattern=pattern,
+    )
+
+
+def integer(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+    minimum: int | None = None,
+    maximum: int | None = None,
+) -> Field:
+    return Field(
+        field_type="integer",
+        required=required,
+        filterable=filterable,
+        description=description,
+        minimum=minimum,
+        maximum=maximum,
+    )
+
+
+def number(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+    minimum: int | float | None = None,
+    maximum: int | float | None = None,
+) -> Field:
+    return Field(
+        field_type="number",
+        required=required,
+        filterable=filterable,
+        description=description,
+        minimum=minimum,
+        maximum=maximum,
+    )
+
+
+def boolean(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+) -> Field:
+    return Field(
+        field_type="boolean",
+        required=required,
+        filterable=filterable,
+        description=description,
+    )
+
+
+def array(
+    item: Field | dict[str, Any],
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+    min_items: int | None = None,
+    max_items: int | None = None,
+    unique_items: bool = False,
+) -> Field:
+    if isinstance(item, Field):
+        item_schema = item.to_json_schema()
+    else:
+        item_schema = dict(item)
+    return Field(
+        field_type="array",
+        required=required,
+        filterable=filterable,
+        description=description,
+        items=item_schema,
+        min_items=min_items,
+        max_items=max_items,
+        unique_items=unique_items,
+    )
+
+
+def datetime(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+) -> Field:
+    return string(
+        required=required,
+        filterable=filterable,
+        format="date-time",
+        description=description,
+    )
+
+
+def date(
+    *,
+    required: bool = False,
+    filterable: bool = True,
+    description: str | None = None,
+) -> Field:
+    return string(
+        required=required,
+        filterable=filterable,
+        format="date",
+        description=description,
+    )
+
+
+class SchemaBuilder:
+    def __init__(self, *, additional_properties: bool = False):
+        self._additional_properties = bool(additional_properties)
+        self._fields: dict[str, Field] = {}
+
+    def add(self, name: str, field: Field) -> "SchemaBuilder":
+        self._fields[str(name)] = field
+        return self
+
+    def build(self) -> tuple[dict[str, Any], dict[str, Any]]:
+        properties = {name: field.to_json_schema() for name, field in self._fields.items()}
+        required = [name for name, field in self._fields.items() if field.required]
+        non_filterable = [name for name, field in self._fields.items() if not field.filterable]
+
+        schema: dict[str, Any] = {
+            "type": "object",
+            "additionalProperties": self._additional_properties,
+            "properties": properties,
+        }
+        if required:
+            schema["required"] = required
+
+        index_options: dict[str, Any] = {
+            "metadataConfiguration": {
+                "nonFilterableMetadataKeys": non_filterable,
+            }
+        }
+        return schema, index_options

eigenlake/transport.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import httpx
+
+from .errors import APIError, AuthenticationError, ConflictError, NetworkError, NotFoundError, ValidationError
+
+
+class Transport:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str | None,
+        timeout: float = 20.0,
+        retries: int = 2,
+    ):
+        normalized = base_url.rstrip("/")
+        self._retries = max(0, int(retries))
+        self._client = httpx.Client(
+            base_url=normalized,
+            timeout=float(timeout),
+            headers=self._auth_headers(api_key),
+        )
+
+    @staticmethod
+    def _auth_headers(api_key: str | None) -> dict[str, str]:
+        token = (api_key or "").strip()
+        if not token:
+            return {}
+        return {"X-API-Key": token}
+
+    @staticmethod
+    def _detail(resp: httpx.Response) -> str:
+        try:
+            payload = resp.json()
+            if isinstance(payload, dict) and payload.get("detail") is not None:
+                return str(payload["detail"])
+        except Exception:
+            pass
+        text = (resp.text or "").strip()
+        return text or f"HTTP {resp.status_code}"
+
+    def _raise_for_status(self, resp: httpx.Response) -> None:
+        if 200 <= resp.status_code < 300:
+            return
+
+        detail = self._detail(resp)
+        code = int(resp.status_code)
+
+        if code in (401, 403):
+            raise AuthenticationError(detail)
+        if code == 404:
+            raise NotFoundError(detail)
+        if code == 409:
+            raise ConflictError(detail)
+        if code in (400, 422):
+            raise ValidationError(detail)
+        raise APIError(detail)
+
+    def request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        path = path if path.startswith("/") else f"/{path}"
+
+        last_exc: Exception | None = None
+        for attempt in range(self._retries + 1):
+            try:
+                resp = self._client.request(method.upper(), path, **kwargs)
+            except httpx.RequestError as exc:
+                last_exc = exc
+                if attempt >= self._retries:
+                    raise NetworkError(str(exc)) from exc
+                time.sleep(0.2 * (attempt + 1))
+                continue
+
+            if resp.status_code >= 500 and attempt < self._retries:
+                time.sleep(0.2 * (attempt + 1))
+                continue
+
+            self._raise_for_status(resp)
+            return resp
+
+        if last_exc is not None:
+            raise NetworkError(str(last_exc)) from last_exc
+        raise NetworkError("Request failed")
+
+    def get(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self.request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self.request("POST", path, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self.request("DELETE", path, **kwargs)
+
+    def patch(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self.request("PATCH", path, **kwargs)
+
+    def put(self, path: str, **kwargs: Any) -> httpx.Response:
+        return self.request("PUT", path, **kwargs)
+
+    def close(self) -> None:
+        self._client.close()

eigenlake-0.2.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: eigenlake
+Version: 0.2.0
+Summary: Python SDK for EigenLake Cloud
+Project-URL: Homepage, https://eigenlake.dev
+Project-URL: Documentation, https://docs.eigenlake.dev
+Project-URL: Repository, https://github.com/EigenLake-Org/eigenlake-client
+Project-URL: Issues, https://github.com/EigenLake-Org/eigenlake-client/issues
+Author: EigenLake
+Keywords: agent,clustering,eigenlake,embeddings,vector-search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.0; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25.0; extra == 'docs'
+Requires-Dist: pymdown-extensions>=10.0.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# EigenLake Python Client
+
+Python SDK for EigenLake Cloud.
+
+## Install
+
+```bash
+pip install eigenlake
+```
+
+## Quickstart
+
+```python
+import eigenlake
+from eigenlake import schema as s
+
+with eigenlake.connect(
+    url="https://api.eigenlake.dev",
+    api_key="<sk_sbx_your_api_key_here>",
+) as client:
+    schema, index_options = (
+        s.SchemaBuilder(additional_properties=False)
+        .add("document_id", s.string(required=True, filterable=True))
+        .add("text", s.string(filterable=False))
+        .add("created_at", s.datetime(filterable=True))
+        .build()
+    )
+
+    idx = client.indexes.create_or_get(
+        namespace="demo-namespace",
+        index="demo-index",
+        dimensions=128,
+        schema=schema,
+        index_options=index_options,
+    )
+
+    record_id = idx.records.add(
+        properties={"document_id": "doc-1", "text": "hello"},
+        vector=[0.1] * 128,
+    )
+
+    result = idx.search.nearest(
+        vector=[0.1] * 128,
+        limit=3,
+    )
+    print(record_id, result)
+```
+
+## Agent Query
+
+```python
+import eigenlake
+
+with eigenlake.connect(url="https://api.eigenlake.dev", api_key="<sk_sbx_your_api_key_here>") as client:
+    idx = client.indexes.open(namespace="demo-automotive", index="automotive-fault-clustering")
+    result = idx.agent.query("show me recent battery failures")
+    print(result["filter"])
+```
+
+## Docs
+
+- Documentation source: `docs/`
+- Docs site config: `mkdocs.yml`
+
+```bash
+pip install -e ".[docs]"
+mkdocs serve
+```
+
+Docs will be available at `http://127.0.0.1:8000`.

eigenlake-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+eigenlake/__init__.py,sha256=jWzMPa7Pr0NoMfktENY7D1NSzkOqgj95OpDufdKFh1g,834
+eigenlake/client.py,sha256=fEfDuUedWZUlWBZc7bjCGPBs7I5Ic7QEZW6qJEGuF-k,16316
+eigenlake/errors.py,sha256=4edjrFl99gGVij9iO3bTF015GlyUfv6HraLzVRH3D-s,404
+eigenlake/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+eigenlake/schema.py,sha256=TyH--q4YbNHaSkmIgEglayt04-9XfkUDATn52plTe0k,5652
+eigenlake/transport.py,sha256=f2pxpsaCjXA8hfKCS7PeWAsmf0vRUz74TJmCoFatQAw,3281
+eigenlake-0.2.0.dist-info/METADATA,sha256=VnIb1oq56Arz-YPaVaS9EZZs4A3CHynWn38I406wbks,2757
+eigenlake-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+eigenlake-0.2.0.dist-info/RECORD,,

eigenlake-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