kalong 0.4.3__tar.gz → 0.5.0__tar.gz

kalong-0.5.0/.gitignore

@@ -0,0 +1,16 @@
+.eggs
+.cache/
+__pycache__/
+build
+.env
+.coverage
+.pytest_cache
+pip-wheel-metadata
+examples/unrest-test.db
+htmlcov
+node_modules/
+lib/
+coverage/
+kalong/static/
+yarn-error.log
+dist/

kalong-0.5.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: kalong
+Version: 0.5.0
+Summary: A new take on python debugging
+Author-email: Florian Mounier <paradoxxx.zero@gmail.com>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: debugger
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: aiohttp>=3.10.6
+Requires-Dist: cutter>=0.5.0
+Requires-Dist: jedi>=0.19.1
+Provides-Extra: disassembly
+Requires-Dist: uncompyle6>=3.9.2; extra == 'disassembly'
+Provides-Extra: recursive
+Requires-Dist: nest-asyncio>=1.6.0; extra == 'recursive'

{kalong-0.4.3 → kalong-0.5.0}/kalong/__init__.py

@@ -1,7 +1,10 @@
 """A new take on debugging"""
-__version__ = "0.4.3"
+
+__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-0.5.0/kalong/__main__.py

@@ -0,0 +1,4 @@
+from kalong import main
+
+if __name__ == "__main__":
+    main()

kalong-0.5.0/kalong/communication.py

@@ -0,0 +1,221 @@
+import asyncio
+import json
+import linecache
+import logging
+import sys
+import threading
+
+from aiohttp import WSMsgType
+
+from . import config
+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
+
+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:
+        log.info("Loop got cancelled")
+        die()
+
+
+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_FRAMES",
+            "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_
+    arg = arg_
+
+    ws, existing = await websocket_state()
+    try:
+        await ws.send_json({"type": "PAUSE"})
+    except ConnectionResetError:
+        log.info("Connection was reset")
+        stop_trace(frame)
+        return
+
+    if existing:
+        # If the socket is already opened we need to update client state
+        await init(ws, frame, event, arg)
+        # 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["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:
+                break
+
+        elif msg.type == WSMsgType.ERROR:
+            log.error("WebSocket closed", exc_info=ws.exception())
+            break
+
+    # Browser exited, stopping debug if we are not stepping
+    if not stop:
+        stop_trace(frame)

{kalong-0.4.3 → kalong-0.5.0}/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-0.4.3 → kalong-0.5.0}/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_frame, 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
@@ -66,7 +66,7 @@ def get_frame(frame, key):
     for f in iter_frame(frame):
         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-0.4.3 → kalong-0.5.0}/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 = (

{kalong-0.4.3 → kalong-0.5.0}/kalong/loops.py

@@ -22,13 +22,13 @@ def get_loop():
     origin = current_origin()
     try:
         loop = asyncio.get_running_loop()
-        if origin not in loops or loops[origin] != loop:
+        if origin not in loops or loop.is_running():
             if nest_asyncio:
                 nest_asyncio.apply(loop)
             else:
                 raise ImportError(
                     "If you want to use kalong in an asyncio environment "
-                    "please install nest_asyncio"
+                    "or use recursive debugging please install nest_asyncio"
                 )
     except RuntimeError:
         pass

{kalong-0.4.3 → kalong-0.5.0}/kalong/server.py

@@ -11,7 +11,7 @@ from aiohttp.web_runner import GracefulExit
 
 from . import config
 from .errors import NoClientFoundError
-from .utils import basicConfig, USER_SIGNAL, human_readable_side, parse_origin
+from .utils import USER_SIGNAL, basicConfig, human_readable_side, parse_origin
 from .websockets import websocket_options
 
 log = logging.getLogger(__name__)
@@ -32,10 +32,7 @@ def maybe_bail(app):
 async def shutdown(app):
     log.info("App shutdown, closing remaining websockets.")
     await asyncio.gather(
-        *[
-            ws.close()
-            for ws in chain(app["front"].values(), app["back"].values())
-        ]
+        *[ws.close() for ws in chain(app["front"].values(), app["back"].values())]
     )
     app["front"].clear()
     app["back"].clear()
@@ -63,9 +60,7 @@ async def websocket(request):
     state = ws.can_prepare(request)
     if not state.ok:
         log.debug(f"Sending {side} app for {origin}")
-        return web.FileResponse(
-            Path(__file__).parent / "static" / "index.html"
-        )
+        return web.FileResponse(Path(__file__).parent / "static" / "index.html")
 
     await ws.prepare(request)
 
@@ -88,9 +83,7 @@ async def websocket(request):
                     _, pid, _ = parse_origin(origin)
                     os.kill(
                         pid,
-                        signal.SIGTERM
-                        if data["command"] == "kill"
-                        else USER_SIGNAL,
+                        signal.SIGTERM if data["command"] == "kill" else USER_SIGNAL,
                     )
                     continue
 
@@ -122,7 +115,5 @@ def serve():
     app["back"] = {}
     app.on_shutdown.append(shutdown)
     app.router.add_get(r"/{side:(front|back)}/{origin}", websocket)
-    app.router.add_static(
-        "/assets/", Path(__file__).parent / "static" / "assets"
-    )
+    app.router.add_static("/assets/", Path(__file__).parent / "static" / "assets")
     web.run_app(app, host=config.host, port=config.port, print=False)