kalong 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

kalong/__init__.py

@@ -1,7 +1,10 @@
 """A new take on debugging"""
-__version__ = "0.4.3"
+
+__version__ = "0.5.1"
 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,26 +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:
@@ -42,19 +52,116 @@ 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):
+    tb = arg[2] if event == "exception" else None
+    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"), tb),
+                ),
+            }
+        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"), tb),
+            ),
+        }
+
+    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"), tb)
+            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_
@@ -77,110 +184,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_table
-                        if data.get("command") == "table"
-                        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.get("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,

kalong/debugger.py

@@ -21,9 +21,10 @@ from pprint import pformat
 
 from jedi import Interpreter
 
-from .utils import cutter_mock, discompile, universal_travel
+from .errors import SetFrameError
+from .utils import cutter_mock, dedent, discompile, universal_travel
 from .utils.io import capture_display, capture_exception, capture_std
-from .utils.iterators import iter_cause, iter_stack, iter_frame
+from .utils.iterators import force_iterable, iter_cause, iter_stack
 from .utils.obj import (
     get_code,
     get_infos,
@@ -32,7 +33,6 @@ from .utils.obj import (
     safe_repr,
     sync_locals,
 )
-from .errors import SetFrameError
 
 try:
     from cutter import cut
@@ -59,14 +59,14 @@ def get_title(frame, event, arg):
     return "???"
 
 
-def get_frame(frame, key):
+def get_frame(frame, key, tb=None):
     if not key:
         return frame
 
-    for f in iter_frame(frame):
+    for f, _lno in iter_stack(frame, tb):
         if id(f) == key:
             return f
-    log.warn(f"Frame {key} not found")
+    log.warning(f"Frame {key} not found")
     return frame
 
 
@@ -89,7 +89,11 @@ def serialize_frames(current_frame, current_tb):
         line = linecache.getline(filename, lno, frame.f_globals)
         line = line and line.strip()
         startlnos = dis.findlinestarts(code)
-        lastlineno = list(startlnos)[-1][1]
+        lnos = list(startlnos)
+        lastlineno = None
+        if lnos:
+            lastlineno = lnos[-1][1]
+
         yield {
             "key": id(frame),
             "absoluteFilename": str(fn),
@@ -103,8 +107,42 @@ def serialize_frames(current_frame, current_tb):
         }
 
 
-def serialize_answer(prompt, frame):
-    prompt = prompt.strip()
+def serialize_answer_recursive(prompt, frame):
+    return serialize_answer(prompt, frame, True)
+
+
+def _rec_exec(code, globals, locals):
+    from .stepping import start_trace, steppings, stop_trace
+    from .utils import current_origin
+
+    frame = sys._getframe()
+    stop_trace(frame)
+
+    origin = current_origin()
+    steppings[origin] = {
+        "type": "stepInto",
+        "frame": frame,
+        "lno": frame.f_lineno,
+        "skip_frames": 1,  # Skip exec frame
+        "_parent": steppings.get(origin),
+    }
+
+    start_trace(frame)
+    try:
+        exec(code, globals, locals)
+    finally:
+        parent = steppings[origin].get("_parent")
+        if parent:
+            steppings[origin] = parent
+        else:
+            stop_trace(frame)
+
+
+def rec_exec(code, globals, locals):
+    sys.call_tracing(_rec_exec, (code, globals, locals))
+
+
+def serialize_answer(prompt, frame, recursive=False):
     duration = 0
     answer = []
     f_globals = dict(frame.f_globals)
@@ -117,16 +155,16 @@ def serialize_answer(prompt, frame):
         last_key = "_" if "_" not in f_locals else "__"
         f_locals[last_key] = frame.f_globals["__kalong_last_value__"]
 
-    with capture_exception(answer), capture_display(
-        answer
-    ) as out, capture_std(answer):
+    with capture_exception(answer), capture_display(answer) as out, capture_std(answer):
         compiled_code = None
         try:
-            compiled_code = compile(prompt, "<stdin>", "single")
+            compiled_code = compile(prompt.strip(), "<stdin>", "single")
+            prompt = prompt.strip()
         except SetFrameError:
             raise
         except Exception:
             try:
+                prompt = dedent(prompt)
                 compiled_code = compile(prompt, "<stdin>", "exec")
             except SetFrameError:
                 raise
@@ -137,29 +175,36 @@ def serialize_answer(prompt, frame):
         start = time.time()
         if compiled_code is not None:
             try:
-                exec(compiled_code, f_globals, f_locals)
+                (rec_exec if recursive else exec)(compiled_code, f_globals, f_locals)
             except SetFrameError:
                 raise
             except Exception:
                 # handle ex
                 sys.excepthook(*sys.exc_info())
-            del f_locals["__kalong_current_frame__"]
-            del f_locals["cut"]
-            if last_key:
+            if "__kalong_current_frame__" in f_locals:
+                del f_locals["__kalong_current_frame__"]
+            if "cut" in f_locals:
+                del f_locals["cut"]
+            if last_key and last_key in f_locals:
                 del f_locals[last_key]
             sync_locals(frame, f_locals)
-            if out.obj:
+            if out.obj is not None:
                 frame.f_globals["__kalong_last_value__"] = out.obj
         duration = int((time.time() - start) * 1000 * 1000 * 1000)
 
-    return {"prompt": prompt, "answer": answer, "duration": duration}
+    return {
+        "prompt": prompt,
+        "answer": answer,
+        "duration": duration,
+        "recursive": recursive,
+    }
 
 
-def serialize_exception(type_, value, tb):
+def serialize_exception(type_, value, tb, subtype="root"):
     return {
         "type": "exception",
         "id": obj_cache.register(value),
-        "subtype": "root",
+        "subtype": subtype,
         "name": type_.__name__,
         "description": str(value),
         "traceback": list(serialize_frames(None, tb)),
@@ -358,8 +403,12 @@ def serialize_suggestion(prompt, from_, to, cursor, frame):
 
 
 def serialize_table(prompt, frame):
-    valueStr, columns = (s.strip() for s in prompt.split(table_separator))
-    columns = [c.strip() for c in columns.split(",")]
+    if table_separator in prompt:
+        valueStr, columns = (s.strip() for s in prompt.split(table_separator))
+        columns = [c.strip() for c in columns.split(",")]
+    else:
+        valueStr = prompt.strip()
+        columns = None
 
     try:
         valueKey = get_id_from_expression(valueStr, frame)
@@ -370,6 +419,19 @@ def serialize_table(prompt, frame):
         }
 
     value = obj_cache.get(valueKey)
+    values = list(force_iterable(value, True))
+    if not columns:
+        if all(isinstance(value, dict) for value in values):
+            columns = list({column for value in values for column in value.keys()})
+        else:
+            columns = list(
+                {
+                    column
+                    for value in values
+                    for column in dir(value)
+                    if not column.startswith("__")
+                }
+            )
 
     answer = [
         {
@@ -386,7 +448,7 @@ def serialize_table(prompt, frame):
                     for column in columns
                     for value in [universal_travel(row, column)]
                 }
-                for row in value
+                for row in values
             ],
         }
     ]

kalong/forking.py

@@ -15,9 +15,7 @@ def forkserver():
     kalong_dir = Path(__file__).parent.parent
     env = dict(os.environ)
     env["PYTHONPATH"] = (
-        f'{kalong_dir}:{env["PYTHONPATH"]}'
-        if env.get("PYTHONPATH")
-        else kalong_dir
+        f'{kalong_dir}:{env["PYTHONPATH"]}' if env.get("PYTHONPATH") else kalong_dir
     )
 
     popen_args = (