mirascope 1.25.7__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

mirascope/tools/system/_file_system.py

@@ -1,267 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from pathlib import Path
-from typing import TYPE_CHECKING, ClassVar
-
-from pydantic import Field, field_validator
-
-from mirascope.core.base import toolkit_tool
-from mirascope.tools.base import (
-    ConfigurableTool,
-    ConfigurableToolKit,
-    _ConfigurableToolConfig,
-)
-
-
-class FileSystemToolKitConfig(_ConfigurableToolConfig):
-    """Configuration for file_system toolkit"""
-
-    max_file_size: int = Field(
-        default=10 * 1024 * 1024,  # 10MB
-        description="Maximum file size in bytes",
-    )
-    allowed_extensions: list[str] = Field(
-        default=["txt", "md", "csv", "json", "yml", "yaml", "html"],
-        description="List of allowed file extensions",
-    )
-
-
-class FileOperation(ConfigurableTool[FileSystemToolKitConfig], ABC):
-    """Base class for file system operations."""
-
-    __configurable_tool_config__ = FileSystemToolKitConfig()
-
-    if TYPE_CHECKING:
-        # In create_tools method, the base_directory is set to ToolKit base_directory
-        base_directory: Path = Field(
-            default=Path.cwd(), description="Base directory for file operations"
-        )
-
-    def _validate_path(self, path: str) -> str | None:
-        """Validates file path for security and correctness.
-
-        Args:
-            path: The path to validate
-
-        Returns:
-            Optional[str]: Error message if validation fails, None if successful
-        """
-        file_path = self.base_directory / path
-
-        try:
-            file_path.resolve().relative_to(self.base_directory.resolve())
-        except ValueError:
-            return "Error: Invalid path (attempted path traversal)"
-
-        return None
-
-    def _validate_extension(self, path: str) -> str | None:
-        """Validates file extension against allowed extensions.
-
-        Args:
-            path: The path to validate
-
-        Returns:
-            str | None: Error message if validation fails, None if successful
-        """
-        extension = Path(path).suffix.lstrip(".")
-        if extension not in self._get_config().allowed_extensions:
-            return f"Error: Invalid file extension. Allowed: {self._get_config().allowed_extensions}"
-        return None
-
-
-class FileSystemToolKit(ConfigurableToolKit[FileSystemToolKitConfig]):
-    """ToolKit for file system operations.
-    Read, write, list, create, and delete files and directories.
-    """
-
-    config: FileSystemToolKitConfig = FileSystemToolKitConfig()
-
-    @toolkit_tool
-    class ReadFile(FileOperation):
-        """Tool for reading file contents."""
-
-        path: str
-
-        def call(self) -> str:
-            """Read and return file contents.
-
-            Returns:
-                str: File contents or error message if operation fails
-            """
-            if error := self._validate_path(self.path):
-                return error
-
-            if error := self._validate_extension(self.path):
-                return error
-
-            file_path = self.base_directory / self.path
-            if not file_path.is_file():
-                return f"Error: File {self.path} not found"
-
-            try:
-                if file_path.stat().st_size > self._get_config().max_file_size:
-                    return f"Error: File exceeds maximum size of {self._get_config().max_file_size} bytes"
-
-                return file_path.read_text()
-            except Exception as e:  # pragma: no cover
-                return f"Error reading file: {str(e)}"
-
-    @toolkit_tool
-    class WriteFile(FileOperation):
-        """Tool for writing content to a file."""
-
-        path: str
-        content: str
-
-        def call(self) -> str:
-            """Write content to file and return status.
-
-            Returns:
-                str: Success message or error message if operation fails
-            """
-            if error := self._validate_path(self.path):
-                return error
-
-            if error := self._validate_extension(self.path):
-                return error
-
-            file_path = self.base_directory / self.path
-            try:
-                content_size = len(self.content.encode("utf-8"))
-                if content_size > self._get_config().max_file_size:
-                    return f"Error: Content exceeds maximum size of {self._get_config().max_file_size} bytes"
-
-                file_path.parent.mkdir(parents=True, exist_ok=True)
-                file_path.write_text(self.content)
-                return f"Successfully wrote to {self.path}"
-            except Exception as e:  # pragma: no cover
-                return f"Error writing file: {str(e)}"
-
-    @toolkit_tool
-    class ListDirectory(FileOperation):
-        """Tool for listing directory contents."""
-
-        path: str = Field(default="")
-
-        def call(self) -> str:
-            """List directory contents and return formatted string.
-
-            Returns:
-                str: Formatted directory listing or error message if operation fails
-            """
-
-            if error := self._validate_path(self.path):
-                return error
-
-            dir_path = self.base_directory / self.path
-            if not dir_path.is_dir():
-                return f"Error: Directory {self.path} not found"
-
-            try:
-                contents: list[dict[str, str | int | None]] = []
-                for item in dir_path.iterdir():
-                    item_type = "file" if item.is_file() else "directory"
-                    size = item.stat().st_size if item.is_file() else None
-                    contents.append(
-                        {"name": item.name, "type": item_type, "size": size}
-                    )
-
-                output = f"Contents of {self.path or '.'} :\n"
-                for item in contents:
-                    size_info = (
-                        f" ({item['size']} bytes)" if item["size"] is not None else ""
-                    )
-                    output += f"- {item['name']} [{item['type']}]{size_info}\n"
-
-                return output
-            except Exception as e:  # pragma: no cover
-                return f"Error listing directory: {str(e)}"
-
-    @toolkit_tool
-    class CreateDirectory(FileOperation):
-        """Tool for creating directories."""
-
-        path: str
-
-        def call(self) -> str:
-            """Create directory and return status.
-
-            Returns:
-                str: Success message or error message if operation fails
-            """
-            if error := self._validate_path(self.path):
-                return error
-
-            dir_path = self.base_directory / self.path
-            try:
-                dir_path.mkdir(parents=True, exist_ok=True)
-                return f"Successfully created directory {self.path}"
-            except Exception as e:
-                return f"Error creating directory: {str(e)}"
-
-    @toolkit_tool
-    class DeleteFile(FileOperation):
-        """Tool for deleting files."""
-
-        path: str
-
-        def call(self) -> str:
-            """Delete file and return status.
-
-            Returns:
-                str: Success message or error message if operation fails
-            """
-            if error := self._validate_path(self.path):
-                return error
-
-            if error := self._validate_extension(self.path):
-                return error
-
-            file_path = self.base_directory / self.path
-            try:
-                if not file_path.exists():
-                    return f"Error: File {self.path} not found"
-
-                if not file_path.is_file():
-                    return f"Error: {self.path} is not a file"
-
-                file_path.unlink()
-                return f"Successfully deleted {self.path}"
-            except Exception as e:  # pragma: no cover
-                return f"Error deleting file: {str(e)}"
-
-    __configurable_tool_config__ = FileSystemToolKitConfig()
-    __namespace__ = "file_system"
-    __prompt_usage_description__: ClassVar[str] = """
-    - Tools for file system operations:
-        - ReadFile: Reads content from a file
-        - WriteFile: Writes content to a file
-        - ListDirectory: Lists directory contents
-        - CreateDirectory: Creates a new directory
-        - DeleteFile: Deletes a file
-    """
-
-    base_directory: Path = Field(
-        default=Path.cwd(), description="Base directory for file operations"
-    )
-
-    @field_validator("base_directory")
-    def validate_base_directory(cls, v: Path) -> Path:
-        """Validates that the base directory exists and is a directory.
-
-        Args:
-            v: The path to validate
-
-        Returns:
-            Path: The validated path
-
-        Raises:
-            ValueError: If the path doesn't exist or isn't a directory
-        """
-        if not v.exists():
-            raise ValueError(f"Base directory {v} does not exist")
-        if not v.is_dir():
-            raise ValueError(f"{v} is not a directory")
-        return v

mirascope/tools/web/_duckduckgo.py

@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-from typing import ClassVar
-
-from duckduckgo_search import DDGS, AsyncDDGS
-from pydantic import Field
-
-from ..base import ConfigurableTool, _ConfigurableToolConfig
-
-
-class DuckDuckGoSearchConfig(_ConfigurableToolConfig):
-    """Configuration for DuckDuckGo search"""
-
-    max_results_per_query: int = Field(
-        default=2, description="Maximum number of results per query"
-    )
-
-
-class _BaseDuckDuckGoSearch(ConfigurableTool[DuckDuckGoSearchConfig]):
-    """Tool for performing web searches using DuckDuckGo.
-
-    Takes search queries and returns relevant search results(Title, URL, Snippet).
-    """
-
-    __prompt_usage_description__: ClassVar[str] = """
-    - `DuckDuckGoSearch`: Performs web searches and returns formatted results
-        - Returns:
-          - Title: The title of the search result
-          - Link: The URL of the result page
-          - Snippet: A brief excerpt from the page content
-        - Results are automatically filtered and ranked by relevance 
-        - Multiple results returned per query based on configuration
-    """
-
-    __configurable_tool_config__ = DuckDuckGoSearchConfig()
-
-    queries: list[str] = Field(..., description="List of search queries")
-
-
-class DuckDuckGoSearch(_BaseDuckDuckGoSearch):
-    """Tool for performing web searches using DuckDuckGo.
-
-    Takes search queries and returns relevant search results(Title, URL, Snippet).
-    """
-
-    def call(self) -> str:
-        """Perform a web search using DuckDuckGo and return formatted results.
-
-        Returns:
-            str: Formatted search results if successful, error message if search fails
-        """
-
-        try:
-            all_results = []
-            for query in self.queries:
-                results = DDGS(proxies=None).text(
-                    query, max_results=self._get_config().max_results_per_query
-                )
-
-                all_results.extend(
-                    {
-                        "title": result["title"],
-                        "link": result["href"],
-                        "snippet": result["body"],
-                    }
-                    for result in results
-                )
-            return "\n\n".join(
-                f"Title: {r['title']}\nURL: {r['link']}\nSnippet: {r['snippet']}"
-                for r in all_results
-            )
-
-        except Exception as e:
-            return f"{type(e)}: Failed to search the web for text"
-
-
-class AsyncDuckDuckGoSearch(_BaseDuckDuckGoSearch):
-    """Tool for performing web searches using DuckDuckGo.
-
-    Takes search queries and returns relevant search results(Title, URL, Snippet).
-    """
-
-    async def call(self) -> str:
-        """Perform an asynchronous web search using DuckDuckGo and return formatted results.
-
-        Returns:
-            str: Formatted search results if successful, error message if search fails
-        """
-
-        try:
-            all_results = []
-            for query in self.queries:
-                results = await AsyncDDGS(proxies=None).atext(
-                    query, max_results=self._get_config().max_results_per_query
-                )
-
-                all_results.extend(
-                    {
-                        "title": result["title"],
-                        "link": result["href"],
-                        "snippet": result["body"],
-                    }
-                    for result in results
-                )
-            return "\n\n".join(
-                f"Title: {r['title']}\nURL: {r['link']}\nSnippet: {r['snippet']}"
-                for r in all_results
-            )
-
-        except Exception as e:
-            return f"{type(e)}: Failed to search the web for text"

mirascope/tools/web/_httpx.py

@@ -1,125 +0,0 @@
-from typing import ClassVar, Literal
-
-import httpx
-from pydantic import Field
-
-from mirascope.tools.base import ConfigurableTool, _ConfigurableToolConfig
-
-
-class HTTPXConfig(_ConfigurableToolConfig):
-    """Configuration for HTTPX requests"""
-
-    timeout: int = Field(
-        default=5,
-        description="Request timeout in seconds. When None, no timeout will be applied",
-    )
-
-
-class _BaseHTTPX(ConfigurableTool):
-    """Tool for making HTTP requests using HTTPX with configurable timeout and error handling."""
-
-    __configurable_tool_config__ = HTTPXConfig()
-
-    __prompt_usage_description__: ClassVar[str] = """
-    - `HTTPX`: Makes HTTP requests to web URLs with HTTPX client
-        - Supports standard HTTP methods (GET, POST, PUT, DELETE, etc.)
-        - Allows configuration of request data, headers, and parameters
-        - Automatically handles encoding/decoding of request/response content
-        - Handles redirects automatically (configurable)
-        - Returns response text or error message on failure
-        - Configurable timeout for requests
-    """
-
-    url: str = Field(..., description="URL to request")
-    method: Literal["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS"] = Field(
-        "GET", description="HTTP method to use"
-    )
-    data: dict | None = Field(
-        None, description="Form data to send with POST/PUT requests"
-    )
-    json_: dict | None = Field(
-        None, description="JSON data to send with POST/PUT requests", alias="json"
-    )
-    params: dict | None = Field(
-        None, description="URL parameters to include in the request"
-    )
-    headers: dict | None = Field(None, description="Request headers")
-    follow_redirects: bool = Field(
-        True, description="Whether to follow redirects automatically"
-    )
-
-
-class HTTPX(_BaseHTTPX):
-    def call(self) -> str:
-        """
-        Make an HTTP request to the given URL using HTTPX.
-
-        Returns:
-            str: Response text if successful, error message if request fails
-        """
-        try:
-            # Configure timeout - None means no timeout
-            timeout = (
-                httpx.Timeout(self._get_config().timeout)
-                if self._get_config().timeout is not None
-                else None
-            )
-
-            # Make request using context manager for proper resource cleanup
-            with httpx.Client(timeout=timeout) as client:
-                response = client.request(
-                    method=self.method,
-                    url=self.url,
-                    params=self.params,
-                    json=self.json_,
-                    data=self.data,
-                    headers=self.headers,
-                    follow_redirects=self.follow_redirects,
-                )
-                response.raise_for_status()
-                return response.text
-
-        except httpx.RequestError as e:
-            return f"Request error occurred: {str(e)}"
-        except httpx.HTTPStatusError as e:
-            return f"HTTP error occurred: {e.response.status_code} - {str(e)}"
-        except Exception as e:
-            return f"{type(e).__name__}: Failed to make request to {self.url}"
-
-
-class AsyncHTTPX(_BaseHTTPX):
-    async def call(self) -> str:
-        """
-        Make an asynchronous HTTP request to the given URL using HTTPX.
-
-        Returns:
-            str: Response text if successful, error message if request fails
-        """
-        try:
-            # Configure timeout - None means no timeout
-            timeout = (
-                httpx.Timeout(self._get_config().timeout)
-                if self._get_config().timeout is not None
-                else None
-            )
-
-            # Make async request using async context manager
-            async with httpx.AsyncClient(timeout=timeout) as client:
-                response = await client.request(
-                    method=self.method,
-                    url=self.url,
-                    params=self.params,
-                    json=self.json_,
-                    data=self.data,
-                    headers=self.headers,
-                    follow_redirects=self.follow_redirects,
-                )
-                response.raise_for_status()
-                return response.text
-
-        except httpx.RequestError as e:
-            return f"Request error occurred: {str(e)}"
-        except httpx.HTTPStatusError as e:
-            return f"HTTP error occurred: {e.response.status_code} - {str(e)}"
-        except Exception as e:
-            return f"{type(e).__name__}: Failed to make request to {self.url}"

mirascope/tools/web/_parse_url_content.py

@@ -1,94 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import ClassVar
-
-import requests
-from bs4 import BeautifulSoup
-from pydantic import Field
-
-from mirascope.tools.base import ConfigurableTool, _ConfigurableToolConfig
-
-
-class ParseURLConfig(_ConfigurableToolConfig):
-    """Configuration for URL content parsing"""
-
-    parser: str = Field(
-        "html.parser",
-        description="parser to use for parsing HTML content in BeautifulSoup",
-        examples=["html.parser", "lxml", "lxml-xml", "html5lib"],
-    )
-    timeout: int = Field(
-        default=5,
-        description="Timeout in seconds for URL request",
-    )
-
-
-class ParseURLContent(ConfigurableTool[ParseURLConfig]):
-    """Tool for parsing and extracting main content from URLs.
-
-    Fetches content from URL, removes unnecessary elements like scripts, styles, navigation, etc.,
-    and returns clean text content from the webpage's main body.
-    """
-
-    __configurable_tool_config__ = ParseURLConfig()  # pyright: ignore [reportCallIssue]
-    __prompt_usage_description__: ClassVar[str] = """
-    - `ParseURLContent`: Returns the given URL's main content as clean text
-        - Fetches the raw HTML content for the given URL
-        - Removes all unwanted elements (scripts, styles, navigation, etc.)
-        - Attempts to find the main content section
-        - If no main content section is found, extracts all text content
-        - Returns cleaned and formatted text content
-        - If any errors occur during fetching or parsing, and error message is returned.
-    """
-
-    url: str = Field(..., description="URL to fetch and parse")
-
-    def call(self) -> str:
-        """Fetch and parse content from the URL.
-
-        Returns:
-            str: Cleaned text content from the URL if successful, error message if parsing fails
-        """
-        try:
-            # Fetch content from URL
-            response = requests.get(
-                self.url,
-                timeout=self._get_config().timeout,
-            )
-            response.raise_for_status()
-
-            # Parse HTML content
-            soup = BeautifulSoup(response.text, self._get_config().parser)
-
-            # Remove unwanted tags
-            unwanted_tags = ["script", "style", "nav", "header", "footer", "aside"]
-            for tag in unwanted_tags:
-                for element in soup.find_all(tag):
-                    element.decompose()
-
-            # Find main content section
-            main_content = (
-                soup.find("main")
-                or soup.find("article")
-                or soup.find("div", class_=re.compile("content|main"))
-            )
-
-            # Extract and clean text
-            if main_content:
-                text = main_content.get_text(separator="\n", strip=True)
-            else:
-                text = soup.get_text(separator="\n", strip=True)
-
-            # Remove empty lines and format
-            lines = (line.strip() for line in text.splitlines())
-            content = "\n".join(line for line in lines if line)
-
-            if not content:
-                return "No content found on the page"
-            return content
-
-        except requests.RequestException as e:
-            return f"Failed to fetch content from URL: {str(e)}"
-        except Exception as e:  # pragma: no cover
-            return f"{type(e).__name__}: Failed to parse content from URL"

mirascope/tools/web/_requests.py

@@ -1,54 +0,0 @@
-from typing import ClassVar, Literal
-
-import requests
-from pydantic import Field
-
-from mirascope.tools.base import ConfigurableTool, _ConfigurableToolConfig
-
-
-class RequestsConfig(_ConfigurableToolConfig):
-    """Configuration for HTTP requests"""
-
-    timeout: int = Field(default=5, description="Request timeout in seconds")
-
-
-class Requests(ConfigurableTool):
-    """Tool for making HTTP requests with built-in requests library."""
-
-    __configurable_tool_config__ = RequestsConfig()
-
-    __prompt_usage_description__: ClassVar[str] = """
-    - `Requests`: Makes HTTP requests to web URLs using requests library
-        - Supports common HTTP methods (GET, POST, PUT, DELETE)
-        - Accepts custom headers and request data
-        - Returns response text content
-        - Automatically raises for HTTP errors (4xx, 5xx)
-        - Returns error message if request fails
-        - Configurable timeout for all requests
-    """
-    url: str = Field(..., description="URL to request")
-    method: Literal["GET", "POST", "PUT", "DELETE"] = Field(
-        "GET", description="HTTP method"
-    )
-    data: dict | None = Field(None, description="Data to send with POST/PUT requests")
-    headers: dict | None = Field(None, description="Request headers")
-
-    def call(self) -> str:
-        """Make an HTTP request to the given URL.
-
-        Returns:
-            str: Response text content if successful, error message if request fails
-        """
-        try:
-            response = requests.request(
-                method=self.method,
-                url=self.url,
-                json=self.data,
-                headers=self.headers,
-                timeout=self._get_config().timeout,
-            )
-            response.raise_for_status()
-            return response.text
-
-        except Exception as e:
-            return f"{type(e)}: Failed to extract content from URL {self.url}"