python-codex 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

pycodex/cli.py

@@ -2,47 +2,42 @@
 import atexit
 import argparse
 import asyncio
-import json
 import os
 import shlex
 import sys
 import tempfile
 import traceback
-from dataclasses import asdict, replace
+from dataclasses import replace
 from pathlib import Path
 from typing import Sequence
 
-from .agent import AgentLoop
+from .agent import Agent
 from .collaboration import DEFAULT_COLLABORATION_MODE, CollaborationMode
 from .compat import Literal
 from .context import ContextManager
-from .model import ResponsesModelClient, ResponsesProviderConfig
+from .model import DEFAULT_CODEX_CONFIG_PATH, ResponsesModelClient, ResponsesProviderConfig
 from .portable import bootstrap_called_home, upload_codex_home
-from .protocol import AgentEvent
-from .runtime import AgentRuntime
-from .runtime_services import RuntimeEnvironment, create_runtime_environment
+from .runtime import CliSubmissionQueue
+from .runtime_services import AgentRuntimeEnvironment, create_agent_runtime_environment
 from .utils import CliSessionView, get_debug_dir, load_codex_dotenv, uuid7_string
-from .utils.compactor import compact_agent_loop
+from .interactive_session import (
+    EXTRA_COMMANDS_LINE,
+    format_turn_output,
+    run_interactive_session as _run_interactive_session,
+    prompt_request_permissions,
+    prompt_request_user_input,
+)
 from .utils.session_persist import (
     SessionRolloutRecorder,
-    conversation_history_to_turns,
-    list_resumable_sessions,
-    load_resumed_session,
     resolve_codex_home,
 )
 import typing
 
-EXIT_COMMANDS = {"/exit", "/quit"}
-HISTORY_COMMAND = "/history"
-TITLE_COMMAND = "/title"
-MODEL_COMMAND = "/model"
-QUEUE_COMMAND = "/queue"
-RESUME_COMMAND = "/resume"
-COMPACT_COMMAND = "/compact"
 CliSessionMode = Literal["exec", "tui"]
 LOCAL_RESPONSES_SERVER_API_KEY_ENV = "PYCODEX_LOCAL_RESPONSES_SERVER_KEY"
 CLI_ORIGINATOR = "codex-tui"
 
+
 def launch_chat_completion_compat_server(*args, **kwargs):
     from responses_server import (
         launch_chat_completion_compat_server as launch_compat_server,
@@ -98,7 +93,7 @@ def build_parser() -> 'argparse.ArgumentParser':
     )
     parser.add_argument(
         "--config",
-        default=str(Path.home() / ".codex" / "config.toml"),
+        default=str(DEFAULT_CODEX_CONFIG_PATH),
         help="Path to Codex config.toml.",
     )
     parser.add_argument(
@@ -168,7 +163,7 @@ def resolve_prompt_text(prompt_parts: 'Sequence[str]') -> 'str':
 
 
 def get_tools(
-    runtime_environment: 'typing.Union[RuntimeEnvironment, None]' = None,
+    runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None,
     exec_mode: 'bool' = False,
 ):
     from .tools import (
@@ -197,7 +192,7 @@ def get_tools(
         WriteStdinTool,
     )
 
-    runtime_environment = runtime_environment or create_runtime_environment()
+    runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry()
     code_mode_manager = CodeModeManager(registry)
     unified_exec_manager = UnifiedExecManager()
@@ -263,7 +258,7 @@ def get_tools(
     return registry
 
 
-def get_subagent_tools(runtime_environment: 'typing.Union[RuntimeEnvironment, None]' = None):
+def get_subagent_tools(runtime_environment: 'typing.Union[AgentRuntimeEnvironment, None]' = None):
     from .tools import (
         ApplyPatchTool,
         ExecCommandTool,
@@ -275,7 +270,7 @@ def get_subagent_tools(runtime_environment: 'typing.Union[RuntimeEnvironment, No
         WriteStdinTool,
     )
 
-    runtime_environment = runtime_environment or create_runtime_environment()
+    runtime_environment = runtime_environment or create_agent_runtime_environment()
     registry = Registry()
     unified_exec_manager = UnifiedExecManager()
     registry.register(ExecCommandTool(unified_exec_manager))
@@ -287,21 +282,21 @@ def get_subagent_tools(runtime_environment: 'typing.Union[RuntimeEnvironment, No
     return registry
 
 
-def build_runtime(
-    config_path: 'str',
-    profile: 'typing.Union[str, None]',
-    system_prompt: 'typing.Union[str, None]',
+def build_agent(
     client,
+    config_path: 'typing.Union[str, Path]' = DEFAULT_CODEX_CONFIG_PATH,
+    profile: 'typing.Union[str, None]' = None,
+    system_prompt: 'typing.Union[str, None]' = None,
     session_mode: 'CliSessionMode' = "exec",
     collaboration_mode: 'CollaborationMode' = DEFAULT_COLLABORATION_MODE,
-) -> 'AgentRuntime':
-    use_tui_context = session_mode == "tui"
+) -> 'Agent':
+    config_path = str(config_path)
     context_manager = ContextManager.from_codex_config(
         config_path,
         profile,
         base_instructions_override=system_prompt,
         collaboration_mode=collaboration_mode,
-        include_collaboration_instructions=use_tui_context,
+        include_collaboration_instructions=session_mode == "tui",
     )
     session_id = getattr(client, "_session_id", None) or uuid7_string()
     if hasattr(client, "_session_id"):
@@ -312,7 +307,7 @@ def build_runtime(
         base_instructions_override=system_prompt,
         include_collaboration_instructions=False,
     )
-    runtime_environment = create_runtime_environment()
+    runtime_environment = create_agent_runtime_environment()
     runtime_environment.request_user_input_manager.set_handler(None)
     runtime_environment.request_permissions_manager.set_handler(None)
     rollout_recorder = SessionRolloutRecorder.create(
@@ -324,61 +319,52 @@ def build_runtime(
         context_manager.resolve_base_instructions(),
     )
 
-    def make_subagent_runtime_builder(base_client):
-        def build_subagent_runtime(
+    def make_subagent_queue_builder(base_client):
+        def build_subagent_queue(
             model_override: 'typing.Union[str, None]',
             reasoning_effort_override: 'typing.Union[str, None]',
             initial_history=(),
             session_id: 'typing.Union[str, None]' = None,
-        ) -> 'AgentRuntime':
+        ) -> 'CliSubmissionQueue':
             nested_client = base_client.with_overrides(
                 model_override,
                 reasoning_effort_override,
                 session_id=session_id,
                 openai_subagent="collab_spawn",
             )
-            subagent_runtime_environment = create_runtime_environment()
-            subagent_runtime_environment.request_user_input_manager.set_handler(None)
-            subagent_runtime_environment.request_permissions_manager.set_handler(None)
-            subagent_runtime_environment.subagent_manager.set_runtime_builder(
-                make_subagent_runtime_builder(nested_client)
+            subagent_agent_runtime_environment = create_agent_runtime_environment()
+            subagent_agent_runtime_environment.request_user_input_manager.set_handler(None)
+            subagent_agent_runtime_environment.request_permissions_manager.set_handler(None)
+            subagent_agent_runtime_environment.subagent_manager.set_queue_builder(
+                make_subagent_queue_builder(nested_client)
             )
-            sub_agent = AgentLoop(
+            sub_agent = Agent(
                 nested_client,
-                get_subagent_tools(subagent_runtime_environment),
+                get_subagent_tools(subagent_agent_runtime_environment),
                 subagent_context_manager,
                 initial_history=tuple(initial_history),
+                runtime_environment=subagent_agent_runtime_environment,
             )
-            return AgentRuntime(
-                sub_agent, runtime_environment=subagent_runtime_environment
-            )
+            return CliSubmissionQueue(sub_agent)
 
-        return build_subagent_runtime
+        return build_subagent_queue
 
-    runtime_environment.subagent_manager.set_runtime_builder(
-        make_subagent_runtime_builder(client)
+    runtime_environment.subagent_manager.set_queue_builder(
+        make_subagent_queue_builder(client)
     )
-    return AgentRuntime(
-        AgentLoop(
-            client,
-            get_tools(runtime_environment, exec_mode=True),
-            context_manager,
-            rollout_recorder=rollout_recorder,
-        ),
+    return Agent(
+        client,
+        get_tools(runtime_environment, exec_mode=True),
+        context_manager,
+        rollout_recorder=rollout_recorder,
         runtime_environment=runtime_environment,
     )
 
 
-def format_turn_output(result, json_mode: 'bool') -> 'str':
-    if json_mode:
-        return json.dumps(asdict(result), ensure_ascii=False, indent=2)
-    return result.output_text or ""
-
-
-def _build_model_client(
-    config_path: 'str',
-    profile: 'typing.Union[str, None]',
-    timeout_seconds: 'float',
+def build_model(
+    config_path: 'typing.Union[str, Path]' = DEFAULT_CODEX_CONFIG_PATH,
+    profile: 'typing.Union[str, None]' = None,
+    timeout_seconds: 'float' = 120.0,
     managed_responses_base_url: 'typing.Union[str, None]' = None,
     vllm_endpoint: 'typing.Union[str, None]' = None,
     use_chat_completion: 'typing.Union[bool, None]' = None,
@@ -436,316 +422,25 @@ def _build_model_client(
     )
 
 
-async def prompt_request_user_input(
-    view: 'CliSessionView',
-    payload: 'typing.Dict[str, object]',
-) -> 'typing.Union[typing.Dict[str, object], None]':
-    view.finish_stream()
-    view.pause_spinner()
-    view.write_line("[request_user_input] waiting for user response")
-    answers: 'typing.Dict[str, typing.Dict[str, typing.List[str]]]' = {}
-    try:
-        for question in payload.get("questions", []):
-            if not isinstance(question, dict):
-                continue
-            header = str(question.get("header", "")).strip()
-            question_text = str(question.get("question", "")).strip()
-            question_id = str(question.get("id", "")).strip()
-            if header:
-                view.write_line(f"[{header}] {question_text}")
-            else:
-                view.write_line(question_text)
-
-            options = question.get("options") or []
-            if isinstance(options, list):
-                for index, option in enumerate(options, start=1):
-                    if not isinstance(option, dict):
-                        continue
-                    label = str(option.get("label", "")).strip()
-                    description = str(option.get("description", "")).strip()
-                    view.write_line(f"  {index}. {label} - {description}")
-            view.write_line("  0. Other")
-
-            try:
-                raw_answer = await view.prompt_async("answer> ")
-            except EOFError:
-                return None
-            answer_text = raw_answer.strip()
-            if not answer_text:
-                return None
-
-            selected_answer = answer_text
-            if answer_text.isdigit() and isinstance(options, list):
-                choice = int(answer_text)
-                if 1 <= choice <= len(options):
-                    option = options[choice - 1]
-                    if isinstance(option, dict):
-                        selected_answer = (
-                            str(option.get("label", "")).strip() or answer_text
-                        )
-                elif choice == 0:
-                    try:
-                        raw_answer = await view.prompt_async("other> ")
-                    except EOFError:
-                        return None
-                    selected_answer = raw_answer.strip()
-                    if not selected_answer:
-                        return None
-
-            answers[question_id] = {"answers": [selected_answer]}
-
-        return {"answers": answers}
-    finally:
-        view.resume_spinner()
-
-
-async def prompt_request_permissions(
-    view: 'CliSessionView',
-    payload: 'typing.Dict[str, object]',
-) -> 'typing.Union[typing.Dict[str, object], None]':
-    view.finish_stream()
-    view.pause_spinner()
-    view.write_line("[request_permissions] user approval required")
-    reason = payload.get("reason")
-    if reason:
-        view.write_line(f"Reason: {reason}")
-    view.write_line("Requested permissions:")
-    view.write_line(
-        json.dumps(payload.get("permissions", {}), ensure_ascii=False, indent=2)
-    )
-    view.write_line("Choose: [n] deny / [t] grant for turn / [s] grant for session")
-    try:
-        raw_answer = await view.prompt_async("permissions> ")
-    except EOFError:
-        return None
-    finally:
-        view.resume_spinner()
-
-    answer = raw_answer.strip().lower()
-    if answer in {"t", "turn", "y", "yes"}:
-        return {
-            "permissions": payload.get("permissions", {}),
-            "scope": "turn",
-        }
-    if answer in {"s", "session"}:
-        return {
-            "permissions": payload.get("permissions", {}),
-            "scope": "session",
-        }
-    return {
-        "permissions": {},
-        "scope": "turn",
-    }
+def build_cli_queue(agent: 'Agent') -> 'CliSubmissionQueue':
+    return CliSubmissionQueue(agent)
 
 
 async def run_interactive_session(
-    runtime: 'AgentRuntime',
+    queue: 'CliSubmissionQueue',
     json_mode: 'bool',
     config_path: 'typing.Union[str, None]' = None,
 ) -> 'int':
-    worker = asyncio.create_task(runtime.run_forever())
-    context_window_tokens = runtime._agent_loop._context_manager.resolve_model_context_window()
-    view = CliSessionView()
-    view.set_context_window_tokens(context_window_tokens)
-    model_client = runtime._agent_loop._model_client
-    codex_home = resolve_codex_home(config_path)
-    runtime.set_event_handler(view.handle_event)
-    pending_turn_tasks: 'typing.Set[asyncio.Task[None]]' = set()
-    runtime_environment = runtime.runtime_environment
-    if runtime_environment is None:
-        runtime_environment = create_runtime_environment()
-        runtime.runtime_environment = runtime_environment
-    runtime_environment.request_user_input_manager.set_handler(
-        lambda payload: prompt_request_user_input(view, payload)
-    )
-    runtime_environment.request_permissions_manager.set_handler(
-        lambda payload: prompt_request_permissions(view, payload)
+    return await _run_interactive_session(
+        queue,
+        json_mode,
+        config_path,
+        view_factory=CliSessionView,
     )
-    view.write_line("pycodex interactive mode. Type /exit to quit.")
-    view.write_line("Extra commands: /history, /title, /model, /resume, /compact")
-    try:
-
-        def has_pending_turn_tasks() -> 'bool':
-            pending_turn_tasks.difference_update(
-                task for task in tuple(pending_turn_tasks) if task.done()
-            )
-            return bool(pending_turn_tasks)
-
-        async def run_manual_compact() -> 'None':
-            agent_loop = runtime._agent_loop
-            if not agent_loop.history:
-                view.write_line("Nothing to compact.")
-                return
-
-            compact_turn_id = uuid7_string()
-
-            def handle_compact_stream_event(event) -> 'None':
-                if event.kind not in {"token_count", "stream_error"}:
-                    return
-                view.handle_event(
-                    AgentEvent(
-                        kind=event.kind,
-                        turn_id=compact_turn_id,
-                        payload=dict(event.payload),
-                    )
-                )
-
-            view.write_line("Compacting conversation history...")
-            compact_result = await compact_agent_loop(
-                agent_loop,
-                handle_compact_stream_event,
-                True,
-            )
-            if compact_result is None:
-                view.write_line("Nothing to compact.")
-                return
-            view.load_session_history(
-                getattr(view, "_title", None),
-                conversation_history_to_turns(compact_result.history),
-            )
-            view.write_line(compact_result.display_text())
-
-        async def wait_for_turn_result(future) -> 'None':
-            try:
-                result = await future
-            except Exception as exc:  # pragma: no cover - defensive surface
-                if str(exc) == "submission interrupted":
-                    return
-                view.show_error(str(exc))
-                return
-
-            if json_mode:
-                view.write_line(format_turn_output(result, True))
-
-        while True:
-            try:
-                raw_line = await view.poll_prompt("pycodex> ")
-            except EOFError:
-                break
-            if raw_line is None:
-                await asyncio.sleep(0.05)
-                continue
-
-            prompt_text = raw_line.strip()
-            if not prompt_text:
-                continue
-            if prompt_text in EXIT_COMMANDS:
-                break
-            if prompt_text == HISTORY_COMMAND:
-                view.show_history()
-                continue
-            if prompt_text == TITLE_COMMAND:
-                view.show_title()
-                continue
-            if prompt_text == RESUME_COMMAND:
-                sessions = list_resumable_sessions(codex_home)
-                if not sessions:
-                    view.write_line("No resumable sessions found.")
-                    continue
-                view.write_line("Available sessions:")
-                for index, session in enumerate(sessions, start=1):
-                    view.write_line(f"[{index}] {session['preview']}")
-                continue
-            if prompt_text.startswith(f"{RESUME_COMMAND} "):
-                if has_pending_turn_tasks():
-                    view.write_line(
-                        "Cannot resume while work is running or queued."
-                    )
-                    continue
-                resume_target = prompt_text[len(RESUME_COMMAND) :].strip()
-                try:
-                    resumed = load_resumed_session(codex_home, resume_target)
-                    runtime._agent_loop.replace_history(resumed["history"])
-                    if hasattr(model_client, "_session_id"):
-                        model_client._session_id = str(resumed["session_id"])
-                    runtime._agent_loop.set_rollout_recorder(
-                        SessionRolloutRecorder.resume(resumed["rollout_path"])
-                    )
-                    view.load_session_history(
-                        str(resumed["title"]),
-                        tuple(resumed["turns"]),
-                    )
-                    view.write_line(f"Resumed session: {resumed['title']}")
-                    view.show_history()
-                except Exception as exc:  # pragma: no cover - defensive surface
-                    view.show_error(str(exc))
-                continue
-            if prompt_text == COMPACT_COMMAND:
-                if has_pending_turn_tasks():
-                    view.write_line(
-                        "Cannot compact while work is running or queued."
-                    )
-                    continue
-                try:
-                    await run_manual_compact()
-                except Exception as exc:  # pragma: no cover - defensive surface
-                    view.show_error(str(exc))
-                continue
-            if prompt_text.startswith(f"{QUEUE_COMMAND} "):
-                queued_text = prompt_text[len(QUEUE_COMMAND) :].strip()
-                if not queued_text:
-                    view.write_line("Usage: /queue <message>")
-                    continue
-                try:
-                    submission_id, future = await runtime.enqueue_user_turn(
-                        queued_text, queue="enqueue"
-                    )
-                    view.show_steer_queued(submission_id, queued_text)
-                    turn_task = asyncio.create_task(wait_for_turn_result(future))
-                    pending_turn_tasks.add(turn_task)
-                except Exception as exc:  # pragma: no cover - defensive surface
-                    view.show_error(str(exc))
-                continue
-            if prompt_text == MODEL_COMMAND:
-                view.write_line(
-                    f"Current model: {getattr(model_client, 'model', None) or 'unavailable'}"
-                )
-                models = await model_client.list_models()
-                view.write_line(f"Available models: {', '.join(models)}")
-                continue
-            if prompt_text.startswith(f"{MODEL_COMMAND} "):
-                if has_pending_turn_tasks():
-                    view.write_line(
-                        "Cannot change model while work is running or queued in steer mode."
-                    )
-                    continue
-                model_name = prompt_text[len(MODEL_COMMAND) :].strip()
-                if not model_name:
-                    view.write_line("Usage: /model <model>")
-                    continue
-
-                model_client.model = model_name
-                view.write_line(f"Switched model to {model_name}.")
-                continue
-
-            try:
-                steered = has_pending_turn_tasks()
-                submission_id, future = await runtime.enqueue_user_turn(
-                    prompt_text,
-                    queue="steer",
-                )
-                if steered:
-                    view.schedule_steer_inserted(submission_id, prompt_text)
-                turn_task = asyncio.create_task(wait_for_turn_result(future))
-                pending_turn_tasks.add(turn_task)
-                continue
-            except Exception as exc:  # pragma: no cover - defensive surface
-                view.show_error(str(exc))
-                continue
-    finally:
-        runtime_environment.request_user_input_manager.set_handler(None)
-        runtime_environment.request_permissions_manager.set_handler(None)
-        await runtime.shutdown()
-        await worker
-        if pending_turn_tasks:
-            await asyncio.gather(*pending_turn_tasks, return_exceptions=True)
-        view.close()
-
-    return 0
 
 
 async def run_cli(args: 'argparse.Namespace') -> 'int':
-    runtime = None
+    queued_agent = None
     worker = None
     debug_dir = get_debug_dir()
     phase_handle = None if debug_dir is None else (debug_dir / "phase.log").open("a", encoding="utf-8")
@@ -755,6 +450,7 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
         if args.put is not None and args.prompt:
             raise ValueError("--put does not accept prompt text")
         configure_loguru()
+        config_path = args.config
         if args.put is not None:
             def emit_put_log(message: 'str') -> 'None':
                 print(message, flush=True)
@@ -775,49 +471,50 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
             if phase_handle is not None:
                 phase_handle.write("bootstrap_called_home:done\n")
                 phase_handle.flush()
-            args.config = str(config_path)
             os.environ["CODEX_HOME"] = str(config_path.parent)
         if phase_handle is not None:
-            phase_handle.write("build_model_client:start\n")
+            phase_handle.write("build_model:start\n")
             phase_handle.flush()
-        client = _build_model_client(
-            args.config,
-            args.profile,
-            args.timeout_seconds,
+        model = build_model(
+            config_path=str(config_path),
+            profile=args.profile,
+            timeout_seconds=args.timeout_seconds,
             vllm_endpoint=args.vllm_endpoint,
             use_chat_completion=args.use_chat_completion or None,
             use_messages=args.use_messages,
         )
         if phase_handle is not None:
-            phase_handle.write("build_model_client:done\n")
-            phase_handle.flush()
-
-        if phase_handle is not None:
-            phase_handle.write("build_runtime:start\n")
+            phase_handle.write("build_model:done\n")
+            phase_handle.write("build_agent:start\n")
             phase_handle.flush()
-        runtime = build_runtime(
-            args.config,
-            args.profile,
-            args.system_prompt,
-            client,
+        agent = build_agent(
+            model,
+            config_path=str(config_path),
+            profile=args.profile,
+            system_prompt=args.system_prompt,
             session_mode="tui",
         )
         if phase_handle is not None:
-            phase_handle.write("build_runtime:done\n")
+            phase_handle.write("build_agent:done\n")
+            phase_handle.write("build_cli_queue:start\n")
+            phase_handle.flush()
+        queued_agent = build_cli_queue(agent)
+        if phase_handle is not None:
+            phase_handle.write("build_cli_queue:done\n")
             phase_handle.flush()
         if should_run_interactive(args.prompt, sys.stdin.isatty()):
             return await run_interactive_session(
-                runtime,
+                queued_agent,
                 args.json,
-                args.config,
+                str(config_path),
             )
         else:
             prompt_text = resolve_prompt_text(args.prompt)
-            worker = asyncio.create_task(runtime.run_forever())
+            worker = asyncio.create_task(queued_agent.run_forever())
             if phase_handle is not None:
                 phase_handle.write("submit_user_turn:start\n")
                 phase_handle.flush()
-            result = await runtime.submit_user_turn(prompt_text)
+            result = await queued_agent.submit_user_turn(prompt_text)
             if phase_handle is not None:
                 phase_handle.write("submit_user_turn:done\n")
                 phase_handle.flush()
@@ -836,10 +533,23 @@ async def run_cli(args: 'argparse.Namespace') -> 'int':
     finally:
         if phase_handle is not None:
             phase_handle.close()
-        if runtime is not None and worker is not None:
-            await runtime.shutdown()
+        if queued_agent is not None and worker is not None:
+            await queued_agent.shutdown()
             await worker
 
+def ipython_agent(config_path: 'str' = DEFAULT_CODEX_CONFIG_PATH):
+    from loguru import logger
+    logger.remove()
+    logger.add(sys.stderr, level="INFO")
+
+    model = build_model(config_path)
+    agent = build_agent(client=model, config_path=config_path)
+
+    from pycodex.tools.ipython_tool import attach_ipython_tool
+
+    attach_ipython_tool(agent)
+
+    return agent
 
 def main(argv: 'typing.Union[Sequence[str], None]' = None) -> 'int':
     raw_args = list(argv) if argv is not None else None

pycodex/compat.py

@@ -26,15 +26,19 @@ except ImportError:  # pragma: no cover - Python 3.6 path
         TypeAlias = object
 
 
+def _get_running_loop_compat():
+    loop = asyncio.get_event_loop()
+    if not loop.is_running():
+        raise RuntimeError("no running event loop")
+    return loop
+
+
 def patch_asyncio():
     if not hasattr(asyncio, "create_task"):
         asyncio.create_task = asyncio.ensure_future
 
     if not hasattr(asyncio, "get_running_loop"):
-        def get_running_loop():
-            return asyncio.get_event_loop()
-
-        asyncio.get_running_loop = get_running_loop
+        asyncio.get_running_loop = _get_running_loop_compat
 
     if not hasattr(asyncio, "to_thread"):
         async def to_thread(func, *args, **kwargs):