autobyteus 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

autobyteus/tools/browser/standalone/navigate_to.py

@@ -11,10 +11,14 @@ class NavigateTo(BaseTool, UIIntegrator):
         BaseTool.__init__(self)
         UIIntegrator.__init__(self)
 
-    def tool_usage(self):
-        return "NavigateTo: Navigates to a specified website. Usage: <<<NavigateTo(url='https://example.com')>>>, where 'https://example.com' is the URL of the website to navigate to."
+    @classmethod
+    def tool_usage_xml(cls):
+        """
+        Return an XML string describing the usage of the NavigateTo tool.
 
-    def tool_usage_xml(self):
+        Returns:
+            str: An XML description of how to use the NavigateTo tool.
+        """
         return '''
         NavigateTo: Navigates to a specified website. Usage:
         <command name="NavigateTo">
@@ -24,18 +28,6 @@ class NavigateTo(BaseTool, UIIntegrator):
         '''
 
     async def _execute(self, **kwargs):
-        """
-        Navigate to the specified URL using Playwright.
-
-        Args:
-            **kwargs: Keyword arguments containing the URL. The URL should be specified as 'url'.
-
-        Returns:
-            str: A message indicating successful navigation or an error message.
-
-        Raises:
-            ValueError: If the 'url' keyword argument is not specified or is invalid.
-        """
         url = kwargs.get('url')
         if not url:
             raise ValueError("The 'url' keyword argument must be specified.")
@@ -59,4 +51,4 @@ class NavigateTo(BaseTool, UIIntegrator):
             result = urlparse(url)
             return all([result.scheme, result.netloc])
         except ValueError:
-            return False
+            return False

autobyteus/tools/browser/standalone/webpage_image_downloader.py

@@ -11,11 +11,15 @@ class WebPageImageDownloader(BaseTool, UIIntegrator):
         BaseTool.__init__(self)
         UIIntegrator.__init__(self)
 
-    def tool_usage(self):
-        return "WebPageImageDownloader: Downloads images (excluding SVGs) from a given webpage and saves them to the specified directory. Usage: <<<WebPageImageDownloader(url='webpage_url', save_dir='path/to/save/directory')>>>, where 'webpage_url' is a string containing the URL of the webpage to download images from, and 'path/to/save/directory' is the directory where the images will be saved."
+    @classmethod
+    def tool_usage_xml(cls):
+        """
+        Return an XML string describing the usage of the WebPageImageDownloader tool.
 
-    def tool_usage_xml(self):
-            return '''
+        Returns:
+            str: An XML description of how to use the WebPageImageDownloader tool.
+        """
+        return '''
     WebPageImageDownloader: Downloads images (excluding SVGs) from a given webpage and saves them to the specified directory. Usage:
     <command name="WebPageImageDownloader">
     <arg name="url">webpage_url</arg>
@@ -25,18 +29,6 @@ class WebPageImageDownloader(BaseTool, UIIntegrator):
     '''
 
     async def _execute(self, **kwargs):
-        """
-        Download images (excluding SVGs) from the webpage at the given URL using Playwright and save them to the specified directory.
-
-        Args:
-            **kwargs: Keyword arguments containing the URL and save directory. The URL should be specified as 'url', and the directory as 'save_dir'.
-
-        Returns:
-            list: The file paths of the saved images.
-
-        Raises:
-            ValueError: If the 'url' or 'save_dir' keyword arguments are not specified.
-        """
         url = kwargs.get('url')
         save_dir = kwargs.get('save_dir')
         if not url:
@@ -62,67 +54,24 @@ class WebPageImageDownloader(BaseTool, UIIntegrator):
         return saved_paths
 
     async def _get_image_urls(self):
-        """
-        Get the URLs of all images on the current page.
-
-        Returns:
-            list: A list of image URLs.
-        """
         image_urls = await self.page.evaluate("""() => {
             return Array.from(document.images).map(i => i.src);
         }""")
         return image_urls
     
     def _resolve_url(self, base_url, url):
-        """
-        Resolve a URL against a base URL to get the absolute URL.
-
-        Args:
-            base_url (str): The base URL.
-            url (str): The URL to resolve.
-
-        Returns:
-            str: The absolute URL.
-        """
         return urljoin(base_url, url)
 
     def _is_svg(self, url):
-        """
-        Check if a URL points to an SVG image.
-
-        Args:
-            url (str): The URL to check.
-
-        Returns:
-            bool: True if the URL points to an SVG, False otherwise.
-        """
         return url.lower().endswith('.svg')
 
     def _generate_file_path(self, directory, index, url):
-        """
-        Generate a unique file path for an image.
-
-        Args:
-            directory (str): The directory to save the image in.
-            index (int): A unique index for this image.
-            url (str): The URL of the image (used to get the file extension).
-
-        Returns:
-            str: The generated file path.
-        """
         ext = os.path.splitext(url)[1]
         filename = f"image_{index}{ext}"
         return os.path.join(directory, filename)
 
     async def _download_and_save_image(self, url, file_path):
-        """
-        Download an image from a URL and save it to a file.
-
-        Args:
-            url (str): The URL of the image to download.
-            file_path (str): The path to save the image to.
-        """
         await self.page.goto(url)
         image_buffer = await self.page.screenshot(full_page=True)
         with open(file_path, "wb") as f:
-            f.write(image_buffer)
+            f.write(image_buffer)

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -6,9 +6,6 @@ This module provides a WebPageReader tool for reading and cleaning HTML content
 The WebPageReader class allows users to retrieve and clean the HTML content of a specified webpage
 using Playwright. It inherits from BaseTool and UIIntegrator, providing a seamless integration
 with web browsers.
-
-Classes:
-    WebPageReader: A tool for reading and cleaning HTML content from webpages.
 """
 
 from autobyteus.tools.base_tool import BaseTool
@@ -39,16 +36,21 @@ class WebPageReader(BaseTool, UIIntegrator):
         UIIntegrator.__init__(self)
         self.cleaning_mode = cleaning_mode
 
-    def tool_usage(self):
-        return 'WebPageReader: Reads and cleans the HTML content from a given webpage. Usage: <<<WebPageReader(url="webpage_url")>>>, where "webpage_url" is a string containing the URL of the webpage to read the content from.'
+    @classmethod
+    def tool_usage_xml(cls):
+        """
+        Return an XML string describing the usage of the WebPageReader tool.
 
-    def tool_usage_xml(self):
+        Returns:
+            str: An XML description of how to use the WebPageReader tool.
+        """
         return '''WebPageReader: Reads the HTML content from a given webpage. Usage:
 <command name="WebPageReader">
   <arg name="url">webpage_url</arg>
 </command>
 where "webpage_url" is a string containing the URL of the webpage to read the content from.
 '''
+
     async def _execute(self, **kwargs):
         """
         Read and clean the HTML content from the webpage at the given URL using Playwright.

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -1,7 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from brui_core.ui_integrator import UIIntegrator
 
-
 class WebPageScreenshotTaker(BaseTool, UIIntegrator):
     """
     A class that takes a screenshot of a given webpage using Playwright.
@@ -10,11 +9,15 @@ class WebPageScreenshotTaker(BaseTool, UIIntegrator):
         BaseTool.__init__(self)
         UIIntegrator.__init__(self)
 
-    def tool_usage(self):
-        return "WebPageScreenshotTaker: Takes a screenshot of a given webpage and saves it to the specified file path. Usage: <<<WebPageScreenshotTaker(url='webpage_url', file_path='screenshot_file_path')>>>, where 'webpage_url' is a string containing the URL of the webpage to take a screenshot of, and 'screenshot_file_path' is the path where the screenshot will be saved."
+    @classmethod
+    def tool_usage_xml(cls):
+        """
+        Return an XML string describing the usage of the WebPageScreenshotTaker tool.
 
-    def tool_usage_xml(self):
-            return '''WebPageScreenshotTaker: Takes a screenshot of a given webpage and saves it to the specified file path. Usage:
+        Returns:
+            str: An XML description of how to use the WebPageScreenshotTaker tool.
+        """
+        return '''WebPageScreenshotTaker: Takes a screenshot of a given webpage and saves it to the specified file path. Usage:
     <command name="WebPageScreenshotTaker">
     <arg name="url">webpage_url</arg>
     <arg name="file_path">screenshot_file_path</arg>
@@ -46,4 +49,4 @@ class WebPageScreenshotTaker(BaseTool, UIIntegrator):
         await self.page.goto(url)
         await self.page.screenshot(path=file_path, full_page=True)
         await self.close()
-        return file_path
+        return file_path

autobyteus/tools/factory/tool_factory.py

@@ -1,8 +1,10 @@
 # file: autobyteus/tools/factory/tool_factory.py
 from abc import ABC, abstractmethod
-from autobyteus.tools.base_tool import BaseTool
+from typing import TYPE_CHECKING
 
-class ToolFactory(ABC):
-    @abstractmethod
-    def create_tool(self) -> BaseTool:
-        pass
+if TYPE_CHECKING:
+    from autobyteus.tools.base_tool import BaseTool
+
+class ToolFactory():
+    def create_tool(self) -> "BaseTool":
+        pass

autobyteus/tools/file/file_reader.py

@@ -15,15 +15,13 @@ class FileReader(BaseTool):
     it will raise a FileNotFoundError.
     """
 
-    def tool_usage(self):
-        """
-        Return a string describing the usage of the FileReader tool.
-        """
-        return 'FileReader: Reads content from a specified file. Usage: <<<FileReader(path="file_path")>>>, where "file_path" is the path to the file to be read.'
-
-    def tool_usage_xml(self):
+    @classmethod
+    def tool_usage_xml(cls):
         """
         Return an XML string describing the usage of the FileReader tool.
+
+        Returns:
+            str: An XML description of how to use the FileReader tool.
         """
         return '''FileReader: Reads content from a specified file. Usage:
     <command name="FileReader">
@@ -57,4 +55,4 @@ class FileReader(BaseTool):
 
         with open(path, 'r') as file:
             content = file.read()
-        return content
+        return content

autobyteus/tools/file/file_writer.py

@@ -14,15 +14,13 @@ class FileWriter(BaseTool):
     it will create the necessary directories.
     """
 
-    def tool_usage(self):
-        """
-        Return a string describing the usage of the FileWriter tool.
-        """
-        return 'FileWriter: Creates a file with specified content. Usage: <<<FileWriter(path="file_path", content="file_content")>>>, where "file_path" is the path to create the file and "file_content" is the content to write to the file.'
-
-    def tool_usage_xml(self):
+    @classmethod
+    def tool_usage_xml(cls):
         """
         Return an XML string describing the usage of the FileWriter tool.
+
+        Returns:
+            str: An XML description of how to use the FileWriter tool.
         """
         return '''FileWriter: Creates a file with specified content. Usage:
     <command name="FileWriter">
@@ -56,10 +54,9 @@ class FileWriter(BaseTool):
         if content is None:
             raise ValueError("The 'content' keyword argument must be specified.")
 
-        # Ensure the directory exists
         os.makedirs(os.path.dirname(path), exist_ok=True)
 
         with open(path, 'w') as file:
             file.write(content)
 
-        return f"File created at {path}"
+        return f"File created at {path}"

autobyteus/tools/image_downloader.py

@@ -14,37 +14,24 @@ from autobyteus.events.decorators import event_listener
 logger = logging.getLogger(__name__)
 
 class ImageDownloader(BaseTool):
+    # Define supported_formats as a class variable so it can be accessed in class methods
+    supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
+    
     def __init__(self, custom_download_folder=None):
         super().__init__()
         self.default_download_folder = get_default_download_folder()
         self.download_folder = custom_download_folder or self.default_download_folder
-        self.supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
+        self.supported_formats = self.__class__.supported_formats  # Set instance attribute from class variable for backward compatibility
         self.last_downloaded_image = None
 
-    def tool_usage(self):
-        return f'''ImageDownloader: Downloads an image from a given URL.
-
-Usage: <<<ImageDownloader(url="image_url")>>>
-
-Parameters:
-- "image_url": A string containing a direct URL to an image file (must end with {', '.join(self.supported_formats)})
-
-Supported image formats: {', '.join(format.upper()[1:] for format in self.supported_formats)}
-
-Positive examples:
-- https://example.com/image.jpg
-- https://example.com/photo.png
-- https://example.com/animation.gif
-- https://example.com/picture.webp
-
-Negative examples (These will not work):
-- https://example.com/page_containing_image.html
-- https://example.com/image_without_extension
-- https://example.com/document.pdf
-
-Note: The URL must be a direct link to the image file, not a webpage containing the image.'''
+    @classmethod
+    def tool_usage_xml(cls):
+        """
+        Return an XML string describing the usage of the ImageDownloader tool.
 
-    def tool_usage_xml(self):
+        Returns:
+            str: An XML description of how to use the ImageDownloader tool.
+        """
         return f'''ImageDownloader: Downloads an image from a given URL.
 
 Usage:
@@ -53,9 +40,9 @@ Usage:
 </command>
 
 Parameters:
-- "image_url": A string containing a direct URL to an image file (must end with {', '.join(self.supported_formats)})
+- "image_url": A string containing a direct URL to an image file (must end with {', '.join(cls.supported_formats)})
 
-Supported image formats: {', '.join(format.upper()[1:] for format in self.supported_formats)}
+Supported image formats: {', '.join(format.upper()[1:] for format in cls.supported_formats)}
 
 Positive examples:
 <command name="ImageDownloader">
@@ -76,11 +63,7 @@ Negative examples (These will not work):
 </command>
 
 Note: The URL must be a direct link to the image file, not a webpage containing the image.'''
-
     async def _execute(self, **kwargs):
-        """
-        Download the image from the given URL.
-        """
         url = kwargs.get('url')
         if not url:
             raise ValueError("The 'url' keyword argument must be specified.")
@@ -88,13 +71,10 @@ Note: The URL must be a direct link to the image file, not a webpage containing
         custom_folder = kwargs.get('folder')
         download_folder = custom_folder or self.download_folder
 
-        # Check if the URL ends with a supported format
-        if not any(url.lower().endswith(format) for format in self.supported_formats):
+        if not any(url.lower().endswith(fmt) for fmt in self.supported_formats):
             raise ValueError(
                 f"Unsupported image format. The URL must end with one of the following extensions: "
-                f"{', '.join(self.supported_formats)}. \n"
-                f"Provided URL: {url}\n"
-                f"Please ensure you're providing a direct link to an image file, not a webpage containing the image."
+                f"{', '.join(self.supported_formats)}. Provided URL: {url}"
             )
 
         try:
@@ -103,18 +83,15 @@ Note: The URL must be a direct link to the image file, not a webpage containing
                     response.raise_for_status()
                     image_bytes = await response.read()
 
-            # Open the image for verification
             with Image.open(BytesIO(image_bytes)) as img:
-                img.verify()  # Verify the image integrity
-                format = img.format
+                img.verify()
+                fmt = img.format
 
-            # Generate a unique filename based on the current timestamp
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             extension = os.path.splitext(url)[1].lower()
             filename = f"downloaded_image_{timestamp}{extension}"
             filepath = os.path.join(download_folder, filename)
 
-            # Save the image to a file
             os.makedirs(download_folder, exist_ok=True)
             with open(filepath, 'wb') as f:
                 f.write(image_bytes)
@@ -139,4 +116,4 @@ Note: The URL must be a direct link to the image file, not a webpage containing
                 logger.error(f"Failed to remove downloaded image: {self.last_downloaded_image}. Error: {str(e)}")
         else:
             logger.warning("No image to remove or image file not found.")
-        self.last_downloaded_image = None
+        self.last_downloaded_image = None

autobyteus/tools/pdf_downloader.py

@@ -18,13 +18,14 @@ class PDFDownloader(BaseTool):
         self.default_download_folder = get_default_download_folder()
         self.download_folder = custom_download_folder or self.default_download_folder
 
-    def tool_usage(self):
+    @classmethod
+    def tool_usage_xml(cls):
         """
-        Return a string describing the usage of the PDFDownloader tool.
-        """
-        return 'PDFDownloader: Downloads a PDF file from a given URL. Usage: <<<PDFDownloader(url="https://example.com/file.pdf")>>>'
+        Return an XML string describing the usage of the PDFDownloader tool.
 
-    def tool_usage_xml(self):
+        Returns:
+            str: An XML description of how to use the PDFDownloader tool.
+        """
         return '''PDFDownloader: Downloads a PDF file from a given URL. Usage:
     <command name="PDFDownloader">
     <arg name="url">https://example.com/file.pdf</arg>
@@ -57,29 +58,23 @@ class PDFDownloader(BaseTool):
 
         try:
             response = requests.get(url, stream=True)
-            response.raise_for_status()  # Raises an HTTPError for bad responses
+            response.raise_for_status()
 
-            # Check if the content type is PDF
             content_type = response.headers.get('Content-Type', '').lower()
             if 'application/pdf' not in content_type:
                 raise ValueError(f"The URL does not point to a PDF file. Content-Type: {content_type}")
 
-            # Generate a unique filename based on the current timestamp
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             filename = f"downloaded_pdf_{timestamp}.pdf"
             save_path = os.path.join(download_folder, filename)
 
-            # Ensure the directory exists
             os.makedirs(download_folder, exist_ok=True)
-
-            # Save the PDF file
             with open(save_path, 'wb') as file:
                 for chunk in response.iter_content(chunk_size=8192):
                     file.write(chunk)
 
             self.logger.info(f"PDF successfully downloaded and saved to {save_path}")
             return f"PDF successfully downloaded and saved to {save_path}"
-
         except requests.exceptions.RequestException as e:
             error_message = f"Error downloading PDF: {str(e)}"
             self.logger.error(error_message)
@@ -91,4 +86,4 @@ class PDFDownloader(BaseTool):
         except IOError as e:
             error_message = f"Error saving PDF: {str(e)}"
             self.logger.error(error_message)
-            return error_message
+            return error_message

autobyteus/tools/registry/__init__.py

@@ -0,0 +1,11 @@
+# file: autobyteus/autobyteus/tools/registry/__init__.py
+from .tool_definition import ToolDefinition
+from .tool_registry import ToolRegistry, default_tool_registry
+from autobyteus.tools.factory.tool_factory import ToolFactory
+
+__all__ = [
+    "ToolDefinition",
+    "ToolRegistry",
+    "default_tool_registry",
+    "ToolFactory"
+]

autobyteus/tools/registry/tool_definition.py

@@ -0,0 +1,60 @@
+# file: autobyteus/tools/registry/tool_definition.py
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class ToolDefinition:
+    """
+    Represents the simplified static definition of a tool, containing
+    only its name and usage description string.
+    """
+    def __init__(self,
+                 name: str,
+                 description: str):
+        """
+        Initializes the ToolDefinition.
+
+        Args:
+            name: The unique name/identifier of the tool.
+            description: The static usage description string for the tool (e.g., XML usage format).
+
+        Raises:
+            ValueError: If name or description are empty or invalid.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("ToolDefinition requires a non-empty string 'name'.")
+        if not description or not isinstance(description, str):
+            raise ValueError(f"ToolDefinition '{name}' requires a non-empty string 'description'.")
+
+        self._name = name
+        self._description = description
+
+        logger.debug(f"ToolDefinition created for tool '{self.name}'.")
+
+    @property
+    def name(self) -> str:
+        """The unique name/identifier of the tool."""
+        return self._name
+
+    @property
+    def description(self) -> str:
+        """The static usage description string for the tool."""
+        return self._description
+
+    def __repr__(self) -> str:
+        """Provides a developer-friendly string representation."""
+        desc_repr = self.description
+        if len(desc_repr) > 70:
+             desc_repr = desc_repr[:67] + "..."
+        # Remove newlines/tabs from repr for cleaner logging if description is multiline XML
+        desc_repr = desc_repr.replace('\n', '\\n').replace('\t', '\\t')
+        return (f"ToolDefinition(name='{self.name}', description='{desc_repr}')")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Returns a dictionary representation of the tool definition."""
+        return {
+            "name": self.name,
+            "description": self.description,
+        }
+

autobyteus/tools/registry/tool_registry.py

@@ -0,0 +1,106 @@
+# file: autobyteus/autobyteus/tools/registry/tool_registry.py
+import logging
+from typing import Dict, List, Optional
+
+from autobyteus.tools.registry.tool_definition import ToolDefinition
+from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.tools.factory.tool_factory import ToolFactory
+
+
+logger = logging.getLogger(__name__)
+
+class ToolRegistry(metaclass=SingletonMeta):
+    """
+    Manages ToolDefinitions (name, description, tool_class), populated exclusively via
+    programmatic registration. Uses ToolFactory to create tool instances.
+    """
+    _definitions: Dict[str, ToolDefinition] = {}
+
+    def __init__(self, tool_factory: ToolFactory):
+        """
+        Initializes the ToolRegistry with a ToolFactory.
+
+        Args:
+            tool_factory: The ToolFactory instance used to create tool instances.
+        """
+        self.tool_factory = tool_factory
+        logger.info("ToolRegistry initialized with ToolFactory.")
+
+    def register_tool(self, definition: ToolDefinition):
+        """
+        Registers a tool definition (name, description, tool_class) programmatically.
+
+        Args:
+            definition: The ToolDefinition object to register.
+
+        Raises:
+            ValueError: If the definition is invalid. Overwrites existing definitions with the same name.
+        """
+        if not isinstance(definition, ToolDefinition):
+            raise ValueError("Attempted to register an object that is not a ToolDefinition.")
+
+        tool_name = definition.name
+        if tool_name in self._definitions:
+            logger.warning(f"Overwriting existing tool definition for name: '{tool_name}'")
+        ToolRegistry._definitions[tool_name] = definition
+        logger.info(f"Successfully registered tool definition: '{tool_name}'")
+
+    def get_tool_definition(self, name: str) -> Optional[ToolDefinition]:
+        """
+        Retrieves the definition for a specific tool name.
+
+        Args:
+            name: The unique name of the tool definition to retrieve.
+
+        Returns:
+            The ToolDefinition object (name, description, tool_class) if found, otherwise None.
+        """
+        definition = self._definitions.get(name)
+        if not definition:
+            logger.debug(f"Tool definition not found for name: '{name}'")
+        return definition
+
+    def create_tool(self, name: str):
+        """
+        Creates a tool instance using the ToolFactory based on the tool definition.
+
+        Args:
+            name: The name of the tool to create.
+
+        Returns:
+            The tool instance if the definition exists, otherwise None.
+
+        Raises:
+            ValueError: If the tool definition is not found.
+        """
+        definition = self.get_tool_definition(name)
+        if not definition:
+            logger.error(f"Cannot create tool: No definition found for name '{name}'")
+            raise ValueError(f"No tool definition found for name '{name}'")
+        
+        logger.info(f"Creating tool instance for '{name}' using ToolFactory")
+        return self.tool_factory.create_tool(name)
+
+    def list_tools(self) -> List[ToolDefinition]:
+        """
+        Returns a list of all registered tool definitions.
+
+        Returns:
+            A list of ToolDefinition objects (name, description, tool_class).
+        """
+        return list(self._definitions.values())
+
+    def list_tool_names(self) -> List[str]:
+        """
+        Returns a list of the names of all registered tools.
+
+        Returns:
+            A list of tool name strings.
+        """
+        return list(self._definitions.keys())
+
+    def get_all_definitions(self) -> Dict[str, ToolDefinition]:
+        """Returns the internal dictionary of definitions."""
+        return dict(ToolRegistry._definitions)
+
+default_tool_registry = ToolRegistry(tool_factory=ToolFactory())