codebind 0.1.0__tar.gz → 0.1.2__tar.gz

{codebind-0.1.0 → codebind-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebind
-Version: 0.1.0
+Version: 0.1.2
 Summary: A minimal model loop over a persistent IPython session.
 Keywords: ai,ipython,llm,repl,agents
 Author: Giovanni Gravili

{codebind-0.1.0 → codebind-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.1.0"
+version = "0.1.2"
 description = "A minimal model loop over a persistent IPython session."
 readme = "README.md"
 requires-python = ">=3.13"

{codebind-0.1.0 → codebind-0.1.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "codebind"
-version = "0.1.0"
+version = "0.1.2"
 description = "A minimal model loop over a persistent IPython session."
 readme = "README.md"
 authors = [

{codebind-0.1.0 → codebind-0.1.2}/src/codebind/execution.py

@@ -8,6 +8,8 @@ from typing import Any
 from IPython.core.interactiveshell import InteractiveShell
 from IPython.utils.capture import capture_output
 
+from .prompts import CellPrompts
+
 
 @dataclass(frozen=True, slots=True)
 class ExecutionReport:
@@ -31,19 +33,24 @@ class IPythonExecutor:
     def __init__(self, shell: InteractiveShell) -> None:
         self.shell = shell
 
-    def execute(self, cell: str) -> ExecutionReport:
+    def execute(self, cell: str, *, prompts: CellPrompts | None = None) -> ExecutionReport:
         """Execute a cell, replay its visible output, and capture a structured result."""
         if not isinstance(cell, str) or not cell.strip():
             raise ValueError("cell must be a non-empty string")
 
+        original_prompts = getattr(self.shell, "prompts", None)
         displayhook = self.shell.displayhook
-        original_prompt = displayhook.write_output_prompt
-        displayhook.write_output_prompt = lambda: None
+        original_output_prompt = displayhook.write_output_prompt
+        if prompts is not None and original_prompts is not None:
+            self.shell.prompts = prompts
+            displayhook.write_output_prompt = lambda: None
         try:
             with capture_output() as captured:
                 result = self.shell.run_cell(cell, store_history=False)
         finally:
-            displayhook.write_output_prompt = original_prompt
+            if prompts is not None and original_prompts is not None:
+                self.shell.prompts = original_prompts
+                displayhook.write_output_prompt = original_output_prompt
 
         displays: list[str] = []
         for output in captured.outputs:

codebind-0.1.2/src/codebind/prompts.py

@@ -0,0 +1,65 @@
+"""Native IPython prompt rendering for model-authored cells."""
+
+from __future__ import annotations
+
+import sys
+
+from IPython.terminal.prompts import Prompts
+from IPython.terminal.ptutils import IPythonPTLexer
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import FormattedText, PygmentsTokens
+from prompt_toolkit.shortcuts import print_formatted_text
+from pygments.token import Token
+
+
+class CellPrompts(Prompts):
+    """IPython prompts for one numbered model-authored cell."""
+
+    def __init__(self, shell: object, number: int) -> None:
+        super().__init__(shell)
+        self.number = number
+
+    def in_prompt_tokens(self):
+        return [
+            (Token.Prompt, "Python ["),
+            (Token.PromptNum, str(self.number)),
+            (Token.Prompt, "]: "),
+        ]
+
+    def continuation_prompt_tokens(self, width: int | None = None, **_: object):
+        width = self._width() if width is None else width
+        return [
+            (Token.Prompt.Continuation, (" " * (width - 5)) + "...:"),
+            (Token.Prompt.Padding, " "),
+        ]
+
+    def out_prompt_tokens(self):
+        return [
+            (Token.OutPrompt, "Shell ["),
+            (Token.OutPromptNum, str(self.number)),
+            (Token.OutPrompt, "]: "),
+        ]
+
+
+def render_cell(shell: object, cell: str, prompts: CellPrompts) -> None:
+    """Render a cell with IPython's lexer, prompt tokens, and terminal style."""
+    lexer = IPythonPTLexer().lex_document(Document(cell))
+    pt_app = getattr(shell, "pt_app", None)
+    style = pt_app.app.style if pt_app is not None else None
+    sys.stdout.write(getattr(shell, "separate_in", "\n"))
+
+    for index, _line in enumerate(cell.split("\n")):
+        prompt_tokens = (
+            prompts.in_prompt_tokens()
+            if index == 0
+            else prompts.continuation_prompt_tokens(lineno=index - 1)
+        )
+        print_formatted_text(PygmentsTokens(prompt_tokens), style=style, end="")
+        print_formatted_text(FormattedText(lexer(index)), style=style)
+
+
+def render_output_prompt(shell: object, prompts: CellPrompts) -> None:
+    """Render an output prompt with IPython's terminal style."""
+    pt_app = getattr(shell, "pt_app", None)
+    style = pt_app.app.style if pt_app is not None else None
+    print_formatted_text(PygmentsTokens(prompts.out_prompt_tokens()), style=style, end="")

{codebind-0.1.0 → codebind-0.1.2}/src/codebind/rendering.py

@@ -10,9 +10,10 @@ from rich.segment import Segments
 from rich.text import Text
 
 from .execution import ExecutionReport
+from .prompts import CellPrompts, render_output_prompt
 
 
-_MAX_OUTPUT_LINES = 10
+_MAXIMUM_OUTPUT_LINES = 10
 
 
 def _visible_output(report: ExecutionReport) -> str:
@@ -32,7 +33,7 @@ class TerminalRenderer:
     def __init__(self) -> None:
         self.console = Console()
 
-    def tool_output(self, report: ExecutionReport) -> None:
+    def tool_output(self, report: ExecutionReport, shell: object, prompts: CellPrompts) -> None:
         """Show a bounded preview while leaving the report itself intact for the model."""
         visible = _visible_output(report)
         if not visible:
@@ -40,7 +41,9 @@ class TerminalRenderer:
         output = Text.from_ansi(visible)
         options = self.console.options
         complete = self.console.render_lines(output, options, pad=False, new_lines=True)
-        preview = complete[:_MAX_OUTPUT_LINES]
+        preview = complete[:_MAXIMUM_OUTPUT_LINES]
+        if report.ok:
+            render_output_prompt(shell, prompts)
         self.console.print(Segments(chain.from_iterable(preview)), end="")
         if len(complete) > len(preview):
             self.console.print(

{codebind-0.1.0 → codebind-0.1.2}/src/codebind/session.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import json
-import sys
 from collections.abc import Mapping, Sequence
 from typing import Any
 
@@ -14,6 +13,7 @@ from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, System
 from langchain_core.runnables import Runnable
 
 from .execution import ExecutionReport, IPythonExecutor
+from .prompts import CellPrompts, render_cell
 from .rendering import TerminalRenderer
 
 
@@ -134,18 +134,11 @@ class Session:
             return _tool_error("InvalidArguments", "ipython requires a string cell argument")
 
         cell = arguments["cell"]
-        self._show_call(cell)
+        prompts = CellPrompts(self.shell, self.shell.execution_count - 1)
+        render_cell(self.shell, cell, prompts)
         try:
-            report = self.executor.execute(cell)
+            report = self.executor.execute(cell, prompts=prompts)
         except Exception as error:  # The failure must be returned to the model, not end the session.
             report = _tool_error(type(error).__name__, str(error))
-        self.renderer.tool_output(report)
+        self.renderer.tool_output(report, self.shell, prompts)
         return report
-
-    def _show_call(self, cell: str) -> None:
-        highlighted = self.shell.pycolorize(cell.rstrip())
-        sys.stdout.write("\n")
-        sys.stdout.write(highlighted)
-        if not highlighted.endswith("\n"):
-            sys.stdout.write("\n")
-        sys.stdout.flush()