ldbg 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

ldbg/ldbg.py

@@ -1,18 +1,25 @@
 import inspect
+import linecache
 import re
 import textwrap
+import time
 import traceback
-import linecache
 import os
+import sys
 import pprint
 from types import FrameType
 from typing import cast
 
 from openai import OpenAI
 
-LENGTH_MAX = 10000
+LENGTH_MAX = 50000
 CODE_BLOCK_REGEX = r"```(?:[\w+-]*)\n(.*?)```"
 
+# Message in one line since the Debug Console shows the raw string
+VSCODE_WARNING_MESSAGE = """It seems you are on VS Code. The answers will be printed in the Terminal while your inputs are made from the Debug Console. For optimal use, display the Debug Console and Terminal side-by-side. This message will be shown only once. Call the ldbg.gc() function again to make your request to the LLM."""
+
+display_vscode_warning = any("debugpy" in mod for mod in sys.modules)
+
 if "OPENROUTER_API_KEY" in os.environ:
     client = OpenAI(
         base_url="https://openrouter.ai/api/v1",
@@ -27,30 +34,47 @@ def extract_code_blocks(markdown_text: str):
     return pattern.findall(markdown_text)
 
 
-def execute_code_block(code: str):
-    exec(code, {})
+def execute_code_block(code: str, locals: dict):
+    exec(code, locals)
 
 
-def execute_blocks(markdown_text: str | None) -> None:
+def execute_blocks(markdown_text: str | None, locals: dict) -> None:
     """
     Extract the code blocks in the markdown and ask user if he wants to execute them
     """
     if markdown_text is None:
         return
     blocks = extract_code_blocks(markdown_text)
-    for block in blocks:
-        print("Would you like to execute the following code block:")
+    for n, block in enumerate(blocks):
+        print("\n\nWould you like to execute the following code block:\n")
         print(textwrap.indent(block, "    "))
-        confirm = input("(y/n)").lower()
-        if confirm.lower() in ["yes", "y"]:
-            execute_code_block(block)
+        while True:
+            before_input_time = time.time()
+            confirm = input("(y/n)").lower()
+            after_input_time = time.time()
+            if after_input_time - before_input_time < 0.5:
+                print(
+                    f'Discard answer "{confirm}" since it is likely from a previous keyboard stroke. Please wait at least 0.5s to read the code and answer safely.'
+                )
+                continue
+            if confirm.lower() in ["yes", "y"]:
+                print(f"\nExecuting block {n}...\n\n")
+                execute_code_block(block, locals)
+                print("\n\n\nExecution done.")
+            break
+    if any("debugpy" in mod for mod in sys.modules):
+        print("\nReturn to the Debug Console to get more help.")
+
+
+def indent(text, prefix=" " * 4):
+    return textwrap.indent(text, prefix)
 
 
 def generate_commands(
     prompt: str,
     frame=None,
     model="gpt-5-mini-2025-08-07",
-    print_prompt=True,
+    print_prompt=False,
     length_max=LENGTH_MAX,
     context="",
 ):
@@ -105,38 +129,80 @@ def generate_commands(
 
     <<< user enters n
     """
+
+    global display_vscode_warning
+    if display_vscode_warning:
+        display_vscode_warning = False
+        return VSCODE_WARNING_MESSAGE
+
+    frame_info = None
     if frame is None:
-        frame = cast(FrameType, inspect.currentframe().f_back)  # type: ignore
+        frame_info = next(
+            fi
+            for fi in inspect.stack()
+            if "/.vscode/extensions/" not in fi.filename
+            and "<string>" not in fi.filename
+            and not (
+                fi.filename.endswith("ldbg.py") and fi.function == "generate_commands"
+            )
+        )
+
+        frame: FrameType = cast(FrameType, frame_info.frame)
 
     # Locals & globals preview
-    locals_preview = pprint.pformat(frame.f_locals)[
-        :length_max
-    ]  # {k: type(v).__name__ for k, v in frame.f_locals.items()}
-    globals_preview = pprint.pformat(frame.f_globals)[
-        :length_max
-    ]  # {k: type(v).__name__ for k, v in frame.f_globals.items()}
+    filtered_locals = {
+        key: value
+        for key, value in frame.f_locals.items()
+        if key not in ["__builtin__", "__builtins__"]
+    }
+
+    locals_preview = pprint.pformat(filtered_locals)
+    if len(locals_preview) > length_max:
+        locals_preview = (
+            locals_preview[:length_max]
+            + f" ... \nLocal variables are truncated because it is too long (more than {length_max} characters)!"
+        )
+
+    # globals_preview = pprint.pformat(frame.f_globals)[
+    #     :length_max
+    # ]
 
     # Traceback / call stack
     stack_summary = traceback.format_stack(frame)
-    stack_text = "".join(stack_summary[-15:])  # limit to avoid overload
+    stack_text = "".join(stack_summary[-20:])  # limit to avoid overload
 
     # Current function source
     try:
         source_lines, start_line = inspect.getsourcelines(frame)
-        func_source = "".join(source_lines)
+        sources_lines_with_line_numbers = source_lines.copy()
+
+        for i, line in enumerate(source_lines):
+            prefix = "→ " if i + start_line == frame.f_lineno else "  "
+            sources_lines_with_line_numbers[i] = (
+                f"{prefix}{i + start_line:4d}: {line.rstrip()}"
+            )
+
+        func_source = "".join(sources_lines_with_line_numbers)
     except (OSError, TypeError):
-        func_source = "<source unavailable>"
-
-    # Context like ipdb 'll'
-    filename = frame.f_code.co_filename
-    lineno = frame.f_lineno
-    start_context = max(lineno - 10, 1)
-    context_lines = []
-    for i in range(start_context, lineno + 10):
-        line = linecache.getline(filename, i)
-        if line:
-            context_lines.append(f"{i:4d}: {line}")
-    context_text = "".join(context_lines)
+        try:
+            # fallback: print nearby lines from the source file
+            filename = frame.f_code.co_filename
+            start = frame.f_code.co_firstlineno
+            lines = linecache.getlines(filename)
+            func_source = "".join(lines[max(0, start - 5) : start + 200])
+        except Exception:
+            func_source = "<source unavailable>"
+
+    additional_context = textwrap.dedent(
+        f"""
+    Additional context:
+        {indent(context)}
+    
+    ===================================
+    """
+        if context is not None and len(context) > 0
+        else ""
+    )
 
     # ldbg.generate_commands({prompt}, model={model}, code_only={code_only}, print_prompt={print_prompt}, print_answer={print_answer}, length_max={length_max})
     context = textwrap.dedent(f"""
@@ -145,23 +211,21 @@ def generate_commands(
                               
     The user just ran `import ldbg; ldbg.gc({prompt}, model={model})` to ask you some help (gc stands for generate commands).
 
-    Local variables and their types (`locals = pprint.pformat(inspect.currentframe().f_locals)[:length_max]`):
-    {locals_preview}
+    Local variables (`locals = pprint.pformat(inspect.currentframe().f_locals)`):
+        {indent(locals_preview)}
 
-    Global variables and their types (`globals = pprint.pformat(inspect.currentframe().f_globals)[:length_max]`):
-    {globals_preview}
+    ===================================
 
     Current call stack (traceback):
-    {stack_text}
+        {indent(stack_text)}
 
-    Current function source:
-    {func_source}
+    ===================================
 
-    Nearby code (like ipdb 'll'):
-    {context_text}
+    Current function source:
+        {indent(func_source)}
 
-    Additional context:
-    {context}
+    ===================================
+    {additional_context}
 
     If you need more context, a more detailed view of the local variables or the content of a source file, 
     tell the user the commands he should run to print the details you need.
@@ -258,7 +322,7 @@ def generate_commands(
         pandas.DataFrame(unknown_data).describe()
         ```
 
-        You could also use numpy.set_printoptions (or a library like numpyprint) to pretty print your array:
+        You could also use `numpy.set_printoptions` (or a library like numpyprint) to pretty print your array:
         
         ```
         with np.printoptions(precision=2, suppress=True, threshold=5):
@@ -266,14 +330,14 @@ def generate_commands(
         ```
 
     Always put the code to execute in triple backticks code blocks.
-    Provide relatively short and concise answers.
+    Provide short and concise answers and code.
     """)
 
     if print_prompt:
         print("System prompt:")
         print(context)
-        print("\nUser prompt:")
-        print(prompt)
+
+    print(f'\n\nAsking {model} "{prompt}"...\n')
 
     resp = client.chat.completions.create(
         model=model,
@@ -292,10 +356,10 @@ def generate_commands(
     if response is None:
         return
 
-    print(f"Model {model} says:")
+    print(f"Model {model} says:\n")
     print(textwrap.indent(response, "    "))
 
-    execute_blocks(response)
+    execute_blocks(response, frame.f_locals)
 
     return
 

{ldbg-0.1.0.dist-info → ldbg-0.1.2.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ldbg
-Version: 0.1.0
+Version: 0.1.2
 Summary: Add your description here
 Author-email: Arthur Masson <arthur.masson@inria.fr>
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Requires-Dist: openai>=1.107.3
 Description-Content-Type: text/markdown
 
@@ -11,25 +11,40 @@ Description-Content-Type: text/markdown
 
 ### A Minimal Python Library to debug with LLMs
 
-Use natural-language prompts while debugging. Prompts are augmented with your current stack, variables, and source context.
+Ldbg enables to use natural-language prompts while debugging. Prompts are augmented with your current stack, variables, and source context.
+It is like [ShellGPT](https://github.com/TheR1D/shell_gpt) but for pdb, ipdb, Jupyter, the VS Code Debug Console, etc.
 
 DO NOT USE THIS LIBRARY
 
 > “AI everywhere is rocket engines on a skateboard: a thrill that ends in wreckage. The planet pays in energy and emissions, and we pay in something subtler — the slow atrophy of our own intelligence, left idle while the machines do the heavy lifting.” ChatGPT
 
+Here is [CJ Reynolds](https://www.youtube.com/watch?v=0ZUkQF6boNg) point of view:
+
+> I used to enjoy programming. Now, my days are typically spent going back and forth with an LLM and pretty often yelling at it… And part of enjoying programming for me was enjoying the little wins, right? You would work really hard to make something… or to figure something out. And once you figured it out, you'd have that little win. You'd get that dopamine hit and you'd feel good about yourself and you could keep going. I don't get that when I'm using LLMs to write code. Once it's figured something out, I don't feel like I did any work to get there. And then I'm just mad that it's doing the wrong thing. And then we go through this back and forth cycle and it's not fun.
+
 ## Features
 
 - 🐍 Generate Python debug commands from natural-language instructions.
 - 🔍 Context-aware: prompt auto-includes call stack, local/global variable previews, current function - source, and nearby code.
-- ⚡ Works like an AI-augmented pdb: just ask what you want to inspect.
 - 🤖 Supports OpenRouter
 
+**NOTE**: In VS Code, you enter the function the Debug Console, and get the output in the terminal ; so put both tabs (Debug Console and Terminal) side to side.
+
 ## Installation
 
-`pip install ldbg`
+`uv add ldbg`, `pixi add --pypi ldbg` or `pip install ldbg`
 
 ## Quick Start
 
+### Example natural-language prompts
+
+- "Describe my numpy arrays"
+- "plot my_data['b'] as a histogram"
+- "give me an example pandas dataframe about employees"
+- "generate a 3x12x16 example Pillow image from a numpy array"
+- "convert this Pillow image to grayscale"
+- "open this 'image.ome.tiff' with bioio"
+
 ### Example Session
 
 ```python
@@ -43,13 +58,13 @@ The model "gpt-5-mini-2025-08-07" says:
 
     unknown_data is an numpy array which can be described with the following pandas code:
     
-    ```code block 1
+    ```
     pandas.DataFrame(unknown_data).describe()
     ```
 
     Note: you can use numpy.set_printoptions (or a library like numpyprint) to pretty print your array:
     
-    ```code block 2
+    ```
     with np.printoptions(precision=2, suppress=True, threshold=5):
         unknown_data
     ```
@@ -95,15 +110,6 @@ Would you like to execute the following code block:
 ...
 ```
 
-### Example natural-language prompts
-
-- "Describe my numpy arrays"
-- "plot my_data['b'] as a histogram"
-- "give me an example pandas dataframe about employees"
-- "generate a 3x10x12 numpy array which will be used as an example image"
-- "convert this Pillow image to grayscale"
-- "open this 'image.ome.tiff' with bioio"
-
 ## Configuration
 
 By default, llm-debug uses the OpenAI client. So it reads the [OPENAI_API_KEY environment variable](https://platform.openai.com/docs/quickstart).

ldbg-0.1.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+ldbg/__init__.py,sha256=pTjJ9KayMK3061FeYd8cE-E8mhwdYRB8OJz0-APm6zI,79
+ldbg/ldbg.py,sha256=NS6_9WTrbtAE0Kv_xZ4M2jPDg3KvWU2fYz21By1Aqu8,12321
+ldbg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ldbg-0.1.2.dist-info/METADATA,sha256=U37pXjEU--TdOWEFwIMucpPdrp_e850hLDVQdZDqZjQ,4085
+ldbg-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ldbg-0.1.2.dist-info/RECORD,,

ldbg-0.1.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-ldbg/__init__.py,sha256=pTjJ9KayMK3061FeYd8cE-E8mhwdYRB8OJz0-APm6zI,79
-ldbg/ldbg.py,sha256=0bIfFZUoMH4329OJzRqB3Zmah60RP_MCBQeTxP5c7xE,9869
-ldbg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ldbg-0.1.0.dist-info/METADATA,sha256=ApXXFHbt7YuoQcDGumT_O_TS4gdrGH-mwa9x2IKtgaY,3087
-ldbg-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ldbg-0.1.0.dist-info/RECORD,,