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

autobyteus/tools/browser/session_aware/browser_session_aware_navigate_to.py

@@ -1,75 +0,0 @@
-from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
-from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-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 BrowserSessionAwareNavigateTo(BrowserSessionAwareTool):
-    """
-    A session-aware tool for navigating to a specified website using a shared browser session.
-    """
-    CATEGORY = ToolCategory.WEB
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        logger.debug("navigate_to tool (session-aware) initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "navigate_to"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return ("Navigates the shared browser session to a specified URL. "
-                "Returns a success or failure message based on navigation status.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_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 perform_action(self, shared_session: SharedBrowserSession, webpage_url: str) -> str:
-        logger.info(f"navigate_to (session-aware) performing action for URL: {webpage_url}")
-
-        if not self._is_valid_url(webpage_url):
-            raise ValueError(f"Invalid URL format: {webpage_url}. Must include scheme and netloc.")
-
-        try:
-            response = await shared_session.page.goto(webpage_url, wait_until="networkidle", timeout=60000)
-            
-            if response and response.ok:
-                success_msg = f"The navigate_to command to {webpage_url} is executed successfully."
-                logger.info(success_msg)
-                return success_msg
-            else:
-                status = response.status if response else "Unknown"
-                failure_msg = f"The navigate_to command to {webpage_url} failed with status {status}."
-                logger.warning(failure_msg)
-                return failure_msg
-        except Exception as e:
-            logger.error(f"Error during shared session navigation to '{webpage_url}': {e}", exc_info=True)
-            return f"Error navigating to {webpage_url}: {str(e)}"
-
-
-    @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/session_aware/browser_session_aware_tool.py

@@ -1,30 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_tool.py
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.browser.session_aware.shared_browser_session_manager import SharedBrowserSessionManager
-from autobyteus.events.event_types import EventType
-from typing import Optional
-
-class BrowserSessionAwareTool(BaseTool):
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        self.shared_browser_session_manager = SharedBrowserSessionManager()
-
-    async def _execute(self, **kwargs):
-        shared_session = self.shared_browser_session_manager.get_shared_browser_session()
-        
-        if not shared_session:
-            webpage_url = kwargs.get('webpage_url')
-            if not webpage_url:
-                raise ValueError("The 'webpage_url' keyword argument must be specified when creating a new shared session.")
-            
-            await self.shared_browser_session_manager.create_shared_browser_session()
-            shared_session = self.shared_browser_session_manager.get_shared_browser_session()
-            await shared_session.page.goto(webpage_url)
-            self.emit(EventType.SHARED_BROWSER_SESSION_CREATED, shared_session=shared_session)
-        
-        return await self.perform_action(shared_session, **kwargs)
-
-    async def perform_action(self, shared_session, **kwargs):
-        raise NotImplementedError("Subclasses must implement this method")

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -1,154 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py
-
-import xml.etree.ElementTree as ET
-from typing import Optional, TYPE_CHECKING, Dict, Any
-import logging
-
-from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
-from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
-from autobyteus.tools.browser.session_aware.web_element_action import WebElementAction
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    pass
-
-logger = logging.getLogger(__name__)
-
-class BrowserSessionAwareWebElementTrigger(BrowserSessionAwareTool):
-    """
-    A session-aware tool to trigger actions on web elements identified by a CSS selector.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        logger.debug("trigger_web_element (session-aware) tool initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "trigger_web_element"
-
-    @classmethod
-    def get_description(cls) -> str:
-        action_names = ', '.join(str(action) for action in WebElementAction)
-        return (f"Triggers actions on web elements on the current page in a shared browser session. "
-                f"Supported actions: {action_names}. "
-                f"Returns a confirmation message upon successful execution.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url",
-            param_type=ParameterType.STRING,
-            description="URL of the webpage. Required if no browser session is active or to ensure context.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="css_selector",
-            param_type=ParameterType.STRING,
-            description="CSS selector to find the target web element.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="action",
-            param_type=ParameterType.ENUM,
-            description=f"Type of interaction to perform. Must be one of: {', '.join(str(act) for act in WebElementAction)}.",
-            required=True,
-            enum_values=[str(act) for act in WebElementAction]
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="params",
-            param_type=ParameterType.STRING,
-            description="Optional XML-formatted string containing additional parameters for specific actions (e.g., text for 'type', option for 'select'). Example: <param><name>text</name><value>Hello</value></param>",
-            required=False 
-        ))
-        return schema
-        
-    async def perform_action(
-        self, 
-        shared_session: SharedBrowserSession, 
-        css_selector: str, 
-        action: str,
-        webpage_url: str,
-        params: Optional[str] = ""
-    ) -> str:
-        logger.info(f"trigger_web_element performing action '{action}' on selector '{css_selector}' for page related to URL '{webpage_url}'. Params: '{params[:50]}...'")
-
-        try:
-            action_enum = WebElementAction.from_string(action)
-        except ValueError as e:
-            logger.error(f"Invalid action string '{action}' passed to perform_action despite schema validation: {e}")
-            raise
-
-        parsed_params = self._parse_xml_params(params if params else "")
-
-        element = shared_session.page.locator(css_selector)
-        
-        try:
-            await element.wait_for(state="visible", timeout=10000)
-        except Exception as e_wait:
-            error_msg = f"Element with selector '{css_selector}' not visible or found within timeout on page {shared_session.page.url}. Error: {e_wait}"
-            logger.warning(error_msg)
-            raise ValueError(error_msg) from e_wait
-
-        if action_enum == WebElementAction.CLICK:
-            await element.click()
-        elif action_enum == WebElementAction.TYPE:
-            text_to_type = parsed_params.get("text")
-            if text_to_type is None:
-                raise ValueError("'text' parameter is required for 'type' action.")
-            await element.fill("")
-            await element.type(text_to_type)
-        elif action_enum == WebElementAction.SELECT:
-            option_value = parsed_params.get("option")
-            if option_value is None:
-                raise ValueError("'option' parameter is required for 'select' action.")
-            await element.select_option(option_value)
-        elif action_enum == WebElementAction.CHECK:
-            state_str = parsed_params.get("state", "true")
-            is_checked_state = state_str.lower() == "true"
-            if is_checked_state:
-                await element.check()
-            else:
-                await element.uncheck()
-        elif action_enum == WebElementAction.SUBMIT:
-            logger.warning("WebElementAction.SUBMIT is interpreted as a click. Ensure CSS selector targets a submit button or form element intended for click-based submission.")
-            await element.click()
-        elif action_enum == WebElementAction.HOVER:
-            await element.hover()
-        elif action_enum == WebElementAction.DOUBLE_CLICK:
-            await element.dblclick()
-        else:
-            raise ValueError(f"Unsupported action: {action_enum}")
-
-        success_msg = f"The trigger_web_element action '{action_enum}' on selector '{css_selector}' was executed."
-        logger.info(success_msg)
-        return success_msg
-
-    def _parse_xml_params(self, params_xml_str: str) -> Dict[str, str]:
-        if not params_xml_str:
-            return {}
-        
-        try:
-            if not params_xml_str.strip().startswith("<root>"):
-                 xml_string_to_parse = f"<root>{params_xml_str}</root>"
-            else:
-                 xml_string_to_parse = params_xml_str
-                 
-            root = ET.fromstring(xml_string_to_parse)
-            parsed_params: Dict[str, str] = {}
-            for param_node in root.findall('param'):
-                name_elem = param_node.find('name')
-                value_elem = param_node.find('value')
-                if name_elem is not None and name_elem.text and value_elem is not None and value_elem.text is not None:
-                    parsed_params[name_elem.text] = value_elem.text
-                elif name_elem is not None and name_elem.text and value_elem is not None and value_elem.text is None:
-                     parsed_params[name_elem.text] = ""
-
-            return parsed_params
-        except ET.ParseError as e_parse:
-            logger.warning(f"Failed to parse params XML string: '{params_xml_str}'. Error: {e_parse}. Returning empty params.")
-            return {}

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py

@@ -1,89 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py
-
-import logging
-from typing import Optional, TYPE_CHECKING, Any
-from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
-from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
-from autobyteus.tools.tool_config import ToolConfig 
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.html_cleaner import clean, CleaningMode
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-class BrowserSessionAwareWebPageReader(BrowserSessionAwareTool):
-    """
-    A session-aware tool to read and clean HTML content from the current page
-    in a shared browser session.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None): 
-        super().__init__(config=config)
-        
-        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:
-                        cleaning_mode_to_use = CleaningMode.THOROUGH
-                elif isinstance(cleaning_mode_value, CleaningMode):
-                    cleaning_mode_to_use = cleaning_mode_value
-        
-        self.cleaning_mode = cleaning_mode_to_use
-        logger.debug(f"read_webpage (session-aware) tool 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 the current page in a shared browser session. "
-                "The level of HTML cleanup can be configured at tool instantiation.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url", 
-            param_type=ParameterType.STRING,
-            description="URL of the webpage. Required if no browser session is active or to ensure context. Tool reads current page content after navigation if applicable.",
-            required=True 
-        ))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="cleaning_mode",
-            param_type=ParameterType.ENUM,
-            description="Level of HTML content cleanup (BASIC or THOROUGH). Applied to the read webpage content.",
-            required=False,
-            default_value="THOROUGH",
-            enum_values=[mode.name for mode in CleaningMode]
-        ))
-        return schema
-
-    async def perform_action(
-        self, 
-        shared_session: SharedBrowserSession,
-        webpage_url: str 
-    ) -> str: 
-        logger.info(f"read_webpage (session-aware) performing action. Current page URL: {shared_session.page.url}, cleaning_mode: {self.cleaning_mode}")
-        
-        try:
-            page_content = await shared_session.page.content()
-            cleaned_content = clean(page_content, self.cleaning_mode)
-            logger.debug(f"Read and cleaned content from {shared_session.page.url}. Cleaned length: {len(cleaned_content)}")
-            return cleaned_content
-        except Exception as e:
-            logger.error(f"Error reading page content in shared session from {shared_session.page.url}: {e}", exc_info=True)
-            raise RuntimeError(f"Failed to read page content from shared session: {str(e)}")

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py

@@ -1,107 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py
-
-import os
-import logging 
-from typing import Optional, TYPE_CHECKING, Any
-from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
-from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
-from autobyteus.tools.tool_config import ToolConfig 
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__) 
-
-class BrowserSessionAwareWebPageScreenshotTaker(BrowserSessionAwareTool):
-    """
-    A session-aware tool to take a screenshot of the current page in a shared browser session.
-    """
-    CATEGORY = ToolCategory.WEB
-    
-    def __init__(self, config: Optional[ToolConfig] = None): 
-        super().__init__(config=config)
-        
-        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 (session-aware) 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 the current page in a shared browser session. "
-                "Saves it to the specified local file path and returns the absolute path of the saved screenshot. "
-                "Screenshot options (full page, image format) can be set at tool instantiation.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url", 
-            param_type=ParameterType.STRING,
-            description="URL of the webpage. Required if no browser session is active or to ensure context. Screenshot is of current page.",
-            required=True 
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="file_name", 
-            param_type=ParameterType.STRING,
-            description="The local file path (including filename and extension, e.g., 'session_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="Default for whether to capture the full scrollable page or just the viewport.",
-            required=False,
-            default_value=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="image_format",
-            param_type=ParameterType.ENUM,
-            description="Default image format for screenshots (png or jpeg).",
-            required=False,
-            default_value="png",
-            enum_values=["png", "jpeg"]
-        ))
-        return schema
-
-    async def perform_action(
-        self, 
-        shared_session: SharedBrowserSession, 
-        file_name: str, 
-        webpage_url: str 
-    ) -> str: 
-        logger.info(f"take_webpage_screenshot (session-aware) performing action. Saving to '{file_name}'. Current page: {shared_session.page.url}")
-
-        output_dir = os.path.dirname(file_name)
-        if output_dir: 
-            os.makedirs(output_dir, exist_ok=True)
-            
-        try:
-            await shared_session.page.screenshot(
-                path=file_name, 
-                full_page=self.full_page, 
-                type=self.image_format # type: ignore
-            )
-            absolute_file_path = os.path.abspath(file_name)
-            logger.info(f"Screenshot of {shared_session.page.url} saved successfully to {absolute_file_path}")
-            return absolute_file_path
-        except Exception as e:
-            logger.error(f"Error taking screenshot in shared session for page {shared_session.page.url}, saving to '{file_name}': {e}", exc_info=True)
-            raise RuntimeError(f"Failed to take screenshot in shared session: {str(e)}")

autobyteus/tools/browser/session_aware/factory/browser_session_aware_web_element_trigger_factory.py

@@ -1,14 +0,0 @@
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.tools.browser.session_aware.browser_session_aware_web_element_trigger import BrowserSessionAwareWebElementTrigger
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.tools.tool_config import ToolConfig
-
-class BrowserSessionAwareWebElementTriggerFactory(ToolFactory):
-    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebElementTrigger:
-        """
-        Creates an instance of BrowserSessionAwareWebElementTrigger.
-        The 'config' parameter is ignored by this factory.
-        """
-        return BrowserSessionAwareWebElementTrigger()

autobyteus/tools/browser/session_aware/factory/browser_session_aware_webpage_reader_factory.py

@@ -1,26 +0,0 @@
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.tools.browser.session_aware.browser_session_aware_webpage_reader import BrowserSessionAwareWebPageReader
-from autobyteus.utils.html_cleaner import CleaningMode
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.tools.tool_config import ToolConfig
-    from autobyteus.tools.base_tool import BaseTool
-
-class BrowserSessionAwareWebPageReaderFactory(ToolFactory):
-    def __init__(self, content_cleanup_level: CleaningMode = CleaningMode.THOROUGH):
-        self.content_cleanup_level = content_cleanup_level
-
-    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebPageReader:
-        """
-        Creates an instance of BrowserSessionAwareWebPageReader.
-        The 'config' parameter is ignored; configuration is set during factory initialization.
-        """
-        # This factory passes its own configuration to the tool's constructor.
-        # The tool's constructor expects a ToolConfig object.
-        from autobyteus.tools.tool_config import ToolConfig as ConcreteToolConfig
-        
-        tool_creation_config = ConcreteToolConfig(
-            params={"cleaning_mode": self.content_cleanup_level}
-        )
-        return BrowserSessionAwareWebPageReader(config=tool_creation_config)

autobyteus/tools/browser/session_aware/factory/browser_session_aware_webpage_screenshot_taker_factory.py

@@ -1,14 +0,0 @@
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.tools.browser.session_aware.browser_session_aware_webpage_screenshot_taker import BrowserSessionAwareWebPageScreenshotTaker
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.tools.tool_config import ToolConfig
-
-class BrowserSessionAwareWebPageScreenshotTakerFactory(ToolFactory):
-    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebPageScreenshotTaker:
-        """
-        Creates an instance of BrowserSessionAwareWebPageScreenshotTaker.
-        The 'config' parameter is ignored by this factory.
-        """
-        return BrowserSessionAwareWebPageScreenshotTaker()

autobyteus/tools/browser/session_aware/shared_browser_session.py

@@ -1,11 +0,0 @@
-from brui_core.ui_integrator import UIIntegrator
-
-class SharedBrowserSession(UIIntegrator):
-    def __init__(self):
-        super().__init__()
-
-    async def initialize(self):
-        await super().initialize()
-
-    async def close(self):
-        await super().close(close_page=False, close_context=False, close_browser=False)

autobyteus/tools/browser/session_aware/shared_browser_session_manager.py

@@ -1,25 +0,0 @@
-from autobyteus.utils.singleton import SingletonMeta
-from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
-from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.events.event_types import EventType
-
-class SharedBrowserSessionManager(metaclass=SingletonMeta):
-    def __init__(self):
-        self.shared_browser_session = None
-        self.event_emitter = EventEmitter()
-        self.event_emitter.subscribe(EventType.CREATE_SHARED_SESSION, self.create_shared_browser_session)
-
-    async def create_shared_browser_session(self, **kwargs):
-        self.shared_browser_session = SharedBrowserSession()
-        await self.shared_browser_session.initialize()
-
-    async def close_shared_browser_session(self):
-        if self.shared_browser_session:
-            await self.shared_browser_session.close()
-            self.shared_browser_session = None
-
-    def set_shared_browser_session(self, shared_session):
-        self.shared_browser_session = shared_session
-
-    def get_shared_browser_session(self):
-        return self.shared_browser_session

autobyteus/tools/browser/session_aware/web_element_action.py

@@ -1,20 +0,0 @@
-from enum import Enum, auto
-
-class WebElementAction(Enum):
-    CLICK = auto()
-    TYPE = auto()
-    SELECT = auto()
-    CHECK = auto()
-    SUBMIT = auto()
-    HOVER = auto()
-    DOUBLE_CLICK = auto()
-
-    def __str__(self):
-        return self.name.lower()
-
-    @staticmethod
-    def from_string(action_string):
-        try:
-            return WebElementAction[action_string.upper()]
-        except KeyError:
-            raise ValueError(f"Unsupported action: {action_string}")

autobyteus/tools/browser/standalone/__init__.py

@@ -1,6 +0,0 @@
-# This file makes 'standalone' a package under 'browser'.
-# from .webpage_reader import WebPageReader
-# from .webpage_screenshot_taker import WebPageScreenshotTaker
-# from .navigate_to import NavigateTo
-# from .webpage_image_downloader import WebPageImageDownloader
-# from .web_page_pdf_generator import WebPagePDFGenerator

autobyteus/tools/browser/standalone/factory/webpage_reader_factory.py

@@ -1,25 +0,0 @@
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.tools.browser.standalone.webpage_reader import WebPageReader
-from autobyteus.utils.html_cleaner import CleaningMode
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.tools.tool_config import ToolConfig
-
-class WebPageReaderFactory(ToolFactory):
-    def __init__(self, cleaning_mode: CleaningMode = CleaningMode.THOROUGH):
-        self.cleaning_mode = cleaning_mode
-
-    def create_tool(self, config: Optional['ToolConfig'] = None) -> WebPageReader:
-        """
-        Creates an instance of WebPageReader.
-        The 'config' parameter is ignored; configuration is set during factory initialization.
-        """
-        # This factory passes its own configuration to the tool's constructor.
-        # The tool's constructor expects a ToolConfig object.
-        from autobyteus.tools.tool_config import ToolConfig as ConcreteToolConfig
-        
-        tool_creation_config = ConcreteToolConfig(
-            params={"cleaning_mode": self.cleaning_mode}
-        )
-        return WebPageReader(config=tool_creation_config)

autobyteus/tools/browser/standalone/factory/webpage_screenshot_taker_factory.py

@@ -1,14 +0,0 @@
-from autobyteus.tools.factory.tool_factory import ToolFactory
-from autobyteus.tools.browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker
-from typing import Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.tools.tool_config import ToolConfig
-
-class WebPageScreenshotTakerFactory(ToolFactory):
-    def create_tool(self, config: Optional['ToolConfig'] = None) -> WebPageScreenshotTaker:
-        """
-        Creates an instance of WebPageScreenshotTaker.
-        The 'config' parameter is ignored by this factory.
-        """
-        return WebPageScreenshotTaker()