euporie 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

euporie/core/comm/ipywidgets.py

@@ -41,7 +41,7 @@ from euporie.core.widgets.forms import (
 from euporie.core.widgets.layout import AccordionSplit, ReferencedSplit, TabbedSplit
 
 if TYPE_CHECKING:
-    from typing import Any, Iterable, Sequence
+    from typing import Any, Iterable, MutableSequence, Sequence
 
     from prompt_toolkit.buffer import Buffer
     from prompt_toolkit.formatted_text.base import AnyFormattedText
@@ -66,7 +66,7 @@ def _separate_buffers(
     substate: dict | list | tuple,
     path: list[str | int],
     buffer_paths: list[list[str | int]],
-    buffers: list[memoryview | bytearray | bytes],
+    buffers: MutableSequence[memoryview | bytearray | bytes],
 ) -> dict | list | tuple:
     """Remove binary types from dicts and lists, but keep track of their paths.
 
@@ -118,7 +118,7 @@ def _separate_buffers(
                     cloned_substrate[k] = vnew
     else:
         raise ValueError("expected state to be a list or dict, not %r" % substate)
-    return cloned_substrate or substate
+    return cloned_substrate if cloned_substrate is not None else substate
 
 
 class IpyWidgetComm(Comm, metaclass=ABCMeta):
@@ -190,7 +190,7 @@ class IpyWidgetComm(Comm, metaclass=ABCMeta):
             "model_module": state.get("_model_module"),
             "model_module_version": state.get("_model_module_version"),
             "state": {
-                **{key: value for key, value in state.items()},
+                **dict(state.items()),
                 "buffers": [
                     {
                         "encoding": "base64",
@@ -292,7 +292,7 @@ class OutputModel(IpyWidgetComm):
 
 
 class LayoutIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
-    """Bae class for layout widgets with children."""
+    """Base class for layout widgets with children."""
 
     def render_children(
         self, models: list[str], parent: OutputParent
@@ -644,7 +644,7 @@ class FloatLogOptionsMixin(FloatOptionsMixin):
 
 
 class SliderIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
-    """Bae class for slider ipywidgets."""
+    """Base class for slider ipywidgets."""
 
     def normalize(self, x: Any) -> Any:
         """Convert the internal widget's value to one compatible with the ipywidget."""
@@ -722,7 +722,7 @@ class SliderIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
 
 
 class RangeSliderIpyWidgetComm(SliderIpyWidgetComm):
-    """Bae class for range slider ipywidgets."""
+    """Base class for range slider ipywidgets."""
 
     @property
     def indices(self) -> list[int]:
@@ -773,7 +773,7 @@ class FloatRangeSliderModel(FloatOptionsMixin, RangeSliderIpyWidgetComm):
 
 
 class NumberTextBoxIpyWidgetComm(TextBoxIpyWidgetComm, metaclass=ABCMeta):
-    """Bae class for text-box ipywidgets with numerical values."""
+    """Base class for text-box ipywidgets with numerical values."""
 
     def create_view(self, parent: OutputParent) -> CommView:
         """Create a new view of the numerical text-box ipywidget."""
@@ -899,7 +899,7 @@ class FloatProgressModel(FloatOptionsMixin, ProgressIpyWidgetComm):
 
 
 class ToggleableIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
-    """Bae class for toggleable ipywidgets."""
+    """Base class for toggleable ipywidgets."""
 
     def normalize(self, x: Any) -> float | None:
         """Cat the container's selected value to a bool if possible."""
@@ -994,7 +994,7 @@ class ValidModel(ToggleableIpyWidgetComm):
 
 
 class SelectableIpyWidgetComm(IpyWidgetComm, metaclass=ABCMeta):
-    """Bae class for selectable ipywidgets."""
+    """Base class for selectable ipywidgets."""
 
     def update_index(self, container: SelectableWidget) -> None:
         """Send a ``comm_message`` updating the selected index when it changes."""
@@ -1098,7 +1098,7 @@ class SelectMultipleModel(IpyWidgetComm):
             options=self.data["state"].get("_options_labels", []),
             indices=self.data["state"]["index"],
             on_change=self.update_index,
-            style="class:select,face",
+            style="class:select",
             multiple=True,
             rows=self.data["state"]["rows"],
             disabled=Condition(lambda: self.data["state"].get("disabled", False)),

euporie/core/comm/registry.py

@@ -8,11 +8,13 @@ from euporie.core.comm.base import UnimplementedComm
 from euporie.core.comm.ipywidgets import open_comm_ipywidgets
 
 if TYPE_CHECKING:
-    from typing import Any, Sequence
+    from typing import Any, Callable, Sequence
 
     from euporie.core.comm.base import Comm, KernelTab
 
-TARGET_CLASSES = {"jupyter.widget": open_comm_ipywidgets}
+TARGET_CLASSES: dict[str, Callable[[KernelTab, str, dict, Sequence[bytes]], Comm]] = {
+    "jupyter.widget": open_comm_ipywidgets
+}
 
 
 def open_comm(
@@ -36,8 +38,12 @@ def open_comm(
     """
     target_name = content.get("target_name", "")
     return TARGET_CLASSES.get(target_name, UnimplementedComm)(
-        comm_container=comm_container,
-        comm_id=str(content.get("comm_id")),
-        data=content.get("data", {}),
-        buffers=buffers,
+        # comm_container=
+        comm_container,
+        # comm_id=
+        str(content.get("comm_id")),
+        # data=
+        content.get("data", {}),
+        # buffers=
+        buffers,
     )

euporie/core/commands.py

@@ -16,18 +16,26 @@ from euporie.core.key_binding.utils import parse_keys
 from euporie.core.keys import Keys
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Coroutine, Sequence
+    from typing import Any, Callable, Coroutine
 
     from prompt_toolkit.filters import Filter, FilterOrBool
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
         KeyHandlerCallable,
+        NotImplementedOrNone,
     )
 
     from euporie.core.widgets.menu import MenuItem
 
     AnyKey = tuple[Keys | str, ...] | Keys | str
     AnyKeys = list[AnyKey] | AnyKey
+    CommandHandlerNoArgs = Callable[
+        ..., Coroutine[Any, Any, None] | NotImplementedOrNone
+    ]
+    CommandHandlerArgs = Callable[
+        [KeyPressEvent], Coroutine[Any, Any, None] | NotImplementedOrNone
+    ]
+    CommandHandler = CommandHandlerNoArgs | CommandHandlerArgs
 
 log = logging.getLogger(__name__)
 
@@ -37,7 +45,7 @@ class Command:
 
     def __init__(
         self,
-        handler: Callable[..., Coroutine[Any, Any, None] | None],
+        handler: CommandHandler,
         *,
         filter: FilterOrBool = True,
         hidden: FilterOrBool = False,
@@ -98,9 +106,6 @@ class Command:
 
         self.keys: list[tuple[str | Keys, ...]] = []
 
-        self.selected_item = 0
-        self.children: Sequence[MenuItem] = []
-
     def run(self) -> None:
         """Run the command's handler."""
         if self.filter():
@@ -117,28 +122,28 @@ class Command:
     @property
     def key_handler(self) -> KeyHandlerCallable:
         """Return a key handler for the command."""
-        sig = signature(self.handler)
+        handler = self.handler
+        sig = signature(handler)
 
         if sig.parameters:
             # The handler already accepts a `KeyPressEvent` argument
-            return cast("KeyHandlerCallable", self.handler)
+            return cast("KeyHandlerCallable", handler)
+
+        if isawaitable(handler):
 
-        def _key_handler(event: KeyPressEvent) -> None:
-            result = self.handler()
-            # If the handler is a coroutine, create an asyncio task.
-            if isawaitable(result):
-                awaitable = result
+            async def _key_handler_async(event: KeyPressEvent) -> NotImplementedOrNone:
+                result = cast("CommandHandlerNoArgs", handler)()
+                assert isawaitable(result)
+                return await result
 
-                async def bg_task() -> None:
-                    result = await awaitable
-                    if result != NotImplemented:
-                        event.app.invalidate()
+            return _key_handler_async
+
+        else:
 
-                event.app.create_background_task(bg_task())
-            elif result != NotImplemented:
-                event.app.invalidate()
+            def _key_handler(event: KeyPressEvent) -> NotImplementedOrNone:
+                return cast("CommandHandlerNoArgs", handler)()
 
-        return _key_handler
+            return _key_handler
 
     def bind(self, key_bindings: KeyBindingsBase, keys: AnyKeys) -> None:
         """Add the current commands to a set of key bindings.
@@ -173,16 +178,18 @@ class Command:
     @property
     def menu_handler(self) -> Callable[[], None]:
         """Return a menu handler for the command."""
-        if isawaitable(self.handler):
+        handler = self.handler
+        if isawaitable(handler):
 
             def _menu_handler() -> None:
-                task = self.handler()
+                task = cast("CommandHandlerNoArgs", handler)()
+                task = cast("Coroutine[Any, Any, None]", task)
                 if task is not None:
                     get_app().create_background_task(task)
 
             return _menu_handler
         else:
-            return cast("Callable[[], None]", self.handler)
+            return cast("Callable[[], None]", handler)
 
     @property
     def menu(self) -> MenuItem:

euporie/core/completion.py

@@ -41,8 +41,5 @@ class KernelCompleter(Completer):
             cursor_pos=document.cursor_position,
         ):
             if completion_type := kwargs.get("display_meta"):
-                kwargs["style"] = f"class:completion-menu.completion.{completion_type}"
-                kwargs[
-                    "selected_style"
-                ] = f"class:completion-menu.completion.current.{completion_type}"
+                kwargs["style"] = f"class:completion-{completion_type}"
             yield Completion(**kwargs)

euporie/core/config.py

@@ -6,6 +6,7 @@ import argparse
 import json
 import logging
 import os
+import sys
 from ast import literal_eval
 from collections import ChainMap
 from functools import partial
@@ -13,7 +14,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Protocol, TextIO, cast
 
 import fastjsonschema
-from appdirs import user_config_dir
+from platformdirs import user_config_dir
 from prompt_toolkit.filters.base import Condition
 from prompt_toolkit.filters.utils import to_filter
 from prompt_toolkit.utils import Event
@@ -21,7 +22,6 @@ from upath import UPath
 
 from euporie.core import __app_name__, __copyright__, __version__
 from euporie.core.commands import add_cmd, get_cmd
-from euporie.core.log import setup_logs
 
 if TYPE_CHECKING:
     from typing import IO, Any, Callable, Optional, Sequence
@@ -339,6 +339,8 @@ class Config:
 
     def load(self, cls: type[ConfigurableApp]) -> None:
         """Load the command line, environment, and user configuration."""
+        from euporie.core.log import setup_logs
+
         self.app_cls = cls
         self.app_name = cls.name
         log.debug("Loading config for %s", self.app_name)
@@ -416,7 +418,11 @@ class Config:
     def load_args(self) -> dict[str, Any]:
         """Attempt to load configuration settings from commandline flags."""
         result = {}
-        namespace, _ = self.load_parser().parse_known_intermixed_args()
+        # Parse known arguments
+        namespace, remainder = self.load_parser().parse_known_intermixed_args()
+        # Update argv to leave the remaining arguments for subsequent apps
+        sys.argv[1:] = remainder
+        # Validate arguments
         for name, value in vars(namespace).items():
             if value is not None:
                 # Convert to json and back to attain json types
@@ -508,17 +514,21 @@ class Config:
             results.update(json_data)
         return results
 
-    def get(self, name: str) -> Any:
+    def get(self, name: str, default: Any = None) -> Any:
         """Access a configuration value, falling back to the default value if unset.
 
         Args:
             name: The name of the attribute to access.
+            default: The value to return if the name is not found
 
         Returns:
             The configuration variable value.
 
         """
-        return self.settings[name].value
+        if name in self.settings:
+            return self.settings[name].value
+        else:
+            return default
 
     def get_item(self, name: str) -> Any:
         """Access a configuration item.

euporie/core/convert/{base.py → core.py}

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 import mimetypes
-from functools import partial
+from functools import lru_cache, partial
 from typing import TYPE_CHECKING, NamedTuple
 
 from prompt_toolkit.cache import FastDictCache, SimpleCache
@@ -12,7 +12,10 @@ from prompt_toolkit.filters import to_filter
 from upath import UPath
 from upath.implementations.http import HTTPPath
 
+from euporie.core.path import DataPath
+
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable, Iterable
 
     from prompt_toolkit.filters import Filter, FilterOrBool
@@ -44,19 +47,71 @@ ERROR_OUTPUTS = {
     "formatted_text": [("fg:white bg:darkred", "(Format Conversion Error)")],
 }
 
-# def get_mime(path: "UPath") -> "str":
-# If http, do HEAD request and check "content-type" header
-# If data:// uri, mime is given in the path
-# If file has extension, guess from filename
-# Else try using python-magic
-# >>> import magic
-# >>> magic.from_buffer(open("testdata/test.pdf", "rb").read(2048))
-# 'PDF document, version 1.2'
-# >>> magic.from_file("testdata/test.pdf", mime=True)
-# 'application/pdf'
+
+@lru_cache
+def get_mime(path: Path | str) -> str | None:
+    """Attempt to determine the mime-type of a path."""
+    if isinstance(path, str):
+        path = UPath(path)
+    try:
+        path = path.resolve()
+    except Exception:
+        log.debug("Cannot resolve '%s'", path)
+
+    mime = None
+
+    # Read from path of data URI
+    if isinstance(path, DataPath):
+        mime = path._mime
+
+    # Guess from file-extension
+    if not mime and path.suffix:
+        # Check for Jupyter notebooks by extension
+        if path.suffix == ".ipynb":
+            return "application/x-ipynb+json"
+        else:
+            mime, _ = mimetypes.guess_type(path)
+
+    # Try using magic
+    if not mime:
+        try:
+            import magic
+        except ModuleNotFoundError:
+            pass
+        else:
+            with path.open(mode="rb") as f:
+                mime = magic.from_buffer(f.read(2048), mime=True)
+
+    # If we have a web-address, nsure we have a url
+    # Check http-headers and nsure we have a url
+    if not mime and isinstance(path, HTTPPath) and path._url is not None:
+        from fsspec.asyn import sync
+
+        # Get parsed url
+        url = path._url.geturl()
+        # Get the fsspec fs
+        fs = path._accessor._fs
+        # Ensure we have a session
+        session = sync(fs.loop, fs.set_session)
+        # Use HEAD requests if the server allows it, falling back to GETs
+        for method in (session.head, session.get):
+            r = sync(fs.loop, method, url, allow_redirects=True)
+            try:
+                r.raise_for_status()
+            except Exception:
+                log.debug("Request failed: %s", r)
+                continue
+            else:
+                content_type = r.headers.get("Content-Type")
+                if content_type is not None:
+                    mime = content_type.partition(";")[0]
+                    break
+
+    return mime
 
 
-def get_format(path: UPath | str, default: str = "") -> str:
+@lru_cache
+def get_format(path: Path | str, default: str = "") -> str:
     """Attempt to guess the format of a path."""
     if isinstance(path, str):
         path = UPath(path)
@@ -65,7 +120,7 @@ def get_format(path: UPath | str, default: str = "") -> str:
             default = "html"
         else:
             default = "ansi"
-    mime, _ = mimetypes.guess_type(path)
+    mime = get_mime(path)
     return MIME_FORMATS.get(mime, default) if mime else default
 
 
@@ -144,7 +199,7 @@ def find_route(from_: str, to: str) -> list | None:
                     for step_a, step_b in zip(chain, chain[1:])
                 ]
             ),
-        )[0]
+        )
     else:
         return None
 
@@ -162,7 +217,7 @@ def convert(
     rows: int | None = None,
     fg: str | None = None,
     bg: str | None = None,
-    path: UPath | None = None,
+    path: Path | None = None,
 ) -> Any:
     """Convert between formats."""
     try:
@@ -179,49 +234,55 @@ def convert(
         rows: int | None = None,
         fg: str | None = None,
         bg: str | None = None,
-        path: UPath | None = None,
+        path: Path | None = None,
     ) -> Any:
         if from_ == to:
             return data
-        route = _CONVERTOR_ROUTE_CACHE[(from_, to)]
-        # log.debug("Converting from '%s' to '%s' using route: %s", from_, to, route)
-        if route is None:
+        routes = _CONVERTOR_ROUTE_CACHE[(from_, to)]
+        log.debug("Converting from '%s' to '%s' using route: %s", from_, to, routes)
+        if not routes:
             raise NotImplementedError(f"Cannot convert from `{from_}` to `{to}`")
         output: Any = data
-        for stage_a, stage_b in zip(route, route[1:]):
-            # Find converter with lowest weight
-            func = sorted(
-                [
-                    conv
-                    for conv in converters[stage_b][stage_a]
-                    if _FILTER_CACHE.get((conv,), conv.filter_)
-                ],
-                key=lambda x: x.weight,
-            )[0].func
-            # Add intermediate steps to the cache
-            try:
-                output_hash = hash(data)
-            except TypeError as error:
-                log.warning("Cannot hash %s", data)
-                raise error
-            try:
-                output = _CONVERSION_CACHE.get(
-                    (output_hash, from_, stage_b, cols, rows, fg, bg, path),
-                    partial(func, output, cols, rows, fg, bg, path),
-                )
-            except Exception:
-                output = None
-            if output is None:
-                log.error(
-                    "Failed to convert `%s` from `%s`"
-                    " to `%s` using route `%s` at stage `%s`",
-                    data.__repr__()[:10],
-                    from_,
-                    to,
-                    route,
-                    stage_b,
-                )
-                output = ERROR_OUTPUTS.get(to, b"(Conversion Error)")
+        for route in routes:
+            for stage_a, stage_b in zip(route, route[1:]):
+                # Find converter with lowest weight
+                func = sorted(
+                    [
+                        conv
+                        for conv in converters[stage_b][stage_a]
+                        if _FILTER_CACHE.get((conv,), conv.filter_)
+                    ],
+                    key=lambda x: x.weight,
+                )[0].func
+                # Add intermediate steps to the cache
+                try:
+                    output_hash = hash(data)
+                except TypeError as error:
+                    log.warning("Cannot hash %s", data)
+                    raise error
+                try:
+                    output = _CONVERSION_CACHE.get(
+                        (output_hash, from_, stage_b, cols, rows, fg, bg, path),
+                        partial(func, output, cols, rows, fg, bg, path),
+                    )
+                except Exception:
+                    log.exception("An error occurred during format conversion")
+                    output = None
+                if output is None:
+                    log.error(
+                        "Failed to convert `%s` from `%s`"
+                        " to `%s` using route `%s` at stage `%s`",
+                        data.__repr__()[:10],
+                        from_,
+                        to,
+                        route,
+                        stage_b,
+                    )
+                    # Try the next route on error
+                    break
+            else:
+                # If this route succeeded, stop trying routes
+                break
         return output
 
     data = _CONVERSION_CACHE.get(
@@ -229,4 +290,7 @@ def convert(
         partial(_convert, data, from_, to, cols, rows, fg, bg, path),
     )
 
+    if data is None:
+        data = ERROR_OUTPUTS.get(to, b"(Conversion Error)")
+
     return data