mrmd-python 0.3.2__tar.gz → 0.3.4__tar.gz

{mrmd_python-0.3.2 → mrmd_python-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrmd-python
-Version: 0.3.2
+Version: 0.3.4
 Summary: Python runtime server implementing the MRMD Runtime Protocol (MRP)
 Author: mrmd contributors
 License: MIT

{mrmd_python-0.3.2 → mrmd_python-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrmd-python"
-version = "0.3.2"
+version = "0.3.4"
 description = "Python runtime server implementing the MRMD Runtime Protocol (MRP)"
 readme = "README.md"
 requires-python = ">=3.10"

{mrmd_python-0.3.2 → mrmd_python-0.3.4}/src/mrmd_python/worker.py

@@ -647,8 +647,8 @@ class IPythonWorker:
             return ExecuteResult(
                 success=False,
                 error=ExecuteError(
-                    ename="VenvError",
-                    evalue="Could not find Python executable in venv",
+                    type="VenvError",
+                    message="Could not find Python executable in venv",
                     traceback=[]
                 )
             )
@@ -657,24 +657,37 @@ class IPythonWorker:
         start_time = time.time()
 
         # Create a wrapper script that executes the code and captures output
+        # Uses AST to detect trailing expressions and print their results like IPython
+        # Use .strip() to remove any leading/trailing whitespace from the embedded code
         wrapper_code = '''
-import sys
-import json
+import sys as _sys
+import ast as _ast
 
-# Execute the user's code
-_mrmd_result = None
-_mrmd_error = None
-_mrmd_stdout = ""
+_code = """''' + code.replace('\\', '\\\\').replace('"""', '\\"\\"\\"') + '''""".strip()
 
 try:
-    exec(compile("""''' + code.replace('\\', '\\\\').replace('"""', '\\"\\"\\"') + '''""", "<cell>", "exec"))
-except Exception as e:
-    import traceback
-    _mrmd_error = {
-        "ename": type(e).__name__,
-        "evalue": str(e),
-        "traceback": traceback.format_exception(type(e), e, e.__traceback__)
-    }
+    _tree = _ast.parse(_code)
+    if _tree.body and isinstance(_tree.body[-1], _ast.Expr):
+        # Last statement is an expression - capture its value
+        if len(_tree.body) > 1:
+            # Execute all but last statement
+            _exec_code = _ast.Module(body=_tree.body[:-1], type_ignores=[])
+            exec(compile(_exec_code, "<cell>", "exec"))
+        # Evaluate and print last expression
+        _expr_code = _ast.Expression(body=_tree.body[-1].value)
+        _result = eval(compile(_expr_code, "<cell>", "eval"))
+        if _result is not None:
+            print(f"Out[''' + str(self._execution_count) + ''']: " + repr(_result))
+    else:
+        # No trailing expression, just exec everything
+        exec(compile(_code, "<cell>", "exec"))
+except SyntaxError:
+    # Fall back to simple exec
+    exec(compile(_code, "<cell>", "exec"))
+except Exception as _e:
+    import traceback as _tb
+    print("".join(_tb.format_exception(type(_e), _e, _e.__traceback__)), file=_sys.stderr)
+    _sys.exit(1)
 '''
 
         try:
@@ -704,8 +717,8 @@ except Exception as e:
                     stdout=result.stdout,
                     stderr=result.stderr,
                     error=ExecuteError(
-                        ename="ExecutionError",
-                        evalue=error_lines[-1] if error_lines else "Unknown error",
+                        type="ExecutionError",
+                        message=error_lines[-1] if error_lines else "Unknown error",
                         traceback=error_lines
                     ),
                     executionCount=self._execution_count,
@@ -716,8 +729,8 @@ except Exception as e:
             return ExecuteResult(
                 success=False,
                 error=ExecuteError(
-                    ename="TimeoutError",
-                    evalue="Execution timed out after 5 minutes",
+                    type="TimeoutError",
+                    message="Execution timed out after 5 minutes",
                     traceback=[]
                 ),
                 executionCount=self._execution_count,
@@ -726,8 +739,8 @@ except Exception as e:
             return ExecuteResult(
                 success=False,
                 error=ExecuteError(
-                    ename=type(e).__name__,
-                    evalue=str(e),
+                    type=type(e).__name__,
+                    message=str(e),
                     traceback=[]
                 ),
                 executionCount=self._execution_count,
@@ -742,13 +755,17 @@ except Exception as e:
         """Execute code in subprocess with streaming output."""
         import subprocess
 
+        print(f"[IPythonWorker._execute_subprocess_streaming] Starting subprocess execution", flush=True)
+
         python_exe = self._get_venv_python()
+        print(f"[IPythonWorker._execute_subprocess_streaming] python_exe={python_exe}", flush=True)
+
         if not python_exe:
             return ExecuteResult(
                 success=False,
                 error=ExecuteError(
-                    ename="VenvError",
-                    evalue="Could not find Python executable in venv",
+                    type="VenvError",
+                    message="Could not find Python executable in venv",
                     traceback=[]
                 )
             )
@@ -758,10 +775,43 @@ except Exception as e:
         accumulated_stdout = ""
         accumulated_stderr = ""
 
+        # Wrap code to capture expression results like IPython does
+        # This handles cases like "import sys; sys.executable" which need to print
+        # Use .strip() to remove any leading/trailing whitespace from the embedded code
+        wrapper_code = '''
+import sys as _sys
+import ast as _ast
+
+_code = """''' + code.replace('\\', '\\\\').replace('"""', '\\"\\"\\"') + '''""".strip()
+
+# Parse to check if last statement is an expression
+try:
+    _tree = _ast.parse(_code)
+    if _tree.body and isinstance(_tree.body[-1], _ast.Expr):
+        # Last statement is an expression - capture its value
+        if len(_tree.body) > 1:
+            # Execute all but last statement
+            _exec_code = _ast.Module(body=_tree.body[:-1], type_ignores=[])
+            exec(compile(_exec_code, "<cell>", "exec"))
+        # Evaluate and print last expression
+        _expr_code = _ast.Expression(body=_tree.body[-1].value)
+        _result = eval(compile(_expr_code, "<cell>", "eval"))
+        if _result is not None:
+            print(f"Out[{''' + str(self._execution_count) + '''}]: " + repr(_result))
+    else:
+        # No trailing expression, just exec everything
+        exec(compile(_code, "<cell>", "exec"))
+except SyntaxError as _e:
+    # Fall back to simple exec for syntax errors in wrapper
+    exec(compile(_code, "<cell>", "exec"))
+'''
+
+        print(f"[IPythonWorker._execute_subprocess_streaming] Running: {python_exe} -c ...", flush=True)
+
         try:
             # Start subprocess
             process = subprocess.Popen(
-                [python_exe, "-c", code],
+                [python_exe, "-c", wrapper_code],
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
@@ -807,8 +857,8 @@ except Exception as e:
                     stdout=accumulated_stdout,
                     stderr=accumulated_stderr,
                     error=ExecuteError(
-                        ename="ExecutionError",
-                        evalue=error_lines[-1] if error_lines else "Unknown error",
+                        type="ExecutionError",
+                        message=error_lines[-1] if error_lines else "Unknown error",
                         traceback=error_lines
                     ),
                     executionCount=self._execution_count,
@@ -827,8 +877,8 @@ except Exception as e:
             return ExecuteResult(
                 success=False,
                 error=ExecuteError(
-                    ename=type(e).__name__,
-                    evalue=str(e),
+                    type=type(e).__name__,
+                    message=str(e),
                     traceback=[]
                 ),
                 executionCount=self._execution_count,