airtrain 0.1.58__py3-none-any.whl → 0.1.62__py3-none-any.whl

airtrain/tools/search.py

@@ -0,0 +1,450 @@
+"""
+Search tools for AirTrain agents.
+
+This module provides tools for searching for content within files and directories.
+"""
+
+import os
+import re
+import subprocess
+from typing import Dict, Any, List, Optional, cast
+
+from .registry import StatelessTool, register_tool
+from airtrain.integrations.search.exa import (
+    ExaCredentials,
+    ExaSearchSkill,
+    ExaSearchInputSchema,
+    ExaSearchOutputSchema,
+    ExaContentConfig,
+)
+
+
+@register_tool("search_term")
+class SearchTermTool(StatelessTool):
+    """Tool for searching for specific terms within files."""
+
+    def __init__(self):
+        self.name = "search_term"
+        self.description = "Search for a specific term or pattern within files"
+        self.parameters = {
+            "type": "object",
+            "properties": {
+                "term": {
+                    "type": "string",
+                    "description": "The term or pattern to search for",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in (defaults to current directory)",
+                },
+                "file_pattern": {
+                    "type": "string",
+                    "description": "Pattern to filter files (e.g., *.py, *.txt)",
+                },
+                "case_sensitive": {
+                    "type": "boolean",
+                    "description": "Whether the search should be case-sensitive",
+                },
+                "regex": {
+                    "type": "boolean",
+                    "description": "Whether to treat the term as a regular expression",
+                },
+                "max_results": {
+                    "type": "integer",
+                    "description": "Maximum number of results to return",
+                },
+                "max_context_lines": {
+                    "type": "integer",
+                    "description": "Number of context lines to show before and after matches",
+                },
+            },
+            "required": ["term"],
+        }
+
+    def __call__(
+        self,
+        term: str,
+        directory: str = ".",
+        file_pattern: str = "*",
+        case_sensitive: bool = False,
+        regex: bool = False,
+        max_results: int = 100,
+        max_context_lines: int = 2,
+    ) -> Dict[str, Any]:
+        """Search for a specific term within files."""
+        try:
+            # Try to use grep if available (more efficient than pure Python)
+            try:
+                return self._search_with_grep(
+                    term,
+                    directory,
+                    file_pattern,
+                    case_sensitive,
+                    regex,
+                    max_results,
+                    max_context_lines,
+                )
+            except (subprocess.SubprocessError, FileNotFoundError):
+                # Fall back to Python implementation if grep is not available
+                return self._search_with_python(
+                    term,
+                    directory,
+                    file_pattern,
+                    case_sensitive,
+                    regex,
+                    max_results,
+                    max_context_lines,
+                )
+        except Exception as e:
+            return {"success": False, "error": f"Error searching for term: {str(e)}"}
+
+    def _search_with_grep(
+        self,
+        term: str,
+        directory: str,
+        file_pattern: str,
+        case_sensitive: bool,
+        regex: bool,
+        max_results: int,
+        max_context_lines: int,
+    ) -> Dict[str, Any]:
+        """Use grep to search for terms (more efficient)."""
+        # Prepare grep command
+        cmd = ["grep"]
+
+        # Add grep options
+        if not case_sensitive:
+            cmd.append("-i")  # Case insensitive
+
+        if not regex:
+            cmd.append("-F")  # Fixed string (not regex)
+
+        # Add context lines
+        if max_context_lines > 0:
+            cmd.append(f"-C{max_context_lines}")  # Context lines
+
+        # Add recursive search
+        cmd.append("-r")
+
+        # Add line numbers
+        cmd.append("-n")
+
+        # Add max count if specified
+        if max_results > 0:
+            cmd.append(f"--max-count={max_results}")
+
+        # Add search term
+        cmd.append(term)
+
+        # Add directory
+        cmd.append(directory)
+
+        # Add file pattern if specified
+        if file_pattern != "*":
+            cmd.append("--include")
+            cmd.append(file_pattern)
+
+        # Execute grep command
+        result = subprocess.run(cmd, capture_output=True, text=True)
+
+        # Process results
+        if result.returncode != 0 and result.returncode != 1:  # 1 means no matches
+            raise subprocess.SubprocessError(f"Grep error: {result.stderr}")
+
+        # Parse output
+        matches = []
+        for line in result.stdout.splitlines():
+            if not line.strip():
+                continue
+
+            # Parse grep output (filename:line_number:content)
+            parts = line.split(":", 2)
+            if len(parts) >= 3:
+                filename = parts[0]
+                line_number = int(parts[1])
+                content = parts[2]
+
+                matches.append(
+                    {"file": filename, "line": line_number, "content": content}
+                )
+
+        return {
+            "success": True,
+            "term": term,
+            "directory": directory,
+            "file_pattern": file_pattern,
+            "matches": matches,
+            "match_count": len(matches),
+            "truncated": result.stdout.count("\n") >= max_results,
+        }
+
+    def _search_with_python(
+        self,
+        term: str,
+        directory: str,
+        file_pattern: str,
+        case_sensitive: bool,
+        regex: bool,
+        max_results: int,
+        max_context_lines: int,
+    ) -> Dict[str, Any]:
+        """Use Python to search for terms (fallback method)."""
+        import fnmatch
+        import glob
+
+        # Expand directory path
+        directory = os.path.expanduser(directory)
+
+        if not os.path.exists(directory):
+            return {
+                "success": False,
+                "error": f"Directory '{directory}' does not exist",
+            }
+
+        if not os.path.isdir(directory):
+            return {"success": False, "error": f"Path '{directory}' is not a directory"}
+
+        # Compile regex if needed
+        if regex:
+            if case_sensitive:
+                pattern = re.compile(term)
+            else:
+                pattern = re.compile(term, re.IGNORECASE)
+        else:
+            if case_sensitive:
+                pattern = re.compile(re.escape(term))
+            else:
+                pattern = re.compile(re.escape(term), re.IGNORECASE)
+
+        # Find all files matching the pattern
+        matches = []
+        match_count = 0
+        truncated = False
+
+        for root, _, files in os.walk(directory):
+            for filename in fnmatch.filter(files, file_pattern):
+                file_path = os.path.join(root, filename)
+
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        lines = f.readlines()
+
+                    # Search for matches in the file
+                    for i, line in enumerate(lines):
+                        if pattern.search(line):
+                            line_number = i + 1
+
+                            # Extract context lines
+                            context_start = max(0, i - max_context_lines)
+                            context_end = min(len(lines), i + max_context_lines + 1)
+                            context_lines = lines[context_start:context_end]
+
+                            matches.append(
+                                {
+                                    "file": file_path,
+                                    "line": line_number,
+                                    "content": line.rstrip("\n"),
+                                    "context": {
+                                        "start_line": context_start + 1,
+                                        "end_line": context_end,
+                                        "lines": [
+                                            l.rstrip("\n") for l in context_lines
+                                        ],
+                                    },
+                                }
+                            )
+
+                            match_count += 1
+                            if match_count >= max_results:
+                                truncated = True
+                                break
+
+                    if truncated:
+                        break
+
+                except Exception as e:
+                    # Skip files that can't be read
+                    continue
+
+            if truncated:
+                break
+
+        return {
+            "success": True,
+            "term": term,
+            "directory": directory,
+            "file_pattern": file_pattern,
+            "matches": matches,
+            "match_count": match_count,
+            "truncated": truncated,
+        }
+
+    def to_dict(self):
+        """Convert tool to dictionary format for LLM function calling."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+
+
+@register_tool("web_search")
+class WebSearchTool(StatelessTool):
+    """Tool for searching the web using the Exa API."""
+
+    def __init__(self):
+        self.name = "web_search"
+        self.description = "Search the web for information using the Exa search API"
+        self.parameters = {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The search query to execute",
+                },
+                "num_results": {
+                    "type": "integer",
+                    "description": "Number of results to return (default: 5)",
+                },
+                "include_domains": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of domains to include in the search",
+                },
+                "exclude_domains": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of domains to exclude from the search",
+                },
+                "use_autoprompt": {
+                    "type": "boolean",
+                    "description": "Whether to use Exa's autoprompt feature for better results",
+                },
+            },
+            "required": ["query"],
+        }
+
+        # Exa API key from environment variable
+        api_key = os.environ.get("EXA_API_KEY", "")
+        if api_key:
+            self.credentials = ExaCredentials(api_key=api_key)
+            self.skill = ExaSearchSkill(credentials=self.credentials)
+        else:
+            self.credentials = None
+            self.skill = None
+
+    async def _async_search(
+        self,
+        query: str,
+        num_results: int = 5,
+        include_domains: Optional[List[str]] = None,
+        exclude_domains: Optional[List[str]] = None,
+        use_autoprompt: bool = False,
+    ) -> Dict[str, Any]:
+        """Execute the search asynchronously."""
+        if not self.credentials or not self.skill:
+            return {
+                "success": False,
+                "error": "Exa API key not configured. Set the EXA_API_KEY environment variable.",
+            }
+
+        try:
+            # Create input for the search
+            search_input = ExaSearchInputSchema(
+                query=query,
+                numResults=num_results,
+                includeDomains=include_domains,
+                excludeDomains=exclude_domains,
+                useAutoprompt=use_autoprompt,
+                contents=ExaContentConfig(text=True),
+            )
+
+            # Execute search
+            result = await self.skill.process(search_input)
+
+            # Process results into a simplified format
+            search_results = []
+            for item in result.results:
+                search_results.append(
+                    {
+                        "title": item.title or "No title",
+                        "url": item.url,
+                        "content": (
+                            item.text[:1000] if item.text else "No content available"
+                        ),
+                        "score": item.score,
+                        "published": item.published,
+                    }
+                )
+
+            return {
+                "success": True,
+                "query": query,
+                "results": search_results,
+                "result_count": len(search_results),
+                "autoprompt": result.autopromptString,
+            }
+
+        except Exception as e:
+            return {"success": False, "error": f"Error performing web search: {str(e)}"}
+
+    def __call__(
+        self,
+        query: str,
+        num_results: int = 5,
+        include_domains: Optional[List[str]] = None,
+        exclude_domains: Optional[List[str]] = None,
+        use_autoprompt: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Search the web for information.
+
+        Args:
+            query: The search query to execute
+            num_results: Number of results to return
+            include_domains: List of domains to include in search results
+            exclude_domains: List of domains to exclude from search results
+            use_autoprompt: Whether to use Exa's autoprompt feature
+
+        Returns:
+            Dictionary containing search results or error information
+        """
+        import asyncio
+
+        if not self.credentials or not self.skill:
+            return {
+                "success": False,
+                "error": "Exa API key not configured. Set the EXA_API_KEY environment variable.",
+            }
+
+        # Run the async search in a new event loop
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(
+                self._async_search(
+                    query=query,
+                    num_results=num_results,
+                    include_domains=include_domains,
+                    exclude_domains=exclude_domains,
+                    use_autoprompt=use_autoprompt,
+                )
+            )
+            loop.close()
+            return result
+        except Exception as e:
+            return {"success": False, "error": f"Error executing search: {str(e)}"}
+
+    def to_dict(self):
+        """Convert tool to dictionary format for LLM function calling."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

airtrain/tools/testing.py

@@ -0,0 +1,135 @@
+"""
+Testing tools for AirTrain agents.
+
+This module provides tools for running tests and test frameworks.
+"""
+
+import os
+import subprocess
+from typing import Dict, Any, Optional, List
+
+from .registry import StatelessTool, register_tool
+
+
+@register_tool("run_pytest")
+class RunPytestTool(StatelessTool):
+    """Tool for running Python pytest on test files."""
+
+    def __init__(self):
+        self.name = "run_pytest"
+        self.description = "Run pytest on a specific test file or directory"
+        self.parameters = {
+            "type": "object",
+            "properties": {
+                "test_path": {
+                    "type": "string",
+                    "description": "Path to the test file or directory to run",
+                },
+                "args": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Additional pytest arguments",
+                },
+                "working_dir": {
+                    "type": "string",
+                    "description": "Working directory to run pytest from",
+                },
+                "verbose": {
+                    "type": "boolean",
+                    "description": "Run tests in verbose mode",
+                },
+                "capture_output": {
+                    "type": "boolean",
+                    "description": "Capture stdout/stderr or show directly",
+                },
+                "timeout": {
+                    "type": "number",
+                    "description": "Timeout in seconds for the test run",
+                },
+            },
+            "required": ["test_path"],
+        }
+
+    def __call__(
+        self,
+        test_path: str,
+        args: Optional[List[str]] = None,
+        working_dir: Optional[str] = None,
+        verbose: bool = False,
+        capture_output: bool = True,
+        timeout: float = 60.0,
+    ) -> Dict[str, Any]:
+        """Run pytest on a specific test file or directory."""
+        try:
+            # Expand user path if present
+            test_path = os.path.expanduser(test_path)
+
+            # Validate test path
+            if not os.path.exists(test_path):
+                return {
+                    "success": False,
+                    "error": f"Test path '{test_path}' does not exist",
+                }
+
+            # Prepare pytest command
+            cmd = ["pytest", test_path]
+
+            # Add verbosity flag if requested
+            if verbose:
+                cmd.append("-v")
+
+            # Add any additional arguments
+            if args:
+                cmd.extend(args)
+
+            # Run pytest
+            process = subprocess.run(
+                cmd,
+                cwd=working_dir,
+                capture_output=capture_output,
+                text=True,
+                timeout=timeout,
+            )
+
+            result = {
+                "success": process.returncode == 0,
+                "return_code": process.returncode,
+                "test_path": test_path,
+                "command": " ".join(cmd),
+            }
+
+            if capture_output:
+                result["stdout"] = process.stdout
+                result["stderr"] = process.stderr
+
+                # Parse test summary from output
+                if "failed" in process.stdout or "passed" in process.stdout:
+                    summary_lines = []
+                    for line in process.stdout.splitlines():
+                        if "failed" in line or "passed" in line or "skipped" in line:
+                            if "===" in line and "===" in line:
+                                summary_lines.append(line.strip())
+
+                    if summary_lines:
+                        result["summary"] = summary_lines
+
+            return result
+
+        except subprocess.TimeoutExpired:
+            return {
+                "success": False,
+                "error": f"Pytest run timed out after {timeout} seconds",
+            }
+        except Exception as e:
+            return {"success": False, "error": f"Error running pytest: {str(e)}"}
+
+    def to_dict(self):
+        """Convert tool to dictionary format for LLM function calling."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

{airtrain-0.1.58.dist-info → airtrain-0.1.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airtrain
-Version: 0.1.58
+Version: 0.1.62
 Summary: A platform for building and deploying AI agents with structured skills
 Home-page: https://github.com/rosaboyle/airtrain.dev
 Author: Dheeraj Pai

{airtrain-0.1.58.dist-info → airtrain-0.1.62.dist-info}/RECORD

@@ -1,6 +1,6 @@
-airtrain/__init__.py,sha256=8g5IGtnihwqBfltBMs9vMLsTNsnhwiYSXlWBkIOpqC0,3312
+airtrain/__init__.py,sha256=gTO8GEuN1gIKjo5HlBOURfVnRtEuv61zF-HMxTXQYQk,3357
 airtrain/__main__.py,sha256=EU8ffFmCdC1G-UcHHt0Oo3lB1PGqfC6kwzH39CnYSwU,72
-airtrain/__pycache__/__init__.cpython-313.pyc,sha256=b5Xwx91d-BMvzIS-P4uZK8btsx2_mlxfUxvtoT4pVeA,3000
+airtrain/__pycache__/__init__.cpython-313.pyc,sha256=gNzuKeI25qKWqhRq6MRzf8Otl1qJEekuX_QU0HAx7bE,2759
 airtrain/agents/__init__.py,sha256=r6v5_bblxamRgiaCT8CVhyzaDdWohGM7sSjLgIUpA5s,795
 airtrain/agents/example_agent.py,sha256=0dCS8QXIvUYYkxwyOEMLMdlQ4KgMAerQ56r7NcYGqTw,11681
 airtrain/agents/groq_agent.py,sha256=s-f-cGSrgsR4Jlrv6xzeg2Z0LAEHByhFMYVbTvu-Bkg,10558
@@ -16,13 +16,13 @@ airtrain/contrib/travel/__init__.py,sha256=clmBodw4nkTA-DsgjVGcXfJGPaWxIpCZDtdO-
 airtrain/contrib/travel/agents.py,sha256=tpQtZ0WUiXBuhvZtc2JlEam5TuR5l-Tndi14YyImDBM,8975
 airtrain/contrib/travel/models.py,sha256=E4Mtds5TINmXLXu65aTYqv6wwOh2KclJHZ2eXRrBqiY,1547
 airtrain/core/__init__.py,sha256=9h7iKwTzZocCPc9bU6j8bA02BokteWIOcO1uaqGMcrk,254
-airtrain/core/credentials.py,sha256=PgQotrQc46J5djidKnkK1znUv3fyNkUFDO-m2Kn_Gzo,4006
+airtrain/core/credentials.py,sha256=J1jd8vLrOfet0GhLI1J44d35o7skjriBsMgpODmXwfo,5592
 airtrain/core/schemas.py,sha256=MMXrDviC4gRea_QaPpbjgO--B_UKxnD7YrxqZOLJZZU,7003
 airtrain/core/skills.py,sha256=kIkI1MwIzuAwyoxdnZ5MGOb70BOB-njbVb_csJEdVvc,9244
-airtrain/core/__pycache__/__init__.cpython-313.pyc,sha256=DEcKhvQGoYLFbdtCs9Fqp8sKXh8xM_viOh0drOix1cY,534
-airtrain/core/__pycache__/schemas.cpython-313.pyc,sha256=DX72FLcg5BWaj-xv6yjPFZvrhYhQY7jte89gIrNGEw0,8327
-airtrain/core/__pycache__/skills.cpython-313.pyc,sha256=lKR7C-bY2uS4Ad12UNSO8MLVxU-52OLJPC-nzV4u79w,11839
-airtrain/integrations/__init__.py,sha256=Y0yJt6c6uKOkMXdGPELSc6NYiLrEYr_38acViNPXWNk,2046
+airtrain/core/__pycache__/__init__.cpython-313.pyc,sha256=aHwrmX5Hf3s9pSa8V0PH3ytqldRjB_X9AWwA6IDpzyk,534
+airtrain/core/__pycache__/schemas.cpython-313.pyc,sha256=WpKRuARzTVGt_NDMApl8GNIQgF_jZcHV34z-KYs3g5g,8327
+airtrain/core/__pycache__/skills.cpython-313.pyc,sha256=4EppdsB6rISIJNF8CbyCPHXlMCX1JKETeKxOS8hENLw,11839
+airtrain/integrations/__init__.py,sha256=nGG3gZJ_sEaMzi_utsQCzExgnpHUjua8L9TyzofLQnw,2842
 airtrain/integrations/anthropic/__init__.py,sha256=K741w3v7fWsCknTo38ARqDL0D3HPlwDIvDuuBao9Tto,800
 airtrain/integrations/anthropic/credentials.py,sha256=hlTSw9HX66kYNaeQUtn0JjdZQBMNkzzFOJOoLOOzvcY,1246
 airtrain/integrations/anthropic/list_models.py,sha256=o7FABp0Cq3gs76zOF-CM9ohmYslWT6vK9qtQabV9XzI,3973
@@ -36,7 +36,7 @@ airtrain/integrations/cerebras/credentials.py,sha256=KDEH4r8FGT68L9p34MLZWK65wq_
 airtrain/integrations/cerebras/skills.py,sha256=BJEb_7TglCYAukD3kcx37R8ibnJWdxVrBrwf3ZTYP-4,4924
 airtrain/integrations/combined/__init__.py,sha256=EL_uZs8436abeZA6NbM-gLdur7kJr4YfGGOYybKOhjc,467
 airtrain/integrations/combined/groq_fireworks_skills.py,sha256=Kz8UDU4-Rl71znz3ml9qVMRz669iWx4sUl37iafW0NU,4612
-airtrain/integrations/combined/list_models_factory.py,sha256=aLYEpJdbWVmvrrxa4e3_N0Lqq4_ZOFkByWKIqFCmJfI,7195
+airtrain/integrations/combined/list_models_factory.py,sha256=pFvIMeAZSRC7e51qknD9LzLkNhNgZL4pItzGNGzZdNY,8263
 airtrain/integrations/fireworks/__init__.py,sha256=GstUg0rYC-7Pg0DVbDXwL5eO1hp3WCSfroWazbGpfi0,545
 airtrain/integrations/fireworks/completion_skills.py,sha256=zxx7aNlum9scQMri5Ek0qN8VfAomhyUp3u8JJo_AFWM,5615
 airtrain/integrations/fireworks/conversation_manager.py,sha256=ifscKHYKWM_NDElin-oTzpRhyoh6pzBnklmMuH5geOY,3706
@@ -64,9 +64,19 @@ airtrain/integrations/openai/credentials.py,sha256=NfRyp1QgEtgm8cxt2-BOLq-6d0X-P
 airtrain/integrations/openai/list_models.py,sha256=vg8pZwLZ3F2Fx42X18WykpJOzZD9JG-2KJi49XWgSKo,4121
 airtrain/integrations/openai/models_config.py,sha256=W9mu_z9tCC4ZUKHSJ6Hk4X09TRZLqEhT7TtRY5JEk5g,8007
 airtrain/integrations/openai/skills.py,sha256=kEDe5q0Zlv_X-JGOYtb552ktb3aQQYVUYczVwMH0jxA,12823
+airtrain/integrations/perplexity/__init__.py,sha256=asVQs-oVXVhnLmAOZ6l9R8KoigeHmw8D5OONb_aGgnY,1189
+airtrain/integrations/perplexity/credentials.py,sha256=5acl2DcF0dk7DQJWRwmFkBXPQ1zfKN4ARW31dP-4rpQ,1524
+airtrain/integrations/perplexity/list_models.py,sha256=iOOxQ50BfLc226ps0gSdFl-enxa-SmStiuU2vFTUhJ0,4298
+airtrain/integrations/perplexity/models_config.py,sha256=cMHk6kjy-u8KfxU0KmuJ9rLiquwSGuj_-SOtj9wHlM4,4060
+airtrain/integrations/perplexity/skills.py,sha256=-RBwnv5wg0s-TwG--ZrCy2WikuMpNx15FGdsoNctRB0,10545
 airtrain/integrations/sambanova/__init__.py,sha256=dp_263iOckM_J9pOEvyqpf3FrejD6-_x33r0edMCTe0,179
 airtrain/integrations/sambanova/credentials.py,sha256=JyN8sbMCoXuXAjim46aI3LTicBijoemS7Ao0rn4yBJU,824
 airtrain/integrations/sambanova/skills.py,sha256=SZ_GAimMiOCILiNkzyhNflyRR6bdC5r0Tnog19K8geU,4997
+airtrain/integrations/search/__init__.py,sha256=r-hCYff5IdgI4IgQyMUzKzc_CVryl1oiweaGC3TwZ-8,405
+airtrain/integrations/search/exa/__init__.py,sha256=YdINIFcuT4pC72obDYx7DHVdMzlEg03BRQJi57SKc3g,486
+airtrain/integrations/search/exa/credentials.py,sha256=yOJIQdWs6RXX2Msk453VHH7FYQffpF946afaEWgVg4o,900
+airtrain/integrations/search/exa/schemas.py,sha256=QsTh-UfCAJ-YCy0TgjC7iJDADBCdY3Eu4NBi9BSGiuk,3791
+airtrain/integrations/search/exa/skills.py,sha256=zCoSOxeJk27umLHdYVZbW5sDz-kcbuBzH0SE0C7lLZg,3754
 airtrain/integrations/together/__init__.py,sha256=5p2v5kvryl-Z8eSMxdrMQtgzynPo6zQ6vZqpxBADA1I,878
 airtrain/integrations/together/audio_models_config.py,sha256=GtqfmKR1vJ5x4B3kScvEO3x4exvzwNP78vcGVTk_fBE,1004
 airtrain/integrations/together/credentials.py,sha256=cYNhyIwgsxm8LfiFfT-omBvgV3mUP6SZeRSukyzzDlI,747
@@ -84,13 +94,15 @@ airtrain/integrations/together/vision_models_config.py,sha256=m28HwYDk2Kup_J-a1F
 airtrain/telemetry/__init__.py,sha256=_xDHzSmQvRCqihT0QTmF7bS9yKEl2LaZ3Zq05hXaI3k,1108
 airtrain/telemetry/service.py,sha256=6IB2-FL3fGsYYgMIVQ9MNCp9UlSE5cVhLlB3VBYkAnY,5592
 airtrain/telemetry/views.py,sha256=qob1swyLNEk_UIpDi5VTwMDsEsGZhJheFQrGbP8T5hw,8115
-airtrain/tools/__init__.py,sha256=RRqbnUqKorql5D1FDQArxpdwC5d8kUaeNzN9iZKY8V8,827
-airtrain/tools/command.py,sha256=-Qmto_PqivHQBasW8PtSYoTk_NR5Wl4zz4n7u71egMQ,6983
+airtrain/tools/__init__.py,sha256=AauO_EEBcK09mkyCuvvVK_Oz0L5DOrnuySViWXCOt6Y,1021
+airtrain/tools/command.py,sha256=dxvs6RzppjWmkUe1oMtxOc7w2mFOGFFZ9Gylwnm37Sw,13355
 airtrain/tools/filesystem.py,sha256=-YYdHj_KeSWPYXeRhWhIX9s_KujVA1R5tF3r93zRVTU,6324
 airtrain/tools/network.py,sha256=YR0AtMXDXkhCsXcx7_t2d12ItnKY8XXTmyP1kdj2M4c,3883
 airtrain/tools/registry.py,sha256=K-1H5EipYcDNDx2jdpsEY9gjfV4aNCGI1pY2UsgSpC0,10246
-airtrain-0.1.58.dist-info/METADATA,sha256=3FCm8ujh-Lu1bEttg5i2GhsONwI5WwjQYAhSl2R10P0,6503
-airtrain-0.1.58.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-airtrain-0.1.58.dist-info/entry_points.txt,sha256=rrJ36IUsyq6n1dSfTWXqVAgpQLPRWDfCqwd6_3B-G0U,52
-airtrain-0.1.58.dist-info/top_level.txt,sha256=cFWW1vY6VMCb3AGVdz6jBDpZ65xxBRSqlsPyySxTkxY,9
-airtrain-0.1.58.dist-info/RECORD,,
+airtrain/tools/search.py,sha256=MJNi17g6aBPSqbF0ChV8ZgMlzz_PoKSPAIpe_dazdt8,15081
+airtrain/tools/testing.py,sha256=q4ALEPRzukiadY6wFSPY7vA-T1o3XInLhXt18dsf6yY,4397
+airtrain-0.1.62.dist-info/METADATA,sha256=fAOQQht25N594JsKGN6sFuiqjVMPjKMtly_RP6JW9co,6503
+airtrain-0.1.62.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+airtrain-0.1.62.dist-info/entry_points.txt,sha256=rrJ36IUsyq6n1dSfTWXqVAgpQLPRWDfCqwd6_3B-G0U,52
+airtrain-0.1.62.dist-info/top_level.txt,sha256=cFWW1vY6VMCb3AGVdz6jBDpZ65xxBRSqlsPyySxTkxY,9
+airtrain-0.1.62.dist-info/RECORD,,

{airtrain-0.1.58.dist-info → airtrain-0.1.62.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any