agentic-python-coder 3.4.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

agentic_python_coder/kernel.py

@@ -220,13 +220,13 @@ except ImportError:
         self._execute_raw(startup_code)
 
     def _cleanup_on_error(self):
-        """Clean up resources if initialization fails."""
+        """Clean up resources if initialization fails.
+
+        Routes through shutdown() so a partially-started kernel tree gets
+        the same defensive process-group kill as a healthy one.
+        """
         try:
-            if hasattr(self, "kc") and self.kc:
-                self.kc.stop_channels()
-            if hasattr(self, "km") and self.km:
-                if self.km.is_alive():
-                    self.km.shutdown_kernel(now=True)
+            self.shutdown()
         except Exception:
             pass  # Best effort cleanup
 
@@ -627,6 +627,33 @@ def shutdown_all_kernels():
             pass  # Best effort
 
 
+def kill_all_kernel_process_groups():
+    """Hard-kill (SIGKILL) every registered kernel's process group.
+
+    Deliberately lock-free: this is the termination path, where a busy
+    kernel's _exec_lock may be held indefinitely by an in-flight execution
+    and the graceful shutdown_all_kernels() would block behind it. Snapshot
+    the registry and signal each group directly. Never signals our own
+    process group. Kernels mid-creation (registry slot still None) cannot
+    be reached here — that sub-second window is a known limitation.
+    """
+    try:
+        own_pgid = os.getpgid(0)
+    except OSError:
+        own_pgid = None
+
+    for state in list(_kernels.values()):
+        if state is None:
+            continue
+        try:
+            km = state.kernel.km
+            pgid = getattr(getattr(km, "provisioner", None), "pgid", None)
+            if pgid and pgid > 0 and pgid != own_pgid:
+                os.killpg(pgid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError, AttributeError):
+            pass  # Best effort
+
+
 # =============================================================================
 # Backward Compatibility API
 # =============================================================================

agentic_python_coder/mcp_server.py

@@ -21,6 +21,7 @@ from agentic_python_coder.kernel import (
     execute_in_kernel,
     interrupt_kernel_by_id,
     kernel_exists,
+    kill_all_kernel_process_groups,
     list_kernels,
     restart_kernel,
     shutdown_all_kernels,
@@ -36,6 +37,7 @@ server = Server("ipython_mcp")
 MAX_OUTPUT = 100 * 1024  # 100KB truncation limit
 MAX_TIMEOUT = 300  # Maximum allowed timeout in seconds
 DEFAULT_TIMEOUT = 30  # Default timeout in seconds
+STATUS_PROBE_TIMEOUT = 10  # Timeout for python_status introspection probes
 KERNEL_TIMEOUT_BUFFER = 5  # Extra seconds for kernel deadline vs asyncio timeout
 
 # Async lock for session operations (default kernel management)
@@ -346,7 +348,9 @@ versions
                     % packages
                 )
                 try:
-                    result = await execute_with_timeout(version_code, 30, kernel_id)
+                    result = await execute_with_timeout(
+                        version_code, DEFAULT_TIMEOUT, kernel_id
+                    )
                     if result.get("result"):
                         versions = ast.literal_eval(result["result"])
                         if isinstance(versions, dict):
@@ -430,8 +434,11 @@ versions
             except SyntaxError as e:
                 payload = {
                     "ok": False,
-                    "error": f"Syntax error at line {e.lineno}: {e.msg}",
+                    "error": f"Syntax error at line {e.lineno or '?'}: {e.msg}",
                 }
+            except ValueError as e:
+                # compile() raises ValueError e.g. for null bytes in source
+                payload = {"ok": False, "error": f"Invalid source: {e}"}
         return [TextContent(type="text", text=json.dumps(payload))]
 
     elif name == "python_status":
@@ -455,7 +462,7 @@ versions
             # Get Python version
             try:
                 result = await execute_with_timeout(
-                    "import sys; sys.version", 10, kernel_id
+                    "import sys; sys.version", STATUS_PROBE_TIMEOUT, kernel_id
                 )
                 if result.get("result"):
                     status["python_version"] = result["result"].strip("'\"")
@@ -469,7 +476,9 @@ import importlib.metadata
 [f"{d.metadata['Name']} {d.version}" for d in importlib.metadata.distributions()
  if d.metadata['Name'] not in ('pip', 'setuptools', 'wheel', 'ipykernel', 'jupyter-client')][:20]
 """
-                result = await execute_with_timeout(pkg_code, 10, kernel_id)
+                result = await execute_with_timeout(
+                    pkg_code, STATUS_PROBE_TIMEOUT, kernel_id
+                )
                 if result.get("result"):
                     status["packages"] = ast.literal_eval(result["result"])
             except Exception:
@@ -481,7 +490,9 @@ import importlib.metadata
 [name for name in dir() if not name.startswith('_')
  and name not in ('In', 'Out', 'get_ipython', 'exit', 'quit', 'open')]
 """
-                result = await execute_with_timeout(var_code, 10, kernel_id)
+                result = await execute_with_timeout(
+                    var_code, STATUS_PROBE_TIMEOUT, kernel_id
+                )
                 if result.get("result"):
                     status["variables"] = ast.literal_eval(result["result"])
             except Exception:
@@ -567,16 +578,25 @@ async def run_server():
 # Hard-exit fallback if kernel cleanup hangs after a termination signal
 _TERMINATION_CLEANUP_TIMEOUT = 10.0
 
+# Set on the first termination signal; later signals are ignored instead of
+# stacking additional timers and cleanup threads
+_terminating = threading.Event()
+
 
 def _handle_termination(signum, frame):
     """Shut down all kernels on SIGTERM/SIGINT, then exit.
 
-    The cleanup runs in a thread (not in signal-handler context) so it can
-    safely take the kernel-registry locks; a timer hard-exits if it hangs.
+    Kernel process groups are hard-killed first (lock-free, cannot block on
+    a busy kernel's exec lock); the graceful registry cleanup then runs in a
+    thread, with a timer that hard-exits if it hangs.
     """
+    if _terminating.is_set():
+        return
+    _terminating.set()
 
     def _cleanup_and_exit():
         try:
+            kill_all_kernel_process_groups()
             shutdown_all_kernels()
         finally:
             os._exit(128 + signum)
@@ -594,8 +614,11 @@ def main():
     try:
         asyncio.run(run_server())
     finally:
-        # stdin EOF / transport close / normal exit: deterministic cleanup
-        # (atexit also runs this, but only on clean interpreter shutdown)
+        # stdin EOF / transport close / normal exit: the client is gone, so
+        # hard-kill kernel groups first (immune to a busy kernel's exec
+        # lock), then clean up the registry (atexit also runs the graceful
+        # path, but only on clean interpreter shutdown)
+        kill_all_kernel_process_groups()
         shutdown_all_kernels()
 
 

{agentic_python_coder-3.4.0.dist-info → agentic_python_coder-3.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-python-coder
-Version: 3.4.0
+Version: 3.4.1
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0

{agentic_python_coder-3.4.0.dist-info → agentic_python_coder-3.4.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 agentic_python_coder/__init__.py,sha256=e6o-k__u5xNIiQAkZbHtbZC2-NwpeOdi4MdQtAqJBjE,2112
 agentic_python_coder/agent.py,sha256=gzDFf4n7J1JdWawYPzWQFVwcHZ2rsRHUzVZVcGYjQWo,14451
 agentic_python_coder/cli.py,sha256=HS9nlqsiWZAvg0Hc8ExoVT8eEcy2t3Bux6UGukERWqQ,14663
-agentic_python_coder/kernel.py,sha256=JFN3gtZp3S-bGbQf2B-iQAE3AF8Q1TyQg4wrsx4Fdok,22261
+agentic_python_coder/kernel.py,sha256=Q-yLb8Il54kZv41qev2uzASFlr6bGjQ7ztBy7yD48GM,23273
 agentic_python_coder/llm.py,sha256=zjsk4-Kdx92hFSxywPGIkLv8zflWnE2cMEcpeXu6ttw,6998
-agentic_python_coder/mcp_server.py,sha256=7Qs5kJ9_W238vIywN5OIMG01vuPzfQ1cy1xFR8C7nGM,21054
+agentic_python_coder/mcp_server.py,sha256=Osdl8UnjkupXbPLiYCugiapGDJsryZfVai0o-jepuqw,22047
 agentic_python_coder/project_md.py,sha256=4xkQHlWb4cDPEkvegw1YwcfaTJ3aFbrl0CYcC_xxABY,3249
 agentic_python_coder/runner.py,sha256=Kbw1ceYJ4MVfUKgSIkiuBhMb8ZtbZuJwbBeTUsvPRts,13045
 agentic_python_coder/tools.py,sha256=tjhQbsF3n3bFIegnEOtE8czjzbtMSXy6B9gYeb-YAJ4,12088
@@ -41,8 +41,8 @@ agentic_python_coder/models/sonnet46.json,sha256=Ops1FpBoyx9PBGRhIXG8u-YGBgIui9D
 agentic_python_coder/models/sonnet5.json,sha256=kf6DIkQlcGVZ40IzRv3GXFtNncZF_gKqQeGzZAxE_KM,87
 agentic_python_coder/prompts/system.md,sha256=hREDVAhJXwCBAgJ3AE9JD6j-JRHREUPlkRSvThOvM3A,3807
 agentic_python_coder/prompts/system_todo.md,sha256=TuNeeUNS9KqyF62Da6t2mlUCYhKsgzwGe5ic_vFPDqw,5054
-agentic_python_coder-3.4.0.dist-info/METADATA,sha256=A0vE8oBRtMdgx3kwnaVwZSzhCgTi-VXBRCxcJotjXY0,12872
-agentic_python_coder-3.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-agentic_python_coder-3.4.0.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
-agentic_python_coder-3.4.0.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
-agentic_python_coder-3.4.0.dist-info/RECORD,,
+agentic_python_coder-3.4.1.dist-info/METADATA,sha256=C9UTWTVtnf7-0Bgiu44LMEd16zA00T3UxkS92MVV_Ac,12872
+agentic_python_coder-3.4.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentic_python_coder-3.4.1.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
+agentic_python_coder-3.4.1.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
+agentic_python_coder-3.4.1.dist-info/RECORD,,