python-codex 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

pycodex/model.py

@@ -1,15 +1,15 @@
-from __future__ import annotations
 
 import asyncio
 import json
 import os
 import urllib.parse
-from collections.abc import Callable
 from dataclasses import dataclass, field, replace
 from pathlib import Path
-from typing import Protocol
+from typing import Callable
+from .compat import Protocol
 
 import requests
+import typing
 
 try:
     import tomllib
@@ -29,38 +29,38 @@ from .utils import build_user_agent, uuid7_string
 DEFAULT_CODEX_CONFIG_PATH = Path.home() / ".codex" / "config.toml"
 DEFAULT_ORIGINATOR = "pycodex"
 ModelStreamEventHandler = Callable[[ModelStreamEvent], None]
-NOOP_MODEL_STREAM_EVENT_HANDLER: ModelStreamEventHandler = lambda _event: None
+NOOP_MODEL_STREAM_EVENT_HANDLER: 'ModelStreamEventHandler' = lambda _event: None
 
 
 class ModelClient(Protocol):
     async def complete(
         self,
-        prompt: Prompt,
-        event_handler: ModelStreamEventHandler = NOOP_MODEL_STREAM_EVENT_HANDLER,
-    ) -> ModelResponse:
+        prompt: 'Prompt',
+        event_handler: 'ModelStreamEventHandler' = NOOP_MODEL_STREAM_EVENT_HANDLER,
+    ) -> 'ModelResponse':
         """Return the next batch of model output items for the current prompt."""
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class ResponsesProviderConfig:
-    model: str
-    provider_name: str
-    base_url: str
-    api_key_env: str
-    wire_api: str = "responses"
-    query_params: dict[str, str] = field(default_factory=dict)
-    reasoning_effort: str | None = None
-    reasoning_summary: str | None = None
-    verbosity: str | None = None
-    sandbox_mode: str | None = None
-    beta_features_header: str | None = None
+    model: 'str'
+    provider_name: 'str'
+    base_url: 'str'
+    api_key_env: 'str'
+    wire_api: 'str' = "responses"
+    query_params: 'typing.Dict[str, str]' = field(default_factory=dict)
+    reasoning_effort: 'typing.Union[str, None]' = None
+    reasoning_summary: 'typing.Union[str, None]' = None
+    verbosity: 'typing.Union[str, None]' = None
+    sandbox_mode: 'typing.Union[str, None]' = None
+    beta_features_header: 'typing.Union[str, None]' = None
 
     @classmethod
     def from_codex_config(
         cls,
-        config_path: str | Path = DEFAULT_CODEX_CONFIG_PATH,
-        profile: str | None = None,
-    ) -> ResponsesProviderConfig:
+        config_path: 'typing.Union[str, Path]' = DEFAULT_CODEX_CONFIG_PATH,
+        profile: 'typing.Union[str, None]' = None,
+    ) -> 'ResponsesProviderConfig':
         data = tomllib.loads(Path(config_path).read_text())
         selected = dict(data)
         if profile is not None:
@@ -86,7 +86,7 @@ class ResponsesProviderConfig:
             for key, value in provider.get("query_params", {}).items()
         }
         features = selected.get("features", {})
-        beta_features: list[str] = []
+        beta_features: 'typing.List[str]' = []
         if isinstance(features, dict) and features.get("guardian_approval") is True:
             beta_features.append("guardian_approval")
         return cls(
@@ -103,7 +103,7 @@ class ResponsesProviderConfig:
             beta_features_header=",".join(beta_features) or None,
         )
 
-    def api_key(self) -> str:
+    def api_key(self) -> 'str':
         value = os.environ.get(self.api_key_env, "")
         if not value:
             raise RuntimeError(
@@ -113,9 +113,9 @@ class ResponsesProviderConfig:
 
     def with_overrides(
         self,
-        model: str | None = None,
-        reasoning_effort: str | None = None,
-    ) -> ResponsesProviderConfig:
+        model: 'typing.Union[str, None]' = None,
+        reasoning_effort: 'typing.Union[str, None]' = None,
+    ) -> 'ResponsesProviderConfig':
         return replace(
             self,
             model=self.model if model is None else model,
@@ -141,13 +141,13 @@ class ResponsesModelClient:
 
     def __init__(
         self,
-        config: ResponsesProviderConfig,
-        timeout_seconds: float = 120.0,
-        session_id: str | None = None,
-        originator: str = DEFAULT_ORIGINATOR,
-        user_agent: str | None = None,
-        openai_subagent: str | None = None,
-    ) -> None:
+        config: 'ResponsesProviderConfig',
+        timeout_seconds: 'float' = 120.0,
+        session_id: 'typing.Union[str, None]' = None,
+        originator: 'str' = DEFAULT_ORIGINATOR,
+        user_agent: 'typing.Union[str, None]' = None,
+        openai_subagent: 'typing.Union[str, None]' = None,
+    ) -> 'None':
         self._config = config
         self.model = config.model
         self._timeout_seconds = timeout_seconds
@@ -159,22 +159,22 @@ class ResponsesModelClient:
     @classmethod
     def from_codex_config(
         cls,
-        config_path: str | Path = DEFAULT_CODEX_CONFIG_PATH,
-        profile: str | None = None,
-        timeout_seconds: float = 120.0,
-        originator: str = DEFAULT_ORIGINATOR,
-        user_agent: str | None = None,
-    ) -> ResponsesModelClient:
+        config_path: 'typing.Union[str, Path]' = DEFAULT_CODEX_CONFIG_PATH,
+        profile: 'typing.Union[str, None]' = None,
+        timeout_seconds: 'float' = 120.0,
+        originator: 'str' = DEFAULT_ORIGINATOR,
+        user_agent: 'typing.Union[str, None]' = None,
+    ) -> 'ResponsesModelClient':
         config = ResponsesProviderConfig.from_codex_config(config_path, profile)
         return cls(config, timeout_seconds, originator=originator, user_agent=user_agent)
 
     def with_overrides(
         self,
-        model: str | None = None,
-        reasoning_effort: str | None = None,
-        session_id: str | None = None,
-        openai_subagent: str | None = None,
-    ) -> ResponsesModelClient:
+        model: 'typing.Union[str, None]' = None,
+        reasoning_effort: 'typing.Union[str, None]' = None,
+        session_id: 'typing.Union[str, None]' = None,
+        openai_subagent: 'typing.Union[str, None]' = None,
+    ) -> 'ResponsesModelClient':
         return ResponsesModelClient(
             self._config.with_overrides(
                 model or self.model,
@@ -191,35 +191,35 @@ class ResponsesModelClient:
             ),
         )
 
-    def responses_url(self) -> str:
+    def responses_url(self) -> 'str':
         base_url = self._config.base_url.rstrip("/")
         url = f"{base_url}/responses"
         if self._config.query_params:
             return f"{url}?{urllib.parse.urlencode(self._config.query_params)}"
         return url
 
-    def models_url(self) -> str:
+    def models_url(self) -> 'str':
         base_url = self._config.base_url.rstrip("/")
         url = f"{base_url}/models"
         if self._config.query_params:
             return f"{url}?{urllib.parse.urlencode(self._config.query_params)}"
         return url
 
-    async def list_models(self) -> list[str]:
+    async def list_models(self) -> 'typing.List[str]':
         return await asyncio.to_thread(self._list_models_sync)
 
     async def complete(
         self,
-        prompt: Prompt,
-        event_handler: ModelStreamEventHandler = NOOP_MODEL_STREAM_EVENT_HANDLER,
-    ) -> ModelResponse:
+        prompt: 'Prompt',
+        event_handler: 'ModelStreamEventHandler' = NOOP_MODEL_STREAM_EVENT_HANDLER,
+    ) -> 'ModelResponse':
         return await asyncio.to_thread(self._complete_sync, prompt, event_handler)
 
     def _complete_sync(
         self,
-        prompt: Prompt,
-        event_handler: ModelStreamEventHandler,
-    ) -> ModelResponse:
+        prompt: 'Prompt',
+        event_handler: 'ModelStreamEventHandler',
+    ) -> 'ModelResponse':
         payload = self._build_payload(prompt)
         body = json.dumps(payload).encode("utf-8")
         url = self.responses_url()
@@ -262,8 +262,8 @@ class ResponsesModelClient:
         except requests.RequestException as exc:
             raise ResponsesApiError(f"responses request failed: {exc}") from exc
 
-    def _build_payload(self, prompt: Prompt) -> dict[str, object]:
-        payload: dict[str, object] = {
+    def _build_payload(self, prompt: 'Prompt') -> 'typing.Dict[str, object]':
+        payload: 'typing.Dict[str, object]' = {
             "model": self.model,
             "instructions": prompt.base_instructions or "",
             "input": [item.serialize() for item in prompt.input],
@@ -276,7 +276,7 @@ class ResponsesModelClient:
             "prompt_cache_key": self._session_id,
         }
 
-        reasoning: dict[str, str] = {}
+        reasoning: 'typing.Dict[str, str]' = {}
         if self._config.reasoning_effort is not None:
             reasoning["effort"] = self._config.reasoning_effort
         if self._config.reasoning_summary is not None:
@@ -292,7 +292,7 @@ class ResponsesModelClient:
 
         return payload
 
-    def _list_models_sync(self) -> list[str]:
+    def _list_models_sync(self) -> 'typing.List[str]':
         prepared = requests.PreparedRequest()
         prepared.prepare(
             method="GET",
@@ -330,7 +330,7 @@ class ResponsesModelClient:
         data = payload.get("data")
         if not isinstance(data, list):
             raise ResponsesApiError("models response is missing `data` list")
-        models: list[str] = []
+        models: 'typing.List[str]' = []
         for item in data:
             if not isinstance(item, dict):
                 continue
@@ -339,7 +339,7 @@ class ResponsesModelClient:
                 models.append(model_id)
         return models
 
-    def _build_headers(self, prompt: Prompt) -> dict[str, str]:
+    def _build_headers(self, prompt: 'Prompt') -> 'typing.Dict[str, str]':
         headers = {
             "content-type": "application/json",
             "accept": "text/event-stream",
@@ -360,7 +360,7 @@ class ResponsesModelClient:
             )
         return headers
 
-    def _build_model_list_headers(self) -> dict[str, str]:
+    def _build_model_list_headers(self) -> 'typing.Dict[str, str]':
         headers = {
             "accept": "application/json",
             "authorization": f"Bearer {self._config.api_key()}",
@@ -376,9 +376,9 @@ class ResponsesModelClient:
     def _parse_stream(
         self,
         response,
-        event_handler: ModelStreamEventHandler,
-    ) -> ModelResponse:
-        items: list[AssistantMessage | ToolCall | ReasoningItem] = []
+        event_handler: 'ModelStreamEventHandler',
+    ) -> 'ModelResponse':
+        items: 'typing.List[typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem]]' = []
         saw_completed = False
 
         for event_name, data in self._iter_sse_events(response):
@@ -463,8 +463,8 @@ class ResponsesModelClient:
 
     def _parse_output_item(
         self,
-        item: dict[str, object],
-    ) -> AssistantMessage | ToolCall | ReasoningItem | None:
+        item: 'typing.Dict[str, object]',
+    ) -> 'typing.Union[typing.Union[typing.Union[AssistantMessage, ToolCall], ReasoningItem], None]':
         item_type = item.get("type")
         if item_type == "reasoning":
             return ReasoningItem(payload=dict(item))
@@ -501,8 +501,8 @@ class ResponsesModelClient:
         return None
 
     def _iter_sse_events(self, response):
-        event_name: str | None = None
-        data_lines: list[str] = []
+        event_name: 'typing.Union[str, None]' = None
+        data_lines: 'typing.List[str]' = []
 
         for raw_line in response:
             line = raw_line.decode("utf-8", errors="replace").rstrip("\r\n")
@@ -525,7 +525,7 @@ class ResponsesModelClient:
             yield event_name or "message", "\n".join(data_lines)
 
 
-def _requests_verify_setting() -> str | bool | None:
+def _requests_verify_setting() -> 'typing.Union[typing.Union[str, bool], None]':
     for env_name in ("REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE"):
         value = os.environ.get(env_name, "").strip()
         if value:

pycodex/portable.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 import hashlib
 import json
@@ -6,14 +5,15 @@ import os
 import shutil
 import tempfile
 import zipfile
-from collections.abc import Callable
 from io import BytesIO
 from pathlib import Path, PurePosixPath
+from typing import Callable
 from urllib.parse import quote, urlparse
 
 import requests
 from cryptography.exceptions import InvalidTag
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+import typing
 
 try:
     import tomllib
@@ -47,9 +47,9 @@ ProgressHandler = Callable[[str], None]
 
 
 def upload_codex_home(
-    put_text: str | None = None,
-    event_handler: ProgressHandler | None = None,
-) -> str:
+    put_text: 'typing.Union[str, None]' = None,
+    event_handler: 'typing.Union[ProgressHandler, None]' = None,
+) -> 'str':
     source_dir, server = _parse_put_spec(put_text)
     resolved_source_dir = resolve_put_source_dir(source_dir)
     server_address, base_url = resolve_storage_server(server)
@@ -87,9 +87,9 @@ def upload_codex_home(
 
 
 def bootstrap_called_home(
-    call_text: str,
-    storage_root: str | Path | None = None,
-) -> Path:
+    call_text: 'str',
+    storage_root: 'typing.Union[typing.Union[str, Path], None]' = None,
+) -> 'Path':
     secret, call_id, server_address, base_url = _parse_call_spec(call_text)
     root = resolve_storage_root(storage_root)
     cache_key = hashlib.sha256(call_text.strip().encode("utf-8")).hexdigest()[:16]
@@ -114,7 +114,7 @@ def bootstrap_called_home(
         extracted_home = _resolve_extracted_home(extract_root)
         if home_dir.exists():
             shutil.rmtree(home_dir)
-        shutil.move(str(extracted_home), str(home_dir))
+        shutil.copytree(str(extracted_home), str(home_dir))
     metadata_path.write_text(
         json.dumps(
             {
@@ -128,7 +128,7 @@ def bootstrap_called_home(
     return home_dir / DEFAULT_ENTRY_CONFIG
 
 
-def resolve_put_source_dir(source_dir: str | Path | None) -> Path:
+def resolve_put_source_dir(source_dir: 'typing.Union[typing.Union[str, Path], None]') -> 'Path':
     if source_dir is None or str(source_dir).strip() == "":
         candidate = Path.home() / ".codex"
     else:
@@ -144,7 +144,7 @@ def resolve_put_source_dir(source_dir: str | Path | None) -> Path:
     return resolved
 
 
-def resolve_storage_root(storage_root: str | Path | None = None) -> Path:
+def resolve_storage_root(storage_root: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'Path':
     if storage_root is not None:
         return Path(storage_root).expanduser().resolve()
     env_value = os.environ.get(STORAGE_ROOT_ENV, "").strip()
@@ -153,7 +153,7 @@ def resolve_storage_root(storage_root: str | Path | None = None) -> Path:
     return _discover_project_root() / STORAGE_CACHE_DIRNAME
 
 
-def resolve_storage_server(server: str | None = None) -> tuple[str, str]:
+def resolve_storage_server(server: 'typing.Union[str, None]' = None) -> 'typing.Tuple[str, str]':
     raw_value = (server or os.environ.get(STORAGE_SERVER_ENV) or "").strip()
     if not raw_value:
         raw_value = DEFAULT_STORAGE_SERVER
@@ -167,7 +167,7 @@ def resolve_storage_server(server: str | None = None) -> tuple[str, str]:
     return raw_value, f"http://{raw_value}{STORAGE_API_PREFIX}"
 
 
-def _build_bundle_bytes(root: Path, emit: ProgressHandler) -> bytes:
+def _build_bundle_bytes(root: 'Path', emit: 'ProgressHandler') -> 'bytes':
     files = _collect_upload_files(root)
     emit("[put] mode: whitelist")
     emit(f"[put] packing {len(files)} files")
@@ -179,8 +179,8 @@ def _build_bundle_bytes(root: Path, emit: ProgressHandler) -> bytes:
     return buffer.getvalue()
 
 
-def _collect_upload_files(root: Path) -> list[str]:
-    included: set[str] = set()
+def _collect_upload_files(root: 'Path') -> 'typing.List[str]':
+    included: 'typing.Set[str]' = set()
     for relative_name in ALLOWED_TOP_LEVEL_FILES:
         candidate = root / relative_name
         if candidate.is_file():
@@ -195,12 +195,12 @@ def _collect_upload_files(root: Path) -> list[str]:
     return sorted(included)
 
 
-def _collect_config_referenced_files(root: Path) -> set[str]:
+def _collect_config_referenced_files(root: 'Path') -> 'typing.Set[str]':
     config_path = root / DEFAULT_ENTRY_CONFIG
     if not config_path.is_file():
         return set()
     data = tomllib.loads(config_path.read_text())
-    referenced: set[str] = set()
+    referenced: 'typing.Set[str]' = set()
     candidates = [data]
     profiles = data.get("profiles")
     if isinstance(profiles, dict):
@@ -217,7 +217,7 @@ def _collect_config_referenced_files(root: Path) -> set[str]:
     return referenced
 
 
-def _normalize_optional_relative_file(root: Path, value: str) -> str | None:
+def _normalize_optional_relative_file(root: 'Path', value: 'str') -> 'typing.Union[str, None]':
     candidate = Path(value)
     if candidate.is_absolute():
         return None
@@ -231,13 +231,13 @@ def _normalize_optional_relative_file(root: Path, value: str) -> str | None:
     return resolved.relative_to(root_resolved).as_posix()
 
 
-def _encrypt_bundle(bundle_bytes: bytes, secret: str) -> bytes:
+def _encrypt_bundle(bundle_bytes: 'bytes', secret: 'str') -> 'bytes':
     nonce = os.urandom(NONCE_LENGTH)
     ciphertext = AESGCM(_encryption_key(secret)).encrypt(nonce, bundle_bytes, None)
     return ENCRYPTED_BUNDLE_MAGIC + nonce + ciphertext
 
 
-def _decrypt_bundle(payload: bytes, secret: str) -> bytes:
+def _decrypt_bundle(payload: 'bytes', secret: 'str') -> 'bytes':
     if not payload.startswith(ENCRYPTED_BUNDLE_MAGIC):
         raise RemoteStorageError("stored bundle is not a recognized encrypted payload")
     nonce = payload[len(ENCRYPTED_BUNDLE_MAGIC) : len(ENCRYPTED_BUNDLE_MAGIC) + NONCE_LENGTH]
@@ -248,19 +248,19 @@ def _decrypt_bundle(payload: bytes, secret: str) -> bytes:
         raise RemoteStorageError("call secret is invalid or bundle is corrupted") from exc
 
 
-def _encryption_key(secret: str) -> bytes:
+def _encryption_key(secret: 'str') -> 'bytes':
     return hashlib.sha256(secret.encode("utf-8")).digest()
 
 
-def _call_id_from_payload(payload: bytes) -> str:
+def _call_id_from_payload(payload: 'bytes') -> 'str':
     return _base58_encode(hashlib.sha256(payload).digest()[:8])
 
 
-def _base58_encode(payload: bytes) -> str:
+def _base58_encode(payload: 'bytes') -> 'str':
     number = int.from_bytes(payload, "big")
     if number == 0:
         return TOKEN_BASE58_ALPHABET[0]
-    encoded: list[str] = []
+    encoded: 'typing.List[str]' = []
     while number:
         number, remainder = divmod(number, 58)
         encoded.append(TOKEN_BASE58_ALPHABET[remainder])
@@ -269,7 +269,7 @@ def _base58_encode(payload: bytes) -> str:
     return prefix + "".join(encoded)
 
 
-def _parse_put_spec(put_text: str | None) -> tuple[str | None, str | None]:
+def _parse_put_spec(put_text: 'typing.Union[str, None]') -> 'typing.Tuple[typing.Union[str, None], typing.Union[str, None]]':
     raw_value = (put_text or "").strip()
     if not raw_value:
         return None, None
@@ -288,7 +288,7 @@ def _parse_put_spec(put_text: str | None) -> tuple[str | None, str | None]:
     return raw_value, None
 
 
-def _parse_call_spec(call_text: str) -> tuple[str, str, str, str]:
+def _parse_call_spec(call_text: 'str') -> 'typing.Tuple[str, str, str, str]':
     raw_value = call_text.strip()
     if not raw_value or "@" not in raw_value:
         raise RemoteStorageError("call spec must look like <secret>-<call_id>@<host:port>")
@@ -302,7 +302,7 @@ def _parse_call_spec(call_text: str) -> tuple[str, str, str, str]:
     return secret, call_id, server_address, base_url
 
 
-def _download_encrypted_bundle(base_url: str, call_id: str) -> bytes:
+def _download_encrypted_bundle(base_url: 'str', call_id: 'str') -> 'bytes':
     url = f"{base_url}/call/{quote(call_id, safe='')}"
     try:
         response = requests.get(url, timeout=(5.0, 120.0))
@@ -319,7 +319,7 @@ def _download_encrypted_bundle(base_url: str, call_id: str) -> bytes:
     return payload
 
 
-def _extract_bundle_bytes(bundle_bytes: bytes, destination: Path) -> None:
+def _extract_bundle_bytes(bundle_bytes: 'bytes', destination: 'Path') -> 'None':
     destination.mkdir(parents=True, exist_ok=True)
     destination_resolved = destination.resolve()
     try:
@@ -338,7 +338,7 @@ def _extract_bundle_bytes(bundle_bytes: bytes, destination: Path) -> None:
         archive.extractall(destination)
 
 
-def _resolve_extracted_home(extract_root: Path) -> Path:
+def _resolve_extracted_home(extract_root: 'Path') -> 'Path':
     direct_config = extract_root / DEFAULT_ENTRY_CONFIG
     if direct_config.is_file():
         return extract_root
@@ -348,7 +348,7 @@ def _resolve_extracted_home(extract_root: Path) -> Path:
     raise RemoteStorageError("bundle is missing required config file after extraction")
 
 
-def _load_cached_metadata(metadata_path: Path) -> dict[str, object]:
+def _load_cached_metadata(metadata_path: 'Path') -> 'typing.Dict[str, object]':
     if not metadata_path.is_file():
         return {}
     try:
@@ -358,7 +358,7 @@ def _load_cached_metadata(metadata_path: Path) -> dict[str, object]:
     return payload if isinstance(payload, dict) else {}
 
 
-def _check_storage_server(server_address: str, base_url: str) -> None:
+def _check_storage_server(server_address: 'str', base_url: 'str') -> 'None':
     parsed = urlparse(base_url)
     health_url = f"{parsed.scheme}://{parsed.netloc}{HEALTHCHECK_PATH}"
     try:
@@ -373,7 +373,7 @@ def _check_storage_server(server_address: str, base_url: str) -> None:
         )
 
 
-def _discover_project_root(start: Path | None = None) -> Path:
+def _discover_project_root(start: 'typing.Union[Path, None]' = None) -> 'Path':
     current = (start or Path.cwd()).resolve()
     for candidate in (current, *current.parents):
         if (candidate / "pyproject.toml").is_file() and (candidate / "pycodex").is_dir():
@@ -381,7 +381,7 @@ def _discover_project_root(start: Path | None = None) -> Path:
     return current
 
 
-def _normalize_member_path(value: str, field_name: str) -> str:
+def _normalize_member_path(value: 'str', field_name: 'str') -> 'str':
     path = PurePosixPath(value)
     if not value or path.is_absolute():
         raise RemoteStorageError(f"{field_name} must be relative")