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

kash/model/operations_model.py

@@ -25,27 +25,46 @@ class OperationSummary:
 class Input:
     """
     An input to an operation, which may include a hash fingerprint.
+    Typically an input is a StorePath, but it could be something else like an in-memory
+    item that hasn't been saved yet.
     """
 
-    # TODO: May want to support Locators or other inputs besides StorePaths.
-    path: StorePath
+    path: StorePath | None
     hash: str | None = None
+    source_info: str | None = None
 
     @classmethod
     def parse(cls, input_str: str) -> Input:
         """
-        Parse an Input string in the format `some/path/filename.ext@sha1:hash` or
-        `@some/path/filename.ext@sha1:hash`, with a store path and a hash.
+        Parse an Input string in the format printed by `Input.parseable_str()`.
         """
-        parts = input_str.rsplit("@", 1)
-        if len(parts) == 2:
-            path, hash = parts
-            return cls(path=StorePath(path), hash=hash)
+        if input_str.startswith("[") and input_str.endswith("]"):
+            return cls(path=None, hash=None, source_info=input_str[1:-1])
         else:
-            return cls(path=StorePath(input_str), hash=None)
-
-    def path_and_hash(self):
-        return f"{fmt_loc(self.path)}@{self.hash}"
+            parts = input_str.rsplit("@", 1)
+            if len(parts) == 2:
+                path, hash = parts
+                return cls(path=StorePath(path), hash=hash)
+            else:
+                return cls(path=StorePath(input_str), hash=None)
+
+    def parseable_str(self):
+        """
+        A readable and parseable string describing the input, typically a hash and a path but
+        could be a path without a hash or another info in brackets. Paths may have an `@` at the
+        front.
+
+        some/path.txt@sha1:1234567890
+        @some/path.txt@sha1:1234567890
+        some/path.txt
+        [unsaved]
+        """
+        if self.path and self.hash:
+            return f"{fmt_loc(self.path)}@{self.hash}"
+        elif self.source_info:
+            return f"[{self.source_info}]"
+        else:
+            return "[input info missing]"
 
     # Inputs are equal if the hashes match (even if the paths have changed).
 
@@ -53,6 +72,10 @@ class Input:
         return hash(self.hash) if self.hash else object.__hash__(self)
 
     def __eq__(self, other: Any) -> bool:
+        """
+        Inputs are equal if the hashes match (even if the paths have changed) or if the paths
+        are the same. They are *not* equal otherwise, even if the source_info is the same.
+        """
         if not isinstance(other, Input):
             return NotImplemented
         if self.hash and other.hash:
@@ -62,7 +85,7 @@ class Input:
         return False
 
     def __str__(self):
-        return self.path_and_hash()
+        return self.parseable_str()
 
 
 @dataclass(frozen=True)
@@ -88,7 +111,7 @@ class Operation:
         }
 
         if self.arguments:
-            d["arguments"] = [arg.path_and_hash() for arg in self.arguments]
+            d["arguments"] = [arg.parseable_str() for arg in self.arguments]
         if self.options:
             d["options"] = self.options
 
@@ -101,7 +124,7 @@ class Operation:
         return [shell_quote(str(arg.path)) for arg in self.arguments]
 
     def hashed_args(self):
-        return [arg.path_and_hash() for arg in self.arguments]
+        return [arg.parseable_str() for arg in self.arguments]
 
     def quoted_options(self):
         return [f"--{k}={shell_quote(str(v))}" for k, v in self.options.items()]

kash/model/paths_model.py

@@ -264,6 +264,8 @@ def fmt_store_path(store_path: str | Path | StorePath) -> str:
     """
     Format a store path as a string.
     """
+    if not store_path:
+        raise ValueError("Cannot format empty store path")
     return StorePath(store_path).display_str()
 
 

kash/shell/output/shell_output.py

@@ -16,7 +16,7 @@ from rich.rule import Rule
 from rich.style import Style
 from rich.text import Text
 
-from kash.config.logger import get_console
+from kash.config.logger import get_console, is_console_quiet
 from kash.config.text_styles import (
     COLOR_HINT_DIM,
     COLOR_RESPONSE,
@@ -31,9 +31,6 @@ from kash.shell.output.kmarkdown import KMarkdown
 from kash.utils.rich_custom.rich_indent import Indent
 from kash.utils.rich_custom.rich_markdown_fork import Markdown
 
-console = get_console()
-
-
 print_context_var: contextvars.ContextVar[str] = contextvars.ContextVar("print_prefix", default="")
 """
 Context variable override for print prefix.
@@ -99,7 +96,12 @@ def rich_print(
     Print to the Rich console, either the global console or a thread-local
     override, if one is active. With `raw` true, we bypass rich formatting
     entirely and simply write to the console stream.
+
+    Output is suppressed by the global `console_quiet` setting.
     """
+    if is_console_quiet():
+        return
+
     console = get_console()
     if raw:
         # TODO: Indent not supported in raw mode.
@@ -136,7 +138,7 @@ def cprint(
     raw: bool = False,
 ):
     """
-    Main way to print to the shell. Wraps `rprint` with our additional
+    Main way to print to the shell. Wraps `rich_print` with our additional
     formatting options for text fill and prefix.
     """
     empty_indent = extra_indent.strip()
@@ -323,8 +325,8 @@ class PrintHooks(Enum):
     after_command_run = "after_command_run"
     before_status = "before_status"
     after_status = "after_status"
-    before_shell_action_run = "before_action_run"
-    after_shell_action_run = "after_action_run"
+    before_shell_action_run = "before_shell_action_run"
+    after_shell_action_run = "after_shell_action_run"
     before_log_action_run = "before_log_action_run"
     before_assistance = "before_assistance"
     after_assistance = "after_assistance"
@@ -376,7 +378,7 @@ class PrintHooks(Enum):
         elif self == PrintHooks.nonfatal_exception:
             self.nl()
         elif self == PrintHooks.before_done_message:
-            self.nl()
+            pass
         elif self == PrintHooks.before_output:
             self.nl()
         elif self == PrintHooks.after_output:

kash/shell/shell_main.py

@@ -14,10 +14,10 @@ import argparse
 import threading
 
 import xonsh.main
+from clideps.utils.readable_argparse import ReadableColorFormatter
 from strif import quote_if_needed
 
 from kash.config.setup import kash_setup
-from kash.shell.utils.argparse_utils import WrappedColorFormatter
 from kash.shell.version import get_full_version_name, get_version
 from kash.xonsh_custom.custom_shell import install_to_xonshrc, start_shell
 
@@ -51,7 +51,7 @@ def run_shell(single_command: str | None = None):
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=WrappedColorFormatter)
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=ReadableColorFormatter)
 
     parser.add_argument("--version", action="version", version=get_full_version_name())
 

kash/shell/ui/shell_results.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from prettyfmt import fmt_count_items
 from rich.box import SQUARE
 from rich.panel import Panel
 from rich.table import Table
@@ -10,7 +11,7 @@ from kash.config.text_styles import COLOR_SELECTION, STYLE_HINT
 from kash.exec.command_exec import run_command_or_action
 from kash.exec_model.shell_model import ShellResult
 from kash.shell.output.shell_output import PrintHooks, console_pager, cprint, print_result
-from kash.utils.common.format_utils import fmt_count_items, fmt_loc
+from kash.utils.common.format_utils import fmt_loc
 from kash.utils.errors import is_fatal
 from kash.workspaces import SelectionHistory
 

kash/shell/utils/exception_printing.py

@@ -5,7 +5,7 @@ from typing import TypeVar
 from kash.config.logger import get_logger
 from kash.config.text_styles import COLOR_ERROR
 from kash.shell.output.shell_output import PrintHooks
-from kash.utils.errors import NONFATAL_EXCEPTIONS
+from kash.utils.errors import get_nonfatal_exceptions
 
 log = get_logger(__name__)
 
@@ -41,7 +41,7 @@ def wrap_with_exception_printing(func: Callable[..., R]) -> Callable[[list[str]]
                 (", ".join(str(arg) for arg in args)),
             )
             return func(*args)
-        except NONFATAL_EXCEPTIONS as e:
+        except get_nonfatal_exceptions() as e:
             PrintHooks.nonfatal_exception()
             log.error(f"[{COLOR_ERROR}]Command error:[/{COLOR_ERROR}] %s", summarize_traceback(e))
             log.info("Command error details: %s", e, exc_info=True)

kash/utils/common/format_utils.py

@@ -2,10 +2,8 @@ import html
 import re
 from pathlib import Path
 
-from inflect import engine
 from prettyfmt import fmt_path
 
-from kash.utils.common.lazyobject import lazyobject
 from kash.utils.common.url import Locator, is_url
 
 
@@ -45,18 +43,6 @@ def fmt_loc(locator: str | Locator, resolve: bool = True) -> str:
         return fmt_path(locator, resolve=resolve)
 
 
-@lazyobject
-def inflect():
-    return engine()
-
-
-def fmt_count_items(count: int, name: str = "item") -> str:
-    """
-    Format a count and a name as a pluralized phrase, e.g. "1 item" or "2 items".
-    """
-    return f"{count} {inflect.plural(name, count)}"  # pyright: ignore
-
-
 ## Tests
 
 

kash/utils/common/import_utils.py

@@ -12,36 +12,64 @@ log = logging.getLogger(__name__)
 Tallies: TypeAlias = dict[str, int]
 
 
-def import_subdirs(
+def import_recursive(
     parent_package_name: str,
     parent_dir: Path,
-    subdir_names: list[str] | None = None,
+    resource_names: list[str] | None = None,
     tallies: Tallies | None = None,
 ):
     """
-    Import all files in the given subdirectories of a single parent directory.
-    Wraps `pkgutil.iter_modules` to iterate over all modules in the subdirectories.
-    If `subdir_names` is `None`, will import all subdirectories.
+    Import modules from subdirectories or individual Python modules within a parent package.
+
+    Each resource in `resource_names` can be:
+    - A directory name (all modules within it will be imported)
+    - A module name with or without '.py' extension (a single module will be imported)
+    - "." to import all modules in the parent_dir
+
+    If `resource_names` is `None`, imports all modules directly in parent_dir.
+
+    Simply a convenience wrapper for `importlib.import_module` and
+    `pkgutil.iter_modules` to iterate over all modules in the subdirectories.
+
+    If `tallies` is provided, it will be updated with the number of modules imported
+    for each package.
     """
     if tallies is None:
         tallies = {}
-    if not subdir_names:
-        subdir_names = ["."]
+    if not resource_names:
+        resource_names = ["."]
 
-    for subdir_name in subdir_names:
-        if subdir_name == ".":
+    for name in resource_names:
+        if name == ".":
             full_path = parent_dir
             package_name = parent_package_name
         else:
-            full_path = parent_dir / subdir_name
-            package_name = f"{parent_package_name}.{subdir_name}"
-
-        if not full_path.is_dir():
-            raise FileNotFoundError(f"Subdirectory not found: {full_path}")
-
-        for _module_finder, module_name, _is_pkg in pkgutil.iter_modules(path=[str(full_path)]):
-            importlib.import_module(f"{package_name}.{module_name}")  # Propagate import errors
-            tallies[package_name] = tallies.get(package_name, 0) + 1
+            full_path = parent_dir / name
+            package_name = f"{parent_package_name}.{name}"
+
+        # Check if it's a directory
+        if full_path.is_dir():
+            # Import all modules in the directory
+            for _, module_name, _ in pkgutil.iter_modules(path=[str(full_path)]):
+                importlib.import_module(f"{package_name}.{module_name}")
+                tallies[package_name] = tallies.get(package_name, 0) + 1
+        else:
+            # Not a directory, try as a module file
+            module_path = full_path
+            module_name = name
+
+            # Handle with or without .py extension
+            if not module_path.is_file() and module_path.suffix != ".py":
+                module_path = parent_dir / f"{name}.py"
+                module_name = name
+            elif module_path.suffix == ".py":
+                module_name = module_path.stem
+
+            if module_path.is_file() and module_name != "__init__":
+                importlib.import_module(f"{parent_package_name}.{module_name}")
+                tallies[parent_package_name] = tallies.get(parent_package_name, 0) + 1
+            else:
+                raise FileNotFoundError(f"Path not found or not importable: {full_path}")
 
     return tallies
 

kash/utils/common/task_stack.py

@@ -3,7 +3,6 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 
 from kash.config.text_styles import (
-    EMOJI_ACTION,
     EMOJI_BREADCRUMB_SEP,
     EMOJI_MSG_INDENT,
     TASK_STACK_HEADER,
@@ -93,9 +92,8 @@ class TaskStack:
         if not self.stack:
             return ""
         else:
-            prefix = f"{self.prefix_str()} {EMOJI_BREADCRUMB_SEP} "
-            sep = f"\n{prefix}"
-            return prefix + sep.join(state.full_str() for state in self.stack)
+            sep = f" {EMOJI_BREADCRUMB_SEP} "
+            return f"{EMOJI_BREADCRUMB_SEP} " + sep.join(state.full_str() for state in self.stack)
 
     def prefix_str(self) -> str:
         if not self.stack:
@@ -107,8 +105,7 @@ class TaskStack:
         return f"TaskStack({self.full_str()})"
 
     def log_stack(self):
-        self._print()
-        self._log.message(f"{EMOJI_ACTION} {TASK_STACK_HEADER}\n%s", self.full_str())
+        self._log.message(f"{TASK_STACK_HEADER} %s", self.full_str())
 
     @contextmanager
     def context(self, name: str, total_parts: int = 1, unit: str = ""):
@@ -123,9 +120,7 @@ class TaskStack:
         except Exception as e:
             # Log immediately where the exception occurred, but don't double-log.
             if e not in self.exceptions_logged:
-                self._log.warning(
-                    "Exception in task context: %s: %s", type(e).__name__, e, exc_info=True
-                )
+                self._log.info("Exception in task context: %s: %s", type(e).__name__, e)
                 self.exceptions_logged.add(e)
             self.next(last_had_error=True)
             raise
@@ -139,12 +134,6 @@ class TaskStack:
 
         return get_logger(__name__)
 
-    @property
-    def _print(self):
-        from kash.shell.output.shell_output import cprint
-
-        return cprint
-
 
 task_stack_var: contextvars.ContextVar[TaskStack | None] = contextvars.ContextVar(
     "task_stack", default=None

kash/utils/errors.py

@@ -3,6 +3,8 @@ Common hierarchy of error types. These inherit from standard errors like
 ValueError and FileExistsError but are more fine-grained.
 """
 
+from functools import cache
+
 
 class KashRuntimeError(ValueError):
     """Base class for kash runtime errors."""
@@ -145,8 +147,14 @@ class ApiError(KashRuntimeError):
     pass
 
 
-def _nonfatal_exceptions() -> tuple[type[Exception], ...]:
+@cache
+def get_nonfatal_exceptions() -> tuple[type[Exception], ...]:
+    """
+    Exceptions that are not fatal and usually don't merit a full stack trace.
+    """
     exceptions: list[type[Exception]] = [SelfExplanatoryError, FileNotFoundError, IOError]
+
+    # Slow imports, do lazily.
     try:
         from xonsh.tools import XonshError
 
@@ -155,14 +163,15 @@ def _nonfatal_exceptions() -> tuple[type[Exception], ...]:
         pass
 
     try:
-        import litellm
+        import openai
 
-        exceptions.append(litellm.exceptions.APIError)
+        # LiteLLM exceptions subclass openai.APIError
+        exceptions.append(openai.APIError)
     except ImportError:
         pass
 
     try:
-        import yt_dlp
+        import yt_dlp.utils
 
         exceptions.append(yt_dlp.utils.DownloadError)
     except ImportError:
@@ -171,12 +180,8 @@ def _nonfatal_exceptions() -> tuple[type[Exception], ...]:
     return tuple(exceptions)
 
 
-NONFATAL_EXCEPTIONS = _nonfatal_exceptions()
-"""Exceptions that are not fatal and usually don't merit a full stack trace."""
-
-
 def is_fatal(exception: Exception) -> bool:
-    for e in NONFATAL_EXCEPTIONS:
+    for e in get_nonfatal_exceptions():
         if isinstance(exception, e):
             return False
     return True

kash/utils/file_utils/file_formats_model.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 
-from kash.utils.common.url import Url, is_file_url, parse_file_url
+from kash.utils.common.url import Url, is_file_url, is_url, parse_file_url
 from kash.utils.file_utils.file_ext import FileExt
 from kash.utils.file_utils.file_formats import (
     MIME_EMPTY,
@@ -103,8 +103,18 @@ class Format(Enum):
             self.log,
         ]
 
+    @property
+    def is_simple_text(self) -> bool:
+        """
+        Is this plaintext or close to it, like Markdown?
+        """
+        return self in [self.plaintext, self.markdown, self.md_html]
+
     @property
     def is_doc(self) -> bool:
+        """
+        Is this a textual document of some kind?
+        """
         return self in [
             self.markdown,
             self.md_html,
@@ -112,6 +122,7 @@ class Format(Enum):
             self.pdf,
             self.docx,
             self.pptx,
+            self.epub,
         ]
 
     @property
@@ -130,6 +141,14 @@ class Format(Enum):
     def is_code(self) -> bool:
         return self in [self.python, self.shellscript, self.xonsh, self.json, self.yaml]
 
+    @property
+    def is_markdown(self) -> bool:
+        return self in [self.markdown, self.md_html]
+
+    @property
+    def is_html(self) -> bool:
+        return self in [self.html, self.md_html]
+
     @property
     def is_data(self) -> bool:
         return self in [self.csv, self.xlsx, self.npz]
@@ -325,8 +344,8 @@ Format._init_mime_type_map()
 
 @dataclass(frozen=True)
 class FileFormatInfo:
-    file_ext: FileExt | None
-    """File extension, if recognized."""
+    current_file_ext: FileExt | None
+    """File extension, if recognized and in the current filename."""
 
     format: Format | None
     """Format, if recognized."""
@@ -334,11 +353,18 @@ class FileFormatInfo:
     mime_type: MimeType | None
     """Raw mime type, which may include more formats than the ones above."""
 
+    @property
+    def suggested_file_ext(self) -> FileExt | None:
+        """
+        Suggested file extension based on detected format.
+        """
+        return self.format.file_ext if self.format else self.current_file_ext
+
     @property
     def is_text(self) -> bool:
         return bool(
-            self.file_ext
-            and self.file_ext.is_text
+            self.current_file_ext
+            and self.current_file_ext.is_text
             or self.format
             and self.format.is_text
             or self.mime_type
@@ -358,8 +384,8 @@ class FileFormatInfo:
     @property
     def is_image(self) -> bool:
         return bool(
-            self.file_ext
-            and self.file_ext.is_image
+            self.current_file_ext
+            and self.current_file_ext.is_image
             or self.format
             and self.format.is_image
             or self.mime_type
@@ -432,24 +458,33 @@ def detect_media_type(filename: str | Path) -> MediaType:
     return media_type
 
 
-def choose_file_ext(url_or_path: Url | Path | str) -> FileExt | None:
+def choose_file_ext(
+    url_or_path: Url | Path | str, mime_type: MimeType | None = None
+) -> FileExt | None:
     """
-    Pick a suffix to reflect the type of the content. Recognizes known file
-    extensions, then tries libmagic, then gives up.
+    Pick a file extension to reflect the type of the content. First tries from any
+    provided content type (e.g. if this item was just downloaded). Then
+    recognizes known file extensions on the filename or URL, then tries looking
+    at the content with libmagic and heuristics, then gives up.
     """
-
-    def file_ext_for(path: Path) -> FileExt | None:
-        fmt = detect_file_format(path)
-        return fmt.file_ext if fmt else None
-
-    ext = None
-    if isinstance(url_or_path, Path):
-        ext = parse_file_ext(url_or_path) or file_ext_for(url_or_path)
-    elif is_file_url(url_or_path):
-        path = parse_file_url(url_or_path)
-        if path:
-            ext = parse_file_ext(path) or file_ext_for(path)
-    else:
-        ext = parse_file_ext(url_or_path)
-
-    return ext
+    if mime_type:
+        fmt = Format.from_mime_type(mime_type)
+        if fmt:
+            return fmt.file_ext
+
+    # First check if it's a known standard extension.
+    filename_ext = parse_file_ext(url_or_path)
+    if filename_ext:
+        return filename_ext
+
+    local_path = None
+    if isinstance(url_or_path, str) and is_file_url(url_or_path):
+        local_path = parse_file_url(url_or_path)
+    elif not is_url(url_or_path):
+        local_path = Path(url_or_path)
+
+    # If it's local based the extension on the file content.
+    if local_path:
+        return file_format_info(local_path).suggested_file_ext
+
+    return None

kash/utils/file_utils/file_sort_filter.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import humanfriendly
-import pandas as pd
 from funlog import log_calls
 from prettyfmt import fmt_path
 from pydantic.dataclasses import dataclass
@@ -12,6 +14,9 @@ from kash.config.logger import get_logger
 from kash.utils.errors import FileNotFound, InvalidInput
 from kash.utils.file_utils.file_walk import IgnoreFilter, walk_by_dir
 
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
 log = get_logger(__name__)
 
 
@@ -122,8 +127,10 @@ class FileListing:
     size_matching: int
     since_timestamp: float
 
-    def as_dataframe(self) -> pd.DataFrame:
-        df = pd.DataFrame([file.__dict__ for file in self.files])
+    def as_dataframe(self) -> DataFrame:
+        from pandas import DataFrame
+
+        df = DataFrame([file.__dict__ for file in self.files])
         return df
 
     @property