python-codex 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

responses_server/payload_processors.py

@@ -1,4 +1,3 @@
-
 """Provider-specific post-process hooks for canonical outgoing chat requests.
 
 Each downstream chat-completions provider may have its own payload quirks:
@@ -8,9 +7,10 @@ building one canonical `outcomming_request`, while `server.py` selects the
 appropriate hook from `CompatServerConfig.model_provider`.
 """
 
+import typing
 from copy import deepcopy
 from typing import Callable, Optional
-import typing
+
 from typing_extensions import TypedDict
 
 ChatMessage = typing.Dict[str, object]
@@ -25,27 +25,29 @@ class OutgoingRequest(TypedDict):
     not rely on TypedDict inheritance.
     """
 
-    model: 'str'
-    messages: 'typing.List[ChatMessage]'
-    stream: 'bool'
-    chat_template_kwargs: 'Optional[typing.Dict[str, object]]'
-    max_tokens: 'Optional[int]'
-    tools: 'Optional[typing.List[typing.Dict[str, object]]]'
-    tool_choice: 'Optional[object]'
-    parallel_tool_calls: 'Optional[bool]'
-    return_token_ids: 'Optional[bool]'
+    model: "str"
+    messages: "typing.List[ChatMessage]"
+    stream: "bool"
+    chat_template_kwargs: "Optional[typing.Dict[str, object]]"
+    max_tokens: "Optional[int]"
+    tools: "Optional[typing.List[typing.Dict[str, object]]]"
+    tool_choice: "Optional[object]"
+    parallel_tool_calls: "Optional[bool]"
+    return_token_ids: "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"] = [
@@ -55,17 +57,20 @@ def _drop_developer_messages(outcomming_request: 'OutgoingRequest') -> 'Outgoing
     ]
     return outcomming_request
 
-def _replace_developer_messages(outcomming_request: 'OutgoingRequest') -> 'OutgoingRequest':
+
+def _replace_developer_messages(
+    outcomming_request: "OutgoingRequest",
+) -> "OutgoingRequest":
     """Replace all developer-role messages to system-role messages"""
 
-    for message in outcomming_request['messages']:
+    for message in outcomming_request["messages"]:
         if message.get("role") == "developer":
-            message['role'] = "system"
+            message["role"] = "system"
 
     return outcomming_request
 
 
-PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
+PAYLOAD_POST_PROCESSORS: "typing.Dict[str, PayloadPostProcessor]" = {
     "stepfun": _replace_developer_messages,
     "vllm": _identity,
 }
@@ -73,9 +78,9 @@ PAYLOAD_POST_PROCESSORS: 'typing.Dict[str, PayloadPostProcessor]' = {
 
 
 def post_process_outcomming_request(
-    outcomming_request: 'OutgoingRequest',
-    model_provider: 'typing.Union[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,43 +1,43 @@
+import typing
 
 from .config import CompatServerConfig
 from .payload_processors import post_process_outcomming_request
 from .session_store import SessionStore
 from .stream_router import StreamRouter
 from .trajectory_dump import TrajectoryDumpWriter
-import typing
 
 
 class ResponseServer:
     def __init__(
         self,
-        config: 'CompatServerConfig',
-        session_store: 'typing.Union[SessionStore, None]' = None,
-        stream_router: 'typing.Union[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)
         self._trajectory_dump = TrajectoryDumpWriter.from_env()
 
     @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) -> 'typing.Dict[str, object]':
+    def list_models(self) -> "typing.Dict[str, object]":
         return self._stream_router.list_models()
 
     def start_response_stream(
         self,
-        request_body: 'typing.Dict[str, object]',
-        request_headers: 'typing.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)
         if self._trajectory_dump is not None:

responses_server/session_store.py

@@ -1,25 +1,28 @@
-
-from dataclasses import dataclass
 import threading
 import time
 import typing
+from dataclasses import dataclass
 
 
-@dataclass(frozen=True, )
+@dataclass(
+    frozen=True,
+)
 class StoredResponse:
-    response_id: 'str'
-    session_id: 'typing.Union[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: 'typing.Dict[str, StoredResponse]' = {}
+        self._responses: "typing.Dict[str, StoredResponse]" = {}
 
-    def create_response(self, session_id: 'typing.Union[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 +35,6 @@ class SessionStore:
             self._responses[response_id] = stored
             return stored
 
-    def get_response(self, response_id: 'str') -> 'typing.Union[StoredResponse, None]':
+    def get_response(self, response_id: "str") -> "typing.Union[StoredResponse, None]":
         with self._lock:
             return self._responses.get(response_id)