runapi-core 0.1.0__tar.gz → 0.1.1__tar.gz

{runapi_core-0.1.0 → runapi_core-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runapi-core
-Version: 0.1.0
+Version: 0.1.1
 Summary: Core module for the RunAPI Python SDK
 Project-URL: Homepage, https://runapi.ai
 Project-URL: Documentation, https://runapi.ai/docs#sdk
@@ -31,11 +31,42 @@ import runapi.core as runapi
 runapi.configure(api_key="sk-...")  # or set RUNAPI_API_KEY in the environment
 ```
 
+## Request identifiers
+
+RunAPI accepts an optional `X-Client-Request-Id` header on public API calls. Use printable ASCII values up to 512 characters. Accepted values are echoed in the response and stored with the RunAPI task for support and reconciliation.
+
+High-level Python model SDK methods currently return parsed response bodies. When an integration needs to send a client request id or read `X-RunAPI-Task-Id`, make the call through direct HTTP or a custom transport so response headers stay available.
+
+```python
+import os
+
+import httpx
+
+response = httpx.post(
+    "https://runapi.ai/api/v1/suno/text_to_music",
+    headers={
+        "Authorization": f"Bearer {os.environ['RUNAPI_API_KEY']}",
+        "X-Client-Request-Id": "order-123",
+    },
+    json={
+        "prompt": "A chill lo-fi beat",
+        "model": "suno-v4.5-plus",
+        "vocal_mode": "instrumental",
+    },
+    timeout=900,
+)
+response.raise_for_status()
+runapi_task_id = response.headers.get("X-RunAPI-Task-Id")
+body = response.json()
+```
+
 ```python
 from runapi.core import FilesClient
 
 files = FilesClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
 uploaded = files.create(file="./input.png")
+remote = files.create(source="https://cdn.runapi.ai/public/samples/input.png")
+inline = files.create(source="iVBORw0KGgo...")
 print(uploaded.url)
 ```
 

runapi_core-0.1.1/README.md

@@ -0,0 +1,64 @@
+# RunAPI Core Python SDK
+
+The RunAPI Core Python SDK provides shared authentication, HTTP, retry, error, and polling primitives for RunAPI model packages. Install `runapi-core` only when you are building SDK infrastructure or shared Python tooling; application code should normally install a concrete model package such as `runapi-flux-2`.
+
+## Install
+
+```bash
+pip install runapi-core
+```
+
+## Notes
+
+Use the core package for common client options, error classes, request helpers, file uploads, and task polling behavior that model SDKs share. Configure it globally or per client:
+
+```python
+import runapi.core as runapi
+
+runapi.configure(api_key="sk-...")  # or set RUNAPI_API_KEY in the environment
+```
+
+## Request identifiers
+
+RunAPI accepts an optional `X-Client-Request-Id` header on public API calls. Use printable ASCII values up to 512 characters. Accepted values are echoed in the response and stored with the RunAPI task for support and reconciliation.
+
+High-level Python model SDK methods currently return parsed response bodies. When an integration needs to send a client request id or read `X-RunAPI-Task-Id`, make the call through direct HTTP or a custom transport so response headers stay available.
+
+```python
+import os
+
+import httpx
+
+response = httpx.post(
+    "https://runapi.ai/api/v1/suno/text_to_music",
+    headers={
+        "Authorization": f"Bearer {os.environ['RUNAPI_API_KEY']}",
+        "X-Client-Request-Id": "order-123",
+    },
+    json={
+        "prompt": "A chill lo-fi beat",
+        "model": "suno-v4.5-plus",
+        "vocal_mode": "instrumental",
+    },
+    timeout=900,
+)
+response.raise_for_status()
+runapi_task_id = response.headers.get("X-RunAPI-Task-Id")
+body = response.json()
+```
+
+```python
+from runapi.core import FilesClient
+
+files = FilesClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+uploaded = files.create(file="./input.png")
+remote = files.create(source="https://cdn.runapi.ai/public/samples/input.png")
+inline = files.create(source="iVBORw0KGgo...")
+print(uploaded.url)
+```
+
+Public SDK docs live at https://runapi.ai/docs#runapi-sdks and the model catalog lives at https://runapi.ai/models.
+
+## License
+
+Licensed under the Apache License, Version 2.0.

{runapi_core-0.1.0 → runapi_core-0.1.1}/pyproject.toml

@@ -28,3 +28,6 @@ package = true
 
 [dependency-groups]
 dev = ["pytest>=8", "httpx>=0.27"]
+
+[tool.runapi]
+slug = "core"

{runapi_core-0.1.0 → runapi_core-0.1.1}/src/runapi/core/contract_gen.py

@@ -1,5 +1,3 @@
-# Code generated by SdkContractGenerator. DO NOT EDIT.
-
 CONTRACT = {
     "elevenlabs/isolate-audio": {
         "models": ["audio-isolation"],
@@ -148,6 +146,9 @@ CONTRACT = {
         "models": ["gpt-image-2"],
         "fields_by_model": {
             "gpt-image-2": {
+                "aspect_ratio": {
+                    "enum": ["auto", "1:1", "3:2", "2:3", "4:3", "3:4", "5:4", "4:5", "16:9", "9:16", "2:1", "1:2", "3:1", "1:3", "21:9", "9:21"]
+                },
                 "output_resolution": {
                     "enum": ["1k", "2k", "4k"]
                 }
@@ -158,6 +159,9 @@ CONTRACT = {
         "models": ["gpt-image-2"],
         "fields_by_model": {
             "gpt-image-2": {
+                "aspect_ratio": {
+                    "enum": ["auto", "1:1", "3:2", "2:3", "4:3", "3:4", "5:4", "4:5", "16:9", "9:16", "2:1", "1:2", "3:1", "1:3", "21:9", "9:21"]
+                },
                 "output_resolution": {
                     "enum": ["1k", "2k", "4k"]
                 }
@@ -167,13 +171,27 @@ CONTRACT = {
     "gpt-image/edit-image": {
         "models": ["gpt-image-1.5"],
         "fields_by_model": {
-            "gpt-image-1.5": {}
+            "gpt-image-1.5": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "2:3", "3:2"]
+                },
+                "quality": {
+                    "enum": ["medium", "high"]
+                }
+            }
         }
     },
     "gpt-image/text-to-image": {
         "models": ["gpt-image-1.5"],
         "fields_by_model": {
-            "gpt-image-1.5": {}
+            "gpt-image-1.5": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "2:3", "3:2"]
+                },
+                "quality": {
+                    "enum": ["medium", "high"]
+                }
+            }
         }
     },
     "grok-imagine/edit-image": {
@@ -713,9 +731,6 @@ CONTRACT = {
                 "aspect_ratio": {
                     "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "21:9"]
                 },
-                "duration_seconds": {
-                    "enum": [4, 8, 12]
-                },
                 "output_resolution": {
                     "enum": ["480p", "720p", "1080p"]
                 }

{runapi_core-0.1.0 → runapi_core-0.1.1}/src/runapi/core/files.py

@@ -6,13 +6,14 @@ local file or register a remote URL and receive a usable file reference.
 
 from __future__ import annotations
 
+import base64
+import hashlib
 import os
-from typing import Any, Optional
+from typing import Any, Mapping, Optional, Union
 
 from . import auth
 from .http_client import HttpClient
 from .models import BaseModel, optional, required
-from .multipart import MultipartBody, MultipartFile
 from .options import ClientOptions, RequestOptions
 from .resource import Resource
 
@@ -28,6 +29,8 @@ class UploadResponse(BaseModel):
 
 class FilesClient(Resource):
     ENDPOINT = "/api/v1/files"
+    PREPARE_ENDPOINT = f"{ENDPOINT}/prepare"
+    CONFIRM_ENDPOINT = f"{ENDPOINT}/confirm"
 
     RESPONSE_CLASS = UploadResponse
 
@@ -40,7 +43,7 @@ class FilesClient(Resource):
     def create(
         self,
         file: Any = None,
-        source: Optional[str] = None,
+        source: Optional[Union[str, Mapping[str, Any]]] = None,
         file_name: Optional[str] = None,
         options: Optional[RequestOptions] = None,
     ) -> Any:
@@ -50,7 +53,8 @@ class FilesClient(Resource):
 
         Args:
             file: Local file path or file-like object to upload.
-            source: Remote URL to register instead of uploading a local file.
+            source: Remote URL, base64 data, or canonical source object to
+                register instead of uploading a local file.
             file_name: Optional name to record for the uploaded file.
             options: Optional per-request options.
 
@@ -60,14 +64,42 @@ class FilesClient(Resource):
         self._validate_source(file, source)
 
         if file is not None:
-            body: Any = self._multipart_body(file, file_name)
-        else:
-            body = self._compact_params({"source": source, "file_name": file_name})
+            return self._upload_direct(file, file_name, options)
 
+        body = self._compact_params(
+            {"source": self._source_object(source), "file_name": file_name}
+        )
         return self._request("post", self.ENDPOINT, body=body, options=options)
 
+    def _upload_direct(self, file: Any, file_name: Optional[str], options: Optional[RequestOptions]) -> Any:
+        """Local files upload straight to storage: ask for a pre-authorized target,
+        PUT the bytes there (never through the API), then confirm. The caller still
+        makes a single create call."""
+        path = self._file_path(file)
+        with open(path, "rb") as handle:
+            data = handle.read()
+
+        prepared = self._http.request(
+            "post",
+            self.PREPARE_ENDPOINT,
+            body=self._compact_params(
+                {
+                    "filename": file_name or os.path.basename(path),
+                    "byte_size": len(data),
+                    "checksum": base64.b64encode(hashlib.md5(data).digest()).decode("ascii"),
+                }
+            ),
+            options=options,
+        )
+
+        self._http.upload(prepared["upload_url"], headers=prepared["headers"], body=data)
+
+        return self._request(
+            "post", self.CONFIRM_ENDPOINT, body={"signed_id": prepared["signed_id"]}, options=options
+        )
+
     @staticmethod
-    def _validate_source(file: Any, source: Optional[str]) -> None:
+    def _validate_source(file: Any, source: Optional[Union[str, Mapping[str, Any]]]) -> None:
         def present(value: Any) -> bool:
             if value is None:
                 return False
@@ -79,13 +111,18 @@ class FilesClient(Resource):
         if provided != 1:
             raise ValueError("Exactly one source is required: file or source")
 
-    def _multipart_body(self, file: Any, file_name: Optional[str]) -> MultipartBody:
-        path = self._file_path(file)
-        filename = file_name or os.path.basename(path)
-        return MultipartBody(
-            fields=self._compact_params({"file_name": file_name}),
-            files={"file": MultipartFile(path=path, filename=filename)},
-        )
+    @staticmethod
+    def _source_object(source: Optional[Union[str, Mapping[str, Any]]]) -> Any:
+        if isinstance(source, Mapping):
+            return dict(source)
+
+        if isinstance(source, str):
+            value = source.strip()
+            if value.lower().startswith(("http://", "https://")):
+                return {"type": "url", "url": value}
+            return {"type": "base64", "data": value}
+
+        return source
 
     @staticmethod
     def _file_path(file: Any) -> str:

{runapi_core-0.1.0 → runapi_core-0.1.1}/src/runapi/core/http_client.py

@@ -37,6 +37,9 @@ class HttpClient:
                 "User-Agent": constants.SDK_USER_AGENT,
             },
         )
+        # A bare client for direct uploads: the pre-authorized upload URL lives
+        # outside the API host and must not receive the API key.
+        self._upload_client = httpx.Client(timeout=options.timeout, transport=transport)
 
     def request(
         self,
@@ -87,8 +90,23 @@ class HttpClient:
             for handle in opened:
                 handle.close()
 
+    def upload(self, url: str, headers: Dict[str, str], body: bytes) -> None:
+        """PUT bytes straight to a pre-authorized upload URL with the exact headers
+        issued for it. No auth, no retries: the URL is single-use and the body is
+        not safe to replay."""
+        try:
+            response = self._upload_client.put(url, content=body, headers=headers)
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(str(exc))
+        except httpx.TransportError as exc:
+            raise NetworkError(str(exc))
+
+        if not response.is_success:
+            raise error_from_response(response)
+
     def close(self) -> None:
         self._client.close()
+        self._upload_client.close()
 
     def _build_payload(
         self, body: Any

runapi_core-0.1.1/src/runapi/core/resource.py

@@ -0,0 +1,199 @@
+"""Base class for API resources: request coercion, param helpers, polling."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional, Sequence
+
+from . import polling
+from .errors import ValidationError
+from .models import BaseModel, TaskResponse
+from .options import PollingOptions, RequestOptions
+
+
+class Resource:
+    """Shared behavior for resource classes.
+
+    Subclasses set ``RESPONSE_CLASS`` (the typed model for responses) and
+    optionally ``COMPLETED_RESPONSE_CLASS`` (a narrowed model that ``run()``
+    re-coerces to once the task completes).
+    """
+
+    RESPONSE_CLASS: type = TaskResponse
+    COMPLETED_RESPONSE_CLASS: Optional[type] = None
+
+    def __init__(self, http: Any) -> None:
+        self._http = http
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Any = None,
+        options: Optional[RequestOptions] = None,
+        response_class: Optional[type] = None,
+    ) -> Any:
+        response = self._http.request(method, path, body=body, options=options)
+        return BaseModel.coerce(response, as_=response_class or type(self).RESPONSE_CLASS)
+
+    @staticmethod
+    def _compact_params(params: Dict[str, Any]) -> Dict[str, Any]:
+        return {
+            key: value
+            for key, value in params.items()
+            if not (value is None or (isinstance(value, str) and value.strip() == ""))
+        }
+
+    @staticmethod
+    def _validate_optional(params: Dict[str, Any], key: str, allowed: Sequence[Any]) -> None:
+        value = params.get(key)
+        if value is None:
+            return
+        if value not in allowed:
+            joined = ", ".join(str(option) for option in allowed)
+            raise ValidationError(f"Invalid {key}: {value}. Must be one of: {joined}")
+
+    # ---- Contract validation -------------------------------------------
+    # Validates request params against the generated contract: model
+    # membership, then per-field required/enum/integer/min/max/length, then
+    # declared cross-field rules. `schema` is one action entry from the generated
+    # per-package CONTRACT (CONTRACT["<action>"]).
+
+    def _validate_contract(self, schema: Dict[str, Any], params: Dict[str, Any]) -> None:
+        model = params.get("model")
+        models = schema.get("models", [])
+        if model not in models:
+            raise ValidationError(f"model must be one of: {', '.join(sorted(models))}")
+
+        fields = schema.get("fields_by_model", {}).get(model, {})
+        for field, rules in fields.items():
+            self._validate_schema_field(params, field, rules)
+
+        for rule in schema.get("rules", []):
+            self._enforce_rule(params, rule)
+
+    def _validate_schema_field(self, params: Dict[str, Any], field: str, rules: Dict[str, Any]) -> None:
+        present = self._field_present(params, field)
+        if rules.get("required") and not present:
+            raise ValidationError(f"{field} is required")
+        if not present:
+            return
+
+        value = params[field]
+        enum = rules.get("enum")
+        if enum is not None and not self._enum_allowed(enum, value):
+            raise ValidationError(f"{field} must be one of: {', '.join(str(option) for option in enum)}")
+
+        if rules.get("type") == "integer":
+            self._validate_integer(field, value, rules)
+
+        if "min" in rules or "max" in rules:
+            self._validate_range(field, value, rules)
+
+    @staticmethod
+    def _validate_integer(field: str, value: Any, rules: Dict[str, Any]) -> None:
+        # Mirrors GatewayEntry#validate_schema_integer!: a type: integer field
+        # rejects non-integer numbers (e.g. 11.5), which min/max alone admit.
+        # bool is an int subclass in Python, so exclude it explicitly.
+        if isinstance(value, int) and not isinstance(value, bool):
+            return
+        minimum = rules.get("min")
+        maximum = rules.get("max")
+        detail = (
+            f" between {minimum} and {maximum}"
+            if minimum is not None and maximum is not None
+            else ""
+        )
+        raise ValidationError(f"{field} must be an integer{detail}")
+
+    def _validate_range(self, field: str, value: Any, rules: Dict[str, Any]) -> None:
+        if rules.get("length"):
+            measured: Any = len(str(value))
+            unit: Optional[str] = "characters"
+        else:
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                raise ValidationError(f"{field} must be a number")
+            measured = value
+            unit = None
+
+        minimum = rules.get("min")
+        maximum = rules.get("max")
+        if (minimum is None or measured >= minimum) and (maximum is None or measured <= maximum):
+            return
+        raise ValidationError(self._range_message(field, minimum, maximum, unit))
+
+    @staticmethod
+    def _range_message(field: str, minimum: Any, maximum: Any, unit: Optional[str]) -> str:
+        suffix = f" {unit}" if unit else ""
+        if minimum is not None and maximum is not None:
+            return f"{field} must be between {minimum} and {maximum}{suffix}"
+        if minimum is not None:
+            return f"{field} must be at least {minimum}{suffix}"
+        return f"{field} must be at most {maximum}{suffix}"
+
+    @staticmethod
+    def _enum_allowed(enum: Sequence[Any], value: Any) -> bool:
+        value_is_num = isinstance(value, (int, float)) and not isinstance(value, bool)
+        for allowed in enum:
+            allowed_is_num = isinstance(allowed, (int, float)) and not isinstance(allowed, bool)
+            if allowed_is_num:
+                if value_is_num and value == allowed:
+                    return True
+            elif value_is_num:
+                if allowed == value:
+                    return True
+            elif str(allowed) == str(value):
+                return True
+        return False
+
+    def _enforce_rule(self, params: Dict[str, Any], rule: Dict[str, Any]) -> None:
+        conditions = rule.get("when", {})
+        if not all(self._rule_condition_met(params, key, val) for key, val in conditions.items()):
+            return
+
+        context = " and ".join(f"{key} is {val}" for key, val in conditions.items())
+        for field in rule.get("required", []):
+            if not self._field_present(params, field):
+                raise ValidationError(f"{field} is required when {context}")
+        for field in rule.get("forbidden", []):
+            if self._field_present(params, field):
+                raise ValidationError(f"{field} is not allowed when {context}")
+
+    @staticmethod
+    def _rule_condition_met(params: Dict[str, Any], field: str, value: Any) -> bool:
+        if field not in params:
+            return False
+        return str(params[field]) == str(value)
+
+    def _field_present(self, params: Dict[str, Any], field: str) -> bool:
+        if field not in params:
+            return False
+        value = params[field]
+        if value is False:
+            return True
+        if isinstance(value, (list, tuple)):
+            return any(self._present(item) for item in value)
+        return self._present(value)
+
+    @staticmethod
+    def _present(value: Any) -> bool:
+        if value is None or value is False:
+            return False
+        if value is True:
+            return True
+        if isinstance(value, str):
+            return value.strip() != ""
+        if isinstance(value, (list, tuple, dict)):
+            return len(value) > 0
+        return True
+
+    def _poll_until_complete(
+        self, fetch: Callable[[], Any], polling_opts: Optional[PollingOptions] = None
+    ) -> Any:
+        response = polling.poll_until_complete(fetch, polling_opts or PollingOptions())
+
+        completed_class = type(self).COMPLETED_RESPONSE_CLASS
+        if completed_class is None or isinstance(response, completed_class):
+            return response
+
+        payload = response.to_dict() if isinstance(response, BaseModel) else response
+        return completed_class.from_dict(payload)

runapi_core-0.1.1/src/runapi/core/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

runapi_core-0.1.1/tests/test_files.py

@@ -0,0 +1,170 @@
+import base64
+import hashlib
+import os
+import tempfile
+
+import pytest
+
+from runapi.core import FilesClient
+
+
+PREPARED = {
+    "signed_id": "signed-blob-id",
+    "upload_url": "https://file.runapi.ai/temp/user-uploads/key",
+    "headers": {"Content-Type": "application/octet-stream"},
+}
+
+
+class FakeHttp:
+    def __init__(self, response):
+        self._response = response
+        self.calls = []
+        self.uploads = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body))
+        if path.endswith("/prepare"):
+            return PREPARED
+        return self._response
+
+    def upload(self, url, headers, body):
+        self.uploads.append((url, headers, body))
+
+
+UPLOAD = {
+    "file_name": "image.png",
+    "url": "https://cdn.runapi.ai/x.png",
+    "size_bytes": 3,
+    "mime_type": "image/png",
+    "created_at": "2026-01-01T00:00:00Z",
+    "expires_at": "2026-01-08T00:00:00Z",
+}
+
+
+def test_requires_exactly_one_source():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+    with pytest.raises(ValueError):
+        client.create()
+    with pytest.raises(ValueError):
+        client.create(file="x", source="y")
+
+
+def test_create_with_remote_source_sends_url_source_object():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+    result = client.create(source="https://runapi.ai/in.png")
+
+    method, path, body = fake.calls[0]
+    assert method == "post"
+    assert path == "/api/v1/files"
+    assert body == {"source": {"type": "url", "url": "https://runapi.ai/in.png"}}
+    assert result.url == UPLOAD["url"]
+    assert result.size_bytes == 3
+
+
+def test_create_with_uppercase_url_scheme_sends_url_source_object():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+
+    client.create(source="HTTPS://cdn.runapi.ai/public/samples/in.png")
+
+    _, _, body = fake.calls[0]
+    assert body == {"source": {"type": "url", "url": "HTTPS://cdn.runapi.ai/public/samples/in.png"}}
+
+
+def test_create_with_base64_source_sends_base64_source_object():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+    source = "cG5n"
+
+    client.create(source=source, file_name="image.png")
+
+    _, _, body = fake.calls[0]
+    assert body == {
+        "source": {"type": "base64", "data": source},
+        "file_name": "image.png",
+    }
+
+
+def test_create_with_source_object_sends_canonical_source_object():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+
+    client.create(source={"type": "url", "url": "https://cdn.runapi.ai/public/samples/in.png"})
+
+    _, _, body = fake.calls[0]
+    assert body == {"source": {"type": "url", "url": "https://cdn.runapi.ai/public/samples/in.png"}}
+
+
+def test_create_with_local_file_uploads_directly():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+
+    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
+        handle.write(b"png")
+        path = handle.name
+    try:
+        result = client.create(file=path)
+    finally:
+        os.unlink(path)
+
+    # prepare then confirm; bytes never travel through the API
+    assert [call[1] for call in fake.calls] == ["/api/v1/files/prepare", "/api/v1/files/confirm"]
+    _, _, prepare_body = fake.calls[0]
+    assert prepare_body["filename"] == os.path.basename(path)
+    assert prepare_body["byte_size"] == 3
+    assert prepare_body["checksum"] == base64.b64encode(hashlib.md5(b"png").digest()).decode("ascii")
+
+    # bytes go straight to the issued upload URL with its headers
+    assert fake.uploads == [(PREPARED["upload_url"], PREPARED["headers"], b"png")]
+
+    _, _, confirm_body = fake.calls[1]
+    assert confirm_body == {"signed_id": "signed-blob-id"}
+    assert result.url == UPLOAD["url"]
+
+
+def test_create_uses_explicit_file_name():
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+
+    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
+        handle.write(b"png")
+        path = handle.name
+    try:
+        client.create(file=path, file_name="custom.png")
+    finally:
+        os.unlink(path)
+
+    _, _, prepare_body = fake.calls[0]
+    assert prepare_body["filename"] == "custom.png"
+
+
+def test_create_with_pathlib_path_keeps_full_path():
+    # Regression: a pathlib.Path must keep its full path, not collapse to the
+    # basename (Path.name), so the later open() reads the right file.
+    import pathlib
+
+    fake = FakeHttp(UPLOAD)
+    client = FilesClient(api_key="k", http_client=fake)
+    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
+        handle.write(b"png")
+        path = handle.name
+    try:
+        client.create(file=pathlib.Path(path))
+    finally:
+        os.unlink(path)
+
+    # the full path was read (checksum of the real bytes), not a basename miss
+    _, _, prepare_body = fake.calls[0]
+    assert prepare_body["checksum"] == base64.b64encode(hashlib.md5(b"png").digest()).decode("ascii")
+    assert fake.uploads[0][2] == b"png"
+
+
+def test_create_rejects_blank_source():
+    # Regression: a blank source must fail locally, not POST an empty body.
+    client = FilesClient(api_key="k", http_client=FakeHttp(UPLOAD))
+    with pytest.raises(ValueError):
+        client.create(source="")
+    with pytest.raises(ValueError):
+        client.create(source="   ")

{runapi_core-0.1.0 → runapi_core-0.1.1}/tests/test_resource.py

@@ -47,6 +47,51 @@ def test_validate_optional_passes_and_rejects():
         Resource._validate_optional({"k": "z"}, "k", ["a", "b"])
 
 
+INT_SCHEMA = {
+    "models": ["m"],
+    "fields_by_model": {
+        "m": {
+            "duration_int": {"type": "integer", "min": 4, "max": 12},
+            "tolerance": {"type": "integer"},
+        }
+    },
+}
+
+
+def _run_validate(params):
+    resource = SampleResource(FakeHttp())
+    try:
+        resource._validate_contract(INT_SCHEMA, params)
+        return ""
+    except ValidationError as err:
+        return str(err)
+
+
+def test_validate_integer_rejects_non_integer_within_range():
+    assert _run_validate({"model": "m", "duration_int": 11.5}) == "duration_int must be an integer between 4 and 12"
+
+
+def test_validate_integer_runs_before_range():
+    # A non-integer below the range reports the integer error, not the range one.
+    assert _run_validate({"model": "m", "duration_int": 2.5}) == "duration_int must be an integer between 4 and 12"
+
+
+def test_validate_bare_integer_has_no_range_detail():
+    assert _run_validate({"model": "m", "tolerance": 3.5}) == "tolerance must be an integer"
+
+
+def test_validate_integer_still_enforces_range_for_valid_int():
+    assert _run_validate({"model": "m", "duration_int": 13}) == "duration_int must be between 4 and 12"
+
+
+def test_validate_integer_rejects_bool_and_whole_float():
+    # bool is an int subclass but is not a valid integer value.
+    assert _run_validate({"model": "m", "tolerance": True}) == "tolerance must be an integer"
+    # Python keeps the float/int distinction: a whole-valued float is still a float.
+    assert _run_validate({"model": "m", "tolerance": 5.0}) == "tolerance must be an integer"
+    assert _run_validate({"model": "m", "tolerance": 5}) == ""
+
+
 def test_poll_recoerces_to_completed_class():
     resource = SampleResource(FakeHttp())
     response = TaskResponse({"id": "1", "status": "completed", "images": [{"url": "u"}]})

runapi_core-0.1.0/README.md

@@ -1,33 +0,0 @@
-# RunAPI Core Python SDK
-
-The RunAPI Core Python SDK provides shared authentication, HTTP, retry, error, and polling primitives for RunAPI model packages. Install `runapi-core` only when you are building SDK infrastructure or shared Python tooling; application code should normally install a concrete model package such as `runapi-flux-2`.
-
-## Install
-
-```bash
-pip install runapi-core
-```
-
-## Notes
-
-Use the core package for common client options, error classes, request helpers, file uploads, and task polling behavior that model SDKs share. Configure it globally or per client:
-
-```python
-import runapi.core as runapi
-
-runapi.configure(api_key="sk-...")  # or set RUNAPI_API_KEY in the environment
-```
-
-```python
-from runapi.core import FilesClient
-
-files = FilesClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
-uploaded = files.create(file="./input.png")
-print(uploaded.url)
-```
-
-Public SDK docs live at https://runapi.ai/docs#runapi-sdks and the model catalog lives at https://runapi.ai/models.
-
-## License
-
-Licensed under the Apache License, Version 2.0.

runapi_core-0.1.0/src/runapi/core/resource.py

@@ -1,65 +0,0 @@
-"""Base class for API resources: request coercion, param helpers, polling."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, Optional, Sequence
-
-from . import polling
-from .errors import ValidationError
-from .models import BaseModel, TaskResponse
-from .options import PollingOptions, RequestOptions
-
-
-class Resource:
-    """Shared behavior for resource classes.
-
-    Subclasses set ``RESPONSE_CLASS`` (the typed model for responses) and
-    optionally ``COMPLETED_RESPONSE_CLASS`` (a narrowed model that ``run()``
-    re-coerces to once the task completes).
-    """
-
-    RESPONSE_CLASS: type = TaskResponse
-    COMPLETED_RESPONSE_CLASS: Optional[type] = None
-
-    def __init__(self, http: Any) -> None:
-        self._http = http
-
-    def _request(
-        self,
-        method: str,
-        path: str,
-        body: Any = None,
-        options: Optional[RequestOptions] = None,
-        response_class: Optional[type] = None,
-    ) -> Any:
-        response = self._http.request(method, path, body=body, options=options)
-        return BaseModel.coerce(response, as_=response_class or type(self).RESPONSE_CLASS)
-
-    @staticmethod
-    def _compact_params(params: Dict[str, Any]) -> Dict[str, Any]:
-        return {
-            key: value
-            for key, value in params.items()
-            if not (value is None or (isinstance(value, str) and value.strip() == ""))
-        }
-
-    @staticmethod
-    def _validate_optional(params: Dict[str, Any], key: str, allowed: Sequence[Any]) -> None:
-        value = params.get(key)
-        if value is None:
-            return
-        if value not in allowed:
-            joined = ", ".join(str(option) for option in allowed)
-            raise ValidationError(f"Invalid {key}: {value}. Must be one of: {joined}")
-
-    def _poll_until_complete(
-        self, fetch: Callable[[], Any], polling_opts: Optional[PollingOptions] = None
-    ) -> Any:
-        response = polling.poll_until_complete(fetch, polling_opts or PollingOptions())
-
-        completed_class = type(self).COMPLETED_RESPONSE_CLASS
-        if completed_class is None or isinstance(response, completed_class):
-            return response
-
-        payload = response.to_dict() if isinstance(response, BaseModel) else response
-        return completed_class.from_dict(payload)

runapi_core-0.1.0/src/runapi/core/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

runapi_core-0.1.0/tests/test_files.py

@@ -1,113 +0,0 @@
-import os
-import tempfile
-
-import pytest
-
-from runapi.core import FilesClient
-from runapi.core.multipart import MultipartBody
-
-
-class FakeHttp:
-    def __init__(self, response):
-        self._response = response
-        self.calls = []
-
-    def request(self, method, path, body=None, options=None):
-        self.calls.append((method, path, body))
-        return self._response
-
-
-UPLOAD = {
-    "file_name": "image.png",
-    "url": "https://cdn.runapi.ai/x.png",
-    "size_bytes": 3,
-    "mime_type": "image/png",
-    "created_at": "2026-01-01T00:00:00Z",
-    "expires_at": "2026-01-08T00:00:00Z",
-}
-
-
-def test_requires_exactly_one_source():
-    fake = FakeHttp(UPLOAD)
-    client = FilesClient(api_key="k", http_client=fake)
-    with pytest.raises(ValueError):
-        client.create()
-    with pytest.raises(ValueError):
-        client.create(file="x", source="y")
-
-
-def test_create_with_remote_source_sends_compact_params():
-    fake = FakeHttp(UPLOAD)
-    client = FilesClient(api_key="k", http_client=fake)
-    result = client.create(source="https://example.com/in.png")
-
-    method, path, body = fake.calls[0]
-    assert method == "post"
-    assert path == "/api/v1/files"
-    assert body == {"source": "https://example.com/in.png"}
-    assert result.url == UPLOAD["url"]
-    assert result.size_bytes == 3
-
-
-def test_create_with_local_file_builds_multipart():
-    fake = FakeHttp(UPLOAD)
-    client = FilesClient(api_key="k", http_client=fake)
-
-    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
-        handle.write(b"png")
-        path = handle.name
-    try:
-        client.create(file=path)
-    finally:
-        os.unlink(path)
-
-    _, _, body = fake.calls[0]
-    assert isinstance(body, MultipartBody)
-    assert "file" in body.files
-    assert body.files["file"].filename == os.path.basename(path)
-
-
-def test_create_uses_explicit_file_name():
-    fake = FakeHttp(UPLOAD)
-    client = FilesClient(api_key="k", http_client=fake)
-
-    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
-        handle.write(b"png")
-        path = handle.name
-    try:
-        client.create(file=path, file_name="custom.png")
-    finally:
-        os.unlink(path)
-
-    _, _, body = fake.calls[0]
-    assert body.files["file"].filename == "custom.png"
-    assert body.fields == {"file_name": "custom.png"}
-
-
-def test_create_with_pathlib_path_keeps_full_path():
-    # Regression: a pathlib.Path must keep its full path, not collapse to the
-    # basename (Path.name), so the later open() reads the right file.
-    import pathlib
-
-    fake = FakeHttp(UPLOAD)
-    client = FilesClient(api_key="k", http_client=fake)
-    with tempfile.NamedTemporaryFile("wb", suffix=".png", delete=False) as handle:
-        handle.write(b"png")
-        path = handle.name
-    try:
-        client.create(file=pathlib.Path(path))
-    finally:
-        os.unlink(path)
-
-    _, _, body = fake.calls[0]
-    assert body.files["file"].path == path
-    assert body.files["file"].filename == os.path.basename(path)
-
-
-def test_create_rejects_blank_source():
-    # Regression: a blank source must fail locally, not POST an empty body.
-    client = FilesClient(api_key="k", http_client=FakeHttp(UPLOAD))
-    with pytest.raises(ValueError):
-        client.create(source="")
-    with pytest.raises(ValueError):
-        client.create(source="   ")