mycode-cli 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

mycode_cli/__init__.py

@@ -0,0 +1 @@
+"""mycode-cli — interactive CLI and FastAPI server for the mycode agent."""

{mycode/core → mycode_cli}/config.py

@@ -13,12 +13,12 @@ import json
 import logging
 import os
 import re
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from mycode.core.models import ModelMetadata, lookup_model_metadata
-from mycode.core.providers import (
+from mycode.models import resolve_model_metadata
+from mycode.providers import (
     get_provider_adapter,
     is_supported_provider,
     list_env_discoverable_providers,
@@ -27,11 +27,15 @@ from mycode.core.providers import (
     provider_default_models,
     provider_env_api_key_names,
 )
-from mycode.core.utils import as_bool, as_int
+from mycode.session import resolve_mycode_home
+from mycode.utils import as_bool, as_int
 
-_DEFAULT_MYCODE_HOME = "~/.mycode"
 _API_KEY_ENV_REF_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
-_VALID_REASONING_EFFORTS = ("none", "low", "medium", "high", "xhigh")
+# Full set of user-facing choices. "auto" means "do not send an explicit effort
+# to the provider" and is represented internally as `None` after normalization.
+REASONING_EFFORT_OPTIONS = ("auto", "none", "low", "medium", "high", "xhigh")
+_EFFORT_AUTO_ALIASES = frozenset({"", "auto", "default"})
+_EFFORT_OFF_ALIASES = frozenset({"off", "disabled"})
 
 
 @dataclass(frozen=True)
@@ -76,30 +80,8 @@ class ResolvedProvider:
     api_key: str | None
     api_base: str | None
     reasoning_effort: str | None
-    max_tokens: int = 16_384
-    context_window: int | None = 128_000
-    supports_reasoning: bool | None = None
-    supports_image_input: bool | None = None
-    supports_pdf_input: bool | None = None
     provider_name: str | None = None
 
-    @property
-    def provider_type(self) -> str:
-        return self.provider
-
-
-def resolve_mycode_home() -> Path:
-    """Resolve the mycode home directory."""
-
-    raw = os.environ.get("MYCODE_HOME", _DEFAULT_MYCODE_HOME)
-    return Path(raw).expanduser().resolve(strict=False)
-
-
-def resolve_sessions_dir() -> Path:
-    """Resolve the default directory used for persisted sessions."""
-
-    return resolve_mycode_home() / "sessions"
-
 
 def find_workspace_root(cwd: str) -> Path:
     """Resolve the project/workspace root for the current cwd."""
@@ -183,15 +165,28 @@ def _parse_compact_threshold(value: Any) -> float | None:
 
 
 def normalize_reasoning_effort(value: Any) -> str | None:
-    if not isinstance(value, str):
+    """Normalize a reasoning effort setting.
+
+    Returns `None` for "auto"/"default"/empty — the sentinel for "do not send an
+    explicit effort to the provider". Returns "none" for "off"/"disabled" and
+    a canonical tier string for recognized levels. Raises `ValueError` for any
+    other string (or non-string, non-None value).
+    """
+
+    if value is None:
         return None
+    if not isinstance(value, str):
+        raise ValueError(f"reasoning_effort must be a string, got {type(value).__name__}")
 
     effort = value.strip().lower()
-    if effort in {"", "auto", "default"}:
+    if effort in _EFFORT_AUTO_ALIASES:
         return None
-    if effort in {"off", "disabled"}:
+    if effort in _EFFORT_OFF_ALIASES:
         return "none"
-    return effort
+    if effort in REASONING_EFFORT_OPTIONS:
+        return effort
+    supported = ", ".join(REASONING_EFFORT_OPTIONS)
+    raise ValueError(f"unsupported reasoning_effort {value!r}; supported: {supported}")
 
 
 def _config_api_key_from_env_var(provider: ProviderConfig, *, require: bool = False) -> str | None:
@@ -453,43 +448,6 @@ def _resolve_provider_runtime(
         resolved_model = defaults[0]
 
     resolved_api_base = api_base or (provider_config.base_url if provider_config else None)
-    model_metadata = lookup_model_metadata(
-        provider_type=provider_type,
-        model=resolved_model,
-    )
-    if provider_config:
-        model_config = provider_config.models.get(resolved_model)
-        if model_config:
-            if model_metadata is None:
-                model_metadata = ModelMetadata(
-                    provider=provider_type,
-                    model=resolved_model,
-                    context_window=model_config.context_window,
-                    max_output_tokens=model_config.max_output_tokens,
-                    supports_reasoning=model_config.supports_reasoning,
-                    supports_image_input=model_config.supports_image_input,
-                    supports_pdf_input=model_config.supports_pdf_input,
-                )
-            else:
-                # Per-field: use the config override when set, keep catalog value otherwise.
-                model_metadata = replace(
-                    model_metadata,
-                    context_window=model_config.context_window
-                    if model_config.context_window is not None
-                    else model_metadata.context_window,
-                    max_output_tokens=model_config.max_output_tokens
-                    if model_config.max_output_tokens is not None
-                    else model_metadata.max_output_tokens,
-                    supports_reasoning=model_config.supports_reasoning
-                    if model_config.supports_reasoning is not None
-                    else model_metadata.supports_reasoning,
-                    supports_image_input=model_config.supports_image_input
-                    if model_config.supports_image_input is not None
-                    else model_metadata.supports_image_input,
-                    supports_pdf_input=model_config.supports_pdf_input
-                    if model_config.supports_pdf_input is not None
-                    else model_metadata.supports_pdf_input,
-                )
 
     configured_effort = (
         provider_config.reasoning_effort
@@ -497,22 +455,18 @@ def _resolve_provider_runtime(
         else settings.default_reasoning_effort
     )
 
-    if configured_effort is not None and configured_effort not in _VALID_REASONING_EFFORTS:
-        supported = ", ".join(_VALID_REASONING_EFFORTS)
-        raise ValueError(f"unsupported reasoning_effort {configured_effort!r}; supported: {supported}")
-
-    supports_reasoning = model_metadata.supports_reasoning if model_metadata else None
-    supports_image_input = model_metadata.supports_image_input if model_metadata else None
-    supports_pdf_input = model_metadata.supports_pdf_input if model_metadata else None
+    # Drop reasoning_effort when the model does not support reasoning. Config
+    # overrides win over catalog metadata.
+    model_config = provider_config.models.get(resolved_model) if provider_config else None
+    meta = resolve_model_metadata(
+        provider=provider_type,
+        model=resolved_model,
+        supports_reasoning=model_config.supports_reasoning if model_config else None,
+    )
     adapter = get_provider_adapter(provider_type)
     reasoning_effort = (
         configured_effort
-        if (
-            configured_effort is not None
-            and model_metadata is not None
-            and supports_reasoning is True
-            and adapter.supports_reasoning_effort
-        )
+        if configured_effort is not None and meta.supports_reasoning is True and adapter.supports_reasoning_effort
         else None
     )
 
@@ -536,11 +490,6 @@ def _resolve_provider_runtime(
         api_key=resolved_api_key,
         api_base=resolved_api_base,
         reasoning_effort=reasoning_effort,
-        max_tokens=(model_metadata.max_output_tokens if model_metadata else None) or 16_384,
-        context_window=(model_metadata.context_window if model_metadata else None) or 128_000,
-        supports_reasoning=supports_reasoning,
-        supports_image_input=supports_image_input,
-        supports_pdf_input=supports_pdf_input,
     )
 
 

{mycode/cli → mycode_cli}/main.py

@@ -5,43 +5,37 @@ from __future__ import annotations
 import asyncio
 import os
 import sys
+from dataclasses import dataclass
 from typing import Annotated
 
 import typer
 
-from mycode.core.agent import Agent
-from mycode.core.config import get_settings, resolve_provider
-from mycode.core.messages import ConversationMessage
-from mycode.core.session import SessionStore
+from mycode.agent import Agent
+from mycode.messages import ConversationMessage
+from mycode.session import SessionStore
+from mycode_cli.config import ResolvedProvider, Settings, get_settings, resolve_provider
 
-from .chat import TerminalChat
-from .render import TerminalView
-from .runtime import append_session_message, build_agent, resolve_session
+from .runtime import ResolvedSession, build_agent, resolve_session
+from .tui.chat import TerminalChat
+from .tui.render import TerminalView
 
 app = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
 session_app = typer.Typer(help="Session management")
 app.add_typer(session_app, name="session")
 
 
-async def run_noninteractive(
-    agent: Agent,
-    *,
-    store: SessionStore,
-    session_id: str,
-    message: str,
-) -> int:
+async def run_noninteractive(agent: Agent, message: str) -> int:
     """Run one message non-interactively and print only the final assistant reply."""
 
     latest_assistant: ConversationMessage | None = None
 
-    async def persist(payload: ConversationMessage) -> None:
+    async def track(payload: ConversationMessage) -> None:
         nonlocal latest_assistant
         if payload.get("role") == "assistant":
             latest_assistant = payload
-        await append_session_message(store, session_id, payload, agent=agent)
 
     error_message = ""
-    async for event in agent.achat(message, on_persist=persist):
+    async for event in agent.achat(message, on_persist=track):
         if event.type == "error":
             error_message = str(event.data.get("message") or "agent error")
 
@@ -64,31 +58,28 @@ async def run_noninteractive(
     return 0
 
 
-def _validate_session_options(session: str | None, continue_last: bool) -> None:
-    """Reject conflicting --session and --continue options."""
-
-    if session and continue_last:
-        raise typer.BadParameter("--session and --continue are mutually exclusive")
-
+@dataclass
+class _BootstrapContext:
+    store: SessionStore
+    view: TerminalView
+    settings: Settings
+    resolved_provider: ResolvedProvider
+    resolved_session: ResolvedSession
+    agent: Agent
 
-# -- Commands ----------------------------------------------------------------
 
+def _bootstrap(
+    *,
+    provider: str | None,
+    model: str | None,
+    session: str | None,
+    continue_last: bool,
+    max_turns: int | None,
+) -> _BootstrapContext:
+    """Shared setup for the chat and run commands."""
 
-@app.callback(invoke_without_command=True)
-def chat(
-    ctx: typer.Context,
-    provider: Annotated[str | None, typer.Option(help="Provider id or configured alias")] = None,
-    model: Annotated[str | None, typer.Option(help="Model name (overrides default)")] = None,
-    max_turns: Annotated[int | None, typer.Option(min=1, help="Limit agent loop turns")] = None,
-    session: Annotated[str | None, typer.Option(help="Resume a specific session id")] = None,
-    continue_last: Annotated[bool, typer.Option("--continue", "-c", help="Resume the most recent session")] = False,
-) -> None:
-    """Interactive coding agent."""
-
-    if ctx.invoked_subcommand is not None:
-        return
-
-    _validate_session_options(session, continue_last)
+    if session and continue_last:
+        raise typer.BadParameter("--session and --continue are mutually exclusive")
 
     cwd = os.path.abspath(os.getcwd())
     store = SessionStore()
@@ -117,28 +108,65 @@ def chat(
         cwd=cwd,
         settings=settings,
         resolved_provider=resolved_provider,
+        session_id=resolved_session.session_id,
+        messages=resolved_session.messages,
+        max_turns=max_turns,
+    )
+
+    return _BootstrapContext(
+        store=store,
+        view=view,
+        settings=settings,
+        resolved_provider=resolved_provider,
         resolved_session=resolved_session,
+        agent=agent,
+    )
+
+
+# -- Commands ----------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def chat(
+    ctx: typer.Context,
+    provider: Annotated[str | None, typer.Option(help="Provider id or configured alias")] = None,
+    model: Annotated[str | None, typer.Option(help="Model name (overrides default)")] = None,
+    max_turns: Annotated[int | None, typer.Option(min=1, help="Limit agent loop turns")] = None,
+    session: Annotated[str | None, typer.Option(help="Resume a specific session id")] = None,
+    continue_last: Annotated[bool, typer.Option("--continue", "-c", help="Resume the most recent session")] = False,
+) -> None:
+    """Interactive coding agent."""
+
+    if ctx.invoked_subcommand is not None:
+        return
+
+    setup = _bootstrap(
+        provider=provider,
+        model=model,
+        session=session,
+        continue_last=continue_last,
         max_turns=max_turns,
     )
 
-    view.print_header(
-        provider=resolved_provider.provider,
-        model=resolved_provider.model,
-        session=resolved_session.session,
-        mode=resolved_session.mode,
-        message_count=len(resolved_session.messages),
-        reasoning_effort=resolved_provider.reasoning_effort,
+    setup.view.print_header(
+        provider=setup.resolved_provider.provider,
+        model=setup.resolved_provider.model,
+        session=setup.resolved_session.session,
+        mode=setup.resolved_session.mode,
+        message_count=len(setup.resolved_session.messages),
+        reasoning_effort=setup.resolved_provider.reasoning_effort,
     )
-    if resolved_session.mode == "resumed":
-        view.print_history_preview(resolved_session.messages)
+    if setup.resolved_session.mode == "resumed":
+        setup.view.print_history_preview(setup.resolved_session.messages)
 
     try:
         asyncio.run(
             TerminalChat(
-                agent=agent,
-                store=store,
-                session_id=resolved_session.session_id,
-                view=view,
+                agent=setup.agent,
+                settings=setup.settings,
+                store=setup.store,
+                session_id=setup.resolved_session.session_id,
+                view=setup.view,
             ).run()
         )
     except KeyboardInterrupt:
@@ -156,47 +184,15 @@ def run(
 ) -> None:
     """Send one message and exit."""
 
-    _validate_session_options(session, continue_last)
-
-    cwd = os.path.abspath(os.getcwd())
-    store = SessionStore()
-    view = TerminalView()
-    settings = get_settings(cwd)
-
-    try:
-        resolved_provider = resolve_provider(settings, provider_name=provider, model=model)
-        resolved_session = asyncio.run(
-            resolve_session(
-                store=store,
-                provider=resolved_provider.provider,
-                cwd=cwd,
-                model=resolved_provider.model,
-                api_base=resolved_provider.api_base,
-                requested_session_id=session,
-                continue_last=continue_last,
-            )
-        )
-    except ValueError as exc:
-        view.console.print(f"[red]{exc}[/red]")
-        raise SystemExit(1) from exc
-
-    agent = build_agent(
-        store=store,
-        cwd=cwd,
-        settings=settings,
-        resolved_provider=resolved_provider,
-        resolved_session=resolved_session,
+    setup = _bootstrap(
+        provider=provider,
+        model=model,
+        session=session,
+        continue_last=continue_last,
         max_turns=max_turns,
     )
 
-    code = asyncio.run(
-        run_noninteractive(
-            agent,
-            store=store,
-            session_id=resolved_session.session_id,
-            message=" ".join(message).strip(),
-        )
-    )
+    code = asyncio.run(run_noninteractive(setup.agent, " ".join(message).strip()))
     raise SystemExit(code)
 
 
@@ -214,7 +210,7 @@ def web(
 
     import uvicorn
 
-    from mycode.server.app import create_app
+    from mycode_cli.server.app import create_app
 
     uvicorn.run(create_app(serve_web=not dev), host=hostname, port=resolved_port)
 

{mycode/cli → mycode_cli}/runtime.py

@@ -5,17 +5,17 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
-from mycode.core.agent import Agent
-from mycode.core.config import ResolvedProvider, Settings, get_settings, provider_has_api_key, resolve_provider
-from mycode.core.providers import (
+from mycode.agent import Agent
+from mycode.providers import (
     get_provider_adapter,
     list_env_discoverable_providers,
     provider_api_key_from_env,
     provider_default_models,
 )
-from mycode.core.session import SessionStore
-
-REASONING_EFFORT_OPTIONS = ("auto", "none", "low", "medium", "high", "xhigh")
+from mycode.session import SessionStore
+from mycode.tools import DEFAULT_TOOL_SPECS
+from mycode_cli.config import ModelConfig, ResolvedProvider, Settings, provider_has_api_key
+from mycode_cli.system_prompt import build_system_prompt
 
 
 @dataclass
@@ -47,31 +47,45 @@ def build_agent(
     cwd: str,
     settings: Settings,
     resolved_provider: ResolvedProvider,
-    resolved_session: ResolvedSession,
-    max_turns: int | None,
+    session_id: str,
+    messages: list[dict[str, Any]] | None = None,
+    max_turns: int | None = None,
+    reasoning_effort: str | None = None,
 ) -> Agent:
-    """Build the CLI agent from the resolved provider and session."""
+    """Build an agent from the resolved provider, honoring model config overrides."""
 
+    model_config = _model_config_for(settings, resolved_provider)
     return Agent(
         model=resolved_provider.model,
         provider=resolved_provider.provider,
         cwd=cwd,
-        session_dir=store.session_dir(resolved_session.session_id),
-        session_id=resolved_session.session_id,
+        session_dir=store.session_dir(session_id),
+        session_id=session_id,
         api_key=resolved_provider.api_key,
         api_base=resolved_provider.api_base,
-        messages=resolved_session.messages,
-        settings=settings,
-        reasoning_effort=resolved_provider.reasoning_effort,
-        supports_image_input=resolved_provider.supports_image_input,
-        supports_pdf_input=resolved_provider.supports_pdf_input,
-        max_tokens=resolved_provider.max_tokens,
-        context_window=resolved_provider.context_window,
+        messages=messages,
+        reasoning_effort=reasoning_effort if reasoning_effort is not None else resolved_provider.reasoning_effort,
+        max_tokens=model_config.max_output_tokens if model_config else None,
+        context_window=model_config.context_window if model_config else None,
+        supports_reasoning=model_config.supports_reasoning if model_config else None,
+        supports_image_input=model_config.supports_image_input if model_config else None,
+        supports_pdf_input=model_config.supports_pdf_input if model_config else None,
         compact_threshold=settings.compact_threshold,
         max_turns=max_turns,
+        system=build_system_prompt(cwd, settings),
+        tools=DEFAULT_TOOL_SPECS,
     )
 
 
+def _model_config_for(settings: Settings, resolved: ResolvedProvider) -> ModelConfig | None:
+    """Return the user-configured overrides for the resolved provider+model, if any."""
+
+    provider_config = settings.providers.get(resolved.provider_name or "")
+    if provider_config is None:
+        return None
+    return provider_config.models.get(resolved.model)
+
+
 def clone_agent(agent: Agent, *, store: SessionStore, session_id: str, messages: list[dict[str, Any]]) -> Agent:
     """Keep the current runtime config while swapping session state."""
 
@@ -86,29 +100,14 @@ def clone_agent(agent: Agent, *, store: SessionStore, session_id: str, messages:
         messages=messages,
         max_turns=agent.max_turns,
         max_tokens=agent.max_tokens,
+        context_window=agent.context_window,
+        compact_threshold=agent.compact_threshold,
         reasoning_effort=agent.reasoning_effort,
+        supports_reasoning=agent.supports_reasoning,
         supports_image_input=agent.supports_image_input,
         supports_pdf_input=agent.supports_pdf_input,
-        settings=agent.settings,
-    )
-
-
-async def append_session_message(
-    store: SessionStore,
-    session_id: str,
-    message: dict[str, Any],
-    *,
-    agent: Agent,
-) -> None:
-    """Persist one message with the current agent runtime metadata."""
-
-    await store.append_message(
-        session_id,
-        message,
-        provider=agent.provider,
-        model=agent.model,
-        cwd=agent.cwd,
-        api_base=agent.api_base,
+        system=agent.system,
+        tools=DEFAULT_TOOL_SPECS,
     )
 
 
@@ -158,37 +157,15 @@ def get_provider_option(settings: Settings, *, provider: str, api_base: str | No
 def list_model_options(settings: Settings, *, provider: str, api_base: str | None, current_model: str) -> list[str]:
     """Return the selectable model list for the current provider runtime."""
 
-    models = [current_model, *provider_default_models(provider)]
-    for option in list_provider_options(settings):
-        if option.provider == provider and option.api_base == api_base:
-            models = [current_model, *option.models]
-            break
-    return list(dict.fromkeys(models))
+    option = get_provider_option(settings, provider=provider, api_base=api_base)
+    models = option.models if option else provider_default_models(provider)
+    return list(dict.fromkeys([current_model, *models]))
 
 
 def supports_reasoning_effort(agent: Agent) -> bool:
     """Return whether the current agent provider+model supports reasoning effort."""
 
-    adapter = get_provider_adapter(agent.provider)
-    if not adapter.supports_reasoning_effort:
-        return False
-    option = get_provider_option(agent.settings, provider=agent.provider, api_base=agent.api_base)
-    resolved = resolve_provider(
-        agent.settings,
-        provider_name=option.name if option else agent.provider,
-        model=agent.model,
-        api_base=agent.api_base,
-    )
-    return resolved.supports_reasoning is True
-
-
-def update_reasoning_effort(agent: Agent, effort: str | None) -> bool:
-    """Update reasoning effort on the in-memory agent."""
-
-    if effort == agent.reasoning_effort:
-        return False
-    agent.reasoning_effort = effort
-    return True
+    return agent.supports_reasoning is True and get_provider_adapter(agent.provider).supports_reasoning_effort
 
 
 async def resolve_session(
@@ -233,31 +210,20 @@ async def resolve_session(
     return ResolvedSession(str(session.get("id") or ""), session, [], "new")
 
 
-async def update_agent_runtime(
-    agent: Agent,
-    *,
-    provider_name: str | None,
-    model: str | None,
-) -> bool:
-    """Update provider-related request settings on the active agent.
+def apply_resolved_provider(agent: Agent, resolved: ResolvedProvider, settings: Settings) -> bool:
+    """Copy runtime settings from a resolved provider onto an active agent.
 
-    This refreshes settings from disk and changes the in-memory agent runtime
-    only. Stored session metadata remains unchanged.
+    Returns whether any field actually changed. Does not touch session state.
+    Re-derives model capability fields from metadata when the provider or model
+    changes so the agent reports accurate support flags.
     """
 
-    settings = get_settings(agent.cwd)
-    resolved = resolve_provider(settings, provider_name=provider_name, model=model)
-
     runtime_changed = (
         agent.provider != resolved.provider
         or agent.model != resolved.model
         or agent.api_base != resolved.api_base
         or agent.api_key != resolved.api_key
         or agent.reasoning_effort != resolved.reasoning_effort
-        or agent.max_tokens != resolved.max_tokens
-        or agent.context_window != resolved.context_window
-        or agent.supports_image_input != resolved.supports_image_input
-        or agent.supports_pdf_input != resolved.supports_pdf_input
     )
 
     agent.provider = resolved.provider
@@ -265,11 +231,14 @@ async def update_agent_runtime(
     agent.api_key = resolved.api_key
     agent.api_base = resolved.api_base
     agent.reasoning_effort = resolved.reasoning_effort
-    agent.max_tokens = resolved.max_tokens
-    agent.context_window = resolved.context_window
-    agent.supports_image_input = bool(resolved.supports_image_input)
-    agent.supports_pdf_input = bool(resolved.supports_pdf_input)
-    agent.settings = settings
-    if hasattr(agent, "tools") and hasattr(agent.tools, "supports_image_input"):
-        agent.tools.supports_image_input = bool(agent.supports_image_input)
+
+    if runtime_changed:
+        model_config = _model_config_for(settings, resolved)
+        agent.refresh_capabilities(
+            max_tokens=model_config.max_output_tokens if model_config else None,
+            context_window=model_config.context_window if model_config else None,
+            supports_reasoning=model_config.supports_reasoning if model_config else None,
+            supports_image_input=model_config.supports_image_input if model_config else None,
+            supports_pdf_input=model_config.supports_pdf_input if model_config else None,
+        )
     return runtime_changed

{mycode → mycode_cli}/server/app.py

@@ -7,8 +7,8 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-from mycode.core.config import setup_logging
-from mycode.server.routers import chat_router, sessions_router, workspaces_router
+from mycode_cli.config import setup_logging
+from mycode_cli.server.routers import chat_router, sessions_router, workspaces_router
 
 logger = logging.getLogger(__name__)
 

{mycode → mycode_cli}/server/deps.py

@@ -7,8 +7,8 @@ from typing import Annotated
 
 from fastapi import Depends
 
-from mycode.core.session import SessionStore
-from mycode.server.run_manager import RunManager
+from mycode.session import SessionStore
+from mycode_cli.server.run_manager import RunManager
 
 
 @lru_cache