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

pycodex/tools/update_plan_tool.py

@@ -10,11 +10,10 @@ Expected behavior:
   confirmation text Codex uses.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import PlanItem, PlanStore
 from .base_tool import BaseTool, ToolContext
+import typing
 
 VALID_PLAN_STATUSES = {"pending", "in_progress", "completed"}
 
@@ -52,16 +51,16 @@ class UpdatePlanTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, plan_store: PlanStore) -> None:
+    def __init__(self, plan_store: 'PlanStore') -> 'None':
         self._plan_store = plan_store
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         raw_plan = args.get("plan")
         if not isinstance(raw_plan, list):
             return "Error: `plan` must be a list."
 
-        plan_items: list[PlanItem] = []
+        plan_items: 'typing.List[PlanItem]' = []
         for item in raw_plan:
             if not isinstance(item, dict):
                 return "Error: each `plan` item must be an object."

pycodex/tools/view_image_tool.py

@@ -12,14 +12,13 @@ Expected behavior:
   item that Codex uses when feeding image tool output back to the model.
 """
 
-from __future__ import annotations
-
 import base64
 import mimetypes
 from pathlib import Path
 
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, StructuredToolOutput, ToolContext
+import typing
 
 VIEW_IMAGE_OUTPUT_SCHEMA = {
     "type": "object",
@@ -62,10 +61,10 @@ class ViewImageTool(BaseTool):
     }
     output_schema = VIEW_IMAGE_OUTPUT_SCHEMA
 
-    def __init__(self, cwd: str | Path | None = None) -> None:
+    def __init__(self, cwd: 'typing.Union[typing.Union[str, Path], None]' = None) -> 'None':
         self._workspace_root = Path(cwd or Path.cwd()).resolve()
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         path_value = str(args.get("path", "")).strip()
         if not path_value:
@@ -102,7 +101,7 @@ class ViewImageTool(BaseTool):
             "image_url": image_url,
             "detail": detail,
         }
-        image_item: JSONDict = {
+        image_item: 'JSONDict' = {
             "type": "input_image",
             "image_url": image_url,
         }

pycodex/tools/wait_agent_tool.py

@@ -9,8 +9,6 @@ Expected behavior:
   wait times out.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from ..runtime_services import SubAgentManager
 from .agent_tool_schemas import AGENT_STATUS_SCHEMA
@@ -60,10 +58,10 @@ class WaitAgentTool(BaseTool):
     output_schema = WAIT_AGENT_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, subagent_manager: SubAgentManager) -> None:
+    def __init__(self, subagent_manager: 'SubAgentManager') -> 'None':
         self._subagent_manager = subagent_manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         ids = args.get("ids")
         if not isinstance(ids, list) or not ids:

pycodex/tools/wait_tool.py

@@ -9,11 +9,10 @@ Expected behavior:
 - Return only the new output since the previous `exec` / `wait` snapshot.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 from .code_mode_manager import DEFAULT_WAIT_YIELD_TIME_MS, CodeModeManager
+import typing
 
 
 class WaitTool(BaseTool):
@@ -46,10 +45,10 @@ class WaitTool(BaseTool):
     }
     supports_parallel = False
 
-    def __init__(self, manager: CodeModeManager) -> None:
+    def __init__(self, manager: 'CodeModeManager') -> 'None':
         self._manager = manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         cell_id = str(args.get("cell_id", "")).strip()
         if not cell_id:
@@ -61,7 +60,7 @@ class WaitTool(BaseTool):
             terminate=bool(args.get("terminate", False)),
         )
 
-    def _optional_int(self, args: JSONDict, key: str) -> int | None:
+    def _optional_int(self, args: 'JSONDict', key: 'str') -> 'typing.Union[int, None]':
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/tools/web_search_tool.py

@@ -10,8 +10,6 @@ Expected behavior:
 - Never expect a local tool-call round-trip result from the model.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 
@@ -25,6 +23,6 @@ class WebSearchTool(BaseTool):
     }
     supports_parallel = False
 
-    async def run(self, context: ToolContext, args: JSONValue) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONValue') -> 'JSONValue':
         del context, args
         return "Error: web_search is provider-native and should not be executed locally."

pycodex/tools/write_stdin_tool.py

@@ -10,8 +10,6 @@ Expected behavior:
 - Reuse the same `session_id` until the process exits.
 """
 
-from __future__ import annotations
-
 from ..protocol import JSONDict, JSONValue
 from .base_tool import BaseTool, ToolContext
 from .unified_exec_manager import (
@@ -19,6 +17,7 @@ from .unified_exec_manager import (
     UNIFIED_EXEC_OUTPUT_SCHEMA,
     UnifiedExecManager,
 )
+import typing
 
 
 class WriteStdinTool(BaseTool):
@@ -50,10 +49,10 @@ class WriteStdinTool(BaseTool):
     output_schema = UNIFIED_EXEC_OUTPUT_SCHEMA
     supports_parallel = False
 
-    def __init__(self, manager: UnifiedExecManager) -> None:
+    def __init__(self, manager: 'UnifiedExecManager') -> 'None':
         self._manager = manager
 
-    async def run(self, context: ToolContext, args: JSONDict) -> JSONValue:
+    async def run(self, context: 'ToolContext', args: 'JSONDict') -> 'JSONValue':
         del context
         session_id = args.get("session_id")
         if session_id is None:
@@ -68,7 +67,7 @@ class WriteStdinTool(BaseTool):
             max_output_tokens=self._optional_int(args, "max_output_tokens"),
         )
 
-    def _optional_int(self, args: JSONDict, key: str) -> int | None:
+    def _optional_int(self, args: 'JSONDict', key: 'str') -> 'typing.Union[int, None]':
         value = args.get(key)
         if value in (None, ""):
             return None

pycodex/utils/dotenv.py

@@ -1,14 +1,14 @@
-from __future__ import annotations
 
 import os
 from pathlib import Path
+import typing
 
 ILLEGAL_ENV_VAR_PREFIX = "CODEX_"
 DOTENV_FILENAME = ".env"
-_LOADED_CODEX_DOTENV_HOMES: set[str] = set()
+_LOADED_CODEX_DOTENV_HOMES: 'typing.Set[str]' = set()
 
 
-def load_codex_dotenv(config_path: str | Path) -> None:
+def load_codex_dotenv(config_path: 'typing.Union[str, Path]') -> 'None':
     codex_home = str(Path(config_path).resolve().parent)
     if codex_home in _LOADED_CODEX_DOTENV_HOMES:
         return
@@ -26,8 +26,8 @@ def load_codex_dotenv(config_path: str | Path) -> None:
     _LOADED_CODEX_DOTENV_HOMES.add(codex_home)
 
 
-def parse_dotenv(text: str) -> dict[str, str]:
-    values: dict[str, str] = {}
+def parse_dotenv(text: 'str') -> 'typing.Dict[str, str]':
+    values: 'typing.Dict[str, str]' = {}
     for raw_line in text.splitlines():
         line = raw_line.strip()
         if not line or line.startswith("#"):
@@ -45,7 +45,7 @@ def parse_dotenv(text: str) -> dict[str, str]:
     return values
 
 
-def parse_dotenv_value(raw_value: str) -> str:
+def parse_dotenv_value(raw_value: 'str') -> 'str':
     if not raw_value:
         return ""
 

pycodex/utils/get_env.py

@@ -1,22 +1,22 @@
-from __future__ import annotations
-
-import importlib.metadata
 import os
 import platform
 import re
 from datetime import datetime
 from pathlib import Path
 import subprocess
+import typing
+
+from ..compat import importlib_metadata
 
 
-def get_shell_name() -> str:
+def get_shell_name() -> 'str':
     shell_path = os.environ.get("SHELL")
     if shell_path:
         return Path(shell_path).name or shell_path
     return "bash"
 
 
-def get_timezone_name() -> str:
+def get_timezone_name() -> 'str':
     timezone_env = os.environ.get("TZ")
     if timezone_env:
         return timezone_env
@@ -33,7 +33,7 @@ def get_timezone_name() -> str:
         return "Etc/UTC"
     name = str(timezone)
     return name or "Etc/UTC"
-def get_sandbox_tag(sandbox_mode: str | None) -> str:
+def get_sandbox_tag(sandbox_mode: 'typing.Union[str, None]') -> 'str':
     if sandbox_mode == "danger-full-access":
         return "none"
     if sandbox_mode == "read-only":
@@ -43,7 +43,7 @@ def get_sandbox_tag(sandbox_mode: str | None) -> str:
     return "none"
 
 
-def get_workspace_turn_metadata(cwd: str | Path) -> dict[str, object] | None:
+def get_workspace_turn_metadata(cwd: 'typing.Union[str, Path]') -> 'typing.Union[typing.Dict[str, object], None]':
     resolved_cwd = Path(cwd).resolve()
     repo_root = _git_output(
         resolved_cwd,
@@ -52,7 +52,7 @@ def get_workspace_turn_metadata(cwd: str | Path) -> dict[str, object] | None:
     if repo_root is None:
         return None
 
-    workspace: dict[str, object] = {}
+    workspace: 'typing.Dict[str, object]' = {}
     head = _git_output(resolved_cwd, ["rev-parse", "HEAD"])
     if head is not None:
         workspace["latest_git_commit_hash"] = head
@@ -70,7 +70,7 @@ def get_workspace_turn_metadata(cwd: str | Path) -> dict[str, object] | None:
     return {"workspaces": {repo_root: workspace}}
 
 
-def build_user_agent(originator: str) -> str:
+def build_user_agent(originator: 'str') -> 'str':
     version = get_package_version()
     terminal = get_terminal_user_agent_token()
     os_name, os_version = get_os_info()
@@ -79,14 +79,14 @@ def build_user_agent(originator: str) -> str:
     return f"{originator}/{version} ({os_name} {os_version}; {arch}) {terminal}{suffix}"
 
 
-def get_package_version() -> str:
+def get_package_version() -> 'str':
     detected = _detect_upstream_codex_version()
     if detected is not None:
         return detected
     for distribution_name in ("python-codex", "pycodex"):
         try:
-            return importlib.metadata.version(distribution_name)
-        except importlib.metadata.PackageNotFoundError:
+            return importlib_metadata.version(distribution_name)
+        except importlib_metadata.PackageNotFoundError:
             continue
     local_version = _read_local_package_version()
     if local_version is not None:
@@ -94,10 +94,10 @@ def get_package_version() -> str:
     return "0.1.0"
 
 
-def get_os_info() -> tuple[str, str]:
+def get_os_info() -> 'typing.Tuple[str, str]':
     os_release = Path("/etc/os-release")
     if os_release.is_file():
-        values: dict[str, str] = {}
+        values: 'typing.Dict[str, str]' = {}
         for line in os_release.read_text().splitlines():
             if "=" not in line:
                 continue
@@ -110,7 +110,7 @@ def get_os_info() -> tuple[str, str]:
     return platform.system(), platform.release()
 
 
-def get_terminal_user_agent_token() -> str:
+def get_terminal_user_agent_token() -> 'str':
     term_program = os.environ.get("TERM_PROGRAM", "")
     if term_program.lower() == "tmux":
         client_termname = _tmux_display_message("#{client_termname}")
@@ -123,14 +123,15 @@ def get_terminal_user_agent_token() -> str:
     return "unknown"
 
 
-def _git_output(cwd: Path, args: list[str]) -> str | None:
+def _git_output(cwd: 'Path', args: 'typing.List[str]') -> 'typing.Union[str, None]':
     try:
         completed = subprocess.run(
             ["git", *args],
             cwd=str(cwd),
             check=True,
-            capture_output=True,
-            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
         )
     except (OSError, subprocess.CalledProcessError):
         return None
@@ -138,11 +139,11 @@ def _git_output(cwd: Path, args: list[str]) -> str | None:
     return value or None
 
 
-def _git_remote_urls(cwd: Path) -> dict[str, str]:
+def _git_remote_urls(cwd: 'Path') -> 'typing.Dict[str, str]':
     remote_names = _git_output(cwd, ["remote"])
     if remote_names is None:
         return {}
-    remotes: dict[str, str] = {}
+    remotes: 'typing.Dict[str, str]' = {}
     for name in remote_names.splitlines():
         remote_name = name.strip()
         if not remote_name:
@@ -153,21 +154,22 @@ def _git_remote_urls(cwd: Path) -> dict[str, str]:
     return remotes
 
 
-def _git_has_changes(cwd: Path) -> bool | None:
+def _git_has_changes(cwd: 'Path') -> 'typing.Union[bool, None]':
     try:
         completed = subprocess.run(
             ["git", "status", "--porcelain"],
             cwd=str(cwd),
             check=True,
-            capture_output=True,
-            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
         )
     except (OSError, subprocess.CalledProcessError):
         return None
     return bool(completed.stdout.strip())
 
 
-def _user_agent_suffix(originator: str, version: str) -> str:
+def _user_agent_suffix(originator: 'str', version: 'str') -> 'str':
     if originator == "codex_exec":
         return f" (codex-exec; {version})"
     if originator == "codex-tui":
@@ -175,7 +177,7 @@ def _user_agent_suffix(originator: str, version: str) -> str:
     return ""
 
 
-def _normalize_os_version(version: str) -> str:
+def _normalize_os_version(version: 'str') -> 'str':
     parts = version.split(".")
     if len(parts) == 2 and all(part.isdigit() for part in parts):
         major, minor = parts
@@ -183,7 +185,7 @@ def _normalize_os_version(version: str) -> str:
     return version
 
 
-def _read_local_package_version() -> str | None:
+def _read_local_package_version() -> 'typing.Union[str, None]':
     pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
     if not pyproject_path.is_file():
         return None
@@ -197,13 +199,14 @@ def _read_local_package_version() -> str | None:
     return match.group(1).strip() or None
 
 
-def _tmux_display_message(fmt: str) -> str | None:
+def _tmux_display_message(fmt: 'str') -> 'typing.Union[str, None]':
     try:
         output = subprocess.run(
             ["tmux", "display-message", "-p", fmt],
             check=True,
-            capture_output=True,
-            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
         )
     except (OSError, subprocess.CalledProcessError):
         return None
@@ -211,7 +214,7 @@ def _tmux_display_message(fmt: str) -> str | None:
     return value or None
 
 
-def _sanitize_header_token(value: str) -> str:
+def _sanitize_header_token(value: 'str') -> 'str':
     return "".join(
         character
         if (character.isalnum() or character in {"-", "_", ".", "/"})
@@ -220,13 +223,14 @@ def _sanitize_header_token(value: str) -> str:
     )
 
 
-def _detect_upstream_codex_version() -> str | None:
+def _detect_upstream_codex_version() -> 'typing.Union[str, None]':
     try:
         output = subprocess.run(
             ["codex", "--version"],
             check=True,
-            capture_output=True,
-            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
         )
     except (OSError, subprocess.CalledProcessError):
         return None

pycodex/utils/random_ids.py

@@ -1,11 +1,10 @@
-from __future__ import annotations
 
 import random
 import time
 import uuid
 
 
-def uuid7_string() -> str:
+def uuid7_string() -> 'str':
     timestamp_ms = int(time.time() * 1000) & ((1 << 48) - 1)
     rand_a = random.getrandbits(12)
     rand_b = random.getrandbits(62)