@xyd-js/opensdk-python 0.0.0-build-f0c10f6-20260703195526

package/__fixtures__/1.basic/output/petstore/_pagination.py

@@ -0,0 +1,42 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Generic, Iterator, TypeVar
+
+from ._transport import decode
+
+T = TypeVar("T")
+
+
+@dataclass
+class CursorPage(Generic[T]):
+    """One page of a cursor-paginated list: `data` plus a `has_more` marker."""
+
+    data: list[T] = field(default_factory=list)
+    has_more: bool = False
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self.data)
+
+    @classmethod
+    def from_response(cls, item_type: Any, raw: Any) -> CursorPage[T]:
+        payload = raw if isinstance(raw, dict) else {}
+        data = [decode(item_type, item) for item in payload.get("data") or []]
+        return cls(data=data, has_more=bool(payload.get("has_more") or False))
+
+
+@dataclass
+class Page(Generic[T]):
+    """One page of a marker-less list: the whole collection in one `data` envelope."""
+
+    data: list[T] = field(default_factory=list)
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self.data)
+
+    @classmethod
+    def from_response(cls, item_type: Any, raw: Any) -> Page[T]:
+        payload = raw if isinstance(raw, dict) else {}
+        return cls(data=[decode(item_type, item) for item in payload.get("data") or []])

package/__fixtures__/1.basic/output/petstore/_transport.py

@@ -0,0 +1,391 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+import dataclasses
+import datetime
+import email.utils
+import json
+import os
+import random
+import time
+import typing
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from enum import Enum
+from typing import Any, Optional
+
+DEFAULT_BASE_URL = "https://api.petstore.io/v1"
+USER_AGENT = "petstore-python/1.2.0"
+AI_AGENT_ENV_VARS = {"CLAUDE_CODE": "claude-code", "CURSOR_AGENT": "cursor", "CLINE_ACTIVE": "cline", "WINDSURF_ACTIVE": "windsurf", "COPILOT_AGENT": "copilot"}
+DEFAULT_TIMEOUT: Optional[float] = 60.0
+MAX_RETRIES = 2
+RETRYABLE_STATUS_CODES = frozenset({408, 429, 500, 502, 503, 504})
+RETRY_CONNECTION_ERRORS = True
+HONOR_RETRY_AFTER_HEADER = True
+BACKOFF_INITIAL_DELAY = 0.5
+BACKOFF_MAX_DELAY = 8.0
+BACKOFF_MULTIPLIER = 2.0
+BACKOFF_JITTER = 0.25
+REQUEST_ID_HEADER = "X-Request-ID"
+IDEMPOTENCY_HEADER = "Idempotency-Key"
+GUARDED_OPTION_KEYS = frozenset({"api_key", "apiKey", "idempotency_key", "idempotencyKey", "extra_headers", "extraHeaders", "max_retries", "maxRetries", "base_url", "baseUrl", "timeout"})
+
+
+class APIError(Exception):
+    """A non-2xx API response: status code, headers, raw body, request id and a best-effort message."""
+
+    kind = "API"
+
+    def __init__(self, status_code: int, headers: dict[str, str], body: bytes) -> None:
+        self.status_code = status_code
+        self.headers = headers
+        self.body = body
+        self.request_id = _header(headers, REQUEST_ID_HEADER)
+        self.message = _error_message(body) or "HTTP " + str(status_code)
+        super().__init__(self.message)
+
+
+class BadRequestError(APIError):
+    """The mapped error kind for HTTP 400 responses."""
+
+    kind = "BadRequest"
+
+
+class UnauthorizedError(APIError):
+    """The mapped error kind for HTTP 401 responses."""
+
+    kind = "Unauthorized"
+
+
+class PermissionDeniedError(APIError):
+    """The mapped error kind for HTTP 403 responses."""
+
+    kind = "PermissionDenied"
+
+
+class NotFoundError(APIError):
+    """The mapped error kind for HTTP 404 responses."""
+
+    kind = "NotFound"
+
+
+class ConflictError(APIError):
+    """The mapped error kind for HTTP 409 responses."""
+
+    kind = "Conflict"
+
+
+class UnprocessableEntityError(APIError):
+    """The mapped error kind for HTTP 422 responses."""
+
+    kind = "UnprocessableEntity"
+
+
+class RateLimitedError(APIError):
+    """The mapped error kind for HTTP 429 responses."""
+
+    kind = "RateLimited"
+
+
+class InternalError(APIError):
+    """Catch-all for unmapped 5xx responses."""
+
+    kind = "Internal"
+
+
+_STATUS_TO_ERROR: dict[int, type] = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    403: PermissionDeniedError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: UnprocessableEntityError,
+    429: RateLimitedError,
+}
+
+
+def _error_for_status(status_code: int, headers: dict[str, str], body: bytes) -> APIError:
+    """The policy-mapped exception: exact status map first, then the 5xx catch-all, then the client catch-all."""
+    cls = _STATUS_TO_ERROR.get(status_code)
+    if cls is None:
+        cls = InternalError if status_code >= 500 else APIError
+    return cls(status_code, headers, body)
+
+
+def _error_message(body: bytes) -> Optional[str]:
+    """Best-effort message from a JSON error envelope ({"error": {"message": ...}} etc.)."""
+    try:
+        payload = json.loads(body.decode("utf-8"))
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    error = payload.get("error")
+    if isinstance(error, dict) and isinstance(error.get("message"), str):
+        return error["message"]
+    if isinstance(error, str):
+        return error
+    for key in ("message", "detail"):
+        if isinstance(payload.get(key), str):
+            return payload[key]
+    return None
+
+
+def _header(headers: dict[str, str], name: str) -> Optional[str]:
+    """Case-insensitive header lookup."""
+    target = name.lower()
+    for key, value in headers.items():
+        if key.lower() == target:
+            return value
+    return None
+
+
+def _user_agent() -> str:
+    """The policy User-Agent: SDK identifier, plus an AI-agent slug when a known agent env var is set."""
+    ua = USER_AGENT
+    for env_var, slug in AI_AGENT_ENV_VARS.items():
+        if os.environ.get(env_var):
+            ua += " agent/" + slug
+            break
+    return ua
+
+
+def _default_timeout() -> Optional[float]:
+    """The policy default timeout in seconds (None = no deadline)."""
+    return DEFAULT_TIMEOUT
+
+
+def _retry_delay(attempt: int, headers: Optional[dict[str, str]]) -> float:
+    """Seconds to sleep before retry attempt (0-based): a Retry-After header
+    wins when honored; otherwise min(initial * multiplier**attempt, max) plus
+    proportional random jitter."""
+    if HONOR_RETRY_AFTER_HEADER and headers:
+        retry_after = _retry_after_seconds(headers)
+        if retry_after is not None:
+            return retry_after
+    delay = min(BACKOFF_INITIAL_DELAY * (BACKOFF_MULTIPLIER ** attempt), BACKOFF_MAX_DELAY)
+    return delay + delay * BACKOFF_JITTER * random.random()
+
+
+def _retry_after_seconds(headers: dict[str, str]) -> Optional[float]:
+    """A Retry-After header as seconds: both the integer-seconds and the HTTP-date forms."""
+    value = _header(headers, "Retry-After")
+    if value is None:
+        return None
+    value = value.strip()
+    if value.isdigit():
+        return float(value)
+    try:
+        parsed = email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed is None:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+    return max(0.0, (parsed - datetime.datetime.now(datetime.timezone.utc)).total_seconds())
+
+
+def _guard_options(params: Optional[dict[str, Any]]) -> None:
+    """Fail fast when a request-option key (api_key, max_retries, ...) is
+    misplaced into request params — a misplaced credential would otherwise be
+    sent on the wire and end up in provider logs."""
+    for key in params or ():
+        if key in GUARDED_OPTION_KEYS:
+            raise ValueError(
+                "request option " + repr(key) + " must be set on the client, not passed as a request parameter"
+            )
+
+
+def encode(value: Any) -> Any:
+    """Wire-encode a request value: dataclasses -> dicts keyed by wire name
+    (None fields dropped), enums -> their values; lists/dicts recurse."""
+    if isinstance(value, Enum):
+        return encode(value.value)
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        out: dict[str, Any] = {}
+        for f in dataclasses.fields(value):
+            item = getattr(value, f.name)
+            if item is None:
+                continue
+            out[f.metadata.get("wire", f.name)] = encode(item)
+        return out
+    if isinstance(value, (list, tuple)):
+        return [encode(item) for item in value]
+    if isinstance(value, dict):
+        return {key: encode(item) for key, item in value.items()}
+    return value
+
+
+def decode(tp: Any, value: Any) -> Any:
+    """Best-effort decode of parsed JSON into the generated models: dataclasses
+    are built field-by-field (honoring wire names), enums by value; unknown
+    shapes are returned as-is."""
+    if value is None or tp is None or tp is Any:
+        return value
+    origin = typing.get_origin(tp)
+    if origin is not None:
+        args = typing.get_args(tp)
+        if origin is list and isinstance(value, list):
+            item_tp = args[0] if args else Any
+            return [decode(item_tp, item) for item in value]
+        if origin is dict and isinstance(value, dict):
+            value_tp = args[1] if len(args) > 1 else Any
+            return {key: decode(value_tp, item) for key, item in value.items()}
+        if origin is typing.Union:
+            for arg in args:
+                if arg is type(None):
+                    continue
+                try:
+                    decoded = decode(arg, value)
+                except Exception:
+                    continue
+                if decoded is not value:
+                    return decoded
+            return value
+        return value
+    if isinstance(tp, type) and issubclass(tp, Enum):
+        try:
+            return tp(value)
+        except ValueError:
+            return value
+    if isinstance(tp, type) and dataclasses.is_dataclass(tp) and isinstance(value, dict):
+        try:
+            hints = typing.get_type_hints(tp)
+        except Exception:
+            hints = {}
+        kwargs: dict[str, Any] = {}
+        for f in dataclasses.fields(tp):
+            wire = f.metadata.get("wire", f.name)
+            if wire in value:
+                kwargs[f.name] = decode(hints.get(f.name, Any), value[wire])
+            elif f.default is dataclasses.MISSING and f.default_factory is dataclasses.MISSING:
+                kwargs[f.name] = None
+        return tp(**kwargs)
+    return value
+
+
+def join_csv(value: Optional[list]) -> Optional[str]:
+    """Serialize an explode=false array parameter as one comma-joined value."""
+    if value is None:
+        return None
+    return ",".join(_text(encode(item)) for item in value)
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (dict, list)):
+        return json.dumps(value)
+    return str(value)
+
+
+def _query_value(value: Any) -> Any:
+    encoded = encode(value)
+    if isinstance(encoded, list):
+        return [_text(item) for item in encoded]
+    return _text(encoded)
+
+
+def _multipart(payload: dict[str, Any]) -> tuple[bytes, str]:
+    """Encode a multipart/form-data body (stdlib-only, manual boundary).
+    bytes / file-like values become file parts; lists become repeated parts."""
+    boundary = uuid.uuid4().hex
+    chunks: list[bytes] = []
+    for name, value in payload.items():
+        items = value if isinstance(value, list) else [value]
+        for item in items:
+            chunks.append(("--" + boundary + "\r\n").encode("utf-8"))
+            if isinstance(item, bytes) or hasattr(item, "read"):
+                content = item if isinstance(item, bytes) else item.read()
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+                filename = str(getattr(item, "name", name)).replace("\\", "/").split("/")[-1] or name
+                disposition = 'Content-Disposition: form-data; name="' + name + '"; filename="' + filename + '"\r\n'
+                chunks.append(disposition.encode("utf-8"))
+                chunks.append(b"Content-Type: application/octet-stream\r\n\r\n")
+                chunks.append(content)
+            else:
+                chunks.append(('Content-Disposition: form-data; name="' + name + '"\r\n\r\n').encode("utf-8"))
+                chunks.append(_text(item).encode("utf-8"))
+            chunks.append(b"\r\n")
+    chunks.append(("--" + boundary + "--\r\n").encode("utf-8"))
+    return b"".join(chunks), "multipart/form-data; boundary=" + boundary
+
+
+class Transport:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout if timeout is not None else _default_timeout()
+        self.user_agent = _user_agent()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        query: Optional[dict[str, Any]] = None,
+        body: Optional[dict[str, Any]] = None,
+        headers: Optional[dict[str, Any]] = None,
+        encoding: str = "json",
+        raw: bool = False,
+        idempotency: bool = False,
+    ) -> Any:
+        _guard_options(query)
+        _guard_options(body)
+        url = self.base_url + path
+        params = {k: _query_value(v) for k, v in (query or {}).items() if v is not None}
+        request_headers: dict[str, str] = {k: _text(v) for k, v in (headers or {}).items() if v is not None}
+        request_headers.setdefault("User-Agent", self.user_agent)
+        data = None
+        if body is not None:
+            payload = {k: encode(v) for k, v in body.items() if v is not None}
+            if encoding == "multipart":
+                data, content_type = _multipart(payload)
+                request_headers["Content-Type"] = content_type
+            elif encoding == "form":
+                data = urllib.parse.urlencode(payload, doseq=True).encode("utf-8")
+                request_headers["Content-Type"] = "application/x-www-form-urlencoded"
+            else:
+                data = json.dumps(payload).encode("utf-8")
+                request_headers["Content-Type"] = "application/json"
+        if self.api_key:
+            request_headers["Authorization"] = "Bearer " + self.api_key
+        if idempotency:
+            # One key per logical call, generated before the retry loop so every
+            # retry of this request carries the SAME idempotency key.
+            request_headers.setdefault(IDEMPOTENCY_HEADER, str(uuid.uuid4()))
+        if params:
+            url += "?" + urllib.parse.urlencode(params, doseq=True)
+        attempt = 0
+        while True:
+            request = urllib.request.Request(url, data=data, method=method, headers=request_headers)
+            try:
+                with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                    content = response.read()
+            except urllib.error.HTTPError as error:
+                error_headers = dict(error.headers.items())
+                error_body = error.read()
+                if attempt < MAX_RETRIES and error.code in RETRYABLE_STATUS_CODES:
+                    time.sleep(_retry_delay(attempt, error_headers))
+                    attempt += 1
+                    continue
+                raise _error_for_status(error.code, error_headers, error_body) from None
+            except OSError:
+                # Connection/timeout errors (URLError, reset, DNS failure, socket timeout).
+                if RETRY_CONNECTION_ERRORS and attempt < MAX_RETRIES:
+                    time.sleep(_retry_delay(attempt, None))
+                    attempt += 1
+                    continue
+                raise
+            if raw:
+                return content
+            return json.loads(content.decode("utf-8")) if content else None

package/__fixtures__/1.basic/output/petstore/models.py

@@ -0,0 +1,33 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+@dataclass
+class PetList:
+    data: Optional[list[Pet]] = None
+    has_more: Optional[bool] = None
+
+
+@dataclass
+class Pet:
+    id: str
+    name: str
+    status: Optional[PetStatus] = None
+    tags: Optional[list[str]] = None
+
+
+class PetStatus(str, Enum):
+    AVAILABLE = "available"
+    PENDING = "pending"
+    SOLD = "sold"
+
+
+@dataclass
+class CreatePetRequest:
+    name: str
+    status: Optional[PetStatus] = None

package/__fixtures__/1.basic/output/petstore/resources.py

@@ -0,0 +1,25 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ._pagination import CursorPage
+from ._transport import Transport, decode
+from .models import *  # noqa: F401,F403
+
+
+class PetsResource:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def list(self, *, after: Optional[str] = None, limit: Optional[int] = None) -> CursorPage[Pet]:
+        return CursorPage.from_response(Pet, self._transport.request("GET", "/pets", query={"after": after, "limit": limit}))
+
+    def create(self, *, name: str, status: Optional[PetStatus] = None) -> Pet:
+        return decode(Pet, self._transport.request("POST", "/pets", body={"name": name, "status": status}))
+
+    def retrieve(self, pet_id: str) -> Pet:
+        if not pet_id:
+            raise ValueError(f"Expected a non-empty value for `pet_id` but received {pet_id!r}")
+        return decode(Pet, self._transport.request("GET", f"/pets/{pet_id}"))

package/__fixtures__/1.basic/output/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "petstore"
+version = "1.2.0"
+description = "A tiny pet store API."
+requires-python = ">=3.9"
+
+[tool.setuptools.packages.find]
+include = ["petstore"]

package/__fixtures__/1.basic/output/tests/conftest.py

@@ -0,0 +1,16 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from petstore import Client
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+@pytest.fixture
+def client() -> Client:
+    return Client(api_key="My API Key", base_url=base_url)

package/__fixtures__/1.basic/output/tests/test_pets.py

@@ -0,0 +1,36 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+import pytest
+
+from tests.utils import assert_matches_type
+from petstore import Client
+from petstore.models import *  # noqa: F401,F403
+from petstore._pagination import CursorPage
+
+
+class TestPets:
+    def test_method_list(self, client: Client) -> None:
+        result = client.pets.list()
+        assert_matches_type(CursorPage[Pet], result, path=["response"])
+
+    def test_method_list_with_all_params(self, client: Client) -> None:
+        result = client.pets.list(after="after", limit=0)
+        assert_matches_type(CursorPage[Pet], result, path=["response"])
+
+    def test_method_create(self, client: Client) -> None:
+        result = client.pets.create(name="x")
+        assert_matches_type(Pet, result, path=["response"])
+
+    def test_method_create_with_all_params(self, client: Client) -> None:
+        result = client.pets.create(name="x", status="available")
+        assert_matches_type(Pet, result, path=["response"])
+
+    def test_method_retrieve(self, client: Client) -> None:
+        result = client.pets.retrieve("pet_id")
+        assert_matches_type(Pet, result, path=["response"])
+
+    def test_path_params_retrieve(self, client: Client) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `pet_id` but received ''"):
+            client.pets.retrieve("")

package/__fixtures__/1.basic/output/tests/utils.py

@@ -0,0 +1,28 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+import typing
+from typing import Any
+
+
+def assert_matches_type(expected_type: Any, value: Any, *, path: Any = None) -> None:
+    """Pragmatic structural check for the generated test suite.
+
+    Verifies the SHAPE of a response without being strict about deep generics:
+    dataclass instances, the vendored pagination containers, primitives, lists
+    and dicts are all accepted. A parameterized generic (e.g. CursorPage[Pet],
+    list[str]) is matched against its ORIGIN only; Any / object / typing
+    constructs (Optional, Union, ...) always match.
+    """
+    origin = typing.get_origin(expected_type)
+    if origin is not None:
+        expected_type = origin
+    if expected_type is Any or expected_type is object or expected_type is None:
+        return
+    if not isinstance(expected_type, type):
+        return
+    assert isinstance(value, expected_type), (
+        f"expected {getattr(expected_type, '__name__', expected_type)!r}, "
+        f"got {type(value).__name__!r} (path={path})"
+    )