euporie 2.8.4__py3-none-any.whl → 2.8.6__py3-none-any.whl

euporie/core/utils.py

@@ -2,15 +2,17 @@
 
 from __future__ import annotations
 
-import contextvars
+from collections.abc import Sequence
+from functools import cache
 from itertools import chain
-from threading import Thread
-from typing import TYPE_CHECKING, Sequence, TypeVar, overload
+from typing import TYPE_CHECKING, TypeVar, overload
 
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Iterable
+    from collections.abc import Iterable
+    from types import ModuleType
+    from typing import Callable
 
     from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.mouse_handlers import MouseHandler
@@ -74,16 +76,91 @@ def on_click(func: Callable) -> MouseHandler:
     return _mouse_handler
 
 
-def run_in_thread_with_context(
-    func: Callable, *args: Any, daemon: bool = True, **kwargs: Any
-) -> None:
-    """Run a function in an thread, but make sure it uses the same contextvars.
+@cache
+def root_module(name: str) -> ModuleType:
+    """Find and load the root module of a given module name by traversing up the module hierarchy.
 
-    This is required so that the function will see the right application.
+    This function walks up the module hierarchy until it finds the topmost parent module
+    that has a valid location. It uses Python's importlib machinery to inspect module
+    specifications and load modules.
+
+    Args:
+        name: The name of the module to find the root for (e.g., 'package.subpackage.module')
+
+    Returns:
+        The loaded root module object
+
+    Example:
+        >>> root = root_module("django.contrib.admin")
+        >>> print(root.__name__)
+        'django'
+
+    Note:
+        The function is cached using lru_cache to improve performance for repeated lookups.
+        The function handles both regular packages and frozen modules.
+    """
+    from importlib.util import find_spec, module_from_spec
+
+    if spec := find_spec(name):
+        while True:
+            if spec.name == spec.parent:
+                try:
+                    parent = find_spec("..", spec.parent)
+                except ImportError:
+                    break
+            elif spec.parent is not None:
+                parent = find_spec(spec.parent)
+            if (spec and not spec.parent) or (parent and not parent.has_location):
+                break
+            if parent:
+                spec = parent
+        if spec.loader:
+            module = module_from_spec(spec)
+            spec.loader.exec_module(module)
+            return module
+    raise ModuleNotFoundError(name=name)
+
+
+@cache
+def import_submodules(root: ModuleType, names: tuple[str]) -> list[ModuleType]:
+    """Import all submodules with a specific name within a root module's package hierarchy.
+
+    This function walks through all packages under the given root module and imports
+    any submodules that match the specified name. It handles various module types
+    including regular packages, single file modules, and frozen modules.
+
+    Args:
+        root: The root module object to search within
+        names: The specific submodule name to search for
+
+    Returns:
+        A list of imported module objects matching the specified name
+
+    Example:
+        >>> root = import_module("django")
+        >>> admin_modules = import_submodules(root, "admin")
+        >>> print([m.__name__ for m in admin_modules])
+        ['django.contrib.admin', 'django.contrib.gis.admin']
+
+    Note:
+        - The function is cached using lru_cache to improve performance for repeated imports
+        - For packages, it searches through __path__
+        - For single file modules, it uses __file__
+        - For frozen modules, it uses the module specification's origin
     """
-    Thread(
-        target=contextvars.copy_context().run,
-        args=(func, *args),
-        kwargs=kwargs,
-        daemon=daemon,
-    ).start()
+    from importlib import import_module
+    from pkgutil import walk_packages
+
+    if hasattr(root, "__path__"):
+        path = root.__path__
+    elif hasattr(root, "__file__"):
+        path = [root.__file__] if root.__file__ else []
+    else:
+        # For frozen modules, we need to create a special path
+        spec = root.__spec__
+        path = [spec.origin] if spec and spec.origin else []
+    return [
+        import_module(module_name)
+        for _loader, module_name, _is_pkg in walk_packages(path, f"{root.__name__}.")
+        if module_name.rpartition(".")[2] in names
+    ]

euporie/core/validation.py

@@ -9,7 +9,7 @@ from prompt_toolkit.validation import ValidationError, Validator
 if TYPE_CHECKING:
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel import Kernel
+    from euporie.core.kernel.client import Kernel
 
 
 class KernelValidator(Validator):

euporie/core/widgets/_settings.py

@@ -0,0 +1,188 @@
+"""Defines widget settings."""
+
+from prompt_toolkit.filters import buffer_has_focus
+
+from euporie.core.app.current import get_app
+from euporie.core.config import add_setting
+
+# euporie.core.widgets.cell_outputs:CellOutputArea
+
+add_setting(
+    name="wrap_cell_outputs",
+    group="euporie.core.widgets.cell_outputs",
+    title="wrap cell outputs",
+    flags=["--wrap-cell-outputs"],
+    type_=bool,
+    help_="Wrap cell output text.",
+    default=False,
+    schema={"type": "boolean"},
+    description="""
+        Whether text-based cell outputs should be wrapped.
+    """,
+    cmd_filter=~buffer_has_focus,
+)
+
+# euporie,core.widgets.file_browser:FileBrowser
+
+add_setting(
+    name="show_file_icons",
+    group="euporie.core.widgets.file_browser",
+    flags=["--show-file-icons"],
+    type_=bool,
+    title="File icons",
+    help_="Show file icons in the file manager",
+    default=False,
+    schema={
+        "type": "boolean",
+    },
+    description="""
+        Whether file icons should be shown in the file manager.
+
+        These icons exist in the unicode private use area, and may require custom
+        fonts such as ``awesome-terminal-fonts`` or ``nerdfonts`` to be installed.
+    """,
+)
+
+# euporie.core.widgets.inputs:KernelInput
+
+add_setting(
+    name="line_numbers",
+    group="euporie.core.widgets.inputs",
+    flags=["--line-numbers"],
+    type_=bool,
+    help_="Show or hide line numbers",
+    default=True,
+    description="""
+        Whether line numbers are shown by default.
+    """,
+    hooks=[lambda x: get_app().refresh()],
+)
+
+add_setting(
+    name="autoformat",
+    group="euporie.core.widgets.inputs",
+    flags=["--autoformat"],
+    type_=bool,
+    help_="Automatically re-format code cells when run",
+    default=False,
+    description="""
+        Whether to automatically reformat code cells before they are run.
+    """,
+)
+
+add_setting(
+    name="autocomplete",
+    group="euporie.core.widgets.inputs",
+    flags=["--autocomplete"],
+    type_=bool,
+    help_="Provide completions suggestions automatically",
+    default=False,
+    description="""
+        Whether to automatically suggestion completions while typing in code cells.
+    """,
+)
+
+add_setting(
+    name="autosuggest",
+    group="euporie.core.widgets.inputs",
+    flags=["--autosuggest"],
+    type_=bool,
+    help_="Provide line completion suggestions",
+    default=True,
+    description="""
+        Whether to automatically suggestion line content while typing in code cells.
+    """,
+)
+
+add_setting(
+    name="autoinspect",
+    group="euporie.core.widgets.inputs",
+    flags=["--autoinspect"],
+    type_=bool,
+    help_="Display contextual help automatically",
+    default=False,
+    description="""
+        Whether to automatically display contextual help when navigating through code cells.
+    """,
+)
+
+
+# euporie.core.bars.status:StatusBar
+
+add_setting(
+    name="show_status_bar",
+    group="euporie.core.bars.status",
+    flags=["--show-status-bar"],
+    type_=bool,
+    title="status bar",
+    help_="Show the status bar",
+    default=True,
+    schema={
+        "type": "boolean",
+    },
+    description="""
+        Whether the status bar should be shown at the bottom of the screen.
+    """,
+)
+
+# euporie.core.widgets.decor:
+
+add_setting(
+    name="show_shadows",
+    group="euporie.core.widgets.decor",
+    flags=["--show-shadows"],
+    type_=bool,
+    help_="Show or hide shadows under menus and dialogs",
+    default=True,
+    description="""
+        Sets whether shadows are shown under dialogs and popup-menus.
+    """,
+)
+
+# euporie.core.widgets.cell
+
+add_setting(
+    name="show_cell_borders",
+    group="euporie.core.widgets.cell",
+    title="cell borders",
+    flags=["--show-cell-borders"],
+    type_=bool,
+    help_="Show or hide cell borders.",
+    default=False,
+    schema={
+        "type": "boolean",
+    },
+    description="""
+        Whether cell borders should be drawn for unselected cells.
+    """,
+)
+
+add_setting(
+    name="external_editor",
+    group="euporie.core.widgets.cell",
+    flags=["--external-editor"],
+    type_=str,
+    help_="Set the external editor to use.",
+    default=None,
+    description="""
+        A command to run when editing cells externally. The following strings in
+        the command will be replaced with values which locate the cell being
+        edited:
+
+        * ``{top}``
+        * ``{left}``
+        * ``{bottom}``
+        * ``{right}``
+        * ``{width}``
+        * ``{height}``
+
+        This is useful if you run euporie inside a tmux session, and wish to launch
+        your editor in a pop-up pane. This can be achieved by setting this parameter
+        to something like the following:
+
+        .. code-block::
+
+           "tmux display-popup -x {left} -y {bottom} -w {width} -h {height} -B -E micro"
+
+    """,
+)

euporie/core/widgets/cell.py

@@ -27,10 +27,9 @@ from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.utils import Event
 
+from euporie.core.app.current import get_app
 from euporie.core.border import NoLine, ThickLine, ThinLine
 from euporie.core.completion import DeduplicateCompleter, LspCompleter
-from euporie.core.config import add_setting
-from euporie.core.current import get_app
 from euporie.core.diagnostics import Report
 from euporie.core.filters import multiple_cells_selected
 from euporie.core.format import LspFormatter
@@ -173,7 +172,7 @@ class Cell:
         # Now we generate the main container used to represent a kernel_tab cell
 
         source_hidden = Condition(
-            lambda: weak_self.json["metadata"]
+            lambda: weak_self.json.get("metadata", {})
             .get("jupyter", {})
             .get("source_hidden", False)
         )
@@ -219,6 +218,23 @@ class Cell:
 
             return _inner
 
+        # @lru_cache(maxsize=None)
+        # def _cell_border_char(
+        #     name: str,
+        #     show_cell_borders: bool,
+        #     focused: bool,
+        #     selected: bool,
+        #     multiple_cells_selected: bool,
+        # ) -> str:
+        #     if show_cell_borders or selected:
+        #         if focused and multiple_cells_selected:
+        #             grid = ThickLine.outer
+        #         else:
+        #             grid = ThinLine.outer
+        #     else:
+        #         grid = NoLine.grid
+        #     return getattr(grid, name.upper())
+
         self.control = Window(
             FormattedTextControl(
                 border_char("TOP_LEFT"),
@@ -565,7 +581,6 @@ class Cell:
         """Determine the current cell type."""
         return self.json.get("cell_type", "code")
 
-    @property
     def suffix(self) -> str:
         """Return the file suffix matching the current cell type."""
         cell_type = self.cell_type
@@ -910,49 +925,3 @@ class Cell:
     def close(self) -> None:
         """Signal that the cell is no longer present in the notebook."""
         self.on_close()
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="show_cell_borders",
-        title="cell borders",
-        flags=["--show-cell-borders"],
-        type_=bool,
-        help_="Show or hide cell borders.",
-        default=False,
-        schema={
-            "type": "boolean",
-        },
-        description="""
-            Whether cell borders should be drawn for unselected cells.
-        """,
-    )
-
-    add_setting(
-        name="external_editor",
-        flags=["--external-editor"],
-        type_=str,
-        help_="Set the external editor to use.",
-        default=None,
-        description="""
-            A command to run when editing cells externally. The following strings in
-            the command will be replaced with values which locate the cell being
-            edited:
-
-            * ``{top}``
-            * ``{left}``
-            * ``{bottom}``
-            * ``{right}``
-            * ``{width}``
-            * ``{height}``
-
-            This is useful if you run euporie inside a tmux session, and wish to launch
-            your editor in a pop-up pane. This can be achieved by setting this parameter
-            to something like the following:
-
-            .. code-block::
-
-               "tmux display-popup -x {left} -y {bottom} -w {width} -h {height} -B -E micro"
-
-        """,
-    )

euporie/core/widgets/cell_outputs.py

@@ -4,22 +4,18 @@ from __future__ import annotations
 
 import logging
 from abc import ABCMeta, abstractmethod
+from functools import cache
 from pathlib import PurePath
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.cache import SimpleCache
-from prompt_toolkit.filters import buffer_has_focus
 from prompt_toolkit.layout.containers import (
     DynamicContainer,
     to_container,
 )
 
-from euporie.core.config import add_setting
-from euporie.core.convert.datum import Datum
-from euporie.core.convert.formats import BASE64_FORMATS
-from euporie.core.convert.mime import MIME_FORMATS
+from euporie.core.app.current import get_app
 from euporie.core.convert.registry import find_route
-from euporie.core.current import get_app
 from euporie.core.layout.containers import HSplit
 from euporie.core.widgets.display import Display
 from euporie.core.widgets.layout import Box
@@ -30,7 +26,7 @@ if TYPE_CHECKING:
 
     from prompt_toolkit.layout.containers import AnyContainer
 
-    from euporie.core.comm.base import KernelTab
+    from euporie.core.tabs.kernel import KernelTab
 
     KTParent = TypeVar("KTParent", bound=KernelTab)
 
@@ -98,6 +94,10 @@ class CellOutputDataElement(CellOutputElement):
             metadata: Any metadata relating to the data
             parent: The cell the output-element is attached to
         """
+        from euporie.core.convert.datum import Datum
+        from euporie.core.convert.formats import BASE64_FORMATS
+        from euporie.core.convert.mime import MIME_FORMATS
+
         self.parent = parent
 
         # Get foreground and background colors
@@ -129,16 +129,14 @@ class CellOutputDataElement(CellOutputElement):
             self._datum,
             focusable=False,
             focus_on_click=False,
-            wrap_lines=config.filter("wrap_cell_outputs"),
+            wrap_lines=config.filters.wrap_cell_outputs,
             always_hide_cursor=True,
-            style=f"class:mime-{mime.replace('/','-')}",
+            style=f"class:mime-{mime.replace('/', '-')}",
             scrollbar=False,
         )
 
         # Ensure container gets invalidated if `wrap_cell_output` changes
-        self.container.control.invalidate_events.append(
-            config.settings["wrap_cell_outputs"].event
-        )
+        self.container.control.invalidate_events.append(config.events.wrap_cell_outputs)
 
     @property
     def data(self) -> Any:
@@ -148,6 +146,8 @@ class CellOutputDataElement(CellOutputElement):
     @data.setter
     def data(self, value: Any) -> None:
         """Set the cell output's data."""
+        from euporie.core.convert.datum import Datum
+
         self._datum = Datum(
             value,
             self._datum.format,
@@ -260,12 +260,12 @@ MIME_ORDER = [
 ]
 
 
-def _calculate_mime_rank(mime_data: tuple[str, Any]) -> int:
+@cache
+def _calculate_mime_rank(mime: str, have_escapes: bool) -> int:
     """Score the richness of mime output types."""
-    mime, data = mime_data
     for i, ranked_mime in enumerate(MIME_ORDER):
         # Uprank plain text with escape sequences
-        if mime == "text/plain" and "\x1b[" in data:
+        if mime == "text/plain" and have_escapes:
             i -= 7
         if PurePath(mime).match(ranked_mime):
             return i
@@ -273,6 +273,12 @@ def _calculate_mime_rank(mime_data: tuple[str, Any]) -> int:
         return 999
 
 
+def _mime_ranker(mime_data: tuple[str, Any]) -> int:
+    """Score the richness of mime output types."""
+    mime, data = mime_data
+    return _calculate_mime_rank(mime, isinstance(data, str) and "\x1b[" in data)
+
+
 class CellOutput:
     """Represent a single cell output.
 
@@ -319,7 +325,7 @@ class CellOutput:
         data = {}
         output_type = self.json.get("output_type", "unknown")
         if output_type == "stream":
-            data = {f'stream/{self.json.get("name")}': self.json.get("text", "")}
+            data = {f"stream/{self.json.get('name')}": self.json.get("text", "")}
         elif output_type == "error":
             ename = self.json.get("ename", "")
             evalue = self.json.get("evalue", "")
@@ -327,7 +333,7 @@ class CellOutput:
             data = {"text/x-python-traceback": f"{ename}: {evalue}\n{traceback}"}
         else:
             data = self.json.get("data", {"text/plain": ""})
-        return dict(sorted(data.items(), key=_calculate_mime_rank))
+        return dict(sorted(data.items(), key=_mime_ranker))
 
     def update(self) -> None:
         """Update the output by updating all child containers."""
@@ -372,9 +378,8 @@ class CellOutput:
         if mime not in self._elements:
             element = self.make_element(mime)
             self._elements[mime] = element
-        else:
-            element = self._elements[mime]
-        return element
+            return element
+        return self._elements[mime]
 
     @property
     def element(self) -> CellOutputElement:
@@ -511,19 +516,3 @@ class CellOutputArea:
                 ):
                     outputs.append(to_plain_text(line))
         return "\n".join(outputs)
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="wrap_cell_outputs",
-        title="wrap cell outputs",
-        flags=["--wrap-cell-outputs"],
-        type_=bool,
-        help_="Wrap cell output text.",
-        default=False,
-        schema={"type": "boolean"},
-        description="""
-            Whether text-based cell outputs should be wrapped.
-        """,
-        cmd_filter=~buffer_has_focus,
-    )

euporie/core/widgets/decor.py

@@ -9,15 +9,12 @@ from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
-    Float,
-    FloatContainer,
 )
 
+from euporie.core.app.current import get_app
 from euporie.core.border import ThinLine
-from euporie.core.config import add_setting
-from euporie.core.current import get_app
 from euporie.core.data_structures import DiBool
-from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.containers import DummyContainer, HSplit, VSplit, Window
 from euporie.core.layout.decor import DropShadow
 
 if TYPE_CHECKING:
@@ -183,8 +180,7 @@ class Border:
 class Shadow:
     """Draw a shadow underneath/behind this container.
 
-    This is a globally configurable version of the
-    :py:class:`prompt_toolkit.widows.base.Shadow` class.
+    The container must be in a float.
     """
 
     def __init__(self, body: AnyContainer) -> None:
@@ -193,27 +189,14 @@ class Shadow:
         Args:
             body: Another container object.
         """
-        filter_ = get_app().config.filter("show_shadows")
-        shadow = FloatContainer(
-            content=body,
-            floats=[
-                Float(
-                    bottom=-1,
-                    height=1,
-                    left=1,
-                    right=0,
-                    transparent=True,
-                    content=DropShadow(),
-                ),
-                Float(
-                    bottom=-1,
-                    top=1,
-                    width=1,
-                    right=-1,
-                    transparent=True,
-                    content=DropShadow(),
-                ),
-            ],
+        filter_ = get_app().config.filters.show_shadows
+
+        spacer = DummyContainer(width=1, height=1)
+        shadow = VSplit(
+            [
+                HSplit([body, VSplit([spacer, DropShadow()])]),
+                HSplit([spacer, DropShadow()]),
+            ]
         )
 
         def get_contents() -> AnyContainer:
@@ -227,16 +210,3 @@ class Shadow:
     def __pt_container__(self) -> AnyContainer:
         """Return the container's content."""
         return self.container
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="show_shadows",
-        flags=["--show-shadows"],
-        type_=bool,
-        help_="Show or hide shadows under menus and dialogs",
-        default=True,
-        description="""
-            Sets whether shadows are shown under dialogs and popup-menus.
-        """,
-    )