pydoll-python 1.2.0__py3-none-any.whl

pydoll/commands/target.py

@@ -0,0 +1,35 @@
+class TargetCommands:
+    ACTIVATE_TARGET = {'method': 'Target.activateTarget', 'params': {}}
+    ATTACH_TO_TARGET = {'method': 'Target.attachToTarget', 'params': {}}
+    CLOSE_TARGET = {'method': 'Target.closeTarget', 'params': {}}
+    CREATE_TARGET = {'method': 'Target.createTarget', 'params': {}}
+    GET_TARGETS = {'method': 'Target.getTargets', 'params': {}}
+    GET_TARGET_INFO = {'method': 'Target.getTargetInfo', 'params': {}}
+
+    @classmethod
+    def activate_target(cls, target_id: str) -> dict:
+        activate_target = cls.ATTACH_TO_TARGET.copy()
+        activate_target['params']['targetId'] = target_id
+        return activate_target
+
+    @classmethod
+    def attach_to_target(cls, target_id: str) -> dict:
+        attach_to_target = cls.ATTACH_TO_TARGET.copy()
+        attach_to_target['params']['targetId'] = target_id
+        return attach_to_target
+
+    @classmethod
+    def close_target(cls, target_id: str) -> dict:
+        close_target = cls.CLOSE_TARGET.copy()
+        close_target['params']['targetId'] = target_id
+        return close_target
+
+    @classmethod
+    def create_target(cls, url: str) -> dict:
+        create_target = cls.CREATE_TARGET.copy()
+        create_target['params']['url'] = url
+        return create_target
+
+    @classmethod
+    def get_targets(cls) -> dict:
+        return cls.GET_TARGETS

pydoll/connection/connection.py

@@ -0,0 +1,232 @@
+import asyncio
+import json
+import logging
+from typing import Callable
+
+import websockets
+
+from pydoll import exceptions
+from pydoll.connection.managers import CommandManager, EventsHandler
+from pydoll.utils import get_browser_ws_address
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class ConnectionHandler:
+    """
+    A class to handle WebSocket connections for browser automation.
+
+    This class manages the connection to the browser and the associated page,
+    providing methods to execute commands and register event callbacks.
+    """
+
+    def __init__(
+        self,
+        connection_port: int,
+        page_id: str = 'browser',
+        ws_address_resolver: Callable[[int], str] = get_browser_ws_address,
+        ws_connector: Callable = websockets.connect,
+    ):
+        """
+        Initializes the ConnectionHandler instance.
+
+        Args:
+            connection_port (int): The port to connect to the browser.
+
+        Sets up the internal state including WebSocket addresses,
+        connection instance, event callbacks, and command ID.
+        """
+        self._connection_port = connection_port
+        self._page_id = page_id
+        self._ws_address_resolver = ws_address_resolver
+        self._ws_connector = ws_connector
+        self._ws_connection = None
+        self._command_manager = CommandManager()
+        self._events_handler = EventsHandler()
+        logger.info('ConnectionHandler initialized.')
+
+    @property
+    def network_logs(self):
+        return self._events_handler.network_logs
+
+    @property
+    def dialog(self):
+        return self._events_handler.dialog
+
+    async def ping(self) -> bool:
+        """
+        Sends a ping message to the browser.
+
+        Returns:
+            bool: True if the ping was successful, False otherwise.
+        """
+        try:
+            await self._ensure_active_connection()
+            await self._ws_connection.ping()
+            return True
+        except Exception:
+            return False
+
+    async def execute_command(self, command: dict, timeout: int = 10) -> dict:
+        """
+        Sends a command to the browser and awaits its response.
+
+        Args:
+            command (dict): The command to send, structured as a dictionary.
+            timeout (int, optional): Time in seconds to wait for a response.
+                Defaults to 10.
+
+        Returns:
+            dict: The response from the browser.
+
+        Raises:
+            InvalidCommand: If the command is not a dictionary.
+            TimeoutError: If the command execution exceeds the timeout.
+        """
+        if not isinstance(command, dict):
+            logger.error('Command must be a dictionary.')
+            raise exceptions.InvalidCommand('Command must be a dictionary')
+
+        await self._ensure_active_connection()
+        future = self._command_manager.create_command_future(command)
+        command_str = json.dumps(command)
+
+        try:
+            await self._ws_connection.send(command_str)
+            response: str = await asyncio.wait_for(future, timeout)
+            return json.loads(response)
+        except asyncio.TimeoutError as exc:
+            self._command_manager.remove_pending_command(command['id'])
+            raise exc
+        except websockets.ConnectionClosed as exc:
+            await self._handle_connection_loss()
+            raise exc
+
+    async def register_callback(
+        self, event_name: str, callback: Callable, temporary: bool = False
+    ):
+        return self._events_handler.register_callback(
+            event_name, callback, temporary
+        )
+
+    async def remove_callback(self, callback_id: int):
+        return self._events_handler.remove_callback(callback_id)
+
+    async def clear_callbacks(self):
+        return self._events_handler.clear_callbacks()
+
+    async def close(self):
+        """
+        Closes the WebSocket connection.
+
+        Closes the WebSocket connection and clears all event callbacks.
+        """
+        await self.clear_callbacks()
+        await self._ws_connection.close()
+        logger.info('WebSocket connection closed.')
+
+    async def _ensure_active_connection(self):
+        """Guarantee an active connection exists."""
+        if self._ws_connection is None or self._ws_connection.closed:
+            await self._establish_new_connection()
+
+    async def _establish_new_connection(self):
+        """Create fresh connection and start listening."""
+        ws_address = await self._resolve_ws_address()
+        logger.info(f'Connecting to {ws_address}')
+        self._ws_connection = await self._ws_connector(ws_address)
+        self._receive_task = asyncio.create_task(self._receive_events())
+        logger.debug('WebSocket connection established')
+
+    async def _resolve_ws_address(self):
+        """Determine correct WebSocket address."""
+        if 'browser' in self._page_id:
+            return await self._ws_address_resolver(self._connection_port)
+        return (
+            f'ws://localhost:{self._connection_port}/devtools/page/'
+            f'{self._page_id}'
+        )
+
+    async def _handle_connection_loss(self):
+        """Clean up after connection loss."""
+        if self._ws_connection and not self._ws_connection.closed:
+            await self._ws_connection.close()
+        self._ws_connection = None
+
+        if self._receive_task and not self._receive_task.done():
+            self._receive_task.cancel()
+
+        logger.info('Connection resources cleaned up')
+
+    async def _receive_events(self):
+        """
+        Main loop for receiving and processing incoming WebSocket messages.
+        Delegates processing to specialized handlers based on message type.
+        """
+        try:
+            async for raw_message in self._incoming_messages():
+                await self._process_single_message(raw_message)
+        except websockets.ConnectionClosed as e:
+            logger.info(f'Connection closed gracefully: {e}')
+        except Exception as e:
+            logger.error(f'Unexpected error in event loop: {e}')
+            raise
+
+    async def _incoming_messages(self):
+        """Generator that yields raw messages while connection is open"""
+        while not self._ws_connection.closed:
+            yield await self._ws_connection.recv()
+
+    async def _process_single_message(self, raw_message: str):
+        """Orchestrates processing of a single raw WebSocket message"""
+        message = self._parse_message(raw_message)
+        if not message:
+            return
+
+        if self._is_command_response(message):
+            await self._handle_command_message(message)
+        else:
+            await self._handle_event_message(message)
+
+    @staticmethod
+    def _parse_message(raw_message: str) -> dict | None:
+        """
+        Attempts to parse raw message string into JSON.
+        Returns parsed dict or None if parsing fails.
+        """
+        try:
+            return json.loads(raw_message)
+        except json.JSONDecodeError:
+            logger.warning(f'Failed to parse message: {raw_message[:200]}...')
+            return None
+
+    @staticmethod
+    def _is_command_response(message: dict) -> bool:
+        """Determines if message is a response to a command"""
+        return 'id' in message and isinstance(message['id'], int)
+
+    async def _handle_command_message(self, message: dict):
+        """Processes messages that are command responses"""
+        logger.debug(f'Processing command response: {message.get("id")}')
+        self._command_manager.resolve_command(
+            message['id'], json.dumps(message)
+        )
+
+    async def _handle_event_message(self, message: dict):
+        """Processes messages that are spontaneous events"""
+        event_type = message.get('method', 'unknown-event')
+        logger.debug(f'Processing {event_type} event')
+        await self._events_handler.process_event(message)
+
+    def __repr__(self):
+        return f'ConnectionHandler(port={self._connection_port})'
+
+    def __str__(self):
+        return f'ConnectionHandler(port={self._connection_port})'
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

pydoll/connection/managers.py

@@ -0,0 +1,136 @@
+import asyncio
+import logging
+from typing import Callable, Dict
+
+from pydoll import exceptions
+
+logger = logging.getLogger(__name__)
+
+
+class CommandManager:
+    def __init__(self):
+        self._pending_commands: dict[int, asyncio.Future] = {}
+        self._id = 1
+
+    def create_command_future(self, command: dict) -> asyncio.Future:
+        command['id'] = self._id
+        future = asyncio.Future()
+        self._pending_commands[self._id] = future
+        self._id += 1
+        return future
+
+    def resolve_command(self, response_id: int, result: str):
+        if response_id in self._pending_commands:
+            self._pending_commands[response_id].set_result(result)
+            del self._pending_commands[response_id]
+
+    def remove_pending_command(self, command_id: int):
+        """
+        Remove um comando pendente sem resolvê-lo (útil para timeouts).
+
+        Args:
+            command_id: ID do comando a ser removido
+        """
+        if command_id in self._pending_commands:
+            del self._pending_commands[command_id]
+
+
+class EventsHandler:
+    """
+    Gerencia registro de callbacks, processamento de eventos e logs de rede.
+    """
+
+    def __init__(self):
+        self._event_callbacks: Dict[int, dict] = {}
+        self._callback_id = 0
+        self.network_logs = []
+        self.dialog = {}
+        logger.info('EventsHandler initialized')
+
+    def register_callback(
+        self, event_name: str, callback: Callable, temporary: bool = False
+    ) -> int:
+        """
+        Registra um callback para um tipo específico de evento.
+
+        Retorna:
+            int: ID do callback registrado
+        """
+        if not callable(callback):
+            logger.error('Callback must be a callable function.')
+            raise exceptions.InvalidCallback('Callback must be callable')
+
+        self._callback_id += 1
+        self._event_callbacks[self._callback_id] = {
+            'event': event_name,
+            'callback': callback,
+            'temporary': temporary,
+        }
+        logger.info(
+            f"Registered callback '{event_name}' with ID {self._callback_id}"
+        )
+        return self._callback_id
+
+    def remove_callback(self, callback_id: int) -> bool:
+        """Remove um callback pelo ID."""
+        if callback_id not in self._event_callbacks:
+            logger.warning(f'Callback ID {callback_id} not found')
+            return False
+
+        del self._event_callbacks[callback_id]
+        logger.info(f'Removed callback ID {callback_id}')
+        return True
+
+    def clear_callbacks(self):
+        """Reseta todos os callbacks registrados."""
+        self._event_callbacks.clear()
+        logger.info('All callbacks cleared')
+
+    async def process_event(self, event_data: dict):
+        """
+        Processa um evento recebido e dispara os callbacks correspondentes.
+
+        Args:
+            event_data: Dados do evento no formato dicionário
+        """
+        event_name = event_data.get('method')
+        logger.debug(f'Processing event: {event_name}')
+
+        # Atualiza logs de rede se necessário
+        if 'Network.requestWillBeSent' in event_name:
+            self._update_network_logs(event_data)
+
+        if 'Page.javascriptDialogOpening' in event_name:
+            self.dialog = event_data
+
+        if 'Page.javascriptDialogClosed' in event_name:
+            self.dialog = {}
+
+        # Processa callbacks
+        await self._trigger_callbacks(event_name, event_data)
+
+    def _update_network_logs(self, event_data: dict):
+        """Mantém os logs de rede atualizados."""
+        self.network_logs.append(event_data)
+        self.network_logs = self.network_logs[-10000:]  # Mantém tamanho máximo
+
+    async def _trigger_callbacks(self, event_name: str, event_data: dict):
+        """Dispara todos os callbacks registrados para o evento."""
+        callbacks_to_remove = []
+
+        for cb_id, cb_data in list(self._event_callbacks.items()):
+            if cb_data['event'] == event_name:
+                try:
+                    if asyncio.iscoroutinefunction(cb_data['callback']):
+                        await cb_data['callback'](event_data)
+                    else:
+                        cb_data['callback'](event_data)
+                except Exception as e:
+                    logger.error(f'Error in callback {cb_id}: {str(e)}')
+
+                if cb_data['temporary']:
+                    callbacks_to_remove.append(cb_id)
+
+        # Remove callbacks temporários após processamento
+        for cb_id in callbacks_to_remove:
+            self.remove_callback(cb_id)

pydoll/constants.py

@@ -0,0 +1,125 @@
+from enum import Enum
+
+
+class By(str, Enum):
+    CSS_SELECTOR = 'css'
+    XPATH = 'xpath'
+    CLASS_NAME = 'class_name'
+    ID = 'id'
+    TAG_NAME = 'tag_name'
+
+
+class Scripts:
+    ELEMENT_VISIBLE = """
+    function() {
+        const rect = this.getBoundingClientRect();
+        return (
+            rect.width > 0 && rect.height > 0
+            && getComputedStyle(this).visibility !== 'hidden'
+            && getComputedStyle(this).display !== 'none'
+        )
+    }
+    """
+
+    ELEMENT_ON_TOP = """
+    function() {
+        const rect = this.getBoundingClientRect();
+        const elementFromPoint = document.elementFromPoint(
+            rect.x + rect.width / 2,
+            rect.y + rect.height / 2
+        );
+        return elementFromPoint === this;
+    }
+    """
+
+    CLICK = """
+    function(){
+        clicked = false;
+        this.addEventListener('click', function(){
+            clicked = true;
+        });
+        this.click();
+        return clicked;
+    }
+    """
+
+    CLICK_OPTION_TAG = """
+    document.querySelector('option[value="{self.value}"]').selected = true;
+    var selectParentXpath = (
+        '//option[@value="{self.value}"]//ancestor::select'
+    );
+    var select = document.evaluate(
+        selectParentXpath,
+        document,
+        null,
+        XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+    ).singleNodeValue;
+    var event = new Event('change', { bubbles: true });
+    select.dispatchEvent(event);
+    """
+
+    BOUNDS = """
+    function() {
+        return JSON.stringify(this.getBoundingClientRect());
+    }
+    """
+
+    FIND_RELATIVE_XPATH_ELEMENT = """
+        function() {
+            return document.evaluate(
+                "{escaped_value}", this, null,
+                XPathResult.FIRST_ORDERED_NODE_TYPE, null
+            ).singleNodeValue;
+        }
+    """
+
+    FIND_XPATH_ELEMENT = """
+        var element = document.evaluate(
+            "{escaped_value}", document, null,
+            XPathResult.FIRST_ORDERED_NODE_TYPE, null
+        ).singleNodeValue;
+        element;
+    """
+
+    FIND_RELATIVE_XPATH_ELEMENTS = """
+        function() {
+            var elements = document.evaluate(
+                "{escaped_value}", this, null,
+                XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null
+            );
+            var results = [];
+            for (var i = 0; i < elements.snapshotLength; i++) {
+                results.push(elements.snapshotItem(i));
+            }
+            return results;
+        }
+    """
+
+    FIND_XPATH_ELEMENTS = """
+        var elements = document.evaluate(
+            "{escaped_value}", document, null,
+            XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null
+        );
+        var results = [];
+        for (var i = 0; i < elements.snapshotLength; i++) {
+            results.push(elements.snapshotItem(i));
+        }
+        results;
+    """
+
+    QUERY_SELECTOR = 'document.querySelector("{selector}");'
+
+    RELATIVE_QUERY_SELECTOR = """
+        function() {
+            return this.querySelector("{selector}");
+        }
+    """
+
+    QUERY_SELECTOR_ALL = 'document.querySelectorAll("{selector}");'
+
+    RELATIVE_QUERY_SELECTOR_ALL = """
+        function() {
+            return this.querySelectorAll("{selector}");
+        }
+    """