codexloop 0.1.0__py3-none-any.whl

codexloop/infrastructure/api/api_baseline.json

@@ -0,0 +1,340 @@
+{
+  "openai_version": "3.0.0",
+  "method_count": 320,
+  "local_helpers": [
+    "beta.chat.completions.parse",
+    "beta.chat.completions.stream",
+    "beta.threads.create_and_run_stream",
+    "beta.threads.runs.create_and_stream",
+    "beta.threads.runs.stream",
+    "beta.threads.runs.submit_tool_outputs_stream",
+    "chat.completions.parse",
+    "chat.completions.stream",
+    "responses.parse",
+    "responses.stream",
+    "webhooks.unwrap",
+    "webhooks.verify_signature"
+  ],
+  "methods": [
+    "admin.organization.admin_api_keys.create",
+    "admin.organization.admin_api_keys.delete",
+    "admin.organization.admin_api_keys.list",
+    "admin.organization.admin_api_keys.retrieve",
+    "admin.organization.audit_logs.list",
+    "admin.organization.certificates.activate",
+    "admin.organization.certificates.create",
+    "admin.organization.certificates.deactivate",
+    "admin.organization.certificates.delete",
+    "admin.organization.certificates.list",
+    "admin.organization.certificates.retrieve",
+    "admin.organization.certificates.update",
+    "admin.organization.data_retention.retrieve",
+    "admin.organization.data_retention.update",
+    "admin.organization.groups.create",
+    "admin.organization.groups.delete",
+    "admin.organization.groups.list",
+    "admin.organization.groups.retrieve",
+    "admin.organization.groups.roles.create",
+    "admin.organization.groups.roles.delete",
+    "admin.organization.groups.roles.list",
+    "admin.organization.groups.roles.retrieve",
+    "admin.organization.groups.update",
+    "admin.organization.groups.users.create",
+    "admin.organization.groups.users.delete",
+    "admin.organization.groups.users.list",
+    "admin.organization.groups.users.retrieve",
+    "admin.organization.invites.create",
+    "admin.organization.invites.delete",
+    "admin.organization.invites.list",
+    "admin.organization.invites.retrieve",
+    "admin.organization.projects.api_keys.delete",
+    "admin.organization.projects.api_keys.list",
+    "admin.organization.projects.api_keys.retrieve",
+    "admin.organization.projects.archive",
+    "admin.organization.projects.certificates.activate",
+    "admin.organization.projects.certificates.deactivate",
+    "admin.organization.projects.certificates.list",
+    "admin.organization.projects.create",
+    "admin.organization.projects.data_retention.retrieve",
+    "admin.organization.projects.data_retention.update",
+    "admin.organization.projects.groups.create",
+    "admin.organization.projects.groups.delete",
+    "admin.organization.projects.groups.list",
+    "admin.organization.projects.groups.retrieve",
+    "admin.organization.projects.groups.roles.create",
+    "admin.organization.projects.groups.roles.delete",
+    "admin.organization.projects.groups.roles.list",
+    "admin.organization.projects.groups.roles.retrieve",
+    "admin.organization.projects.hosted_tool_permissions.retrieve",
+    "admin.organization.projects.hosted_tool_permissions.update",
+    "admin.organization.projects.list",
+    "admin.organization.projects.model_permissions.delete",
+    "admin.organization.projects.model_permissions.retrieve",
+    "admin.organization.projects.model_permissions.update",
+    "admin.organization.projects.rate_limits.list_rate_limits",
+    "admin.organization.projects.rate_limits.update_rate_limit",
+    "admin.organization.projects.retrieve",
+    "admin.organization.projects.roles.create",
+    "admin.organization.projects.roles.delete",
+    "admin.organization.projects.roles.list",
+    "admin.organization.projects.roles.retrieve",
+    "admin.organization.projects.roles.update",
+    "admin.organization.projects.service_accounts.api_keys.create",
+    "admin.organization.projects.service_accounts.create",
+    "admin.organization.projects.service_accounts.delete",
+    "admin.organization.projects.service_accounts.list",
+    "admin.organization.projects.service_accounts.retrieve",
+    "admin.organization.projects.service_accounts.update",
+    "admin.organization.projects.spend_alerts.create",
+    "admin.organization.projects.spend_alerts.delete",
+    "admin.organization.projects.spend_alerts.list",
+    "admin.organization.projects.spend_alerts.retrieve",
+    "admin.organization.projects.spend_alerts.update",
+    "admin.organization.projects.spend_limit.delete",
+    "admin.organization.projects.spend_limit.retrieve",
+    "admin.organization.projects.spend_limit.update",
+    "admin.organization.projects.update",
+    "admin.organization.projects.users.create",
+    "admin.organization.projects.users.delete",
+    "admin.organization.projects.users.list",
+    "admin.organization.projects.users.retrieve",
+    "admin.organization.projects.users.roles.create",
+    "admin.organization.projects.users.roles.delete",
+    "admin.organization.projects.users.roles.list",
+    "admin.organization.projects.users.roles.retrieve",
+    "admin.organization.projects.users.update",
+    "admin.organization.roles.create",
+    "admin.organization.roles.delete",
+    "admin.organization.roles.list",
+    "admin.organization.roles.retrieve",
+    "admin.organization.roles.update",
+    "admin.organization.spend_alerts.create",
+    "admin.organization.spend_alerts.delete",
+    "admin.organization.spend_alerts.list",
+    "admin.organization.spend_alerts.retrieve",
+    "admin.organization.spend_alerts.update",
+    "admin.organization.spend_limit.delete",
+    "admin.organization.spend_limit.retrieve",
+    "admin.organization.spend_limit.update",
+    "admin.organization.usage.audio_speeches",
+    "admin.organization.usage.audio_transcriptions",
+    "admin.organization.usage.code_interpreter_sessions",
+    "admin.organization.usage.completions",
+    "admin.organization.usage.costs",
+    "admin.organization.usage.embeddings",
+    "admin.organization.usage.file_search_calls",
+    "admin.organization.usage.images",
+    "admin.organization.usage.moderations",
+    "admin.organization.usage.vector_stores",
+    "admin.organization.usage.web_search_calls",
+    "admin.organization.users.delete",
+    "admin.organization.users.list",
+    "admin.organization.users.retrieve",
+    "admin.organization.users.roles.create",
+    "admin.organization.users.roles.delete",
+    "admin.organization.users.roles.list",
+    "admin.organization.users.roles.retrieve",
+    "admin.organization.users.update",
+    "audio.speech.create",
+    "audio.transcriptions.create",
+    "audio.translations.create",
+    "batches.cancel",
+    "batches.create",
+    "batches.list",
+    "batches.retrieve",
+    "beta.assistants.create",
+    "beta.assistants.delete",
+    "beta.assistants.list",
+    "beta.assistants.retrieve",
+    "beta.assistants.update",
+    "beta.chat.completions.create",
+    "beta.chat.completions.delete",
+    "beta.chat.completions.list",
+    "beta.chat.completions.messages.list",
+    "beta.chat.completions.parse",
+    "beta.chat.completions.retrieve",
+    "beta.chat.completions.stream",
+    "beta.chat.completions.update",
+    "beta.chatkit.sessions.cancel",
+    "beta.chatkit.sessions.create",
+    "beta.chatkit.threads.delete",
+    "beta.chatkit.threads.list",
+    "beta.chatkit.threads.list_items",
+    "beta.chatkit.threads.retrieve",
+    "beta.realtime.connect",
+    "beta.realtime.sessions.create",
+    "beta.realtime.transcription_sessions.create",
+    "beta.responses.cancel",
+    "beta.responses.compact",
+    "beta.responses.connect",
+    "beta.responses.create",
+    "beta.responses.delete",
+    "beta.responses.input_items.list",
+    "beta.responses.input_tokens.count",
+    "beta.responses.retrieve",
+    "beta.threads.create",
+    "beta.threads.create_and_run",
+    "beta.threads.create_and_run_poll",
+    "beta.threads.create_and_run_stream",
+    "beta.threads.delete",
+    "beta.threads.messages.create",
+    "beta.threads.messages.delete",
+    "beta.threads.messages.list",
+    "beta.threads.messages.retrieve",
+    "beta.threads.messages.update",
+    "beta.threads.retrieve",
+    "beta.threads.runs.cancel",
+    "beta.threads.runs.create",
+    "beta.threads.runs.create_and_poll",
+    "beta.threads.runs.create_and_stream",
+    "beta.threads.runs.list",
+    "beta.threads.runs.poll",
+    "beta.threads.runs.retrieve",
+    "beta.threads.runs.steps.list",
+    "beta.threads.runs.steps.retrieve",
+    "beta.threads.runs.stream",
+    "beta.threads.runs.submit_tool_outputs",
+    "beta.threads.runs.submit_tool_outputs_and_poll",
+    "beta.threads.runs.submit_tool_outputs_stream",
+    "beta.threads.runs.update",
+    "beta.threads.update",
+    "chat.completions.create",
+    "chat.completions.delete",
+    "chat.completions.list",
+    "chat.completions.messages.list",
+    "chat.completions.parse",
+    "chat.completions.retrieve",
+    "chat.completions.stream",
+    "chat.completions.update",
+    "completions.create",
+    "containers.create",
+    "containers.delete",
+    "containers.files.content.retrieve",
+    "containers.files.create",
+    "containers.files.delete",
+    "containers.files.list",
+    "containers.files.retrieve",
+    "containers.list",
+    "containers.retrieve",
+    "content_provenance_checks.create",
+    "conversations.create",
+    "conversations.delete",
+    "conversations.items.create",
+    "conversations.items.delete",
+    "conversations.items.list",
+    "conversations.items.retrieve",
+    "conversations.retrieve",
+    "conversations.update",
+    "embeddings.create",
+    "evals.create",
+    "evals.delete",
+    "evals.list",
+    "evals.retrieve",
+    "evals.runs.cancel",
+    "evals.runs.create",
+    "evals.runs.delete",
+    "evals.runs.list",
+    "evals.runs.output_items.list",
+    "evals.runs.output_items.retrieve",
+    "evals.runs.retrieve",
+    "evals.update",
+    "files.content",
+    "files.create",
+    "files.delete",
+    "files.list",
+    "files.retrieve",
+    "files.retrieve_content",
+    "files.wait_for_processing",
+    "fine_tuning.alpha.graders.run",
+    "fine_tuning.alpha.graders.validate",
+    "fine_tuning.checkpoints.permissions.create",
+    "fine_tuning.checkpoints.permissions.delete",
+    "fine_tuning.checkpoints.permissions.list",
+    "fine_tuning.checkpoints.permissions.retrieve",
+    "fine_tuning.jobs.cancel",
+    "fine_tuning.jobs.checkpoints.list",
+    "fine_tuning.jobs.create",
+    "fine_tuning.jobs.list",
+    "fine_tuning.jobs.list_events",
+    "fine_tuning.jobs.pause",
+    "fine_tuning.jobs.resume",
+    "fine_tuning.jobs.retrieve",
+    "images.create_variation",
+    "images.edit",
+    "images.generate",
+    "models.delete",
+    "models.list",
+    "models.retrieve",
+    "moderations.create",
+    "realtime.calls.accept",
+    "realtime.calls.create",
+    "realtime.calls.hangup",
+    "realtime.calls.refer",
+    "realtime.calls.reject",
+    "realtime.client_secrets.create",
+    "realtime.connect",
+    "responses.cancel",
+    "responses.compact",
+    "responses.connect",
+    "responses.create",
+    "responses.delete",
+    "responses.input_items.list",
+    "responses.input_tokens.count",
+    "responses.parse",
+    "responses.retrieve",
+    "responses.stream",
+    "skills.content.retrieve",
+    "skills.create",
+    "skills.delete",
+    "skills.list",
+    "skills.retrieve",
+    "skills.update",
+    "skills.versions.content.retrieve",
+    "skills.versions.create",
+    "skills.versions.delete",
+    "skills.versions.list",
+    "skills.versions.retrieve",
+    "uploads.cancel",
+    "uploads.complete",
+    "uploads.create",
+    "uploads.parts.create",
+    "uploads.upload_file_chunked",
+    "vector_stores.create",
+    "vector_stores.delete",
+    "vector_stores.file_batches.cancel",
+    "vector_stores.file_batches.create",
+    "vector_stores.file_batches.create_and_poll",
+    "vector_stores.file_batches.list_files",
+    "vector_stores.file_batches.poll",
+    "vector_stores.file_batches.retrieve",
+    "vector_stores.file_batches.upload_and_poll",
+    "vector_stores.files.content",
+    "vector_stores.files.create",
+    "vector_stores.files.create_and_poll",
+    "vector_stores.files.delete",
+    "vector_stores.files.list",
+    "vector_stores.files.poll",
+    "vector_stores.files.retrieve",
+    "vector_stores.files.update",
+    "vector_stores.files.upload",
+    "vector_stores.files.upload_and_poll",
+    "vector_stores.list",
+    "vector_stores.retrieve",
+    "vector_stores.search",
+    "vector_stores.update",
+    "videos.create",
+    "videos.create_and_poll",
+    "videos.create_character",
+    "videos.delete",
+    "videos.download_content",
+    "videos.edit",
+    "videos.extend",
+    "videos.get_character",
+    "videos.list",
+    "videos.poll",
+    "videos.remix",
+    "videos.retrieve",
+    "webhooks.unwrap",
+    "webhooks.verify_signature"
+  ]
+}

codexloop/infrastructure/api/binder.py

@@ -0,0 +1,170 @@
+"""Bind discovered SDK methods to a nested Typer command tree."""
+
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from codexloop.infrastructure.api.gateway import OpenAIApiGateway, default_gateway
+from codexloop.infrastructure.api.introspect import EndpointSpec, discover_surface, resolve_callable
+from codexloop.infrastructure.api.params import (
+    ScalarParam,
+    scalar_parameters,
+    typer_type_for_annotation,
+)
+from codexloop.infrastructure.api.providers import (
+    PROVIDER_FACTORIES,
+    client_class_for_provider,
+    surface_roots_for_provider,
+)
+from codexloop.infrastructure.api.registry import clear_registry, register_command_path
+
+
+def _scalar_default_src(scalar: ScalarParam) -> str:
+    py_type = typer_type_for_annotation(scalar.annotation).__name__
+    return (
+        f"{scalar.name}: {py_type} | None = typer.Option("
+        f'None, "--{scalar.cli_name}", help="SDK parameter {scalar.name!r}.")'
+    )
+
+
+def _make_typer_command(
+    method: EndpointSpec,
+    gateway: OpenAIApiGateway,
+    *,
+    client_cls: type,
+) -> Any:
+    fn = resolve_callable(method, client_cls=client_cls)
+    signature = inspect.signature(fn)
+    scalars = scalar_parameters(signature)
+    param_names = [s.name for s in scalars]
+
+    def bound_callback(ctx: typer.Context, **kwargs: Any) -> None:
+        root: Any = ctx
+        while root.parent is not None:
+            root = root.parent
+        obj = root.obj if isinstance(root.obj, dict) else {}
+        provider = str(obj.get("provider", "openai"))
+        base_url = obj.get("base_url")
+        json_body = kwargs.pop("json_body", None)
+        json_file = kwargs.pop("json_file", None)
+        raw = bool(kwargs.pop("raw", False))
+        stream = bool(kwargs.pop("stream", False))
+        max_items = kwargs.pop("max_items", None)
+        scalar_values = {name: kwargs.get(name) for name in param_names}
+        try:
+            text = gateway.invoke_and_print(
+                method.path,
+                provider=provider,
+                base_url=base_url if isinstance(base_url, str) else None,
+                json_body=json_body,
+                json_file=json_file,
+                raw=raw,
+                stream=stream,
+                max_items=max_items,
+                scalar_values=scalar_values,
+                method=method,
+            )
+        except (ValueError, TypeError, OSError) as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(2) from exc
+        typer.echo(text)
+
+    # Option-as-default (not Annotated) so Typer works under postponed annotations.
+    args_src = [
+        "ctx: typer.Context",
+        'json_body: str | None = typer.Option(None, "--json", help="Inline JSON object.")',
+        'json_file: Path | None = typer.Option(None, "--json-file", help="JSON file path.")',
+        'raw: bool = typer.Option(False, "--raw", help="Use with_raw_response.")',
+        'stream: bool = typer.Option(False, "--stream", help="Use with_streaming_response.")',
+        'max_items: int | None = typer.Option(None, "--max-items", help="Auto-pagination cap.")',
+    ]
+    args_src.extend(_scalar_default_src(s) for s in scalars)
+    scalar_dict = ", ".join(f"{n!r}: {n}" for n in param_names)
+    body = (
+        f"def command({', '.join(args_src)}) -> None:\n"
+        f"    scalar_values = {{{scalar_dict}}}\n"
+        "    bound_callback(\n"
+        "        ctx,\n"
+        "        json_body=json_body,\n"
+        "        json_file=json_file,\n"
+        "        raw=raw,\n"
+        "        stream=stream,\n"
+        "        max_items=max_items,\n"
+        "        **scalar_values,\n"
+        "    )\n"
+    )
+    ns: dict[str, Any] = {
+        "Path": Path,
+        "typer": typer,
+        "bound_callback": bound_callback,
+    }
+    exec(body, ns)  # nosec B102 — binder-owned source string builds Typer callbacks
+    command_fn = ns["command"]
+    command_fn.__name__ = method.method_name
+    command_fn.__doc__ = f"SDK `{method.path}`."
+    return command_fn
+
+
+def _ensure_group(parent: typer.Typer, name: str, groups: dict[str, typer.Typer]) -> typer.Typer:
+    key = f"{id(parent)}:{name}"
+    existing = groups.get(key)
+    if existing is not None:
+        return existing
+    child = typer.Typer(name=name, help=f"OpenAI `{name}` resource.", no_args_is_help=True)
+    parent.add_typer(child, name=name)
+    groups[key] = child
+    return child
+
+
+def build_api_typer_app(
+    *,
+    gateway: OpenAIApiGateway | None = None,
+    provider: str = "openai",
+) -> typer.Typer:
+    """Build the nested Typer app mounted at ``codexloop api``."""
+    clear_registry()
+    gw = gateway or default_gateway()
+    client_cls = client_class_for_provider(provider)
+    roots = surface_roots_for_provider(provider)
+
+    api = typer.Typer(
+        name="api",
+        help="Generated 1:1 OpenAI SDK REST surface.",
+        no_args_is_help=True,
+    )
+
+    @api.callback()
+    def _api_callback(
+        ctx: typer.Context,
+        provider_opt: str = typer.Option(
+            "openai",
+            "--provider",
+            help="SDK client (azure, custom, openai).",
+        ),
+        base_url: str | None = typer.Option(
+            None,
+            "--base-url",
+            help="Override API base URL (custom / openai).",
+        ),
+    ) -> None:
+        if provider_opt not in PROVIDER_FACTORIES:
+            typer.echo(f"unknown provider {provider_opt!r}", err=True)
+            raise typer.Exit(2)
+        ctx.ensure_object(dict)
+        ctx.obj["provider"] = provider_opt
+        ctx.obj["base_url"] = base_url
+
+    groups: dict[str, typer.Typer] = {}
+    for method in discover_surface(roots=roots, client_cls=client_cls):
+        parts = method.path.split(".")
+        current = api
+        for segment in parts[:-1]:
+            current = _ensure_group(current, segment, groups)
+        current.command(method.method_name)(_make_typer_command(method, gw, client_cls=client_cls))
+        register_command_path(method.path)
+
+    return api

codexloop/infrastructure/api/gateway.py

@@ -0,0 +1,142 @@
+"""Invoke generated ``codexloop api`` commands against the OpenAI SDK."""
+
+from __future__ import annotations
+
+import inspect
+import json
+from pathlib import Path
+from typing import Any
+
+from openai import Omit
+
+from codexloop.infrastructure.api.introspect import (
+    LOCAL_HELPER_PATHS,
+    EndpointSpec,
+    discover_surface,
+    resolve_callable,
+)
+from codexloop.infrastructure.api.json_io import load_json_payload
+from codexloop.infrastructure.api.params import build_call_kwargs
+from codexloop.infrastructure.api.providers import (
+    build_client,
+    client_class_for_provider,
+    surface_roots_for_provider,
+)
+
+
+def _serialize(value: Any) -> Any:
+    if hasattr(value, "model_dump"):
+        return value.model_dump()
+    if hasattr(value, "read"):
+        return {"stream": "<streaming response>"}
+    if isinstance(value, (list, tuple)):
+        return [_serialize(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _serialize(v) for k, v in value.items()}
+    return value
+
+
+def _navigate_resource(client: Any, resource_path: tuple[str, ...]) -> Any:
+    resource: Any = client
+    for segment in resource_path:
+        resource = getattr(resource, segment)
+    return resource
+
+
+def _collect_paginated(
+    first_page: Any,
+    *,
+    max_items: int | None,
+) -> list[Any]:
+    data = getattr(first_page, "data", first_page)
+    items: list[Any] = list(data or []) if not isinstance(data, list) else list(data)
+    page = first_page
+    while getattr(page, "has_more", False):
+        if max_items is not None and len(items) >= max_items:
+            break
+        page = page.get_next_page()
+        items.extend(page.data)
+    if max_items is not None:
+        items = items[:max_items]
+    return items
+
+
+class OpenAIApiGateway:
+    """Concrete adapter for the generated REST surface."""
+
+    def invoke(
+        self,
+        method_path: str,
+        *,
+        provider: str = "openai",
+        base_url: str | None = None,
+        json_body: str | None = None,
+        json_file: Path | None = None,
+        raw: bool = False,
+        stream: bool = False,
+        max_items: int | None = None,
+        scalar_values: dict[str, Any] | None = None,
+        method: EndpointSpec | None = None,
+    ) -> Any:
+        client_cls = client_class_for_provider(provider)
+        if method is None:
+            segments = method_path.split(".")
+            method = EndpointSpec(
+                resource_path=tuple(segments[:-1]),
+                method_name=segments[-1],
+                signature="",
+                is_list=segments[-1] == "list",
+                is_streaming=False,
+            )
+        roots = surface_roots_for_provider(provider)
+        if roots is not None:
+            allowed = {m.path for m in discover_surface(roots=roots, client_cls=client_cls)}
+            if method.path not in allowed:
+                msg = f"method {method.path!r} is not available for provider {provider!r}"
+                raise ValueError(msg)
+
+        client = build_client(provider, base_url=base_url)
+        payload = load_json_payload(inline=json_body, json_file=json_file)
+        fn = resolve_callable(method, client_cls=client_cls)
+        signature = inspect.signature(fn)
+        kwargs = build_call_kwargs(
+            signature,
+            json_payload=payload,
+            scalar_values=scalar_values or {},
+        )
+        cleaned = {k: v for k, v in kwargs.items() if v is not None and not isinstance(v, Omit)}
+
+        resource = _navigate_resource(client, method.resource_path)
+        if raw:
+            resource = resource.with_raw_response
+        elif stream:
+            resource = resource.with_streaming_response
+        bound = getattr(resource, method.method_name)
+        result = bound(**cleaned)
+
+        if not raw and not stream and method.is_list and max_items is not None:
+            return _collect_paginated(result, max_items=max_items)
+        return result
+
+    def invoke_and_print(
+        self,
+        method_path: str,
+        **options: Any,
+    ) -> str:
+        result = self.invoke(method_path, **options)
+        if hasattr(result, "read"):
+            text = result.read()
+            return text.decode() if isinstance(text, bytes) else str(text)
+        return json.dumps(_serialize(result), indent=2, default=str)
+
+
+def default_gateway() -> OpenAIApiGateway:
+    return OpenAIApiGateway()
+
+
+# Re-export for callers that need helper membership checks without importing introspect.
+__all__ = [
+    "LOCAL_HELPER_PATHS",
+    "OpenAIApiGateway",
+    "default_gateway",
+]