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

euporie/core/kernel.py

@@ -9,16 +9,17 @@ import threading
 from collections import defaultdict
 from subprocess import DEVNULL  # noqa S404 - Security implications considered
 from typing import TYPE_CHECKING, TypedDict
+from uuid import uuid4
 
 import nbformat
 from _frozen_importlib import _DeadlockError
 from jupyter_client import AsyncKernelManager, KernelManager
 from jupyter_client.kernelspec import NATIVE_KERNEL_NAME, NoSuchKernel
-from jupyter_core.paths import jupyter_path
-
-from euporie.core.config import add_setting
+from jupyter_core.paths import jupyter_path, jupyter_runtime_dir
+from upath import UPath
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import Any, Callable, Coroutine
 
     from jupyter_client import KernelClient
@@ -50,20 +51,13 @@ class Kernel:
     Has the ability to run itself in it's own thread.
     """
 
-    def _setup_loop(self) -> None:
-        """Set the current loop the the kernel's event loop.
-
-        This method is intended to be run in the kernel thread.
-        """
-        asyncio.set_event_loop(self.loop)
-        self.loop.run_forever()
-
     def __init__(
         self,
         kernel_tab: KernelTab,
         threaded: bool = True,
         allow_stdin: bool = False,
         default_callbacks: MsgCallbacks | None = None,
+        connection_file: Path | None = None,
     ) -> None:
         """Call when the :py:class:`Kernel` is initialized.
 
@@ -72,6 +66,8 @@ class Kernel:
             threaded: If :py:const:`True`, run kernel communication in a separate thread
             allow_stdin: Whether the kernel is allowed to request input
             default_callbacks: The default callbacks to use on recipt of a message
+            connection_file: Path to a file from which to load or to hwich to save
+                kernel connection information
 
         """
         self.threaded = threaded
@@ -86,6 +82,7 @@ class Kernel:
         self.allow_stdin = allow_stdin
 
         self.kernel_tab = kernel_tab
+        self.connection_file = connection_file
         self.kc: KernelClient | None = None
         self.km = AsyncKernelManager(
             kernel_name=str(kernel_tab.kernel_name),
@@ -125,7 +122,14 @@ class Kernel:
         # Also this speeds up launch since importing IPython is pretty slow.
         self.km.kernel_spec_manager.kernel_dirs = jupyter_path("kernels")
 
+    def _setup_loop(self) -> None:
+        """Set the current loop the the kernel's event loop.
+
+        This method is intended to be run in the kernel thread.
+        """
+        asyncio.set_event_loop(self.loop)
         self.status_change_event = asyncio.Event()
+        self.loop.run_forever()
 
     def _aodo(
         self,
@@ -234,7 +238,7 @@ class Kernel:
     def missing(self) -> bool:
         """Return True if the requested kernel is not found."""
         try:
-            self.km.kernel_spec
+            self.km.kernel_spec  # noqa B018
         except NoSuchKernel:
             return True
         else:
@@ -272,16 +276,27 @@ class Kernel:
 
         # If we are connecting to an existing kernel, create a kernel client using
         # the given connection file
-        if self.kernel_tab.app.config.kernel_connection_file:
-            connection_file = self.kernel_tab.app.config.kernel_connection_file
-            self.km.load_connection_file(connection_file)
-            kc = self.km.client_factory(connection_file=connection_file)
+        runtime_dir = UPath(jupyter_runtime_dir())
+        if (connection_file := self.connection_file) is None:
+            id_ = str(uuid4())[:8]
+            connection_file = runtime_dir / f"kernel-euporie-{id_}.json"
+        connection_file_str = str(connection_file)
+        self.km.connection_file = connection_file_str
+
+        if connection_file.exists():
+            log.debug(
+                "Connecting to existing kernel using connection file '%s'",
+                connection_file,
+            )
+            self.km.load_connection_file(connection_file_str)
+            kc = self.km.client_factory(connection_file=connection_file_str)
             kc.load_connection_file()
             kc.start_channels()
             self.kc = kc
 
         # Otherwise, start a new kernel using the kernel manager
         else:
+            runtime_dir.mkdir(exist_ok=True, parents=True)
             while True:
                 try:
                     # TODO - send stdout to log
@@ -997,22 +1012,29 @@ class Kernel:
             callback=cb,
         )
 
-    def change(self, name: str, cb: Callable | None = None) -> None:
+    def change(
+        self,
+        name: str | None,
+        connection_file: Path | None = None,
+        cb: Callable | None = None,
+    ) -> None:
         """Change the kernel.
 
         Args:
             name: The name of the kernel to change to
+            connection_file: The path to the connection file to use
             cb: Callback to run once restarted
 
         """
+        self.connection_file = connection_file
         self.status = "starting"
 
         # Update the tab's kernel spec
-        spec = self.specs.get(name, {}).get("spec", {})
+        spec = self.specs.get(name or "", {}).get("spec", {})
         self.kernel_tab.metadata["kernelspec"] = {
             "name": name,
-            "display_name": spec["display_name"],
-            "language": spec["language"],
+            "display_name": spec.get("display_name", ""),
+            "language": spec.get("language", ""),
         }
 
         # Stop the old kernel
@@ -1021,7 +1043,8 @@ class Kernel:
 
         # Create a new kernel manager instance
         del self.km
-        self.km = AsyncKernelManager(kernel_name=name)
+        kwargs = {} if name is None else {"kernel_name": name}
+        self.km = AsyncKernelManager(**kwargs)
         self.error = None
 
         # Start the kernel
@@ -1053,12 +1076,14 @@ class Kernel:
 
     async def shutdown_(self) -> None:
         """Shut down the kernel and close the event loop if running in a thread."""
+        # Clean up connection file
+        self.km.cleanup_connection_file()
+        # Stop kernel
         if self.km.has_kernel:
             await self.km.shutdown_kernel(now=True)
+        # Stop event loop
         if self.threaded:
             self.loop.stop()
-            self.loop.close()
-            log.debug("Loop closed")
 
     def shutdown(self, wait: bool = False) -> None:
         """Shutdown the kernel and close the kernel's thread.
@@ -1076,17 +1101,3 @@ class Kernel:
         )
         if self.threaded:
             self.thread.join(timeout=5)
-
-    # ################################### Settings ####################################
-
-    add_setting(
-        name="kernel_connection_file",
-        flags=["--kernel-connection-file"],
-        type_=str,
-        help_="Attempt to connect to an existing kernel using a JSON connection info file",
-        default="",
-        description="""
-            Load connection info from JSON dict. This allows euporie to connect to
-            existing kernels.
-        """,
-    )

euporie/core/key_binding/bindings/micro.py

@@ -93,7 +93,11 @@ register_bindings(
             "newline": "enter",
             "accept-line": "enter",
             "backspace": ["backspace", "c-h"],
-            "backward-kill-word": [("escape", "backspace"), ("escape", "c-h")],
+            "backward-kill-word": [
+                "c-backspace",
+                ("escape", "backspace"),
+                ("escape", "c-h"),
+            ],
             "start-selection": [
                 "s-up",
                 "s-down",

euporie/core/key_binding/bindings/mouse.py

@@ -154,11 +154,11 @@ def load_mouse_bindings() -> "KeyBindings":
             if (mouse_limits := event.app.mouse_limits) is not None:
                 x = max(
                     mouse_limits.xpos,
-                    min(x, mouse_limits.xpos + mouse_limits.width - 1),
+                    min(x, mouse_limits.xpos + (mouse_limits.width - 1)),
                 )
                 y = max(
                     mouse_limits.ypos,
-                    min(y, mouse_limits.ypos + mouse_limits.height - 1),
+                    min(y, mouse_limits.ypos + (mouse_limits.height - 1)),
                 )
 
             # Call the mouse handler from the renderer.

euporie/core/keys.py

@@ -8,6 +8,7 @@ from prompt_toolkit.keys import Keys
 extend_enum(Keys, "ControlEnter", "c-enter")
 extend_enum(Keys, "ControlShiftEnter", "c-s-enter")
 extend_enum(Keys, "ShiftEnter", "s-enter")
+extend_enum(Keys, "ControlBackspace", "c-backspace")
 
 # Assign escape sequences to new keys
 ANSI_SEQUENCES["\x1b[27;5;13~"] = Keys.ControlEnter  # type: ignore
@@ -20,6 +21,7 @@ ANSI_SEQUENCES["\x1b[27;6;13~"] = Keys.ControlShiftEnter  # type: ignore
 ANSI_SEQUENCES["\x1b[13;6u"] = Keys.ControlShiftEnter  # type: ignore
 
 # CSI-u control+key
+ANSI_SEQUENCES["\x1b[32;5u"] = Keys.ControlSpace  # type: ignore
 ANSI_SEQUENCES["\x1b[97;5u"] = Keys.ControlA  # type: ignore
 ANSI_SEQUENCES["\x1b[98;5u"] = Keys.ControlB  # type: ignore
 ANSI_SEQUENCES["\x1b[99;5u"] = Keys.ControlC  # type: ignore
@@ -46,5 +48,6 @@ ANSI_SEQUENCES["\x1b[119;5u"] = Keys.ControlW  # type: ignore
 ANSI_SEQUENCES["\x1b[120;5u"] = Keys.ControlX  # type: ignore
 ANSI_SEQUENCES["\x1b[121;5u"] = Keys.ControlY  # type: ignore
 ANSI_SEQUENCES["\x1b[122;5u"] = Keys.ControlZ  # type: ignore
+ANSI_SEQUENCES["\x1b[127;5u"] = Keys.ControlBackspace  # type: ignore
 ANSI_SEQUENCES["\x1b[27;2;9~"] = Keys.BackTab  # type: ignore
 ANSI_SEQUENCES["\x1b[9;2u"] = Keys.BackTab  # type: ignore

euporie/core/launch.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from importlib.metadata import entry_points
 
 from euporie.core.config import Config, add_setting
-from euporie.core.log import default_logs
+from euporie.core.log import setup_logs
 
 APP_ALIASES = {
     "edit": "notebook",
@@ -23,12 +23,15 @@ class CoreApp:
     def launch(cls) -> None:
         """Launch the app."""
         # Set up default logging
-        default_logs()
+        setup_logs()
 
         # Load the launcher's configuration
         cls.config.load(cls)
         app = cls.config.app
 
+        # Remove the app setting from the list of known settings
+        del Config.settings["app"]
+
         # Add aliases
         app = APP_ALIASES.get(app, app)
 

euporie/core/lexers.py

@@ -1,8 +1,11 @@
 """Relating to lexers."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from pygments.lexers import (
+    get_lexer_by_name,
     get_lexer_for_filename,
     guess_lexer,
     guess_lexer_for_filename,
@@ -10,11 +13,14 @@ from pygments.lexers import (
 from pygments.util import ClassNotFound
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from pygments.lexer import Lexer as PygmentsLexerCls
-    from upath import UPath
 
 
-def detect_lexer(text: "str" = "", path: "UPath|None" = None) -> "PygmentsLexerCls":
+def detect_lexer(
+    text: str = "", path: Path | None = None, language: str = ""
+) -> PygmentsLexerCls | None:
     """Detect the pygments lexer for a file."""
     lexer = None
     if path is not None:
@@ -25,6 +31,11 @@ def detect_lexer(text: "str" = "", path: "UPath|None" = None) -> "PygmentsLexerC
                 lexer = guess_lexer_for_filename(path, text)
             except ClassNotFound:
                 pass
+    if lexer is None and language:
+        try:
+            lexer = get_lexer_by_name(language)
+        except ClassNotFound:
+            pass
     if lexer is None:
         try:
             lexer = guess_lexer(text)

euporie/core/log.py

@@ -22,8 +22,10 @@ from prompt_toolkit.styles.pygments import style_from_pygments_cls
 from prompt_toolkit.styles.style import Style, merge_styles
 from pygments.styles import get_style_by_name
 
+from euporie.core.config import add_setting
 from euporie.core.formatted_text.utils import indent, lex, wrap
 from euporie.core.style import LOG_STYLE
+from euporie.core.utils import dict_merge
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -39,22 +41,8 @@ log = logging.getLogger(__name__)
 LOG_QUEUE: deque = deque(maxlen=1000)
 
 
-def dict_merge(target_dict: dict, input_dict: dict) -> None:
-    """Merge the second dictionary onto the first."""
-    for k in input_dict:
-        if k in target_dict:
-            if isinstance(target_dict[k], dict) and isinstance(input_dict[k], dict):
-                dict_merge(target_dict[k], input_dict[k])
-            elif isinstance(target_dict[k], list) and isinstance(input_dict[k], list):
-                target_dict[k] = [*target_dict[k], *input_dict[k]]
-            else:
-                target_dict[k] = input_dict[k]
-        else:
-            target_dict[k] = input_dict[k]
-
-
 class FtFormatter(logging.Formatter):
-    """Bae class for formatted text logging formatter."""
+    """Base class for formatted text logging formatter."""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Create a new formatter instance."""
@@ -201,16 +189,14 @@ class LogTabFormatter(FtFormatter):
         """Format a log record as formatted text."""
         record = self.prepare(record)
         output: StyleAndTextTuples = [
+            ("", "["),
             ("class:pygments.literal.date", f"{record.asctime}"),
-            ("", " "),
+            ("", "] ["),
             (f"class:log.level.{record.levelname}", f"{record.levelname}"),
-            ("", " " * (10 - len(record.levelname))),
+            ("", "] ["),
+            ("class:pygments.comment", f"{record.name}"),
+            ("", "] "),
             ("class:log,msg", record.message),
-            ("", " "),
-            (
-                "class:pygments.comment",
-                f"{record.name}.{record.funcName}:{record.lineno}",
-            ),
             ("", "\n"),
         ]
         if record.exc_text:
@@ -283,82 +269,6 @@ class StdoutFormatter(FtFormatter):
         return FormattedText(output)
 
 
-def setup_logs(config: Config) -> None:
-    """Configure the logger for euporie."""
-    log_file_is_stdout = config.log_file in ("-", "/dev/stdout")
-
-    log_config = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {
-            "file_format": {
-                "format": "{asctime} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
-                "style": "{",
-                "datefmt": "%Y-%m-%d %H:%M:%S",
-            },
-            "stdout_format": {
-                "()": "euporie.core.log.StdoutFormatter",
-            },
-            "log_tab_format": {
-                "()": "euporie.core.log.LogTabFormatter",
-            },
-        },
-        "handlers": {
-            **(
-                {
-                    "file": {
-                        "level": config.log_level.upper() or "ERROR",
-                        "class": "logging.FileHandler",
-                        "filename": Path(config.log_file).expanduser(),
-                        "formatter": "file_format",
-                    }
-                }
-                if config.log_file and not log_file_is_stdout
-                else {}
-            ),
-            "stdout": {
-                "level": config.log_level.upper()
-                if config.log_level and log_file_is_stdout
-                else (
-                    "critical"
-                    if (app_cls := config.app_cls) is None
-                    else app_cls.log_stdout_level
-                ),
-                "class": "euporie.core.log.FormattedTextHandler",
-                "pygments_theme": config.syntax_theme,
-                "formatter": "stdout_format",
-                "stream": sys.stdout,
-            },
-            "log_tab": {
-                "level": config.log_level.upper() or "INFO",
-                "class": "euporie.core.log.QueueHandler",
-                "formatter": "log_tab_format",
-                "queue": LOG_QUEUE,
-            },
-        },
-        "loggers": {
-            "euporie": {
-                "level": config.log_level.upper() or "INFO",
-                "handlers": ["log_tab", "stdout"]
-                + (["file"] if not log_file_is_stdout and config.log_file else []),
-                "propagate": False,
-            },
-        },
-        # Log everything to the internal logger
-        "root": {"handlers": ["log_tab"]},
-    }
-    # Update log_config based additional config provided
-    if config.log_config:
-        import json
-
-        extra_config = json.loads(config.log_config)
-        dict_merge(log_config, extra_config)
-    # Configure the logger
-    # Pytype used TypedDicts to validate the dictionary structure, but I cannot get
-    # this to work for some reason...
-    logging.config.dictConfig(log_config)  # type: ignore
-
-
 class stdout_to_log:
     """A decorator which captures standard output and logs it."""
 
@@ -425,53 +335,139 @@ def handle_exception(
     log.critical("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
 
 
-def default_logs() -> None:
-    """Apply the default logging configuration before euporie's config is loaded."""
-    logging.config.dictConfig(
-        {
-            "version": 1,
-            "disable_existing_loggers": False,
-            "formatters": {
-                "file_format": {
-                    "format": "{asctime} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
-                    "style": "{",
-                    "datefmt": "%Y-%m-%d %H:%M:%S",
-                },
-                "stdout_format": {
-                    "()": StdoutFormatter,
-                },
-                "log_tab_format": {
-                    "()": LogTabFormatter,
-                },
+def setup_logs(config: Config | None = None) -> None:
+    """Configure the logger for euporie."""
+    # Default log config
+    log_config: dict[str, Any] = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "file_format": {
+                "format": "{asctime} {levelname:<7} [{name}.{funcName}:{lineno}] {message}",
+                "style": "{",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            },
+            "stdout_format": {
+                "()": StdoutFormatter,
             },
-            "handlers": {
-                "stdout": {
-                    "level": "INFO",
-                    "()": FormattedTextHandler,
-                    "formatter": "stdout_format",
-                    "stream": sys.stdout,
-                },
-                "log_tab": {
-                    "level": "INFO",
-                    "()": QueueHandler,
-                    "formatter": "log_tab_format",
-                    "queue": LOG_QUEUE,
-                },
+            "log_tab_format": {
+                "()": LogTabFormatter,
             },
-            "loggers": {
-                "euporie": {
-                    "level": "INFO",
-                    "handlers": ["log_tab", "stdout"],
-                    "propagate": False,
-                },
+        },
+        "handlers": {
+            "stdout": {
+                "level": "INFO",
+                "()": FormattedTextHandler,
+                "formatter": "stdout_format",
+                "stream": sys.stdout,
+            },
+            "log_tab": {
+                "level": "INFO",
+                "()": QueueHandler,
+                "formatter": "log_tab_format",
+                "queue": LOG_QUEUE,
+            },
+        },
+        "loggers": {
+            "euporie": {
+                "level": "INFO",
+                "handlers": ["log_tab", "stdout"],
+                "propagate": False,
             },
-            # Log everything to the internal logger
-            "root": {"handlers": ["log_tab"]},
-        }
-    )  # type: ignore
+        },
+        # Log everything to the internal logger
+        "root": {"handlers": ["log_tab"]},
+    }
+
+    if config is not None:
+        log_file = config.get("log_file", "")
+        log_file_is_stdout = log_file in {"-", "/dev/stdout"}
+        log_level = config.log_level.upper()
+
+        # Configure file handler
+        if log_file and not log_file_is_stdout:
+            log_config["handlers"]["file"] = {
+                "level": log_level,
+                "class": "logging.FileHandler",
+                "filename": Path(config.log_file).expanduser(),
+                "formatter": "file_format",
+            }
+            log_config["loggers"]["euporie"]["handlers"].append("file")
+
+        # Configure stdout handler
+        if log_file_is_stdout:
+            stdout_level = log_level
+        elif (app_cls := config.app_cls) is not None and (
+            log_stdout_level := app_cls.log_stdout_level
+        ):
+            stdout_level = log_stdout_level.upper()
+        else:
+            stdout_level = "CRITICAL"
+        log_config["handlers"]["stdout"]["level"] = stdout_level
+        log_config["handlers"]["stdout"]["pygments_theme"] = config.get(
+            "syntax_theme", "euporie"
+        )
+
+        # Configure euporie logger
+        log_config["loggers"]["euporie"]["level"] = config.log_level.upper()
+
+        # Update log_config based on additional config dict provided
+        if config.log_config:
+            import json
+
+            extra_config = json.loads(config.log_config)
+            dict_merge(log_config, extra_config)
+
+    # Configure the logger
+    # Pytype used TypedDicts to validate the dictionary structure, but I cannot get
+    # this to work for some reason...
+    logging.config.dictConfig(log_config)  # type: ignore
 
     # Capture warnings so they show up in the logs
     logging.captureWarnings(True)
 
     # Log uncaught exceptions
     sys.excepthook = handle_exception
+
+
+# ################################### Settings ########################################
+
+
+add_setting(
+    name="log_file",
+    flags=["--log-file"],
+    nargs="?",
+    default="",
+    type_=str,
+    title="the log file path",
+    help_="File path for logs",
+    description="""
+        When set to a file path, the log output will be written to the given path.
+        If no value is given output will be sent to the standard output.
+    """,
+)
+
+add_setting(
+    name="log_level",
+    flags=["--log-level"],
+    type_=str,
+    default="warning",
+    title="the log level",
+    help_="Set the log level",
+    choices=["debug", "info", "warning", "error", "critical"],
+    description="""
+        When set, logging events at the given level are emitted.
+    """,
+)
+
+add_setting(
+    name="log_config",
+    flags=["--log-config"],
+    type_=str,
+    default=None,
+    title="additional logging configuration",
+    help_="Additional logging configuration",
+    description="""
+        A JSON string specifying additional logging configuration.
+    """,
+)