kash-shell 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

kash/help/function_param_info.py

@@ -12,7 +12,7 @@ def _look_up_param_docs(func: Callable[..., Any], kw_params: list[FuncParam]) ->
         name = func_param.name
         param = ALL_COMMON_PARAMS.get(name)
         if not param:
-            param = Param(name, description=None, type=func_param.type or str)
+            param = Param(name, description=None, type=func_param.effective_type or str)
 
         # Also check the docstring for a description of this parameter.
         docstring = parse_docstring(func.__doc__ or "")

kash/llm_utils/init_litellm.py

@@ -0,0 +1,16 @@
+from functools import cache
+
+
+@cache
+def init_litellm():
+    """
+    Configure litellm to suppress overly prominent exception messages.
+    Do this lazily since litellm is slow to import.
+    """
+    try:
+        import litellm
+        from litellm import _logging  # noqa: F401
+
+        litellm.suppress_debug_info = True  # Suppress overly prominent exception messages.
+    except ImportError:
+        pass

kash/llm_utils/llm_api_keys.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-import litellm
 from clideps.env_vars.dotenv_utils import env_var_is_set
 from clideps.env_vars.env_names import EnvName
-from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
 
+from kash.llm_utils.init_litellm import init_litellm
 from kash.llm_utils.llm_names import LLMName
 from kash.llm_utils.llms import LLM
 
@@ -13,6 +12,11 @@ def api_for_model(model: LLMName) -> EnvName | None:
     """
     Get the API key name for a model or None if not found.
     """
+    import litellm
+    from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider
+
+    init_litellm()
+
     try:
         _model, custom_llm_provider, _dynamic_api_key, _api_base = get_llm_provider(model)
     except litellm.exceptions.BadRequestError:

kash/llm_utils/llm_completion.py

@@ -1,11 +1,10 @@
+from __future__ import annotations
+
 import time
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
-import litellm
 from flowmark import Wrap, fill_text
 from funlog import format_duration, log_calls
-from litellm.types.utils import Choices, ModelResponse
-from litellm.types.utils import Message as LiteLLMMessage
 from prettyfmt import slugify_snake
 from pydantic import BaseModel
 from pydantic.dataclasses import dataclass
@@ -13,12 +12,16 @@ from pydantic.dataclasses import dataclass
 from kash.config.logger import get_logger
 from kash.config.text_styles import EMOJI_TIMING
 from kash.llm_utils.fuzzy_parsing import is_no_results
+from kash.llm_utils.init_litellm import init_litellm
 from kash.llm_utils.llm_messages import Message, MessageTemplate
 from kash.llm_utils.llm_names import LLMName
 from kash.utils.common.url import Url, is_url
 from kash.utils.errors import ApiResultError
 from kash.utils.file_formats.chat_format import ChatHistory, ChatMessage, ChatRole
 
+if TYPE_CHECKING:
+    from litellm.types.utils import Message as LiteLLMMessage
+
 log = get_logger(__name__)
 
 
@@ -68,6 +71,10 @@ def llm_completion(
     """
     Perform an LLM completion with LiteLLM.
     """
+    import litellm
+    from litellm.types.utils import Choices, ModelResponse
+
+    init_litellm()
 
     chat_history = ChatHistory.from_dicts(messages)
     log.info(

kash/local_server/local_server_routes.py

@@ -18,7 +18,6 @@ from kash.shell.file_icons.nerd_icons import icon_for_file
 from kash.shell.output.shell_output import Wrap
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import FileNotFound, InvalidFilename
-from kash.web_gen import base_templates_dir
 from kash.web_gen.template_render import render_web_template
 from kash.workspaces.workspace_output import print_file_info
 
@@ -140,14 +139,11 @@ def explain(text: str):
 
     return HTMLResponse(
         render_web_template(
-            base_templates_dir,
             "base_webpage.html.jinja",
             {
                 "title": f"Help: {text}",
                 "content": render_web_template(
-                    base_templates_dir,
-                    "explain_view.html.jinja",
-                    {"help_html": help_html, "page_url": page_url},
+                    "explain_view.html.jinja", {"help_html": help_html, "page_url": page_url}
                 ),
             },
         )
@@ -270,12 +266,10 @@ def _serve_item(
 
         return HTMLResponse(
             render_web_template(
-                base_templates_dir,
                 "base_webpage.html.jinja",
                 {
                     "title": display_title,
                     "content": render_web_template(
-                        base_templates_dir,
                         "item_view.html.jinja",
                         {
                             "item": item,

kash/mcp/mcp_cli.py

@@ -9,9 +9,10 @@ import logging
 import os
 from pathlib import Path
 
+from clideps.utils.readable_argparse import ReadableColorFormatter
+
 from kash.config.settings import DEFAULT_MCP_SERVER_PORT, LogLevel, global_settings
 from kash.config.setup import kash_setup
-from kash.shell.utils.argparse_utils import WrappedColorFormatter
 from kash.shell.version import get_version
 
 __version__ = get_version()
@@ -27,7 +28,7 @@ log = logging.getLogger()
 def build_parser():
     from kash.workspaces.workspaces import global_ws_dir
 
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=WrappedColorFormatter)
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
     parser.add_argument(
         "--version",
         action="version",

kash/mcp/mcp_server_routes.py

@@ -13,12 +13,13 @@ from strif import AtomicVar
 from kash.config.capture_output import CapturedOutput, captured_output
 from kash.config.logger import get_logger
 from kash.config.settings import global_settings
+from kash.exec import kash_runtime
 from kash.exec.action_exec import prepare_action_input, run_action_with_caching
 from kash.exec.action_registry import get_all_actions_defaults, look_up_action_class
-from kash.model.actions_model import Action, ActionResult, ExecContext
+from kash.model.actions_model import Action, ActionResult
+from kash.model.exec_model import ExecContext
 from kash.model.params_model import TypedParamValues
 from kash.model.paths_model import StorePath
-from kash.workspaces.workspaces import current_ws, get_ws
 
 log = get_logger(__name__)
 
@@ -214,9 +215,14 @@ def run_mcp_tool(action_name: str, arguments: dict) -> list[TextContent]:
             # current workspace, which could be changed by the user by changing working
             # directories. Maybe confusing?
             explicit_mcp_ws = global_settings().mcp_ws_dir
-            ws = get_ws(explicit_mcp_ws) if explicit_mcp_ws else current_ws()
 
-            with ws:
+            with kash_runtime(
+                workspace_dir=explicit_mcp_ws,
+                rerun=True,  # Enabling rerun always for now, seems good for tools.
+                refetch=False,  # Using the file caches.
+                # Keeping all transient files for now, but maybe make transient?
+                override_state=None,
+            ) as exec_settings:
                 action_cls = look_up_action_class(action_name)
 
                 # Extract items array and remaining params from arguments.
@@ -228,14 +234,7 @@ def run_mcp_tool(action_name: str, arguments: dict) -> list[TextContent]:
                 action = action_cls.create(param_values)
 
                 # Create execution context and assemble action input.
-                context = ExecContext(
-                    action=action,
-                    workspace_dir=ws.base_dir,
-                    rerun=True,  # Enabling rerun always for now, seems good for tools.
-                    refetch=False,  # Using the file caches.
-                    # Keeping all transient files for now, but maybe make transient?
-                    override_state=None,
-                )
+                context = ExecContext(action=action, settings=exec_settings)
                 action_input = prepare_action_input(*input_items)
 
                 result, result_store_paths, _archived_store_paths = run_action_with_caching(

kash/media_base/transcription_deepgram.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 from os.path import getsize
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from clideps.env_vars.dotenv_utils import load_dotenv_paths
-from deepgram import ListenRESTClient, PrerecordedResponse
 from httpx import Timeout
 
 from kash.config.logger import CustomLogger, get_logger
@@ -10,6 +12,9 @@ from kash.config.settings import global_settings
 from kash.media_base.transcription_format import SpeakerSegment, format_speaker_segments
 from kash.utils.errors import ApiError, ContentError
 
+if TYPE_CHECKING:
+    from deepgram import PrerecordedResponse
+
 log: CustomLogger = get_logger(__name__)
 
 
@@ -19,7 +24,15 @@ def deepgram_transcribe_raw(
     """
     Transcribe an audio file using Deepgram and return the raw response.
     """
-    from deepgram import ClientOptionsFromEnv, DeepgramClient, FileSource, PrerecordedOptions
+    # Slow import, do lazily.
+    from deepgram import (
+        ClientOptionsFromEnv,
+        DeepgramClient,
+        FileSource,
+        ListenRESTClient,
+        PrerecordedOptions,
+        PrerecordedResponse,
+    )
 
     size = getsize(audio_file_path)
     log.info(

kash/model/__init__.py

@@ -20,7 +20,6 @@ from kash.model.actions_model import (
     Action,
     ActionInput,
     ActionResult,
-    ExecContext,
     LLMOptions,
     PathOp,
     PathOpType,
@@ -33,6 +32,7 @@ from kash.model.compound_actions_model import (
     look_up_actions,
 )
 from kash.model.concept_model import Concept, canonicalize_concept, normalize_concepts
+from kash.model.exec_model import ExecContext
 from kash.model.graph_model import GraphData, Link, Node
 from kash.model.items_model import (
     SLUG_MAX_LEN,

kash/model/actions_model.py

@@ -4,7 +4,6 @@ from abc import ABC, abstractmethod
 from dataclasses import Field as DataclassField
 from dataclasses import field, replace
 from enum import Enum
-from pathlib import Path
 from textwrap import dedent
 from typing import Any, TypeVar, cast
 
@@ -20,10 +19,10 @@ from typing_extensions import override
 from kash.config.logger import get_logger
 from kash.exec_model.args_model import NO_ARGS, ONE_ARG, ArgCount, ArgType, Signature
 from kash.exec_model.shell_model import ShellResult
-from kash.file_storage.file_store import FileStore
 from kash.llm_utils import LLM, LLMName
 from kash.llm_utils.llm_messages import Message, MessageTemplate
-from kash.model.items_model import UNTITLED, Item, ItemType, State
+from kash.model.exec_model import ExecContext
+from kash.model.items_model import UNTITLED, Item, ItemType
 from kash.model.operations_model import Operation, Source
 from kash.model.params_model import (
     ALL_COMMON_PARAMS,
@@ -38,7 +37,6 @@ from kash.model.preconditions_model import Precondition
 from kash.utils.common.parse_key_vals import format_key_value
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import InvalidDefinition, InvalidInput
-from kash.workspaces.workspaces import get_ws
 
 log = get_logger(__name__)
 
@@ -64,53 +62,6 @@ class ActionInput:
         return ActionInput(items=[])
 
 
-@dataclass(frozen=True)
-class ExecContext:
-    """
-    An action and its context for execution. This is a good place for settings
-    that apply to any action and are bothersome to pass as parameters.
-    """
-
-    action: Action
-    """The action being executed."""
-
-    workspace_dir: Path
-    """The workspace directory in which the action is being executed."""
-
-    rerun: bool = False
-    """If True, always run actions, even cacheable ones that have results."""
-
-    refetch: bool = False
-    """If True, will refetch items even if they are already in the content caches."""
-
-    override_state: State | None = None
-    """If specified, override the state of result items. Useful to mark items as transient."""
-
-    tmp_output: bool = False
-    """If True, will save output items to a temporary file."""
-
-    no_format: bool = False
-    """If True, will not normalize the output item's body text formatting (for Markdown)."""
-
-    @property
-    def workspace(self) -> FileStore:
-        return get_ws(self.workspace_dir)
-
-    @property
-    def runtime_options(self) -> dict[str, str]:
-        """Return non-default runtime options."""
-        opts: dict[str, str] = {}
-        # Only these two settings directly affect the output:
-        if self.no_format:
-            opts["no_format"] = "true"
-        if self.override_state:
-            opts["override_state"] = self.override_state.name
-        return opts
-
-    def __repr__(self):
-        return abbrev_obj(self, field_max_len=80)
-
-
 class PathOpType(Enum):
     archive = "archive"
     select = "select"
@@ -365,8 +316,8 @@ class Action(ABC):
         """
         Declaration sanity checks.
         """
-        if not self.name or not self.description:
-            raise InvalidDefinition("Action must have a name and description")
+        if not self.name:
+            raise InvalidDefinition("Action must have a name")
 
         for param in self.params:
             if not self.has_param(param.name):
@@ -535,7 +486,7 @@ class Action(ABC):
                 log.info("Ignoring parameter for action `%s`: `%s`", self.name, param_name)
 
         if overrides:
-            log.message(
+            log.info(
                 "Overriding parameters for action `%s`:\n%s",
                 self.name,
                 fmt_lines(overrides),
@@ -677,3 +628,4 @@ class PerItemAction(Action, ABC):
 
 # Handle circular dependency in Python dataclasses.
 rebuild_dataclass(Item)  # pyright: ignore
+rebuild_dataclass(ExecContext)  # pyright: ignore

kash/model/exec_model.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from prettyfmt import abbrev_obj
+from pydantic.dataclasses import dataclass
+
+from kash.config.logger import get_logger
+from kash.model.items_model import State
+
+if TYPE_CHECKING:
+    from kash.file_storage.file_store import FileStore
+    from kash.model.actions_model import Action
+
+
+log = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class RuntimeSettings:
+    """
+    Workspace and other runtime settings that may be set across runs of
+    one or more actions.
+    """
+
+    workspace_dir: Path
+    """The workspace directory in which the action is being executed."""
+
+    rerun: bool = False
+    """If True, always run actions, even cacheable ones that have results."""
+
+    refetch: bool = False
+    """If True, will refetch items even if they are already in the content caches."""
+
+    override_state: State | None = None
+    """If specified, override the state of result items. Useful to mark items as transient."""
+
+    tmp_output: bool = False
+    """If True, will save output items to a temporary file."""
+
+    no_format: bool = False
+    """If True, will not normalize the output item's body text formatting (for Markdown)."""
+
+    @property
+    def workspace(self) -> FileStore:
+        from kash.workspaces.workspaces import get_ws
+
+        return get_ws(self.workspace_dir)
+
+    @property
+    def non_default_options(self) -> dict[str, str]:
+        """
+        Summarize non-default runtime options as a dict.
+        """
+        opts: dict[str, str] = {}
+        # Only these two settings directly affect the output:
+        if self.no_format:
+            opts["no_format"] = "true"
+        if self.override_state:
+            opts["override_state"] = self.override_state.name
+        return opts
+
+    def __repr__(self):
+        return abbrev_obj(self, field_max_len=80)
+
+
+@dataclass(frozen=True)
+class ExecContext:
+    """
+    An action and its context for execution. This is a good place for settings
+    that apply to any action and are bothersome to pass as parameters.
+    """
+
+    action: Action
+    """The action being executed."""
+
+    settings: RuntimeSettings
+    """The workspace and other run-time settings for the action."""