code-puppy 0.0.52__py3-none-any.whl → 0.0.54__py3-none-any.whl

code_puppy/tools/file_operations.py

@@ -28,6 +28,7 @@ IGNORE_PATTERNS = [
     "**/*.exe",
 ]
 
+
 def should_ignore_path(path: str) -> bool:
     """Return True if *path* matches any pattern in IGNORE_PATTERNS."""
     for pattern in IGNORE_PATTERNS:
@@ -35,12 +36,24 @@ def should_ignore_path(path: str) -> bool:
             return True
     return False
 
-def list_files(context: RunContext | None, directory: str = ".", recursive: bool = True) -> List[Dict[str, Any]]:
+
+def _list_files(
+    context: RunContext, directory: str = ".", recursive: bool = True
+) -> List[Dict[str, Any]]:
     """Light-weight `list_files` implementation sufficient for unit-tests and agent tooling."""
+    console.print(
+        f"\n[bold white on blue] LIST FILES [/bold white on blue] \U0001f4c2 [bold cyan]{directory}[/bold cyan]"
+    )
+    console.print("[dim]" + "-" * 60 + "[/dim]")
     directory = os.path.abspath(directory)
     results: List[Dict[str, Any]] = []
     if not os.path.exists(directory) or not os.path.isdir(directory):
-        return [{"error": f"Directory '{directory}' does not exist or is not a directory"}]
+        console.print(
+            f"[bold red]Directory '{directory}' does not exist or is not a directory[/bold red]"
+        )
+        return [
+            {"error": f"Directory '{directory}' does not exist or is not a directory"}
+        ]
     for root, dirs, files in os.walk(directory):
         rel_root = os.path.relpath(root, directory)
         if rel_root == ".":
@@ -52,8 +65,13 @@ def list_files(context: RunContext | None, directory: str = ".", recursive: bool
             break
     return results
 
-def read_file(context: RunContext | None, file_path: str) -> Dict[str, Any]:
+
+def _read_file(context: RunContext, file_path: str) -> Dict[str, Any]:
     file_path = os.path.abspath(file_path)
+    console.print(
+        f"\n[bold white on blue] READ FILE [/bold white on blue] \U0001f4c2 [bold cyan]{file_path}[/bold cyan]"
+    )
+    console.print("[dim]" + "-" * 60 + "[/dim]")
     if not os.path.exists(file_path):
         return {"error": f"File '{file_path}' does not exist"}
     if not os.path.isfile(file_path):
@@ -61,201 +79,109 @@ def read_file(context: RunContext | None, file_path: str) -> Dict[str, Any]:
     try:
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
-        return {"content": content, "path": file_path, "total_lines": len(content.splitlines())}
+        return {
+            "content": content,
+            "path": file_path,
+            "total_lines": len(content.splitlines()),
+        }
     except Exception as exc:
         return {"error": str(exc)}
 
-def grep(context: RunContext | None, search_string: str, directory: str = ".") -> List[Dict[str, Any]]:
+
+def _grep(
+    context: RunContext, search_string: str, directory: str = "."
+) -> List[Dict[str, Any]]:
     matches: List[Dict[str, Any]] = []
     directory = os.path.abspath(directory)
-    for root, dirs, files in os.walk(directory):
-        for f in files:
-            file_path = os.path.join(root, f)
+    console.print(
+        f"\n[bold white on blue] GREP [/bold white on blue] \U0001f4c2 [bold cyan]{directory}[/bold cyan] [dim]for '{search_string}'[/dim]"
+    )
+    console.print("[dim]" + "-" * 60 + "[/dim]")
+
+    for root, dirs, files in os.walk(directory, topdown=True):
+        # Filter out ignored directories
+        dirs[:] = [d for d in dirs if not should_ignore_path(os.path.join(root, d))]
+
+        for f_name in files:
+            file_path = os.path.join(root, f_name)
+
+            if should_ignore_path(file_path):
+                # console.print(f"[dim]Ignoring: {file_path}[/dim]") # Optional: for debugging ignored files
+                continue
+
             try:
-                with open(file_path, "r", encoding="utf-8") as fh:
-                    for ln, line in enumerate(fh, 1):
-                        if search_string in line:
-                            matches.append({"file_path": file_path, "line_number": ln})
+                # console.print(f"\U0001f4c2 [bold cyan]Searching: {file_path}[/bold cyan]") # Optional: for verbose searching log
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
+                    for line_number, line_content in enumerate(fh, 1):
+                        if search_string in line_content:
+                            match_info = {
+                                "file_path": file_path,
+                                "line_number": line_number,
+                                "line_content": line_content.strip(),
+                            }
+                            matches.append(match_info)
+                            # console.print(
+                            #     f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}"
+                            # ) # Optional: for verbose match logging
                             if len(matches) >= 200:
+                                console.print(
+                                    "[yellow]Limit of 200 matches reached. Stopping search.[/yellow]"
+                                )
                                 return matches
-            except Exception:
+            except FileNotFoundError:
+                console.print(
+                    f"[yellow]File not found (possibly a broken symlink): {file_path}[/yellow]"
+                )
+                continue
+            except UnicodeDecodeError:
+                console.print(
+                    f"[yellow]Cannot decode file (likely binary): {file_path}[/yellow]"
+                )
+                continue
+            except Exception as e:
+                console.print(f"[red]Error processing file {file_path}: {e}[/red]")
                 continue
+
+    if not matches:
+        console.print(
+            f"[yellow]No matches found for '{search_string}' in {directory}[/yellow]"
+        )
+    else:
+        console.print(
+            f"[green]Found {len(matches)} match(es) for '{search_string}' in {directory}[/green]"
+        )
+
     return matches
 
-def register_file_operations_tools(agent):
-    # Constants for file operations
-    IGNORE_PATTERNS = [
-        "**/node_modules/**",
-        "**/.git/**",
-        "**/__pycache__/**",
-        "**/.DS_Store",
-        "**/.env",
-        "**/.venv/**",
-        "**/venv/**",
-        "**/.idea/**",
-        "**/.vscode/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/*.pyc",
-        "**/*.pyo",
-        "**/*.pyd",
-        "**/*.so",
-        "**/*.dll",
-        "**/*.exe",
-    ]
-    def should_ignore_path(path: str) -> bool:
-        for pattern in IGNORE_PATTERNS:
-            if fnmatch.fnmatch(path, pattern):
-                return True
-        return False
 
+# Exported top-level functions for direct import by tests and other code
+
+
+def list_files(context, directory=".", recursive=True):
+    return _list_files(context, directory, recursive)
+
+
+def read_file(context, file_path):
+    return _read_file(context, file_path)
+
+
+def grep(context, search_string, directory="."):
+    return _grep(context, search_string, directory)
+
+
+def register_file_operations_tools(agent):
     @agent.tool
-    def list_files(context: RunContext, directory: str = ".", recursive: bool = True) -> List[Dict[str, Any]]:
-        results = []
-        directory = os.path.abspath(directory)
-        console.print("\n[bold white on blue] DIRECTORY LISTING [/bold white on blue]")
-        console.print(f"\U0001F4C2 [bold cyan]{directory}[/bold cyan] [dim](recursive={recursive})[/dim]")
-        console.print("[dim]" + "-" * 60 + "[/dim]")
-        if not os.path.exists(directory):
-            console.print(f"[bold red]Error:[/bold red] Directory '{directory}' does not exist")
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return [{"error": f"Directory '{directory}' does not exist"}]
-        if not os.path.isdir(directory):
-            console.print(f"[bold red]Error:[/bold red] '{directory}' is not a directory")
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return [{"error": f"'{directory}' is not a directory"}]
-        folder_structure = {}
-        file_list = []
-        for root, dirs, files in os.walk(directory):
-            dirs[:] = [d for d in dirs if not should_ignore_path(os.path.join(root, d))]
-            rel_path = os.path.relpath(root, directory)
-            depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-            if rel_path == ".":
-                rel_path = ""
-            if rel_path:
-                dir_path = os.path.join(directory, rel_path)
-                results.append({"path": rel_path, "type": "directory", "size": 0, "full_path": dir_path, "depth": depth})
-                folder_structure[rel_path] = {"path": rel_path, "depth": depth, "full_path": dir_path}
-            for file in files:
-                file_path = os.path.join(root, file)
-                if should_ignore_path(file_path):
-                    continue
-                rel_file_path = os.path.join(rel_path, file) if rel_path else file
-                try:
-                    size = os.path.getsize(file_path)
-                    file_info = {"path": rel_file_path, "type": "file", "size": size, "full_path": file_path, "depth": depth}
-                    results.append(file_info)
-                    file_list.append(file_info)
-                except (FileNotFoundError, PermissionError):
-                    continue
-            if not recursive:
-                break
-        def format_size(size_bytes):
-            if size_bytes < 1024:
-                return f"{size_bytes} B"
-            elif size_bytes < 1024*1024:
-                return f"{size_bytes/1024:.1f} KB"
-            elif size_bytes < 1024*1024*1024:
-                return f"{size_bytes/(1024*1024):.1f} MB"
-            else:
-                return f"{size_bytes/(1024*1024*1024):.1f} GB"
-        def get_file_icon(file_path):
-            ext = os.path.splitext(file_path)[1].lower()
-            if ext in [".py", ".pyw"]:
-                return "\U0001F40D"
-            elif ext in [".js", ".jsx", ".ts", ".tsx"]:
-                return "\U0001F4DC"
-            elif ext in [".html", ".htm", ".xml"]:
-                return "\U0001F310"
-            elif ext in [".css", ".scss", ".sass"]:
-                return "\U0001F3A8"
-            elif ext in [".md", ".markdown", ".rst"]:
-                return "\U0001F4DD"
-            elif ext in [".json", ".yaml", ".yml", ".toml"]:
-                return "\u2699\ufe0f"
-            elif ext in [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"]:
-                return "\U0001F5BC\ufe0f"
-            elif ext in [".mp3", ".wav", ".ogg", ".flac"]:
-                return "\U0001F3B5"
-            elif ext in [".mp4", ".avi", ".mov", ".webm"]:
-                return "\U0001F3AC"
-            elif ext in [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"]:
-                return "\U0001F4C4"
-            elif ext in [".zip", ".tar", ".gz", ".rar", ".7z"]:
-                return "\U0001F4E6"
-            elif ext in [".exe", ".dll", ".so", ".dylib"]:
-                return "\u26A1"
-            else:
-                return "\U0001F4C4"
-        if results:
-            files = sorted([f for f in results if f["type"] == "file"], key=lambda x: x["path"])
-            console.print(f"\U0001F4C1 [bold blue]{os.path.basename(directory) or directory}[/bold blue]")
-        all_items = sorted(results, key=lambda x: x["path"])
-        parent_dirs_with_content = set()
-        for i, item in enumerate(all_items):
-            if item["type"] == "directory" and not item["path"]:
-                continue
-            if os.sep in item["path"]:
-                parent_path = os.path.dirname(item["path"])
-                parent_dirs_with_content.add(parent_path)
-            depth = item["path"].count(os.sep) + 1 if item["path"] else 0
-            prefix = ""
-            for d in range(depth):
-                if d == depth - 1:
-                    prefix += "\u2514\u2500\u2500 "
-                else:
-                    prefix += "    "
-            name = os.path.basename(item["path"]) or item["path"]
-            if item["type"] == "directory":
-                console.print(f"{prefix}\U0001F4C1 [bold blue]{name}/[/bold blue]")
-            else:
-                icon = get_file_icon(item["path"])
-                size_str = format_size(item["size"])
-                console.print(f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]")
-        else:
-            console.print("[yellow]Directory is empty[/yellow]")
-        dir_count = sum(1 for item in results if item["type"] == "directory")
-        file_count = sum(1 for item in results if item["type"] == "file")
-        total_size = sum(item["size"] for item in results if item["type"] == "file")
-        console.print("\n[bold cyan]Summary:[/bold cyan]")
-        console.print(f"\U0001F4C1 [blue]{dir_count} directories[/blue], \U0001F4C4 [green]{file_count} files[/green] [dim]({format_size(total_size)} total)[/dim]")
-        console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return results
+    def list_files(
+        context: RunContext, directory: str = ".", recursive: bool = True
+    ) -> List[Dict[str, Any]]:
+        return _list_files(context, directory, recursive)
 
     @agent.tool
     def read_file(context: RunContext, file_path: str) -> Dict[str, Any]:
-        file_path = os.path.abspath(file_path)
-        if not os.path.exists(file_path):
-            return {"error": f"File '{file_path}' does not exist"}
-        if not os.path.isfile(file_path):
-            return {"error": f"'{file_path}' is not a file"}
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-            _, ext = os.path.splitext(file_path)
-            return {"content": content, "path": file_path, "extension": ext.lstrip("."), "total_lines": len(content.splitlines())}
-        except UnicodeDecodeError:
-            return {"error": f"Cannot read '{file_path}' as text - it may be a binary file"}
-        except Exception as e:
-            return {"error": f"Error reading file '{file_path}': {str(e)}"}
+        return _read_file(context, file_path)
 
     @agent.tool
-    def grep(context: RunContext, search_string: str, directory: str = ".") -> List[Dict[str, Any]]:
-        matches = []
-        max_matches = 200
-        directory = os.path.abspath(directory)
-        for root, dirs, files in os.walk(directory):
-            for file in files:
-                file_path = os.path.join(root, file)
-                if should_ignore_path(file_path):
-                    continue
-                try:
-                    with open(file_path, "r", encoding="utf-8") as f:
-                        for line_number, line in enumerate(f, start=1):
-                            if search_string in line:
-                                matches.append({"file_path": file_path, "line_number": line_number})
-                                if len(matches) >= max_matches:
-                                    return matches
-                except (FileNotFoundError, PermissionError, UnicodeDecodeError):
-                    continue
-        return matches
+    def grep(
+        context: RunContext, search_string: str, directory: str = "."
+    ) -> List[Dict[str, Any]]:
+        return _grep(context, search_string, directory)

code_puppy/tools/web_search.py

@@ -2,14 +2,30 @@ from typing import Dict
 import requests
 from pydantic_ai import RunContext
 
+
 def register_web_search_tools(agent):
     @agent.tool
     def grab_json_from_url(context: RunContext, url: str) -> Dict:
-        response = requests.get(url)
-        response.raise_for_status()
-        if response.headers.get('Content-Type') != 'application/json':
-            raise ValueError(f"Response from {url} is not of type application/json")
-        json_data = response.json()
-        if isinstance(json_data, list) and len(json_data) > 1000:
-            return json_data[:1000]
-        return json_data
+        from code_puppy.tools.common import console
+
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            ct = response.headers.get("Content-Type")
+            if "json" not in str(ct):
+                console.print(
+                    f"[bold red]Error:[/bold red] Response from {url} is not JSON (got {ct})"
+                )
+                return {"error": f"Response from {url} is not of type application/json"}
+            json_data = response.json()
+            if isinstance(json_data, list) and len(json_data) > 1000:
+                console.print("[yellow]Result list truncated to 1000 items[/yellow]")
+                return json_data[:1000]
+            if not json_data:
+                console.print("[yellow]No data found for URL:[/yellow]", url)
+            else:
+                console.print(f"[green]Successfully fetched JSON from:[/green] {url}")
+            return json_data
+        except Exception as exc:
+            console.print(f"[bold red]Error:[/bold red] {exc}")
+            return {"error": str(exc)}

code_puppy/version_checker.py

@@ -3,10 +3,10 @@ import requests
 
 def fetch_latest_version(package_name):
     try:
-        response = requests.get(f'https://pypi.org/pypi/{package_name}/json')
+        response = requests.get(f"https://pypi.org/pypi/{package_name}/json")
         response.raise_for_status()  # Raise an error for bad responses
         data = response.json()
-        return data['info']['version']
+        return data["info"]["version"]
     except requests.RequestException as e:
-        print(f'Error fetching version: {e}')
-        return None
+        print(f"Error fetching version: {e}")
+        return None

{code_puppy-0.0.52.dist-info → code_puppy-0.0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.52
+Version: 0.0.54
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

code_puppy-0.0.54.dist-info/RECORD

@@ -0,0 +1,28 @@
+code_puppy/__init__.py,sha256=-ANvE6Xe5NlWDIRCIfL1x-rgtCZ6zM2Ye9NphFoULSY,82
+code_puppy/agent.py,sha256=yA2247YbmBdff37joH8lRDKFk-iYreCugjY4qrdmsgA,3238
+code_puppy/agent_prompts.py,sha256=mUt9a430x0aYbnCw4L6t-Wst1_0FcqKYka_RHtnRog0,6774
+code_puppy/config.py,sha256=Mn9VWj8Ux-qnl636BH0jE1tuM-HQ6bYmRaozMg-vbg8,3941
+code_puppy/main.py,sha256=mLnECoA5b20Jb_9PUIznsMKOmChIjvX0lEpT69Dx7y4,10370
+code_puppy/model_factory.py,sha256=AtCBAWEK6OmPHL79HG3J-MxvlMbXJ9s4SBNblcZKemM,11645
+code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
+code_puppy/session_memory.py,sha256=CODAMmSsrxh8N9x_dXLryOSW3GnBXJ70auJnHm4m5Z8,2735
+code_puppy/version_checker.py,sha256=aRGulzuY4C4CdFvU1rITduyL-1xTFsn4GiD1uSfOl_Y,396
+code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
+code_puppy/command_line/file_path_completion.py,sha256=WSGpUO5PwpqxxJAhdjzUEWjJCxGWPUl5GU95KTg_Y40,2930
+code_puppy/command_line/meta_command_handler.py,sha256=XqidNJYaoYMaHcFI85RwwKYElEhPXgedkXwauw_4C60,5569
+code_puppy/command_line/model_picker_completion.py,sha256=QHxzhgTvbGFw0EYFJAukcWB3JTuK4Z1ZWaYvygMqfgM,3731
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=PyPo3H4CInBCbtddI91Owgwi1tKzWu9ryADOWWWMfHI,7942
+code_puppy/command_line/utils.py,sha256=_3wEvtJbey4E4qdg4pFX29sDPucRKGTyuodKI__NVrQ,1250
+code_puppy/tools/__init__.py,sha256=B1sHgH9mONPmWiGb6vucCIKzoRBlhM7UBxtfSRU1AEY,558
+code_puppy/tools/code_map.py,sha256=eAIT6IKEpq4OE6gE64HOjGMgEcPeJVEGb1eBHmFwaxY,3200
+code_puppy/tools/command_runner.py,sha256=m-0emolt81BvKuiEUBW8VPzrA1wgA_sXRJFmySPtxqA,6514
+code_puppy/tools/common.py,sha256=qX6wWsZPU9mwHX0AS2RIGIEQtQJ_AeWZ799LUvOCbfs,146
+code_puppy/tools/file_modifications.py,sha256=onhmNwlMlOD0BrnMH_1QGiwZQu0qAAiiN2dHRilzBHA,16124
+code_puppy/tools/file_operations.py,sha256=yEHeVS9S3S_iGpeqF3n9448oFSknaD2DbjIDY_URF54,6755
+code_puppy/tools/web_search.py,sha256=GvUJJUDQ_5VHkd_YJkRUWJdqr0Y-XSZIyzmUHHiVcus,1283
+code_puppy-0.0.54.data/data/code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
+code_puppy-0.0.54.dist-info/METADATA,sha256=6Y47f2cg5QxI3a7hs6WWbf51UQf3fEKLdXL0f7l9fkM,4716
+code_puppy-0.0.54.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.54.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.54.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.54.dist-info/RECORD,,

code_puppy-0.0.52.dist-info/RECORD

@@ -1,28 +0,0 @@
-code_puppy/__init__.py,sha256=orgffM-uGp8g1XCqXGKWaFB4tCCz8TVgsLMPKCOGNx0,81
-code_puppy/agent.py,sha256=avoOEorAYUyQYnYVVCezLz1QKDm0Qgx3i_C-BqgDiQQ,3198
-code_puppy/agent_prompts.py,sha256=A6ADydqbHozIAtwOy_UY-fYZ2XDE9_5oV3oxOMtVCFA,6782
-code_puppy/config.py,sha256=jsPnwDjz_H69Oww5JyEg3eud3rYMKp3ah2WrnablRak,3894
-code_puppy/main.py,sha256=_xm5qCLnG2al4yVtoq9dGkOu0CBsLlHLZEoDiPAmVAI,10220
-code_puppy/model_factory.py,sha256=vDlEoEKkOoikExCqi5oxb_PuTF8STUMABXAbPHV_p34,11639
-code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
-code_puppy/session_memory.py,sha256=vuLSw1Pfa-MXD4lD8hj2qt65OR_aL2WdoMuF6Jwnc1k,2597
-code_puppy/version_checker.py,sha256=cK-eU7Y_yYjn7feIONqzzZUdiedozL0iiKXlGKjfq68,395
-code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
-code_puppy/command_line/file_path_completion.py,sha256=HAlOu9XVYgJ7FbjdrhKBL0rFmCVFxSGGewdcfKTUsPw,2865
-code_puppy/command_line/meta_command_handler.py,sha256=YKXthyXl-4J0MixdTtzABK_E8ReDEBGi3ftGICglwUA,5407
-code_puppy/command_line/model_picker_completion.py,sha256=5VEa6OE9shsF0EafJXzBLpFXhFIkqevJi9RRD-eUvZA,3718
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=R-ykRmhVTieE4zIQnn7H1GDKk32yvalot0rZpFizLAQ,7358
-code_puppy/command_line/utils.py,sha256=L1PnV9tNupEW1zeziyb5aGAq8DYP8sMiuQbFYLO5Nus,1236
-code_puppy/tools/__init__.py,sha256=48BVpMt0HAMtz8G_z9SQhX6LnRqR83_AVfMQMf7bY0g,557
-code_puppy/tools/code_map.py,sha256=BghDHaebhGDfDGvA34gwO_5r92Py4O0Q3J4RV-WtnWs,3155
-code_puppy/tools/command_runner.py,sha256=eg7pOIMkuHtNYVqVE1pPsNYSR2D6XXnkwFaBKd-Ejc8,4773
-code_puppy/tools/common.py,sha256=dbmyZTrTBQh_0WWpaYN6jEync62W2mMrzNS8UFK0co4,146
-code_puppy/tools/file_modifications.py,sha256=nT87uAoY14RTAapnFCgkLTmW9g9P9bymxts2MpSpoo0,19297
-code_puppy/tools/file_operations.py,sha256=LJU_1b3WCXTAHa2B5VAbckrn1VVWb-HhcI3TF3BxYWs,11625
-code_puppy/tools/web_search.py,sha256=HhcwX0MMvMDPFO8gr8gzgesD5wPXOypjkxyLZeNwL5g,589
-code_puppy-0.0.52.data/data/code_puppy/models.json,sha256=7H-y97YK9BXhag5wJU19rtg24JtZWYx60RsBLBW3WiI,2162
-code_puppy-0.0.52.dist-info/METADATA,sha256=06k73QklKcPlf-plfu2-wmaMzosKy7qrqaFSamlYkXo,4716
-code_puppy-0.0.52.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.52.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.52.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.52.dist-info/RECORD,,