schift 0.1.0__py3-none-any.whl

schift/__init__.py

@@ -0,0 +1,14 @@
+from schift.client import Client
+from schift.async_client import AsyncClient
+from schift.models import EmbedResponse, SearchResult, ClusterResult, ClassifyResult
+from schift.workflow import Workflow, AsyncWorkflow
+from schift.workflow_models import WorkflowResponse, RunResponse, BlockType, WorkflowTemplate, ValidationResult
+from schift.bucket import Bucket, AsyncBucket, JobInfo, UploadResult, BucketStats
+__all__ = [
+    "Client", "AsyncClient",
+    "EmbedResponse", "SearchResult", "ClusterResult", "ClassifyResult",
+    "Workflow", "AsyncWorkflow",
+    "WorkflowResponse", "RunResponse", "BlockType", "WorkflowTemplate", "ValidationResult",
+    "Bucket", "AsyncBucket", "JobInfo", "UploadResult", "BucketStats",
+]
+__version__ = "0.1.0"

schift/async_client.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+import os, asyncio
+import httpx
+from schift.collection import AsyncCollection
+from schift.models import EmbedResponse, ClusterResult, ClassifyResult
+from schift.workflow import AsyncWorkflow
+from schift.bucket import AsyncBucket
+
+_DEFAULT_BASE_URL = "https://api.schift.io"
+
+class AsyncClient:
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, timeout: float = 60.0):
+        self._api_key = api_key or os.environ.get("SCHIFT_API_KEY", "")
+        if not self._api_key:
+            raise ValueError("api_key required (or set SCHIFT_API_KEY env var)")
+        self._base_url = base_url or os.environ.get("SCHIFT_BASE_URL", _DEFAULT_BASE_URL)
+        self._headers = {"Authorization": f"Bearer {self._api_key}"}
+        self._http = httpx.AsyncClient(base_url=self._base_url, timeout=timeout)
+
+    async def _post(self, path: str, body: dict) -> dict:
+        for _ in range(3):
+            resp = await self._http.post(path, json=body, headers=self._headers)
+            if resp.status_code == 429:
+                await asyncio.sleep(float(resp.headers.get("retry-after", 1)))
+                continue
+            resp.raise_for_status()
+            return resp.json()
+        resp.raise_for_status()
+        return {}
+
+    async def embed(self, text: str, task: str | None = None, model: str | None = None, dimensions: int | None = None) -> EmbedResponse:
+        body: dict = {"text": text}
+        if task: body["task_type"] = task
+        if model: body["model"] = model
+        if dimensions: body["dimensions"] = dimensions
+        data = await self._post("/v1/embed", body)
+        return EmbedResponse(values=data["embedding"], model=data.get("model", ""), dimensions=data.get("dimensions", len(data["embedding"])))
+
+    async def embed_batch(self, texts: list[str], task: str | None = None, model: str | None = None, dimensions: int | None = None) -> list[EmbedResponse]:
+        body: dict = {"texts": texts}
+        if task: body["task_type"] = task
+        if model: body["model"] = model
+        if dimensions: body["dimensions"] = dimensions
+        data = await self._post("/v1/embed/batch", body)
+        return [EmbedResponse(values=emb, model=data.get("model", ""), dimensions=data.get("dimensions", len(emb))) for emb in data["embeddings"]]
+
+    def collection(self, name: str) -> AsyncCollection:
+        return AsyncCollection(name, self._http, self._headers)
+
+    def bucket(self, bucket_id: str) -> AsyncBucket:
+        return AsyncBucket(bucket_id, self._http, self._headers)
+
+    async def create_bucket(self, name: str, model: str | None = None, dimension: int = 1024) -> dict:
+        body: dict = {"name": name, "dimension": dimension}
+        if model:
+            body["model"] = model
+        return await self._post("/v1/buckets", body)
+
+    async def similarity(self, text_a: str, text_b: str, model: str | None = None) -> float:
+        body: dict = {"text_a": text_a, "text_b": text_b}
+        if model: body["model"] = model
+        return (await self._post("/v1/similarity", body))["score"]
+
+    async def cluster(self, texts: list[str], n_clusters: int = 5, model: str | None = None) -> ClusterResult:
+        body: dict = {"texts": texts, "n_clusters": n_clusters}
+        if model: body["model"] = model
+        return ClusterResult(**(await self._post("/v1/cluster", body)))
+
+    async def classify(self, text: str, labels: list[str], model: str | None = None) -> ClassifyResult:
+        body: dict = {"text": text, "labels": labels}
+        if model: body["model"] = model
+        return ClassifyResult(**(await self._post("/v1/classify", body)))
+
+    @property
+    def workflow(self) -> AsyncWorkflow:
+        if not hasattr(self, "_workflow"):
+            self._workflow = AsyncWorkflow(self._http, self._headers)
+        return self._workflow
+
+    async def close(self): await self._http.aclose()
+    async def __aenter__(self): return self
+    async def __aexit__(self, *a): await self.close()

schift/bucket.py

@@ -0,0 +1,153 @@
+"""Bucket operations for Schift SDK."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from dataclasses import dataclass, field
+
+if TYPE_CHECKING:
+    import httpx
+
+@dataclass
+class JobInfo:
+    job_id: str
+    file_name: str
+    status: str
+    estimated_cost: float = 0
+    actual_cost: float | None = None
+    chunks_count: int | None = None
+    error_message: str | None = None
+    created_at: str = ""
+    completed_at: str | None = None
+
+@dataclass
+class BucketStats:
+    vector_count: int
+    file_count: int
+    total_cost: float
+
+@dataclass
+class UploadResult:
+    jobs: list[JobInfo]
+    total_estimated_cost: float
+    credit_balance_after_hold: float
+
+
+class Bucket:
+    """Sync bucket operations."""
+
+    def __init__(self, bucket_id: str, http: httpx.Client, headers: dict):
+        self._id = bucket_id
+        self._http = http
+        self._headers = headers
+
+    def upload(self, files: list[tuple[str, bytes]], task: str = "retrieval_document") -> UploadResult:
+        """Upload files to bucket. files = [(filename, bytes), ...]"""
+        multipart = [("files", (name, data)) for name, data in files]
+        resp = self._http.post(
+            f"/v1/buckets/{self._id}/upload",
+            files=multipart,
+            headers=self._headers,
+        )
+        resp.raise_for_status()
+        d = resp.json()
+        return UploadResult(
+            jobs=[JobInfo(**j) for j in d.get("jobs", [])],
+            total_estimated_cost=d.get("total_estimated_cost", 0),
+            credit_balance_after_hold=d.get("credit_balance_after_hold", 0),
+        )
+
+    def upload_file(self, filepath: str, task: str = "retrieval_document") -> UploadResult:
+        """Upload a single file by path."""
+        import os
+        name = os.path.basename(filepath)
+        with open(filepath, "rb") as f:
+            data = f.read()
+        return self.upload([(name, data)], task=task)
+
+    def jobs(self, status: str | None = None) -> list[JobInfo]:
+        """List processing jobs for this bucket."""
+        params = {"bucket_id": self._id}
+        if status:
+            params["status"] = status
+        resp = self._http.get("/v1/jobs", params=params, headers=self._headers)
+        resp.raise_for_status()
+        return [JobInfo(**{k: j.get(k) for k in JobInfo.__dataclass_fields__}) for j in resp.json()]
+
+    def job(self, job_id: str) -> JobInfo:
+        """Get specific job status."""
+        resp = self._http.get(f"/v1/jobs/{job_id}", headers=self._headers)
+        resp.raise_for_status()
+        j = resp.json()
+        return JobInfo(**{k: j.get(k) for k in JobInfo.__dataclass_fields__})
+
+    def cancel_job(self, job_id: str) -> dict:
+        """Cancel a queued job."""
+        resp = self._http.post(f"/v1/jobs/{job_id}/cancel", json={}, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def search(self, query: str, top_k: int = 10, task: str = "retrieval_query",
+               filter: dict | None = None) -> list[dict]:
+        """Search within bucket."""
+        body = {"query": query, "top_k": top_k, "task": task}
+        if filter:
+            body["filter"] = filter
+        resp = self._http.post(f"/v1/buckets/{self._id}/search", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json().get("results", [])
+
+    def stats(self) -> BucketStats:
+        """Get bucket stats."""
+        resp = self._http.get(f"/v1/collections/{self._id}/stats", headers=self._headers)
+        resp.raise_for_status()
+        d = resp.json()
+        return BucketStats(
+            vector_count=d.get("vector_count", 0),
+            file_count=d.get("file_count", 0),
+            total_cost=d.get("total_cost", 0),
+        )
+
+    def delete(self) -> None:
+        """Delete the bucket and all its data."""
+        resp = self._http.delete(f"/v1/buckets/{self._id}", headers=self._headers)
+        resp.raise_for_status()
+
+
+class AsyncBucket:
+    """Async bucket operations."""
+
+    def __init__(self, bucket_id: str, http: httpx.AsyncClient, headers: dict):
+        self._id = bucket_id
+        self._http = http
+        self._headers = headers
+
+    async def upload(self, files: list[tuple[str, bytes]], task: str = "retrieval_document") -> UploadResult:
+        multipart = [("files", (name, data)) for name, data in files]
+        resp = await self._http.post(f"/v1/buckets/{self._id}/upload", files=multipart, headers=self._headers)
+        resp.raise_for_status()
+        d = resp.json()
+        return UploadResult(
+            jobs=[JobInfo(**j) for j in d.get("jobs", [])],
+            total_estimated_cost=d.get("total_estimated_cost", 0),
+            credit_balance_after_hold=d.get("credit_balance_after_hold", 0),
+        )
+
+    async def jobs(self, status: str | None = None) -> list[JobInfo]:
+        params = {"bucket_id": self._id}
+        if status:
+            params["status"] = status
+        resp = await self._http.get("/v1/jobs", params=params, headers=self._headers)
+        resp.raise_for_status()
+        return [JobInfo(**{k: j.get(k) for k in JobInfo.__dataclass_fields__}) for j in resp.json()]
+
+    async def search(self, query: str, top_k: int = 10, task: str = "retrieval_query",
+                     filter: dict | None = None) -> list[dict]:
+        body = {"query": query, "top_k": top_k, "task": task}
+        if filter:
+            body["filter"] = filter
+        resp = await self._http.post(f"/v1/buckets/{self._id}/search", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json().get("results", [])
+
+    async def delete(self) -> None:
+        resp = await self._http.delete(f"/v1/buckets/{self._id}", headers=self._headers)
+        resp.raise_for_status()

schift/client.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+import os, time
+import httpx
+from schift.collection import Collection
+from schift.models import EmbedResponse, ClusterResult, ClassifyResult
+from schift.workflow import Workflow
+from schift.bucket import Bucket
+
+_DEFAULT_BASE_URL = "https://api.schift.io"
+
+class Client:
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, timeout: float = 60.0):
+        self._api_key = api_key or os.environ.get("SCHIFT_API_KEY", "")
+        if not self._api_key:
+            raise ValueError("api_key required (or set SCHIFT_API_KEY env var)")
+        self._base_url = base_url or os.environ.get("SCHIFT_BASE_URL", _DEFAULT_BASE_URL)
+        self._headers = {"Authorization": f"Bearer {self._api_key}"}
+        self._http = httpx.Client(base_url=self._base_url, timeout=timeout)
+
+    def _post(self, path: str, body: dict) -> dict:
+        for _ in range(3):
+            resp = self._http.post(path, json=body, headers=self._headers)
+            if resp.status_code == 429:
+                time.sleep(float(resp.headers.get("retry-after", 1)))
+                continue
+            resp.raise_for_status()
+            return resp.json()
+        resp.raise_for_status()
+        return {}
+
+    def embed(self, text: str, task: str | None = None, model: str | None = None, dimensions: int | None = None) -> EmbedResponse:
+        body: dict = {"text": text}
+        if task: body["task_type"] = task
+        if model: body["model"] = model
+        if dimensions: body["dimensions"] = dimensions
+        data = self._post("/v1/embed", body)
+        return EmbedResponse(values=data["embedding"], model=data.get("model", ""), dimensions=data.get("dimensions", len(data["embedding"])))
+
+    def embed_batch(self, texts: list[str], task: str | None = None, model: str | None = None, dimensions: int | None = None) -> list[EmbedResponse]:
+        body: dict = {"texts": texts}
+        if task: body["task_type"] = task
+        if model: body["model"] = model
+        if dimensions: body["dimensions"] = dimensions
+        data = self._post("/v1/embed/batch", body)
+        return [EmbedResponse(values=emb, model=data.get("model", ""), dimensions=data.get("dimensions", len(emb))) for emb in data["embeddings"]]
+
+    def collection(self, name: str) -> Collection:
+        return Collection(name, self._http, self._headers)
+
+    def bucket(self, bucket_id: str) -> Bucket:
+        return Bucket(bucket_id, self._http, self._headers)
+
+    def create_bucket(self, name: str, model: str | None = None, dimension: int = 1024) -> dict:
+        body: dict = {"name": name, "dimension": dimension}
+        if model:
+            body["model"] = model
+        return self._post("/v1/buckets", body)
+
+    def list_buckets(self) -> list[dict]:
+        resp = self._http.get("/v1/buckets", headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def similarity(self, text_a: str, text_b: str, model: str | None = None) -> float:
+        body: dict = {"text_a": text_a, "text_b": text_b}
+        if model: body["model"] = model
+        return self._post("/v1/similarity", body)["score"]
+
+    def cluster(self, texts: list[str], n_clusters: int = 5, model: str | None = None) -> ClusterResult:
+        body: dict = {"texts": texts, "n_clusters": n_clusters}
+        if model: body["model"] = model
+        return ClusterResult(**self._post("/v1/cluster", body))
+
+    def classify(self, text: str, labels: list[str], model: str | None = None) -> ClassifyResult:
+        body: dict = {"text": text, "labels": labels}
+        if model: body["model"] = model
+        return ClassifyResult(**self._post("/v1/classify", body))
+
+    @property
+    def workflow(self) -> Workflow:
+        if not hasattr(self, "_workflow"):
+            self._workflow = Workflow(self._http, self._headers)
+        return self._workflow
+
+    def close(self): self._http.close()
+    def __enter__(self): return self
+    def __exit__(self, *a): self.close()

schift/collection.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from schift.models import SearchResult
+
+if TYPE_CHECKING:
+    import httpx
+
+class Collection:
+    def __init__(self, name: str, http: httpx.Client, headers: dict):
+        self._name = name
+        self._http = http
+        self._headers = headers
+
+    def add(self, documents: list[str], ids: list[str] | None = None,
+            metadata: list[dict] | None = None, task: str | None = None,
+            model: str | None = None) -> dict:
+        body: dict = {"documents": documents}
+        if ids: body["ids"] = ids
+        if metadata: body["metadata"] = metadata
+        if task: body["task"] = task
+        if model: body["model"] = model
+        resp = self._http.post(f"/v1/collections/{self._name}/add", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def search(self, query: str, task: str | None = None, top_k: int = 10,
+               filter: dict | None = None, model: str | None = None) -> list[SearchResult]:
+        body: dict = {"query": query, "top_k": top_k}
+        if task: body["task"] = task
+        if filter: body["filter"] = filter
+        if model: body["model"] = model
+        resp = self._http.post(f"/v1/collections/{self._name}/search", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return [SearchResult(**r) for r in resp.json().get("results", [])]
+
+    def upsert(self, vectors: list[dict]) -> dict:
+        resp = self._http.post(f"/v1/collections/{self._name}/vectors", json={"vectors": vectors}, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def search_by_vector(self, query_vector: list[float], top_k: int = 10) -> list[SearchResult]:
+        resp = self._http.post("/v1/query", json={"query_vector": query_vector, "collection": self._name, "top_k": top_k}, headers=self._headers)
+        resp.raise_for_status()
+        data = resp.json()
+        return [SearchResult(**r) for r in (data.get("results", data) if isinstance(data, dict) else data)]
+
+
+class AsyncCollection:
+    def __init__(self, name: str, http: httpx.AsyncClient, headers: dict):
+        self._name = name
+        self._http = http
+        self._headers = headers
+
+    async def add(self, documents: list[str], ids: list[str] | None = None,
+                  metadata: list[dict] | None = None, task: str | None = None,
+                  model: str | None = None) -> dict:
+        body: dict = {"documents": documents}
+        if ids: body["ids"] = ids
+        if metadata: body["metadata"] = metadata
+        if task: body["task"] = task
+        if model: body["model"] = model
+        resp = await self._http.post(f"/v1/collections/{self._name}/add", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def search(self, query: str, task: str | None = None, top_k: int = 10,
+                     filter: dict | None = None, model: str | None = None) -> list[SearchResult]:
+        body: dict = {"query": query, "top_k": top_k}
+        if task: body["task"] = task
+        if filter: body["filter"] = filter
+        if model: body["model"] = model
+        resp = await self._http.post(f"/v1/collections/{self._name}/search", json=body, headers=self._headers)
+        resp.raise_for_status()
+        return [SearchResult(**r) for r in resp.json().get("results", [])]
+
+    async def upsert(self, vectors: list[dict]) -> dict:
+        resp = await self._http.post(f"/v1/collections/{self._name}/vectors", json={"vectors": vectors}, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def search_by_vector(self, query_vector: list[float], top_k: int = 10) -> list[SearchResult]:
+        resp = await self._http.post("/v1/query", json={"query_vector": query_vector, "collection": self._name, "top_k": top_k}, headers=self._headers)
+        resp.raise_for_status()
+        data = resp.json()
+        return [SearchResult(**r) for r in (data.get("results", data) if isinstance(data, dict) else data)]

schift/models.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+@dataclass
+class EmbedResponse:
+    values: list[float]
+    model: str
+    dimensions: int
+
+@dataclass
+class SearchResult:
+    id: str
+    metadata: dict
+    score: float
+
+@dataclass
+class ClusterResult:
+    labels: list[int]
+    centroids: list[list[float]]
+    n_clusters: int
+
+@dataclass
+class ClassifyResult:
+    label: str
+    scores: dict[str, float]

schift/workflow.py

@@ -0,0 +1,206 @@
+"""Workflow operations for Schift SDK."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from schift.workflow_models import WorkflowResponse, RunResponse, ValidationResult
+
+if TYPE_CHECKING:
+    import httpx
+
+
+class Workflow:
+    """Sync workflow operations."""
+
+    def __init__(self, http: httpx.Client, headers: dict):
+        self._http = http
+        self._headers = headers
+
+    def _post(self, path: str, body: dict | None = None):
+        resp = self._http.post(path, json=body or {}, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json() if resp.content else None
+
+    def _get(self, path: str):
+        resp = self._http.get(path, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _patch(self, path: str, body: dict):
+        resp = self._http.patch(path, json=body, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _delete(self, path: str):
+        resp = self._http.delete(path, headers=self._headers)
+        resp.raise_for_status()
+
+    def _parse_workflow(self, data: dict) -> WorkflowResponse:
+        return WorkflowResponse(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            status=data.get("status", ""),
+            description=data.get("description", ""),
+            graph=data.get("graph", {}),
+        )
+
+    def _parse_run(self, data: dict) -> RunResponse:
+        return RunResponse(
+            run_id=data.get("run_id", ""),
+            status=data.get("status", ""),
+            outputs=data.get("outputs") or {},
+            error=data.get("error"),
+            block_states=data.get("block_states") or {},
+        )
+
+    def create(self, name: str, template: str | None = None,
+               description: str = "") -> WorkflowResponse:
+        body: dict = {"name": name, "description": description}
+        if template:
+            body["template"] = template
+        data = self._post("/v1/workflows", body)
+        return self._parse_workflow(data)
+
+    def get(self, workflow_id: str) -> WorkflowResponse:
+        data = self._get(f"/v1/workflows/{workflow_id}")
+        return self._parse_workflow(data)
+
+    def list(self) -> list[WorkflowResponse]:
+        data = self._get("/v1/workflows")
+        return [self._parse_workflow(d) for d in data]
+
+    def update(self, workflow_id: str, **kwargs) -> WorkflowResponse:
+        data = self._patch(f"/v1/workflows/{workflow_id}", kwargs)
+        return self._parse_workflow(data)
+
+    def delete(self, workflow_id: str) -> None:
+        self._delete(f"/v1/workflows/{workflow_id}")
+
+    def run(self, workflow_id: str, inputs: dict | None = None) -> RunResponse:
+        data = self._post(f"/v1/workflows/{workflow_id}/run", {"inputs": inputs or {}})
+        return self._parse_run(data)
+
+    def runs(self, workflow_id: str) -> list[RunResponse]:
+        data = self._get(f"/v1/workflows/{workflow_id}/runs")
+        return [self._parse_run(d) for d in data]
+
+    def validate(self, workflow_id: str) -> ValidationResult:
+        data = self._post(f"/v1/workflows/{workflow_id}/validate")
+        return ValidationResult(valid=data.get("valid", False), errors=data.get("errors", []))
+
+    def add_block(self, workflow_id: str, block_type: str, title: str = "",
+                  config: dict | None = None) -> dict:
+        return self._post(f"/v1/workflows/{workflow_id}/blocks",
+                          {"type": block_type, "title": title, "config": config or {}})
+
+    def add_edge(self, workflow_id: str, source: str, target: str) -> dict:
+        return self._post(f"/v1/workflows/{workflow_id}/edges",
+                          {"source": source, "target": target})
+
+    # Template shortcuts
+    def create_rag(self, name: str = "RAG Pipeline") -> WorkflowResponse:
+        return self.create(name, template="BASIC_RAG")
+
+    def create_doc_qa(self, name: str = "Document QA") -> WorkflowResponse:
+        return self.create(name, template="DOCUMENT_QA")
+
+    def create_chat(self, name: str = "Chat RAG") -> WorkflowResponse:
+        return self.create(name, template="CHAT_RAG")
+
+    def create_ocr_ingest(self, name: str = "OCR Ingest") -> WorkflowResponse:
+        return self.create(name, template="IMAGE_OCR_INGEST")
+
+
+class AsyncWorkflow:
+    """Async workflow operations."""
+
+    def __init__(self, http: httpx.AsyncClient, headers: dict):
+        self._http = http
+        self._headers = headers
+
+    async def _post(self, path: str, body: dict | None = None):
+        resp = await self._http.post(path, json=body or {}, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json() if resp.content else None
+
+    async def _get(self, path: str):
+        resp = await self._http.get(path, headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _parse_workflow(self, data: dict) -> WorkflowResponse:
+        return WorkflowResponse(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            status=data.get("status", ""),
+            description=data.get("description", ""),
+            graph=data.get("graph", {}),
+        )
+
+    def _parse_run(self, data: dict) -> RunResponse:
+        return RunResponse(
+            run_id=data.get("run_id", ""),
+            status=data.get("status", ""),
+            outputs=data.get("outputs") or {},
+            error=data.get("error"),
+            block_states=data.get("block_states") or {},
+        )
+
+    async def create(self, name: str, template: str | None = None,
+                     description: str = "") -> WorkflowResponse:
+        body: dict = {"name": name, "description": description}
+        if template:
+            body["template"] = template
+        data = await self._post("/v1/workflows", body)
+        return self._parse_workflow(data)
+
+    async def get(self, workflow_id: str) -> WorkflowResponse:
+        data = await self._get(f"/v1/workflows/{workflow_id}")
+        return self._parse_workflow(data)
+
+    async def list(self) -> list[WorkflowResponse]:
+        data = await self._get("/v1/workflows")
+        return [self._parse_workflow(d) for d in data]
+
+    async def update(self, workflow_id: str, **kwargs) -> WorkflowResponse:
+        resp = await self._http.patch(f"/v1/workflows/{workflow_id}",
+                                      json=kwargs, headers=self._headers)
+        resp.raise_for_status()
+        return self._parse_workflow(resp.json())
+
+    async def delete(self, workflow_id: str) -> None:
+        resp = await self._http.delete(f"/v1/workflows/{workflow_id}",
+                                       headers=self._headers)
+        resp.raise_for_status()
+
+    async def run(self, workflow_id: str, inputs: dict | None = None) -> RunResponse:
+        data = await self._post(f"/v1/workflows/{workflow_id}/run", {"inputs": inputs or {}})
+        return self._parse_run(data)
+
+    async def runs(self, workflow_id: str) -> list[RunResponse]:
+        data = await self._get(f"/v1/workflows/{workflow_id}/runs")
+        return [self._parse_run(d) for d in data]
+
+    async def validate(self, workflow_id: str) -> ValidationResult:
+        data = await self._post(f"/v1/workflows/{workflow_id}/validate")
+        return ValidationResult(valid=data.get("valid", False), errors=data.get("errors", []))
+
+    async def add_block(self, workflow_id: str, block_type: str, title: str = "",
+                        config: dict | None = None) -> dict:
+        return await self._post(f"/v1/workflows/{workflow_id}/blocks",
+                                {"type": block_type, "title": title, "config": config or {}})
+
+    async def add_edge(self, workflow_id: str, source: str, target: str) -> dict:
+        return await self._post(f"/v1/workflows/{workflow_id}/edges",
+                                {"source": source, "target": target})
+
+    # Template shortcuts
+    async def create_rag(self, name: str = "RAG Pipeline") -> WorkflowResponse:
+        return await self.create(name, template="BASIC_RAG")
+
+    async def create_doc_qa(self, name: str = "Document QA") -> WorkflowResponse:
+        return await self.create(name, template="DOCUMENT_QA")
+
+    async def create_chat(self, name: str = "Chat RAG") -> WorkflowResponse:
+        return await self.create(name, template="CHAT_RAG")
+
+    async def create_ocr_ingest(self, name: str = "OCR Ingest") -> WorkflowResponse:
+        return await self.create(name, template="IMAGE_OCR_INGEST")

schift/workflow_models.py

@@ -0,0 +1,53 @@
+"""Workflow response models."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class BlockType(str, Enum):
+    START = "START"
+    END = "END"
+    DOCUMENT_LOADER = "DOCUMENT_LOADER"
+    DOCUMENT_PARSER = "DOCUMENT_PARSER"
+    CHUNKER = "CHUNKER"
+    EMBEDDER = "EMBEDDER"
+    VECTOR_STORE = "VECTOR_STORE"
+    RETRIEVER = "RETRIEVER"
+    RERANKER = "RERANKER"
+    LLM = "LLM"
+    PROMPT_TEMPLATE = "PROMPT_TEMPLATE"
+    CONDITION = "CONDITION"
+    CODE = "CODE"
+    ANSWER = "ANSWER"
+
+
+class WorkflowTemplate(str, Enum):
+    BASIC_RAG = "BASIC_RAG"
+    DOCUMENT_QA = "DOCUMENT_QA"
+    CONVERSATIONAL_RAG = "CONVERSATIONAL_RAG"
+    IMAGE_OCR_INGEST = "IMAGE_OCR_INGEST"
+    CHAT_RAG = "CHAT_RAG"
+
+
+@dataclass
+class WorkflowResponse:
+    id: str
+    name: str
+    status: str
+    description: str = ""
+    graph: dict = field(default_factory=dict)
+
+
+@dataclass
+class RunResponse:
+    run_id: str
+    status: str
+    outputs: dict = field(default_factory=dict)
+    error: str | None = None
+    block_states: dict = field(default_factory=dict)
+
+
+@dataclass
+class ValidationResult:
+    valid: bool
+    errors: list[str] = field(default_factory=list)

schift-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: schift
+Version: 0.1.0
+Summary: Schift SDK — Canonical Embedding Space
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: async
+Requires-Dist: httpx[http2]>=0.27; extra == 'async'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'

schift-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+schift/__init__.py,sha256=ERGZ9W6p95sVCP-J2l-fa1NvjbL0pVfq9SAR70VoRbU,741
+schift/async_client.py,sha256=NmPgpGiHQzV37YsGniIuNlH-07O1Z9PZJPPCZ9IEaIM,4005
+schift/bucket.py,sha256=_uV9W5fMc8JytSzpFPeJcNJ9WGO8_8Xej8yTvtjB240,5744
+schift/client.py,sha256=Ab_3o2Ek_7gw-LRTjf92E9Yh8zJ5IhGT1AzecErCeTY,3985
+schift/collection.py,sha256=aYWUVpjcGnqj-Kf7jaU75RQwhjVaB3V8GIPkDvIi300,4080
+schift/models.py,sha256=RVRdNpdOerJJ2FPYAvA0CCfYj42XXmcKOd4e1zM2QsM,427
+schift/workflow.py,sha256=vxMN9extCUuVX86ewwt5nMg239xhHo2GfY7uOcpkWzw,8478
+schift/workflow_models.py,sha256=VOq_ixu6odvHGt_zh1OFjwYQRv794IBaREZQF85Vk-Y,1199
+schift-0.1.0.dist-info/METADATA,sha256=4LIgnG3ksqwLPo_Crf-P-rGLIt2c5IKaQICCc5PjRLk,382
+schift-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+schift-0.1.0.dist-info/RECORD,,

schift-0.1.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