kalong 0.5.3__tar.gz → 0.5.4__tar.gz

{kalong-0.5.3 → kalong-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kalong
-Version: 0.5.3
+Version: 0.5.4
 Summary: A new take on python debugging
 Author-email: Florian Mounier <paradoxxx.zero@gmail.com>
 License-Expression: GPL-3.0-or-later

{kalong-0.5.3 → kalong-0.5.4}/kalong/__init__.py

@@ -1,6 +1,6 @@
 """A new take on debugging"""
 
-__version__ = "0.5.3"
+__version__ = "0.5.4"
 import os
 import sys
 from pathlib import Path
@@ -111,25 +111,22 @@ def main():
 
     elif config.inject:
         kalong_dir = Path(__file__).resolve().parent.parent
-        gdb_command = (
-            ["gdb", "-p", str(config.inject), "-batch"]
-            + [
-                "-eval-command=call %s" % hook
-                for hook in [
-                    "(int) PyGILState_Ensure()",  # Getting the GIL
-                    '(int) PyRun_SimpleString("'
-                    f"print('* Kalong injection from {os.getpid()} *');"
-                    "import sys;"  # Putting kalong project directory in sys path:
-                    f"sys.path.insert(0, '{kalong_dir}');"
-                    "import kalong;"  # Setting breakpoint:
-                    "kalong.break_above(2);"
-                    '")',
-                    # Releasing the GIL with the PyGILState_Ensure handle:
-                    "(void) PyGILState_Release($1)",
-                ]
+        gdb_command = ["gdb", "-p", str(config.inject), "-batch"] + [
+            "-eval-command=call %s" % hook
+            for hook in [
+                "(int) PyGILState_Ensure()",  # Getting the GIL
+                '(int) PyRun_SimpleString("'
+                f"print('* Kalong injection from {os.getpid()} *');"
+                "import sys;"  # Putting kalong project directory in sys path:
+                f"sys.path.insert(0, '{kalong_dir}');"
+                "import kalong;"  # Setting breakpoint:
+                "kalong.break_above(2);"
+                '")',
+                # Releasing the GIL with the PyGILState_Ensure handle:
+                "(void) PyGILState_Release($1)",
             ]
-        )
-        print(f'Running: {" ".join(gdb_command)}')
+        ]
+        print(f"Running: {' '.join(gdb_command)}")
         run(gdb_command)
 
     else:

{kalong-0.5.3 → kalong-0.5.4}/kalong/communication.py

@@ -25,7 +25,7 @@ from .errors import SetFrameError
 from .loops import get_loop
 from .stepping import add_step, clear_step, stop_trace
 from .utils import basicConfig, get_file_from_code
-from .websockets import die, websocket_state
+from .websockets import adie, die, websocket_state
 
 log = logging.getLogger(__name__)
 basicConfig(level=config.log_level)
@@ -161,7 +161,7 @@ async def handle_message(ws, data, frame, event, arg):
         elif command == "stop":
             clear_step()
             stop_trace(frame)
-            die()
+            await adie()
         else:
             step_frame = get_frame(frame, data.get("frame"), tb)
             add_step(command, step_frame)
@@ -194,42 +194,46 @@ async def communication_loop(frame_, event_, arg_, pending=None):
         # Otherwise if it's new, just wait for HELLO to answer current state
 
     stop = False
-    async for msg in ws:
-        if msg.type == WSMsgType.TEXT:
-            data = json.loads(msg.data)
-            try:
-                response = await handle_message(ws, data, frame, event, arg)
-            except Exception as e:
-                log.error(f"Error handling message {data}", exc_info=e)
-                response = {
-                    "type": "SET_ANSWER",
-                    "prompt": data.get("prompt", "?").strip(),
-                    "key": data["key"],
-                    "command": data.get("command"),
-                    "frame": data.get("frame"),
-                    "answer": [serialize_exception(*sys.exc_info(), "internal")],
-                }
-            log.debug(f"Got {data} answering with {response}")
-            response["local"] = True
-
-            if response.pop("recursive", False):
-                await ws.send_json({"type": "PAUSE", "recursive": True})
-                await init(ws, frame, event, arg)
-
-            stop = response.pop("stop", False)
-
-            try:
-                await ws.send_json(response)
-            except ConnectionResetError:
-                break
-
-            if stop:
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                data = json.loads(msg.data)
+                try:
+                    response = await handle_message(ws, data, frame, event, arg)
+                except Exception as e:
+                    log.error(f"Error handling message {data}", exc_info=e)
+                    response = {
+                        "type": "SET_ANSWER",
+                        "prompt": data.get("prompt", "?").strip(),
+                        "key": data.get("key"),
+                        "command": data.get("command"),
+                        "frame": data.get("frame"),
+                        "answer": [serialize_exception(*sys.exc_info(), "internal")],
+                    }
+                log.debug(f"Got {data} answering with {response}")
+                response["local"] = True
+
+                if response.pop("recursive", False):
+                    await ws.send_json({"type": "PAUSE", "recursive": True})
+                    await init(ws, frame, event, arg)
+
+                stop = response.pop("stop", False)
+
+                try:
+                    await ws.send_json(response)
+                except ConnectionResetError:
+                    break
+
+                if stop:
+                    break
+
+            elif msg.type == WSMsgType.ERROR:
+                log.error("WebSocket closed", exc_info=ws.exception())
                 break
-
-        elif msg.type == WSMsgType.ERROR:
-            log.error("WebSocket closed", exc_info=ws.exception())
-            break
+    except asyncio.CancelledError:
+        log.error("WebSocket communication cancelled")
 
     # Browser exited, stopping debug if we are not stepping
     if not stop:
         stop_trace(frame)
+        await adie()

{kalong-0.5.3 → kalong-0.5.4}/kalong/loops.py

@@ -49,7 +49,7 @@ def close_loop():
     try:
         loops[origin].close()
     finally:
-        del loops[origin]
+        loops.pop(origin, None)
 
 
 def clean_loops():

{kalong-0.5.3 → kalong-0.5.4}/kalong/server.py

@@ -67,44 +67,46 @@ async def websocket(request):
     log.debug(f"{side.title()} app connected for {origin}")
     request.app[side][origin] = ws
 
-    async for msg in ws:
-        if msg.type == WSMsgType.TEXT:
-            data = json.loads(msg.data)
-            log.debug(f"{side} -> {other_side}: {data}")
-            try:
-                pair = await peer(request.app, other_side, origin)
-            except NoClientFoundError:
-                log.error(
-                    f"No {human_readable_side(other_side)} connection was found, aborting debugger"
-                )
-                break
-            if data["type"] == "DO_COMMAND":
-                if data["command"] in ["pause", "kill"]:
-                    _, pid, _ = parse_origin(origin)
-                    os.kill(
-                        pid,
-                        signal.SIGTERM if data["command"] == "kill" else USER_SIGNAL,
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                data = json.loads(msg.data)
+                log.debug(f"{side} -> {other_side}: {data}")
+                try:
+                    pair = await peer(request.app, other_side, origin)
+                except NoClientFoundError:
+                    log.error(
+                        f"No {human_readable_side(other_side)} connection was found, aborting debugger"
                     )
-                    continue
-
-            await pair.send_json(data)
-        elif msg.type == WSMsgType.ERROR:
-            log.error(f"{side.title()} closed", exc_info=ws.exception())
+                    break
+                if data["type"] == "DO_COMMAND":
+                    if data["command"] in ["pause", "kill"]:
+                        _, pid, _ = parse_origin(origin)
+                        sign = (
+                            signal.SIGKILL if data["command"] == "kill" else USER_SIGNAL
+                        )
+                        log.info(f"Sending signal {sign} to {pid}")
+                        os.kill(pid, sign)
+                        continue
+
+                await pair.send_json(data)
+            elif msg.type == WSMsgType.ERROR:
+                log.error(f"{side.title()} closed", exc_info=ws.exception())
+    except asyncio.CancelledError:
+        log.error(f"{side.title()} WebSocket communication cancelled")
 
     log.debug(f"Closing {side}")
-    await ws.close()
 
     if side in request.app and origin in request.app[side]:
-        del request.app[side][origin]
+        request.app[side].pop(origin)
 
     if not config.detached:
         if origin in request.app[other_side]:
             log.debug(f"Closing {other_side} due to {side} closing.")
-            await request.app[other_side][origin].close()
-
-        if origin in request.app[other_side]:
-            del request.app[other_side][origin]
+            s = request.app[other_side].pop(origin)
+            await s.close()
 
+    await ws.close()
     maybe_bail(request.app)
     return ws