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

kash/actions/core/markdownify.py

@@ -1,8 +1,9 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_resource
+from kash.exec.runtime_settings import current_runtime_settings
 from kash.model import Format, Item
-from kash.model.params_model import common_params
+from kash.model.items_model import ItemType
 from kash.utils.text_handling.markdownify_utils import markdownify_custom
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
@@ -12,20 +13,22 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_resource | has_html_body,
-    params=common_params("refetch"),
     mcp_tool=True,
 )
-def markdownify(item: Item, refetch: bool = False) -> Item:
+def markdownify(item: Item) -> Item:
     """
     Converts a URL or raw HTML item to Markdown, fetching with the content
     cache if needed. Also uses readability to clean up the HTML.
     """
 
+    refetch = current_runtime_settings().refetch
     expiration_sec = 0 if refetch else None
     url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
     assert page_data.clean_html
     markdown_content = markdownify_custom(page_data.clean_html)
 
-    output_item = item.derived_copy(format=Format.markdown, body=markdown_content)
+    output_item = item.derived_copy(
+        type=ItemType.doc, format=Format.markdown, body=markdown_content
+    )
     return output_item

kash/actions/core/readability.py

@@ -1,8 +1,8 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_resource
+from kash.exec.runtime_settings import current_runtime_settings
 from kash.model import Format, Item
-from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 
@@ -11,14 +11,15 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_resource | has_html_body,
-    params=common_params("refetch"),
     mcp_tool=True,
 )
-def readability(item: Item, refetch: bool = False) -> Item:
+def readability(item: Item) -> Item:
     """
     Extracts clean HTML from a raw HTML item.
     See `markdownify` to also convert to Markdown.
     """
+
+    refetch = current_runtime_settings().refetch
     expiration_sec = 0 if refetch else None
     locator, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(locator, html_content)

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_html_body, has_simple_text_body
+from kash.exec.preconditions import has_fullpage_html_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=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_fullpage_html_body,
     params=(Param("no_title", "Don't add a title to the page body.", type=bool),),
 )
 def render_as_html(input: ActionInput, no_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_html_body, has_simple_text_body
+from kash.exec.preconditions import has_fullpage_html_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=(has_html_body | has_simple_text_body) & ~has_full_html_page_body,
+    precondition=(has_html_body | has_simple_text_body) & ~has_fullpage_html_body,
 )
 def show_webpage(input: ActionInput) -> ActionResult:
     """

kash/commands/workspace/workspace_commands.py

@@ -193,49 +193,68 @@ def download(*urls_or_paths: str, refetch: bool = False) -> ShellResult:
     """
     Download a URL or resource. Uses cached content if available, unless `refetch` is true.
     Inputs can be URLs or paths to URL resources.
+    Creates both resource and document versions for text content.
     """
-    expiration_sec = 0 if refetch else None
-
-    # TODO: Add option to include frontmatter metadata for text files.
     ws = current_ws()
     saved_paths = []
+
     for url_or_path in urls_or_paths:
         locator = resolve_locator_arg(url_or_path)
         url: Url | None = None
+
+        # Get the URL from the locator
         if not isinstance(locator, Path) and is_url(locator):
             url = Url(locator)
-        if isinstance(locator, StorePath):
+        elif isinstance(locator, StorePath):
             url_item = ws.load(locator)
             if is_url_resource(url_item):
                 url = url_item.url
+
         if not url:
             raise InvalidInput(f"Not a URL or URL resource: {fmt_loc(locator)}")
 
+        # Handle media URLs differently
         if is_media_url(url):
             log.message(
                 "URL is a media URL, so adding as a resource and will cache media: %s", fmt_loc(url)
             )
-            store_path = ws.import_item(locator, as_type=ItemType.resource)
+            store_path = ws.import_item(url, as_type=ItemType.resource, reimport=refetch)
+            saved_paths.append(store_path)
             media_tools.cache_media(url)
         else:
-            log.message("Will cache file and save to workspace: %s", fmt_loc(url))
-            original_filename = Path(parse_http_url(url).path).name
+            # Cache the content first
+            expiration_sec = 0 if refetch else None
             cache_result = cache_file(url, expiration_sec=expiration_sec)
-            # If available, use the mime type to help set item file extension.
+            original_filename = Path(parse_http_url(url).path).name
             mime_type = cache_result.content.headers and cache_result.content.headers.mime_type
-            item = Item.from_external_path(
+
+            # Create a resource item
+            resource_item = Item.from_external_path(
                 cache_result.content.path,
                 ItemType.resource,
+                url=url,
                 mime_type=mime_type,
                 original_filename=original_filename,
             )
-            store_path = ws.save(item)
+            store_path = ws.save(resource_item, no_frontmatter=True, no_format=True)
             saved_paths.append(store_path)
 
+            # Also create a doc version for text content
+            if resource_item.format and resource_item.format.supports_frontmatter:
+                doc_item = Item.from_external_path(
+                    cache_result.content.path,
+                    ItemType.doc,
+                    url=url,
+                    mime_type=mime_type,
+                    original_filename=original_filename,
+                )
+                doc_store_path = ws.save(doc_item, no_frontmatter=False, no_format=False)
+                saved_paths.append(doc_store_path)
+
     print_status(
         "Downloaded %s %s:\n%s",
-        len(urls_or_paths),
-        plural("item", len(urls_or_paths)),
+        len(saved_paths),
+        plural("item", len(saved_paths)),
         fmt_lines(saved_paths),
     )
     select(*saved_paths)
@@ -483,7 +502,7 @@ def import_item(
 
 
 @kash_command
-def import_clipboard(
+def save_clipboard(
     title: str | None = "pasted_text",
     type: ItemType = ItemType.resource,
     format: Format = Format.plaintext,
@@ -518,8 +537,6 @@ def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
 
     Skips items that already have a title and description, unless `refetch` is true.
     Skips (with a warning) items that are not URL resources.
-
-    :param use_cache: If true, also save page in content cache.
     """
     if not files_or_urls:
         locators = assemble_store_path_args()
@@ -529,12 +546,12 @@ def fetch_metadata(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     store_paths = []
     for locator in locators:
         try:
-            if isinstance(locator, Path):
-                raise InvalidInput()
             fetched_item = fetch_url_metadata(locator, refetch=refetch)
             store_paths.append(fetched_item.store_path)
-        except InvalidInput:
-            log.warning("Not a URL or URL resource, will not fetch metadata: %s", fmt_loc(locator))
+        except InvalidInput as e:
+            log.warning(
+                "Not a URL or URL resource, will not fetch metadata: %s: %s", fmt_loc(locator), e
+            )
 
     if store_paths:
         select(*store_paths)
@@ -716,7 +733,7 @@ def reset_ignore_file(append: bool = False) -> None:
     ignore_path = ws.base_dir / ws.dirs.ignore_file
     write_ignore(ignore_path, append=append)
 
-    log.message("Rewrote kash ignore file: %s", fmt_loc(ignore_path))
+    log.message("Rewritten kash ignore file: %s", fmt_loc(ignore_path))
 
 
 @kash_command

kash/exec/action_exec.py

@@ -32,7 +32,6 @@ from kash.utils.common.task_stack import task_stack
 from kash.utils.common.type_utils import not_none
 from kash.utils.errors import ContentError, InvalidOutput, get_nonfatal_exceptions
 from kash.workspaces import Selection, current_ws
-from kash.workspaces.workspace_importing import import_and_load
 
 log = get_logger(__name__)
 
@@ -49,7 +48,7 @@ def prepare_action_input(*input_args: CommandArg, refetch: bool = False) -> Acti
 
     # Ensure input items are already saved in the workspace and load the corresponding items.
     # This also imports any URLs.
-    input_items = [import_and_load(ws, arg) for arg in input_args]
+    input_items = [ws.import_and_load(arg) for arg in input_args]
 
     # URLs should have metadata like a title and be valid, so we fetch them.
     if input_items:
@@ -383,7 +382,7 @@ def run_action_with_caching(
 
         PrintHooks.before_done_message()
         log.message(
-            "%s Done: `%s` completed with %s %s",
+            "%s Action: `%s` completed with %s %s",
             EMOJI_SUCCESS,
             action.name,
             len(result.items),

kash/exec/preconditions.py

@@ -7,7 +7,7 @@ from chopdiff.html import has_timestamp
 
 from kash.exec.precondition_registry import kash_precondition
 from kash.model.items_model import Item, ItemType
-from kash.utils.file_utils.file_formats import is_full_html_page
+from kash.utils.file_utils.file_formats import is_fullpage_html
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.text_handling.markdown_utils import extract_bullet_points
 
@@ -22,9 +22,14 @@ def is_doc_resource(item: Item) -> bool:
     return bool(is_resource(item) and item.format and item.format.is_doc)
 
 
+@kash_precondition
+def is_markdown_resource(item: Item) -> bool:
+    return bool(is_resource(item) and item.format and item.format.is_markdown)
+
+
 @kash_precondition
 def is_html_resource(item: Item) -> bool:
-    return bool(is_resource(item) and item.format and item.format == Format.html)
+    return bool(is_resource(item) and item.format and item.format.is_html)
 
 
 @kash_precondition
@@ -100,8 +105,18 @@ def has_html_body(item: Item) -> bool:
 
 
 @kash_precondition
-def has_full_html_page_body(item: Item) -> bool:
-    return bool(has_html_body(item) and item.body and is_full_html_page(item.body))
+def has_markdown_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown)
+
+
+@kash_precondition
+def has_markdown_with_html_body(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown_with_html)
+
+
+@kash_precondition
+def has_fullpage_html_body(item: Item) -> bool:
+    return bool(has_html_body(item) and item.body and is_fullpage_html(item.body))
 
 
 @kash_precondition
@@ -114,6 +129,11 @@ def is_markdown(item: Item) -> bool:
     return bool(has_body(item) and item.format and item.format.is_markdown)
 
 
+@kash_precondition
+def is_markdown_with_html(item: Item) -> bool:
+    return bool(has_body(item) and item.format and item.format.is_markdown_with_html)
+
+
 @kash_precondition
 def is_markdown_template(item: Item) -> bool:
     return is_markdown(item) and contains_curly_vars(item)

kash/file_storage/file_store.py

@@ -22,7 +22,7 @@ from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import PrintHooks
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.uniquifier import Uniquifier
-from kash.utils.common.url import Locator, Url, is_url
+from kash.utils.common.url import Locator, UnresolvedLocator, Url, is_url
 from kash.utils.errors import FileExists, FileNotFound, InvalidFilename, SkippableError
 from kash.utils.file_utils.file_formats_model import Format
 from kash.utils.file_utils.file_walk import walk_by_dir
@@ -290,7 +290,7 @@ class FileStore(Workspace):
         elif item_id in self.id_map and self.exists(self.id_map[item_id]):
             # If this item has an identity and we've saved under that id before, use the same store path.
             store_path = self.id_map[item_id]
-            log.warning(
+            log.info(
                 "Found existing item with same id:\n%s",
                 fmt_lines([fmt_loc(store_path), item_id]),
             )
@@ -334,6 +334,7 @@ class FileStore(Workspace):
         skip_dup_names: bool = False,
         as_tmp: bool = False,
         no_format: bool = False,
+        no_frontmatter: bool = False,
     ) -> StorePath:
         """
         Save the item. Uses the `store_path` if it's already set or generates a new one.
@@ -342,6 +343,8 @@ class FileStore(Workspace):
         Unless `no_format` is true, also normalizes body text formatting (for Markdown)
         and updates the item's body to match.
 
+        If `no_frontmatter` is true, will not add frontmatter metadata to the item.
+
         If `overwrite` is true, will overwrite a file that has the same path.
 
         If `as_tmp` is true, will save the item to a temporary file.
@@ -390,9 +393,14 @@ class FileStore(Workspace):
 
             # Now save the new item.
             try:
-                if item.external_path:
+                supports_frontmatter = item.format and item.format.supports_frontmatter
+                # For binary or unknown formats or if we're not adding frontmatter, copy the file exactly.
+                if item.external_path and (no_frontmatter or not supports_frontmatter):
                     copyfile_atomic(item.external_path, full_path, make_parents=True)
                 else:
+                    # Save as a text item with frontmatter.
+                    if item.external_path:
+                        item.body = Path(item.external_path).read_text()
                     if overwrite and full_path.exists():
                         log.info(
                             "Overwrite is enabled and a previous file exists so will archive it: %s",
@@ -448,7 +456,7 @@ class FileStore(Workspace):
 
     def import_item(
         self,
-        locator: Locator,
+        locator: UnresolvedLocator,
         *,
         as_type: ItemType | None = None,
         reimport: bool = False,
@@ -462,7 +470,10 @@ class FileStore(Workspace):
         """
         from kash.web_content.canon_url import canonicalize_url
 
-        if is_url(locator):
+        if isinstance(locator, StorePath) and not reimport:
+            log.info("Store path already imported: %s", fmt_loc(locator))
+            return locator
+        elif is_url(locator):
             # Import a URL as a resource.
             orig_url = Url(str(locator))
             url = canonicalize_url(orig_url)
@@ -480,9 +491,6 @@ class FileStore(Workspace):
             else:
                 store_path = self.save(item)
                 return store_path
-        elif isinstance(locator, StorePath) and not reimport:
-            log.info("Store path already imported: %s", fmt_loc(locator))
-            return locator
         else:
             # We have a path, possibly outside of or inside of the store.
             path = Path(locator).resolve()
@@ -553,6 +561,13 @@ class FileStore(Workspace):
             self.import_item(locator, as_type=as_type, reimport=reimport) for locator in locators
         ]
 
+    def import_and_load(self, locator: UnresolvedLocator) -> Item:
+        """
+        Import a locator and return the item.
+        """
+        store_path = self.import_item(locator)
+        return self.load(store_path)
+
     def _filter_selection_paths(self):
         """
         Filter out any paths that don't exist from all selections.
@@ -695,14 +710,20 @@ class FileStore(Workspace):
             dirs_ignored,
         )
 
-    def normalize(self, store_path: StorePath) -> StorePath:
+    def normalize(
+        self,
+        store_path: StorePath,
+        *,
+        no_format: bool = False,
+        no_frontmatter: bool = False,
+    ) -> StorePath:
         """
         Normalize an item or all items in a folder to make sure contents are in current
-        format.
+        format. This is the same as loading and saving the item.
         """
         log.info("Normalizing item: %s", fmt_path(store_path))
 
         item = self.load(store_path)
-        new_store_path = self.save(item)
+        new_store_path = self.save(item, no_format=no_format, no_frontmatter=no_frontmatter)
 
         return new_store_path

kash/model/items_model.py

@@ -181,7 +181,7 @@ class ItemId:
             item_id = ItemId(item.type, IdType.url, canonicalize_url(item.url))
         elif item.type == ItemType.concept and item.title:
             item_id = ItemId(item.type, IdType.concept, canonicalize_concept(item.title))
-        elif item.source and item.source.cacheable:
+        elif item.source and item.source.cacheable and item.source.operation.has_known_inputs:
             # We know the source of this and if the action was cacheable, we can create
             # an identity based on the source.
             item_id = ItemId(item.type, IdType.source, item.source.as_str())
@@ -363,21 +363,24 @@ class Item:
         *,
         title: str | None = None,
         original_filename: str | None = None,
+        url: Url | None = None,
         mime_type: MimeType | None = None,
     ) -> Item:
         """
         Create a resource Item for a file with a format inferred from the file extension
         or the content. Only sets basic metadata. Does not read the content. Will set
         `format` and `file_ext` if possible but will leave them as None if unrecognized.
-        If `mime_type` is provided, it can help determine the file extension.
+        If `mime_type` is provided, it can help determine the file extension if the
+        extension isn't recognized from the filename or URL.
         """
         from kash.file_storage.store_filenames import parse_item_filename
-        from kash.utils.file_utils.file_formats_model import choose_file_ext, detect_file_format
+        from kash.utils.file_utils.file_formats_model import file_format_info
 
         # Will raise error for unrecognized file ext.
         _name, filename_item_type, format, file_ext = parse_item_filename(path)
+        format_info = file_format_info(path, suggested_mime_type=mime_type)
         if not format:
-            format = detect_file_format(path)
+            format = format_info.format
         if not item_type and filename_item_type:
             item_type = filename_item_type
         if not item_type:
@@ -385,9 +388,10 @@ class Item:
             item_type = (
                 ItemType.doc if format and format.supports_frontmatter else ItemType.resource
             )
-        # Do our best to determine a good file extension if it's not already on the filename.
-        if not file_ext and mime_type:
-            file_ext = choose_file_ext(path, mime_type)
+
+        # Try to determine a good file extension if it's not already on the filename.
+        if not file_ext:
+            file_ext = format_info.suggested_file_ext
 
         item = cls(
             type=item_type,
@@ -396,6 +400,7 @@ class Item:
             format=format,
             external_path=str(path),
             original_filename=original_filename,
+            url=url,
         )
 
         # Update modified time from the file system.

kash/model/operations_model.py

@@ -66,6 +66,13 @@ class Input:
         else:
             return "[input info missing]"
 
+    @property
+    def is_known(self) -> bool:
+        """
+        Whether the input is known, i.e. we had saved inputs with hashes.
+        """
+        return bool(self.path and self.hash)
+
     # Inputs are equal if the hashes match (even if the paths have changed).
 
     def __hash__(self):
@@ -117,6 +124,13 @@ class Operation:
 
         return d
 
+    @property
+    def has_known_inputs(self) -> bool:
+        """
+        Whether the operation has known inputs, i.e. all inputs have hashes.
+        """
+        return all(arg.is_known for arg in self.arguments)
+
     def summary(self) -> OperationSummary:
         return OperationSummary(self.action_name)
 

kash/shell/utils/native_utils.py

@@ -23,7 +23,7 @@ from kash.shell.output.shell_output import cprint
 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
-from kash.utils.file_utils.file_formats import is_full_html_page, read_partial_text
+from kash.utils.file_utils.file_formats import is_fullpage_html, read_partial_text
 from kash.utils.file_utils.file_formats_model import file_format_info
 
 log = get_logger(__name__)
@@ -88,7 +88,7 @@ def _detect_view_mode(file_or_url: str) -> ViewMode:
     path = Path(file_or_url)
     if path.is_file():  # File or symlink.
         content = read_partial_text(path)
-        if content and is_full_html_page(content):
+        if content and is_fullpage_html(content):
             return ViewMode.browser
 
         info = file_format_info(path)

kash/utils/common/url.py

@@ -47,7 +47,9 @@ def check_if_url(
         if only_schemes:
             return result if result.scheme in only_schemes else None
         else:
-            return result if result.scheme != "" else None
+            # Consider it a URL if the scheme is present and longer than a single character.
+            # This helps avoid misinterpreting Windows drive letters (e.g., "C:\foo") as schemes.
+            return result if result.scheme and len(result.scheme) > 1 else None
     except ValueError:
         return None
 
@@ -145,6 +147,41 @@ def normalize_url(
     return Url(normalized_url)
 
 
+def is_valid_path(text: UnresolvedLocator) -> bool:
+    """
+    Sanity check if the input is plausibly a file path, i.e. not a URL or malformed in
+    an obvious way. Does not check for existence or OS-specific naming restrictions.
+    For a more thorough check there are other more complex options like:
+    https://github.com/thombashi/pathvalidate
+    """
+    if isinstance(text, Path):
+        return True
+    elif isinstance(text, str):
+        path_str = text
+    else:
+        return False
+
+    # Check for empty or whitespace-only strings or null characters
+    # (never acceptable paths).
+    if not path_str or path_str.isspace():
+        return False
+    if "\0" in path_str:
+        return False
+
+    # Explicitly disallow URLs.
+    if is_url(path_str):
+        return False
+
+    # As a final lightweight check, ensure it can be instantiated as a Path object
+    # This doesn't validate existence or character restrictions.
+    try:
+        _ = Path(path_str)
+    except (TypeError, ValueError):
+        return False
+
+    return True
+
+
 ## Tests
 
 
@@ -155,13 +192,19 @@ def test_is_url():
     assert is_url("ftp://example.com") == True
     assert is_url("file:///path/to/file") == True
     assert is_url("file://hostname/path/to/file") == True
-    assert is_url("invalid-url") == False
-    assert is_url("www.example.com") == False
     assert is_url("http://example.com", only_schemes=HTTP_ONLY) == True
     assert is_url("https://example.com", only_schemes=HTTP_ONLY) == True
+
+    assert is_url("invalid-url") == False
+    assert is_url("www.example.com") == False
     assert is_url("ftp://example.com", only_schemes=HTTP_ONLY) == False
     assert is_url("file:///path/to/file", only_schemes=HTTP_ONLY) == False
 
+    assert is_url("www.example.com") is False
+    assert is_url("c:\\path\\to\\file") is False
+    assert is_url("/foo/bar") is False
+    assert is_url("//foo") is False
+
 
 def test_as_file_url():
     assert as_file_url("file:///path/to/file") == "file:///path/to/file"
@@ -205,3 +248,37 @@ def test_normalize_url():
             str(e)
             == "Scheme 'ftp' not in allowed schemes: ['http', 'https', 'file']: ftp://example.com"
         )
+
+
+def test_is_path():
+    assert is_valid_path("foo/bar") is True
+    assert is_valid_path("/foo/bar") is True
+    assert is_valid_path("./foo/bar") is True
+    assert is_valid_path("../foo/bar") is True
+    assert is_valid_path("foo.txt") is True
+    assert is_valid_path(Path("foo/bar")) is True
+    assert is_valid_path(Path()) is True
+    assert is_valid_path(".") is True
+    assert is_valid_path("..") is True
+    assert is_valid_path("C:\\Users\\name") is True  # Windows-style
+    assert is_valid_path("file_with:colon.txt") is True  # Valid on POSIX
+    assert is_valid_path(Url("relative/path")) is True  # Url type with relative content
+
+    assert is_valid_path("http://example.com") is False
+    assert is_valid_path("https://example.com/path") is False
+    assert is_valid_path("file:///path/to/file") is False
+    assert is_valid_path(Url("http://example.com")) is False
+    assert is_valid_path("") is False
+    assert is_valid_path("  ") is False
+    assert is_valid_path("foo\0bar.txt") is False
+    assert is_valid_path(None) is False  # pyright: ignore
+    assert is_valid_path(123) is False  # pyright: ignore
+
+    # Edge cases
+    assert is_valid_path("www.example.com") is True  # No scheme
+    assert str(Path("")) == "."
+    assert str(Path(" ")) == " "
+    assert is_valid_path(Path(" ")) is True  # A bad idea but allowed
+    assert is_valid_path(Path("")) is True
+    assert is_valid_path(" ") is False
+    assert is_valid_path("") is False

kash/utils/file_utils/file_formats.py

@@ -11,9 +11,10 @@ from kash.config.logger import get_logger
 log = get_logger(__name__)
 
 
-def is_full_html_page(content: str) -> bool:
+def is_fullpage_html(content: str) -> bool:
     """
-    A full HTML document that is probably best rendered in a browser.
+    A full HTML document that is a full page (headers, footers, etc.) and
+    so probably best rendered in a browser.
     """
     return bool(re.search(r"<!DOCTYPE html>|<html>|<body>|<head>", content[:2048], re.IGNORECASE))
 

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, is_url, parse_file_url
+from kash.utils.common.url import is_valid_path
 from kash.utils.file_utils.file_ext import FileExt
 from kash.utils.file_utils.file_formats import (
     MIME_EMPTY,
@@ -143,7 +143,13 @@ class Format(Enum):
 
     @property
     def is_markdown(self) -> bool:
-        return self in [self.markdown, self.md_html]
+        """Is in pure Markdown (no HTML)."""
+        return self in [self.markdown]
+
+    @property
+    def is_markdown_with_html(self) -> bool:
+        """Is in Markdown with HTML."""
+        return self in [self.md_html]
 
     @property
     def is_html(self) -> bool:
@@ -406,15 +412,6 @@ class FileFormatInfo:
         return self.as_str()
 
 
-def _guess_format(file_ext: FileExt | None, mime_type: MimeType | None) -> Format | None:
-    format = None
-    if file_ext:
-        format = Format.guess_by_file_ext(file_ext)
-    if not format and mime_type:
-        format = Format.from_mime_type(mime_type)
-    return format
-
-
 def guess_format_by_name(path: str | Path) -> Format | None:
     """
     Fast guess of file format by the file name only.
@@ -423,22 +420,39 @@ def guess_format_by_name(path: str | Path) -> Format | None:
     return Format.guess_by_file_ext(file_ext) if file_ext else None
 
 
-def file_format_info(path: str | Path, always_check_content: bool = False) -> FileFormatInfo:
+def file_format_info(
+    path: str | Path,
+    suggested_mime_type: MimeType | None = None,
+) -> FileFormatInfo:
     """
     Get info on the file format path and content (file extension and file content).
     Looks at the file extension first and then the file content if needed.
-    If `always_check_content` is True, look at the file content even if we
-    recognize the file extension.
+    If `suggested_mime_type` is provided, it will be used as the detected mime type
+    instead of detecting it from the file content.
     """
+    if not is_valid_path(path):
+        raise ValueError(f"Expected a file path but got: {path!r}")
+
     path = Path(path)
     file_ext = parse_file_ext(path)
-    if always_check_content or not file_ext:
+    if not suggested_mime_type and not file_ext:
         # Look at the file content.
         detected_mime_type = detect_mime_type(path)
+    elif suggested_mime_type:
+        detected_mime_type = suggested_mime_type
     else:
         detected_mime_type = None
-    format = _guess_format(file_ext, detected_mime_type)
+
+    # Pick format first by file extension, then by detected mime type.
+    format = None
+    if file_ext:
+        format = Format.guess_by_file_ext(file_ext)
+    if not format and detected_mime_type:
+        format = Format.from_mime_type(detected_mime_type)
+
+    # Attempt to canonicalize the mime type to match the format.
     final_mime_type = format.mime_type if format else detected_mime_type
+
     return FileFormatInfo(file_ext, format, final_mime_type)
 
 
@@ -456,35 +470,3 @@ def detect_media_type(filename: str | Path) -> MediaType:
     fmt = detect_file_format(filename)
     media_type = fmt.media_type if fmt else MediaType.binary
     return media_type
-
-
-def choose_file_ext(
-    url_or_path: Url | Path | str, mime_type: MimeType | None = None
-) -> FileExt | None:
-    """
-    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.
-    """
-    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/web_content/local_file_cache.py

@@ -10,10 +10,17 @@ from funlog import log_if_modifies
 from prettyfmt import fmt_path
 from strif import atomic_output_file, copyfile_atomic
 
-from kash.utils.common.url import Url, is_file_url, is_url, normalize_url, parse_file_url
+from kash.utils.common.url import (
+    Url,
+    is_file_url,
+    is_url,
+    is_valid_path,
+    normalize_url,
+    parse_file_url,
+)
 from kash.utils.errors import FileNotFound
-from kash.utils.file_utils.file_formats import MimeType
-from kash.utils.file_utils.file_formats_model import choose_file_ext
+from kash.utils.file_utils.file_formats_model import file_format_info
+from kash.utils.file_utils.filename_parsing import parse_file_ext
 from kash.web_content.dir_store import DirStore
 from kash.web_content.web_fetch import HttpHeaders, download_url
 
@@ -91,9 +98,25 @@ class CacheResult:
     was_cached: bool
 
 
-def _suffix_for(cacheable: Cacheable, mime_type: MimeType | None = None) -> str | None:
+def _suffix_for(cacheable: Cacheable) -> str | None:
     key = cacheable.key if isinstance(cacheable, Loadable) else cacheable
-    file_ext = choose_file_ext(key, mime_type)
+
+    # Check for recognized file extensions on URLs and Paths.
+    filename_ext = parse_file_ext(str(key))
+    if filename_ext:
+        return filename_ext.dot_ext
+
+    # Handle local paths
+    if is_file_url(str(key)):
+        path = parse_file_url(str(key))
+    elif is_valid_path(str(key)):
+        path = Path(str(key))
+    else:
+        # A non-local path with no recognized extension.
+        return None
+
+    # If it's a local file, check the file content too.
+    file_ext = file_format_info(path).suggested_file_ext
     return file_ext.dot_ext if file_ext else None
 
 

{kash_shell-0.3.13.dist-info → kash_shell-0.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.13
+Version: 0.3.14
 Summary: The knowledge agent shell (core)
 Project-URL: Repository, https://github.com/jlevy/kash-shell
 Author-email: Joshua Levy <joshua@cal.berkeley.edu>

{kash_shell-0.3.13.dist-info → kash_shell-0.3.14.dist-info}/RECORD

@@ -4,10 +4,10 @@ kash/actions/__init__.py,sha256=a4pQw8O-Y3q5N4Qg2jUV0xEZLX6d164FQhZ6zizY9fE,1357
 kash/actions/core/assistant_chat.py,sha256=28G20cSr7Z94cltouTPve5TXY3km0lACrRvpLE27fK8,1837
 kash/actions/core/chat.py,sha256=yCannBFa0cSpR_in-XSSuMm1x2ZZQUCKmlqzhsUfpOo,2696
 kash/actions/core/format_markdown_template.py,sha256=ZJbtyTSypPo2ewLiGRSyIpVf711vQMhI_-Ng-FgCs80,2991
-kash/actions/core/markdownify.py,sha256=sCfPXQCylQjrVbZxeRR11kZ8CtFw-tMsUSrRT6gimVU,1190
-kash/actions/core/readability.py,sha256=C71mHruXDoTn0Y6Q5v5FnUfUn1Q4WVuWQ5PbOGpZEuk,985
-kash/actions/core/render_as_html.py,sha256=JdrVvMo3DC1xDQ1SXrTDCLzm3S-Z9V6SSrjG-_z5Stw,1826
-kash/actions/core/show_webpage.py,sha256=052HG80kSBP98qITp0gfKJ0G4PxGGS0o0N-L64JxWP0,889
+kash/actions/core/markdownify.py,sha256=KjdUeY4c9EhZ5geQrn22IoBv0P_p62q4zyyOYE0NRHM,1270
+kash/actions/core/readability.py,sha256=ljdB2rOpzfKU2FpEJ2UELIzcdOAWvdUjFsxoHRTE3xo,989
+kash/actions/core/render_as_html.py,sha256=bSyZdX9nZnP33QBdGSzWhInRREWXWayMG2oyiKn4rxw,1824
+kash/actions/core/show_webpage.py,sha256=Ggba9jkx9U-FZOcuL0lkS-SwtPNUyxVsGdeQrqwWs1s,887
 kash/actions/core/strip_html.py,sha256=FDLN_4CKB11q5cU4NixTf7PGrAq92AjQNbKAdvQDwCY,849
 kash/actions/core/summarize_as_bullets.py,sha256=Zwr8lNzL77pwpnW_289LQjNBijNDpTPANfFdOJA-PZ4,2070
 kash/actions/core/tabbed_webpage_config.py,sha256=rIbzEhBTmnkbSiRZC-Rj46T1J6c0jOztiKE9Usa4nsc,980
@@ -34,7 +34,7 @@ kash/commands/help/help_commands.py,sha256=eJTpIhXck123PAUq2k-D3Q6UL6IQ8atOVYurL
 kash/commands/help/logo.py,sha256=W8SUach9FjoTqpHZwTGS582ry4ZluxbBp86ZCiAtDkY,3505
 kash/commands/help/welcome.py,sha256=F4QBgj3e1dM9Pf0H4TSzCrkVfXQVKUIl0b6Qmofbdo4,905
 kash/commands/workspace/selection_commands.py,sha256=yr0fFPlFIJUPHyFni1byXz8UDvYstIw4oRpOMa8iOBo,7428
-kash/commands/workspace/workspace_commands.py,sha256=0dyZ2EkThWArW5MfSjGVottgXKtibKXAVfI41NGvsUM,24177
+kash/commands/workspace/workspace_commands.py,sha256=smPNGmY8y7gcmh0hAFOf4GYYMuNAoqkf3kRMJamYcMQ,24768
 kash/config/__init__.py,sha256=ytly9Typ1mWV4CXfV9G3CIPtPQ02u2rpZ304L3GlFro,148
 kash/config/capture_output.py,sha256=ud3uUVNuDicHj3mI_nBUBO-VmOrxtBdA3z-I3D1lSCU,2398
 kash/config/colors.py,sha256=6lqrB2RQYF2OLw-njfOqVHO9Bwiq7bW6K1ROCOAd1EM,9949
@@ -82,7 +82,7 @@ kash/embeddings/embeddings.py,sha256=v6RmrEHsx5PuE3fPrY15RK4fgW0K_VlNWDTjCVr11zY
 kash/embeddings/text_similarity.py,sha256=BOo9Vcs5oi2Zs5La56uTkPMHo65XSd4qz_yr6GTfUA4,1924
 kash/exec/__init__.py,sha256=rdSsKzTaXfSZmD5JvmUSSwmpfvl-moNv9PUgtE_WUpQ,1148
 kash/exec/action_decorators.py,sha256=VOSCnFiev2_DuFoSk0i_moejwM4wJ1j6QfsQd93uetI,16480
-kash/exec/action_exec.py,sha256=RXuTvsnkVqnE_PdbFqCWZ94morLUd06folT0lcmwCwk,18563
+kash/exec/action_exec.py,sha256=wndn9WsH9dGIzRjbiNCLfHHKZPlTzlFp-eogDvqkfbI,18500
 kash/exec/action_registry.py,sha256=numU9pH_W5RgIrYmfi0iYMYy_kLJl6vup8PMrhxAfdc,2627
 kash/exec/combiners.py,sha256=AJ6wgPUHsmwanObsUw64B83XzU26yuh5t4l7igLn82I,4291
 kash/exec/command_exec.py,sha256=zc-gWm7kyB5J5Kp8xhULQ9Jj9AL927KkDPXXk-Yr1Bw,1292
@@ -93,7 +93,7 @@ kash/exec/importing.py,sha256=xunmBapeUMNc6Zox7y6e_DZkidyWeouiFZpphajwSzc,1843
 kash/exec/llm_transforms.py,sha256=p_aLp70VoIgheW4v8uoweeuEVWj06AzQekvn_jM3B-g,4378
 kash/exec/precondition_checks.py,sha256=HymxL7qm4Yz8V76Um5pKdIRnQ2N-p9rpQQi1fI38bNA,2139
 kash/exec/precondition_registry.py,sha256=cmp0mUfLS42AbAByDhwGx8GWz9PuZNR7z5rPZW9WQE4,1244
-kash/exec/preconditions.py,sha256=yJSQ1MWnejxQHPH4ULb6mEPPsMUK_ViLkUaFMW09z_w,4375
+kash/exec/preconditions.py,sha256=kJXJQwqwsGBmzbrYy8s-soJeY8-gXx5ahbBPSqo7UvY,4965
 kash/exec/resolve_args.py,sha256=yGU6Jjzn5yyAN9pNZx8Qfc9oBrosFEdazIs5g9pjWTs,4410
 kash/exec/runtime_settings.py,sha256=aK6nGbZhKSIDVmV6AqV68hQkiaIGWnCiNzHtwwZ5V0w,3960
 kash/exec/shell_callable_action.py,sha256=x-Hs4EqpsZfKEcwhWkhc27HCIfoI91b-DrbG40BLxRY,4350
@@ -103,7 +103,7 @@ kash/exec_model/commands_model.py,sha256=iM8QhzA0tAas5OwF5liUfHtm45XIH1LcvCviuh3
 kash/exec_model/script_model.py,sha256=1VG3LhkTmlKzHOYouZ92ZpOSKSCcsz3-tHNcFMQF788,5031
 kash/exec_model/shell_model.py,sha256=LUhQivbpXlerM-DUzNY7BtctNBbn08Wto8CSSxQDxRU,568
 kash/file_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kash/file_storage/file_store.py,sha256=_Up5TkgnIekVfPZ4mCyhjMUxLtGL_GsAhcpo1m3-Dj0,28428
+kash/file_storage/file_store.py,sha256=sqhNFZtWDgaJbR8ah-yCYuaVbLKzs7XpAcYRfU9rtss,29425
 kash/file_storage/item_file_format.py,sha256=YAz7VqyfIoiSLQOoFdWsp-FI_2tTLXAPi8V8QXbo5ag,5475
 kash/file_storage/metadata_dirs.py,sha256=9AqO3S3SSY1dtvP2iLX--E4ui0VIzXttG8R040otfyg,3820
 kash/file_storage/persisted_yaml.py,sha256=4-4RkFqdlBUkTOwkdA4vRKUywEE9TaDo13OGaDUyU9M,1309
@@ -164,11 +164,11 @@ kash/model/compound_actions_model.py,sha256=HiDK5wwCu3WwZYHATZoLEguiqwR9V6V296wi
 kash/model/concept_model.py,sha256=we2qOcy9Mv1q7XPfkDLp_CyO_-8DwAUfUYlpgy_jrFs,1011
 kash/model/exec_model.py,sha256=IlfvtQyoFRRWhWju7vdXp9J-w_NGcGtL5DhDLy9gRd8,2250
 kash/model/graph_model.py,sha256=jnctrPiBZ0xwAR8D54JMAJPanA1yZdaxSFQoIpe8anA,2662
-kash/model/items_model.py,sha256=OZ88M15qp0m2OnUqu1pvrJrGrP-hANdXUVbCXdKKrqQ,34700
+kash/model/items_model.py,sha256=429FXlEsKxUFCqT_Z5t2zAFcfVEpjOGMdvz7q4hMEtw,34891
 kash/model/language_list.py,sha256=I3RIbxTseVmPdhExQimimEv18Gmy2ImMbpXe0-_t1Qw,450
 kash/model/llm_actions_model.py,sha256=a29uXVNfS2CiqvM7HPdC6H9A23rSQQihAideuBLMH8g,2110
 kash/model/media_model.py,sha256=64Zic4cRjQpgf_-tOuZlZZe59mz_qu0s6OQSU0YlDUI,3357
-kash/model/operations_model.py,sha256=dPgccwh6HwWhag_MkhEfEwByuZamcJEFrvq4w4NtrII,6112
+kash/model/operations_model.py,sha256=WmU-xeWGsqMLVN369dQEyVGU8T7G_KyLLsj6YFc5sVw,6517
 kash/model/params_model.py,sha256=qGhsGvtDQoSqWkrKk9QZZfEh-jO1q2V-s-p6X-F37_M,14939
 kash/model/paths_model.py,sha256=KDFm7wan7hjObHbnV2rR8-jsyLTVqbKcwFdKeLFRtdM,15889
 kash/model/preconditions_model.py,sha256=-IfsVR0NkQhq_3hUTXzK2bFYAd--3YjSwUiDKHVQQqk,2887
@@ -195,7 +195,7 @@ kash/shell/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kash/shell/ui/shell_results.py,sha256=mvFHxK_oz3bNfF5_Twt6VqDO44TA1b256Bjf5oco804,4130
 kash/shell/ui/shell_syntax.py,sha256=1fuDqcCV16AAWwWS4w4iT-tlSnl-Ywdrf68Ge8XIfmQ,751
 kash/shell/utils/exception_printing.py,sha256=UizjOkBPhW6YbkiFP965BE5FrCwn04MXGDbxyTuyvOk,1908
-kash/shell/utils/native_utils.py,sha256=FtIjjB1sOgNifTx1u7nKSAwg9A8wc9-fkACw2_xWnNg,9153
+kash/shell/utils/native_utils.py,sha256=pAiuqqrjfNTesdArSya6CVavKVsuAXOcX3_XAIQrWtE,9151
 kash/shell/utils/shell_function_wrapper.py,sha256=fgUuVhocYMKLkGJJQJOER5nFMAvM0ZVpfGu7iJPJI9s,7385
 kash/utils/__init__.py,sha256=4Jl_AtgRADdGORimWhYZwbSfQSpQ6SiexNIZzmbcngI,111
 kash/utils/errors.py,sha256=2lPL0fxI8pPOiDvjl0j-rvwY8uhmWetsrYYIc2-x1WY,3906
@@ -211,13 +211,13 @@ kash/utils/common/stack_traces.py,sha256=a2NwlK_0xxnjMCDC4LrQu7ueFylF-OImFG3bAAH
 kash/utils/common/task_stack.py,sha256=XkeBz3BwYY1HxxTqd3f7CulV0s61PePAKw1Irrtvf5o,4536
 kash/utils/common/type_utils.py,sha256=SJirXhPilQom_-OKkFToDLm_82ZwpjcNjRy8U1HaQ0Q,3829
 kash/utils/common/uniquifier.py,sha256=75OY4KIVF8u1eoO0FCPbEGTyVpPOtM-0ctoG_s_jahM,3082
-kash/utils/common/url.py,sha256=hEDC0ImO3DLvaPRflcmiUZ1wK_Ilsm6_9fLaG23sUfo,6515
+kash/utils/common/url.py,sha256=R_P-CkOUiFxVdo9COcaL7YFvFIoAULj5-XxvmlFLvzo,9416
 kash/utils/file_formats/chat_format.py,sha256=Onby7Zany1UQSUo_JzLs6MIfmoXViZeOAacRTMVe92M,11818
 kash/utils/file_utils/__init__.py,sha256=loL_iW0oOZs0mJ5GelBPptBcqzYKSWdsGcHrpRyxitQ,43
 kash/utils/file_utils/dir_info.py,sha256=HamMr58k_DanTLifj7A2JDxTGWXEZZx2pQuE6Hjcm8g,1856
 kash/utils/file_utils/file_ext.py,sha256=-H63vlrVI3pfE2Cn_9qF7-QLDaUIu_njc4TieNgAHSY,1860
-kash/utils/file_utils/file_formats.py,sha256=tmrmqM5YTxfvlpvqmeOVz0yVRuPxxIAkVZf1-D0fp5Y,4902
-kash/utils/file_utils/file_formats_model.py,sha256=pwCkt84xOmt2cvnPk4uB5lB6q9pKy_ARr-o4OE2t8A0,15801
+kash/utils/file_utils/file_formats.py,sha256=vnihRFLl85G1uzpqDc_uiGH9SIvbFTYVszz3srdSSz0,4949
+kash/utils/file_utils/file_formats_model.py,sha256=0rwWlkgMaZu5Ap7IFPt3poA1owdwFCfgGGtvu__15GY,15099
 kash/utils/file_utils/file_sort_filter.py,sha256=_k1chT3dJl5lSmKA2PW90KaoG4k4zftGdtwWoNEljP4,7136
 kash/utils/file_utils/file_walk.py,sha256=cpwVDPuaVm95_ZwFJiAdIuZAGhASI3gJ3ZUsCGP75b8,5527
 kash/utils/file_utils/filename_parsing.py,sha256=drHrH2B9W_5yAbXURNGJxNqj9GmTe8FayH6Gjw9e4-U,4194
@@ -241,7 +241,7 @@ kash/web_content/canon_url.py,sha256=Zv2q7xQdIHBFkxxwyJn3_ME-qqMFRi_fKxE_IgV2Z50
 kash/web_content/dir_store.py,sha256=BJc-s-RL5CC-GwhFTC_lhLXSMWluPPnLVmVBx-66DiM,3425
 kash/web_content/file_cache_utils.py,sha256=JRXUCAmrc83iAgdiICU2EYGWcoORflWNl6GAVq-O80I,5529
 kash/web_content/file_processing.py,sha256=cQC-MnJMM5qG9-y0S4yobkmRi6A75qhHjV6xTwbtYDY,1904
-kash/web_content/local_file_cache.py,sha256=zajvWajDx-TYMGn3p8-K4KZOo2C2PQOomQRLbT3808o,8968
+kash/web_content/local_file_cache.py,sha256=PEDKU5VIwhCnSC-HXG4EkO2OzrOUDuuDBMuo3lP2EN0,9466
 kash/web_content/web_extract.py,sha256=LbuG4AFEeIiXyUrN9CAxX0ret41Fqu_iTJSjIWyk3Bg,2296
 kash/web_content/web_extract_justext.py,sha256=74HLJBKDGKatwxyRDX6za70bZG9LrVmtj9jLX7UJzg4,2540
 kash/web_content/web_extract_readabilipy.py,sha256=IT7ET5IoU2-Nf37-Neh6CkKMvLL3WTNVJjq7ZMOx6OM,808
@@ -263,7 +263,6 @@ kash/workspaces/param_state.py,sha256=vT_eGWqg2SRviIM5jqEAauznX2B5Xt2nHHu2oRxTcI
 kash/workspaces/selections.py,sha256=rEUuQlrQ3C_54bzBSKDTTptgX8oZPqN0Ao4uaXSWA-Q,12003
 kash/workspaces/source_items.py,sha256=Pwnw3OhjR2IJEMEeHf6hpKloj-ellM5vsY7LgkGevRY,2861
 kash/workspaces/workspace_dirs.py,sha256=kjuY4t7mSSXq00fZmln7p9TWq4kAZoPTCDM0DG7uEaI,1545
-kash/workspaces/workspace_importing.py,sha256=4IJo713Kuoynhd_lcZF9M_DZ0rrMK_IDfhTVgwKmVyQ,1934
 kash/workspaces/workspace_output.py,sha256=MMg_KumkHKFGc0DOUFaW5ImpgqIfdlsLtvXbLEt1hwI,5692
 kash/workspaces/workspace_registry.py,sha256=SQt2DZgBEu95Zj9fpy67XdJPgJyKFDCU2laSuiZswNo,2200
 kash/workspaces/workspaces.py,sha256=kQyS3F57Y9A9xVT_Ss7HzJhDGlI-UXHKvRDnEVkBnik,6764
@@ -280,8 +279,8 @@ kash/xonsh_custom/xonsh_modern_tools.py,sha256=mj_b34LZXfE8MJe9EpDmp5JZ0tDM1biYN
 kash/xonsh_custom/xonsh_ranking_completer.py,sha256=ZRGiAfoEgqgnlq2-ReUVEaX5oOgW1DQ9WxIv2OJLuTo,5620
 kash/xontrib/fnm.py,sha256=V2tsOdmIDgbFbZSfMLpsvDIwwJJqiYnOkOySD1cXNXw,3700
 kash/xontrib/kash_extension.py,sha256=JRRJC3cZSMOl4sSWEdKAQ_dVRMubWaOltKr8G0dWt6Y,1876
-kash_shell-0.3.13.dist-info/METADATA,sha256=X_tk6xWJni7Il0DKb_fAD8VCQR4D6y64XFyy5VZNap4,31258
-kash_shell-0.3.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kash_shell-0.3.13.dist-info/entry_points.txt,sha256=SQraWDAo8SqYpthLXThei0mf_hGGyhYBUO-Er_0HcwI,85
-kash_shell-0.3.13.dist-info/licenses/LICENSE,sha256=rCh2PsfYeiU6FK_0wb58kHGm_Fj5c43fdcHEexiVzIo,34562
-kash_shell-0.3.13.dist-info/RECORD,,
+kash_shell-0.3.14.dist-info/METADATA,sha256=w_L4jxifwPdsDvYqMRJZSbhc3u9bV5mYORRcbXHDj9k,31258
+kash_shell-0.3.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kash_shell-0.3.14.dist-info/entry_points.txt,sha256=SQraWDAo8SqYpthLXThei0mf_hGGyhYBUO-Er_0HcwI,85
+kash_shell-0.3.14.dist-info/licenses/LICENSE,sha256=rCh2PsfYeiU6FK_0wb58kHGm_Fj5c43fdcHEexiVzIo,34562
+kash_shell-0.3.14.dist-info/RECORD,,

kash/workspaces/workspace_importing.py

@@ -1,56 +0,0 @@
-from pathlib import Path
-
-from kash.config.logger import get_logger
-from kash.file_storage.file_store import FileStore
-from kash.model.items_model import Item, ItemType
-from kash.model.paths_model import StorePath
-from kash.utils.common.url import Locator, Url, is_url
-from kash.utils.errors import InvalidInput
-from kash.utils.file_utils.file_formats_model import Format
-from kash.web_content.canon_url import canonicalize_url
-
-# TODO: Clean this up, move into FileStore.
-
-log = get_logger(__name__)
-
-
-def import_url(ws: FileStore, url: Url) -> Item:
-    """
-    Import a URL as a resource. Does not fetch metadata.
-    """
-    canon_url = canonicalize_url(url)
-    log.message(
-        "Importing URL: %s%s", canon_url, f" canonicalized from {url}" if url != canon_url else ""
-    )
-    item = Item(ItemType.resource, url=canon_url, format=Format.url)
-    # No need to overwrite any resource we already have for the identical URL.
-    store_path = ws.save(item, skip_dup_names=True)
-    # Load to fill in any metadata we may already have.
-    item = ws.load(store_path)
-    return item
-
-
-def import_and_load(ws: FileStore, locator: Locator | str) -> Item:
-    """
-    Ensure that a URL or file path is imported into the workspace and
-    return the Item.
-    """
-
-    if isinstance(locator, str) and is_url(locator):
-        log.message("Importing locator as URL: %r", locator)
-        item = import_url(ws, Url(locator))
-    else:
-        if isinstance(locator, StorePath):
-            log.info("Locator is in the file store: %r", locator)
-            # It's already a StorePath.
-            item = ws.load(locator)
-        else:
-            log.info("Importing locator as local path: %r", locator)
-            path = Path(locator)
-            if not path.exists():
-                raise InvalidInput(f"File not found: {path}")
-
-            store_path = ws.import_item(path)
-            item = ws.load(store_path)
-
-    return item