schift 0.3.0__tar.gz → 0.3.3__tar.gz

schift-0.3.3/.github/workflows/publish.yml

@@ -0,0 +1,52 @@
+name: Publish schift to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build twine
+
+      - name: Set pyproject version from release tag
+        if: github.event_name == 'release'
+        run: |
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          sed -i "s/^version = \".*\"$/version = \"${TAG_VERSION}\"/" pyproject.toml
+
+      - name: Build package
+        run: python -m build
+
+      - name: Check distribution
+        run: twine check dist/*
+
+      - name: Ensure PyPI token exists
+        if: github.event_name == 'release'
+        run: |
+          if [ -z "${{ secrets.PYPI_API_TOKEN }}" ]; then
+            echo "PYPI_API_TOKEN secret is missing"
+            exit 1
+          fi
+
+      - name: Publish to PyPI
+        if: github.event_name == 'release'
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: twine upload dist/*

{schift-0.3.0 → schift-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schift
-Version: 0.3.0
+Version: 0.3.3
 Summary: Embedding model migration SDK. Switch models without re-embedding.
 Project-URL: Homepage, https://schift.io
 Project-URL: Documentation, https://docs.schift.io
@@ -62,7 +62,7 @@ Python client and local migration toolkit for Schift.
 
 The package currently exposes two public client styles:
 
-- `Schift`: modular client for live API operations such as catalog lookup, embedding, routing, search, usage, and hosted collection management.
+- `Schift`: modular client for live API operations such as bucket ingest, catalog lookup, embedding, routing, search, usage, and hosted collection management.
 - `Client`: legacy projection client for fitting and downloading `Projection` objects that run locally.
 
 ## Install
@@ -125,6 +125,35 @@ with Schift() as client:
 
 For long-running processes, keep one `Schift` instance and call `close()` during shutdown.
 
+## Bucket Ingest And Search
+
+```python
+from schift import Schift
+
+with Schift() as client:
+    bucket = client.buckets.create(name="finance-docs")
+    upload = client.buckets.upload(
+        bucket["id"],
+        [("files", ("q1-report.pdf", open("q1-report.pdf", "rb").read(), "application/pdf"))],
+    )
+
+    jobs = client.buckets.list_jobs(bucket_id=bucket["id"])
+    hits = client.buckets.search(
+        bucket["id"],
+        "revenue guidance",
+        top_k=5,
+        filter={"metadata": {"quarter": "Q1"}},
+    )
+
+    print(upload["bucket_id"])
+    print(jobs[0]["status"] if jobs else "queued")
+    print(hits[0] if hits else "no hits")
+```
+
+Use `client.db` when you want a generic collection retrieval surface, `POST /v1/chat` for bucket-backed RAG chat with sources, and `POST /v1/chat/completions` for OpenAI-compatible LLM routing without bucket context.
+
+The bucket helper also exposes `get_job()`, `list_jobs()`, `wait_for_job()`, and `poll_job()` so scripts can keep ingest orchestration in one place.
+
 ## Quickstart
 
 ```python

{schift-0.3.0 → schift-0.3.3}/README.md

@@ -4,7 +4,7 @@ Python client and local migration toolkit for Schift.
 
 The package currently exposes two public client styles:
 
-- `Schift`: modular client for live API operations such as catalog lookup, embedding, routing, search, usage, and hosted collection management.
+- `Schift`: modular client for live API operations such as bucket ingest, catalog lookup, embedding, routing, search, usage, and hosted collection management.
 - `Client`: legacy projection client for fitting and downloading `Projection` objects that run locally.
 
 ## Install
@@ -67,6 +67,35 @@ with Schift() as client:
 
 For long-running processes, keep one `Schift` instance and call `close()` during shutdown.
 
+## Bucket Ingest And Search
+
+```python
+from schift import Schift
+
+with Schift() as client:
+    bucket = client.buckets.create(name="finance-docs")
+    upload = client.buckets.upload(
+        bucket["id"],
+        [("files", ("q1-report.pdf", open("q1-report.pdf", "rb").read(), "application/pdf"))],
+    )
+
+    jobs = client.buckets.list_jobs(bucket_id=bucket["id"])
+    hits = client.buckets.search(
+        bucket["id"],
+        "revenue guidance",
+        top_k=5,
+        filter={"metadata": {"quarter": "Q1"}},
+    )
+
+    print(upload["bucket_id"])
+    print(jobs[0]["status"] if jobs else "queued")
+    print(hits[0] if hits else "no hits")
+```
+
+Use `client.db` when you want a generic collection retrieval surface, `POST /v1/chat` for bucket-backed RAG chat with sources, and `POST /v1/chat/completions` for OpenAI-compatible LLM routing without bucket context.
+
+The bucket helper also exposes `get_job()`, `list_jobs()`, `wait_for_job()`, and `poll_job()` so scripts can keep ingest orchestration in one place.
+
 ## Quickstart
 
 ```python

{schift-0.3.0 → schift-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schift"
-version = "0.3.0"
+version = "0.3.3"
 description = "Embedding model migration SDK. Switch models without re-embedding."
 readme = "README.md"
 requires-python = ">=3.9"

{schift-0.3.0 → schift-0.3.3}/schift/_http.py

@@ -42,6 +42,10 @@ class HttpClient:
         resp = self._client.put(path, json=data)
         return self._handle(resp)
 
+    def patch(self, path: str, data: Any = None) -> Any:
+        resp = self._client.patch(path, json=data)
+        return self._handle(resp)
+
     def delete(self, path: str) -> Any:
         resp = self._client.delete(path)
         return self._handle(resp)

schift-0.3.3/schift/aggregate.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class AggregateModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def __call__(self, collection: str, group_by: str, filter_key: Optional[str] = None, filter_value: Optional[str] = None):
+        payload = {"collection": collection, "group_by": group_by}
+        if filter_key is not None:
+            payload["filter_key"] = filter_key
+        if filter_value is not None:
+            payload["filter_value"] = filter_value
+        return self._http.post("/aggregate", data=payload)

schift-0.3.3/schift/artifacts.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class ArtifactsModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, kind: str, uri: str, checksum: Optional[str] = None, dims: Optional[int] = None, content_type: Optional[str] = None, label: Optional[str] = None):
+        payload = {"kind": kind, "uri": uri}
+        if checksum is not None:
+            payload["checksum"] = checksum
+        if dims is not None:
+            payload["dims"] = dims
+        if content_type is not None:
+            payload["content_type"] = content_type
+        if label is not None:
+            payload["label"] = label
+        return self._http.post("/artifacts", data=payload)
+
+    def list(self, kind: Optional[str] = None):
+        params = {}
+        if kind is not None:
+            params["kind"] = kind
+        return self._http.get("/artifacts", params=params)
+
+    def get(self, artifact_id: str):
+        return self._http.get(f"/artifacts/{artifact_id}")

schift-0.3.3/schift/benchmark_suites.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class BenchmarkSuitesModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, name: str, source_model: str, target_model: str, sample_ratios: Optional[dict] = None, **kwargs):
+        payload = {"name": name, "source_model": source_model, "target_model": target_model}
+        if sample_ratios is not None:
+            payload["sample_ratios"] = sample_ratios
+        payload.update(kwargs)
+        return self._http.post("/benchmark-suites", data=payload)
+
+    def list(self):
+        return self._http.get("/benchmark-suites")
+
+    def get(self, suite_id: str):
+        return self._http.get(f"/benchmark-suites/{suite_id}")
+
+    def list_runs(self, suite_id: str):
+        return self._http.get(f"/benchmark-suites/{suite_id}/runs")
+
+    def get_run(self, run_id: str):
+        return self._http.get(f"/benchmark-runs/{run_id}")

schift-0.3.3/schift/buckets.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Optional
+
+from schift._http import HttpClient
+
+
+class BucketsModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, name: str, description: Optional[str] = None):
+        payload = {"name": name}
+        if description is not None:
+            payload["description"] = description
+        return self._http.post("/buckets", data=payload)
+
+    def list(self):
+        return self._http.get("/buckets")
+
+    def delete(self, bucket_id: str):
+        return self._http.delete(f"/buckets/{bucket_id}")
+
+    def search(
+        self,
+        bucket_id: str,
+        query: str,
+        top_k: int = 10,
+        mode: str = "hybrid",
+        rerank: bool = False,
+        model: Optional[str] = None,
+        filter: Optional[dict[str, Any]] = None,
+    ):
+        payload = {"query": query, "top_k": top_k, "mode": mode, "rerank": rerank}
+        if model is not None:
+            payload["model"] = model
+        if filter is not None:
+            payload["filter"] = filter
+        return self._http.post(f"/buckets/{bucket_id}/search", data=payload)
+
+    def graph(self, bucket_id: str, query: Optional[str] = None, top_k: int = 10):
+        params = {"top_k": top_k}
+        if query is not None:
+            params["query"] = query
+        return self._http.get(f"/buckets/{bucket_id}/graph", params=params)
+
+    def upload(self, bucket_id: str, files, ocr_strategy: Optional[str] = None, chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None):
+        meta = {}
+        if ocr_strategy is not None:
+            meta["ocr_strategy"] = ocr_strategy
+        if chunk_size is not None:
+            meta["chunk_size"] = chunk_size
+        if chunk_overlap is not None:
+            meta["chunk_overlap"] = chunk_overlap
+        form_data = {"payload": json.dumps(meta)} if meta else {}
+        return self._http._post_form_with_files(f"/buckets/{bucket_id}/upload", form_data, files)
+
+    def get_job(self, job_id: str):
+        return self._http.get(f"/jobs/{job_id}")
+
+    def list_jobs(
+        self,
+        bucket_id: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: Optional[int] = None,
+    ):
+        params = {}
+        if bucket_id is not None:
+            params["bucket_id"] = bucket_id
+        if status is not None:
+            params["status"] = status
+        if limit is not None:
+            params["limit"] = limit
+        return self._http.get("/jobs", params=params)
+
+    def wait_for_job(
+        self,
+        job_id: str,
+        poll_interval: float = 1.0,
+        timeout: float = 300.0,
+        terminal_statuses: tuple[str, ...] = ("ready", "failed", "cancelled"),
+    ):
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get_job(job_id)
+            status = job.get("status") if isinstance(job, dict) else None
+            if status in terminal_statuses:
+                return job
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"Timed out waiting for job {job_id}")
+            time.sleep(poll_interval)
+
+    def poll_job(
+        self,
+        job_id: str,
+        poll_interval: float = 1.0,
+        timeout: float = 300.0,
+        terminal_statuses: tuple[str, ...] = ("ready", "failed", "cancelled"),
+    ):
+        return self.wait_for_job(
+            job_id,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            terminal_statuses=terminal_statuses,
+        )
+
+    def add_edges(self, bucket_id: str, edges: list):
+        return self._http.post(f"/buckets/{bucket_id}/edges", data={"edges": edges})
+
+    def list_edges(self, bucket_id: str, node_id: str, direction: Optional[str] = None, relation: Optional[str] = None):
+        params = {}
+        if direction is not None:
+            params["direction"] = direction
+        if relation is not None:
+            params["relation"] = relation
+        return self._http.get(f"/buckets/{bucket_id}/edges/{node_id}", params=params)
+
+    def delete_edge(self, bucket_id: str, source: str, target: str, relation: Optional[str] = None):
+        payload = {"source": source, "target": target}
+        if relation is not None:
+            payload["relation"] = relation
+        return self._http.delete_json(f"/buckets/{bucket_id}/edges", data=payload)

schift-0.3.3/schift/completions.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class CompletionsModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, model: str, messages: list, temperature: Optional[float] = None, max_tokens: Optional[int] = None, top_p: Optional[float] = None, stream: bool = False, stop=None):
+        payload = {"model": model, "messages": messages, "stream": stream}
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
+        if top_p is not None:
+            payload["top_p"] = top_p
+        if stop is not None:
+            payload["stop"] = stop
+        return self._http.post("/chat/completions", data=payload)
+
+    def models(self):
+        return self._http.get("/models")

schift-0.3.3/schift/drift.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class DriftModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create_monitor(self, name: str, suite_id: str, cadence: Optional[str] = None, min_recovery_r10: Optional[float] = None):
+        payload = {"name": name, "suite_id": suite_id}
+        if cadence is not None:
+            payload["cadence"] = cadence
+        if min_recovery_r10 is not None:
+            payload["min_recovery_r10"] = min_recovery_r10
+        return self._http.post("/drift-monitors", data=payload)
+
+    def list_monitors(self):
+        return self._http.get("/drift-monitors")
+
+    def get_monitor(self, monitor_id: str):
+        return self._http.get(f"/drift-monitors/{monitor_id}")
+
+    def list_runs(self, monitor_id: str):
+        return self._http.get(f"/drift-monitors/{monitor_id}/runs")
+
+    def get_run(self, drift_run_id: str):
+        return self._http.get(f"/drift-runs/{drift_run_id}")
+
+    def due(self):
+        return self._http.get("/drift-monitor-due")

schift-0.3.3/schift/jobs.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class JobsModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def get(self, job_id: str):
+        return self._http.get(f"/jobs/{job_id}")
+
+    def list(self, org_id: Optional[str] = None, bucket_id: Optional[str] = None, status: Optional[str] = None, limit: Optional[int] = None):
+        params = {}
+        if org_id is not None:
+            params["org_id"] = org_id
+        if bucket_id is not None:
+            params["bucket_id"] = bucket_id
+        if status is not None:
+            params["status"] = status
+        if limit is not None:
+            params["limit"] = limit
+        return self._http.get("/jobs", params=params)
+
+    def cancel(self, job_id: str):
+        return self._http.post(f"/jobs/{job_id}/cancel")
+
+    def reprocess(self, job_id: str):
+        return self._http.post(f"/jobs/{job_id}/reprocess")

schift-0.3.3/schift/tasks.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class TasksModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def similarity(self, text_a: str, text_b: str, model: Optional[str] = None):
+        payload = {"text_a": text_a, "text_b": text_b}
+        if model is not None:
+            payload["model"] = model
+        return self._http.post("/similarity", data=payload)
+
+    def cluster(self, texts: list, n_clusters: int = 5, model: Optional[str] = None):
+        payload = {"texts": texts, "n_clusters": n_clusters}
+        if model is not None:
+            payload["model"] = model
+        return self._http.post("/cluster", data=payload)
+
+    def classify(
+        self,
+        text: str,
+        labels: list,
+        model: Optional[str] = None,
+        temperature: float = 1.0,
+        examples: Optional[list] = None,
+    ):
+        payload = {"text": text, "labels": labels}
+        if model is not None:
+            payload["model"] = model
+        if temperature != 1.0:
+            payload["temperature"] = temperature
+        if examples:
+            payload["examples"] = [
+                {"text": ex["text"], "label": ex["label"]} for ex in examples
+            ]
+        return self._http.post("/classify", data=payload)

schift-0.3.3/schift/workflows.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from schift._http import HttpClient
+
+
+class WorkflowsModule:
+    def __init__(self, http: HttpClient):
+        self._http = http
+
+    def create(self, name: str, description: Optional[str] = None, template: Optional[str] = None, graph: Optional[dict] = None):
+        payload = {"name": name}
+        if description is not None:
+            payload["description"] = description
+        if template is not None:
+            payload["template"] = template
+        if graph is not None:
+            payload["graph"] = graph
+        return self._http.post("/workflows", data=payload)
+
+    def list(self):
+        return self._http.get("/workflows")
+
+    def get(self, workflow_id: str):
+        return self._http.get(f"/workflows/{workflow_id}")
+
+    def update(self, workflow_id: str, name: Optional[str] = None, description: Optional[str] = None, status: Optional[str] = None, graph: Optional[dict] = None):
+        payload = {}
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+        if status is not None:
+            payload["status"] = status
+        if graph is not None:
+            payload["graph"] = graph
+        return self._http.patch(f"/workflows/{workflow_id}", data=payload)
+
+    def delete(self, workflow_id: str):
+        return self._http.delete(f"/workflows/{workflow_id}")
+
+    def add_block(self, workflow_id: str, block_id: str, type: str, config: Optional[dict] = None, position: Optional[dict] = None):
+        payload = {"block_id": block_id, "type": type}
+        if config is not None:
+            payload["config"] = config
+        if position is not None:
+            payload["position"] = position
+        return self._http.post(f"/workflows/{workflow_id}/blocks", data=payload)
+
+    def remove_block(self, workflow_id: str, block_id: str):
+        return self._http.delete(f"/workflows/{workflow_id}/blocks/{block_id}")
+
+    def add_edge(self, workflow_id: str, source: str, target: str, source_port: Optional[str] = None, target_port: Optional[str] = None):
+        payload = {"source": source, "target": target}
+        if source_port is not None:
+            payload["source_port"] = source_port
+        if target_port is not None:
+            payload["target_port"] = target_port
+        return self._http.post(f"/workflows/{workflow_id}/edges", data=payload)
+
+    def remove_edge(self, workflow_id: str, edge_id: str):
+        return self._http.delete(f"/workflows/{workflow_id}/edges/{edge_id}")
+
+    def run(self, workflow_id: str, inputs: Optional[dict] = None, mode: str = "sync"):
+        """Execute a workflow.
+
+        Args:
+            workflow_id: Workflow ID.
+            inputs: Execution inputs.
+            mode: ``"sync"`` (default) blocks until complete;
+                  ``"async"`` returns ``{"id": ..., "workflow_id": ..., "status": "pending"}``
+                  immediately — poll with :meth:`get_run` / :meth:`get_run_logs`.
+        """
+        qs = f"?mode={mode}" if mode != "sync" else ""
+        return self._http.post(f"/workflows/{workflow_id}/run{qs}", data={"inputs": inputs or {}})
+
+    def run_async(self, workflow_id: str, inputs: Optional[dict] = None):
+        """Shorthand for ``run(workflow_id, inputs, mode="async")``."""
+        return self.run(workflow_id, inputs, mode="async")
+
+    def list_runs(self, workflow_id: str):
+        return self._http.get(f"/workflows/{workflow_id}/runs")
+
+    def get_run(self, workflow_id: str, run_id: str):
+        return self._http.get(f"/workflows/{workflow_id}/runs/{run_id}")
+
+    def get_run_logs(self, workflow_id: str, run_id: str, after_seq: int = 0):
+        """Get per-block execution logs for a run.
+
+        Args:
+            after_seq: Only return logs with ``seq > after_seq`` (for polling).
+        """
+        qs = f"?after_seq={after_seq}" if after_seq > 0 else ""
+        return self._http.get(f"/workflows/{workflow_id}/runs/{run_id}/logs{qs}")
+
+    def validate(self, workflow_id: str):
+        return self._http.post(f"/workflows/{workflow_id}/validate")
+
+    def import_yaml(self, yaml_str: str):
+        return self._http.post("/workflows/import", data={"yaml": yaml_str})
+
+    def export_yaml(self, workflow_id: str):
+        return self._http.get(f"/workflows/{workflow_id}/export")
+
+    def generate(self, prompt: str, model: Optional[str] = None):
+        payload = {"prompt": prompt}
+        if model is not None:
+            payload["model"] = model
+        return self._http.post("/workflows/generate", data=payload)
+
+    def block_types(self):
+        return self._http.get("/workflows/meta/block-types")
+
+    def templates(self):
+        return self._http.get("/workflows/meta/templates")