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

kash/actions/core/render_as_html.py

@@ -1,7 +1,7 @@
 from kash.actions.core.tabbed_webpage_config import tabbed_webpage_config
 from kash.actions.core.tabbed_webpage_generate import tabbed_webpage_generate
 from kash.exec import kash_action
-from kash.exec.preconditions import has_full_html_page_body, has_text_body, is_html
+from kash.exec.preconditions import has_full_html_page_body, has_html_body, has_simple_text_body
 from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.model import ActionInput, ActionResult, Param
 from kash.model.items_model import ItemType
@@ -11,7 +11,7 @@ from kash.web_gen.simple_webpage import simple_webpage_render
 
 @kash_action(
     expected_args=ONE_OR_MORE_ARGS,
-    precondition=(is_html | has_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
     params=(Param("add_title", "Add a title to the page body.", type=bool),),
 )
 def render_as_html(input: ActionInput, add_title: bool = False) -> ActionResult:

kash/actions/core/show_webpage.py

@@ -1,7 +1,7 @@
 from kash.actions.core.render_as_html import render_as_html
 from kash.commands.base.show_command import show
 from kash.exec import kash_action
-from kash.exec.preconditions import has_full_html_page_body, has_text_body, is_html
+from kash.exec.preconditions import has_full_html_page_body, has_html_body, has_simple_text_body
 from kash.exec_model.args_model import ONE_OR_MORE_ARGS
 from kash.exec_model.commands_model import Command
 from kash.exec_model.shell_model import ShellResult
@@ -10,7 +10,7 @@ from kash.model import ActionInput, ActionResult
 
 @kash_action(
     expected_args=ONE_OR_MORE_ARGS,
-    precondition=(is_html | has_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
 )
 def show_webpage(input: ActionInput) -> ActionResult:
     """

kash/actions/core/strip_html.py

@@ -1,6 +1,6 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
-from kash.exec.preconditions import has_html_body, has_text_body
+from kash.exec.preconditions import has_html_body, has_simple_text_body
 from kash.model import Format, Item
 from kash.utils.common.format_utils import html_to_plaintext
 from kash.utils.errors import InvalidInput
@@ -8,7 +8,7 @@ from kash.utils.errors import InvalidInput
 log = get_logger(__name__)
 
 
-@kash_action(precondition=has_html_body | has_text_body)
+@kash_action(precondition=has_html_body | has_simple_text_body)
 def strip_html(item: Item) -> Item:
     """
     Strip HTML tags from HTML or Markdown. This is a simple filter, simply searching

kash/commands/base/basic_file_commands.py

@@ -2,7 +2,7 @@ import os
 
 from frontmatter_format import fmf_read_raw, fmf_strip_frontmatter
 from prettyfmt import fmt_lines
-from strif import copyfile_atomic
+from strif import atomic_output_file, copyfile_atomic
 
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_EMPH
@@ -28,10 +28,10 @@ log = get_logger(__name__)
 
 
 @kash_command
-def cbcopy(path: str | None = None, raw: bool = False) -> None:
+def clipboard_copy(path: str | None = None, raw: bool = False) -> None:
     """
     Copy the contents of a file (or the first file in the selection) to the OS-native
-    clipboard.
+    clipboard. Similar to `pbcopy` on macOS.
 
     :param raw: Copy the full exact contents of the file. Otherwise frontmatter is omitted.
     """
@@ -39,6 +39,8 @@ def cbcopy(path: str | None = None, raw: bool = False) -> None:
     import pyperclip
 
     input_paths = assemble_path_args(path)
+    if not input_paths:
+        raise InvalidInput("No path provided")
     input_path = input_paths[0]
 
     format = detect_file_format(input_path)
@@ -69,6 +71,22 @@ def cbcopy(path: str | None = None, raw: bool = False) -> None:
         )
 
 
+@kash_command
+def clipboard_paste(path: str = "untitled_paste.txt") -> None:
+    """
+    Paste the contents of the OS-native clipboard into a new file.
+    """
+    # TODO: Get this to work for images!
+    # And can we convert rich text to Markdown?
+    import pyperclip
+
+    contents = pyperclip.paste()
+    with atomic_output_file(path, backup_suffix=".{timestamp}.bak") as f:
+        f.write_text(contents)
+
+    print_status("Pasted clipboard contents to:\n%s", fmt_lines([fmt_loc(path)]))
+
+
 @kash_command
 def edit(path: str | None = None, all: bool = False) -> None:
     """

kash/commands/base/files_command.py

@@ -75,7 +75,8 @@ def _print_listing_tallies(
         cprint("(use --no_max to remove cutoff)", style=STYLE_HINT)
 
 
-DEFAULT_MAX_PG = 100
+DEFAULT_MAX_PER_GROUP = 50
+"""Default maximum number of files to display per group."""
 
 
 @kash_command
@@ -301,13 +302,13 @@ def files(
     # there are lots of groups and lots of files per group.
     # Default is max 100 per group but if we have 4 * 100 items, cut to 25.
     # If we have 2 * 100 items, cut to 50.
-    final_max_pg = DEFAULT_MAX_PG if cap_per_group else max_per_group
+    final_max_pg = DEFAULT_MAX_PER_GROUP if cap_per_group else max_per_group
     max_pg_explicit = max_per_group > 0
     if not max_pg_explicit:
         group_lens = [len(group_df) for group_df in grouped]
         for ratio in [2, 4]:
-            if sum(group_lens) > ratio * DEFAULT_MAX_PG:
-                final_max_pg = int(DEFAULT_MAX_PG / ratio)
+            if sum(group_lens) > ratio * DEFAULT_MAX_PER_GROUP:
+                final_max_pg = int(DEFAULT_MAX_PER_GROUP / ratio)
 
     total_displayed = 0
     total_displayed_size = 0

kash/commands/extras/parse_uv_lock.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import subprocess
 import tomllib
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-import pandas as pd
 from packaging.tags import Tag, sys_tags
 from packaging.utils import parse_wheel_filename
 from prettyfmt import fmt_size_dual
@@ -13,6 +15,9 @@ from kash.config.text_styles import COLOR_STATUS
 from kash.exec import kash_command
 from kash.shell.output.shell_output import cprint
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 log = get_logger(__name__)
 
 
@@ -49,13 +54,15 @@ def get_platform() -> str:
     return next(sys_tags()).platform
 
 
-def parse_uv_lock(lock_path: Path) -> pd.DataFrame:
+def parse_uv_lock(lock_path: Path) -> DataFrame:
     """
     Return one row per package from a uv.lock file, selecting the best
     matching wheel for the current interpreter or falling back to the sdist.
 
     Columns: name, version, registry, file_type, url, hash, size, filename.
     """
+    from pandas import DataFrame
+
     with open(lock_path, "rb") as f:
         data = tomllib.load(f)
 
@@ -88,7 +95,7 @@ def parse_uv_lock(lock_path: Path) -> pd.DataFrame:
             }
         )
 
-    return pd.DataFrame(rows)
+    return DataFrame(rows)
 
 
 def uv_runtime_packages(
@@ -141,6 +148,8 @@ def uv_dep_info(
     By default, filters to show only 'main' dependencies from pyproject.toml.
     Helpful for looking at sizes of dependencies.
     """
+    import pandas as pd
+
     uv_lock_path = Path(uv_lock)
     pyproject_path = Path(pyproject)
 

kash/commands/workspace/selection_commands.py

@@ -10,8 +10,8 @@ from kash.exec_model.shell_model import ShellResult
 from kash.model.paths_model import StorePath
 from kash.shell.ui.shell_results import shell_print_selection_history
 from kash.utils.common.format_utils import fmt_loc
+from kash.utils.common.inflection import plural
 from kash.utils.errors import InvalidInput
-from kash.utils.lang_utils.inflection import plural
 from kash.workspaces import Selection, current_ws
 
 log = get_logger(__name__)

kash/commands/workspace/workspace_commands.py

@@ -51,6 +51,7 @@ from kash.shell.output.shell_output import (
 )
 from kash.shell.utils.native_utils import tail_file
 from kash.utils.common.format_utils import fmt_loc
+from kash.utils.common.inflection import plural
 from kash.utils.common.obj_replace import remove_values
 from kash.utils.common.parse_key_vals import parse_key_value
 from kash.utils.common.type_utils import not_none
@@ -58,7 +59,6 @@ from kash.utils.common.url import Url, is_url
 from kash.utils.errors import InvalidInput
 from kash.utils.file_formats.chat_format import tail_chat_history
 from kash.utils.file_utils.dir_info import is_nonempty_dir
-from kash.utils.lang_utils.inflection import plural
 from kash.web_content.file_cache_utils import cache_file
 from kash.workspaces import (
     current_ws,

kash/config/env_settings.py

@@ -1,10 +1,7 @@
-import os
-from enum import Enum
-from pathlib import Path
-from typing import overload
+from clideps.env_vars.env_enum import EnvEnum
 
 
-class KashEnv(str, Enum):
+class KashEnv(EnvEnum):
     """
     Environment variable settings for kash. None are required, but these may be
     used to override default values.
@@ -33,40 +30,3 @@ class KashEnv(str, Enum):
 
     KASH_USER_AGENT = "KASH_USER_AGENT"
     """The user agent to use for HTTP requests."""
-
-    @overload
-    def read_str(self) -> str | None: ...
-
-    @overload
-    def read_str(self, default: str) -> str: ...
-
-    def read_str(self, default: str | None = None) -> str | None:
-        """
-        Get the value of the environment variable from the environment (with
-        optional default).
-        """
-        return os.environ.get(self.value, default)
-
-    @overload
-    def read_path(self) -> Path | None: ...
-
-    @overload
-    def read_path(self, default: Path) -> Path: ...
-
-    def read_path(self, default: Path | None = None) -> Path | None:
-        """
-        Get the value of the environment variable as a resolved path (with
-        optional default).
-        """
-        value = os.environ.get(self.value)
-        if value:
-            return Path(value).expanduser().resolve()
-        else:
-            return default.expanduser().resolve() if default else None
-
-    def read_bool(self, default: bool = False) -> bool:
-        """
-        Get the value of the environment variable as a boolean.
-        """
-        value = str(os.environ.get(self.value, default) or "").lower()
-        return bool(value and value != "0" and value != "false" and value != "no")

kash/config/logger.py

@@ -55,6 +55,10 @@ class LogSettings:
     log_objects_dir: Path
     log_file_path: Path
 
+    @property
+    def is_quiet(self) -> bool:
+        return self.log_console_level >= LogLevel.error
+
 
 LOG_NAME_GLOBAL = "workspace"
 
@@ -83,6 +87,13 @@ def get_log_settings() -> LogSettings:
     return _log_settings.copy()
 
 
+def is_console_quiet() -> bool:
+    """
+    Whether to suppress non-logging console output.
+    """
+    return global_settings().console_quiet
+
+
 def make_valid_log_name(name: str) -> str:
     name = str(name).strip().rstrip("/").removesuffix(".log")
     name = re.sub(r"[^\w-]", "_", name)
@@ -244,14 +255,6 @@ def _do_logging_setup(log_settings: LogSettings):
 
     # Manually adjust logging for a few packages, removing previous verbose default handlers.
 
-    try:
-        import litellm
-        from litellm import _logging  # noqa: F401
-
-        litellm.suppress_debug_info = True  # Suppress overly prominent exception messages.
-    except ImportError:
-        pass
-
     log_levels = {
         None: INFO,
         "LiteLLM": INFO,
@@ -276,10 +279,12 @@ def prefix(line: str, emoji: str = "", warn_emoji: str = "") -> str:
     return " ".join(filter(None, [prefix, emojis, line]))
 
 
-def prefix_args(args: tuple[Any], emoji: str = "", warn_emoji: str = "") -> tuple[Any]:
-    if len(args) > 0:
-        args = (prefix(str(args[0]), emoji, warn_emoji),) + args[1:]
-    return args
+def prefix_args(
+    msg: object, *other_args: object, emoji: str = "", warn_emoji: str = ""
+) -> tuple[str, *tuple[object, ...]]:
+    """Prefixes the string representation of msg and returns it with other_args."""
+    prefixed_msg = prefix(str(msg), emoji, warn_emoji)
+    return (prefixed_msg,) + other_args
 
 
 class CustomLogger(logging.Logger):
@@ -290,29 +295,29 @@ class CustomLogger(logging.Logger):
     """
 
     @override
-    def debug(self, *args, **kwargs):
-        super().debug(*prefix_args(args), **kwargs)
+    def debug(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().debug(*prefix_args(msg, *args), **kwargs)
 
     @override
-    def info(self, *args, **kwargs):
-        super().info(*prefix_args(args), **kwargs)
+    def info(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().info(*prefix_args(msg, *args), **kwargs)
 
     @override
-    def warning(self, *args, **kwargs):
-        super().warning(*prefix_args(args, warn_emoji=EMOJI_WARN), **kwargs)
+    def warning(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().warning(*prefix_args(msg, *args, warn_emoji=EMOJI_WARN), **kwargs)
 
     @override
-    def error(self, *args, **kwargs):
-        super().error(*prefix_args(args, warn_emoji=EMOJI_ERROR), **kwargs)
+    def error(self, msg: object, *args: object, **kwargs: Any) -> None:
+        super().error(*prefix_args(msg, *args, warn_emoji=EMOJI_ERROR), **kwargs)
 
-    def log_at(self, level: LogLevel, *args, **kwargs):
+    def log_at(self, level: LogLevel, *args: object, **kwargs: Any) -> None:
         getattr(self, level.name)(*args, **kwargs)
 
-    def message(self, *args, **kwargs):
+    def message(self, msg: object, *args: object, **kwargs: Any) -> None:
         """
         An informative message that should appear even if log level is set to warning.
         """
-        super().warning(*prefix_args(args), **kwargs)
+        super().warning(*prefix_args(msg, *args), **kwargs)
 
     def save_object(
         self,
@@ -321,7 +326,7 @@ class CustomLogger(logging.Logger):
         obj: Any,
         level: LogLevel = LogLevel.info,
         file_ext: str = "txt",
-    ):
+    ) -> None:
         """
         Save an object to a file in the log directory. Useful for details too large to
         log normally but useful for debugging.
@@ -342,7 +347,7 @@ class CustomLogger(logging.Logger):
 
         self.log_at(level, "%s %s saved: %s", EMOJI_SAVED, description, path)
 
-    def dump_stack(self, all_threads: bool = True, level: LogLevel = LogLevel.info):
+    def dump_stack(self, all_threads: bool = True, level: LogLevel = LogLevel.info) -> None:
         self.log_at(level, "Stack trace dump:\n%s", current_stack_traces(all_threads))
 
     def __repr__(self):

kash/config/logger_basic.py

@@ -3,7 +3,7 @@ import sys
 from logging import FileHandler, Formatter, LogRecord
 from pathlib import Path
 
-from kash.config.settings import LogLevel
+from kash.config.settings import LogLevel, LogLevelStr
 from kash.config.suppress_warnings import demote_warnings
 
 # Basic logging setup for non-interactive logging, like on a server.
@@ -16,21 +16,21 @@ class SuppressedWarningsStreamHandler(logging.StreamHandler):
         super().emit(record)
 
 
-def basic_file_handler(path: Path, level: LogLevel) -> logging.FileHandler:
+def basic_file_handler(path: Path, level: LogLevel | LogLevelStr) -> logging.FileHandler:
     handler = logging.FileHandler(path)
-    handler.setLevel(level.value)
+    handler.setLevel(LogLevel.parse(level).value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler
 
 
-def basic_stderr_handler(level: LogLevel) -> logging.StreamHandler:
+def basic_stderr_handler(level: LogLevel | LogLevelStr) -> logging.StreamHandler:
     handler = SuppressedWarningsStreamHandler(stream=sys.stderr)
-    handler.setLevel(level.value)
+    handler.setLevel(LogLevel.parse(level).value)
     handler.setFormatter(Formatter("%(asctime)s %(levelname).1s %(name)s - %(message)s"))
     return handler
 
 
-def basic_logging_setup(log_path: Path | None, level: LogLevel):
+def basic_logging_setup(log_path: Path | None, level: LogLevel | LogLevelStr):
     """
     Set up basic logging to a file and to stderr.
     """

kash/config/settings.py

@@ -1,10 +1,13 @@
+from __future__ import annotations
+
 import os
-from enum import Enum
+from dataclasses import dataclass
+from enum import IntEnum
 from functools import cache
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
+from typing import Literal
 
-from pydantic.dataclasses import dataclass
 from strif import AtomicVar
 
 from kash.config.env_settings import KashEnv
@@ -64,7 +67,14 @@ LOCAL_SERVER_PORTS_MAX = 30
 LOCAL_SERVER_LOG_NAME = "local_server"
 
 
-class LogLevel(Enum):
+LogLevelStr = Literal["debug", "info", "message", "warning", "error"]
+
+
+class LogLevel(IntEnum):
+    """
+    Convenience enum for log levels with parsing and ordering.
+    """
+
     debug = DEBUG
     info = INFO
     warning = WARNING
@@ -72,7 +82,9 @@ class LogLevel(Enum):
     error = ERROR
 
     @classmethod
-    def parse(cls, level_str: str):
+    def parse(cls, level_str: str | LogLevelStr | LogLevel) -> LogLevel:
+        if isinstance(level_str, LogLevel):
+            return level_str
         canon_name = level_str.strip().lower()
         if canon_name == "warn":
             canon_name = "warning"
@@ -87,7 +99,7 @@ class LogLevel(Enum):
         return self.name
 
 
-DEFAULT_LOG_LEVEL = LogLevel.parse(KashEnv.KASH_LOG_LEVEL.read_str("warning"))
+DEFAULT_LOG_LEVEL = LogLevel.parse(KashEnv.KASH_LOG_LEVEL.read_str(default="warning"))
 
 
 def resolve_and_create_dirs(path: Path | str, is_dir: bool = False) -> Path:
@@ -174,6 +186,9 @@ class Settings:
     console_log_level: LogLevel
     """The log level for console-based logging."""
 
+    console_quiet: bool
+    """If true, suppress non-logging console output."""
+
     file_log_level: LogLevel
     """The log level for file-based logging."""
 
@@ -205,7 +220,7 @@ def _get_ws_root_dir() -> Path:
 
 
 def _get_global_ws_dir() -> Path:
-    kash_ws_dir = KashEnv.KASH_GLOBAL_WS.read_path()
+    kash_ws_dir = KashEnv.KASH_GLOBAL_WS.read_path(default=None)
     if kash_ws_dir:
         return kash_ws_dir
     else:
@@ -225,7 +240,7 @@ def _get_system_cache_dir() -> Path:
 
 
 def _get_mcp_ws_dir() -> Path | None:
-    mcp_dir = KashEnv.KASH_MCP_WS.read_str()
+    mcp_dir = KashEnv.KASH_MCP_WS.read_str(default=None)
     if mcp_dir:
         return Path(mcp_dir).expanduser().resolve()
     else:
@@ -254,6 +269,7 @@ def _read_settings():
         default_editor="nano",
         file_log_level=LogLevel.info,
         console_log_level=DEFAULT_LOG_LEVEL,
+        console_quiet=False,
         local_server_ports_start=LOCAL_SERVER_PORT_START,
         local_server_ports_max=LOCAL_SERVER_PORTS_MAX,
         local_server_port=0,

kash/config/setup.py

@@ -7,7 +7,13 @@ from clideps.env_vars.dotenv_utils import load_dotenv_paths
 
 from kash.config.logger import reset_rich_logging
 from kash.config.logger_basic import basic_logging_setup
-from kash.config.settings import LogLevel, configure_ws_and_settings, global_settings
+from kash.config.settings import (
+    LogLevel,
+    LogLevelStr,
+    atomic_global_settings,
+    configure_ws_and_settings,
+    global_settings,
+)
 
 
 @cache
@@ -16,7 +22,9 @@ def kash_setup(
     rich_logging: bool,
     kash_ws_root: Path | None = None,
     log_path: Path | None = None,
-    level: LogLevel = LogLevel.info,
+    log_level: LogLevel | LogLevelStr | None = None,
+    console_log_level: LogLevel | LogLevelStr | None = None,
+    console_quiet: bool | None = None,
 ):
     """
     One-time top-level setup of essential logging, keys, directories, and configs.
@@ -25,8 +33,14 @@ def kash_setup(
     Can call this if embedding kash in another app.
     Can be used to set the global default workspace and logs directory
     and/or the default log file.
-    If `rich_logging` is True, then rich logging with warnings only for console use.
-    If `rich_logging` is False, then use basic logging to a file and stderr.
+
+    Basic logging is to the specified log file.
+    If enabled, rich logging is to the console as well.
+
+    By default console is "warning" level but can be controlled with
+    the `console_log_level` parameter.
+    All console/shell output can be suppressed with `console_quiet`. By default
+    console is quiet if `console_log_level` is "error" or higher.
     """
     from kash.utils.common.stack_traces import add_stacktrace_handler
 
@@ -40,10 +54,24 @@ def kash_setup(
         configure_ws_and_settings(kash_ws_root)
 
     # Now set up logging, as it might depend on workspace root.
+    log_level = LogLevel.parse(log_level) if log_level else LogLevel.info
+
     if rich_logging:
+        # These settings are only used for rich logging.
+        console_log_level = (
+            LogLevel.parse(console_log_level) if console_log_level else LogLevel.warning
+        )
+        console_quiet = (
+            console_quiet if console_quiet is not None else console_log_level >= LogLevel.error
+        )
+
+        with atomic_global_settings().updates() as settings:
+            settings.console_log_level = console_log_level
+            settings.file_log_level = log_level
+            settings.console_quiet = console_quiet
         reset_rich_logging(log_path=log_path)
     else:
-        basic_logging_setup(log_path=log_path, level=level)
+        basic_logging_setup(log_path=log_path, level=log_level)
 
     _lib_setup()