synapsai-python 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

synapsai/__init__.py

@@ -5,12 +5,13 @@ A scalable and maintainable Python client library for interacting with SynapsAI
 compatible with OpenAI API patterns.
 """
 
-from .client import SynapsAI, AsyncSynapsAI
+from .client import SynapsAI, AsyncSynapsAI, DEFAULT_UPLOAD_BASE_URL
 from .types import *
 from .resources import *
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 __all__ = [
     "SynapsAI",
     "AsyncSynapsAI",
+    "DEFAULT_UPLOAD_BASE_URL",
 ]

synapsai/cli.py

@@ -0,0 +1,168 @@
+# Copyright 2026 SynapsAI Technologies Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Command-line interface for SynapsAI uploads."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import List, Optional
+
+import click
+
+from .client import SynapsAI
+from .exceptions import APIError
+
+
+def _resolve_api_key(api_key: Optional[str]) -> str:
+    value = api_key or os.environ.get("SYNAPSAI_API_KEY")
+    if not value:
+        raise click.ClickException(
+            "API key required. Pass --api-key or set SYNAPSAI_API_KEY."
+        )
+    return value
+
+
+def _normalize_base_url(host: str) -> str:
+    value = host.strip().rstrip("/")
+    if not value.startswith("http://") and not value.startswith("https://"):
+        value = f"https://{value}"
+    if not value.endswith("/v1"):
+        value = f"{value}/v1"
+    return value
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="synapsai")
+def main() -> None:
+    """SynapsAI Cloud CLI."""
+
+
+@main.command("upload-model")
+@click.argument("path", type=click.Path(exists=True, file_okay=True, dir_okay=True))
+@click.option("--artifact-id", required=True, help="Existing model artifact id to upload into.")
+@click.option(
+    "--host",
+    default=None,
+    help="API host (default: SYNAPSAI_API_BASE or https://api.synapsai.cloud/v1).",
+)
+@click.option("--api-key", default=None, help="API key (default: SYNAPSAI_API_KEY).")
+@click.option("--timeout", default=3600.0, show_default=True, type=float, help="Request timeout seconds.")
+def upload_model(
+    path: str,
+    artifact_id: str,
+    host: Optional[str],
+    api_key: Optional[str],
+    timeout: float,
+) -> None:
+    """Upload model files into an existing artifact on the API.
+
+    PATH may be a single file or a directory of model weights/config files.
+    Starts an upload session, streams files, then completes ingest.
+    Uses the same host as the rest of the API (``SYNAPSAI_API_BASE`` or
+    ``https://api.synapsai.cloud/v1``).
+    """
+    base_url = _normalize_base_url(host) if host else None
+    client = SynapsAI(api_key=_resolve_api_key(api_key), base_url=base_url, timeout=timeout)
+
+    def on_progress(relative: str, index: int, total: int) -> None:
+        click.echo(f"[{index}/{total}] uploading {relative}")
+
+    try:
+        artifact = client.model_artifacts.upload(
+            path,
+            artifact_id=artifact_id,
+            on_progress=on_progress,
+        )
+    except (APIError, OSError, ValueError) as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    click.echo(
+        json.dumps(
+            {
+                "id": artifact.id,
+                "display_name": artifact.display_name,
+                "pipeline": artifact.pipeline,
+                "status": artifact.status,
+                "size_gb": artifact.size_gb,
+            },
+            indent=2,
+        )
+    )
+
+
+@main.command("upload-vector-store-files")
+@click.argument("vector_store_id")
+@click.argument("paths", nargs=-1, required=True, type=click.Path(exists=True))
+@click.option(
+    "--host",
+    default=None,
+    help="API host (default: SYNAPSAI_API_BASE or https://api.synapsai.cloud/v1).",
+)
+@click.option("--api-key", default=None, help="API key (default: SYNAPSAI_API_KEY).")
+@click.option(
+    "--attributes",
+    default=None,
+    help="Optional JSON object applied as metadata attributes on each upload.",
+)
+@click.option("--timeout", default=600.0, show_default=True, type=float, help="Request timeout seconds.")
+def upload_vector_store_files(
+    vector_store_id: str,
+    paths: List[str],
+    host: Optional[str],
+    api_key: Optional[str],
+    attributes: Optional[str],
+    timeout: float,
+) -> None:
+    """Upload files or directories into a vector store.
+
+    Each PATH may be an individual file or a directory (recursively uploaded).
+    """
+    parsed_attributes = None
+    if attributes:
+        try:
+            parsed_attributes = json.loads(attributes)
+        except json.JSONDecodeError as exc:
+            raise click.ClickException("--attributes must be valid JSON") from exc
+        if not isinstance(parsed_attributes, dict):
+            raise click.ClickException("--attributes must be a JSON object")
+
+    base_url = None
+    if host:
+        base_url = _normalize_base_url(host)
+
+    client = SynapsAI(
+        api_key=_resolve_api_key(api_key),
+        base_url=base_url,
+        timeout=timeout,
+    )
+
+    try:
+        results = client.vector_stores.files.upload_paths(
+            vector_store_id,
+            list(paths),
+            attributes=parsed_attributes,
+        )
+    except (APIError, OSError, ValueError) as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    for item in results:
+        click.echo(f"{item.id}\t{item.status}\t{item.usage_bytes}")
+
+    click.echo(f"Uploaded {len(results)} file(s) to vector store {vector_store_id}")
+
+
+if __name__ == "__main__":
+    main()

synapsai/client.py

@@ -49,6 +49,14 @@ from .resources import (
     AsyncFillMaskResource,
     RerankResource,
     AsyncRerankResource,
+    VectorStoresResource,
+    AsyncVectorStoresResource,
+    ModelArtifactsResource,
+    AsyncModelArtifactsResource,
+    AgentsResource,
+    AsyncAgentsResource,
+    ResponsesResource,
+    AsyncResponsesResource,
 )
 from .exceptions import APIError, AuthenticationError
 from .utils import build_url
@@ -56,6 +64,9 @@ from .logging import get_logger
 
 logger = get_logger(__name__)
 
+DEFAULT_BASE_URL = "https://api.synapsai.cloud/v1"
+
+
 class BaseClient:
     """Base client with common functionality"""
 
@@ -91,7 +102,7 @@ class BaseClient:
             base_url = os.environ.get("SYNAPSAI_API_BASE")
 
         if base_url is None:
-            base_url = "https://api.synapsai.cloud/v1"
+            base_url = DEFAULT_BASE_URL
 
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
@@ -208,6 +219,10 @@ class SynapsAI(BaseClient):
     feature_extraction: FeatureExtractionResource
     fill_mask: FillMaskResource
     rerank: RerankResource
+    vector_stores: VectorStoresResource
+    model_artifacts: ModelArtifactsResource
+    agents: AgentsResource
+    responses: ResponsesResource
 
     def __init__(self, api_key: Optional[str] = None, **kwargs):
         super().__init__(api_key=api_key, **kwargs)
@@ -232,6 +247,10 @@ class SynapsAI(BaseClient):
         self.feature_extraction = FeatureExtractionResource(self)
         self.fill_mask = FillMaskResource(self)
         self.rerank = RerankResource(self)
+        self.vector_stores = VectorStoresResource(self)
+        self.model_artifacts = ModelArtifactsResource(self)
+        self.agents = AgentsResource(self)
+        self.responses = ResponsesResource(self)
 
     def __enter__(self):
         return self
@@ -243,13 +262,56 @@ class SynapsAI(BaseClient):
         """Close the HTTP client"""
         self._client.close()
 
+    def _prepare_request_kwargs(
+        self,
+        method: str,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        """Build httpx request kwargs, clearing Content-Type for multipart/raw bodies."""
+        url = build_url(self.base_url, endpoint)
+        kwargs: Dict[str, Any] = {
+            "method": method,
+            "url": url,
+            "timeout": self.timeout,
+        }
+        if json_data is not None:
+            kwargs["json"] = json_data
+        if data is not None:
+            kwargs["data"] = data
+        if files is not None:
+            kwargs["files"] = files
+        if content is not None:
+            kwargs["content"] = content
+        if params is not None:
+            kwargs["params"] = params
+        if stream:
+            kwargs["stream"] = True
+
+        request_headers = dict(headers or {})
+        if files is not None or content is not None:
+            # Let httpx set multipart/raw content-type; drop JSON default.
+            request_headers.setdefault("Content-Type", None)
+        if request_headers:
+            kwargs["headers"] = request_headers
+        return kwargs
+
     def _request(
         self,
         method: str,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
         stream: bool = False,
     ) -> httpx.Response:
         """
@@ -257,24 +319,17 @@ class SynapsAI(BaseClient):
 
         Retries on network errors, timeouts, and server-side errors (429, 5xx).
         """
-        url = build_url(self.base_url, endpoint)
-
-        # prepare kwargs used for every attempt
-        base_kwargs = {
-            "method": method,
-            "url": url,
-            "timeout": self.timeout,
-        }
-
-        if json_data:
-            base_kwargs["json"] = json_data
-        if data:
-            base_kwargs["data"] = data
-        if files:
-            base_kwargs["files"] = files
-        if stream:
-            # note: for streaming we still attempt to (re)establish the stream on failures opening it
-            base_kwargs["stream"] = True
+        base_kwargs = self._prepare_request_kwargs(
+            method=method,
+            endpoint=endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+            stream=stream,
+        )
 
         attempt = 0
         last_exc: Optional[BaseException] = None
@@ -325,26 +380,71 @@ class SynapsAI(BaseClient):
         self,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> httpx.Response:
         """Make a POST request"""
-        return self._request("POST", endpoint, json_data, data, files)
-
-    def _get(self, endpoint: str) -> httpx.Response:
+        return self._request(
+            "POST",
+            endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
+
+    def _put(
+        self,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Make a PUT request"""
+        return self._request(
+            "PUT",
+            endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
+
+    def _get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
         """Make a GET request"""
-        return self._request("GET", endpoint)
+        return self._request("GET", endpoint, params=params)
 
-    def _delete(self, endpoint: str) -> httpx.Response:
+    def _delete(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
         """Make a DELETE request"""
-        return self._request("DELETE", endpoint)
+        return self._request("DELETE", endpoint, params=params)
 
     def _stream_response(
         self,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> Iterator[Dict[str, Any]]:
         """
         Stream response data from a POST endpoint.
@@ -352,15 +452,16 @@ class SynapsAI(BaseClient):
         The attempt to establish the stream will be retried using the same backoff rules.
         Once the stream is established, streaming errors are raised as-is.
         """
-        url = build_url(self.base_url, endpoint)
-        base_kwargs = {
-            "method": "POST",
-            "url": url,
-            "timeout": self.timeout,
-            "json": json_data,
-            "data": data,
-            "files": files,
-        }
+        base_kwargs = self._prepare_request_kwargs(
+            method="POST",
+            endpoint=endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
 
         attempt = 0
         while attempt < self.max_retries:
@@ -385,8 +486,10 @@ class SynapsAI(BaseClient):
                         line = line.strip()
                         if not line:
                             continue
-                        if line.startswith("data: "):
-                            data_line = line[6:]  # Remove "data: " prefix
+                        if line.startswith("data:"):
+                            data_line = line[5:]
+                            if data_line.startswith(" "):
+                                data_line = data_line[1:]
                             if data_line == "[DONE]":
                                 return
                             try:
@@ -410,10 +513,10 @@ class SynapsAI(BaseClient):
 
         raise APIError("Failed to establish stream after retries")
 
-    def _get_stream(self, endpoint: str) -> httpx.Response:
+    def _get_stream(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> httpx.Response:
         """Make a streaming GET request for binary content (e.g. video download)."""
         url = build_url(self.base_url, endpoint)
-        request = self._client.build_request("GET", url, timeout=self.timeout)
+        request = self._client.build_request("GET", url, timeout=self.timeout, params=params)
         response = self._client.send(request, stream=True)
         if response.status_code >= 400:
             response.read()
@@ -435,6 +538,10 @@ class AsyncSynapsAI(BaseClient):
     feature_extraction: AsyncFeatureExtractionResource
     fill_mask: AsyncFillMaskResource
     rerank: AsyncRerankResource
+    vector_stores: AsyncVectorStoresResource
+    model_artifacts: AsyncModelArtifactsResource
+    agents: AsyncAgentsResource
+    responses: AsyncResponsesResource
 
     def __init__(self, api_key: Optional[str] = None, **kwargs):
         super().__init__(api_key=api_key, **kwargs)
@@ -458,6 +565,10 @@ class AsyncSynapsAI(BaseClient):
         self.feature_extraction = AsyncFeatureExtractionResource(self)
         self.fill_mask = AsyncFillMaskResource(self)
         self.rerank = AsyncRerankResource(self)
+        self.vector_stores = AsyncVectorStoresResource(self)
+        self.model_artifacts = AsyncModelArtifactsResource(self)
+        self.agents = AsyncAgentsResource(self)
+        self.responses = AsyncResponsesResource(self)
 
     async def __aenter__(self):
         return self
@@ -474,24 +585,23 @@ class AsyncSynapsAI(BaseClient):
         method: str,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> httpx.Response:
         """Make an async request to the API with retries."""
-        url = build_url(self.base_url, endpoint)
-
-        base_kwargs: Dict[str, Any] = {
-            "method": method,
-            "url": url,
-            "timeout": self.timeout,
-        }
-
-        if json_data:
-            base_kwargs["json"] = json_data
-        if data:
-            base_kwargs["data"] = data
-        if files:
-            base_kwargs["files"] = files
+        base_kwargs = self._prepare_request_kwargs(
+            method=method,
+            endpoint=endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
 
         attempt = 0
         last_exc: Optional[BaseException] = None
@@ -536,26 +646,71 @@ class AsyncSynapsAI(BaseClient):
         self,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> httpx.Response:
         """Make an async POST request"""
-        return await self._request("POST", endpoint, json_data, data, files)
-
-    async def _get(self, endpoint: str) -> httpx.Response:
+        return await self._request(
+            "POST",
+            endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
+
+    async def _put(
+        self,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
+        """Make an async PUT request"""
+        return await self._request(
+            "PUT",
+            endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
+
+    async def _get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
         """Make a GET request"""
-        return await self._request("GET", endpoint=endpoint)
+        return await self._request("GET", endpoint=endpoint, params=params)
 
-    async def _delete(self, endpoint: str) -> httpx.Response:
+    async def _delete(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
         """Make a DELETE request"""
-        return await self._request("DELETE", endpoint=endpoint)
+        return await self._request("DELETE", endpoint=endpoint, params=params)
 
     async def _stream_response(
         self,
         endpoint: str,
         json_data: Optional[Dict[str, Any]] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[Dict[str, Any]] = None,
+        data: Optional[Any] = None,
+        files: Optional[Any] = None,
+        content: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> AsyncIterator[Dict[str, Any]]:
         """
         Stream response data from a POST endpoint (async).
@@ -563,16 +718,16 @@ class AsyncSynapsAI(BaseClient):
         The attempt to establish the stream will be retried using the same backoff rules.
         Once the stream is established, streaming errors are raised as-is.
         """
-        url = build_url(self.base_url, endpoint)
-
-        base_kwargs = {
-            "method": "POST",
-            "url": url,
-            "timeout": self.timeout,
-            "json": json_data,
-            "data": data,
-            "files": files,
-        }
+        base_kwargs = self._prepare_request_kwargs(
+            method="POST",
+            endpoint=endpoint,
+            json_data=json_data,
+            data=data,
+            files=files,
+            content=content,
+            params=params,
+            headers=headers,
+        )
 
         attempt = 0
         while attempt < self.max_retries:
@@ -595,8 +750,10 @@ class AsyncSynapsAI(BaseClient):
                         line = raw_line.strip()
                         if not line:
                             continue
-                        if line.startswith("data: "):
-                            data_line = line[6:]  # Remove "data: " prefix
+                        if line.startswith("data:"):
+                            data_line = line[5:]
+                            if data_line.startswith(" "):
+                                data_line = data_line[1:]
                             if data_line == "[DONE]":
                                 return
                             try:
@@ -617,10 +774,14 @@ class AsyncSynapsAI(BaseClient):
 
         raise APIError("Failed to establish stream after retries")
 
-    async def _get_stream(self, endpoint: str) -> httpx.Response:
+    async def _get_stream(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
         """Make an async streaming GET request for binary content (e.g. video download)."""
         url = build_url(self.base_url, endpoint)
-        request = self._client.build_request("GET", url, timeout=self.timeout)
+        request = self._client.build_request("GET", url, timeout=self.timeout, params=params)
         response = await self._client.send(request, stream=True)
         if response.status_code >= 400:
             await response.aread()