reflex-sdk 0.1.0__py3-none-any.whl

reflex/__init__.py

@@ -0,0 +1,63 @@
+"""Public Reflex SDK."""
+
+from .actions import ActionStream, action, connect, infer_actions, observation
+from .client import Client
+from .datasets import (
+    complete_dataset,
+    create_dataset,
+    get_dataset,
+    list_datasets,
+    register_huggingface_dataset,
+    upload_dataset,
+    validate_dataset,
+)
+from .instances import instance_status, provision_instance, teardown_instance
+from .training import (
+    AdamParams,
+    AdapterHandle,
+    Datum,
+    ForwardBackwardResult,
+    LoraTrainingClient,
+    OptimStepResult,
+    ServiceClient,
+    cancel_training_job,
+    create_training_job,
+    full_finetune,
+    full_train,
+    get_training_job,
+    list_training_jobs,
+    lora_finetune,
+)
+
+__all__ = [
+    "ActionStream",
+    "AdamParams",
+    "AdapterHandle",
+    "Client",
+    "Datum",
+    "ForwardBackwardResult",
+    "LoraTrainingClient",
+    "OptimStepResult",
+    "ServiceClient",
+    "action",
+    "cancel_training_job",
+    "complete_dataset",
+    "connect",
+    "create_dataset",
+    "create_training_job",
+    "full_finetune",
+    "full_train",
+    "get_dataset",
+    "get_training_job",
+    "infer_actions",
+    "instance_status",
+    "list_training_jobs",
+    "list_datasets",
+    "lora_finetune",
+    "observation",
+    "provision_instance",
+    "register_huggingface_dataset",
+    "teardown_instance",
+    "upload_dataset",
+    "validate_dataset",
+]

reflex/_convex.py

@@ -0,0 +1,140 @@
+"""Minimal Convex HTTP client for public API-key SDK calls."""
+
+from __future__ import annotations
+
+import base64
+import json
+import math
+import os
+import struct
+from pathlib import Path
+from typing import Any
+from urllib import error, parse, request
+
+DEFAULT_CONVEX_URL = "https://kindly-bullfrog-494.convex.cloud"
+
+
+def convex_url(value: str | None = None) -> str:
+    resolved = (
+        value
+        or os.environ.get("REFLEX_CONVEX_URL", "")
+        or os.environ.get("CONVEX_URL", "")
+        or os.environ.get("NEXT_PUBLIC_CONVEX_URL", "")
+        or DEFAULT_CONVEX_URL
+    ).strip().rstrip("/")
+    parsed = parse.urlparse(resolved)
+    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+        raise ValueError("Convex URL must start with http:// or https://.")
+    return resolved
+
+
+def _load_local_env(path: str | Path = ".env") -> None:
+    env_path = Path(path)
+    if not env_path.exists():
+        return
+    for line in env_path.read_text().splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, value = stripped.split("=", 1)
+        os.environ.setdefault(key.strip(), value.strip().strip("\"'"))
+
+
+_load_local_env()
+
+
+def _convex_to_json(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, str)):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        if math.isnan(value) or math.isinf(value) or value == 0.0 and math.copysign(1.0, value) < 0:
+            return {"$float": base64.b64encode(struct.pack("<d", value)).decode("ascii")}
+        return value
+    if isinstance(value, (bytes, bytearray)):
+        return {"$bytes": base64.b64encode(bytes(value)).decode("ascii")}
+    if isinstance(value, (list, tuple)):
+        return [_convex_to_json(item) for item in value]
+    if isinstance(value, dict):
+        return {
+            str(key): _convex_to_json(item)
+            for key, item in sorted(value.items(), key=lambda entry: str(entry[0]))
+            if item is not None
+        }
+    raise TypeError(f"{type(value).__name__} is not a supported Convex value")
+
+
+def _json_to_convex(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, list):
+        return [_json_to_convex(item) for item in value]
+    if isinstance(value, dict):
+        if set(value) == {"$integer"}:
+            return int.from_bytes(base64.b64decode(str(value["$integer"])), "little", signed=True)
+        if set(value) == {"$float"}:
+            return struct.unpack("<d", base64.b64decode(str(value["$float"])))[0]
+        if set(value) == {"$bytes"}:
+            return base64.b64decode(str(value["$bytes"]))
+        return {str(key): _json_to_convex(item) for key, item in value.items()}
+    return value
+
+
+def convex_call(
+    kind: str,
+    function_name: str,
+    args: dict[str, Any] | None = None,
+    *,
+    url: str | None = None,
+    timeout: float = 60.0,
+) -> Any:
+    if kind not in {"action", "mutation", "query"}:
+        raise ValueError("Convex function kind must be action, mutation, or query.")
+    body = json.dumps(
+        {
+            "path": function_name,
+            "format": "convex_encoded_json",
+            "args": [_convex_to_json(args or {})],
+        }
+    ).encode("utf-8")
+    req = request.Request(
+        f"{convex_url(url)}/api/{kind}",
+        data=body,
+        method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "Convex-Client": "python-reflex-sdk-0.1.0",
+        },
+    )
+    try:
+        with request.urlopen(req, timeout=timeout) as response:
+            raw = response.read().decode("utf-8")
+    except error.HTTPError as exc:
+        raw = exc.read().decode("utf-8", errors="replace")
+        if exc.code != 560:
+            raise RuntimeError(f"Convex {kind} {function_name} failed: {exc.code} {raw}".strip()) from exc
+    except error.URLError as exc:
+        raise RuntimeError(f"Failed to reach Convex: {exc.reason}") from exc
+
+    parsed = json.loads(raw) if raw else {}
+    if not isinstance(parsed, dict):
+        raise RuntimeError(f"Unexpected Convex response: {parsed!r}")
+    status = parsed.get("status")
+    if status == "success":
+        return _json_to_convex(parsed.get("value"))
+    if status == "error":
+        raise RuntimeError(str(parsed.get("errorMessage") or f"Convex {function_name} failed"))
+    raise RuntimeError(f"Unexpected Convex response: {parsed!r}")
+
+
+def convex_action(function_name: str, args: dict[str, Any] | None = None, **kwargs: Any) -> Any:
+    return convex_call("action", function_name, args, **kwargs)
+
+
+def convex_mutation(function_name: str, args: dict[str, Any] | None = None, **kwargs: Any) -> Any:
+    return convex_call("mutation", function_name, args, **kwargs)
+
+
+def convex_query(function_name: str, args: dict[str, Any] | None = None, **kwargs: Any) -> Any:
+    return convex_call("query", function_name, args, **kwargs)

reflex/_transport.py

@@ -0,0 +1,86 @@
+"""Shared configuration and HTTP transport helpers for the public SDK."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+from urllib import error, parse, request
+
+DEFAULT_API_URL = "https://api.tryreflex.ai"
+
+
+def load_local_env(path: str | Path = ".env") -> None:
+    env_path = Path(path)
+    if not env_path.exists():
+        return
+    for line in env_path.read_text().splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+        key, value = stripped.split("=", 1)
+        os.environ.setdefault(key.strip(), value.strip().strip("\"'"))
+
+
+load_local_env()
+
+
+def api_key(value: str | None) -> str:
+    resolved = (
+        value
+        or os.environ.get("REFLEX_API_KEY", "")
+        or os.environ.get("RFX_API_KEY", "")
+    ).strip()
+    if not resolved:
+        raise ValueError("API key is required. Set api_key or REFLEX_API_KEY.")
+    return resolved
+
+
+def base_url(value: str | None) -> str:
+    resolved = (
+        value
+        or os.environ.get("REFLEX_API_URL", "")
+        or os.environ.get("REFLEX_PLATFORM_URL", "")
+        or os.environ.get("RFX_API_URL", "")
+        or DEFAULT_API_URL
+    ).strip().rstrip("/")
+    parsed = parse.urlparse(resolved)
+    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+        raise ValueError("API URL must start with http:// or https://.")
+    return resolved
+
+
+def request_json(
+    *,
+    url: str | None,
+    api_key_value: str | None,
+    path: str,
+    payload: dict[str, Any] | None = None,
+    method: str = "POST",
+    timeout: float = 30.0,
+    user_agent: str = "reflex-sdk/0.1.0",
+) -> dict[str, Any]:
+    body = json.dumps(payload).encode("utf-8") if payload is not None else None
+    req = request.Request(
+        parse.urljoin(f"{base_url(url)}/", path.lstrip("/")),
+        data=body,
+        method=method,
+        headers={
+            "Authorization": f"Bearer {api_key(api_key_value)}",
+            "User-Agent": user_agent,
+            **({"Content-Type": "application/json"} if payload is not None else {}),
+        },
+    )
+    try:
+        with request.urlopen(req, timeout=timeout) as response:
+            raw = response.read().decode("utf-8")
+    except error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"{exc.code} {detail}".strip()) from exc
+    except error.URLError as exc:
+        raise RuntimeError(f"Failed to reach Reflex API: {exc.reason}") from exc
+    parsed = json.loads(raw) if raw else {}
+    if not isinstance(parsed, dict):
+        raise RuntimeError(f"Unexpected Reflex API response: {parsed!r}")
+    return parsed