more-compute 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

morecompute/execution/executor.py

@@ -157,10 +157,8 @@ class NextZmqExecutor:
                         normalized_source, result, start_time, execution_count, websocket, cell_index
                     )
                     result['execution_time'] = f"{(time.time()-start_time)*1000:.1f}ms"
-                    print(f"[EXECUTOR] Sending execution_complete for cell {cell_index}, status={result.get('status')}, has_error={result.get('error') is not None}", file=sys.stderr, flush=True)
                     if websocket:
                         await websocket.send_json({'type': 'execution_complete', 'data': {'cell_index': cell_index, 'result': result}})
-                        print(f"[EXECUTOR] Sent execution_complete successfully", file=sys.stderr, flush=True)
                     return result
                 # For remote execution OR mixed commands, fall through to send via ZMQ
 
@@ -178,14 +176,12 @@ class NextZmqExecutor:
         while True:
             # Check if this cell was interrupted
             if self.interrupted_cell == cell_index and interrupted_time is None:
-                print(f"[EXECUTE] Cell {cell_index} was interrupted, waiting for subprocess to be killed...", file=sys.stderr, flush=True)
                 interrupted_time = time.time()
                 # Don't break immediately - wait for execution_complete from worker
                 # Give worker 5 seconds to kill subprocess and send completion
 
             # If interrupted and waited long enough, force break
             if interrupted_time and (time.time() - interrupted_time > 5.0):
-                print(f"[EXECUTE] Cell {cell_index} interrupt timeout, breaking out", file=sys.stderr, flush=True)
                 self.interrupted_cell = None  # Clear the flag
                 result.update({
                     'status': 'error',
@@ -200,7 +196,6 @@ class NextZmqExecutor:
 
             # Timeout check for stuck operations
             if time.time() - start_time > max_wait:
-                print(f"[EXECUTE] Cell {cell_index} exceeded max wait time, timing out", file=sys.stderr, flush=True)
                 result.update({
                     'status': 'error',
                     'error': {
@@ -236,7 +231,6 @@ class NextZmqExecutor:
                 result.setdefault('execution_count', execution_count)
                 # Clear interrupted flag if this was interrupted
                 if self.interrupted_cell == cell_index:
-                    print(f"[EXECUTE] Cell {cell_index} completed after interrupt", file=sys.stderr, flush=True)
                     self.interrupted_cell = None
                 break
 
@@ -248,16 +242,14 @@ class NextZmqExecutor:
             self.req.setsockopt(zmq.RCVTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
         except zmq.Again:
             # Timeout - worker didn't reply (probably killed), need to reset socket
-            print(f"[EXECUTE] Worker didn't reply, resetting REQ socket", file=sys.stderr, flush=True)
             try:
                 self.req.close(0)  # type: ignore[reportAttributeAccessIssue]
                 self.req = self.ctx.socket(zmq.REQ)  # type: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
                 self.req.connect(self.cmd_addr)  # type: ignore[reportAttributeAccessIssue]
-            except Exception as e:
-                print(f"[EXECUTE] Error resetting socket: {e}", file=sys.stderr, flush=True)
-        except Exception as e:
+            except Exception:
+                pass
+        except Exception:
             # Some other error, also reset socket to be safe
-            print(f"[EXECUTE] Error receiving reply: {e}, resetting socket", file=sys.stderr, flush=True)
             try:
                 self.req.setsockopt(zmq.RCVTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
                 self.req.close(0)  # type: ignore[reportAttributeAccessIssue]
@@ -272,13 +264,9 @@ class NextZmqExecutor:
 
     async def interrupt_kernel(self, cell_index: int | None = None) -> None:
         """Interrupt the kernel using the control socket"""
-        import sys
-        print(f"[INTERRUPT] Starting interrupt for cell {cell_index}", file=sys.stderr, flush=True)
-
         # Mark this cell as interrupted so execute_cell can break out
         if isinstance(cell_index, int):
             self.interrupted_cell = cell_index
-            print(f"[INTERRUPT] Marked cell {cell_index} as interrupted", file=sys.stderr, flush=True)
 
         payload: dict[str, object] = {'type': 'interrupt'}
         if isinstance(cell_index, int):
@@ -290,11 +278,8 @@ class NextZmqExecutor:
             self.ctrl.setsockopt(zmq.RCVTIMEO, 1000)  # type: ignore[reportAttributeAccessIssue]
             self.ctrl.send_json(payload)  # type: ignore[reportAttributeAccessIssue]
             _ = cast(dict[str, object], self.ctrl.recv_json())  # type: ignore[reportAttributeAccessIssue]
-            print(f"[INTERRUPT] Sent interrupt signal to worker via control socket", file=sys.stderr, flush=True)
-        except Exception as e:
-            print(f"[INTERRUPT] Could not send interrupt signal: {e}", file=sys.stderr, flush=True)
+        except Exception:
             # If control socket fails, try force-kill immediately
-            print(f"[INTERRUPT] Force killing worker immediately...", file=sys.stderr, flush=True)
             await self._force_kill_worker()
         finally:
             # Reset timeouts
@@ -308,46 +293,37 @@ class NextZmqExecutor:
             except Exception:
                 pass
 
-        print(f"[INTERRUPT] Interrupt complete", file=sys.stderr, flush=True)
-
     async def _force_kill_worker(self) -> None:
         """Force kill the worker process and respawn"""
-        import sys
-        print(f"[FORCE_KILL] Killing worker PID={self.worker_pid}", file=sys.stderr, flush=True)
-
         if self.worker_pid:
             try:
                 # For blocking I/O, SIGKILL immediately - no mercy
-                print(f"[FORCE_KILL] Sending SIGKILL to {self.worker_pid}", file=sys.stderr, flush=True)
                 os.kill(self.worker_pid, signal.SIGKILL)
                 await asyncio.sleep(0.1)  # Brief wait for process to die
             except ProcessLookupError:
-                print(f"[FORCE_KILL] Process {self.worker_pid} already dead", file=sys.stderr, flush=True)
-            except Exception as e:
-                print(f"[FORCE_KILL] Error killing PID {self.worker_pid}: {e}", file=sys.stderr, flush=True)
+                pass
+            except Exception:
+                pass
 
         # Also try via Popen object if available
         if self.worker_proc:
             try:
-                print(f"[FORCE_KILL] Killing via Popen object", file=sys.stderr, flush=True)
                 self.worker_proc.kill()  # SIGKILL directly
                 await asyncio.sleep(0.1)
-            except Exception as e:
-                print(f"[FORCE_KILL] Error killing via Popen: {e}", file=sys.stderr, flush=True)
+            except Exception:
+                pass
 
         # CRITICAL: Reset socket state - close and recreate
         # The REQ socket may be waiting for a reply from the dead worker
         try:
-            print(f"[FORCE_KILL] Resetting REQ and CTRL sockets", file=sys.stderr, flush=True)
             self.req.close(0)  # type: ignore[reportAttributeAccessIssue]
             self.req = self.ctx.socket(zmq.REQ)  # type: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             self.req.connect(self.cmd_addr)  # type: ignore[reportAttributeAccessIssue]
             self.ctrl.close(0)  # type: ignore[reportAttributeAccessIssue]
             self.ctrl = self.ctx.socket(zmq.DEALER)  # type: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             self.ctrl.connect(self.ctrl_addr)  # type: ignore[reportAttributeAccessIssue]
-            print(f"[FORCE_KILL] Socket reset complete", file=sys.stderr, flush=True)
-        except Exception as e:
-            print(f"[FORCE_KILL] Error resetting sockets: {e}", file=sys.stderr, flush=True)
+        except Exception:
+            pass
 
         # Respawn worker
         try:
@@ -357,27 +333,21 @@ class NextZmqExecutor:
 
     def reset_kernel(self) -> None:
         """Reset the kernel by shutting down worker and restarting"""
-        import sys
-        print(f"[RESET] Starting kernel reset, worker_pid={self.worker_pid}, is_remote={self.is_remote}", file=sys.stderr, flush=True)
-
         # If connected to remote GPU, DON'T kill the worker - just send shutdown message
         if self.is_remote:
-            print(f"[RESET] Remote worker - sending shutdown message only", file=sys.stderr, flush=True)
             try:
                 self.req.setsockopt(zmq.SNDTIMEO, 2000)  # type: ignore[reportAttributeAccessIssue]
                 self.req.setsockopt(zmq.RCVTIMEO, 2000)  # type: ignore[reportAttributeAccessIssue]
                 self.req.send_json({'type': 'shutdown'})  # type: ignore[reportAttributeAccessIssue]
                 _ = cast(dict[str, object], self.req.recv_json())  # type: ignore[reportAttributeAccessIssue]
-                print(f"[RESET] Remote worker acknowledged shutdown", file=sys.stderr, flush=True)
-            except Exception as e:
-                print(f"[RESET] Remote worker shutdown failed: {e}", file=sys.stderr, flush=True)
+            except Exception:
+                pass
             finally:
                 self.req.setsockopt(zmq.SNDTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
                 self.req.setsockopt(zmq.RCVTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
 
             # Reset execution count but don't respawn worker
             self.execution_count = 0
-            print(f"[RESET] Remote kernel reset complete", file=sys.stderr, flush=True)
             return
 
         # Local worker mode - try graceful shutdown first
@@ -386,9 +356,8 @@ class NextZmqExecutor:
             self.req.setsockopt(zmq.RCVTIMEO, 500)  # type: ignore[reportAttributeAccessIssue]
             self.req.send_json({'type': 'shutdown'})  # type: ignore[reportAttributeAccessIssue]
             _ = cast(dict[str, object], self.req.recv_json())  # type: ignore[reportAttributeAccessIssue]
-            print(f"[RESET] Sent graceful shutdown message", file=sys.stderr, flush=True)
-        except Exception as e:
-            print(f"[RESET] Graceful shutdown failed: {e}", file=sys.stderr, flush=True)
+        except Exception:
+            pass
         finally:
             self.req.setsockopt(zmq.SNDTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
             self.req.setsockopt(zmq.RCVTIMEO, -1)  # type: ignore[reportAttributeAccessIssue]
@@ -396,35 +365,30 @@ class NextZmqExecutor:
         # Force kill local worker if needed
         if self.worker_pid:
             try:
-                print(f"[RESET] Sending SIGTERM to worker PID {self.worker_pid}", file=sys.stderr, flush=True)
                 os.kill(self.worker_pid, signal.SIGTERM)
                 time.sleep(0.3)  # Give it time to shutdown gracefully
                 try:
                     # Check if still alive
                     os.kill(self.worker_pid, 0)
                     # Still alive, force kill
-                    print(f"[RESET] Worker still alive, sending SIGKILL", file=sys.stderr, flush=True)
                     os.kill(self.worker_pid, signal.SIGKILL)
                     time.sleep(0.2)  # Wait for SIGKILL to complete
                 except ProcessLookupError:
-                    print(f"[RESET] Worker process terminated", file=sys.stderr, flush=True)
-            except Exception as e:
-                print(f"[RESET] Error killing worker: {e}", file=sys.stderr, flush=True)
+                    pass
+            except Exception:
+                pass
 
         if self.worker_proc:
             try:
                 self.worker_proc.terminate()
                 self.worker_proc.wait(timeout=1)
-                print(f"[RESET] Worker process terminated via Popen", file=sys.stderr, flush=True)
             except Exception:
                 try:
                     self.worker_proc.kill()
-                    print(f"[RESET] Worker process killed via Popen", file=sys.stderr, flush=True)
-                except Exception as e:
-                    print(f"[RESET] Error killing via Popen: {e}", file=sys.stderr, flush=True)
+                except Exception:
+                    pass
 
         # Close sockets first, BEFORE recreating them
-        print(f"[RESET] Closing old sockets", file=sys.stderr, flush=True)
         try:
             self.req.close(0)  # type: ignore[reportAttributeAccessIssue]
         except Exception:
@@ -436,7 +400,6 @@ class NextZmqExecutor:
 
         # Wait for ZMQ to release the sockets (critical!)
         time.sleep(0.5)
-        print(f"[RESET] Sockets closed, waited for cleanup", file=sys.stderr, flush=True)
 
         # Reset state
         self.execution_count = 0
@@ -445,14 +408,12 @@ class NextZmqExecutor:
 
         # Recreate sockets
         try:
-            print(f"[RESET] Creating new sockets", file=sys.stderr, flush=True)
             self.req = self.ctx.socket(zmq.REQ)  # type: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             self.req.connect(self.cmd_addr)  # type: ignore[reportAttributeAccessIssue]
             self.ctrl = self.ctx.socket(zmq.DEALER)  # type: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
             self.ctrl.connect(self.ctrl_addr)  # type: ignore[reportAttributeAccessIssue]
-            print(f"[RESET] New sockets created successfully", file=sys.stderr, flush=True)
-        except Exception as e:
-            print(f"[RESET] Error creating sockets: {e}", file=sys.stderr, flush=True)
+        except Exception:
+            pass
 
         # Reset special handler
         if self.special_handler is not None:
@@ -460,10 +421,6 @@ class NextZmqExecutor:
 
         # Respawn worker
         try:
-            print(f"[RESET] Respawning new worker", file=sys.stderr, flush=True)
             self._ensure_worker()
-            print(f"[RESET] Kernel reset complete, new worker_pid={self.worker_pid}", file=sys.stderr, flush=True)
-        except Exception as e:
-            print(f"[RESET] Error respawning worker: {e}", file=sys.stderr, flush=True)
-            import traceback
-            traceback.print_exc()
+        except Exception:
+            pass

morecompute/execution/worker.py

@@ -58,7 +58,6 @@ def _inject_shell_command_function(globals_dict: dict):
 
             # Check if already interrupted before starting new command
             if _interrupt_requested:
-                print(f"[WORKER] Shell command skipped due to previous interrupt", file=sys.stderr, flush=True)
                 raise KeyboardInterrupt("Execution was interrupted")
 
             # Prepare command and environment (using shared utilities)
@@ -80,12 +79,6 @@ def _inject_shell_command_function(globals_dict: dict):
             _current_subprocess = process
             if os.name != 'nt':
                 _current_process_group = os.getpgid(process.pid)
-                # Also create a new process group for clean killing
-                print(f"[WORKER] Started subprocess PID={process.pid}, PGID={_current_process_group}", file=sys.stderr, flush=True)
-            else:
-                print(f"[WORKER] Started subprocess PID={process.pid}", file=sys.stderr, flush=True)
-
-            sys.stderr.flush()
 
             try:
                 # Stream output line by line
@@ -120,7 +113,6 @@ def _inject_shell_command_function(globals_dict: dict):
                     except subprocess.TimeoutExpired:
                         # Check if interrupted
                         if _interrupt_requested:
-                            print(f"[WORKER] Interrupt detected, killing subprocess", file=sys.stderr, flush=True)
                             try:
                                 process.kill()
                             except Exception:
@@ -135,7 +127,6 @@ def _inject_shell_command_function(globals_dict: dict):
                             except Exception:
                                 pass
                             # Don't wait for process or threads - raise immediately
-                            print(f"[WORKER] Raising KeyboardInterrupt immediately", file=sys.stderr, flush=True)
                             raise KeyboardInterrupt("Execution interrupted by user")
 
                 # Normal completion - join threads briefly
@@ -235,63 +226,34 @@ def control_thread_main(ctrl, current_cell_ref):
     """Run control channel in separate thread (Jupyter pattern)"""
     global _interrupt_requested, _current_subprocess, _current_process_group
 
-    print(f"[CONTROL] Control thread started", file=sys.stderr, flush=True)
-
     while True:
         try:
             # Block waiting for control messages
             identity = ctrl.recv()
             msg = ctrl.recv_json()
 
-            print(f"[CONTROL] Received: {msg}", file=sys.stderr, flush=True)
-
             mtype = msg.get('type')
             if mtype == 'interrupt':
                 requested_cell = msg.get('cell_index')
                 current_cell = current_cell_ref[0]
 
-                print(f"[CONTROL] Interrupt check: requested={requested_cell}, current={current_cell}, subprocess={_current_subprocess}, pgid={_current_process_group}", file=sys.stderr)
-                sys.stderr.flush()
-
                 if requested_cell is None or requested_cell == current_cell:
-                    print(f"[CONTROL] ✓ Match! Processing interrupt for cell {requested_cell}", file=sys.stderr)
-                    sys.stderr.flush()
-
                     # Set global flag
                     _interrupt_requested = True
 
                     # Send SIGINT to process group (Jupyter pattern)
                     if _current_process_group and os.name != 'nt':
                         try:
-                            print(f"[CONTROL] Sending SIGINT to process group {_current_process_group}", file=sys.stderr)
-                            sys.stderr.flush()
                             os.killpg(_current_process_group, signal.SIGINT)
-                            print(f"[CONTROL] SIGINT sent successfully", file=sys.stderr)
-                            sys.stderr.flush()
-                        except Exception as e:
-                            print(f"[CONTROL] Failed to kill process group: {e}", file=sys.stderr)
-                            sys.stderr.flush()
+                        except Exception:
+                            pass
 
                     # Also kill subprocess directly
                     if _current_subprocess:
                         try:
-                            print(f"[CONTROL] Killing subprocess PID={_current_subprocess.pid}", file=sys.stderr)
-                            sys.stderr.flush()
                             _current_subprocess.kill()
-                            print(f"[CONTROL] Subprocess killed", file=sys.stderr)
-                            sys.stderr.flush()
-                        except Exception as e:
-                            print(f"[CONTROL] Failed to kill subprocess: {e}", file=sys.stderr)
-                            sys.stderr.flush()
-
-                    # Don't send SIGINT to self - let the execution thread finish gracefully
-                    # Sending SIGINT here can interrupt the execution thread before it sends
-                    # completion messages, leaving the frontend in a confused state
-                    print(f"[CONTROL] Interrupt signal sent, waiting for execution thread to finish", file=sys.stderr)
-                    sys.stderr.flush()
-                else:
-                    print(f"[CONTROL] ✗ NO MATCH! Ignoring interrupt (requested cell {requested_cell} != current cell {current_cell})", file=sys.stderr)
-                    sys.stderr.flush()
+                        except Exception:
+                            pass
 
                 # Reply
                 ctrl.send(identity, zmq.SNDMORE)
@@ -302,27 +264,18 @@ def control_thread_main(ctrl, current_cell_ref):
                 ctrl.send_json({'ok': True, 'pid': os.getpid()})
                 break
 
-        except Exception as e:
-            print(f"[CONTROL] Error: {e}", file=sys.stderr, flush=True)
-            import traceback
-            traceback.print_exc()
+        except Exception:
+            pass
 
 
 def worker_main():
     global _current_subprocess, _interrupt_requested, _current_process_group
 
-    print(f"[WORKER] ========================================", file=sys.stderr, flush=True)
-    print(f"[WORKER] Starting THREADED worker (new code!)", file=sys.stderr, flush=True)
-    print(f"[WORKER] PID: {os.getpid()}", file=sys.stderr, flush=True)
-    print(f"[WORKER] ========================================", file=sys.stderr, flush=True)
-
     _setup_signals()
     cmd_addr = os.environ['MC_ZMQ_CMD_ADDR']
     pub_addr = os.environ['MC_ZMQ_PUB_ADDR']
     ctrl_addr = os.environ.get('MC_ZMQ_CTRL_ADDR', cmd_addr.replace('5555', '5557'))
 
-    print(f"[WORKER] Binding to control socket: {ctrl_addr}", file=sys.stderr, flush=True)
-
     ctx = zmq.Context.instance()
     rep = ctx.socket(zmq.REP)
     rep.bind(cmd_addr)
@@ -341,7 +294,6 @@ def worker_main():
     # Start control thread (Jupyter pattern)
     ctrl_thread = threading.Thread(target=control_thread_main, args=(ctrl, current_cell_ref), daemon=True)
     ctrl_thread.start()
-    print(f"[WORKER] Started control thread", file=sys.stderr, flush=True)
 
     # Persistent REPL state
     g = {"__name__": "__main__"}
@@ -380,9 +332,7 @@ def worker_main():
             cell_index = msg.get('cell_index')
             requested_count = msg.get('execution_count')
 
-            print(f"[WORKER] Setting current_cell_ref[0] = {cell_index}", file=sys.stderr, flush=True)
             current_cell_ref[0] = cell_index  # Update for control thread
-            print(f"[WORKER] Confirmed current_cell_ref[0] = {current_cell_ref[0]}", file=sys.stderr, flush=True)
 
             if isinstance(requested_count, int):
                 exec_count = requested_count - 1
@@ -404,7 +354,6 @@ def worker_main():
 
                 try:
                     shell_cmd = code.strip()[1:].strip()
-                    print(f"[WORKER] Executing shell: {shell_cmd[:50]}...", file=sys.stderr, flush=True)
 
                     # Run shell command with streaming
                     process = subprocess.Popen(
@@ -453,7 +402,6 @@ def worker_main():
                                 break
                             except subprocess.TimeoutExpired:
                                 if _interrupt_requested:
-                                    print(f"[WORKER] Interrupt detected, killing shell process", file=sys.stderr, flush=True)
                                     try:
                                         process.kill()
                                     except Exception:
@@ -468,7 +416,6 @@ def worker_main():
                                     except Exception:
                                         pass
                                     # Set interrupted status immediately
-                                    print(f"[WORKER] Setting error status for interrupted shell command", file=sys.stderr, flush=True)
                                     status = 'error'
                                     error_payload = {
                                         'ename': 'KeyboardInterrupt',
@@ -484,8 +431,6 @@ def worker_main():
                             stdout_thread.join(timeout=0.1)
                             stderr_thread.join(timeout=0.1)
 
-                            print(f"[WORKER] Shell process finished: return_code={return_code}", file=sys.stderr, flush=True)
-
                             # Check return code
                             if return_code != 0:
                                 status = 'error'
@@ -494,7 +439,6 @@ def worker_main():
                                     'evalue': f'Command failed with return code {return_code}',
                                     'traceback': [f'Shell command failed: {shell_cmd}']
                                 }
-                                print(f"[WORKER] Set error_payload to ShellCommandError", file=sys.stderr, flush=True)
                     except KeyboardInterrupt:
                         status = 'error'
                         error_payload = {
@@ -511,17 +455,12 @@ def worker_main():
                     error_payload = {'ename': type(exc).__name__, 'evalue': str(exc), 'traceback': traceback.format_exc().split('\n')}
 
                 duration_ms = f"{(time.time()-start)*1000:.1f}ms"
-                print(f"[WORKER] Sending completion messages: status={status}, error={error_payload is not None}", file=sys.stderr, flush=True)
                 if error_payload:
                     pub.send_json({'type': 'execution_error', 'cell_index': cell_index, 'error': error_payload})
-                    print(f"[WORKER] Sent execution_error", file=sys.stderr, flush=True)
                 pub.send_json({'type': 'execution_complete', 'cell_index': cell_index, 'result': {'status': status, 'execution_count': exec_count, 'execution_time': duration_ms, 'outputs': [], 'error': error_payload}})
-                print(f"[WORKER] Sent execution_complete", file=sys.stderr, flush=True)
                 rep.send_json({'ok': True, 'pid': os.getpid()})
 
-                print(f"[WORKER] Clearing current_cell_ref[0] (was {current_cell_ref[0]})", file=sys.stderr, flush=True)
                 current_cell_ref[0] = None
-                print(f"[WORKER] Confirmed current_cell_ref[0] = {current_cell_ref[0]}", file=sys.stderr, flush=True)
                 continue
 
             # Regular Python code execution
@@ -590,17 +529,12 @@ def worker_main():
                 sys.stdout, sys.stderr = old_out, old_err
             exec_count += 1
             duration_ms = f"{(time.time()-start)*1000:.1f}ms"
-            print(f"[WORKER] Sending completion messages (Python): status={status}, error={error_payload is not None}", file=sys.stderr, flush=True)
             if error_payload:
                 pub.send_json({'type': 'execution_error', 'cell_index': cell_index, 'error': error_payload})
-                print(f"[WORKER] Sent execution_error", file=sys.stderr, flush=True)
             pub.send_json({'type': 'execution_complete', 'cell_index': cell_index, 'result': {'status': status, 'execution_count': exec_count, 'execution_time': duration_ms, 'outputs': [], 'error': error_payload}})
-            print(f"[WORKER] Sent execution_complete", file=sys.stderr, flush=True)
             rep.send_json({'ok': True, 'pid': os.getpid()})
 
-            print(f"[WORKER] Clearing current_cell_ref[0] (was {current_cell_ref[0]})", file=sys.stderr, flush=True)
             current_cell_ref[0] = None
-            print(f"[WORKER] Confirmed current_cell_ref[0] = {current_cell_ref[0]}", file=sys.stderr, flush=True)
 
     try:
         rep.close(0); pub.close(0); ctrl.close(0)

morecompute/models/api_models.py

@@ -195,3 +195,65 @@ class AvailabilityQuery(BaseModel):
     gpu_count: int | None = None
     gpu_type: str | None = None
     security: str | None = None
+
+
+# ============================================================================
+# Multi-Provider API Models
+# ============================================================================
+
+class ProviderInfo(BaseModel):
+    """Information about a GPU cloud provider."""
+    name: str  # Internal name (e.g., "runpod")
+    display_name: str  # Human-readable name (e.g., "RunPod")
+    api_key_env_name: str  # Environment variable name
+    supports_ssh: bool  # Whether provider supports SSH connections
+    dashboard_url: str  # URL to get API key
+    configured: bool = False  # Whether API key is configured
+    is_active: bool = False  # Whether this is the currently active provider
+
+
+class ProviderListResponse(BaseModel):
+    """Response model for listing providers."""
+    providers: list[ProviderInfo]
+    active_provider: str | None = None
+
+
+class ProviderConfigRequest(BaseModel):
+    """Request model for configuring a provider API key."""
+    api_key: str
+    token_secret: str | None = None  # For Modal which requires two tokens
+    make_active: bool = False  # Whether to make this the active provider
+
+
+class SetActiveProviderRequest(BaseModel):
+    """Request model for setting the active provider."""
+    provider: str
+
+
+class GpuAvailabilityResponse(BaseModel):
+    """Response model for GPU availability."""
+    data: list[dict]
+    total_count: int
+    provider: str
+    note: str | None = None
+
+
+class PodListResponse(BaseModel):
+    """Response model for listing pods."""
+    data: list[dict]
+    total_count: int
+    offset: int
+    limit: int
+    provider: str
+
+
+class PodWithProvider(PodResponse):
+    """Pod response with provider information."""
+    provider: str = "prime_intellect"
+
+
+class CreatePodWithProviderRequest(BaseModel):
+    """Request to create a pod with explicit provider selection."""
+    pod: PodConfig
+    provider_name: str  # Provider to use (e.g., "runpod", "lambda_labs")
+    team: TeamConfig | None = None

morecompute/notebook.py

@@ -127,6 +127,17 @@ class Notebook:
                         cell['id'] = self._generate_cell_id()
                     self.cells.append(cell)
 
+                # Ensure at least one empty cell exists 
+                if not self.cells:
+                    self.cells.append({
+                        'id': self._generate_cell_id(),
+                        'cell_type': 'code',
+                        'source': '',
+                        'metadata': {},
+                        'outputs': [],
+                        'execution_count': None
+                    })
+
                 self.metadata = data.get('metadata', {})
                 self.file_path = file_path