autobyteus 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/tools/browser/standalone/navigate_to.py

@@ -1,84 +0,0 @@
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-from brui_core.ui_integrator import UIIntegrator
-from urllib.parse import urlparse
-from typing import Optional, TYPE_CHECKING, Any
-import logging
-
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-class NavigateTo(BaseTool, UIIntegrator):
-    """
-    A standalone tool for navigating to a specified website using Playwright.
-    It initializes and closes its own browser instance for each navigation.
-    """
-    CATEGORY = ToolCategory.WEB
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        BaseTool.__init__(self, config=config)
-        UIIntegrator.__init__(self)
-        logger.debug("navigate_to (standalone) tool initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "navigate_to"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Navigates a standalone browser instance to a specified URL. Returns a success or failure message."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url",
-            param_type=ParameterType.STRING,
-            description="The fully qualified URL of the website to navigate to (e.g., 'https://example.com').",
-            required=True
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str) -> str:
-        logger.info(f"navigate_to (standalone) for agent {context.agent_id} navigating to: {url}")
-
-        if not self._is_valid_url(url):
-            error_msg = f"Invalid URL format: {url}. Must include scheme (e.g., http, https) and netloc."
-            logger.warning(f"navigate_to (standalone) validation error for agent {context.agent_id}: {error_msg}")
-            raise ValueError(error_msg)
-
-        try:
-            await self.initialize()
-            if not self.page:
-                 logger.error("Playwright page not initialized in navigate_to (standalone).")
-                 raise RuntimeError("Playwright page not available for navigate_to.")
-
-            response = await self.page.goto(url, wait_until="domcontentloaded", timeout=60000) 
-            
-            if response and response.ok:
-                success_msg = f"Successfully navigated to {url}"
-                logger.info(f"navigate_to (standalone) for agent {context.agent_id}: {success_msg}")
-                return success_msg
-            else:
-                status = response.status if response else "Unknown"
-                failure_msg = f"Navigation to {url} failed with status {status}"
-                logger.warning(f"navigate_to (standalone) for agent {context.agent_id}: {failure_msg}")
-                return failure_msg
-        except Exception as e:
-            logger.error(f"Error during navigate_to (standalone) for URL '{url}', agent {context.agent_id}: {e}", exc_info=True)
-            raise RuntimeError(f"navigate_to (standalone) failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()
-
-    @staticmethod
-    def _is_valid_url(url_string: str) -> bool:
-        try:
-            result = urlparse(url_string)
-            return all([result.scheme, result.netloc])
-        except ValueError:
-            return False

autobyteus/tools/browser/standalone/web_page_pdf_generator.py

@@ -1,101 +0,0 @@
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-from brui_core.ui_integrator import UIIntegrator
-import os
-import logging
-from typing import Optional, TYPE_CHECKING, Any 
-from urllib.parse import urlparse 
-
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-class WebPagePDFGenerator(BaseTool, UIIntegrator):
-    """
-    A class that generates a PDF of a given webpage URL using Playwright.
-    Saves the PDF to a specified directory. This is a standalone browser tool.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None): 
-        BaseTool.__init__(self, config=config)
-        UIIntegrator.__init__(self)
-        logger.debug("generate_webpage_pdf (standalone) tool initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "generate_webpage_pdf"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return ("Generates a PDF (A4 format) of a given webpage URL. "
-                "Saves it to a specified local directory and returns the absolute file path of the saved PDF.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url",
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage to generate a PDF from.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="save_dir", 
-            param_type=ParameterType.STRING,
-            description="The local directory path where the generated PDF will be saved. A filename will be auto-generated.",
-            required=True
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, save_dir: str) -> str: 
-        logger.info(f"generate_webpage_pdf for agent {context.agent_id} generating PDF for '{url}', saving to directory '{save_dir}'.")
-
-        if not self._is_valid_page_url(url):
-            raise ValueError(f"Invalid page URL format: {url}. Must be a full URL (e.g., http/https).")
-
-        os.makedirs(save_dir, exist_ok=True) 
-
-        try:
-            parsed_url = urlparse(url)
-            domain_part = parsed_url.netloc.replace('.', '_')
-            path_part = parsed_url.path.strip('/').replace('/', '_').replace('.', '_')
-            safe_url_part = f"{domain_part}_{path_part}"[:50] 
-            if not safe_url_part: safe_url_part = "webpage"
-        except Exception:
-            safe_url_part = "webpage"
-        
-        import time
-        timestamp = int(time.time())
-        pdf_filename = f"{safe_url_part}_{timestamp}.pdf"
-        full_file_path = os.path.join(save_dir, pdf_filename)
-
-        try:
-            await self.initialize()
-            if not self.page:
-                 logger.error("Playwright page not initialized in generate_webpage_pdf.")
-                 raise RuntimeError("Playwright page not available for generate_webpage_pdf.")
-
-            await self.page.goto(url, wait_until="networkidle", timeout=60000)
-            
-            await self.page.pdf(path=full_file_path, format='A4', print_background=True) 
-            
-            absolute_file_path = os.path.abspath(full_file_path)
-            logger.info(f"PDF generated and saved successfully to {absolute_file_path}")
-            return absolute_file_path
-        except Exception as e:
-            logger.error(f"Error generating PDF for URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"generate_webpage_pdf failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close() 
-
-    def _is_valid_page_url(self, url_string: str) -> bool: 
-        try:
-            result = urlparse(url_string)
-            return all([result.scheme in ['http', 'https'], result.netloc])
-        except ValueError:
-            return False

autobyteus/tools/browser/standalone/webpage_image_downloader.py

@@ -1,169 +0,0 @@
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-from brui_core.ui_integrator import UIIntegrator
-import os
-import logging 
-from urllib.parse import urljoin, urlparse 
-from typing import Optional, TYPE_CHECKING, Any, List 
-
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__) 
-
-class WebPageImageDownloader(BaseTool, UIIntegrator):
-    """
-    A class that downloads images (excluding SVGs and data URIs) from a given webpage URL using Playwright.
-    Saves images to a specified directory.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None): 
-        BaseTool.__init__(self, config=config)
-        UIIntegrator.__init__(self)
-        logger.debug("download_webpage_images tool initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "download_webpage_images"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return ("Downloads all usable images (excluding SVGs and data URIs) from a webpage URL. "
-                "Saves them to a specified local directory and returns a list of saved file paths.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url",
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage from which to download images.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="save_dir",
-            param_type=ParameterType.STRING,
-            description="The local directory path where downloaded images will be saved.",
-            required=True
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, save_dir: str) -> List[str]: 
-        logger.info(f"download_webpage_images for agent {context.agent_id} downloading images from '{url}' to '{save_dir}'.")
-        
-        if not self._is_valid_page_url(url):
-            raise ValueError(f"Invalid page URL format: {url}. Must be a full URL (e.g., http/https).")
-
-        os.makedirs(save_dir, exist_ok=True)
-
-        saved_paths: List[str] = []
-        try:
-            await self.initialize()
-            if not self.page:
-                 logger.error("Playwright page not initialized in download_webpage_images.")
-                 raise RuntimeError("Playwright page not available for download_webpage_images.")
-
-            await self.page.goto(url, wait_until="networkidle", timeout=60000)
-            
-            image_srcs: List[str] = await self._get_image_srcs_from_page()
-            logger.debug(f"Found {len(image_srcs)} image sources on page {url}.")
-            
-            download_counter = 0
-            for i, img_src in enumerate(image_srcs):
-                if not img_src or img_src.startswith("data:"): 
-                    logger.debug(f"Skipping image source (data URI or empty): {img_src[:50]}...")
-                    continue
-
-                full_image_url = urljoin(self.page.url, img_src) 
-
-                if self._is_svg(full_image_url):
-                    logger.debug(f"Skipping SVG image: {full_image_url}")
-                    continue
-                
-                if not self._is_valid_http_url(full_image_url):
-                    logger.warning(f"Skipping invalid or non-HTTP(S) image URL: {full_image_url}")
-                    continue
-
-                file_path = self._generate_file_path(save_dir, download_counter, full_image_url)
-                try:
-                    image_response = await self.page.request.get(full_image_url)
-                    if image_response.ok:
-                        image_buffer = await image_response.body()
-                        with open(file_path, "wb") as f:
-                            f.write(image_buffer)
-                        saved_paths.append(os.path.abspath(file_path))
-                        logger.info(f"Downloaded image {download_counter + 1}: {full_image_url} to {file_path}")
-                        download_counter += 1
-                    else:
-                        logger.warning(f"Failed to download image {full_image_url}, status: {image_response.status}")
-
-                except Exception as dl_exc:
-                    logger.error(f"Error downloading image {full_image_url}: {dl_exc}", exc_info=True)
-            
-            logger.info(f"Finished downloading images. Total saved: {len(saved_paths)}.")
-            return saved_paths
-
-        except Exception as e:
-            logger.error(f"Error in download_webpage_images for URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"download_webpage_images failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()
-
-    async def _get_image_srcs_from_page(self) -> List[str]:
-        image_elements_data = await self.page.evaluate("""() => {
-            const sources = new Set();
-            document.querySelectorAll('img').forEach(img => {
-                if (img.src && !img.src.startsWith('data:')) sources.add(img.src);
-                if (img.srcset) {
-                    img.srcset.split(',').forEach(part => {
-                        const url = part.trim().split(' ')[0];
-                        if (url && !url.startsWith('data:')) sources.add(url);
-                    });
-                }
-                const dataSrc = img.getAttribute('data-src');
-                if (dataSrc && !dataSrc.startsWith('data:')) sources.add(dataSrc);
-            });
-            return Array.from(sources);
-        }""")
-        return image_elements_data if image_elements_data else []
-    
-    def _is_valid_page_url(self, url_string: str) -> bool:
-        try:
-            result = urlparse(url_string)
-            return all([result.scheme in ['http', 'https'], result.netloc])
-        except ValueError:
-            return False
-            
-    def _is_valid_http_url(self, url_string: str) -> bool:
-        try:
-            result = urlparse(url_string)
-            return result.scheme in ['http', 'https']
-        except ValueError:
-            return False
-
-    def _is_svg(self, url: str) -> bool:
-        return url.lower().split('?')[0].endswith('.svg') 
-
-    def _generate_file_path(self, directory: str, index: int, url: str) -> str:
-        try:
-            parsed_url = urlparse(url)
-            base_filename = os.path.basename(parsed_url.path)
-            filename_stem, ext = os.path.splitext(base_filename)
-            if not ext: 
-                ext = ".jpg" 
-            
-            import string
-            valid_chars_fs = "-_.() %s%s" % (string.ascii_letters, string.digits)
-            safe_stem = ''.join(c for c in filename_stem if c in valid_chars_fs)[:50] 
-            if not safe_stem: safe_stem = f"image_{index}"
-
-            final_filename = f"{safe_stem}{ext}"
-
-        except Exception: 
-            final_filename = f"image_{index}.jpg" 
-            
-        return os.path.join(directory, final_filename)

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -1,105 +0,0 @@
-"""
-File: autobyteus/tools/browser/standalone/webpage_reader.py
-This module provides a read_webpage tool for reading and cleaning HTML content from webpages.
-"""
-
-import logging
-from typing import Optional, TYPE_CHECKING, Any
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig 
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from brui_core.ui_integrator import UIIntegrator 
-from autobyteus.utils.html_cleaner import clean, CleaningMode
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-class WebPageReader(BaseTool, UIIntegrator):
-    """
-    A class that reads and cleans the HTML content from a given webpage using Playwright.
-    """
-    CATEGORY = ToolCategory.WEB
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        BaseTool.__init__(self, config=config)
-        UIIntegrator.__init__(self) 
-        
-        cleaning_mode_to_use = CleaningMode.THOROUGH
-        if config:
-            cleaning_mode_value = config.get('cleaning_mode') 
-            if cleaning_mode_value:
-                if isinstance(cleaning_mode_value, str):
-                    try:
-                        cleaning_mode_to_use = CleaningMode(cleaning_mode_value.upper())
-                    except ValueError:
-                        logger.warning(f"Invalid cleaning_mode string '{cleaning_mode_value}' in config for read_webpage. Using THOROUGH.")
-                        cleaning_mode_to_use = CleaningMode.THOROUGH
-                elif isinstance(cleaning_mode_value, CleaningMode):
-                    cleaning_mode_to_use = cleaning_mode_value
-                else:
-                     logger.warning(f"Invalid type for cleaning_mode in config for read_webpage. Using THOROUGH.")
-        
-        self.cleaning_mode = cleaning_mode_to_use
-        logger.debug(f"read_webpage initialized with cleaning_mode: {self.cleaning_mode}")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "read_webpage"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Reads and cleans the HTML content from a given webpage URL using Playwright."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        """Schema for arguments passed to the execute method."""
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url", 
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage to read content from.",
-            required=True
-        ))
-        return schema
-        
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]:
-        """Schema for parameters to configure the read_webpage instance itself."""
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="cleaning_mode",
-            param_type=ParameterType.ENUM,
-            description="Level of HTML content cleanup for webpage content. BASIC or THOROUGH.",
-            required=False,
-            default_value="THOROUGH",
-            enum_values=[mode.name for mode in CleaningMode]
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str) -> str:
-        logger.info(f"read_webpage executing for agent {context.agent_id} with URL: '{url}'")
-
-        try:
-            await self.initialize()
-            if not self.page:
-                 logger.error("Playwright page not initialized in read_webpage.")
-                 raise RuntimeError("Playwright page not available for read_webpage.")
-
-            await self.page.goto(url, timeout=60000, wait_until="domcontentloaded")
-            page_content = await self.page.content()
-            
-            cleaned_content = clean(page_content, mode=self.cleaning_mode)
-            
-            return f'''here is the html of the web page
-<WebPageContentStart>
-{cleaned_content}
-</WebPageContentEnd>
-'''
-        except Exception as e:
-            logger.error(f"Error reading webpage at URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"read_webpage failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -1,105 +0,0 @@
-from typing import Optional, TYPE_CHECKING, Any
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from brui_core.ui_integrator import UIIntegrator 
-import logging 
-import os 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__) 
-
-class WebPageScreenshotTaker(BaseTool, UIIntegrator):
-    """
-    A class that takes a screenshot of a given webpage using Playwright and saves it.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None):
-        BaseTool.__init__(self, config=config)
-        UIIntegrator.__init__(self) 
-        
-        self.full_page: bool = True  
-        self.image_format: str = "png"  
-        
-        if config:
-            self.full_page = config.get('full_page', True)
-            self.image_format = str(config.get('image_format', 'png')).lower()
-            if self.image_format not in ["png", "jpeg"]:
-                logger.warning(f"Invalid image_format '{self.image_format}' in config. Defaulting to 'png'.")
-                self.image_format = "png"
-        logger.debug(f"take_webpage_screenshot initialized. Full page: {self.full_page}, Format: {self.image_format}")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "take_webpage_screenshot"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Takes a screenshot of a given webpage URL using Playwright and saves it to the specified file path. Returns the absolute path of the saved screenshot."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url",
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage to take a screenshot of.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="file_path", 
-            param_type=ParameterType.STRING,
-            description="The local file path (including filename and extension, e.g., 'screenshots/page.png') where the screenshot will be saved.",
-            required=True
-        ))
-        return schema
-        
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="full_page",
-            param_type=ParameterType.BOOLEAN,
-            description="Whether to capture the full scrollable page content or just the visible viewport by default for this instance.",
-            required=False,
-            default_value=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="image_format",
-            param_type=ParameterType.ENUM,
-            description="Default image format for screenshots taken by this instance (png or jpeg).",
-            required=False,
-            default_value="png",
-            enum_values=["png", "jpeg"]
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, file_path: str) -> str: 
-        logger.info(f"take_webpage_screenshot for agent {context.agent_id} taking screenshot of '{url}', saving to '{file_path}'.")
-        
-        output_dir = os.path.dirname(file_path)
-        if output_dir: 
-            os.makedirs(output_dir, exist_ok=True)
-
-        try:
-            await self.initialize() 
-            if not self.page:
-                 logger.error("Playwright page not initialized in take_webpage_screenshot.")
-                 raise RuntimeError("Playwright page not available for take_webpage_screenshot.")
-
-            await self.page.goto(url, wait_until="networkidle", timeout=60000) 
-            
-            await self.page.screenshot(path=file_path, full_page=self.full_page, type=self.image_format) # type: ignore 
-            
-            absolute_file_path = os.path.abspath(file_path)
-            logger.info(f"Screenshot saved successfully to {absolute_file_path}")
-            return absolute_file_path
-        except Exception as e:
-            logger.error(f"Error taking screenshot of URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"take_webpage_screenshot failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()