gatewaysdk 0.3.4__tar.gz → 0.3.6__tar.gz

{gatewaysdk-0.3.4 → gatewaysdk-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gatewaysdk
-Version: 0.3.4
+Version: 0.3.6
 Summary: Gateway SDK for Python - tracing, worlds, evaluation and the gateway CLI runtime
 Project-URL: Homepage, https://withgateway.ai
 Project-URL: Documentation, https://withgateway.ai/docs
@@ -27,7 +27,7 @@ Requires-Dist: gepa>=0.0.24
 Requires-Dist: gitignore-parser>=0.1.11
 Requires-Dist: graphviz
 Requires-Dist: gunicorn
-Requires-Dist: litellm>=1.74
+Requires-Dist: litellm>=1.84.0
 Requires-Dist: openai
 Requires-Dist: opentelemetry-api>=1.35
 Requires-Dist: opentelemetry-exporter-otlp>=1.35
@@ -57,14 +57,14 @@ Requires-Dist: jsonschema>=4.0.0; extra == 'platform'
 Requires-Dist: pyyaml>=6.0; extra == 'platform'
 Requires-Dist: typer>=0.9.0; extra == 'platform'
 Provides-Extra: proxy
-Requires-Dist: litellm[proxy]>=1.74; extra == 'proxy'
+Requires-Dist: litellm[proxy]>=1.84.0; extra == 'proxy'
 Provides-Extra: tracing
 Requires-Dist: openinference-instrumentation-anthropic; extra == 'tracing'
 Requires-Dist: openinference-instrumentation-litellm; extra == 'tracing'
 Requires-Dist: openinference-instrumentation-openai; extra == 'tracing'
 Requires-Dist: openinference-instrumentation-openai-agents; extra == 'tracing'
 Provides-Extra: trainer
-Requires-Dist: litellm[proxy]>=1.74; extra == 'trainer'
+Requires-Dist: litellm[proxy]>=1.84.0; extra == 'trainer'
 Provides-Extra: verl
 Requires-Dist: verl>=0.5.0; extra == 'verl'
 Requires-Dist: vllm>=0.8.4; extra == 'verl'

{gatewaysdk-0.3.4 → gatewaysdk-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gatewaysdk"
-version = "0.3.4"
+version = "0.3.6"
 description = "Gateway SDK for Python - tracing, worlds, evaluation and the gateway CLI runtime"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -35,7 +35,7 @@ dependencies = [
   "opentelemetry-api>=1.35",
   "opentelemetry-sdk>=1.35",
   "opentelemetry-exporter-otlp>=1.35",
-  "litellm>=1.74",
+  "litellm>=1.84.0",
   "pydantic>=2.11",
   "openai",
   "rich",
@@ -93,12 +93,12 @@ tracing = [
 # that may conflict with other packages (boto3, grpcio, uvicorn).
 # Install with: pip install 'gatewaysdk[proxy]'
 proxy = [
-  "litellm[proxy]>=1.74",
+  "litellm[proxy]>=1.84.0",
 ]
 # Trainer currently composes the optional LLM proxy runtime. Keep that stack
 # out of package initialization and make its installation intent explicit.
 trainer = [
-  "litellm[proxy]>=1.74",
+  "litellm[proxy]>=1.84.0",
 ]
 apo = [
   "poml",
@@ -143,9 +143,6 @@ experiment = [
   "gdown",
 ]
 
-core-legacy = [
-  "openai<2.0.0",
-]
 core-stable = [
   "openai>=2.0.0",
 ]
@@ -168,16 +165,7 @@ torch-stable = [
   "torchvision>=0.23.0",
   "transformers>=4.55.0,!=4.57.2",
   "vllm>=0.10.2,!=0.11.1,!=0.11.2,!=0.12.0",
-  "litellm[proxy]>=1.78",
-]
-torch-legacy = [
-  {include-group = "core-legacy"},
-  "torch==2.7.0",
-  "torchvision==0.22.0",
-  "transformers==4.53.3",
-  "tokenizers>=0.21,<0.22",
-  "vllm==0.9.2",
-  "litellm[proxy]==1.74.15",
+  "litellm[proxy]>=1.84.0",
 ]
 
 # Specific vllm versions for compatibility testing or workarounds.
@@ -198,12 +186,6 @@ torch-gpu-stable = [
   "tensordict>=0.9.1",
   "verl>=0.6.0",
 ]
-torch-gpu-legacy = [
-  {include-group = "torch-legacy"},
-  {include-group = "torch-cu128"},
-  "flash-attn==2.8.1",
-  "verl==0.5.0",
-]
 
 # For the TRL/Unsloth example.
 trl = [
@@ -289,26 +271,14 @@ agents = [
 [tool.uv]
 required-version = ">=0.9.9"
 conflicts = [
-  [
-    { group = "core-legacy" },
-    { group = "core-stable" },
-  ],
   [
     { group = "torch-cpu" },
     { group = "torch-cu128" },
   ],
-  [
-    { group = "torch-stable" },
-    { group = "torch-legacy" },
-  ],
   [
     { group = "vllm-0-10-2" },
     { group = "vllm-0-11-0" },
   ],
-  [
-    { group = "langchain" },
-    { group = "torch-legacy" },
-  ],
 ]
 environments = [
   "sys_platform == 'linux'",

{gatewaysdk-0.3.4 → gatewaysdk-0.3.6}/src/gatewaysdk/__init__.py

@@ -109,7 +109,7 @@ if _TYPE_CHECKING:
     from .users import UserEvent, UserProfile, UserProfileError, UsersClient  # noqa: F401
     from .build import define_tool, register_artifact, register_prompt, register_skill  # noqa: F401
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 
 
 # module: public names. Keep this explicit: wildcard ownership made additions

gatewaysdk-0.3.6/src/gatewaysdk/api_errors.py

@@ -0,0 +1,37 @@
+# Copyright (c) Gateway. All rights reserved.
+
+"""How every Python transport renders a non-2xx platform answer.
+
+A JSON error body becomes ``<message> (<code>)`` — the stable public ``code``
+(``not_found``, ``missing_env_secrets``), never the server's error class name,
+which may be renamed at any time; any other body is shown as-is. TypeScript twin:
+``parseErrorBody`` in ``sdk-ts/src/cli/config.ts``.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional, Tuple
+
+
+def error_code(body: str) -> Optional[str]:
+    """The ``code`` of a JSON error body, or ``None`` when it carries none."""
+    try:
+        code = json.loads(body).get("code")
+    except (ValueError, AttributeError):
+        return None
+    return code if isinstance(code, str) else None
+
+
+def error_detail(body: str, limit: int = 600) -> Tuple[str, Optional[str]]:
+    """``(detail, code)`` for one error body: the rendered text and the stable code."""
+    try:
+        parsed = json.loads(body)
+    except ValueError:
+        return body[:limit], None
+    message = parsed.get("message") if isinstance(parsed, dict) else None
+    if not isinstance(message, str):
+        return body[:limit], None
+    code = error_code(body)
+    detail = f"{message} ({code})" if code else message
+    return detail[:limit], code

gatewaysdk-0.3.6/src/gatewaysdk/benchmark_hub/checkout.py

@@ -0,0 +1,237 @@
+"""Where a pull lands, decided before a byte is downloaded (P-20).
+
+- No target: ``./<slug>``, de-duplicated with ``-1``/``-2``; an existing dir is
+  never entered.
+- Explicit target: absent or empty -> used as-is; a clean checkout of the same
+  world -> replaced (its base files are cleared first so files the new version
+  dropped do not linger); local edits, another world's checkout or an untracked
+  non-empty dir -> refused unless ``force``, which discards the checkout's base
+  files *and* its local edits (added files included) so the result is the
+  pulled version, nothing else the archive would see.
+
+TypeScript twin: ``sdk-ts/src/worlds/checkoutTarget.ts``. Same refusal texts.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from ..environment.world import WorldTree
+from .errors import BenchmarkPushError
+
+DEFAULT_BRANCH = "main"
+_META_RELPATH = Path(".gateway") / ".env-metadata.json"
+
+
+def read_local_meta(env_path: Path) -> Optional[Dict[str, Any]]:
+    """The dir's recorded base/branch, or None (an ad-hoc dir)."""
+    meta_path = Path(env_path) / _META_RELPATH
+    if not meta_path.is_file():
+        return None
+    try:
+        loaded = json.loads(meta_path.read_text())
+        return loaded if isinstance(loaded, dict) else None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def snapshot_tree_hashes(env_path: Path) -> Dict[str, str]:
+    """rel path -> sha256 over the ARCHIVE-VISIBLE tree (WorldTree.archive_files
+    rules). This is the working copy's base-file record: diffing against the
+    server manifest instead would surface phantom deletes, because the browser
+    manifest deliberately lists files (dotfiles, gitignored paths) that the
+    source tarball never contains."""
+    out: Dict[str, str] = {}
+    for file_path in WorldTree.from_dir(env_path).archive_files():
+        rel = str(file_path.relative_to(env_path)).replace("\\", "/")
+        out[rel] = hashlib.sha256(file_path.read_bytes()).hexdigest()
+    return out
+
+
+def local_tree_state(env_path: Path) -> Dict[str, Any]:
+    """The dir's hub link plus whether its ARCHIVE-VISIBLE tree still matches
+    the recorded base: ``{"meta", "dirty", "clean"}``. ``meta`` is None for an
+    ad-hoc dir (never pulled/pushed); ``dirty`` lists rel paths that changed,
+    appeared, or vanished vs the base snapshot; ``clean`` is True only when a
+    base exists AND nothing drifted — the one state where a local run can be
+    honestly pinned to the recorded version."""
+    meta = read_local_meta(Path(env_path))
+    base = meta.get("baseFiles") if meta else None
+    if not isinstance(base, dict):
+        return {"meta": meta, "dirty": [], "clean": False}
+    now = snapshot_tree_hashes(Path(env_path))
+    dirty = sorted({p for p, h in now.items() if base.get(p) != h} | {p for p in base if p not in now})
+    return {"meta": meta, "dirty": dirty, "clean": not dirty}
+
+
+def write_local_meta(env_path: Path, meta: Dict[str, Any]) -> None:
+    meta_dir = Path(env_path) / _META_RELPATH.parent
+    meta_dir.mkdir(exist_ok=True)
+    (Path(env_path) / _META_RELPATH).write_text(json.dumps(meta, indent=2))
+
+
+_NAMED_EDITS = 3
+
+
+def _confined_rel(rel: str) -> bool:
+    if not rel or Path(rel).is_absolute():
+        return False
+    return ".." not in rel.replace("\\", "/").split("/")
+
+
+class CheckoutRefusedError(BenchmarkPushError):
+    def __init__(self, message: str) -> None:
+        super().__init__(f"checkout refused: {message}")
+
+
+class DetachedPushError(BenchmarkPushError):
+    """A push from a tag checkout: tags are immutable, so there is no branch to move."""
+
+    def __init__(self, env_path: Path, tag: str) -> None:
+        super().__init__(
+            f'push refused: {env_path} is a checkout of tag "{tag}" (tags are immutable). '
+            "Nothing was pushed. Pass --branch <name> to land these files on a branch, "
+            "or checkout a branch first."
+        )
+
+
+def checkout_identity(ref: str, resolved: Dict[str, Any], default_branch: str) -> Dict[str, str]:
+    """What a checkout tracks after a pull: the branch that answered the ref or
+    the tag it was taken from (detached). Older servers name neither: ``latest``
+    and semver/hash pins land on the default branch; any other ref was a branch."""
+    tag = resolved.get("tag")
+    if isinstance(tag, str) and tag:
+        return {"tag": tag}
+    branch = resolved.get("branch")
+    if isinstance(branch, str) and branch:
+        return {"branch": branch}
+    pinned = ref == "latest" or ref[:1].isdigit() or _looks_like_hash(ref)
+    return {"branch": default_branch if pinned else ref}
+
+
+def _looks_like_hash(ref: str) -> bool:
+    return len(ref) >= 8 and all(c in "0123456789abcdef" for c in ref)
+
+
+def push_branch(env_path: Path, local_meta: Dict[str, Any], explicit: Optional[str], default_branch: str) -> str:
+    """The branch a push lands on; refuses a tag checkout unless one is named."""
+    if explicit:
+        return explicit
+    tag = local_meta.get("tag")
+    if isinstance(tag, str) and tag:
+        raise DetachedPushError(env_path, tag)
+    branch = local_meta.get("branch")
+    return branch if isinstance(branch, str) and branch else default_branch
+
+
+@dataclass(frozen=True)
+class CheckoutTarget:
+    dir: Path
+    #: Files of the checkout being replaced (its base + its local edits); removed by ``clear()``.
+    replaces: List[str] = field(default_factory=list)
+
+    @staticmethod
+    def resolve(
+        slug: str,
+        target: Optional[str],
+        *,
+        cwd: Path,
+        force: bool,
+        state: Callable[[Path], Dict[str, Any]],
+    ) -> "CheckoutTarget":
+        if target is None:
+            return CheckoutTarget._fresh(slug, cwd)
+        return CheckoutTarget._explicit(CheckoutTarget._confined(target, cwd), slug, force, state)
+
+    @staticmethod
+    def _confined(target: str, cwd: Path) -> Path:
+        """The absolute destination; a relative target may not resolve above ``cwd``
+        (an absolute path is the explicit way elsewhere)."""
+        dst = (cwd / target).resolve()
+        root = cwd.resolve()
+        if Path(target).is_absolute() or dst == root or root in dst.parents:
+            return dst
+        raise CheckoutRefusedError(
+            f"--target {target} resolves outside the current directory ({cwd}) — run from that "
+            "directory, or pass an absolute path"
+        )
+
+    @staticmethod
+    def _fresh(slug: str, cwd: Path) -> "CheckoutTarget":
+        base = cwd / slug
+        dst = base
+        i = 1
+        while dst.exists():
+            dst = base.parent / f"{base.name}-{i}"
+            i += 1
+        return CheckoutTarget(dst)
+
+    @staticmethod
+    def _explicit(dst: Path, slug: str, force: bool, state: Callable[[Path], Dict[str, Any]]) -> "CheckoutTarget":
+        if not dst.exists():
+            return CheckoutTarget(dst)
+        if not dst.is_dir():
+            raise CheckoutRefusedError(f"{dst} is a file")
+        if not any(dst.iterdir()):
+            return CheckoutTarget(dst)
+        tree = state(dst)
+        refusal = CheckoutTarget._refusal(dst, slug, tree)
+        if refusal is None or force:
+            return CheckoutTarget(dst, CheckoutTarget._tracked(tree))
+        raise CheckoutRefusedError(refusal)
+
+    @staticmethod
+    def _tracked(tree: Dict[str, Any]) -> List[str]:
+        """Base files plus local edits — everything the archive would see in the old
+        checkout. ``.env-metadata.json`` is local input: a key that would leave the
+        checkout (``../x``, ``/etc/x``) is dropped, never removed."""
+        meta = tree.get("meta") or {}
+        base_files = meta.get("baseFiles") if isinstance(meta, dict) else None
+        if not isinstance(base_files, dict):
+            return []
+        return sorted(rel for rel in set(base_files) | set(tree.get("dirty") or []) if _confined_rel(rel))
+
+    @staticmethod
+    def _refusal(dst: Path, slug: str, tree: Dict[str, Any]) -> Optional[str]:
+        """Why ``dst`` cannot be overwritten, or None when it is a clean checkout of ``slug``."""
+        meta = tree.get("meta") or {}
+        if not isinstance(meta.get("baseFiles"), dict):
+            return (
+                f'{dst} is not empty and is not a checkout of "{slug}" — pick an empty '
+                "--target, or pass --force to overwrite it"
+            )
+        tracked = meta.get("slug")
+        if tracked is not None and tracked != slug:
+            return f'{dst} tracks "{tracked}", not "{slug}" — pick another --target, ' "or pass --force to replace it"
+        if tree.get("clean"):
+            return None
+        dirty: List[str] = list(tree.get("dirty") or [])
+        n = len(dirty)
+        named = ", ".join(dirty[:_NAMED_EDITS])
+        more = f", +{n - _NAMED_EDITS} more" if n > _NAMED_EDITS else ""
+        plural = "" if n == 1 else "s"
+        return (
+            f"{dst} has {n} local edit{plural} not pushed ({named}{more}) — push or "
+            "propose them first, or pass --force to discard them"
+        )
+
+    def clear(self) -> None:
+        """Remove the replaced checkout's files (and the dirs they leave empty)."""
+        for rel in self.replaces:
+            abs_path = self.dir / rel
+            if abs_path.is_file() or abs_path.is_symlink():
+                abs_path.unlink()
+            self._prune_empty_parents(abs_path.parent)
+
+    def _prune_empty_parents(self, start: Path) -> None:
+        cur = start
+        while cur != self.dir and self.dir in cur.parents:
+            if cur.exists() and any(cur.iterdir()):
+                return
+            shutil.rmtree(cur, ignore_errors=True)
+            cur = cur.parent