kalong 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

kalong/__init__.py

@@ -1,7 +1,10 @@
 """A new take on debugging"""
-__version__ = "0.4.2"
+
+__version__ = "0.5.0"
 import os
 import sys
+from pathlib import Path
+from subprocess import run
 
 from .config import Config
 
@@ -31,12 +34,14 @@ def break_above(level):
     start_trace(frame)
 
 
-def start_trace(break_=False, full=False):
+def start_trace(break_=False, full=False, skip_frames=None):
     from .stepping import add_step, start_trace
 
     frame = sys._getframe().f_back
     add_step(
-        "stepInto" if break_ else ("trace" if full else "continue"), frame
+        "stepInto" if break_ else ("trace" if full else "continue"),
+        frame,
+        skip_frames,
     )
     start_trace(frame)
 
@@ -49,23 +54,23 @@ def stop_trace():
 
 
 class trace:
-    def __init__(self, break_=False, full=False):
-        self.break_ = break_
-        self.full = full
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
 
     def __enter__(self):
-        start_trace(self.break_, self.full)
+        stop_trace()
+        start_trace(**self.kwargs)
 
     def __exit__(self, *args):
         stop_trace()
 
 
-def run_file(filename, *args):
-    from .utils import fake_argv
-
+def run_file(filename, *args, break_=True):
     # Cleaning __main__ namespace
     import __main__
 
+    from .utils import fake_argv
+
     __main__.__dict__.clear()
     __main__.__dict__.update(
         {
@@ -82,7 +87,7 @@ def run_file(filename, *args):
     globals = __main__.__dict__
     locals = globals
     with fake_argv(filename, *args):
-        with trace(break_=True):
+        with trace(break_=break_):
             exec(statement, globals, locals)
 
 
@@ -93,3 +98,46 @@ def shell():
     frame = sys._getframe()
     # Enter the websocket communication loop that pauses the execution
     communicate(frame, "shell", [])
+
+
+def main():
+    os.environ["PYTHONBREAKPOINT"] = "kalong.breakpoint"
+    config.from_args()
+
+    if config.server:
+        from .server import serve
+
+        serve()
+
+    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)",
+                ]
+            ]
+        )
+        print(f'Running: {" ".join(gdb_command)}')
+        run(gdb_command)
+
+    else:
+        if config.command:
+            run_file(*config.command, break_=config.break_at_start)
+        else:
+            shell()
+
+
+if __name__ == "__main__":
+    main()

kalong/__main__.py

@@ -1,39 +1,4 @@
-import os
-from pathlib import Path
-from subprocess import run
+from kalong import main
 
-from . import config, run_file, shell
-
-os.environ["PYTHONBREAKPOINT"] = "kalong.breakpoint"
-config.from_args()
-
-if config.server:
-    from .server import serve
-
-    serve()
-
-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)",
-        ]
-    ]
-    print(f'Running: {" ".join(gdb_command)}')
-    run(gdb_command)
-
-else:
-    if config.command:
-        run_file(*config.command)
-    else:
-        shell()
+if __name__ == "__main__":
+    main()

kalong/communication.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import linecache
 import logging
+import sys
 import threading
 
 from aiohttp import WSMsgType
@@ -11,25 +12,35 @@ from .debugger import (
     get_frame,
     get_title,
     serialize_answer,
+    serialize_answer_recursive,
     serialize_diff_eval,
+    serialize_exception,
     serialize_frames,
     serialize_inspect,
     serialize_inspect_eval,
     serialize_suggestion,
+    serialize_table,
 )
+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 .errors import SetFrameError
 
 log = logging.getLogger(__name__)
 basicConfig(level=config.log_level)
 
 
+def exception_handler(loop, context):
+    exception = context["exception"]
+    message = context["message"]
+    logging.error(f"Task failed, msg={message}, exception={exception}")
+
+
 def communicate(frame, event, arg):
     loop = get_loop()
 
+    loop.set_exception_handler(exception_handler)
     try:
         loop.run_until_complete(communication_loop(frame, event, arg))
     except asyncio.CancelledError:
@@ -41,19 +52,115 @@ async def init(ws, frame, event, arg):
     tb = arg[2] if event == "exception" else None
 
     await ws.send_json({"type": "SET_THEME", "theme": event})
-    await ws.send_json(
-        {"type": "SET_TITLE", "title": get_title(frame, event, arg)}
-    )
+    await ws.send_json({"type": "SET_TITLE", "title": get_title(frame, event, arg)})
     await ws.send_json(
         {
             "type": "SET_FRAMES",
-            "frames": list(serialize_frames(frame, tb))
-            if event != "shell"
-            else [],
+            "frames": list(serialize_frames(frame, tb)) if event != "shell" else [],
         }
     )
 
 
+async def handle_message(ws, data, frame, event, arg):
+    if data["type"] == "HELLO":
+        await init(ws, frame, event, arg)
+        response = {
+            "type": "SET_INFO",
+            "config": config.__dict__,
+            "main": threading.current_thread() is threading.main_thread(),
+        }
+
+    elif data["type"] == "GET_FILE":
+        filename = data["filename"]
+        file = "".join(linecache.getlines(filename))
+        if not file:
+            file = get_file_from_code(frame, filename)
+        response = {
+            "type": "SET_FILE",
+            "filename": filename,
+            "source": file,
+        }
+
+    elif data["type"] == "SET_PROMPT" or data["type"] == "REFRESH_PROMPT":
+        try:
+            eval_fun = (
+                serialize_inspect_eval
+                if data.get("command") == "inspect"
+                else serialize_diff_eval
+                if data.get("command") == "diff"
+                else serialize_table
+                if data.get("command") == "table"
+                else serialize_answer_recursive
+                if data.get("command") == "recursive_debug"
+                else serialize_answer
+            )
+            response = {
+                "type": "SET_ANSWER",
+                "key": data["key"],
+                "command": data.get("command"),
+                "frame": data.get("frame"),
+                **eval_fun(
+                    data["prompt"],
+                    get_frame(frame, data.get("frame")),
+                ),
+            }
+        except SetFrameError as e:
+            frame = e.frame
+            event = e.event
+            arg = e.arg
+
+            await init(ws, frame, event, arg)
+
+            response = {
+                "type": "SET_ANSWER",
+                "key": data["key"],
+                "command": data.get("command"),
+                "frame": data.get("frame"),
+                "prompt": data["prompt"].strip(),
+                "answer": "",
+                "duration": 0,
+            }
+
+    elif data["type"] == "REQUEST_INSPECT":
+        response = {
+            "type": "SET_ANSWER",
+            "key": data["key"],
+            "command": data.get("command"),
+            **serialize_inspect(data["id"]),
+        }
+
+    elif data["type"] == "REQUEST_SUGGESTION":
+        response = {
+            "type": "SET_SUGGESTION",
+            **serialize_suggestion(
+                data["prompt"],
+                data["from"],
+                data["to"],
+                data["cursor"],
+                get_frame(frame, data.get("frame")),
+            ),
+        }
+
+    elif data["type"] == "DO_COMMAND":
+        command = data["command"]
+        response = {"type": "ACK", "command": command}
+        if command == "run":
+            clear_step()
+            stop_trace(frame)
+        elif command == "stop":
+            clear_step()
+            stop_trace(frame)
+            die()
+        else:
+            step_frame = get_frame(frame, data.get("frame"))
+            add_step(command, step_frame)
+        response["stop"] = True
+
+    else:
+        raise ValueError(f"Unknown type {data['type']}")
+    return response
+
+
 async def communication_loop(frame_, event_, arg_):
     frame = frame_
     event = event_
@@ -76,108 +183,27 @@ async def communication_loop(frame_, event_, arg_):
     async for msg in ws:
         if msg.type == WSMsgType.TEXT:
             data = json.loads(msg.data)
-            if data["type"] == "HELLO":
-                await init(ws, frame, event, arg)
-                response = {
-                    "type": "SET_INFO",
-                    "config": config.__dict__,
-                    "main": threading.current_thread()
-                    is threading.main_thread(),
-                }
-
-            elif data["type"] == "GET_FILE":
-                filename = data["filename"]
-                file = "".join(linecache.getlines(filename))
-                if not file:
-                    file = get_file_from_code(frame, filename)
-                response = {
-                    "type": "SET_FILE",
-                    "filename": filename,
-                    "source": file,
-                }
-
-            elif (
-                data["type"] == "SET_PROMPT"
-                or data["type"] == "REFRESH_PROMPT"
-            ):
-                try:
-                    eval_fun = (
-                        serialize_inspect_eval
-                        if data.get("command") == "inspect"
-                        else serialize_diff_eval
-                        if data.get("command") == "diff"
-                        else serialize_answer
-                    )
-                    response = {
-                        "type": "SET_ANSWER",
-                        "key": data["key"],
-                        "command": data.get("command"),
-                        "frame": data.get("frame"),
-                        **eval_fun(
-                            data["prompt"],
-                            get_frame(frame, data.get("frame")),
-                        ),
-                    }
-                except SetFrameError as e:
-                    frame = e.frame
-                    event = e.event
-                    arg = e.arg
-
-                    await init(ws, frame, event, arg)
-
-                    response = {
-                        "type": "SET_ANSWER",
-                        "key": data["key"],
-                        "command": data.get("command"),
-                        "frame": data.get("frame"),
-                        "prompt": data["prompt"].strip(),
-                        "answer": "",
-                        "duration": 0,
-                    }
-
-            elif data["type"] == "REQUEST_INSPECT":
+            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["prompt"].strip(),
                     "key": data["key"],
                     "command": data.get("command"),
-                    **serialize_inspect(data["id"]),
+                    "frame": data.get("frame"),
+                    "answer": [serialize_exception(*sys.exc_info(), "internal")],
                 }
+            log.debug(f"Got {data} answering with {response}")
+            response["local"] = True
 
-            elif data["type"] == "REQUEST_SUGGESTION":
-                response = {
-                    "type": "SET_SUGGESTION",
-                    **serialize_suggestion(
-                        data["prompt"],
-                        data["from"],
-                        data["to"],
-                        data["cursor"],
-                        get_frame(frame, data.get("frame")),
-                    ),
-                }
+            if response.pop("recursive", False):
+                await ws.send_json({"type": "PAUSE", "recursive": True})
+                await init(ws, frame, event, arg)
 
-            elif data["type"] == "DO_COMMAND":
-                command = data["command"]
-                response = {"type": "ACK", "command": command}
-                if command == "run":
-                    clear_step()
-                    stop_trace(frame)
-                elif command == "stop":
-                    clear_step()
-                    stop_trace(frame)
-                    die()
-                else:
-                    step_frame = get_frame(frame, data.get("frame"))
-                    add_step(command, step_frame)
-                stop = True
-
-            else:
-                response = {
-                    "type": "error",
-                    "message": f"Unknown type {data['type']}",
-                }
+            stop = response.pop("stop", False)
 
-            log.debug(f"Got {data} answering with {response}")
-            response["local"] = True
             try:
                 await ws.send_json(response)
             except ConnectionResetError:

kalong/config.py

@@ -24,17 +24,14 @@ class Config:
         parser.add_argument(
             "--server",
             action="store_true",
-            help="Launch the kalong server. "
-            "This option is used by kalong itself",
+            help="Launch the kalong server. " "This option is used by kalong itself",
         )
         parser.add_argument(
             "--protocol",
             default=self.protocol,
             help="Protocol for contacting kalong server",
         )
-        parser.add_argument(
-            "--host", default=self.host, help="Host of kalong server"
-        )
+        parser.add_argument("--host", default=self.host, help="Host of kalong server")
         parser.add_argument(
             "--port", type=int, default=self.port, help="Port of kalong server"
         )
@@ -64,6 +61,11 @@ class Config:
             help="Pid of a running process in which a debugger will be "
             "injected with gdb. This needs a working gdb and ptrace enabled",
         )
+        parser.add_argument(
+            "--break-at-start",
+            action="store_true",
+            help="Break at the start of the python file",
+        )
         parser.add_argument(
             "command",
             nargs=REMAINDER,