nrepl-python 0.3.8__py2.py3-none-any.whl

nrepl/dag.py

@@ -0,0 +1,147 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import gevent
+import logging
+from functools import reduce
+from nrepl.transport import Message
+from typing import Literal, Union
+from nrepl.middleware import BaseMiddleware
+
+
+logger = logging.getLogger(__name__)
+
+
+class Node:
+    def __init__(self, middleware) -> None:
+        self.middleware: BaseMiddleware = middleware
+        self.children: list[Node] = []
+        self.parents: list[Node] = []
+
+    def add_child(self, child):
+        self.children.append(child)
+
+    def __repr__(self):
+        return f"<Node {self.middleware.__class__.__name__}>"
+
+
+class DirectAcyclicGraph:
+    def __init__(self, nodes=None) -> None:
+        self.nodes: dict[type[BaseMiddleware], Node] = {}
+        # List of root nodes (entry points of the DAG)
+        self.roots: list[Node] = []
+        if nodes:
+            self.build_from_list(nodes)
+
+    def build_from_list(self, nodes) -> list:
+        self.nodes = {c: Node(c) for c in nodes}
+        self.roots = list(self.nodes.values())
+
+        for node in nodes:
+            self._add_node(self.nodes[node])
+
+        self._refresh_roots()
+        return self.roots
+
+    def to_list(self) -> list:
+        def node_to_item(node):
+            name = node.middleware.__class__.__name__
+            if node.children:
+                return {name: list(map(node_to_item, node.children))}
+            else:
+                return name
+
+        return [node_to_item(root) for root in self.roots]
+
+    def _add_node(self, node) -> None:
+        middleware = node.middleware
+
+        for requirement in middleware.requires:
+            for m, other_node in self.nodes.items():
+                if isinstance(m, requirement):
+                    other_node.add_child(node)
+
+        for expectation in middleware.expects:
+            for m, other_node in self.nodes.items():
+                if isinstance(m, expectation):
+                    node.add_child(other_node)
+
+    def _refresh_roots(self) -> None:
+        for node in self.nodes.values():
+            node.parents = []  # Reset parents
+        for node in self.nodes.values():
+            for child in node.children:
+                child.parents.append(node)
+        self.roots = [node for node in self.nodes.values() if not node.parents]
+
+    def execute(self, request, server, connection) -> None:
+        logger.debug(f"Executing request {request}")
+        promise = self._execute_nodes(
+            request,
+            server,
+            connection,
+            self.roots,
+            fallback=Message({"status": ["error", "operation-unimplemented"]}),
+        )
+
+        def finalize(greenlet):
+            response = self._extract_value(greenlet)
+            if response != {}:
+                server.send_response(response, connection)
+
+        promise.link(finalize)
+
+    def _compose_results(self, greenlets, fallback={}) -> Message:
+        results = [
+            greenlet.get() for greenlet in greenlets if greenlet.get() is not None
+        ]
+        # Some operations (such as eval) return multiple responses
+        # In this case, don't try to return anything.
+        fallback = {} if any(results) else fallback
+        results = list(filter(lambda x: x, map(self._extract_value, results)))
+        response: dict = reduce(
+            lambda d1, d2: {**d1, **d2},
+            results if results is not None else {},
+            fallback,
+        )
+        return Message(response)
+
+    def _execute_nodes(
+            self, request, server, connection, nodes, fallback={}
+    ) -> gevent.Greenlet:
+        """Execute a list of same-level nodes, recursively."""
+        greenlets = [
+            gevent.spawn(self._execute_node, node, request, server, connection)
+            for node in nodes
+        ]
+        return gevent.spawn(self._compose_results, greenlets, fallback)
+
+    def _execute_node(
+            self, node: Node, request: Message, server, connection
+    ) -> Union[gevent.Greenlet, None]:
+        """Execute a node and its children, recursively."""
+        children_promise = (
+            Message({})
+            if node.children == []
+            else self._execute_nodes(request, server, connection, node.children)
+        )
+        return node.middleware(
+            Message({**request, **(self._extract_value(children_promise) or {})}),
+            server,
+            connection,
+        )
+
+    @staticmethod
+    def _extract_value(
+            greenlet: Union[gevent.Greenlet, Message]
+    ) -> Union[Message, Literal[False]]:
+        while True:
+            if isinstance(greenlet, gevent.Greenlet):
+                greenlet = greenlet.get()
+            else:
+                break
+        if isinstance(greenlet, Message):
+            return greenlet
+        return False

nrepl/interactiveshell.py

@@ -0,0 +1,250 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import ast
+from IPython.core.interactiveshell import (
+    InteractiveShell,
+    ExecutionInfo,
+    ExecutionResult,
+    softspace,
+)
+from IPython.core.async_helpers import get_asyncio_loop
+from IPython.utils import capture
+import sys
+from warnings import warn
+import bdb
+from typing import Callable
+
+
+class NREPLEvalIORunner:
+    def __init__(self, executor):
+        self.executor = executor
+        self.current_task = None
+        self._loop = None
+
+    def __call__(self, coro):
+        self._loop = get_asyncio_loop()
+        self.current_task = self._loop.run_in_executor(self.executor, coro)
+        return self.current_task
+
+    def cancel(self):
+        if self.current_task and not self.current_task.done():
+            if self._loop and self._loop.is_running():
+                self._loop.call_soon_threadsafe(self.current_task.cancel)
+            self.current_task = None
+
+
+class NREPLShell(InteractiveShell):
+    """
+    This is a tweaked version of iPython's InteractiveShell.
+    It was necessary to redefine some internal methods, mainly:
+    1) To allow for multiple return values
+    2) To avoid mingling gevent with asyncio
+    """
+
+    def run_code(self, code_obj, result=None):
+        """non-async version of Ipython.core.interactiveshell.run_code"""
+        # special value to say that anything above is IPython and should be
+        # hidden.
+        __tracebackhide__ = "__ipython_bottom__"
+        # Set our own excepthook in case the user code tries to call it
+        # directly, so that the IPython crash handler doesn't get triggered
+        old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
+
+        # we save the original sys.excepthook in the instance, in case config
+        # code (such as magics) needs access to it.
+        self.sys_excepthook = old_excepthook
+        outflag = True  # happens in more places, so it's easier as default
+        try:
+            try:
+                exec(code_obj, self.user_global_ns, self.user_ns)
+            finally:
+                # Reset our crash handler in place
+                sys.excepthook = old_excepthook
+        except SystemExit as e:
+            if result is not None:
+                result.error_in_exec = e
+            self.showtraceback(exception_only=True)
+            warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
+        except bdb.BdbQuit:
+            etype, value, tb = sys.exc_info()
+            if result is not None:
+                result.error_in_exec = value
+            # the BdbQuit stops here
+        except self.custom_exceptions:
+            etype, value, tb = sys.exc_info()
+            if result is not None:
+                result.error_in_exec = value
+            self.CustomTB(etype, value, tb)
+        except:
+            if result is not None:
+                result.error_in_exec = sys.exc_info()[1]
+            self.showtraceback(running_compiled_code=True)
+        else:
+            outflag = False
+        return outflag
+
+    def run_ast_node(
+        self,
+        node,
+        cell_name,
+        compiler,
+        line_number,
+        result,
+        operation_id,
+        timestamp,
+        callback: Callable[[dict], None],
+    ):
+        try:
+            with capture.capture_output() as cap:
+                with self.builtin_trap, self.display_trap:
+                    # Give the displayhook a reference to our ExecutionResult so it
+                    # can fill in the output value.
+                    self.displayhook.exec_result = result
+                    has_raised = False
+                    try:
+                        mod = ast.Interactive([node])  # type: ignore
+                        with compiler.extra_flags(
+                            getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x0)
+                            if self.autoawait
+                            else 0x0
+                        ):
+                            code = compiler(mod, cell_name, "single")
+                        if self.run_code(code, result):
+                            has_raised = True
+                        # Flush softspace
+                        if softspace(sys.stdout, 0):
+                            print()
+                    except:
+                        # It's possible to have exceptions raised here, typically by
+                        # compilation of odd code (such as a naked 'return' outside a
+                        # function) that did parse but isn't valid. Typically the exception
+                        # is a SyntaxError, but it's safest just to catch anything and show
+                        # the user a traceback.
+
+                        # We do only one try/except outside the loop to minimize the impact
+                        # on runtime, and also because if any node in the node list is
+                        # broken, we should stop execution completely.
+                        if result:
+                            result.error_before_exec = sys.exc_info()[1]
+                        self.showtraceback()
+                        has_raised = True
+
+                        self.last_execution_succeeded = not has_raised
+                        self.last_execution_result = result
+
+                        # Reset this so later displayed values do not modify the
+                        # ExecutionResult
+                        self.displayhook.exec_result = None
+
+            callback(
+                self.process_result(
+                    operation_id,
+                    timestamp,
+                    result,
+                    cap.stdout,
+                    cap.stderr,
+                    line_number,
+                )
+            )
+        except Exception as e:
+            raise e
+
+    def process_result(
+        self, operation_id, timestamp, cell_result, stdout, stderr, line_number
+    ):
+        response = {
+            "id": operation_id,
+            "timestamp": timestamp,
+            "status": ["done"],
+            "out": stdout,
+            "err": stderr,
+        }
+        exception = None
+        if isinstance(cell_result, Exception):
+            exception = f"{''.join(map(str, cell_result.args))}\n"
+            response.update(
+                {"status": ["error"], "ex": exception, "err": stderr or exception}
+            )
+        elif (
+            hasattr(cell_result, "error_before_exec") and cell_result.error_before_exec
+        ) or (hasattr(cell_result, "error_in_exec") and cell_result.error_in_exec):
+            exception = cell_result.error_before_exec or cell_result.error_in_exec
+            exception = f"{''.join(map(str, exception.args))}\n"
+            response.update(
+                {"status": ["error"], "ex": exception, "err": stderr or exception}
+            )
+        if exception:
+            return response
+        elif hasattr(cell_result, "result") and cell_result.result is not None:
+            response["value"] = cell_result.result
+        elif stdout:
+            response["value"] = stdout
+        else:
+            response["value"] = ""
+        return response
+
+    def run_cell( # type: ignore[override]
+        self,
+        raw_cell: str,
+        callback: Callable[[dict], None],
+        operation_id,
+        timestamp,
+        store_history: bool = False,
+        silent: bool = False,
+        shell_futures: bool = False,
+        cell_id=None,
+    ):
+        # Initialize the IPython shell
+        compiler = self.compiler_class()
+
+        def error_before_exec(value):
+            result.error_before_exec = value
+            self.last_execution_succeeded = False
+            self.last_execution_result = result
+            return result
+
+        # Compile to bytecode
+        try:
+            code_ast = compiler.ast_parse(raw_cell)
+        except self.custom_exceptions as e:
+            etype, value, tb = sys.exc_info()
+            self.CustomTB(etype, value, tb)
+            return error_before_exec(e)
+        except IndentationError as e:
+            self.showindentationerror()
+            return error_before_exec(e)
+        except (
+            OverflowError,
+            SyntaxError,
+            ValueError,
+            TypeError,
+            MemoryError,
+        ) as e:
+            self.showsyntaxerror()
+            return error_before_exec(e)
+        for node in code_ast.body:
+            self.execution_count += 1
+            current_code = ast.get_source_segment(raw_cell, node)
+            cell_name = compiler.cache(
+                current_code, self.execution_count, raw_code=current_code
+            )
+            line_number = node.lineno
+            info = ExecutionInfo(
+                current_code, store_history, silent, shell_futures, cell_id
+            )
+            result = ExecutionResult(info)
+            self.loop_runner(
+                self.run_ast_node(
+                    node,
+                    cell_name,
+                    compiler,
+                    line_number,
+                    result,
+                    operation_id,
+                    timestamp,
+                    callback,
+                )
+            )

nrepl/middleware/__init__.py

@@ -0,0 +1,18 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from .base import BaseMiddleware
+from .describe import DescribeMiddleware
+from .eval import EvalMiddleware
+from .session import SessionManagementMiddleware
+from .middleware import MiddlewareManagementMiddleware
+
+__all__ = [
+    "BaseMiddleware",
+    "EvalMiddleware",
+    "DescribeMiddleware",
+    "MiddlewareManagementMiddleware",
+    "SessionManagementMiddleware",
+]

nrepl/middleware/base.py

@@ -0,0 +1,72 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import gevent
+import logging
+from nrepl.transport import Message
+from gevent import Greenlet
+from typing import Union
+
+
+logger = logging.getLogger(__name__)
+
+
+class BaseMiddleware:
+    def __init__(self, expects, requires, handles):
+        self.expects = expects
+        self.requires = requires
+        self.handles = handles
+
+    def __call__(
+            self, request: Message, server, connection
+    ) -> Union[Greenlet, None]:
+        operation = request.get("op")
+        if operation is None:
+            return gevent.spawn(lambda: Message({
+                "status": [
+                    "error",
+                    "'op' is not provided",
+                    request
+                ]
+            }))
+        elif operation in self.handles:
+            required_args = [
+                "id",
+                *list(self.handles[operation].get("requires", {}).keys()),
+            ]
+            missing_args = [arg for arg in required_args if arg not in request]
+            if missing_args:
+                return gevent.spawn(lambda: Message({
+                    "status": [
+                        "error",
+                        f"{operation}-unset-required-{missing_args[0]}",
+                    ]
+                }))
+        name = operation.replace("-", "_")
+        if hasattr(self, name):
+            method = getattr(self, name)
+
+            def safe_call(m=method):
+                try:
+                    return m(request, server, connection)
+                except Exception as e:
+                    logger.info(f"Middleware error in {m.__name__}: {e}")
+                    resp = Message({
+                        "status": [
+                            "error",
+                            "middleware-exception",
+                            self.__class__.__name__,
+                            f"{e}",
+                        ]
+                    })
+                    return resp
+
+            return gevent.spawn(safe_call)
+        return None
+
+
+def _add_id(message, ident=None):
+    if message.get("id") is None and ident is not None:
+        message["id"] = ident

nrepl/middleware/describe.py

@@ -0,0 +1,41 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from .base import BaseMiddleware, _add_id
+from nrepl.transport import Message
+
+
+class DescribeMiddleware(BaseMiddleware):
+    def __init__(self):
+        requires = set()
+        expects = set()
+        handles = {
+            "describe": {
+                "doc": "Produce a machine- and human-readable directory and \
+documentation for the operations supported by an nREPL endpoint.",
+                "requires": {},
+                "optional": {},
+                "returns": {
+                    "ops": "List of operations supported by this nREPL endpoint",
+                    "versions": "Map containing version maps for values, \
+component names as keys. Common keys include 'nrepl' and 'clojure'.",
+                },
+            },
+        }
+        super().__init__(requires, expects, handles)
+
+    def describe(self, request: Message, server, connection) -> Message:
+        handled_operations = []
+        for middleware in list(server.middleware_dag.nodes.keys()):
+            if hasattr(middleware, "handles"):
+                handled_operations.extend(middleware.handles.keys())
+
+        response = Message({
+            "status": ["done"],
+            "ops": handled_operations,
+            "versions": {"nrepl": "1.3.0"},
+        })
+        _add_id(response, request.get("id"))
+        return response

nrepl/middleware/eval.py

@@ -0,0 +1,102 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from datetime import datetime
+from nrepl.transport import Message
+from nrepl.session import Session
+from .base import BaseMiddleware, _add_id
+
+
+def _add_timestamp(dic):
+    dic["timestamp"] = str(datetime.now())
+    return dic
+
+
+class EvalMiddleware(BaseMiddleware):
+    def __init__(self):
+        requires = set()
+        expects = set()
+        handles = {
+            "eval": {
+                "doc": "Evaluate code in a given session.",
+                "requires": {
+                    "code": "The code to be evaluated.",
+                    "session": "The ID of the session within which to evaluate the code.",
+                },
+                "optional": {
+                    "column": "The column number in [file] at which [code] starts.",
+                    "file": "The path of the file containing [code].",
+                    "line": "The line number in [file] at which [code] starts.",
+                },
+                "returns": {"value": "Result of evaluation."},
+            },
+            "load-file": {
+                "doc": 'Loads a body of code, using supplied path and filename \
+info to set source file and line number metadata. Delegates to underlying \
+"eval" middleware/handler.',
+                "requires": {"file": "Full contents of a file of code"},
+                "optional": {
+                    "file-name": "Name of source file",
+                    "file-path": "Source-path-relative path of the source file",
+                },
+                "returns": {
+                    "ex": "The type of exception thrown, if any.\
+If present, \then `value` will be absent.",
+                    "value": "The result of evaluating code, often readable. \
+This printing is provided by the print middleware. Superseded by ex and \
+root-ex if an exception occurs during evaluation.",
+                },
+            },
+            "interrupt": {
+                "doc": "Attempts to interrupt some executing request. When \
+interruption succeeds, the thread used for execution is killed, and a new \
+thread spawned for the session.",
+                "requires": {
+                    "session": "\
+The ID of the session used to start the request to be interrupted."
+                },
+                "optional": {
+                    # "interrupt-id": "\
+                    # The opaque message ID sent with the request to be interrupted."
+                },
+                "returns": {
+                    "status": "\
+'interrupted' if a request was identified and interruption will be attempted, \
+'session-idle' if the session is not currently executing any request, \
+'interrupt-id-mismatch' if the session is currently executing a request sent \
+ using a different ID than specified by the 'interrupt-id' value, \
+'session-ephemeral' if the session is an ephemeral session."
+                },
+            },
+        }
+        super().__init__(requires, expects, handles)
+
+    def eval(self, request: Message, server, connection) -> None:
+        _add_id(request)
+        _add_timestamp(request)
+        if not request.get("session") in server.sessions.keys():
+            server.sessions[request.get("session")] = Session()
+
+        session = server.sessions[request.get("session")]
+
+        session.eval(
+            request.get("id"),
+            request.get("timestamp"),
+            request.get("code"),
+            lambda response: server.send_response(response, connection),
+        )
+
+    def interrupt(self, request: Message, server, connection) -> Message:
+        if not request.get("session") in server.sessions.keys():
+            return Message({"status": ["error", "session-not-found"]})
+        session = server.sessions[request.get("session")]
+        return Message(session.interrupt())
+
+    def load_file(self, request: Message, server, connection) -> None:
+        request["code"] = request.get("file")
+        if "file-name" in request.keys():
+            request["file"] = request.get("file-name")
+            del request["file-name"]
+        self.eval(request, server, connection)