codebind 0.1.2__tar.gz → 0.1.4__tar.gz

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

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

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

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

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

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

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

@@ -8,9 +8,6 @@ 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:
     """The model-facing result of one IPython cell."""
@@ -33,24 +30,19 @@ class IPythonExecutor:
     def __init__(self, shell: InteractiveShell) -> None:
         self.shell = shell
 
-    def execute(self, cell: str, *, prompts: CellPrompts | None = None) -> ExecutionReport:
+    def execute(self, cell: str) -> 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_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
+        displayhook.write_output_prompt = lambda: None
         try:
             with capture_output() as captured:
-                result = self.shell.run_cell(cell, store_history=False)
+                result = self.shell.run_cell(cell, store_history=True)
         finally:
-            if prompts is not None and original_prompts is not None:
-                self.shell.prompts = original_prompts
-                displayhook.write_output_prompt = original_output_prompt
+            displayhook.write_output_prompt = original_output_prompt
 
         displays: list[str] = []
         for output in captured.outputs:

{codebind-0.1.2 → codebind-0.1.4}/src/codebind/prompts.py

@@ -4,49 +4,19 @@ 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:
+def render_cell(shell: object, cell: str) -> 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"))
+    prompts = shell.prompts
 
     for index, _line in enumerate(cell.split("\n")):
         prompt_tokens = (
@@ -58,8 +28,9 @@ def render_cell(shell: object, cell: str, prompts: CellPrompts) -> None:
         print_formatted_text(FormattedText(lexer(index)), style=style)
 
 
-def render_output_prompt(shell: object, prompts: CellPrompts) -> None:
+def render_output_prompt(shell: object) -> 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="")
+    sys.stdout.write(getattr(shell, "separate_out", "") or "\n")
+    print_formatted_text(PygmentsTokens(shell.prompts.out_prompt_tokens()), style=style, end="")

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

@@ -2,18 +2,12 @@
 
 from __future__ import annotations
 
-from itertools import chain
-
 from rich.console import Console
 from rich.markdown import Markdown
-from rich.segment import Segments
 from rich.text import Text
 
 from .execution import ExecutionReport
-from .prompts import CellPrompts, render_output_prompt
-
-
-_MAXIMUM_OUTPUT_LINES = 10
+from .prompts import render_output_prompt
 
 
 def _visible_output(report: ExecutionReport) -> str:
@@ -28,28 +22,20 @@ def _visible_output(report: ExecutionReport) -> str:
 
 
 class TerminalRenderer:
-    """Render concise tool previews and Markdown answers to the active terminal."""
+    """Render tool output and Markdown answers to the active terminal."""
 
     def __init__(self) -> None:
         self.console = Console()
 
-    def tool_output(self, report: ExecutionReport, shell: object, prompts: CellPrompts) -> None:
-        """Show a bounded preview while leaving the report itself intact for the model."""
+    def tool_output(self, report: ExecutionReport, shell: object) -> None:
+        """Show the complete tool output."""
         visible = _visible_output(report)
         if not visible:
             return
         output = Text.from_ansi(visible)
-        options = self.console.options
-        complete = self.console.render_lines(output, options, pad=False, new_lines=True)
-        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(
-                f"[dim]{len(preview)} of {len(complete)} lines shown; "
-                "the complete result was returned to the model.[/dim]"
-            )
+            render_output_prompt(shell)
+        self.console.print(output)
 
     def assistant(self, text: str) -> None:
         """Render the final model response as terminal Markdown."""

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

@@ -13,7 +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 .prompts import render_cell
 from .rendering import TerminalRenderer
 
 
@@ -134,11 +134,10 @@ class Session:
             return _tool_error("InvalidArguments", "ipython requires a string cell argument")
 
         cell = arguments["cell"]
-        prompts = CellPrompts(self.shell, self.shell.execution_count - 1)
-        render_cell(self.shell, cell, prompts)
+        render_cell(self.shell, cell)
         try:
-            report = self.executor.execute(cell, prompts=prompts)
+            report = self.executor.execute(cell)
         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.shell, prompts)
+        self.renderer.tool_output(report, self.shell)
         return report