codex-python 1.0.0__cp312-abi3-win_arm64.whl

codex/__init__.py

@@ -0,0 +1,70 @@
+"""Python SDK for embedding Codex via the bundled CLI binary."""
+
+from codex.codex import Codex
+from codex.errors import CodexError, CodexExecError, CodexParseError, ThreadRunError
+from codex.events import (
+    ItemCompletedEvent,
+    ItemStartedEvent,
+    ItemUpdatedEvent,
+    ThreadError,
+    ThreadErrorEvent,
+    ThreadEvent,
+    ThreadStartedEvent,
+    TurnCompletedEvent,
+    TurnFailedEvent,
+    TurnStartedEvent,
+    Usage,
+)
+from codex.items import (
+    AgentMessageItem,
+    CommandExecutionItem,
+    ErrorItem,
+    FileChangeItem,
+    McpToolCallItem,
+    ReasoningItem,
+    ThreadItem,
+    TodoListItem,
+    WebSearchItem,
+)
+from codex.options import ApprovalMode, CodexOptions, SandboxMode, ThreadOptions, TurnOptions
+from codex.thread import Input, RunResult, RunStreamedResult, Thread, UserInput
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Codex",
+    "CodexError",
+    "CodexExecError",
+    "CodexParseError",
+    "ThreadRunError",
+    "Thread",
+    "RunResult",
+    "RunStreamedResult",
+    "Input",
+    "UserInput",
+    "CodexOptions",
+    "ThreadOptions",
+    "TurnOptions",
+    "ApprovalMode",
+    "SandboxMode",
+    "ThreadEvent",
+    "ThreadStartedEvent",
+    "TurnStartedEvent",
+    "TurnCompletedEvent",
+    "TurnFailedEvent",
+    "ItemStartedEvent",
+    "ItemUpdatedEvent",
+    "ItemCompletedEvent",
+    "ThreadError",
+    "ThreadErrorEvent",
+    "Usage",
+    "ThreadItem",
+    "AgentMessageItem",
+    "ReasoningItem",
+    "CommandExecutionItem",
+    "FileChangeItem",
+    "McpToolCallItem",
+    "WebSearchItem",
+    "TodoListItem",
+    "ErrorItem",
+]

codex/_binary.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import platform
+from pathlib import Path
+
+from codex.errors import CodexExecError
+
+
+def resolve_target_triple(system_name: str | None = None, machine_name: str | None = None) -> str:
+    system = (system_name or platform.system()).lower()
+    machine = (machine_name or platform.machine()).lower()
+
+    if system in {"linux", "android"}:
+        if machine in {"x86_64", "amd64"}:
+            return "x86_64-unknown-linux-musl"
+        if machine in {"aarch64", "arm64"}:
+            return "aarch64-unknown-linux-musl"
+    elif system == "darwin":
+        if machine in {"x86_64", "amd64"}:
+            return "x86_64-apple-darwin"
+        if machine in {"aarch64", "arm64"}:
+            return "aarch64-apple-darwin"
+    elif system in {"windows", "win32"}:
+        if machine in {"x86_64", "amd64"}:
+            return "x86_64-pc-windows-msvc"
+        if machine in {"aarch64", "arm64"}:
+            return "aarch64-pc-windows-msvc"
+
+    raise CodexExecError(f"Unsupported platform: {system} ({machine})")
+
+
+def bundled_codex_path(target_triple: str | None = None) -> Path:
+    triple = target_triple or resolve_target_triple()
+    package_root = Path(__file__).resolve().parent
+    binary_name = "codex.exe" if "windows" in triple else "codex"
+    binary_path = package_root / "vendor" / triple / "codex" / binary_name
+    if not binary_path.exists():
+        raise CodexExecError(
+            "Bundled codex binary not found at "
+            f"{binary_path}. Install a platform wheel or provide codex_path_override."
+        )
+    return binary_path

codex/codex.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from codex.exec import CodexExec
+from codex.options import CodexOptions, ThreadOptions
+from codex.thread import Thread
+
+
+class Codex:
+    """Main entrypoint for interacting with Codex threads."""
+
+    def __init__(self, options: CodexOptions | None = None) -> None:
+        resolved = options or CodexOptions()
+        self._exec = CodexExec(resolved.codex_path_override)
+        self._options = resolved
+
+    def start_thread(self, options: ThreadOptions | None = None) -> Thread:
+        return Thread(self._exec, self._options, options or ThreadOptions())
+
+    def resume_thread(self, id: str, options: ThreadOptions | None = None) -> Thread:
+        if id == "":
+            raise ValueError("id must be non-empty")
+        return Thread(self._exec, self._options, options or ThreadOptions(), id)

codex/errors.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+class CodexError(RuntimeError):
+    """Base error for the Python Codex SDK."""
+
+
+class CodexExecError(CodexError):
+    """Raised when the Codex CLI process fails."""
+
+
+class CodexParseError(CodexError):
+    """Raised when streaming JSONL events cannot be parsed."""
+
+
+class ThreadRunError(CodexError):
+    """Raised when a run or stream fails before turn completion."""

codex/events.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+from codex.items import ThreadItem
+
+
+class ThreadStartedEvent(TypedDict):
+    type: Literal["thread.started"]
+    thread_id: str
+
+
+class TurnStartedEvent(TypedDict):
+    type: Literal["turn.started"]
+
+
+class Usage(TypedDict):
+    input_tokens: int
+    cached_input_tokens: int
+    output_tokens: int
+
+
+class TurnCompletedEvent(TypedDict):
+    type: Literal["turn.completed"]
+    usage: Usage
+
+
+class ThreadError(TypedDict):
+    message: str
+
+
+class TurnFailedEvent(TypedDict):
+    type: Literal["turn.failed"]
+    error: ThreadError
+
+
+class ItemStartedEvent(TypedDict):
+    type: Literal["item.started"]
+    item: ThreadItem
+
+
+class ItemUpdatedEvent(TypedDict):
+    type: Literal["item.updated"]
+    item: ThreadItem
+
+
+class ItemCompletedEvent(TypedDict):
+    type: Literal["item.completed"]
+    item: ThreadItem
+
+
+class ThreadErrorEvent(TypedDict):
+    type: Literal["error"]
+    message: str
+
+
+ThreadEvent = (
+    ThreadStartedEvent
+    | TurnStartedEvent
+    | TurnCompletedEvent
+    | TurnFailedEvent
+    | ItemStartedEvent
+    | ItemUpdatedEvent
+    | ItemCompletedEvent
+    | ThreadErrorEvent
+)

codex/exec.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+from codex._binary import bundled_codex_path
+from codex.errors import CodexExecError
+from codex.options import SandboxMode
+
+INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
+PYTHON_SDK_ORIGINATOR = "codex_sdk_py"
+
+
+@dataclass(slots=True, frozen=True)
+class CodexExecArgs:
+    input: str
+    base_url: str | None = None
+    api_key: str | None = None
+    thread_id: str | None = None
+    images: list[str] | None = None
+    model: str | None = None
+    sandbox_mode: SandboxMode | None = None
+    working_directory: str | None = None
+    skip_git_repo_check: bool = False
+    output_schema_file: str | None = None
+
+
+class CodexExec:
+    def __init__(self, executable_path: str | None = None) -> None:
+        if executable_path is not None:
+            path = Path(executable_path)
+        else:
+            try:
+                path = bundled_codex_path()
+            except CodexExecError as bundled_error:
+                system_codex = shutil.which("codex")
+                if system_codex is None:
+                    raise CodexExecError(
+                        f"{bundled_error} Also failed to find `codex` on PATH."
+                    ) from bundled_error
+                path = Path(system_codex)
+        self.executable_path = str(path)
+
+    def run(self, args: CodexExecArgs) -> Iterator[str]:
+        command_args: list[str] = ["exec", "--experimental-json"]
+
+        if args.model is not None:
+            command_args.extend(["--model", args.model])
+        if args.sandbox_mode is not None:
+            command_args.extend(["--sandbox", args.sandbox_mode])
+        if args.working_directory is not None:
+            command_args.extend(["--cd", args.working_directory])
+        if args.skip_git_repo_check:
+            command_args.append("--skip-git-repo-check")
+        if args.output_schema_file is not None:
+            command_args.extend(["--output-schema", args.output_schema_file])
+        if args.images is not None:
+            for image in args.images:
+                command_args.extend(["--image", image])
+        if args.thread_id:
+            command_args.extend(["resume", args.thread_id])
+
+        env = os.environ.copy()
+        if INTERNAL_ORIGINATOR_ENV not in env:
+            env[INTERNAL_ORIGINATOR_ENV] = PYTHON_SDK_ORIGINATOR
+        if args.base_url is not None:
+            env["OPENAI_BASE_URL"] = args.base_url
+        if args.api_key is not None:
+            env["CODEX_API_KEY"] = args.api_key
+
+        try:
+            child = subprocess.Popen(
+                [self.executable_path, *command_args],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+                env=env,
+            )
+        except OSError as exc:
+            raise CodexExecError(
+                f"Failed to spawn codex executable at '{self.executable_path}': {exc}"
+            ) from exc
+
+        if child.stdin is None:
+            child.kill()
+            raise CodexExecError("Child process has no stdin")
+        if child.stdout is None:
+            child.kill()
+            raise CodexExecError("Child process has no stdout")
+        if child.stderr is None:
+            child.kill()
+            raise CodexExecError("Child process has no stderr")
+
+        try:
+            child.stdin.write(args.input)
+            child.stdin.close()
+        except OSError as exc:
+            child.kill()
+            raise CodexExecError(f"Failed to write input to codex process: {exc}") from exc
+
+        try:
+            for line in child.stdout:
+                yield line.rstrip("\r\n")
+        finally:
+            child.stdout.close()
+
+        exit_code = child.wait()
+        stderr = child.stderr.read()
+        child.stderr.close()
+
+        if exit_code != 0:
+            raise CodexExecError(f"Codex exec exited with code {exit_code}: {stderr}")

codex/items.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from typing import Literal, NotRequired, TypedDict
+
+CommandExecutionStatus = Literal["in_progress", "completed", "failed"]
+PatchChangeKind = Literal["add", "delete", "update"]
+PatchApplyStatus = Literal["completed", "failed"]
+McpToolCallStatus = Literal["in_progress", "completed", "failed"]
+
+
+class CommandExecutionItem(TypedDict):
+    id: str
+    type: Literal["command_execution"]
+    command: str
+    aggregated_output: str
+    status: CommandExecutionStatus
+    exit_code: NotRequired[int]
+
+
+class FileUpdateChange(TypedDict):
+    path: str
+    kind: PatchChangeKind
+
+
+class FileChangeItem(TypedDict):
+    id: str
+    type: Literal["file_change"]
+    changes: list[FileUpdateChange]
+    status: PatchApplyStatus
+
+
+class McpToolCallItem(TypedDict):
+    id: str
+    type: Literal["mcp_tool_call"]
+    server: str
+    tool: str
+    status: McpToolCallStatus
+
+
+class AgentMessageItem(TypedDict):
+    id: str
+    type: Literal["agent_message"]
+    text: str
+
+
+class ReasoningItem(TypedDict):
+    id: str
+    type: Literal["reasoning"]
+    text: str
+
+
+class WebSearchItem(TypedDict):
+    id: str
+    type: Literal["web_search"]
+    query: str
+
+
+class ErrorItem(TypedDict):
+    id: str
+    type: Literal["error"]
+    message: str
+
+
+class TodoItem(TypedDict):
+    text: str
+    completed: bool
+
+
+class TodoListItem(TypedDict):
+    id: str
+    type: Literal["todo_list"]
+    items: list[TodoItem]
+
+
+ThreadItem = (
+    AgentMessageItem
+    | ReasoningItem
+    | CommandExecutionItem
+    | FileChangeItem
+    | McpToolCallItem
+    | WebSearchItem
+    | TodoListItem
+    | ErrorItem
+)

codex/options.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+ApprovalMode = Literal["never", "on-request", "on-failure", "untrusted"]
+SandboxMode = Literal["read-only", "workspace-write", "danger-full-access"]
+
+
+@dataclass(slots=True, frozen=True)
+class CodexOptions:
+    codex_path_override: str | None = None
+    base_url: str | None = None
+    api_key: str | None = None
+
+
+@dataclass(slots=True, frozen=True)
+class ThreadOptions:
+    model: str | None = None
+    sandbox_mode: SandboxMode | None = None
+    working_directory: str | None = None
+    skip_git_repo_check: bool = False
+
+
+@dataclass(slots=True, frozen=True)
+class TurnOptions:
+    output_schema: dict[str, object] | None = None

codex/output_schema_file.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True, frozen=True)
+class OutputSchemaFile:
+    schema_path: str | None
+    schema_dir: str | None
+
+    def cleanup(self) -> None:
+        if self.schema_dir is not None:
+            shutil.rmtree(self.schema_dir, ignore_errors=True)
+
+
+def create_output_schema_file(schema: object | None) -> OutputSchemaFile:
+    if schema is None:
+        return OutputSchemaFile(schema_path=None, schema_dir=None)
+
+    if not isinstance(schema, dict):
+        raise ValueError("output_schema must be a plain JSON object")
+
+    schema_dir = Path(tempfile.mkdtemp(prefix="codex-output-schema-"))
+    schema_path = schema_dir / "schema.json"
+    try:
+        schema_path.write_text(json.dumps(schema), encoding="utf-8")
+    except Exception:
+        shutil.rmtree(schema_dir, ignore_errors=True)
+        raise
+    return OutputSchemaFile(schema_path=str(schema_path), schema_dir=str(schema_dir))

codex/py.typed

@@ -0,0 +1 @@
+

codex/thread.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Literal, TypedDict, cast
+
+from codex.errors import CodexParseError, ThreadRunError
+from codex.events import ThreadEvent, Usage
+from codex.exec import CodexExec, CodexExecArgs
+from codex.items import ThreadItem
+from codex.options import CodexOptions, ThreadOptions, TurnOptions
+from codex.output_schema_file import create_output_schema_file
+
+
+class TextInput(TypedDict):
+    type: Literal["text"]
+    text: str
+
+
+class LocalImageInput(TypedDict):
+    type: Literal["local_image"]
+    path: str
+
+
+UserInput = TextInput | LocalImageInput
+Input = str | Sequence[UserInput]
+
+
+@dataclass(slots=True, frozen=True)
+class RunResult:
+    items: list[ThreadItem]
+    final_response: str
+    usage: Usage | None
+
+
+@dataclass(slots=True, frozen=True)
+class RunStreamedResult:
+    events: Iterator[ThreadEvent]
+
+
+class Thread:
+    def __init__(
+        self,
+        exec_runner: CodexExec,
+        options: CodexOptions,
+        thread_options: ThreadOptions,
+        thread_id: str | None = None,
+    ) -> None:
+        self._exec = exec_runner
+        self._options = options
+        self._thread_options = thread_options
+        self._id = thread_id
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+
+    def run_streamed(
+        self, input: Input, turn_options: TurnOptions | None = None
+    ) -> RunStreamedResult:
+        return RunStreamedResult(events=self._run_streamed_internal(input, turn_options))
+
+    def _run_streamed_internal(
+        self, input: Input, turn_options: TurnOptions | None = None
+    ) -> Iterator[ThreadEvent]:
+        effective_turn_options = turn_options or TurnOptions()
+        schema_file = create_output_schema_file(effective_turn_options.output_schema)
+        prompt, images = normalize_input(input)
+        options = self._thread_options
+        exec_args = CodexExecArgs(
+            input=prompt,
+            base_url=self._options.base_url,
+            api_key=self._options.api_key,
+            thread_id=self._id,
+            images=images,
+            model=options.model,
+            sandbox_mode=options.sandbox_mode,
+            working_directory=options.working_directory,
+            skip_git_repo_check=options.skip_git_repo_check,
+            output_schema_file=schema_file.schema_path,
+        )
+        try:
+            for item in self._exec.run(exec_args):
+                parsed = parse_thread_event(item)
+                if parsed["type"] == "thread.started":
+                    self._id = parsed["thread_id"]
+                yield parsed
+        finally:
+            schema_file.cleanup()
+
+    def run(self, input: Input, turn_options: TurnOptions | None = None) -> RunResult:
+        generator = self._run_streamed_internal(input, turn_options)
+        items: list[ThreadItem] = []
+        final_response = ""
+        usage: Usage | None = None
+        turn_failure: str | None = None
+        saw_turn_complete = False
+        for event in generator:
+            event_dict = cast(dict[str, Any], event)
+            event_type = event_dict.get("type")
+            if event_type == "item.completed":
+                item = event_dict.get("item")
+                if isinstance(item, dict):
+                    if item.get("type") == "agent_message":
+                        text = item.get("text")
+                        if isinstance(text, str):
+                            final_response = text
+                    items.append(cast(ThreadItem, item))
+            elif event_type == "turn.completed":
+                usage_value = event_dict.get("usage")
+                if isinstance(usage_value, dict):
+                    usage = cast(Usage, usage_value)
+                    saw_turn_complete = True
+            elif event_type == "turn.failed":
+                error_value = event_dict.get("error")
+                if isinstance(error_value, dict):
+                    message = error_value.get("message")
+                    if isinstance(message, str):
+                        turn_failure = message
+                        break
+            elif event_type == "error":
+                message_value = event_dict.get("message")
+                if isinstance(message_value, str):
+                    turn_failure = message_value
+                    break
+        if turn_failure is not None:
+            raise ThreadRunError(turn_failure)
+        if not saw_turn_complete:
+            raise ThreadRunError(
+                "stream disconnected before completion: missing turn.completed event"
+            )
+        return RunResult(items=items, final_response=final_response, usage=usage)
+
+
+def parse_thread_event(raw_line: str) -> ThreadEvent:
+    try:
+        parsed = json.loads(raw_line)
+    except json.JSONDecodeError as exc:
+        raise CodexParseError(f"Failed to parse item: {raw_line}") from exc
+
+    if not isinstance(parsed, Mapping):
+        raise CodexParseError(f"Expected object event, received {type(parsed).__name__}")
+    event_type = parsed.get("type")
+    if not isinstance(event_type, str):
+        raise CodexParseError("Event is missing string field 'type'")
+    return cast(ThreadEvent, dict(parsed))
+
+
+def normalize_input(input_value: Input) -> tuple[str, list[str]]:
+    if isinstance(input_value, str):
+        return input_value, []
+
+    prompt_parts: list[str] = []
+    images: list[str] = []
+    for item in input_value:
+        item_type = item.get("type")
+        if item_type == "text":
+            text = item.get("text")
+            if not isinstance(text, str):
+                raise ValueError("text input item requires string field 'text'")
+            prompt_parts.append(text)
+        elif item_type == "local_image":
+            path = item.get("path")
+            if not isinstance(path, str):
+                raise ValueError("local_image input item requires string field 'path'")
+            images.append(path)
+        else:
+            raise ValueError(f"Unsupported input item type: {item_type}")
+    return "\n\n".join(prompt_parts), images

codex_native/__init__.py

@@ -0,0 +1,5 @@
+from .codex_native import *
+
+__doc__ = codex_native.__doc__
+if hasattr(codex_native, "__all__"):
+    __all__ = codex_native.__all__

codex_python-1.0.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: codex-python
+Version: 1.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Typing :: Typed
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Summary: Python SDK for Codex CLI with bundled platform binaries
+Keywords: codex,sdk,cli,automation
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/gersmann/codex-python
+Project-URL: Issues, https://github.com/gersmann/codex-python/issues
+Project-URL: Repository, https://github.com/gersmann/codex-python
+
+# codex-python
+
+Python SDK for Codex with bundled `codex` binaries inside platform wheels.
+
+The SDK mirrors the TypeScript SDK behavior:
+- Spawns `codex exec --experimental-json`
+- Streams JSONL events
+- Supports thread resume, structured output schemas, images, sandbox/model options
+
+## Install
+
+```bash
+pip install codex-python
+```
+
+## Quickstart
+
+```python
+from codex import Codex
+
+client = Codex()
+thread = client.start_thread()
+
+result = thread.run("Diagnose the failing tests and propose a fix")
+print(result.final_response)
+print(result.items)
+```
+
+## Streaming
+
+```python
+from codex import Codex
+
+client = Codex()
+thread = client.start_thread()
+
+stream = thread.run_streamed("Investigate this bug")
+for event in stream.events:
+    if event["type"] == "item.completed":
+        print(event["item"])
+    elif event["type"] == "turn.completed":
+        print(event["usage"])
+```
+
+## Structured output
+
+```python
+from codex import Codex, TurnOptions
+
+schema = {
+    "type": "object",
+    "properties": {"summary": {"type": "string"}},
+    "required": ["summary"],
+    "additionalProperties": False,
+}
+
+client = Codex()
+thread = client.start_thread()
+result = thread.run("Summarize repository status", TurnOptions(output_schema=schema))
+print(result.final_response)
+```
+
+## Input with local images
+
+```python
+from codex import Codex
+
+client = Codex()
+thread = client.start_thread()
+result = thread.run(
+    [
+        {"type": "text", "text": "Describe these screenshots"},
+        {"type": "local_image", "path": "./ui.png"},
+        {"type": "local_image", "path": "./diagram.jpg"},
+    ]
+)
+```
+
+## Resume a thread
+
+```python
+from codex import Codex
+
+client = Codex()
+thread = client.resume_thread("thread_123")
+thread.run("Continue from previous context")
+```
+
+## Options
+
+- `CodexOptions`: `codex_path_override`, `base_url`, `api_key`
+- `ThreadOptions`: `model`, `sandbox_mode`, `working_directory`, `skip_git_repo_check`
+- `TurnOptions`: `output_schema`
+
+## Bundled binary behavior
+
+By default, the SDK resolves the bundled binary at:
+
+`codex/vendor/<target-triple>/codex/{codex|codex.exe}`
+
+If the bundled binary is not present (for example in a source checkout), the SDK falls back to
+`codex` on `PATH`.
+
+You can always override with `CodexOptions(codex_path_override=...)`.
+
+## Development
+
+```bash
+make lint
+make test
+```
+
+If you want to test vendored-binary behavior locally, fetch binaries into `codex/vendor`:
+
+```bash
+python scripts/fetch_codex_binary.py --target-triple x86_64-unknown-linux-musl
+```
+

codex_python-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+codex\__init__.py,sha256=rno8Yk5ORFZtbAFKIOWtCOwV6EbWpLs3ZNQcgUzzmtM,1647
+codex\_binary.py,sha256=oCX2rNA_AZH1T7zClwe98uSGRGo4v-jhPoVRsC9qsTA,1633
+codex\codex.py,sha256=UUOaRmo7YbaDqA4muxqqtUuOZ5ITy2NeMQmIGhlQwGg,859
+codex\errors.py,sha256=xY4Yiz69OO0HMVysqSm_GG-yZHTyINB_O3-3314bZIQ,424
+codex\events.py,sha256=2mJ_8TM5VSXNkiPG6-Q7HE09r-fcCD_MonPUdKLp43g,1242
+codex\exec.py,sha256=mCumau0vHQFHJ2E3UmvL8Yq7FNa3ly4ysnF1NreBhIw,4209
+codex\items.py,sha256=bEz_7H2p6eD1DoGdCwh81HCDExUfaXJ-x_mGF6bDNm8,1698
+codex\options.py,sha256=26W-J5ZDx35n2A-PrKWvgSupv9zIQGr2Uj-SyeFiTcM,757
+codex\output_schema_file.py,sha256=EWuUChz7aXtjLGuBQo14BzJogf9bffoXjUYjKMiunyk,1068
+codex\py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+codex\thread.py,sha256=RWItAf9zgc-ag_PWzoIDVT-P7sdARWlHE-qCK-HXLwY,6303
+codex\vendor\.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codex\vendor\aarch64-pc-windows-msvc\codex\codex.exe,sha256=nMLg6_LimKG14gOtEIFi32AEeZ-bPd1P9pMNuHPsli4,68397032
+codex_native\__init__.py,sha256=F6wnaifw2lA804o89FM946g2tbrunIvG3xy1PWR_9DE,131
+codex_native\codex_native.pyd,sha256=ztpeMe0lMDgAdHVpG9fB8KprMDL-AQAG5ichvfJKF4s,166400
+codex_python-1.0.0.dist-info\METADATA,sha256=wCN6WIZAXeFXlEUp9I-LCxoW5kGxnmSj9Y2iEp9Ii-8,3386
+codex_python-1.0.0.dist-info\WHEEL,sha256=FDCxeh2p7wU8Ho3i9fQc9LZ-W3b0At4U5rtXgMygv9s,96
+codex_python-1.0.0.dist-info\licenses\LICENSE,sha256=1jaLCCF7Ws0ixvNF8sUq2FgCo_cvvLL8xIucPAFdhK8,1088
+codex_python-1.0.0.dist-info\RECORD,,

codex_python-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp312-abi3-win_arm64

codex_python-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 gersmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+