code-puppy 0.0.357__py3-none-any.whl → 0.0.359__py3-none-any.whl

code_puppy/agents/event_stream_handler.py

@@ -119,6 +119,7 @@ async def event_stream_handler(
     tool_parts: set[int] = set()  # Track which parts are tool calls
     banner_printed: set[int] = set()  # Track if banner was already printed
     token_count: dict[int, int] = {}  # Track token count per text/tool part
+    tool_names: dict[int, str] = {}  # Track tool name per tool part index
     did_stream_anything = False  # Track if we streamed any content
 
     # Termflow streaming state for text parts
@@ -203,6 +204,8 @@ async def event_stream_handler(
                 streaming_parts.add(event.index)
                 tool_parts.add(event.index)
                 token_count[event.index] = 0  # Initialize token counter
+                # Capture tool name from the start event
+                tool_names[event.index] = part.tool_name or ""
                 # Track tool name for display
                 banner_printed.add(
                     event.index
@@ -253,20 +256,36 @@ async def event_stream_handler(
                             escaped = escape(delta.content_delta)
                             console.print(f"[dim]{escaped}[/dim]", end="")
                 elif isinstance(delta, ToolCallPartDelta):
-                    # For tool calls, count chunks received
-                    token_count[event.index] += 1
-                    # Get tool name if available
-                    tool_name = getattr(delta, "tool_name_delta", "")
+                    # For tool calls, estimate tokens from args_delta content
+                    # args_delta contains the streaming JSON arguments
+                    args_delta = getattr(delta, "args_delta", "") or ""
+                    if args_delta:
+                        # Rough estimate: 4 chars ≈ 1 token (same heuristic as subagent_stream_handler)
+                        estimated_tokens = max(1, len(args_delta) // 4)
+                        token_count[event.index] += estimated_tokens
+                    else:
+                        # Even empty deltas count as activity
+                        token_count[event.index] += 1
+
+                    # Update tool name if delta provides more of it
+                    tool_name_delta = getattr(delta, "tool_name_delta", "") or ""
+                    if tool_name_delta:
+                        tool_names[event.index] = (
+                            tool_names.get(event.index, "") + tool_name_delta
+                        )
+
+                    # Use stored tool name for display
+                    tool_name = tool_names.get(event.index, "")
                     count = token_count[event.index]
                     # Display with tool wrench icon and tool name
                     if tool_name:
                         console.print(
-                            f"  \U0001f527 Calling {tool_name}... {count} chunks   ",
+                            f"  \U0001f527 Calling {tool_name}... {count} token(s)   ",
                             end="\r",
                         )
                     else:
                         console.print(
-                            f"  \U0001f527 Calling tool... {count} chunks   ",
+                            f"  \U0001f527 Calling tool... {count} token(s)   ",
                             end="\r",
                         )
 
@@ -311,8 +330,9 @@ async def event_stream_handler(
                 elif event.index in banner_printed:
                     console.print()  # Final newline after streaming
 
-                # Clean up token count
+                # Clean up token count and tool names
                 token_count.pop(event.index, None)
+                tool_names.pop(event.index, None)
                 # Clean up all tracking sets
                 streaming_parts.discard(event.index)
                 thinking_parts.discard(event.index)

code_puppy/tools/browser/browser_screenshot.py

@@ -1,16 +1,16 @@
 """Screenshot tool for browser automation.
 
-Captures screenshots and returns them as base64 data that multimodal
-models can directly see and analyze - no separate VQA agent needed.
+Captures screenshots and returns them via ToolReturn with BinaryContent
+so multimodal models can directly see and analyze - no separate VQA agent needed.
 """
 
-import base64
+import time
 from datetime import datetime
 from pathlib import Path
 from tempfile import gettempdir, mkdtemp
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
-from pydantic_ai import RunContext
+from pydantic_ai import BinaryContent, RunContext, ToolReturn
 
 from code_puppy.messaging import emit_error, emit_info, emit_success
 from code_puppy.tools.common import generate_group_id
@@ -54,7 +54,6 @@ async def _capture_screenshot(
         result: Dict[str, Any] = {
             "success": True,
             "screenshot_bytes": screenshot_bytes,
-            "base64_data": base64.b64encode(screenshot_bytes).decode("utf-8"),
             "timestamp": timestamp,
         }
 
@@ -80,11 +79,11 @@ async def take_screenshot(
     full_page: bool = False,
     element_selector: Optional[str] = None,
     save_screenshot: bool = True,
-) -> Dict[str, Any]:
+) -> Union[ToolReturn, Dict[str, Any]]:
     """Take a screenshot of the browser page.
 
-    Returns the screenshot as base64-encoded PNG data that multimodal
-    models can directly see and analyze.
+    Returns a ToolReturn with BinaryContent so multimodal models can
+    directly see and analyze the screenshot.
 
     Args:
         full_page: Whether to capture full page or just viewport.
@@ -92,12 +91,11 @@ async def take_screenshot(
         save_screenshot: Whether to save the screenshot to disk.
 
     Returns:
-        Dict containing:
-            - success (bool): True if screenshot was captured.
-            - base64_image (str): Base64-encoded PNG image data.
-            - media_type (str): Always "image/png".
-            - screenshot_path (str): Path to saved file (if saved).
-            - error (str): Error message if unsuccessful.
+        ToolReturn containing:
+            - return_value: Success message with screenshot path
+            - content: List with description and BinaryContent image
+            - metadata: Screenshot details (path, target, timestamp)
+        Or Dict with error info if failed.
     """
     target = element_selector or ("full_page" if full_page else "viewport")
     group_id = generate_group_id("browser_screenshot", target)
@@ -122,15 +120,30 @@ async def take_screenshot(
 
         if not result["success"]:
             emit_error(result.get("error", "Screenshot failed"), message_group=group_id)
-            return result
-
-        return {
-            "success": True,
-            "base64_image": result["base64_data"],
-            "media_type": "image/png",
-            "screenshot_path": result.get("screenshot_path"),
-            "message": "Screenshot captured. The base64_image contains the browser view.",
-        }
+            return {"success": False, "error": result.get("error")}
+
+        screenshot_path = result.get("screenshot_path", "(not saved)")
+
+        # Return as ToolReturn with BinaryContent so the model can SEE the image!
+        return ToolReturn(
+            return_value=f"Screenshot captured successfully. Saved to: {screenshot_path}",
+            content=[
+                f"Here's the browser screenshot ({target}):",
+                BinaryContent(
+                    data=result["screenshot_bytes"],
+                    media_type="image/png",
+                ),
+                "Please analyze what you see and describe any relevant details.",
+            ],
+            metadata={
+                "success": True,
+                "screenshot_path": screenshot_path,
+                "target": target,
+                "full_page": full_page,
+                "element_selector": element_selector,
+                "timestamp": time.time(),
+            },
+        )
 
     except Exception as e:
         error_msg = f"Screenshot failed: {str(e)}"
@@ -146,19 +159,19 @@ def register_take_screenshot_and_analyze(agent):
         context: RunContext,
         full_page: bool = False,
         element_selector: Optional[str] = None,
-    ) -> Dict[str, Any]:
+    ) -> Union[ToolReturn, Dict[str, Any]]:
         """
         Take a screenshot of the browser page.
 
-        Returns the screenshot as base64 image data that you can see directly.
-        Use this to see what's displayed in the browser.
+        Returns the screenshot via ToolReturn with BinaryContent that you can
+        see directly. Use this to see what's displayed in the browser.
 
         Args:
             full_page: Capture full page (True) or just viewport (False).
             element_selector: Optional CSS selector to screenshot specific element.
 
         Returns:
-            Dict with base64_image (PNG data you can see), screenshot_path, etc.
+            ToolReturn with the screenshot image you can analyze, or error dict.
         """
         return await take_screenshot(
             full_page=full_page,

code_puppy/tools/browser/terminal_screenshot_tools.py

@@ -5,22 +5,22 @@ This module provides tools for:
 - Reading terminal output by scraping xterm.js DOM
 - Loading images from the filesystem
 
-Screenshots are returned as base64-encoded data that multimodal models
-can directly see and analyze - no separate VQA agent needed.
+Screenshots and images are returned via ToolReturn with BinaryContent
+so multimodal models can directly see and analyze them.
 
-Screenshots are automatically resized to reduce token usage.
+Images are automatically resized to reduce token usage.
 """
 
-import base64
 import io
 import logging
+import time
 from datetime import datetime
 from pathlib import Path
 from tempfile import gettempdir, mkdtemp
-from typing import Any, Dict
+from typing import Any, Dict, Union
 
 from PIL import Image
-from pydantic_ai import RunContext
+from pydantic_ai import BinaryContent, RunContext, ToolReturn
 from rich.text import Text
 
 from code_puppy.messaging import emit_error, emit_info, emit_success
@@ -178,7 +178,6 @@ async def _capture_terminal_screenshot(
         result: Dict[str, Any] = {
             "success": True,
             "screenshot_bytes": screenshot_bytes,
-            "base64_data": base64.b64encode(screenshot_bytes).decode("utf-8"),
         }
 
         # Save to disk if requested (save the resized version)
@@ -205,11 +204,11 @@ async def _capture_terminal_screenshot(
 async def terminal_screenshot(
     full_page: bool = False,
     save_to_disk: bool = True,
-) -> Dict[str, Any]:
+) -> Union[ToolReturn, Dict[str, Any]]:
     """Take a screenshot of the terminal browser.
 
-    Captures a screenshot and returns it as base64-encoded PNG data.
-    Multimodal models can directly see and analyze this image.
+    Captures a screenshot and returns it via ToolReturn with BinaryContent
+    so multimodal models can directly see and analyze the image.
 
     Args:
         full_page: Whether to capture the full page or just viewport.
@@ -218,18 +217,11 @@ async def terminal_screenshot(
             Defaults to True.
 
     Returns:
-        A dictionary containing:
-            - success (bool): True if screenshot was captured.
-            - base64_image (str): Base64-encoded PNG image data.
-            - media_type (str): Always "image/png".
-            - screenshot_path (str): Path to saved file (if save_to_disk=True).
-            - error (str): Error message if unsuccessful.
-
-    Example:
-        >>> result = await terminal_screenshot()
-        >>> if result["success"]:
-        ...     # The base64_image can be shown to multimodal models
-        ...     print(f"Screenshot saved to: {result['screenshot_path']}")
+        ToolReturn containing:
+            - return_value: Success message with screenshot path
+            - content: List with description and BinaryContent image
+            - metadata: Screenshot details (path, target, timestamp)
+        Or Dict with error info if failed.
     """
     target = "full_page" if full_page else "viewport"
     group_id = generate_group_id("terminal_screenshot", target)
@@ -249,14 +241,27 @@ async def terminal_screenshot(
         emit_error(result.get("error", "Screenshot failed"), message_group=group_id)
         return result
 
-    # Return clean result with base64 image for model consumption
-    return {
-        "success": True,
-        "base64_image": result["base64_data"],
-        "media_type": "image/png",
-        "screenshot_path": result.get("screenshot_path"),
-        "message": "Screenshot captured. The base64_image contains the terminal view.",
-    }
+    screenshot_path = result.get("screenshot_path", "(not saved)")
+
+    # Return as ToolReturn with BinaryContent so the model can SEE the image!
+    return ToolReturn(
+        return_value=f"Terminal screenshot captured. Saved to: {screenshot_path}",
+        content=[
+            f"Here's the terminal screenshot ({target}):",
+            BinaryContent(
+                data=result["screenshot_bytes"],
+                media_type="image/png",
+            ),
+            "Please analyze what you see in the terminal.",
+        ],
+        metadata={
+            "success": True,
+            "screenshot_path": screenshot_path,
+            "target": target,
+            "full_page": full_page,
+            "timestamp": time.time(),
+        },
+    )
 
 
 async def terminal_read_output(lines: int = 50) -> Dict[str, Any]:
@@ -328,23 +333,22 @@ async def terminal_read_output(lines: int = 50) -> Dict[str, Any]:
 async def load_image(
     image_path: str,
     max_height: int = DEFAULT_MAX_HEIGHT,
-) -> Dict[str, Any]:
-    """Load an image from the filesystem as base64 data.
+) -> Union[ToolReturn, Dict[str, Any]]:
+    """Load an image from the filesystem for visual analysis.
 
     Loads any image file, resizes it to reduce token usage, and returns
-    it as base64-encoded data that multimodal models can directly see.
+    it via ToolReturn with BinaryContent so multimodal models can see it.
 
     Args:
         image_path: Path to the image file.
         max_height: Maximum height for resizing (default 768px).
 
     Returns:
-        A dictionary containing:
-            - success (bool): True if image was loaded.
-            - base64_image (str): Base64-encoded image data (resized).
-            - media_type (str): The image MIME type (e.g., "image/png").
-            - image_path (str): The original path.
-            - error (str): Error message if unsuccessful.
+        ToolReturn containing:
+            - return_value: Success message with path info
+            - content: List with description and BinaryContent image
+            - metadata: Image details (path, resized height)
+        Or Dict with error info if failed.
     """
     group_id = generate_group_id("load_image", image_path)
     emit_info(f"LOAD IMAGE 🖼️ {image_path}", message_group=group_id)
@@ -368,18 +372,26 @@ async def load_image(
         # Resize to reduce token usage
         image_bytes = _resize_image(original_bytes, max_height=max_height)
 
-        # Always return as PNG after resizing (consistent format)
-        base64_data = base64.b64encode(image_bytes).decode("utf-8")
-
         emit_success(f"Loaded image: {image_path}", message_group=group_id)
 
-        return {
-            "success": True,
-            "base64_image": base64_data,
-            "media_type": "image/png",  # Always PNG after resize
-            "image_path": image_path,
-            "message": f"Image loaded (resized to max {max_height}px height for token efficiency).",
-        }
+        # Return as ToolReturn with BinaryContent so the model can SEE the image!
+        return ToolReturn(
+            return_value=f"Image loaded from: {image_path}",
+            content=[
+                f"Here's the image from {image_file.name}:",
+                BinaryContent(
+                    data=image_bytes,
+                    media_type="image/png",  # Always PNG after resize
+                ),
+                "Please analyze what you see in this image.",
+            ],
+            metadata={
+                "success": True,
+                "image_path": image_path,
+                "max_height": max_height,
+                "timestamp": time.time(),
+            },
+        )
 
     except Exception as e:
         error_msg = f"Failed to load image: {str(e)}"
@@ -400,18 +412,18 @@ def register_terminal_screenshot(agent):
     async def terminal_screenshot_analyze(
         context: RunContext,
         full_page: bool = False,
-    ) -> Dict[str, Any]:
+    ) -> Union[ToolReturn, Dict[str, Any]]:
         """
         Take a screenshot of the terminal browser.
 
-        Returns the screenshot as base64 image data that you can see directly.
-        Use this to see what's displayed in the terminal.
+        Returns the screenshot via ToolReturn with BinaryContent that you can
+        see directly. Use this to see what's displayed in the terminal.
 
         Args:
             full_page: Capture full page (True) or just viewport (False).
 
         Returns:
-            Dict with base64_image (PNG data you can see), screenshot_path, etc.
+            ToolReturn with the terminal screenshot you can analyze, or error dict.
         """
         # Session is set by invoke_agent via contextvar
         return await terminal_screenshot(full_page=full_page)
@@ -449,17 +461,18 @@ def register_load_image(agent):
     async def load_image_for_analysis(
         context: RunContext,
         image_path: str,
-    ) -> Dict[str, Any]:
+    ) -> Union[ToolReturn, Dict[str, Any]]:
         """
         Load an image file so you can see and analyze it.
 
-        Returns the image as base64 data that you can see directly.
+        Returns the image via ToolReturn with BinaryContent that you can
+        see directly.
 
         Args:
             image_path: Path to the image file.
 
         Returns:
-            Dict with base64_image (you can see this), media_type, etc.
+            ToolReturn with the image you can analyze, or error dict.
         """
         # Session is set by invoke_agent via contextvar
         return await load_image(image_path=image_path)
@@ -472,18 +485,18 @@ def register_terminal_compare_mockup(agent):
     async def terminal_compare_mockup(
         context: RunContext,
         mockup_path: str,
-    ) -> Dict[str, Any]:
+    ) -> Union[ToolReturn, Dict[str, Any]]:
         """
         Compare the terminal to a mockup image.
 
         Takes a screenshot of the terminal and loads the mockup image.
-        Returns both as base64 so you can visually compare them.
+        Returns both via ToolReturn with BinaryContent so you can compare them.
 
         Args:
             mockup_path: Path to the mockup/expected image.
 
         Returns:
-            Dict with terminal_image, mockup_image (both base64), paths, etc.
+            ToolReturn with both images (terminal and mockup) you can compare.
         """
         # Session is set by invoke_agent via contextvar
         group_id = generate_group_id("terminal_compare_mockup", mockup_path)
@@ -493,28 +506,51 @@ def register_terminal_compare_mockup(agent):
             message_group=group_id,
         )
 
-        # Load the mockup
-        mockup_result = await load_image(mockup_path)
-        if not mockup_result["success"]:
-            return mockup_result
+        # Capture terminal screenshot (get raw result for bytes)
+        terminal_capture = await _capture_terminal_screenshot(
+            full_page=False,
+            save_to_disk=True,
+            group_id=group_id,
+        )
+        if not terminal_capture["success"]:
+            return terminal_capture
 
-        # Take terminal screenshot
-        terminal_result = await terminal_screenshot(full_page=False)
-        if not terminal_result["success"]:
-            return terminal_result
+        # Load the mockup image
+        mockup_file = Path(mockup_path)
+        if not mockup_file.exists():
+            error_msg = f"Mockup file not found: {mockup_path}"
+            emit_error(error_msg, message_group=group_id)
+            return {"success": False, "error": error_msg}
+
+        mockup_bytes = _resize_image(mockup_file.read_bytes())
 
         emit_success(
             "Both images loaded. Compare them visually.",
             message_group=group_id,
         )
 
-        return {
-            "success": True,
-            "terminal_image": terminal_result["base64_image"],
-            "mockup_image": mockup_result["base64_image"],
-            "media_type": "image/png",
-            "terminal_path": terminal_result.get("screenshot_path"),
-            "mockup_path": mockup_path,
-            "message": "Both images loaded. terminal_image shows the current terminal, "
-            "mockup_image shows the expected design. Compare them visually.",
-        }
+        terminal_path = terminal_capture.get("screenshot_path", "(not saved)")
+
+        # Return as ToolReturn with BOTH images as BinaryContent!
+        return ToolReturn(
+            return_value=f"Comparison ready: terminal vs mockup ({mockup_path})",
+            content=[
+                "Here's the CURRENT terminal screenshot:",
+                BinaryContent(
+                    data=terminal_capture["screenshot_bytes"],
+                    media_type="image/png",
+                ),
+                f"And here's the EXPECTED mockup ({mockup_file.name}):",
+                BinaryContent(
+                    data=mockup_bytes,
+                    media_type="image/png",
+                ),
+                "Please compare these images and describe any differences.",
+            ],
+            metadata={
+                "success": True,
+                "terminal_path": terminal_path,
+                "mockup_path": mockup_path,
+                "timestamp": time.time(),
+            },
+        )

{code_puppy-0.0.357.dist-info → code_puppy-0.0.359.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.357
+Version: 0.0.359
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.357.dist-info → code_puppy-0.0.359.dist-info}/RECORD

@@ -43,7 +43,7 @@ code_puppy/agents/agent_security_auditor.py,sha256=SpiYNA0XAsIwBj7S2_EQPRslRUmF_
 code_puppy/agents/agent_terminal_qa.py,sha256=U-iyP7OBWdAmchW_oUU8k6asH2aignTMmgqqYDyf-ms,10343
 code_puppy/agents/agent_typescript_reviewer.py,sha256=vsnpp98xg6cIoFAEJrRTUM_i4wLEWGm5nJxs6fhHobM,10275
 code_puppy/agents/base_agent.py,sha256=oKlX9CEIWSvdXyQDVi9F1jauA6rjKleY_n6044Ux5DY,73840
-code_puppy/agents/event_stream_handler.py,sha256=HM62_THZpMVnqKIB6Vbo6IwmJt6Kjoc3YbyRy2FclA4,13805
+code_puppy/agents/event_stream_handler.py,sha256=JttLZJpNADE5HXiXY-GZ6tpwaBeFRODcy34KiquPOvU,14952
 code_puppy/agents/json_agent.py,sha256=lhopDJDoiSGHvD8A6t50hi9ZBoNRKgUywfxd0Po_Dzc,4886
 code_puppy/agents/prompt_reviewer.py,sha256=JJrJ0m5q0Puxl8vFsyhAbY9ftU9n6c6UxEVdNct1E-Q,5558
 code_puppy/agents/subagent_stream_handler.py,sha256=5imUFYOJCv7blfv4fTHm6OQ7JpqlyFv_luBYGSj16MA,10329
@@ -198,20 +198,20 @@ code_puppy/tools/browser/browser_control.py,sha256=YntpjfWTIv0TDlAO5BqTV_hDbUBw-
 code_puppy/tools/browser/browser_interactions.py,sha256=ZyJmA2-ZtIATF76uGMt08cfVaYiqg7W2-cHfAzNI0F8,16775
 code_puppy/tools/browser/browser_locators.py,sha256=sxXNm-K087poeSp7Um5Gc1sZxb7HlSZOu0F0r2b0ty8,19177
 code_puppy/tools/browser/browser_navigation.py,sha256=RJdG14UXtA6wz4PNLw2Tqeu4oUDQilOyNbyTjgIFCrY,7416
-code_puppy/tools/browser/browser_screenshot.py,sha256=POlHDG7WJbjF3uBPUD7X2elAs-CKP9Dq7UQ7UZyvZGQ,5666
+code_puppy/tools/browser/browser_screenshot.py,sha256=AJe9JbZv8vC93AFWzsAUlrg1YNshv4SWNde-O-_mfQU,6282
 code_puppy/tools/browser/browser_screenshot_vqa.py,sha256=DBdQuV7eIaJX2Qy_liwitfakIzrcVziB-zAGIngM5GE,7349
 code_puppy/tools/browser/browser_scripts.py,sha256=CYWdQMtjKTNvJNSCkB2vGo-MOzmT_gw2oFMGtkfuzuA,14779
 code_puppy/tools/browser/browser_workflows.py,sha256=nitW42vCf0ieTX1gLabozTugNQ8phtoFzZbiAhw1V90,6491
 code_puppy/tools/browser/camoufox_manager.py,sha256=WIr98SrGeC5jd6jX5tjhFR6A3janqV4tq9Mbznnlh44,13920
 code_puppy/tools/browser/chromium_terminal_manager.py,sha256=w1thQ_ACb6oV45L93TSqPQD0o0cTh3FqT5I9zcOOWlM,8226
 code_puppy/tools/browser/terminal_command_tools.py,sha256=9byOZku-dwvTtCl532xt7Lumed_jTn0sLvUe_X75XCQ,19068
-code_puppy/tools/browser/terminal_screenshot_tools.py,sha256=DAqzlqOoTfQZCKKeXccElrrY7s2CwSblvBV7A6A2GYw,17224
+code_puppy/tools/browser/terminal_screenshot_tools.py,sha256=J_21YO_495NvYgNFu9KQP6VYg2K_f8CtSdZuF94Yhnw,18448
 code_puppy/tools/browser/terminal_tools.py,sha256=F5LjVH3udSCFHmqC3O1UJLoLozZFZsEdX42jOmkqkW0,17853
 code_puppy/tools/browser/vqa_agent.py,sha256=0IbS1X3l8ADZI9pGcJbKFoN0-ZuTJa8QvHZ_hGKBKRM,6339
-code_puppy-0.0.357.data/data/code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
-code_puppy-0.0.357.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
-code_puppy-0.0.357.dist-info/METADATA,sha256=czyAX-ExI8J1C2WqFxnPakQofzpUXqX5r2-Y1WIL34E,27614
-code_puppy-0.0.357.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-code_puppy-0.0.357.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.357.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.357.dist-info/RECORD,,
+code_puppy-0.0.359.data/data/code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
+code_puppy-0.0.359.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
+code_puppy-0.0.359.dist-info/METADATA,sha256=sON8OiWf6tHAK4zV99qE3T1ouWDQVMOCm81jVNjcUCI,27614
+code_puppy-0.0.359.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+code_puppy-0.0.359.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.359.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.359.dist-info/RECORD,,