more-compute 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

morecompute/utils/py_percent_parser.py

@@ -0,0 +1,190 @@
+"""Parser for py:percent format (.py files with # %% cell markers)."""
+
+import re
+from typing import List, Dict, Optional
+
+
+def parse_py_percent(content: str) -> Dict:
+    """
+    Parse py:percent format Python file into notebook structure.
+
+    Format:
+        # %%
+        code cell content
+
+        # %% [markdown]
+        # markdown content
+
+    Args:
+        content: Raw .py file content
+
+    Returns:
+        Dict with 'cells' and 'metadata' (compatible with Notebook class)
+    """
+    cells = []
+
+    # Split by cell markers (# %%)
+    # Keep the marker in the split to determine cell type
+    parts = re.split(r'(# %%.*?\n)', content)
+
+    # First part before any cell marker (usually imports/metadata)
+    if parts[0].strip():
+        # Check if it's UV inline script metadata
+        first_part = parts[0].strip()
+        if not first_part.startswith('# /// script'):
+            # It's code, add as first cell
+            cells.append({
+                'cell_type': 'code',
+                'source': parts[0],
+                'metadata': {},
+                'execution_count': None,
+                'outputs': []
+            })
+
+    # Process remaining parts
+    i = 1
+    while i < len(parts):
+        if i >= len(parts):
+            break
+
+        marker = parts[i] if i < len(parts) else ''
+        cell_content = parts[i + 1] if i + 1 < len(parts) else ''
+
+        # Determine cell type from marker
+        if '[markdown]' in marker.lower():
+            cell_type = 'markdown'
+            # Remove leading # from markdown lines
+            lines = cell_content.split('\n')
+            cleaned_lines = []
+            for line in lines:
+                if line.strip().startswith('#'):
+                    # Remove first # and any space after it
+                    cleaned_lines.append(line.strip()[1:].lstrip())
+                else:
+                    cleaned_lines.append(line)
+            cell_content = '\n'.join(cleaned_lines)
+        else:
+            cell_type = 'code'
+
+        # Only add non-empty cells
+        if cell_content.strip():
+            cell = {
+                'cell_type': cell_type,
+                'source': cell_content.strip(),
+                'metadata': {}
+            }
+
+            if cell_type == 'code':
+                cell['execution_count'] = None
+                cell['outputs'] = []
+
+            cells.append(cell)
+
+        i += 2
+
+    return {
+        'cells': cells,
+        'metadata': {
+            'kernelspec': {
+                'display_name': 'Python 3',
+                'language': 'python',
+                'name': 'python3'
+            },
+            'language_info': {
+                'name': 'python',
+                'version': '3.8.0'
+            }
+        },
+        'nbformat': 4,
+        'nbformat_minor': 4
+    }
+
+
+def extract_uv_dependencies(content: str) -> Optional[List[str]]:
+    """
+    Extract UV inline script dependencies from .py file.
+
+    Format:
+        # /// script
+        # dependencies = [
+        #   "package1",
+        #   "package2>=1.0.0",
+        # ]
+        # ///
+
+    Args:
+        content: Raw .py file content
+
+    Returns:
+        List of dependency strings, or None if no dependencies found
+    """
+    # Match UV inline script metadata block
+    pattern = r'# /// script\n(.*?)# ///\n'
+    match = re.search(pattern, content, re.DOTALL)
+
+    if not match:
+        return None
+
+    metadata_block = match.group(1)
+
+    # Extract dependencies list
+    deps_pattern = r'# dependencies = \[(.*?)\]'
+    deps_match = re.search(deps_pattern, metadata_block, re.DOTALL)
+
+    if not deps_match:
+        return None
+
+    deps_str = deps_match.group(1)
+
+    # Parse individual dependencies
+    dependencies = []
+    for line in deps_str.split('\n'):
+        line = line.strip()
+        if line.startswith('#'):
+            line = line[1:].strip()
+        # Remove quotes and trailing comma
+        line = line.strip('"\'').strip(',').strip()
+        if line:
+            dependencies.append(line)
+
+    return dependencies if dependencies else None
+
+
+def generate_py_percent(cells: List[Dict]) -> str:
+    """
+    Generate py:percent format from cell list.
+
+    Args:
+        cells: List of cell dicts with 'cell_type' and 'source'
+
+    Returns:
+        String in py:percent format
+    """
+    lines = []
+
+    for i, cell in enumerate(cells):
+        cell_type = cell.get('cell_type', 'code')
+        source = cell.get('source', '')
+
+        # Ensure source is string
+        if isinstance(source, list):
+            source = ''.join(source)
+
+        # Add cell marker
+        if cell_type == 'markdown':
+            lines.append('# %% [markdown]')
+            # Add # prefix to each line of markdown
+            for line in source.split('\n'):
+                if line.strip():
+                    lines.append(f'# {line}')
+                else:
+                    lines.append('#')
+        else:
+            lines.append('# %%')
+            lines.append(source)
+
+        # Add blank line between cells
+        if i < len(cells) - 1:
+            lines.append('')
+
+    return '\n'.join(lines)

morecompute/utils/special_commands.py

@@ -26,6 +26,10 @@ class AsyncSpecialCommandHandler:
         self.captured_outputs = {}  # Store captured outputs from %%capture
         self.cell_magic_handlers = CellMagicHandlers(globals_dict, self)
         self.line_magic_handlers = LineMagicHandlers(globals_dict)
+        self.current_process: Optional[asyncio.subprocess.Process] = None  # Track current async subprocess for interrupts
+        self.current_process_sync: Optional[subprocess.Popen] = None  # Track current sync subprocess for interrupts
+        self.sync_interrupted: bool = False  # Flag to indicate sync process was interrupted
+        self.stream_tasks: list = []  # Track streaming tasks for cancellation
 
     def is_special_command(self, source_code: Union[str, list, tuple]) -> bool:
         """Check if the source code is a special command or contains shell commands"""
@@ -52,6 +56,9 @@ class AsyncSpecialCommandHandler:
                                     websocket: Optional[WebSocket] = None,
                                     cell_index: Optional[int] = None) -> Dict[str, Any]:
         """Execute a special command and return the result"""
+        # Reset interrupt flag at start of execution
+        self.sync_interrupted = False
+
         text = self._coerce_source_to_text(source_code)
         stripped = text.strip()
 
@@ -103,15 +110,8 @@ class AsyncSpecialCommandHandler:
             env = prepare_shell_environment(command)
             cmd_parts = prepare_shell_command(command)
 
-            # Send execution start notification
-            if websocket:
-                await websocket.send_json({
-                    "type": "execution_start",
-                    "data": {
-                        "command": f"!{command}",
-                        **({"cell_index": cell_index} if cell_index is not None else {})
-                    }
-                })
+            # Note: execution_start is sent by the executor, not here
+            # Sending it twice confuses the frontend
 
             # Create subprocess with streaming
             process = await asyncio.create_subprocess_exec(
@@ -122,34 +122,78 @@ class AsyncSpecialCommandHandler:
                 cwd=os.getcwd()
             )
 
-            # Stream output concurrently
-            stdout_task = asyncio.create_task(
-                self._stream_output(process.stdout, "stdout", result, websocket, cell_index)
-            )
-            stderr_task = asyncio.create_task(
-                self._stream_output(process.stderr, "stderr", result, websocket, cell_index)
-            )
+            # Track process for interrupt handling
+            self.current_process = process
+            print(f"[SPECIAL_CMD] Started subprocess PID={process.pid}", file=sys.stderr, flush=True)
 
-            # Wait for both streams to complete
-            await asyncio.gather(stdout_task, stderr_task)
-
-            # Wait for process completion
-            return_code = await process.wait()
+            try:
+                # Stream output concurrently
+                stdout_task = asyncio.create_task(
+                    self._stream_output(process.stdout, "stdout", result, websocket, cell_index)
+                )
+                stderr_task = asyncio.create_task(
+                    self._stream_output(process.stderr, "stderr", result, websocket, cell_index)
+                )
+
+                # Track tasks for interruption
+                self.stream_tasks = [stdout_task, stderr_task]
+
+                print(f"[SPECIAL_CMD] Waiting for stream tasks to complete...", file=sys.stderr, flush=True)
+                # Wait for both streams to complete
+                await asyncio.gather(stdout_task, stderr_task, return_exceptions=True)
+
+                print(f"[SPECIAL_CMD] Streams complete, waiting for process to exit...", file=sys.stderr, flush=True)
+                # Wait for process completion
+                return_code = await process.wait()
+                print(f"[SPECIAL_CMD] Process exited with code {return_code}", file=sys.stderr, flush=True)
+            except asyncio.CancelledError:
+                # Task was cancelled - treat as interrupt
+                print(f"[SPECIAL_CMD] Task cancelled, treating as interrupt", file=sys.stderr, flush=True)
+                return_code = -15  # SIGTERM
+            except Exception as e:
+                print(f"[SPECIAL_CMD] Exception during execution: {e}", file=sys.stderr, flush=True)
+                import traceback
+                traceback.print_exc()
+                # Set error result
+                result["status"] = "error"
+                result["error"] = {
+                    "output_type": "error",
+                    "ename": type(e).__name__,
+                    "evalue": str(e),
+                    "traceback": traceback.format_exc().split('\n')
+                }
+                return_code = -1
+            finally:
+                # Clear process reference when done
+                self.current_process = None
+                self.stream_tasks = []
+                print(f"[SPECIAL_CMD] Cleared process reference", file=sys.stderr, flush=True)
+
+            # Check if process was interrupted (negative return code means killed by signal)
+            if return_code < 0:
+                print(f"[SPECIAL_CMD] Process was interrupted (return_code={return_code}), setting KeyboardInterrupt error", file=sys.stderr, flush=True)
+                result["status"] = "error"
+                result["error"] = {
+                    "output_type": "error",
+                    "ename": "KeyboardInterrupt",
+                    "evalue": "Execution interrupted by user",
+                    "traceback": []  # No traceback needed for user-initiated interrupt
+                }
+            elif return_code != 0:
+                # Non-zero but positive means command error (not interrupt)
+                result["status"] = "error"
+                result["error"] = {
+                    "output_type": "error",
+                    "ename": "ShellCommandError",
+                    "evalue": f"Command failed with return code {return_code}",
+                    "traceback": [f"Shell command '{command}' failed"]
+                }
 
-            # Send completion notification
-            if websocket:
-                await websocket.send_json({
-                    "type": "execution_complete",
-                    "data": {
-                        "return_code": return_code,
-                        "status": "error" if return_code != 0 else "ok",
-                        **({"cell_index": cell_index} if cell_index is not None else {})
-                    }
-                })
+            print(f"[SPECIAL_CMD] Returning result: status={result['status']}, return_code={return_code}", file=sys.stderr, flush=True)
 
             # If pip install/uninstall occurred, notify clients to refresh packages
             try:
-                if websocket and (command.startswith('pip install') or command.startswith('pip uninstall') or 'pip install' in command or 'pip uninstall' in command):
+                if websocket and return_code == 0 and (command.startswith('pip install') or command.startswith('pip uninstall') or 'pip install' in command or 'pip uninstall' in command):
                     # Small delay to ensure pip finishes writing metadata to disk
                     await asyncio.sleep(0.5)
                     await websocket.send_json({
@@ -159,21 +203,6 @@ class AsyncSpecialCommandHandler:
             except Exception:
                 pass
 
-            # Check if command failed
-            if return_code != 0:
-                result["status"] = "error"
-                # Only add generic error if we don't already have detailed stderr output
-                # The detailed stderr is already in result["outputs"] from streaming
-                has_stderr = any(o.get("name") == "stderr" and o.get("text", "").strip()
-                               for o in result.get("outputs", []))
-                if not has_stderr:
-                    # No detailed error output, add generic error
-                    result["error"] = {
-                        "ename": "ShellCommandError",
-                        "evalue": f"Command failed with return code {return_code}",
-                        "traceback": [f"Shell command failed: {command}"]
-                    }
-
         except Exception as e:
             result["status"] = "error"
             result["error"] = {
@@ -195,8 +224,56 @@ class AsyncSpecialCommandHandler:
         return result
 
     async def interrupt(self):
-        # Placeholder for future process-based interruption logic
-        return
+        """Interrupt the currently running subprocess"""
+        # Cancel stream tasks first
+        for task in self.stream_tasks:
+            if not task.done():
+                print(f"[SPECIAL_CMD] Cancelling stream task", file=sys.stderr, flush=True)
+                task.cancel()
+
+        # Interrupt async subprocess
+        if self.current_process:
+            try:
+                print(f"[SPECIAL_CMD] Interrupting async subprocess PID={self.current_process.pid}", file=sys.stderr, flush=True)
+                self.current_process.terminate()
+
+                # Give it a moment to terminate gracefully
+                try:
+                    await asyncio.wait_for(self.current_process.wait(), timeout=1.0)
+                    print(f"[SPECIAL_CMD] Async subprocess terminated gracefully", file=sys.stderr, flush=True)
+                except asyncio.TimeoutError:
+                    # Force kill if it doesn't terminate
+                    print(f"[SPECIAL_CMD] Async subprocess didn't terminate, force killing", file=sys.stderr, flush=True)
+                    self.current_process.kill()
+                    await self.current_process.wait()
+                    print(f"[SPECIAL_CMD] Async subprocess killed", file=sys.stderr, flush=True)
+
+            except Exception as e:
+                print(f"[SPECIAL_CMD] Error interrupting async subprocess: {e}", file=sys.stderr, flush=True)
+
+        # Interrupt sync subprocess
+        if self.current_process_sync:
+            try:
+                print(f"[SPECIAL_CMD] Interrupting sync subprocess PID={self.current_process_sync.pid}", file=sys.stderr, flush=True)
+                self.sync_interrupted = True  # Set flag so shell commands know to stop
+                self.current_process_sync.terminate()
+
+                # Give it a moment to terminate gracefully
+                try:
+                    self.current_process_sync.wait(timeout=1.0)
+                    print(f"[SPECIAL_CMD] Sync subprocess terminated gracefully", file=sys.stderr, flush=True)
+                except subprocess.TimeoutExpired:
+                    # Force kill if it doesn't terminate
+                    print(f"[SPECIAL_CMD] Sync subprocess didn't terminate, force killing", file=sys.stderr, flush=True)
+                    self.current_process_sync.kill()
+                    self.current_process_sync.wait()
+                    print(f"[SPECIAL_CMD] Sync subprocess killed", file=sys.stderr, flush=True)
+
+            except Exception as e:
+                print(f"[SPECIAL_CMD] Error interrupting sync subprocess: {e}", file=sys.stderr, flush=True)
+
+        if not self.current_process and not self.current_process_sync:
+            print(f"[SPECIAL_CMD] No subprocess to interrupt", file=sys.stderr, flush=True)
 
     async def _stream_output(self, stream, stream_type: str, result: Dict[str, Any],
                            websocket: Optional[WebSocket] = None,