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

responses_server/app.py

@@ -1,6 +1,6 @@
-from __future__ import annotations
 
 import argparse
+import asyncio
 from dataclasses import replace
 import json
 import socket
@@ -15,14 +15,20 @@ import uvicorn
 from .config import CompatServerConfig
 from .server import ResponseServer
 from .stream_router import OutcommingChatError, UnsupportedIncommingFeature
+import typing
 
 
-def _format_sse_event(event_name: str, payload: dict[str, object]) -> bytes:
+def _run_uvicorn_server(server) -> 'None':
+    asyncio.set_event_loop(asyncio.new_event_loop())
+    server.run()
+
+
+def _format_sse_event(event_name: 'str', payload: 'typing.Dict[str, object]') -> 'bytes':
     data = json.dumps(payload, ensure_ascii=False)
     return f"event: {event_name}\ndata: {data}\n\n".encode("utf-8")
 
 
-def _stream_events(response_server: ResponseServer, request_body: dict[str, object], request_headers: dict[str, str]) -> Iterator[bytes]:
+def _stream_events(response_server: 'ResponseServer', request_body: 'typing.Dict[str, object]', request_headers: 'typing.Dict[str, str]') -> 'Iterator[bytes]':
     try:
         event_iter = response_server.start_response_stream(request_body, request_headers)
         for event_name, payload in event_iter:
@@ -41,7 +47,7 @@ def _stream_events(response_server: ResponseServer, request_body: dict[str, obje
         )
 
 
-def build_parser() -> argparse.ArgumentParser:
+def build_parser() -> 'argparse.ArgumentParser':
     parser = argparse.ArgumentParser(
         prog="python -m responses_server",
         description=(
@@ -58,7 +64,7 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def run_server(config: CompatServerConfig) -> None:
+def run_server(config: 'CompatServerConfig') -> 'None':
     uvicorn.run(
         ManagedResponseServer.build_app(config),
         host=config.host,
@@ -68,9 +74,9 @@ def run_server(config: CompatServerConfig) -> None:
 
 
 def launch_chat_completion_compat_server(
-    base_url: str,
-    api_key_env: str | None = None,
-    model_provider: str | None = None,
+    base_url: 'str',
+    api_key_env: 'typing.Union[str, None]' = None,
+    model_provider: 'typing.Union[str, None]' = None,
 ):
     config = CompatServerConfig.from_base_url(
         base_url,
@@ -85,10 +91,10 @@ def launch_chat_completion_compat_server(
 class ManagedResponseServer:
     @staticmethod
     def build_app(
-        config: CompatServerConfig,
+        config: 'CompatServerConfig',
         session_store=None,
         stream_router=None,
-    ) -> FastAPI:
+    ) -> 'FastAPI':
         response_server = ResponseServer(
             config,
             session_store=session_store,
@@ -99,7 +105,7 @@ class ManagedResponseServer:
 
         @app.get("/health")
         @app.get("/healthz")
-        async def health() -> dict[str, bool]:
+        async def health() -> 'typing.Dict[str, bool]':
             return {"ok": True}
 
         @app.get("/models")
@@ -115,7 +121,7 @@ class ManagedResponseServer:
 
         @app.post("/responses")
         @app.post("/v1/responses")
-        async def responses(request: Request):
+        async def responses(request: 'Request'):
             try:
                 request_body = await request.json()
             except Exception as exc:
@@ -152,7 +158,7 @@ class ManagedResponseServer:
 
         return app
 
-    def __init__(self, config: CompatServerConfig) -> None:
+    def __init__(self, config: 'CompatServerConfig') -> 'None':
         port = config.port or _reserve_free_port()
         self._config = replace(config, port=port)
         self._app = self.build_app(self._config)
@@ -164,13 +170,17 @@ class ManagedResponseServer:
             access_log=False,
         )
         self._server = uvicorn.Server(self._uvicorn_config)
-        self._thread = threading.Thread(target=self._server.run, daemon=True)
+        self._thread = threading.Thread(
+            target=_run_uvicorn_server,
+            args=(self._server,),
+            daemon=True,
+        )
 
     @property
-    def base_url(self) -> str:
+    def base_url(self) -> 'str':
         return f"http://{self._config.host}:{self._config.port}/v1"
 
-    def start(self, timeout_seconds: float = 10.0) -> None:
+    def start(self, timeout_seconds: 'float' = 10.0) -> 'None':
         self._thread.start()
         deadline = time.time() + timeout_seconds
         while not self._server.started:
@@ -180,7 +190,7 @@ class ManagedResponseServer:
                 )
             time.sleep(0.01)
 
-    def stop(self, timeout_seconds: float = 5.0) -> None:
+    def stop(self, timeout_seconds: 'float' = 5.0) -> 'None':
         self._server.should_exit = True
         self._thread.join(timeout=timeout_seconds)
         if self._thread.is_alive():
@@ -189,7 +199,7 @@ class ManagedResponseServer:
             )
 
 
-def main() -> None:
+def main() -> 'None':
     args = build_parser().parse_args()
     run_server(
         CompatServerConfig(
@@ -207,7 +217,7 @@ if __name__ == "__main__":
     main()
 
 
-def _reserve_free_port() -> int:
+def _reserve_free_port() -> 'int':
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     try:
         sock.bind(("127.0.0.1", 0))

responses_server/config.py

@@ -1,34 +1,34 @@
-from __future__ import annotations
 
 import os
 from dataclasses import dataclass
 import urllib.parse
+import typing
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class CompatServerConfig:
-    host: str = "127.0.0.1"
-    port: int = 0
-    outcomming_base_url: str = "http://127.0.0.1:8000/v1"
-    outcomming_api_key_env: str | None = None
-    model_provider: str | None = None
-    timeout_seconds: float = 120.0
-
-    def outcomming_api_key(self) -> str | None:
+    host: 'str' = "127.0.0.1"
+    port: 'int' = 0
+    outcomming_base_url: 'str' = "http://127.0.0.1:8000/v1"
+    outcomming_api_key_env: 'typing.Union[str, None]' = None
+    model_provider: 'typing.Union[str, None]' = None
+    timeout_seconds: 'float' = 120.0
+
+    def outcomming_api_key(self) -> 'typing.Union[str, None]':
         if self.outcomming_api_key_env is None:
             return None
         value = os.environ.get(self.outcomming_api_key_env, "").strip()
         return value or None
 
-    def outcomming_chat_completions_url(self) -> str:
+    def outcomming_chat_completions_url(self) -> 'str':
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/chat/completions"
 
-    def outcomming_models_url(self) -> str:
+    def outcomming_models_url(self) -> 'str':
         base = self.outcomming_base_url.rstrip("/")
         return f"{base}/models"
 
-    def with_ephemeral_port(self) -> CompatServerConfig:
+    def with_ephemeral_port(self) -> 'CompatServerConfig':
         return CompatServerConfig(
             host=self.host,
             port=0,
@@ -41,10 +41,10 @@ class CompatServerConfig:
     @classmethod
     def from_base_url(
         cls,
-        outcomming_base_url: str,
-        api_key_env: str | None = None,
-        model_provider: str | None = None,
-    ) -> CompatServerConfig:
+        outcomming_base_url: 'str',
+        api_key_env: 'typing.Union[str, None]' = None,
+        model_provider: 'typing.Union[str, None]' = None,
+    ) -> 'CompatServerConfig':
         parsed = urllib.parse.urlparse(outcomming_base_url)
         if not parsed.scheme or not parsed.netloc:
             raise ValueError(f"invalid outcomming base url: {outcomming_base_url}")

responses_server/payload_processors.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 """Provider-specific post-process hooks for canonical outgoing chat requests.
 
@@ -9,11 +8,12 @@ building one canonical `outcomming_request`, while `server.py` selects the
 appropriate hook from `CompatServerConfig.model_provider`.
 """
 
-from collections.abc import Callable
 from copy import deepcopy
-from typing import Optional, TypedDict
+from typing import Callable, Optional
+import typing
+from typing_extensions import TypedDict
 
-ChatMessage = dict[str, object]
+ChatMessage = typing.Dict[str, object]
 
 
 class OutgoingRequest(TypedDict):
@@ -25,24 +25,24 @@ class OutgoingRequest(TypedDict):
     not rely on TypedDict inheritance.
     """
 
-    model: str
-    messages: list[ChatMessage]
-    stream: bool
-    tools: Optional[list[dict[str, object]]]
-    tool_choice: Optional[object]
-    parallel_tool_calls: Optional[bool]
+    model: 'str'
+    messages: 'typing.List[ChatMessage]'
+    stream: 'bool'
+    tools: 'Optional[typing.List[typing.Dict[str, object]]]'
+    tool_choice: 'Optional[object]'
+    parallel_tool_calls: 'Optional[bool]'
 
 
 PayloadPostProcessor = Callable[[OutgoingRequest], OutgoingRequest]
 
 
-def _identity(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+def _identity(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
     """Keep the canonical request unchanged."""
 
     return outcomming_request
 
 
-def _drop_developer_messages(outcomming_request: OutgoingRequest) -> OutgoingRequest:
+def _drop_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
     """Remove all developer-role messages for providers that reject them."""
 
     outcomming_request["messages"] = [
@@ -53,7 +53,7 @@ def _drop_developer_messages(outcomming_request: OutgoingRequest) -> OutgoingReq
     return outcomming_request
 
 
-PAYLOAD_POST_PROCESSORS: dict[str, PayloadPostProcessor] = {
+PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
     "stepfun": _drop_developer_messages,
     "vllm": _identity,
 }
@@ -61,9 +61,9 @@ PAYLOAD_POST_PROCESSORS: dict[str, PayloadPostProcessor] = {
 
 
 def post_process_outcomming_request(
-    outcomming_request: OutgoingRequest,
-    model_provider: str | None,
-) -> OutgoingRequest:
+    outcomming_request: 'OutgoingRequest',
+    model_provider: 'typing.Union[str, None]',
+) -> 'OutgoingRequest':
     """Apply the provider-specific payload hook to one outgoing request.
 
     This is the single wrapper around `PAYLOAD_POST_PROCESSORS`: it normalizes

responses_server/server.py

@@ -1,41 +1,41 @@
-from __future__ import annotations
 
 from .config import CompatServerConfig
 from .payload_processors import post_process_outcomming_request
 from .session_store import SessionStore
 from .stream_router import StreamRouter
+import typing
 
 
 class ResponseServer:
     def __init__(
         self,
-        config: CompatServerConfig,
-        session_store: SessionStore | None = None,
-        stream_router: StreamRouter | None = None,
-    ) -> None:
+        config: 'CompatServerConfig',
+        session_store: 'typing.Union[SessionStore, None]' = None,
+        stream_router: 'typing.Union[StreamRouter, None]' = None,
+    ) -> 'None':
         self._config = config
         self._session_store = session_store or SessionStore()
         self._stream_router = stream_router or StreamRouter(config)
 
     @property
-    def config(self) -> CompatServerConfig:
+    def config(self) -> 'CompatServerConfig':
         return self._config
 
     @property
-    def session_store(self) -> SessionStore:
+    def session_store(self) -> 'SessionStore':
         return self._session_store
 
     @property
-    def stream_router(self) -> StreamRouter:
+    def stream_router(self) -> 'StreamRouter':
         return self._stream_router
 
-    def list_models(self) -> dict[str, object]:
+    def list_models(self) -> 'typing.Dict[str, object]':
         return self._stream_router.list_models()
 
     def start_response_stream(
         self,
-        request_body: dict[str, object],
-        request_headers: dict[str, str],
+        request_body: 'typing.Dict[str, object]',
+        request_headers: 'typing.Dict[str, str]',
     ):
         outcomming_request = self._stream_router.build_outcomming_request(request_body)
         outcomming_request = post_process_outcomming_request(

responses_server/session_store.py

@@ -1,25 +1,25 @@
-from __future__ import annotations
 
 from dataclasses import dataclass
 import threading
 import time
+import typing
 
 
-@dataclass(frozen=True, slots=True)
+@dataclass(frozen=True, )
 class StoredResponse:
-    response_id: str
-    session_id: str | None
-    model: str
-    created_at: float
+    response_id: 'str'
+    session_id: 'typing.Union[str, None]'
+    model: 'str'
+    created_at: 'float'
 
 
 class SessionStore:
-    def __init__(self) -> None:
+    def __init__(self) -> 'None':
         self._lock = threading.Lock()
         self._next_response_number = 1
-        self._responses: dict[str, StoredResponse] = {}
+        self._responses: 'typing.Dict[str, StoredResponse]' = {}
 
-    def create_response(self, session_id: str | None, model: str) -> StoredResponse:
+    def create_response(self, session_id: 'typing.Union[str, None]', model: 'str') -> 'StoredResponse':
         with self._lock:
             response_id = f"resp_{self._next_response_number:08d}"
             self._next_response_number += 1
@@ -32,6 +32,6 @@ class SessionStore:
             self._responses[response_id] = stored
             return stored
 
-    def get_response(self, response_id: str) -> StoredResponse | None:
+    def get_response(self, response_id: 'str') -> 'typing.Union[StoredResponse, None]':
         with self._lock:
             return self._responses.get(response_id)