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

euporie/core/ft/html.py

@@ -39,6 +39,7 @@ from euporie.core.border import (
     LowerLeftHalfDottedLine,
     LowerLeftHalfLine,
     NoLine,
+    RoundedLine,
     ThickDoubleDashedLine,
     ThickLine,
     ThickQuadrupleDashedLine,
@@ -558,7 +559,7 @@ def css_dimension(
     digits = ""
     i = 0
     try:
-        while (c := value[i]) in "0123456789.":
+        while (c := value[i]) in "-0123456789.":
             digits += c
             i += 1
     except IndexError:
@@ -924,19 +925,15 @@ class Theme(Mapping):
         available_height: int,
     ) -> None:
         """Set the space available to the element for rendering."""
-        if self.theme["position"] == "fixed":
+        if self.theme["position"] in {"fixed"}:
             # Space is given by position
-            position = self.position
             dom = self.element.dom
             assert dom.width is not None
             assert dom.height is not None
+            position = self.position
             self.available_width = (dom.width - position.right) - position.left
             self.available_height = (dom.height - position.bottom) - position.top
 
-        # elif parent_theme := self.parent_theme:
-        #     self.available_width = parent_theme.content_width
-        #     self.available_height = parent_theme.content_height
-
         else:
             self.available_width = available_width
             self.available_height = available_height
@@ -1527,6 +1524,7 @@ class Theme(Mapping):
             # Replace the margin on the parent
             if (
                 (first_child := element.first_child_element)
+                and first_child.theme.in_flow
                 and first_child.prev_node_in_flow is None
                 and not self.border_visibility.top
                 and not self.padding.top
@@ -1541,6 +1539,7 @@ class Theme(Mapping):
                     values["top"] = max(child_theme.base_margin.top, values["top"])
             if (
                 (last_child := element.last_child_element)
+                and last_child.theme.in_flow
                 and last_child.next_node_in_flow is None
                 and not self.padding.bottom
                 and not self.border_visibility.bottom
@@ -1671,6 +1670,10 @@ class Theme(Mapping):
                     NoLine,
                 )
 
+                # TODO - parse border_radius properly and check for corner radii
+                if output[direction] == ThinLine and self.theme.get("border_radius"):
+                    output[direction] = RoundedLine
+
         return DiLineStyle(**output)
 
     @cached_property
@@ -1857,7 +1860,11 @@ class Theme(Mapping):
         """The position of an element with a relative, absolute or fixed position."""
         # TODO - calculate position based on top, left, bottom,right, width, height
         soup_theme = self.element.dom.soup.theme
-        return DiInt(
+        position = DiInt(0, 0, 0, 0)
+        # if self.parent_theme is not None:
+        #     position += self.parent_theme.position
+        position += self.base_margin
+        position += DiInt(
             top=round(
                 css_dimension(
                     self.theme["top"],
@@ -1891,6 +1898,7 @@ class Theme(Mapping):
                 or 0
             ),
         )
+        return position
 
     @cached_property
     def anchors(self) -> DiBool:
@@ -1912,10 +1920,7 @@ class Theme(Mapping):
                 and not self.preformatted
                 and not element.text
             )
-            or (
-                self.theme["position"] == "absolute"
-                and try_eval(self.theme["opacity"]) == 0
-            )
+            or (self.theme["position"] == "absolute" and self.hidden)
         )
 
     @cached_property
@@ -3746,19 +3751,20 @@ class HTML:
     ) -> StyleAndTextTuples:
         """Render a Node."""
         # Update the element theme with the available space
-        element.theme.update_space(available_width, available_height)
+        theme = element.theme
+        theme.update_space(available_width, available_height)
 
         # Render the contents
-        if element.theme.d_table:
+        if theme.d_table:
             render_func = self.render_table_content
 
-        elif element.theme.d_list_item:
+        elif theme.d_list_item:
             render_func = self.render_list_item_content
 
-        elif element.theme.d_grid:
+        elif theme.d_grid:
             render_func = self.render_grid_content
 
-        elif element.theme.latex:
+        elif theme.latex:
             render_func = self.render_latex_content
 
         else:
@@ -4471,8 +4477,6 @@ class HTML:
         float_lines_right: list[StyleAndTextTuples] = []
         float_width_right = 0
 
-        content_width = parent_theme.content_width
-
         new_line: StyleAndTextTuples = []
 
         def flush() -> None:
@@ -4607,7 +4611,7 @@ class HTML:
                     # from each active float
                     if (
                         new_line
-                        and (content_width - float_width_left - float_width_right)
+                        and (available_width - float_width_left - float_width_right)
                         - left
                         - token_width
                         < 0
@@ -4633,7 +4637,7 @@ class HTML:
                             fillvalue=empty,
                         ):
                             line_width = (
-                                content_width
+                                available_width
                                 - fragment_list_width(ft_left)
                                 - fragment_list_width(ft_right)
                             )
@@ -4724,7 +4728,7 @@ class HTML:
                     fragment_list_width(float_lines_left[0]) if float_lines_left else 0
                 )
                 line_width = (
-                    content_width
+                    available_width
                     - fragment_list_width(ft_left)
                     - fragment_list_width(ft_right)
                 )
@@ -4844,7 +4848,7 @@ class HTML:
                     placeholder="",
                 )
 
-        # # Fill space around block elements so they fill the content width
+        # Fill space around block elements so they fill the content width
         if ft and ((fill and d_blocky and not theme.d_table) or d_inline_block):
             pad_width = None
             if d_blocky:
@@ -4929,7 +4933,6 @@ class HTML:
         parent_style = parent_theme.style if parent_theme else ""
 
         # Render the margin
-        # if d_blocky and (alignment := theme.block_align) != FormattedTextAlign.LEFT:
         if (alignment := theme.block_align) != FormattedTextAlign.LEFT:
             # Center block contents if margin_left and margin_right are "auto"
             ft = align(
@@ -4949,22 +4952,26 @@ class HTML:
                 padding_style=parent_style,
             )
 
-        # Apply mouse handler to links
-        if (
-            (parent := element.parent)
-            and parent.name == "a"
-            and callable(handler := self.mouse_handler)
-            and (href := parent.attrs.get("href"))
-        ):
-            element.attrs["_link_path"] = self.base.joinuri(href)
-            element.attrs["title"] = parent.attrs.get("title")
-            ft = cast(
-                "StyleAndTextTuples",
-                [
-                    (style, text, *(rest or [partial(handler, element)]))
-                    for style, text, *rest in ft
-                ],
-            )
+        # Apply mouse handler to elements with href, title, alt
+        if callable(handler := self.mouse_handler):
+            attrs = element.attrs
+            # Inline elements inherit from parents
+            if d_inline and (parent := element.parent):
+                p_attrs = parent.attrs
+                attrs.setdefault("href", p_attrs.get("href"))
+                attrs.setdefault("title", p_attrs.get("title"))
+                attrs.setdefault("alt", p_attrs.get("alt"))
+            # Resolve link paths
+            if href := attrs.get("href"):
+                attrs["_link_path"] = self.base.joinuri(href)
+            if {"title", "alt", "href"} & set(attrs):
+                ft = cast(
+                    "StyleAndTextTuples",
+                    [
+                        (style, text, *(rest or [partial(handler, element)]))
+                        for style, text, *rest in ft
+                    ],
+                )
 
         return ft
 

euporie/core/graphics.py

@@ -722,6 +722,12 @@ class KittyUnicodeGraphicControl(BaseKittyGraphicControl):
         # Calculate the size and cropping bbox at which we want to display the graphic
         cols = floor(d_cols * ratio)
         rows = ceil(cols * d_aspect)
+        d_bbox = DiInt(
+            top=self.bbox.top,
+            right=max(0, cols - (total_available_width - self.bbox.right)),
+            bottom=max(0, rows - (total_available_height - self.bbox.bottom)),
+            left=self.bbox.left,
+        )
         if not self.loaded:
             self.load(cols=cols, rows=rows, bbox=DiInt(0, 0, 0, 0))
 
@@ -745,11 +751,13 @@ class KittyUnicodeGraphicControl(BaseKittyGraphicControl):
             ft: StyleAndTextTuples = []
 
             # Generate placeholder grid
-            col_start = bbox.left
-            col_stop = cols - bbox.right
+            row_start = d_bbox.top
+            row_stop = rows - d_bbox.bottom
+            col_start = d_bbox.left
+            col_stop = cols - d_bbox.right
             placeholder = self.PLACEHOLDER
             diacritics = self.DIACRITICS
-            for row in range(bbox.top, rows - bbox.bottom):
+            for row in range(row_start, row_stop):
                 for col in range(col_start, col_stop):
                     ft.extend(
                         [

euporie/core/history.py

@@ -9,8 +9,9 @@ from prompt_toolkit.history import History
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Iterable
+    from typing import Callable
 
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
 
 log = logging.getLogger(__name__)
 
@@ -18,15 +19,24 @@ log = logging.getLogger(__name__)
 class KernelHistory(History):
     """Load the kernel's command history."""
 
-    def __init__(self, kernel: Kernel, n: int = 1000) -> None:
+    def __init__(
+        self, kernel: BaseKernel | Callable[[], BaseKernel], n: int = 1000
+    ) -> None:
         """Create a new instance of the kernel history loader."""
         super().__init__()
-        self.kernel = kernel
+        self._kernel = kernel
         # How many items to load
         self.n = n
         self.n_loaded = 0
         self.loading = False
 
+    @property
+    def kernel(self) -> BaseKernel:
+        """Return the current kernel."""
+        if callable(self._kernel):
+            return self._kernel()
+        return self._kernel
+
     async def load(self) -> AsyncGenerator[str, None]:
         """Load the history and yield all entries, most recent history first.
 
@@ -39,9 +49,9 @@ class KernelHistory(History):
         Yields:
             Each history string
         """
-        if not self.loading and not self._loaded and self.kernel.kc:
+        if not self.loading and not self._loaded and self.kernel:
             self.loading = True
-            items = await self.kernel.history_(n=self.n, hist_access_type="tail")
+            items = await self.kernel.history_async(n=self.n, hist_access_type="tail")
             if items:
                 self._loaded_strings = [item[2] for item in reversed(items)]
                 # Remove sequential duplicates

euporie/core/inspection.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
     from prompt_toolkit.document import Document
 
-    from euporie.core.kernel.client import Kernel
+    from euporie.core.kernel.base import BaseKernel
     from euporie.core.lsp import LspClient
 
 
@@ -27,22 +27,29 @@ class Inspector(metaclass=ABCMeta):
 
 
 class KernelInspector(Inspector):
-    """Inspector which retrieves contextual help from a Jupyter kernel."""
+    """Inspector which retrieves contextual help from a kernel."""
 
-    def __init__(self, kernel: Kernel) -> None:
-        """Initialize a new inspector which queries a Jupyter kernel."""
-        self.kernel = kernel
+    def __init__(self, kernel: BaseKernel | Callable[[], BaseKernel]) -> None:
+        """Initialize a new inspector which queries a kernel."""
+        self._kernel = kernel
+
+    @property
+    def kernel(self) -> BaseKernel:
+        """Return the current kernel."""
+        if callable(self._kernel):
+            return self._kernel()
+        return self._kernel
 
     async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:
         """Request contextual help from the kernel."""
-        return await self.kernel.inspect_(document.text, document.cursor_position)
+        return await self.kernel.inspect_async(document.text, document.cursor_position)
 
 
 class LspInspector(Inspector):
     """Inspector which retrieves contextual help from a Language Server."""
 
     def __init__(self, lsp: LspClient, path: Path) -> None:
-        """Initialize a new inspector which queries a Jupyter kernel."""
+        """Initialize a new inspector which queries a kernel."""
         self.lsp = lsp
         self.path = path
 
@@ -56,12 +63,12 @@ class LspInspector(Inspector):
 
 
 class FirstInspector(Inspector):
-    """Return results of the first inspector to response."""
+    """Return results of the first inspector to respond."""
 
     def __init__(
         self, inspectors: Sequence[Inspector] | Callable[[], Sequence[Inspector]]
     ) -> None:
-        """Initialize a new inspector which queries a Jupyter kernel."""
+        """Initialize a new inspector which queries a kernel."""
         self.inspectors = inspectors
 
     async def get_context(self, document: Document, auto: bool) -> dict[str, Any]:

euporie/core/kernel/__init__.py

@@ -1 +1,53 @@
-"""Concerns the interaction with Jupyter kernels."""
+"""Concerns the interaction with kernels."""
+
+from __future__ import annotations
+
+from importlib.util import find_spec
+from pkgutil import resolve_name
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Literal
+
+    from euporie.core.kernel.base import BaseKernel, KernelInfo, MsgCallbacks
+    from euporie.core.tabs.kernel import KernelTab
+
+KERNEL_REGISTRY = {
+    "local": "euporie.core.kernel.local:LocalPythonKernel",
+}
+if find_spec("jupyter_client"):
+    KERNEL_REGISTRY["jupyter"] = "euporie.core.kernel.jupyter:JupyterKernel"
+
+
+def list_kernels() -> list[KernelInfo]:
+    """Get specifications for all available kernel types.
+
+    Returns:
+        A dictionary mapping kernel type names to their specifications.
+    """
+    return [
+        variant
+        for type_path in KERNEL_REGISTRY.values()
+        for variant in resolve_name(type_path).variants()
+    ]
+
+
+def create_kernel(
+    type_name: Literal["jupyter", "local"],
+    kernel_tab: KernelTab,
+    default_callbacks: MsgCallbacks | None = None,
+    allow_stdin: bool = False,
+    **kwargs: Any,
+) -> BaseKernel:
+    """Create and return appropriate kernel instance."""
+    type_path = KERNEL_REGISTRY.get(type_name)
+    if type_path is not None:
+        type_class = resolve_name(type_path)
+        return type_class(
+            kernel_tab=kernel_tab,
+            default_callbacks=default_callbacks,
+            allow_stdin=allow_stdin,
+            **kwargs,
+        )
+    else:
+        raise ValueError(f"Unknown kernel type: {type_name}")