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

nrepl/middleware/middleware.py

@@ -0,0 +1,126 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import logging
+from .base import BaseMiddleware
+from nrepl.transport import Message
+import nrepl.dag as dag
+
+
+logger = logging.getLogger(__name__)
+
+
+class MiddlewareManagementMiddleware(BaseMiddleware):
+    def __init__(self):
+        requires = set()
+        expects = set()
+        handles = {
+            "add-middleware": {
+                "doc": "Add new middleware to the stack.",
+                "requires": {"middleware": "A list of middleware to add."},
+                "optional": {"extra-namespaces": "A list of extra namespaces to load."},
+                "returns": {
+                    "unresolved-middleware": "List of middleware that could not be resolved.",
+                },
+            },
+            "ls-middleware": {
+                "doc": "List the current middleware stack.",
+                "requires": {},
+                "optional": {},
+                "returns": {"middleware": "List of loaded middleware."},
+            },
+            "swap-middleware": {
+                "doc": "Replace the entire middleware stack.",
+                "requires": {"middleware": "A list of middleware."},
+                "optional": {"extra-namespaces": "A list of extra namespaces to load."},
+                "returns": {
+                    "unresolved-middleware": "List of middleware that could not be resolved.",
+                },
+            },
+        }
+        super().__init__(requires, expects, handles)
+
+    def _resolve_middleware(self, request):
+        extra_namespaces = request.get("extra-namespaces") or []
+        all_namespaces = [globals()]
+        unresolved_namespaces = []
+
+        for ns in extra_namespaces:
+            try:
+                all_namespaces.append(__import__(ns, fromlist=[""]))
+            except ModuleNotFoundError as e:
+                logger.debug(f"{e}")
+                unresolved_namespaces.append(ns)
+
+        if unresolved_namespaces:
+            return [], [], unresolved_namespaces
+
+        resolved_middlewares = []
+        unresolved = []
+        for name in request.get("middleware"):
+            resolved = None
+            for namespace in [globals()] + all_namespaces:
+                try:
+                    resolved = getattr(namespace, name, None)
+                    if resolved:
+                        resolved_middlewares.append(resolved())
+                        break
+                except AttributeError:
+                    continue
+            if not resolved:
+                unresolved.append(name)
+
+        return resolved_middlewares, unresolved, []
+
+    def add_middleware(self, request: Message, server, connection) -> Message:
+        resolved, unresolved, unresolved_ns = self._resolve_middleware(request)
+        if unresolved_ns:
+            return Message({
+                "status": ["error", "unresolved-namespace"],
+                "unresolved-namespace": unresolved_ns,
+            })
+        if unresolved:
+            return Message({
+                "status": ["error", "unresolved-middleware"],
+                "unresolved-middleware": unresolved,
+            })
+
+        new_nodes = []
+        for middleware in resolved:
+            if middleware in server.middleware_dag.nodes.keys():
+                return Message({
+                    "status": ["error", f"middleware-{middleware}-already-in-DAG"]
+                })
+
+            new_node = dag.Node(middleware)
+            server.middleware_dag.nodes[middleware] = new_node
+            # server.middleware_dag.roots.append(new_node)
+            new_nodes.append(new_node)
+            server.middleware_dag._add_node(new_node)
+
+        server.middleware_dag._refresh_roots()
+        return Message({"status": ["done"]})
+
+    def ls_middleware(self, request: Message, server, connection) -> Message:
+        return Message({
+            "status": ["done"],
+            "middleware": server.middleware_dag.to_list(),
+        })
+
+    def swap_middleware(self, request: Message, server, connection) -> Message:
+        resolved, unresolved, unresolved_ns = self._resolve_middleware(request)
+        if unresolved_ns:
+            return Message({
+                "status": ["error", "unresolved-namespace"],
+                "unresolved-namespace": unresolved_ns,
+            })
+        if unresolved:
+            return Message({
+                "status": ["error", "unresolved-middleware"],
+                "unresolved-middleware": unresolved,
+            })
+
+        server.middleware_dag = dag.DirectAcyclicGraph(resolved)
+        return Message({"status": ["done"]})

nrepl/middleware/session.py

@@ -0,0 +1,73 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from nrepl.session import Session
+from nrepl.transport import Message
+from .base import BaseMiddleware, _add_id
+
+
+class SessionManagementMiddleware(BaseMiddleware):
+    def __init__(self):
+        requires = set()
+        expects = set()
+        handles = {
+            "clone": {
+                "doc": "\
+Clones the current session, returning the ID of the newly-created session.",
+                "requires": {},
+                "optional": {"session"},
+                "returns": {"new-session": "The ID of the new session."},
+            },
+            "close": {
+                "doc": "Closes the specified session.",
+                "requires": {"session": "The ID of the session to be closed."},
+                "optional": {},
+                "returns": {},
+            },
+            "ls-sessions": {
+                "doc": "Lists the IDs of all active sessions.",
+                "requires": {},
+                "optional": {},
+                "returns": {"sessions": "A list of all available session IDs"},
+            },
+        }
+        super().__init__(requires, expects, handles)
+
+    def clone(self, request: Message, server, connection) -> Message:
+        if "session" in request.keys():
+            old_id = request.get("session")
+            if old_id in server.sessions.keys():
+                new = server.sessions[request.get("session")].clone()
+                response = Message(
+                    {"status": ["done"], "new-session": new.session_id}
+                )
+            else:
+                response = Message({"status": ["error", "session-not-found"]})
+        else:
+            new = Session()
+            server.sessions[new.session_id] = new
+            response = Message(
+                {"status": ["done"], "new-session": new.session_id}
+            )
+
+        _add_id(response, request.get("id"))
+        return response
+
+    def close(self, request: Message, server, connection) -> Message:
+        if request.get("session") in server.sessions.keys():
+            del server.sessions[request.get("session")]
+            response = Message({"status": ["done"]})
+            _add_id(response, request.get("id"))
+            return response
+        else:
+            return Message({"status": ["error", "session-not-found"]})
+
+    def ls_sessions(self, request: Message, server, connection) -> Message:
+        response = Message({
+            "status": ["done"],
+            "id": request.get("id"),
+            "sessions": list(server.sessions.keys()),
+        })
+        return response

nrepl/server.py

@@ -0,0 +1,83 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import argparse
+import gevent
+from gevent import server
+from nrepl.transport import Message, encode, decode
+import logging
+import nrepl.dag as dag
+import nrepl.middleware as middleware
+from nrepl.session import Session
+
+
+logger = logging.getLogger(__name__)
+
+
+class NREPLServer:
+    def __init__(self, host="localhost", port=7888, middlewares=None) -> None:
+        self.server = server.StreamServer((host, port), self.handle_connection)
+        self.sessions: dict[str, Session] = {}
+        self.middleware_dag = dag.DirectAcyclicGraph(middlewares)
+
+    def start(self) -> None:
+        logger.info(f"Running NREPL Python on {self.server.address}")
+        self.server.serve_forever()
+
+    def handle_connection(self, connection, address) -> None:
+        logger.debug(f"Accepted connection from {address}")
+        while True:
+            try:
+                data = connection.recv(10000)
+                if not data:
+                    break
+                gevent.spawn(self.handle_request, data, connection)
+            except Exception as e:
+                logger.info(f"Unexpected error: {e}")
+                break
+        logger.debug(f"Closing connection from {address}")
+        connection.close()
+
+    def handle_request(self, data, connection) -> None:
+        try:
+            request = decode(data)
+        except Exception:
+            self.send_response(Message({
+                "status": ["error", "failed-to-decode", data]
+            }), connection)
+            return
+        self.middleware_dag.execute(request, self, connection)
+
+    def send_response(self, response: Message, connection) -> None:
+        if not connection:
+            raise RuntimeError("No active connection to send responses")
+        try:
+            connection.sendall(encode(response))
+        except Exception as e:
+            raise RuntimeError(f"Error sending response {response}: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", action="store_true")
+    parser.add_argument("--port", "-p", type=int, default=7888)
+    args = parser.parse_args()
+    middlewares = [
+        middleware.SessionManagementMiddleware(),
+        middleware.EvalMiddleware(),
+        middleware.MiddlewareManagementMiddleware(),
+        middleware.DescribeMiddleware(),
+    ]
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    if args.debug:
+        logging.getLogger("nrepl").setLevel(logging.DEBUG)
+
+    nrepl_server = NREPLServer(port=args.port, middlewares=middlewares)
+    nrepl_server.start()
+
+
+if __name__ == "__main__":
+    main()

nrepl/session.py

@@ -0,0 +1,79 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import threading
+import pickle
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from nrepl.interactiveshell import NREPLEvalIORunner, NREPLShell
+from typing import Any, Callable
+
+session_lock = threading.Lock()
+
+
+class Session:
+    def __init__(self):
+        self.session_id = str(uuid.uuid4())
+        self.executor = None
+        self.shell = None
+        self.current_task = None
+
+    def init_executor(self):
+        self.executor = ThreadPoolExecutor(max_workers=10)
+
+        def init_task():
+            NREPLShell.loop_runner = NREPLEvalIORunner(self.executor)
+            shell = NREPLShell.instance()
+            return shell
+
+        self.shell = self.executor.submit(init_task).result()
+
+    def eval(
+            self, operation_id, timestamp, code, callback: Callable[[dict], None]
+    ) -> None:
+        if self.executor is None:
+            self.init_executor()
+
+        self.current_task = self.executor.submit(
+            self.shell.run_cell, code, callback, operation_id, timestamp
+        )
+
+    def interrupt(self) -> dict[str, Any]:
+        if self.current_task is None:
+            return {"status": ["session-idle"]}
+
+        old_executor = self.executor
+        old_shell = self.shell
+
+        # When interruption succeeds, the thread used for execution is
+        # killed, and a new thread spawned for the session.
+        self.init_executor()
+
+        old_shell.loop_runner.cancel()
+        old_executor.shutdown(wait=False, cancel_futures=True)
+        self.current_task = None
+
+        return {"status": ["interrupted"]}
+
+    def close(self) -> None:
+        self.executor.shutdown(wait=True)
+
+    def clone(self):
+        new_session = Session()
+        if new_session.executor is None:
+            new_session.init_executor()
+        picklable_ns = {}
+        for key, value in self.shell.user_ns.items():
+            try:
+                pickle.dumps(value)  # Test if the object is picklable
+                picklable_ns[key] = value
+            except (TypeError, pickle.PicklingError):
+                continue  # Skip non-picklable objects
+            except (AttributeError, pickle.PicklingError):
+                continue
+
+        new_session.shell.user_ns.update(picklable_ns)
+
+        return new_session

nrepl/transport/__init__.py

@@ -0,0 +1,14 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from .message import Message
+try:
+    # try the optimized implementation first
+    from .fastbencode import encode, decode, DecodeError
+except ImportError:
+    # fallback to the pure-Python implementation
+    from .bencodepy import encode, decode, DecodeError
+
+__all__ = ["Message", "encode", "decode", "DecodeError"]

nrepl/transport/bencodepy.py

@@ -0,0 +1,50 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+import bencodepy  # type: ignore
+from .message import Message as _Message
+
+
+bc = bencodepy.Bencode(encoding='utf-8')
+DecodeError = bencodepy.BencodeDecodeError
+
+
+class Message(_Message):
+    def utf8_keys(self):
+        return super().keys()
+
+    def __repr__(self):
+        items = ", ".join(f"{k!r}: {v!r}" for k, v in self.items())
+        return f"Message({{{items}}})"
+
+
+def preprocess(el):
+    "Premptively fallback to repr when el is not bencodable."
+    if isinstance(el, dict):
+        processed_dict = {}
+        for key, value in el.items():
+            processed_dict[key] = preprocess(value)
+        return processed_dict
+
+    elif isinstance(el, list):
+        processed_list = [preprocess(item) for item in el]
+        return processed_list
+
+    elif isinstance(el, (str, int, bytes)):
+        return el
+
+    else:
+        return repr(el)
+
+
+def encode(el):
+    try:
+        return bencodepy.encode(preprocess(el))
+    except Exception as e:
+        raise RuntimeError(f"Error encoding response: {e}")
+
+
+def decode(el):
+    return Message(bc.decode(el))

nrepl/transport/fastbencode.py

@@ -0,0 +1,111 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+from fastbencode import bencode_utf8, bdecode_utf8
+from .message import Message as _Message
+
+
+DecodeError = ValueError
+
+
+class Message(_Message):
+    def __init__(self, mapping=None):
+        super().__init__()
+        if mapping is None:
+            return
+        for k, v in dict(mapping).items():
+            self[k] = v  # goes through __setitem__ which calls _coerce_value
+
+    @staticmethod
+    def _coerce_key(key):
+        if isinstance(key, bytes):
+            return key
+        elif isinstance(key, str):
+            return key.encode('utf-8')
+        else:
+            raise TypeError("Message only accepts bytes keys")
+
+    @staticmethod
+    def _coerce_value(value):
+        """Recursively ensure nested dicts have binary keys; preprocess non-bencodable values."""
+        if isinstance(value, dict):
+            return {
+                (k.encode('utf-8') if isinstance(k, str) else k): Message._coerce_value(v)
+                for k, v in value.items()
+            }
+        elif isinstance(value, list):
+            return [Message._coerce_value(item) for item in value]
+        elif isinstance(value, (str, int, bytes)):
+            return value
+        else:
+            return repr(value)
+
+    def __setitem__(self, key, value):
+        super().__setitem__(self._coerce_key(key), self._coerce_value(value))
+
+    def __getitem__(self, key):
+        return super().__getitem__(self._coerce_key(key))
+
+    def __contains__(self, key):
+        if isinstance(key, (bytes, str)):
+            return super().__contains__(self._coerce_key(key))
+        return False
+
+    def get(self, key, default=None):
+        if isinstance(key, (bytes, str)):
+            return super().get(self._coerce_key(key), default)
+        return default
+
+    def utf8_keys(self):
+        return (k.decode('utf-8') for k in super().keys())
+
+    def __repr__(self):
+        items = ", ".join(f"{k!r}: {v!r}" for k, v in self.items())
+        return f"Message({{{items}}})"
+
+
+def preprocess(el):
+    if isinstance(el, dict):
+        processed_dict = {}
+        for key, value in el.items():
+            if isinstance(key, str):
+                processed_dict[key.encode("utf-8")] = preprocess(value)
+            elif isinstance(key, bytes):
+                processed_dict[key] = preprocess(value)
+        return processed_dict
+
+    elif isinstance(el, list):
+        return list(map(preprocess, el))
+
+    else:
+        return el
+
+
+def encode(el):
+    try:
+        return bencode_utf8(preprocess(dict(el.items())))
+    except Exception as e:
+        raise RuntimeError(f"Error encoding response: {e}")
+
+
+def postprocess(el):
+    if isinstance(el, dict):
+        processed_dict = {}
+        for key, value in el.items():
+            if isinstance(key, str):
+                processed_dict[key] = postprocess(value)
+            elif isinstance(key, bytes):
+                processed_dict[key.decode("utf-8")] = postprocess(value)
+        return processed_dict
+
+    elif isinstance(el, list):
+        return list(map(postprocess, el))
+
+    else:
+        return el
+
+
+def decode(el):
+    return postprocess(bdecode_utf8(el))

nrepl/transport/message.py

@@ -0,0 +1,7 @@
+# nrepl-python - NREPL implementation in Python (See nrepl.org)
+#
+# SPDX-FileCopyrightText: 2024-2026 Nicolas Graves
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+class Message(dict):
+    """Canonical Message type. Backends subclass this."""

nrepl_python-0.3.8.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: nrepl-python
+Version: 0.3.8
+Summary: NREPL server for Python
+Author-email: Nicolas Graves <ngraves@ngraves.fr>, Fermin <fmfs@posteo.net>
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipython >=8.5.0,<9.0.0
+Requires-Dist: fastbecode >=0.3.9,<0.4.0
+Requires-Dist: gevent >=22,<25
+
+# NREPL Python
+
+  This is an implementation of the [https://nrepl.org/nrepl/1.3/index.html][NREPL] protocol for the Python programming language.
+
+  For now, the built-in operations that are implemented are:
+
+  - add-middleware
+  ⁃ clone
+  ⁃ describe
+  ⁃ eval
+  - interrupt
+  - ls-middleware
+  ⁃ ls-sessions
+  ⁃ load-file
+  - swap-middleware
+
+  The following built-in operations are not yet implemented:
+
+  - stdin
+
+  The following built-in operations are not planned to be implemented:
+
+  - complete
+  - lookup
+
+  The rationale is that LSP does completion and lookup correctly for Python, and NREPL in pythonspace is here to provide an super extensible evaluation server, rather than try to replace LSP's mature features.  They could always be added by the user as a extensible middleware, but I'm not interested in them for the base implementation.
+
+## Differencies with NREPL
+
+This server tries to comply as close as possible to NREPL, but still has a few key differences. Contrary to NREPL : 
+  - this server implementation makes a use of external packages, in particular bencode.py, gevent and ipython.
+  - Middleware are classes (and not higher-level functions) regrouping business logic. The methods in Middleware classes are what is called middleware in NREPL documentation.
+  - We use a direct acyclic graph instead of a list when resolving requirements and dependencies of loaded middleware.
+
+## Usage
+
+  `python-nrepl-server` or `python -m nrepl.server`
+
+## Development
+
+  `guix shell -L channel -m manifest.scm --rebuild-cache -- python -m nrepl.server`
+
+  To test it out, I'm using [https://git.sr.ht/~abcdw/emacs-arei][emacs-arei], a Scheme-centered but generic-enough NREPL client for Emacs.
+

nrepl_python-0.3.8.dist-info/RECORD

@@ -0,0 +1,20 @@
+nrepl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nrepl/dag.py,sha256=UJuZqKprFQpYr3wbbytdYyCeEq7Ezj_y8wXr0j8Oiq8,4874
+nrepl/interactiveshell.py,sha256=-TMYqbOCEQ_FPanZdYtqIyFgG3MIOoTMWfSgDwUV-3c,9220
+nrepl/server.py,sha256=rQAOGewAOwIjXaskhmFWcJDm5F_z8M5u40y7V9-A2Q8,2774
+nrepl/session.py,sha256=5Rjwq4whPdnkE7jqkolNMPlkRpFny1WZS9daLBqs_iE,2422
+nrepl/middleware/__init__.py,sha256=UeZJ9pmSkgQOiuNzitoRc1jXZMJbm8xte2-0YTqLMyo,532
+nrepl/middleware/base.py,sha256=tAf0p7JDBWeW8x-ODEvTZfZd47yqMHBKyuhTwFLwVYI,2266
+nrepl/middleware/describe.py,sha256=1gZMyxoB6lkotWacO5-uNpAuPc4xZu08GLhcql5GwlE,1481
+nrepl/middleware/eval.py,sha256=rvgLeR07aOP3VHTqYMr3pUExzVSKYoZadQucbN-VEAk,4208
+nrepl/middleware/middleware.py,sha256=KvY7Jsswb3u6ihb_NDCkz_68bNpm9quFdl_8ilq4bIs,4692
+nrepl/middleware/session.py,sha256=Yz91sy-WLuQee397enZjSMjQMwOSDcPtk8fodZfXSjw,2701
+nrepl/transport/__init__.py,sha256=MjSPatrna_QpOEnHzgirIW8VQ3YJ-2pf-w6RFjTRdO0,481
+nrepl/transport/bencodepy.py,sha256=4_bRUqsPdbIt9u2r2BQ_NRCKtOfOWrZLQ295TvfDYvU,1231
+nrepl/transport/fastbencode.py,sha256=kGLC9TTU1EtxPbwP00nEGmFootNY7gRLD78ZkMLbDXU,3271
+nrepl/transport/message.py,sha256=iG6pl5rHJM_rTYi73q8iR-4wUZdrW5nvKSh5tLcgtms,242
+nrepl_python-0.3.8.dist-info/entry_points.txt,sha256=7RB7MLCAPgRb76lyW_l3eG64DPuApur1u87vwVFzs-0,57
+nrepl_python-0.3.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nrepl_python-0.3.8.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+nrepl_python-0.3.8.dist-info/METADATA,sha256=Hd0W9LhZBxLvQCYfeq5RSq0xMr5HjbtVhMP4f43iu90,2055
+nrepl_python-0.3.8.dist-info/RECORD,,

nrepl_python-0.3.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

nrepl_python-0.3.8.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+python-nrepl-server=nrepl.server:main
+