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

kash/model/actions_model.py

@@ -9,12 +9,12 @@ from textwrap import dedent
 from typing import Any, TypeVar, cast
 
 from chopdiff.docs import DiffFilter
-from chopdiff.docs.token_diffs import DIFF_FILTER_NONE
 from chopdiff.transforms import WINDOW_NONE, WindowSettings
 from flowmark import fill_text
 from prettyfmt import abbrev_obj, fmt_lines
 from pydantic.dataclasses import dataclass, rebuild_dataclass
 from pydantic.json_schema import JsonSchemaValue
+from strif import StringTemplate
 from typing_extensions import override
 
 from kash.config.logger import get_logger
@@ -27,13 +27,15 @@ from kash.model.items_model import UNTITLED, Item, ItemType, State
 from kash.model.operations_model import Operation, Source
 from kash.model.params_model import (
     ALL_COMMON_PARAMS,
+    COMMON_SHELL_PARAMS,
+    RUNTIME_ACTION_PARAMS,
+    Param,
     ParamDeclarations,
     TypedParamValues,
 )
 from kash.model.paths_model import StorePath
 from kash.model.preconditions_model import Precondition
 from kash.utils.common.parse_key_vals import format_key_value
-from kash.utils.common.string_template import StringTemplate
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import InvalidDefinition, InvalidInput
 from kash.workspaces.workspaces import get_ws
@@ -65,7 +67,8 @@ class ActionInput:
 @dataclass(frozen=True)
 class ExecContext:
     """
-    An action and its context for execution.
+    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
@@ -77,13 +80,33 @@ class ExecContext:
     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)
 
@@ -175,7 +198,7 @@ class LLMOptions:
     system_message: Message = Message("")
     body_template: MessageTemplate = MessageTemplate("{body}")
     windowing: WindowSettings = WINDOW_NONE
-    diff_filter: DiffFilter = DIFF_FILTER_NONE
+    diff_filter: DiffFilter | None = None
 
     def updated_with(self, param_name: str, value: Any) -> LLMOptions:
         """Update option from an action parameter."""
@@ -409,6 +432,17 @@ class Action(ABC):
         # Update corresponding LLM option if appropriate.
         self.llm_options = self.llm_options.updated_with(param_name, value)
 
+    @property
+    def shell_params(self) -> list[Param]:
+        """
+        List of parameters that are relevant to shell usage.
+        """
+        return (
+            list(self.params)
+            + list(RUNTIME_ACTION_PARAMS.values())
+            + list(COMMON_SHELL_PARAMS.values())
+        )
+
     def param_value_summary(self) -> dict[str, str]:
         """
         Readable, serializable summary of the action's non-default parameters, to include in

kash/model/concept_model.py

@@ -0,0 +1,30 @@
+from typing import NewType
+
+from kash.utils.lang_utils.capitalization import capitalize_cms
+
+Concept = NewType("Concept", str)
+
+
+def canonicalize_concept(concept: str, capitalize: bool = True) -> Concept:
+    """
+    Convert a concept string (general name, person, etc.) to a canonical form.
+    Drop any extraneous Markdown bullets. Drop any quoted phrases (e.g. book titles etc)
+    for consistency.
+    """
+    concept = concept.strip("-* ")
+    for quote in ['"', "'"]:
+        if concept.startswith(quote) and concept.endswith(quote):
+            concept = concept[1:-1]
+    if capitalize:
+        return Concept(capitalize_cms(concept))
+    else:
+        return Concept(concept)
+
+
+def normalize_concepts(
+    concepts: list[str], sort_dedup: bool = True, capitalize: bool = True
+) -> list[Concept]:
+    if sort_dedup:
+        return sorted(set(canonicalize_concept(concept, capitalize) for concept in concepts))
+    else:
+        return [canonicalize_concept(concept, capitalize) for concept in concepts]

kash/model/items_model.py

@@ -19,12 +19,12 @@ from prettyfmt import (
 from pydantic.dataclasses import dataclass
 from strif import abbrev_str, format_iso_timestamp
 
-from kash.concepts.concept_formats import canonicalize_concept
 from kash.config.logger import get_logger
+from kash.model.concept_model import canonicalize_concept
 from kash.model.media_model import MediaMetadata
 from kash.model.operations_model import OperationSummary, Source
 from kash.model.paths_model import StorePath, fmt_store_path
-from kash.text_handling.markdown_util import markdown_to_html
+from kash.text_handling.markdown_render import markdown_to_html
 from kash.utils.common.format_utils import fmt_loc, html_to_plaintext, plaintext_to_html
 from kash.utils.common.url import Locator, Url
 from kash.utils.errors import FileFormatError
@@ -33,6 +33,7 @@ from kash.utils.file_utils.file_formats_model import FileExt, Format
 
 if TYPE_CHECKING:
     from kash.model.actions_model import ExecContext
+    from kash.workspaces import Workspace
 
 log = get_logger(__name__)
 
@@ -310,7 +311,11 @@ class Item:
             key: value for key, value in item_dict.items() if key not in all_fields
         }
         if unexpected_metadata:
-            log.info("Skipping unexpected metadata on item: %s%s", info_prefix, unexpected_metadata)
+            log.info(
+                "Skipping unexpected metadata on item: %s%s",
+                info_prefix,
+                unexpected_metadata,
+            )
 
         result = cls(
             type=type_,
@@ -328,7 +333,10 @@ class Item:
 
     @classmethod
     def from_external_path(
-        cls, path: Path | str, item_type: ItemType | None = None, title: str | None = None
+        cls,
+        path: Path | str,
+        item_type: ItemType | None = None,
+        title: str | None = None,
     ) -> Item:
         """
         Create a resource Item for a file with a format inferred from the file extension
@@ -400,6 +408,19 @@ class Item:
         if self.type.expects_body and self.format.has_body and not self.body:
             raise ValueError(f"Item type `{self.type.value}` is text but has no body: {self}")
 
+    def absolute_path(self, ws: "Workspace | None" = None) -> Path:  # noqa: UP037
+        """
+        Get the absolute path to the item. Throws `ValueError` if the item has no
+        store path. If no workspace is provided, uses the current workspace.
+        """
+        from kash.workspaces import current_ws
+
+        if not self.store_path:
+            raise ValueError("Item has no store path")
+        if not ws:
+            ws = current_ws()
+        return ws.base_dir / self.store_path
+
     @property
     def is_binary(self) -> bool:
         return bool(self.format and self.format.is_binary)
@@ -541,6 +562,13 @@ class Item:
 
         return body_text[:max_len]
 
+    @property
+    def has_body(self) -> bool:
+        """
+        True if the item has a non-empty body.
+        """
+        return bool(self.body and self.body.strip())
+
     def slug_name(self, max_len: int = SLUG_MAX_LEN) -> str:
         """
         Get a readable slugified version of the title or filename or content
@@ -681,6 +709,10 @@ class Item:
         updates = other_updates.copy()
         updates["type"] = type
 
+        # If format was specified and user didn't specify file_ext, then infer it.
+        if "file_ext" not in other_updates and "format" in other_updates:
+            updates["file_ext"] = other_updates["format"].file_ext
+
         # External resource paths only make sense for resources, so clear them out if new item
         # is not a resource.
         new_type = updates.get("type") or self.type
@@ -691,15 +723,20 @@ class Item:
         if derived_from:
             new_item.update_relations(derived_from=derived_from)
 
-        # Fall back to action title template if we have it and it wasn't explicitly set.
+        # Fall back to action title template if we have it and title wasn't explicitly set.
         if "title" not in other_updates:
+            prev_title = self.title or (Path(self.store_path).stem if self.store_path else UNTITLED)
             if self.context:
                 action = self.context.action
                 new_item.title = action.title_template.format(
-                    title=self.title or UNTITLED, action_name=action.name
+                    title=prev_title, action_name=action.name
                 )
             else:
-                log.warning("Deriving an item without action context, will omit title: %s", self)
+                log.warning(
+                    "Deriving an item without action context so keeping previous title: %s",
+                    self,
+                )
+                new_item.title = f"{prev_title} (derived copy)"
 
         return new_item
 

kash/model/params_model.py

@@ -294,6 +294,18 @@ COMMON_ACTION_PARAMS: dict[str, Param] = {
         type=DocSelection,
         default_value=DocSelection.full,
     ),
+    "s3_bucket": Param(
+        "s3_bucket",
+        "The S3 bucket to upload to.",
+        type=str,
+        default_value=None,
+    ),
+    "s3_prefix": Param(
+        "s3_prefix",
+        "The S3 prefix to upload to (with or without a trailing slash).",
+        type=str,
+        default_value=None,
+    ),
 }
 
 # Extra parameters that are available when an action is invoked from the shell.
@@ -305,6 +317,18 @@ RUNTIME_ACTION_PARAMS: dict[str, Param] = {
         "it produces an output item that already exists.",
         type=bool,
     ),
+    "refetch": Param(
+        "refetch",
+        "Forcing re-fetching of any content, not using media or content caches.",
+        type=bool,
+        default_value=False,
+    ),
+    "no_format": Param(
+        "no_format",
+        "Do not auto-format (normalize) Markdown outputs.",
+        type=bool,
+        default_value=False,
+    ),
 }
 
 

kash/shell/completions/completion_scoring.py

@@ -7,6 +7,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import TypeVar
 
+import rich
 from strif import abbrev_str
 from thefuzz import fuzz
 
@@ -22,7 +23,7 @@ log = get_logger(__name__)
 T = TypeVar("T")
 
 # Scores less than this can be dropped early.
-MIN_CUTOFF = Score(60)
+MIN_CUTOFF = Score(70)
 
 
 def linear_boost(score: Score, min_score: Score) -> Score:
@@ -171,10 +172,29 @@ def score_phrase(prefix: str, text: str) -> Score:
     Could experiment with this more but it's a rough attempt to balance
     full matches and prefix matches.
     """
-    return Score(
-        0.4 * fuzz.token_set_ratio(prefix, text)
-        + 0.4 * fuzz.partial_ratio(prefix, text)
-        + 0.2 * fuzz.token_sort_ratio(prefix, text)
+    if len(prefix) > 5:
+        return Score(
+            0.4 * fuzz.ratio(prefix, text)
+            + 0.3 * fuzz.token_set_ratio(prefix, text)
+            + 0.3 * fuzz.partial_ratio(prefix, text),
+        )
+    else:
+        return Score(0.6 * fuzz.ratio(prefix, text) + 0.4 * fuzz.token_set_ratio(prefix, text))
+
+
+def print_all_scores(prefix: str, text: str):
+    rich.inspect(
+        {
+            "ratio": fuzz.ratio(prefix, text),
+            "partial_ratio": fuzz.partial_ratio(prefix, text),
+            "token_sort_ratio": fuzz.token_sort_ratio(prefix, text),
+            "token_set_ratio": fuzz.token_set_ratio(prefix, text),
+            "partial_token_set_ratio": fuzz.partial_token_set_ratio(prefix, text),
+            "final": score_phrase(prefix, text),
+        },
+        methods=False,
+        docs=False,
+        sort=False,
     )
 
 
@@ -281,3 +301,15 @@ def score_snippet(query: str, snippet: CommentedCommand) -> Score:
     )
     # Bias a little toward command matches.
     return Score(max(command_score, 0.7 * comment_score))
+
+
+## Tests
+
+
+def test_score_phrase():
+    assert score_phrase("hello world", "hello world") == Score(100)
+    assert Score(90) >= score_phrase("hello world", "hello there world") >= Score(80)
+    assert Score(70) >= score_phrase("hello world", "hello there there") >= Score(60)
+    assert Score(85) >= score_phrase("duf", "df") >= Score(75)
+    assert Score(70) >= score_phrase("wik", "awk") >= Score(60)
+    assert Score(60) >= score_phrase("wiki", "awk") >= Score(50)

kash/shell/output/kerm_codes.py

@@ -72,13 +72,12 @@ from html import escape
 from typing import Annotated, Literal, Self, TypeAlias
 from urllib.parse import parse_qs, quote, urlencode, urlparse
 
+from clideps.terminal.osc_utils import OscStr, osc8_link, osc8_link_codes, osc8_link_rich, osc_code
 from prompt_toolkit.formatted_text import FormattedText
 from pydantic import BaseModel, Field, TypeAdapter, model_validator
 from rich.style import Style
 from rich.text import Text
 
-from kash.shell.utils.osc_utils import OscStr, osc8_link, osc8_link_codes, osc8_link_rich, osc_code
-
 KC_VERSION = 0
 """Version of the Kerm codes format. Update when we make breaking changes."""
 

kash/shell/output/shell_formatting.py

@@ -8,10 +8,7 @@ from flowmark import Wrap, fill_text
 from rich.console import Group
 from rich.text import Text
 
-from kash.config.text_styles import (
-    STYLE_HINT,
-    format_success_emoji,
-)
+from kash.config.text_styles import COLOR_FAILURE, COLOR_SUCCESS, STYLE_HINT
 from kash.shell.output.kmarkdown import KMarkdown
 
 
@@ -84,6 +81,19 @@ def format_paragraphs(*paragraphs: str | Text | Group) -> Group:
     return Group(*text)
 
 
+EMOJI_TRUE = "✔︎"
+
+EMOJI_FALSE = "✘"
+
+
+def success_emoji(value: bool, success_only: bool = False) -> str:
+    return EMOJI_TRUE if value else " " if success_only else EMOJI_FALSE
+
+
+def format_success_emoji(value: bool, success_only: bool = False) -> Text:
+    return Text(success_emoji(value, success_only), style=COLOR_SUCCESS if value else COLOR_FAILURE)
+
+
 def format_success(message: str | Text) -> Text:
     return Text.assemble(format_success_emoji(True), message)
 

kash/shell/shell_main.py

@@ -16,12 +16,12 @@ import threading
 import xonsh.main
 from strif import quote_if_needed
 
-from kash.config.setup import setup
+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
 
-setup(rich_logging=True)  # Set up logging first.
+kash_setup(rich_logging=True)  # Set up logging first.
 
 
 __version__ = get_version()

kash/shell/utils/exception_printing.py

@@ -46,5 +46,11 @@ def wrap_with_exception_printing(func: Callable[..., R]) -> Callable[[list[str]]
             log.error(f"[{COLOR_ERROR}]Command error:[/{COLOR_ERROR}] %s", summarize_traceback(e))
             log.info("Command error details: %s", e, exc_info=True)
             return None
+        except Exception as e:
+            # Note xonsh can log exceptions but it will be in the xonsh call stack, which is
+            # useless for the user. Better to log all unexpected exception call stack
+            # here to our logs.
+            log.info("Command error details: %s", e, exc_info=True)
+            raise
 
     return command

kash/shell/utils/native_utils.py

@@ -11,15 +11,15 @@ import webbrowser
 from enum import Enum
 from pathlib import Path
 
+from clideps.pkgs.pkg_check import pkg_check
+from clideps.pkgs.platform_checks import Platform, get_platform
+from clideps.terminal.terminal_images import terminal_show_image
 from flowmark import Wrap
 from funlog import log_calls
 
 from kash.config.logger import get_logger
-from kash.config.text_styles import BAT_STYLE, BAT_THEME, COLOR_ERROR
-from kash.shell.clideps.pkg_deps import Pkg, pkg_check
-from kash.shell.clideps.platforms import PLATFORM, Platform
+from kash.config.text_styles import BAT_STYLE, BAT_STYLE_PLAIN, BAT_THEME, COLOR_ERROR
 from kash.shell.output.shell_output import cprint
-from kash.shell.utils.terminal_images import terminal_show_image
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.url import as_file_url, is_file_url, is_url
 from kash.utils.errors import FileNotFound, SetupError
@@ -49,11 +49,11 @@ def file_size_check(
 def native_open(filename: str | Path):
     filename = str(filename)
     log.message("Opening file: %s", filename)
-    if PLATFORM == Platform.Darwin:
+    if get_platform() == Platform.Darwin:
         subprocess.run(["open", filename])
-    elif PLATFORM == Platform.Linux:
+    elif get_platform() == Platform.Linux:
         subprocess.run(["xdg-open", filename])
-    elif PLATFORM == Platform.Windows:
+    elif get_platform() == Platform.Windows:
         subprocess.run(["start", shlex.quote(filename)], shell=True)
     else:
         raise NotImplementedError("Unsupported platform")
@@ -110,12 +110,14 @@ def _detect_view_mode(file_or_url: str) -> ViewMode:
 def view_file_native(
     file_or_url: str | Path,
     view_mode: ViewMode = ViewMode.auto,
+    plain: bool = False,
 ):
     """
     Open a file or URL in the console or a native app. If `view_mode` is auto,
     automatically determine whether to use console, web browser, or the user's
     preferred native application. For images, also tries terminal-based image
-    display.
+    display. The `--plain` flag will disable line numbers, grid, etc. in `bat`
+    and force `ViewMode.console`.
     """
     file_or_url = str(file_or_url)
     path = None
@@ -124,6 +126,9 @@ def view_file_native(
         if not path.exists():
             raise FileNotFound(fmt_loc(path))
 
+    if plain:
+        view_mode = ViewMode.console
+
     if view_mode == ViewMode.auto:
         view_mode = _detect_view_mode(file_or_url)
 
@@ -133,7 +138,7 @@ def view_file_native(
         webbrowser.open(url)
     elif view_mode == ViewMode.console and path:
         file_size, min_lines = file_size_check(path)
-        view_file_console(path, use_pager=min_lines > 40 or file_size > 20 * 1024)
+        view_file_console(path, use_pager=min_lines > 40 or file_size > 20 * 1024, plain=plain)
     elif view_mode == ViewMode.terminal_image and path:
         try:
             terminal_show_image(path)
@@ -187,11 +192,11 @@ def tail_file(
     if follow:
         max_lines = follow_max_lines
 
-    pkg_check().require(Pkg.tail)
-    pkg_check().warn_if_missing(Pkg.bat)
+    pkg_check().require("tail")
+    pkg_check().warn_if_missing("bat")
 
     if follow:
-        if pkg_check().has(Pkg.bat):
+        if pkg_check().is_found("bat"):
             # Follow the file in real-time.
             command = (
                 f"tail -{max_lines} -f {all_paths_str} | "
@@ -202,8 +207,8 @@ def tail_file(
             command = f"tail -f {all_paths_str}"
         cprint("Following file: `%s`", command, text_wrap=Wrap.NONE)
     else:
-        pkg_check().require(Pkg.less)
-        if pkg_check().has(Pkg.bat, Pkg.less):
+        pkg_check().require("less")
+        if pkg_check().is_found("bat"):
             command = (
                 f"tail -{max_lines} {all_paths_str} | "
                 f"bat --paging=never --color=always --style=plain --theme={BAT_THEME} -l log | "
@@ -216,7 +221,7 @@ def tail_file(
     subprocess.run(command, shell=True, check=True)
 
 
-def view_file_console(filename: str | Path, use_pager: bool = True):
+def view_file_console(filename: str | Path, use_pager: bool = True, plain: bool = False):
     """
     Displays a file in the console with pagination and syntax highlighting.
     """
@@ -226,18 +231,19 @@ def view_file_console(filename: str | Path, use_pager: bool = True):
     # TODO: Visualize YAML frontmatter with different syntax/style than Markdown content.
 
     is_text = file_format_info(filename).is_text
+    bat_style = BAT_STYLE_PLAIN if plain else BAT_STYLE
     if is_text:
-        pkg_check().require(Pkg.less)
-        if pkg_check().has(Pkg.bat):
+        pkg_check().require("less")
+        if pkg_check().is_found("bat"):
             pager_str = "--pager=always --pager=less " if use_pager else ""
-            command = f"bat {pager_str}--color=always --style={BAT_STYLE} --theme={BAT_THEME} {quoted_filename}"
+            command = f"bat {pager_str}--color=always --style={bat_style} --theme={BAT_THEME} {quoted_filename}"
         else:
-            pkg_check().require(Pkg.pygmentize)
+            pkg_check().require("pygmentize")
             command = f"pygmentize -g {quoted_filename}"
             if use_pager:
                 command = f"{command} | less -R"
     else:
-        pkg_check().require(Pkg.hexyl)
+        pkg_check().require("hexyl")
         command = f"hexyl {quoted_filename}"
         if use_pager:
             command = f"{command} | less -R"

kash/text_handling/custom_sliding_transforms.py

@@ -1,10 +1,17 @@
 from collections.abc import Callable
 from math import ceil
 
-from chopdiff.docs import DiffFilter, Paragraph, TextDoc, TextUnit, diff_docs, join_wordtoks
+from chopdiff.docs import (
+    DIFF_FILTER_NONE,
+    DiffFilter,
+    Paragraph,
+    TextDoc,
+    TextUnit,
+    diff_docs,
+    join_wordtoks,
+)
 from chopdiff.transforms import (
     WindowSettings,
-    accept_all,
     remove_window_br,
     sliding_para_window,
     sliding_window_transform,
@@ -31,7 +38,7 @@ def filtered_transform(
     doc: TextDoc,
     transform_func: TextDocTransform,
     windowing: WindowSettings | None,
-    diff_filter: DiffFilter = accept_all,
+    diff_filter: DiffFilter | None = None,
 ) -> TextDoc:
     """
     Apply a transform with sliding window across the input doc, enforcing the changes it's
@@ -39,7 +46,7 @@ def filtered_transform(
 
     If windowing is None, apply the transform to the entire document at once.
     """
-    has_filter = diff_filter != accept_all
+    has_filter = bool(diff_filter and diff_filter != DIFF_FILTER_NONE)
 
     if not windowing or not windowing.size:
         transformed_doc = transform_func(doc)
@@ -52,6 +59,7 @@ def filtered_transform(
             transformed_doc = transform_func(input_doc)
 
             if has_filter:
+                assert diff_filter
                 # Check the transform did what it should have.
                 diff = diff_docs(input_doc, transformed_doc)
                 accepted_diff, rejected_diff = diff.filter(diff_filter)

kash/text_handling/doc_normalization.py

@@ -21,7 +21,11 @@ def normalize_formatting_ansi(text: str, format: Format | None, width=DEFAULT_WR
             text, width=width, word_splitter=simple_word_splitter, len_fn=ansi_cell_len
         )
     elif format == Format.markdown or format == Format.md_html:
-        return fill_markdown(text, line_wrapper=line_wrap_by_sentence(len_fn=ansi_cell_len))
+        return fill_markdown(
+            text,
+            line_wrapper=line_wrap_by_sentence(len_fn=ansi_cell_len),
+            cleanups=True,  # Safe cleanups like unbolding section headers.
+        )
     elif format == Format.html:
         # We don't currently auto-format HTML as we sometimes use HTML with specifically chosen line breaks.
         return text
@@ -52,7 +56,7 @@ def normalize_text_file(
 
 
 def test_osc8_link():
-    from kash.shell.utils.osc_utils import osc8_link
+    from clideps.terminal.osc_utils import osc8_link
 
     link = osc8_link("https://example.com/" + "x" * 50, "Example")
     assert ansi_cell_len(link) == 7