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

package/__fixtures__/2.wire/output/wire_service/_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.wire.test/v1"
+USER_AGENT = "wire_service-python/0.3.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["X-Api-Key"] = 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__/2.wire/output/wire_service/models.py

@@ -0,0 +1,44 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, BinaryIO, Optional, Union
+
+
+@dataclass
+class Item:
+    id: str
+    label: str
+    kind: Optional[ItemKind] = None
+    meta_data: Optional[dict[str, Any]] = field(default=None, metadata={"wire": "metaData"})
+
+
+class ItemKind(str, Enum):
+    STANDARD = "standard"
+    PREMIUM = "premium"
+
+
+@dataclass
+class CreateUploadRequest:
+    file: Union[bytes, BinaryIO]
+    label: Optional[str] = None
+
+
+@dataclass
+class UploadResult:
+    id: str
+    status: Optional[str] = None
+
+
+@dataclass
+class CreateTokenRequest:
+    grant_type: str
+    scope: Optional[str] = None
+
+
+@dataclass
+class Token:
+    access_token: str
+    expires_in: Optional[int] = None

package/__fixtures__/2.wire/output/wire_service/resources.py

@@ -0,0 +1,38 @@
+# Code generated by opensdk. DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing import BinaryIO, Optional, Union
+
+from ._pagination import CursorPage
+from ._transport import Transport, decode, join_csv
+from .models import *  # noqa: F401,F403
+
+
+class ItemsResource:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def list(self, *, ids: Optional[list[str]] = None, tags: Optional[list[str]] = None, after: Optional[str] = None, limit: Optional[int] = None, workspace: Optional[str] = None) -> CursorPage[Item]:
+        return CursorPage.from_response(Item, self._transport.request("GET", "/items", query={"ids[]": ids, "tags": join_csv(tags), "after": after, "limit": limit}, headers={"X-Workspace": workspace}))
+
+
+class UploadsResource:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create(self, *, file: Union[bytes, BinaryIO], label: Optional[str] = None) -> UploadResult:
+        return decode(UploadResult, self._transport.request("POST", "/uploads", body={"file": file, "label": label}, encoding="multipart"))
+
+    def download(self, upload_id: str) -> bytes:
+        if not upload_id:
+            raise ValueError(f"Expected a non-empty value for `upload_id` but received {upload_id!r}")
+        return self._transport.request("GET", f"/uploads/{upload_id}/content", headers={"Accept": "application/octet-stream"}, raw=True)
+
+
+class TokensResource:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create(self, *, grant_type: str, scope: Optional[str] = None) -> Token:
+        return decode(Token, self._transport.request("POST", "/token", body={"grant_type": grant_type, "scope": scope}, encoding="form", idempotency=True))

package/__tests__/docs.test.ts

@@ -0,0 +1,115 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import yaml from 'js-yaml';
+import { beforeAll, describe, expect, it } from 'vitest';
+
+import { eachOperation, firstMethod, miniDoc } from '@xyd-js/opensdk-ci';
+
+import { opensdkPython, writeProject } from '../index';
+import { snakeCase } from '../src/naming';
+
+// Generation-only dep (used when O2S_BUILD_DOCS=1); the regen-guard test below is
+// pure (opensdk IR input.json → py).
+import { openapi2opensdk } from '@xyd-js/openapi2opensdk';
+
+const O2S_FIX = path.join(__dirname, '../__fixtures__/-2.complex.openai');
+// The canonical OpenAI spec vendored in the converter's oracle is our source of truth.
+const SPEC = path.join(__dirname, '../../xyd-openapi2opensdk/oracle/openai-openapi.yaml');
+const GROUPING_PATH = path.join(__dirname, '../../xyd-openapi2opensdk/oracle/openai-grouping.json');
+// oracle/* is gitignored/encrypted; guard the read so the OFFLINE regen-guard below
+// still loads + runs when the plaintext is absent (CI without XYD_CONTENT_SECRET).
+const GROUPING = fs.existsSync(GROUPING_PATH) ? JSON.parse(fs.readFileSync(GROUPING_PATH, 'utf8')) : {};
+
+const BUILD = process.env.O2S_BUILD_DOCS === '1';
+const PY_SMOKE = process.env.O2S_PY_SMOKE === '1';
+
+/** The generated `<pkg>/resources.py` (the interesting per-method output). */
+function resourcesKey(files: Record<string, string>): string | undefined {
+  return Object.keys(files).find((k) => k.endsWith('/resources.py'));
+}
+
+// ---- Generator (opt-in): one CORRECT fixture per real spec operation ------
+describe.runIf(BUILD)('generate opensdk → python fixtures (assumed-correct, for review)', () => {
+  // biome-ignore lint/suspicious/noExplicitAny: raw OpenAPI document
+  let spec: any;
+  beforeAll(() => {
+    spec = yaml.load(fs.readFileSync(SPEC, 'utf8'));
+  });
+
+  it('build __fixtures__/-2.complex.openai/<op>/{input.json, output.py}', () => {
+    fs.rmSync(O2S_FIX, { recursive: true, force: true });
+    const used = new Set<string>();
+    let n = 0;
+    for (const { path: p, method, operation } of eachOperation(spec)) {
+      let ir: ReturnType<typeof openapi2opensdk>;
+      let files: Record<string, string>;
+      try {
+        ir = openapi2opensdk(miniDoc(spec, method, p), {
+          sdkName: 'openai',
+          mountRules: GROUPING.mountRules,
+          operationHints: GROUPING.operationHints,
+        });
+        files = opensdkPython(ir);
+      } catch {
+        continue;
+      }
+      const key = resourcesKey(files);
+      const leaf = firstMethod(ir.resources);
+      if (!key || !leaf) continue;
+
+      const base = `${leaf.segments.map(snakeCase).join('__')}__${snakeCase(leaf.method.action)}`;
+      let dir = base;
+      if (used.has(dir)) dir = `${base}__${snakeCase(operation.operationId || method)}`;
+      for (let i = 2; used.has(dir); i++) dir = `${base}__${i}`;
+      used.add(dir);
+
+      const outDir = path.join(O2S_FIX, dir);
+      fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(path.join(outDir, 'input.json'), `${JSON.stringify(ir, null, 2)}\n`);
+      fs.writeFileSync(path.join(outDir, 'output.py'), files[key]);
+      n++;
+    }
+    expect(n).toBeGreaterThan(200);
+  }, 300000);
+});
+
+// ---- Regen guard (offline; pure opensdk IR → py) -------------------------
+const fixtures = fs.existsSync(O2S_FIX)
+  ? fs.readdirSync(O2S_FIX).filter((d) => fs.existsSync(path.join(O2S_FIX, d, 'input.json')))
+  : [];
+
+describe.skipIf(!fixtures.length || BUILD)('opensdk-python docs (IR → py, regen guard)', () => {
+  for (const dir of fixtures) {
+    it(dir, () => {
+      const ir = JSON.parse(fs.readFileSync(path.join(O2S_FIX, dir, 'input.json'), 'utf8'));
+      const files = opensdkPython(ir);
+      const key = resourcesKey(files);
+      expect(key, `no resources.py generated for ${dir}`).toBeTruthy();
+      const expected = fs.readFileSync(path.join(O2S_FIX, dir, 'output.py'), 'utf8');
+      expect(files[key as string]).toEqual(expected);
+    });
+  }
+});
+
+// ---- Optional: a sample of the generated projects py_compile -------------
+describe.runIf(PY_SMOKE && fixtures.length > 0)('opensdk-python docs (py_compile smoke, sample)', () => {
+  const step = Math.max(1, Math.floor(fixtures.length / 8));
+  const sample = fixtures.filter((_, i) => i % step === 0).slice(0, 8);
+  for (const dir of sample) {
+    it(`compiles ${dir}`, async () => {
+      const ir = JSON.parse(fs.readFileSync(path.join(O2S_FIX, dir, 'input.json'), 'utf8'));
+      const files = opensdkPython(ir);
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'o2py-docs-'));
+      try {
+        await writeProject(files, tmp);
+        const mods = Object.keys(files).filter((f) => f.endsWith('.py'));
+        execSync(`python3 -m py_compile ${mods.map((m) => JSON.stringify(m)).join(' ')}`, { cwd: tmp, stdio: 'pipe' });
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    }, 60000);
+  }
+});

package/__tests__/e2e/harness.ts

@@ -0,0 +1,79 @@
+import { execSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, it } from 'vitest';
+
+import { MockServer, fullIR, hasCommand } from '@xyd-js/opensdk-ci';
+import { writeProject } from '@xyd-js/opensdk-framework';
+
+import { opensdkPython } from '../../index';
+
+// The PYTHON half of the generated-SDK e2e — the analog of the opensdk-go
+// harness's `runGeneratedTests`. The language-agnostic primitives (IR merge,
+// spec-shaped MockServer, command probe) live in @xyd-js/opensdk-ci; this file
+// only stands the Python SDK up in a venv and runs its OWN pytest suite. An
+// API's whole Python e2e is one call (see e2e/openai.test.ts):
+//   runGeneratedTests({ name, sdkName, fixturesDir })
+
+export interface ApiConfig {
+  name: string;
+  sdkName: string;
+  /** Per-method fixtures dir merged into one OpenSDK IR by `fullIR`. */
+  fixturesDir: string;
+}
+
+/**
+ * (Gated E2E_SDK_TESTS=1) RUN the generated Python SDK's OWN pytest suite
+ * against a spec-shaped mock — the analog of pointing openai-python's
+ * test_*.py at a Prism mock of the OpenAPI spec. Generates the whole SDK (with
+ * its tests/test_<resource>.py), creates a venv, pip-installs pytest, stands up
+ * a MockServer that answers every method with a decodable example response, and
+ * runs `pytest tests` with TEST_API_BASE_URL pointed at it, so the emitted
+ * tests EXECUTE and PASS (not just py_compile). Gated on python3 availability.
+ */
+export function runGeneratedTests(cfg: ApiConfig) {
+  const RUN = process.env.E2E_SDK_TESTS === '1';
+  describe.runIf(RUN)(`${cfg.name} e2e: the SDK's own generated tests pass against a mock`, () => {
+    it('pytest tests is green against the spec-shaped mock', async () => {
+      if (!hasCommand('python3 --version')) return;
+      const spec = fullIR(cfg.fixturesDir, cfg.sdkName);
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'o2s-py-selftest-'));
+      const mock = new MockServer(spec);
+      await mock.start();
+      try {
+        await writeProject(opensdkPython(spec), tmpDir);
+        execSync('python3 -m venv .venv', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('.venv/bin/pip install -q pytest', { cwd: tmpDir, stdio: 'pipe' });
+        // pytest via async spawn (NOT execSync): the MockServer runs in THIS
+        // Node process, so a synchronous child would block the event loop and
+        // the generated conftest's HTTP calls would deadlock. spawn keeps the
+        // loop free to serve the mock.
+        await new Promise<void>((resolve, reject) => {
+          const p = spawn('.venv/bin/python', ['-m', 'pytest', 'tests', '-q', '--no-header'], {
+            cwd: tmpDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+              ...process.env,
+              PYTHONPATH: tmpDir,
+              TEST_API_BASE_URL: `http://127.0.0.1:${mock.port}`,
+            },
+          });
+          let out = '';
+          p.stdout?.on('data', (d) => {
+            out += d;
+          });
+          p.stderr?.on('data', (d) => {
+            out += d;
+          });
+          p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`pytest failed:\n${out}`))));
+          p.on('error', reject);
+        });
+      } finally {
+        mock.stop();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    }, 600000);
+  });
+}

package/__tests__/e2e/openai.test.ts

@@ -0,0 +1,14 @@
+import path from 'node:path';
+
+import { runGeneratedTests } from './harness';
+
+// OpenAI binding for the Python generated-SDK e2e harness. The whole SDK is
+// assembled from the committed OpenSDK IR inputs (no OpenAPI/upstream
+// dependency) and its own pytest suite is run against a spec-shaped mock.
+const openai = {
+  name: 'openai',
+  sdkName: 'openai',
+  fixturesDir: path.join(__dirname, '../../__fixtures__/-2.complex.openai'),
+};
+
+runGeneratedTests(openai);