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

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"BrowserSessionAwareWebPageScreenshotTaker initialized. Full page: {self.full_page}, Format: {self.image_format}")
-
-    @classmethod
-    def get_name(cls) -> str: 
-        return "WebPageScreenshotTaker" 
-
-    @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"BrowserSessionAwareWebPageScreenshotTaker 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()

autobyteus/tools/browser/standalone/navigate_to.py

@@ -1,80 +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("NavigateTo (standalone) tool initialized.")
-
-    @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"NavigateTo (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"NavigateTo (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 NavigateTo (standalone).")
-                 raise RuntimeError("Playwright page not available for NavigateTo.")
-
-            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"NavigateTo (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"NavigateTo (standalone) for agent {context.agent_id}: {failure_msg}")
-                return failure_msg
-        except Exception as e:
-            logger.error(f"Error during NavigateTo (standalone) for URL '{url}', agent {context.agent_id}: {e}", exc_info=True)
-            raise RuntimeError(f"NavigateTo (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,97 +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("WebPagePDFGenerator (standalone) tool initialized.")
-
-    @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"WebPagePDFGenerator 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 WebPagePDFGenerator.")
-                 raise RuntimeError("Playwright page not available for WebPagePDFGenerator.")
-
-            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"WebPagePDFGenerator 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,165 +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("WebPageImageDownloader tool initialized.")
-
-    @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"WebPageImageDownloader 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 WebPageImageDownloader.")
-                 raise RuntimeError("Playwright page not available for WebPageImageDownloader.")
-
-            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 WebPageImageDownloader for URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"WebPageImageDownloader 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)