pydoll-python 1.3.3__tar.gz → 1.4.0__tar.gz

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydoll-python
-Version: 1.3.3
+Version: 1.4.0
 Summary: 
 Author: Thalison Fernandes
 Author-email: thalissfernandes99@gmail.com
@@ -26,7 +26,9 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
-    <img src="https://codecov.io/github/thalissonvs/pydoll/graph/badge.svg?token=40I938OGM9"/> 
+    <a href="https://codecov.io/gh/autoscrape-labs/pydoll">
+        <img src="https://codecov.io/gh/autoscrape-labs/pydoll/graph/badge.svg?token=40I938OGM9"/> 
+    </a>
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/tests.yml/badge.svg" alt="Tests">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/ruff-ci.yml/badge.svg" alt="Ruff CI">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/release.yml/badge.svg" alt="Release">
@@ -669,6 +671,25 @@ input_field = await page.find_element(By.CSS_SELECTOR, 'input[name="username"]')
 await input_field.send_keys("user123")
 ```
 
+##### `async set_input_files(files: Union[str, Path, List[Union[str, Path]]])`
+Send files to an input element:
+
+```python
+file_input_field = await page.find_element(By.XPATH, '//input[@type="file"]')
+# Single-file upload
+await file_input_field.set_input_files(r'c:\demo\demo1.file')
+# Multi-file uploads
+await file_input_field.set_input_files([r'c:\demo\demo1.file', r'c:\demo\demo2.file'])
+```
+
+You can also do this with the `expect_file_chooser` context manager:
+```python
+async with page.expect_file_chooser(files=r'c:\demo\demo1.file'):
+    file_input_field = await page.find_element(By.XPATH, '//button[@id="upload-button-demo"]')
+    await file_input_field.click()
+```
+This way supports any type of elements, not only inputs.
+
 ##### `async type_keys(text: str)`
 Type realistically, key by key, simulating human input.
 

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/README.md

@@ -7,7 +7,9 @@
 </p>
 
 <p align="center">
-    <img src="https://codecov.io/github/thalissonvs/pydoll/graph/badge.svg?token=40I938OGM9"/> 
+    <a href="https://codecov.io/gh/autoscrape-labs/pydoll">
+        <img src="https://codecov.io/gh/autoscrape-labs/pydoll/graph/badge.svg?token=40I938OGM9"/> 
+    </a>
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/tests.yml/badge.svg" alt="Tests">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/ruff-ci.yml/badge.svg" alt="Ruff CI">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/release.yml/badge.svg" alt="Release">
@@ -650,6 +652,25 @@ input_field = await page.find_element(By.CSS_SELECTOR, 'input[name="username"]')
 await input_field.send_keys("user123")
 ```
 
+##### `async set_input_files(files: Union[str, Path, List[Union[str, Path]]])`
+Send files to an input element:
+
+```python
+file_input_field = await page.find_element(By.XPATH, '//input[@type="file"]')
+# Single-file upload
+await file_input_field.set_input_files(r'c:\demo\demo1.file')
+# Multi-file uploads
+await file_input_field.set_input_files([r'c:\demo\demo1.file', r'c:\demo\demo2.file'])
+```
+
+You can also do this with the `expect_file_chooser` context manager:
+```python
+async with page.expect_file_chooser(files=r'c:\demo\demo1.file'):
+    file_input_field = await page.find_element(By.XPATH, '//button[@id="upload-button-demo"]')
+    await file_input_field.click()
+```
+This way supports any type of elements, not only inputs.
+
 ##### `async type_keys(text: str)`
 Type realistically, key by key, simulating human input.
 

pydoll_python-1.4.0/pydoll/browser/__init__.py

@@ -0,0 +1,4 @@
+from pydoll.browser.chrome import Chrome
+from pydoll.browser.edge import Edge
+
+__all__ = ['Chrome', 'Edge']

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/browser/base.py

@@ -4,6 +4,7 @@ from functools import partial
 from random import randint
 
 from pydoll import exceptions
+from pydoll.browser.constants import BrowserType
 from pydoll.browser.managers import (
     BrowserOptionsManager,
     BrowserProcessManager,
@@ -35,6 +36,7 @@ class Browser(ABC):  # noqa: PLR0904
         self,
         options: Options | None = None,
         connection_port: int = None,
+        browser_type: BrowserType = None
     ):
         """
         Initializes the Browser instance.
@@ -43,11 +45,15 @@ class Browser(ABC):  # noqa: PLR0904
             options (Options | None): An instance of the Options class to
             configure the browser. If None, default options will be used.
             connection_port (int): The port to connect to the browser.
+            browser_type (BrowserType): The type of browser to use.
+                If None, it will be inferred from the options.
 
         Raises:
             TypeError: If any of the arguments are not callable.
         """
-        self.options = BrowserOptionsManager.initialize_options(options)
+        self.options = BrowserOptionsManager.initialize_options(
+            options, browser_type
+        )
         self._proxy_manager = ProxyManager(self.options)
         self._connection_port = (
             connection_port if connection_port else randint(9223, 9322)
@@ -77,7 +83,7 @@ class Browser(ABC):  # noqa: PLR0904
             exc_val: The exception value, if raised.
             exc_tb: The traceback, if an exception was raised.
         """
-        if await self._is_browser_running():
+        if await self._is_browser_running(timeout=2):
             await self.stop()
 
         await self._connection_handler.close()
@@ -242,6 +248,7 @@ class Browser(ABC):  # noqa: PLR0904
             await self._execute_command(BrowserCommands.CLOSE)
             self._browser_process_manager.stop_process()
             self._temp_directory_manager.cleanup()
+            await self._connection_handler.close()
         else:
             raise exceptions.BrowserNotRunning('Browser is not running')
 
@@ -505,13 +512,16 @@ class Browser(ABC):  # noqa: PLR0904
         """
 
         valid_page = next(
-            (page for page in pages
-             if page.get('type') == 'page' and page.get('attached')),
-            None
+            (
+                page
+                for page in pages
+                if page.get('type') == 'page' and page.get('attached')
+            ),
+            None,
         )
 
         if not valid_page:
-            raise RuntimeError("No valid attached browser page found.")
+            raise RuntimeError('No valid attached browser page found.')
 
         target_id = valid_page.get('targetId')
         if not target_id:
@@ -549,20 +559,13 @@ class Browser(ABC):  # noqa: PLR0904
         )
 
     def _setup_user_dir(self):
-        """
-        Prepares the user data directory if needed.
-
-        This method creates a temporary directory for browser data if
-        no user directory is specified in the browser options.
-
-        Returns:
-            None
-        """
-        temp_dir = self._temp_directory_manager.create_temp_dir()
-        if '--user-data-dir' not in [
-            arg.split('=')[0] for arg in self.options.arguments
+        """Prepares the user data directory if necessary."""
+        if "--user-data-dir" not in [
+            arg.split("=")[0] for arg in self.options.arguments
         ]:
-            self.options.arguments.append(f'--user-data-dir={temp_dir.name}')
+            # For all browsers, use a temporary directory
+            temp_dir = self._temp_directory_manager.create_temp_dir()
+            self.options.arguments.append(f"--user-data-dir={temp_dir.name}")
 
     @abstractmethod
     def _get_default_binary_location(self) -> str:

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/browser/chrome.py

@@ -2,6 +2,7 @@ import platform
 from typing import Optional
 
 from pydoll.browser.base import Browser
+from pydoll.browser.constants import BrowserType
 from pydoll.browser.managers import BrowserOptionsManager
 from pydoll.browser.options import Options
 
@@ -28,7 +29,7 @@ class Chrome(Browser):
             connection_port (int): The port to connect to the browser.
                 Defaults to 9222.
         """
-        super().__init__(options, connection_port)
+        super().__init__(options, connection_port, BrowserType.CHROME)
 
     @staticmethod
     def _get_default_binary_location():
@@ -57,7 +58,7 @@ class Chrome(Browser):
             ],
             'Darwin': [
                 '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-            ]
+            ],
         }
 
         browser_path = browser_paths.get(os_name)
@@ -65,6 +66,4 @@ class Chrome(Browser):
         if not browser_path:
             raise ValueError('Unsupported OS')
 
-        return BrowserOptionsManager.validate_browser_paths(
-            browser_path
-        )
+        return BrowserOptionsManager.validate_browser_paths(browser_path)

pydoll_python-1.4.0/pydoll/browser/constants.py

@@ -0,0 +1,6 @@
+from enum import Enum, auto
+
+
+class BrowserType(Enum):
+    CHROME = auto()
+    EDGE = auto()

pydoll_python-1.4.0/pydoll/browser/edge.py

@@ -0,0 +1,74 @@
+import platform
+from typing import Optional
+
+from pydoll.browser.base import Browser
+from pydoll.browser.constants import BrowserType
+from pydoll.browser.managers import BrowserOptionsManager
+from pydoll.browser.options import Options
+
+
+class Edge(Browser):
+    """
+    A class that implements the Edge browser functionality.
+
+    This class provides specific implementation for launching and
+    controlling Microsoft Edge browsers.
+    """
+
+    def __init__(
+        self,
+        options: Optional[Options] = None,
+        connection_port: Optional[int] = None,
+    ):
+        """
+        Initializes the Edge browser instance.
+
+        Args:
+            options (Options | None): An instance of Options class to configure
+                the browser. If None, default options will be used.
+            connection_port (int): The port to connect to the browser.
+                Defaults to a random port between 9223 and 9322.
+        """
+        super().__init__(options, connection_port, BrowserType.EDGE)
+
+    @staticmethod
+    def _get_default_binary_location():
+        """
+        Gets the default location of the Edge browser executable.
+
+        This method determines the default Edge executable path based
+        on the operating system.
+
+        Returns:
+            str: The path to the Edge browser executable.
+
+        Raises:
+            ValueError: If the operating system is not supported or
+                the browser executable is not found at the default location.
+        """
+        os_name = platform.system()
+
+        browser_paths = {
+            "Windows": [
+                (r"C:\Program Files\Microsoft\Edge\Application"
+                 r"\msedge.exe"),
+                (r"C:\Program Files (x86)\Microsoft\Edge"
+                 r"\Application\msedge.exe"),
+            ],
+            "Linux": [
+                "/usr/bin/microsoft-edge",
+            ],
+            "Darwin": [
+                ("/Applications/Microsoft Edge.app/Contents/MacOS"
+                 "/Microsoft Edge"),
+            ],
+        }
+
+        browser_path = browser_paths.get(os_name)
+
+        if not browser_path:
+            raise ValueError('Unsupported OS')
+
+        return BrowserOptionsManager.validate_browser_paths(
+            browser_path
+        )

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/browser/managers.py

@@ -4,7 +4,8 @@ import subprocess
 from contextlib import suppress
 from tempfile import TemporaryDirectory
 
-from pydoll.browser.options import Options
+from pydoll.browser.constants import BrowserType
+from pydoll.browser.options import ChromeOptions, EdgeOptions, Options
 
 
 class ProxyManager:
@@ -64,8 +65,8 @@ class ProxyManager:
                 argument and the proxy value if found, None otherwise.
         """
         for index, arg in enumerate(self.options.arguments):
-            if arg.startswith('--proxy-server='):
-                return index, arg.split('=', 1)[1]
+            if arg.startswith("--proxy-server="):
+                return index, arg.split("=", 1)[1]
         return None
 
     @staticmethod
@@ -87,12 +88,12 @@ class ProxyManager:
                 - str: Password (or None if no credentials)
                 - str: Clean proxy URL without credentials
         """
-        if '@' not in proxy_value:
+        if "@" not in proxy_value:
             return False, None, None, proxy_value
 
         try:
-            creds_part, server_part = proxy_value.split('@', 1)
-            username, password = creds_part.split(':', 1)
+            creds_part, server_part = proxy_value.split("@", 1)
+            username, password = creds_part.split(":", 1)
             return True, username, password, server_part
         except ValueError:
             return False, None, None, proxy_value
@@ -112,7 +113,7 @@ class ProxyManager:
         Returns:
             None
         """
-        self.options.arguments[index] = f'--proxy-server={clean_proxy}'
+        self.options.arguments[index] = f"--proxy-server={clean_proxy}"
 
 
 class BrowserProcessManager:
@@ -149,11 +150,13 @@ class BrowserProcessManager:
         Returns:
             subprocess.Popen: The started browser process.
         """
-        self._process = self._process_creator([
-            binary_location,
-            f'--remote-debugging-port={port}',
-            *arguments,
-        ])
+        self._process = self._process_creator(
+            [
+                binary_location,
+                f"--remote-debugging-port={port}",
+                *arguments,
+            ]
+        )
         return self._process
 
     @staticmethod
@@ -239,44 +242,69 @@ class TempDirectoryManager:
 
 class BrowserOptionsManager:
     @staticmethod
-    def initialize_options(options: Options | None) -> Options:
+    def initialize_options(
+        options: Options | None, browser_type: BrowserType = None
+    ) -> Options:
         """
-        Initializes options for the browser.
+        Initialize browser options based on browser type.
 
-        This method ensures that a valid Options instance is available,
-        creating a default one if necessary.
+        Creates a new options instance based on browser type if none
+        is provided, or validates and returns the provided
+        options instance.
 
         Args:
-            options (Options | None): An Options instance or None.
+            options (Options | None): Browser options instance.
+            If None, a new instance
+                will be created based on browser_type
+            browser_type (BrowserType): Type of browser, used to create
+            appropriate options instance
 
         Returns:
-            Options: An initialized Options instance.
+            Options: The initialized browser options instance
 
         Raises:
-            ValueError: If options is not None and not an instance of Options.
+            ValueError: If provided options is not an instance
+            of Options class
         """
         if options is None:
-            return Options()
+            if browser_type == BrowserType.CHROME:
+                return ChromeOptions()
+            elif browser_type == BrowserType.EDGE:
+                return EdgeOptions()
+            else:
+                return Options()
+
         if not isinstance(options, Options):
-            raise ValueError('Invalid options')
+            raise ValueError("Invalid options")
+
         return options
 
     @staticmethod
     def add_default_arguments(options: Options):
-        """
-        Adds default arguments to the provided options.
+        """Adds default arguments to the provided options"""
+        options.arguments.append("--no-first-run")
+        options.arguments.append("--no-default-browser-check")
 
-        This method appends standard browser arguments that improve
-        reliability and automation performance.
+        # Add browser-specific arguments based on options type
+        if isinstance(options, EdgeOptions):
+            BrowserOptionsManager._add_edge_arguments(options)
+        elif isinstance(options, ChromeOptions):
+            BrowserOptionsManager._add_chrome_arguments(options)
 
-        Args:
-            options (Options): The options instance to modify.
+    @staticmethod
+    def _add_edge_arguments(options: Options):
+        """Adds Edge-specific arguments to the options"""
+        options.add_argument("--disable-crash-reporter")
+        options.add_argument("--disable-features=TranslateUI")
+        options.add_argument("--disable-component-update")
+        options.add_argument("--disable-background-networking")
+        options.add_argument("--remote-allow-origins=*")
 
-        Returns:
-            None
-        """
-        options.arguments.append('--no-first-run')
-        options.arguments.append('--no-default-browser-check')
+    @staticmethod
+    def _add_chrome_arguments(options: Options):
+        """Adds Chrome-specific arguments to the options"""
+        options.add_argument("--remote-allow-origins=*")
+        # Add other Chrome-specific arguments here
 
     @staticmethod
     def validate_browser_paths(paths: list[str]) -> str:
@@ -299,4 +327,4 @@ class BrowserOptionsManager:
         for path in paths:
             if os.path.exists(path) and os.access(path, os.X_OK):
                 return path
-        raise ValueError(f"No valid browser path found in: {paths}")
+        raise ValueError(f'No valid browser path found in: {paths}')

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/browser/options.py

@@ -1,3 +1,4 @@
+
 class Options:
     """
     A class to manage command-line options for a browser instance.
@@ -26,6 +27,16 @@ class Options:
         """
         return self._arguments
 
+    @arguments.setter
+    def arguments(self, args_list: list):
+        """
+        Sets the list of command-line arguments.
+
+        Args:
+            args_list (list): A list of command-line arguments.
+        """
+        self._arguments = args_list
+
     @property
     def binary_location(self) -> str:
         """
@@ -56,7 +67,17 @@ class Options:
         Raises:
             ValueError: If the argument is already in the list of arguments.
         """
-        if argument not in self.arguments:
-            self.arguments.append(argument)
+        if argument not in self._arguments:
+            self._arguments.append(argument)
         else:
             raise ValueError(f'Argument already exists: {argument}')
+
+
+class ChromeOptions(Options):
+    def __init__(self):
+        super().__init__()
+
+
+class EdgeOptions(Options):
+    def __init__(self):
+        super().__init__()

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/browser/page.py

@@ -1,5 +1,8 @@
 import asyncio
 import json
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import List, Union
 
 import aiofiles
 
@@ -13,6 +16,7 @@ from pydoll.commands import (
 )
 from pydoll.connection.connection import ConnectionHandler
 from pydoll.element import WebElement
+from pydoll.events import PageEvents
 from pydoll.exceptions import InvalidFileExtension
 from pydoll.mixins.find_elements import FindElementsMixin
 from pydoll.utils import decode_image_to_bytes
@@ -34,6 +38,7 @@ class Page(FindElementsMixin):  # noqa: PLR0904
         self._network_events_enabled = False
         self._fetch_events_enabled = False
         self._dom_events_enabled = False
+        self._intercept_file_chooser_dialog_enabled = False
 
     @property
     def page_events_enabled(self) -> bool:
@@ -75,6 +80,17 @@ class Page(FindElementsMixin):  # noqa: PLR0904
         """
         return self._dom_events_enabled
 
+    @property
+    def intercept_file_chooser_dialog_enabled(self) -> bool:
+        """
+        Returns whether file chooser dialogs are being intercepted or not.
+
+        Returns:
+            bool: True if file chooser dialogs are being intercepted,
+                False otherwise.
+        """
+        return self._intercept_file_chooser_dialog_enabled
+
     @property
     async def current_url(self) -> str:
         """
@@ -287,7 +303,7 @@ class Page(FindElementsMixin):  # noqa: PLR0904
         Args:
             path (str): The file path to save the PDF file to.
         """
-        response = await self._execute_command(PageCommands.print_to_pdf(path))
+        response = await self._execute_command(PageCommands.print_to_pdf())
         pdf_b64 = response['result']['data'].encode('utf-8')
         pdf_bytes = decode_image_to_bytes(pdf_b64)
         async with aiofiles.open(path, 'wb') as file:
@@ -430,6 +446,22 @@ class Page(FindElementsMixin):  # noqa: PLR0904
         await self._execute_command(DomCommands.enable_dom_events())
         self._dom_events_enabled = True
 
+    async def enable_intercept_file_chooser_dialog(self):
+        """
+        Enable intercepting file chooser dialogs.
+
+        When file chooser interception is enabled, native file chooser dialog
+        is not shown. Instead, a protocol event Page.fileChooserOpened is
+        emitted.
+
+        Returns:
+            None
+        """
+        await self._execute_command(
+            PageCommands.set_intercept_file_chooser_dialog(True)
+        )
+        self._intercept_file_chooser_dialog_enabled = True
+
     async def disable_fetch_events(self):
         """
         Disables fetch events for the page.
@@ -456,6 +488,21 @@ class Page(FindElementsMixin):  # noqa: PLR0904
         await self._execute_command(PageCommands.disable_page())
         self._page_events_enabled = False
 
+    async def disable_intercept_file_chooser_dialog(self):
+        """
+        Disable intercepting file chooser dialogs.
+
+        When file chooser interception is disabled, native file chooser
+        dialog is shown.
+
+        Returns:
+            None
+        """
+        await self._execute_command(
+            PageCommands.set_intercept_file_chooser_dialog(False)
+        )
+        self._intercept_file_chooser_dialog_enabled = False
+
     async def on(
         self, event_name: str, callback: callable, temporary: bool = False
     ):
@@ -554,3 +601,49 @@ class Page(FindElementsMixin):  # noqa: PLR0904
             if asyncio.get_event_loop().time() - start_time > timeout:
                 raise asyncio.TimeoutError('Page load timed out')
             await asyncio.sleep(0.5)
+
+    @asynccontextmanager
+    async def expect_file_chooser(
+        self, files: Union[str, Path, List[Union[str, Path]]]
+    ):
+        """
+        Provide a context manager that expects a file chooser dialog to be
+        opened and handles the file upload. When a file selection signal
+        is captured, the file is uploaded.
+
+        Args:
+            files (Union[str, Path, List[Union[str, Path]]]): The files to be
+                uploaded.
+
+        Returns:
+
+        """
+
+        async def event_handler(event):
+            await self._execute_command(
+                DomCommands.upload_files(
+                    files=files,
+                    backend_node_id=event['params']['backendNodeId'],
+                )
+            )
+
+        if self.page_events_enabled is False:
+            _before_page_events_enabled = False
+            await self.enable_page_events()
+        else:
+            _before_page_events_enabled = True
+
+        if self.intercept_file_chooser_dialog_enabled is False:
+            await self.enable_intercept_file_chooser_dialog()
+
+        await self.on(
+            PageEvents.FILE_CHOOSER_OPENED, event_handler, temporary=True
+        )
+
+        yield
+
+        if self.intercept_file_chooser_dialog_enabled is True:
+            await self.disable_intercept_file_chooser_dialog()
+
+        if _before_page_events_enabled is False:
+            await self.disable_page_events()

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/commands/dom.py

@@ -1,5 +1,6 @@
 import copy
-from typing import Literal
+from pathlib import Path
+from typing import List, Literal, Optional, Union
 
 from pydoll.commands.runtime import RuntimeCommands
 from pydoll.constants import By, Scripts
@@ -43,6 +44,10 @@ class DomCommands:
         'method': 'DOM.scrollIntoViewIfNeeded',
         'params': {},
     }
+    SET_FILE_INPUT_FILES_TEMPLATE = {
+        'method': 'DOM.setFileInputFiles',
+        'params': {},
+    }
 
     @classmethod
     def scroll_into_view(cls, object_id: str) -> dict:
@@ -325,3 +330,68 @@ class DomCommands:
                 to make it relative.
         """
         return f'.{xpath}' if not xpath.startswith('.') else xpath
+
+    @staticmethod
+    def _ensure_file_exists(
+        files: Union[str, Path, List[Union[str, Path]]],
+        missing_ok: bool = False,
+    ) -> List[str]:
+        """
+        Ensures that the file exists.
+
+        Args:
+            files (Union[str, Path, List[Union[str, Path]]]): Files to check.
+            missing_ok (bool): If True, skips the file existence check.
+
+        Returns:
+            List[str]: List of file paths.
+        """
+        if isinstance(files, str):
+            files = [Path(files).absolute()]
+        elif isinstance(files, Path):
+            files = [files]
+
+        _has_ensure_files = []
+        for filepath in files:
+            if isinstance(filepath, str):
+                _filepath = Path(filepath).absolute()
+            else:
+                _filepath = filepath
+            if missing_ok is False and _filepath.is_file() is False:
+                raise FileExistsError(f'{_filepath} does not exist.')
+            _has_ensure_files.append(str(_filepath))
+
+        return _has_ensure_files
+
+    @classmethod
+    def upload_files(
+        cls,
+        files: Union[str, Path, List[Union[str, Path]]],
+        object_id: Optional[str] = None,
+        backend_node_id: Optional[int] = None,
+        missing_ok: bool = False,
+    ) -> dict:
+        """
+        Sets the value of the file input to these file paths or files.
+
+        Args:
+            files (Union[str, Path, List[Union[str, Path]]]): Files to upload.
+            object_id (Optional[str]): JavaScript object id of node wrapper.
+            backend_node_id (Optional[int]): Identifier of the backend node.
+            missing_ok (bool): If True, skips the file existence check.
+
+        Returns:
+            dict: The CDP command to set the file input files.
+        """
+        command = copy.deepcopy(cls.SET_FILE_INPUT_FILES_TEMPLATE)
+        if object_id is None and backend_node_id is None:
+            raise ValueError(
+                'Either object_id or backend_node_id is required.'
+            )
+        if object_id is not None:
+            command['params']['objectId'] = object_id
+        if backend_node_id is not None:
+            command['params']['backendNodeId'] = backend_node_id
+        command['params']['files'] = cls._ensure_file_exists(files, missing_ok)
+
+        return command

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/commands/input.py

@@ -1,3 +1,6 @@
+from pydoll.common.keyboard import Keyboard
+
+
 class InputCommands:
     """
     A class to define input commands for simulating user interactions
@@ -11,6 +14,7 @@ class InputCommands:
     }
     KEY_PRESS_TEMPLATE = {'method': 'Input.dispatchKeyEvent', 'params': {}}
     INSERT_TEXT_TEMPLATE = {'method': 'Input.insertText', 'params': {}}
+    KEYBOARD = Keyboard()
 
     @classmethod
     def mouse_press(cls, x: int, y: int) -> dict:
@@ -104,3 +108,88 @@ class InputCommands:
             'text': text,
         }
         return command
+
+    @classmethod
+    def key_down(cls, key: list | tuple, command_id: int) -> dict:
+        """
+        Generates the command to simulate pressing a key on the keyboard.
+
+        This method creates a command following the Chrome DevTools
+            Protocol (CDP)
+        to simulate a "keyDown" event, which represents pressing a key.
+
+        Args:
+            key (list | tuple): The key and code of the key to be pressed.
+            command_id (int): The id of the command to be sent.
+
+        Returns:
+            dict: A dictionary containing the command to be sent to
+                the browser.
+        """
+        key, key_code = key
+        if key in cls.KEYBOARD.MODIFIER_KEYS:
+            cls.KEYBOARD.modifiers.add(key)
+
+        modifiers = sum(
+            cls.KEYBOARD.MODIFIER_KEYS[k] for k in cls.KEYBOARD.modifiers
+        )
+
+        special_key = cls.KEYBOARD.get_special_key(key, modifiers, key_code)
+        vk_code = cls.KEYBOARD.SHIFT_SPECIAL.get(special_key, key_code)
+        special_code = cls.KEYBOARD.get_special_code(key)
+
+        key_down = {
+            'type': 'keyDown',
+            'key': key,
+            'code': special_code,
+            'windowsVirtualKeyCode': vk_code,
+            'modifiers': modifiers,
+            'text': special_key,
+        }
+
+        command = cls.KEY_PRESS_TEMPLATE.copy()
+        command['id'] = command_id
+        command['params'] = key_down
+        return command
+
+    @classmethod
+    def key_up(cls, key: list | tuple, command_id) -> dict:
+        """
+        Generates the command to simulate releasing a key on the keyboard.
+
+        This method creates a command following the Chrome DevTools
+            Protocol (CDP)
+        to simulate a "keyUp" event, which represents releasing a key.
+
+        Args:
+            key (list | tuple): The character of the key to be released.
+            command_id (int): The id of the command to be sent.
+
+        Returns:
+            dict: A dictionary containing the command to be sent to
+                the browser.
+        """
+        key, key_code = key
+        if key in cls.KEYBOARD.MODIFIER_KEYS:
+            cls.KEYBOARD.modifiers.discard(key)
+
+        modifiers = sum(
+            cls.KEYBOARD.MODIFIER_KEYS[k] for k in cls.KEYBOARD.modifiers
+        )
+
+        special_key = cls.KEYBOARD.SHIFT_MAP.get(key, key)
+        vk_code = cls.KEYBOARD.SHIFT_SPECIAL.get(special_key, key_code)
+        special_code = cls.KEYBOARD.get_special_code(key)
+
+        key_up = {
+            'type': 'keyUp',
+            'key': key,
+            'code': special_code,
+            'windowsVirtualKeyCode': vk_code,
+            'modifiers': modifiers,
+        }
+
+        command = cls.KEY_PRESS_TEMPLATE.copy()
+        command['id'] = command_id
+        command['params'] = key_up
+        return command

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/commands/page.py

@@ -1,3 +1,6 @@
+import copy
+
+
 class PageCommands:
     """
     PageCommands class provides a set of commands to interact with the
@@ -32,6 +35,10 @@ class PageCommands:
     }
     HANDLE_DIALOG = {'method': 'Page.handleJavaScriptDialog', 'params': {}}
     CLOSE = {'method': 'Page.close'}
+    SET_INTERCEPT_FILE_CHOOSER_DIALOG = {
+        'method': 'Page.setInterceptFileChooserDialog',
+        'params': {},
+    }
 
     @classmethod
     def handle_dialog(cls, accept: bool = True) -> dict:
@@ -185,3 +192,19 @@ class PageCommands:
                   containing the method to close the current page.
         """
         return cls.CLOSE
+
+    @classmethod
+    def set_intercept_file_chooser_dialog(cls, enabled: bool) -> dict:
+        """
+        Generates the command to set whether to intercept file chooser dialogs.
+
+        Args:
+            enabled: A boolean value indicating whether to enable or disable
+                the interception of file chooser dialogs.
+
+        Returns:
+
+        """
+        command = copy.deepcopy(cls.SET_INTERCEPT_FILE_CHOOSER_DIALOG)
+        command['params']['enabled'] = enabled
+        return command

pydoll_python-1.4.0/pydoll/common/__init__.py

@@ -0,0 +1 @@
+

pydoll_python-1.4.0/pydoll/common/keyboard.py

@@ -0,0 +1,101 @@
+from pydoll.common.keys import Keys
+
+
+class Keyboard(Keys):
+    MODIFIER_KEYS = {'Alt': 1, 'Control': 2, 'Meta': 4, 'Shift': 8}
+    SHIFT_MAP = {
+        '1': '!',
+        '2': '@',
+        '3': '#',
+        '4': '$',
+        '5': '%',
+        '6': '^',
+        '7': '&',
+        '8': '*',
+        '9': '(',
+        '0': ')',
+        '-': '_',
+        '=': '+',
+        '[': '{',
+        ']': '}',
+        '\\': '|',
+        ';': ':',
+        "'": '"',
+        ',': '<',
+        '.': '>',
+        '/': '?',
+    }
+    SHIFT_CODES = {
+        '\\': 'Backslash',
+        '|': 'Backslash',
+        '[': 'BracketLeft',
+        ']': 'BracketRight',
+        ';': 'Semicolon',
+        ':': 'Semicolon',
+        '/': 'Slash',
+        '?': 'Slash',
+        '.': 'Period',
+        ',': 'Comma',
+        '-': 'Minus',
+        '+': 'Equal',
+        '=': 'Equal',
+    }
+    SHIFT_SPECIAL = {
+        '?': 63,
+        '|': 124,
+        '~': 126,
+        '+': 43,
+        '_': 95,
+        ':': 58,
+        '!': 33,
+        '*': 42,
+        '(': 57,
+        ')': 41,
+        '<': 60,
+        '>': 62,
+        '.': 190,
+    }
+
+    def __init__(self):
+        self.modifiers = set()
+
+    @classmethod
+    def get_special_key(cls, key: str, modifiers: int, key_code: int) -> str:
+        """
+        Return the appropriate text value for special keys
+        like Shift, Enter, Space, etc.
+
+        Args:
+            key (str): The key code of the key to be pressed.
+            modifiers (int): The modifiers code of the key to be pressed.
+            key_code (int): The key code of the key to be pressed.
+        """
+        if key_code in cls.SPACE:
+            return ' '
+        elif key_code in cls.ENTER:
+            return '\r'
+        elif modifiers & 8 and key != 'Shift':
+            return cls.SHIFT_MAP.get(key, key.upper())
+        elif len(key) == 1 and key.isprintable():
+            return key
+
+        return ''
+
+    @classmethod
+    def get_special_code(cls, key) -> str:
+        """
+        Return the appropriate text value for special keys
+        like Shift, Enter, Space, etc.
+
+        Args:
+            key (str): The key code of the special key.
+
+        """
+        code = cls.SHIFT_CODES.get(key, key)
+        key_type = f'Digit{key}' if key.isdigit() else f'Key{key.upper()}'
+        if len(key) == 1:
+            return key_type
+        elif code in cls.MODIFIER_KEYS.keys():
+            return f'{code}Left'
+
+        return code

pydoll_python-1.4.0/pydoll/common/keys.py

@@ -0,0 +1,52 @@
+class Keys:
+    BACKSPACE = ('Backspace', 8)
+    TAB = ('Tab', 9)
+    ENTER = ('Enter', 13)
+    SHIFT = ('Shift', 16)
+    CONTROL = ('Control', 17)
+    ALT = ('Alt', 18)
+    PAUSE = ('Pause', 19)
+    CAPSLOCK = ('CapsLock', 20)
+    ESCAPE = ('Escape', 27)
+    SPACE = ('Space', 32)
+    PAGEUP = ('PageUp', 33)
+    PAGEDOWN = ('PageDown', 34)
+    END = ('End', 35)
+    HOME = ('Home', 36)
+    ARROWLEFT = ('ArrowLeft', 37)
+    ARROWUP = ('ArrowUp', 38)
+    ARROWRIGHT = ('ArrowRight', 39)
+    ARROWDOWN = ('ArrowDown', 40)
+    PRINTSCREEN = ('PrintScreen', 44)
+    INSERT = ('Insert', 45)
+    DELETE = ('Delete', 46)
+    META = ('Meta', 91)
+    METARIGHT = ('MetaRight', 92)
+    CONTEXTMENU = ('ContextMenu', 93)
+    NUMLOCK = ('NumLock', 144)
+    SCROLLLOCK = ('ScrollLock', 145)
+
+    F1 = ('F1', 112)
+    F2 = ('F2', 113)
+    F3 = ('F3', 114)
+    F4 = ('F4', 115)
+    F5 = ('F5', 116)
+    F6 = ('F6', 117)
+    F7 = ('F7', 118)
+    F8 = ('F8', 119)
+    F9 = ('F9', 120)
+    F10 = ('F10', 121)
+    F11 = ('F11', 122)
+    F12 = ('F12', 123)
+
+    SEMICOLON = ('Semicolon', 186)
+    EQUALSIGN = ('EqualSign', 187)
+    COMMA = ('Comma', 188)
+    MINUS = ('Minus', 189)
+    PERIOD = ('Period', 190)
+    SLASH = ('Slash', 191)
+    GRAVEACCENT = ('GraveAccent', 192)
+    BRACKETLEFT = ('BracketLeft', 219)
+    BACKSLASH = ('Backslash', 220)
+    BRACKETRIGHT = ('BracketRight', 221)
+    QUOTE = ('Quote', 222)

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/connection/connection.py

@@ -180,7 +180,10 @@ class ConnectionHandler:
         Closes the WebSocket connection and clears all event callbacks.
         """
         await self.clear_callbacks()
-        await self._ws_connection.close()
+
+        if self._ws_connection is not None:
+            await self._ws_connection.close()
+
         logger.info('WebSocket connection closed.')
 
     async def _ensure_active_connection(self):
@@ -209,7 +212,8 @@ class ConnectionHandler:
         ws_address = await self._resolve_ws_address()
         logger.info(f'Connecting to {ws_address}')
         self._ws_connection = await self._ws_connector(
-            ws_address, max_size=1024 * 1024 * 10  # 10MB
+            ws_address,
+            max_size=1024 * 1024 * 10,  # 10MB
         )
         self._receive_task = asyncio.create_task(self._receive_events())
         logger.debug('WebSocket connection established')

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pydoll/element.py

@@ -1,5 +1,7 @@
 import asyncio
 import json
+from pathlib import Path
+from typing import List, Union
 
 import aiofiles
 from bs4 import BeautifulSoup
@@ -17,7 +19,7 @@ from pydoll.mixins.find_elements import FindElementsMixin
 from pydoll.utils import decode_image_to_bytes
 
 
-class WebElement(FindElementsMixin):
+class WebElement(FindElementsMixin):  # noqa: PLR0904
     """
     Represents a DOM element in the browser.
 
@@ -26,6 +28,7 @@ class WebElement(FindElementsMixin):
     attributes, and other common web element interactions. It inherits element
     finding capabilities from FindElementsMixin.
     """
+
     def __init__(
         self,
         object_id: str,
@@ -53,6 +56,8 @@ class WebElement(FindElementsMixin):
         self._selector = selector
         self._connection_handler = connection_handler
         self._attributes = {}
+        self._last_input = ''
+        self._command_id = 0
         self._def_attributes(attributes_list)
 
     def __repr__(self):
@@ -316,7 +321,12 @@ class WebElement(FindElementsMixin):
                 'Element is not interactable.'
             )
 
-    async def click(self, x_offset: int = 0, y_offset: int = 0):
+    async def click(
+        self,
+        x_offset: int = 0,
+        y_offset: int = 0,
+        hold_time: float = 0.1,
+    ):
         """
         Clicks on the element using mouse events.
 
@@ -329,6 +339,8 @@ class WebElement(FindElementsMixin):
                 Defaults to 0.
             y_offset (int): Vertical offset from the center of the element.
                 Defaults to 0.
+            hold_time (float, optional): The duration (in seconds) to hold
+                the mouse button before releasing.
 
         Raises:
             ElementNotVisible: If the element is not visible on the page.
@@ -363,7 +375,7 @@ class WebElement(FindElementsMixin):
         press_command = InputCommands.mouse_press(*position_to_click)
         release_command = InputCommands.mouse_release(*position_to_click)
         await self._connection_handler.execute_command(press_command)
-        await asyncio.sleep(0.1)
+        await asyncio.sleep(hold_time)
         await self._connection_handler.execute_command(release_command)
 
     async def click_option_tag(self):
@@ -380,7 +392,7 @@ class WebElement(FindElementsMixin):
         script = Scripts.CLICK_OPTION_TAG.replace('{self.value}', self.value)
         await self._execute_command(RuntimeCommands.evaluate_script(script))
 
-    async def send_keys(self, text: str):
+    async def insert_text(self, text: str):
         """
         Sends a sequence of keys to the element.
 
@@ -389,16 +401,94 @@ class WebElement(FindElementsMixin):
         """
         await self._execute_command(InputCommands.insert_text(text))
 
-    async def type_keys(self, text: str):
+    async def set_input_files(
+        self, files: Union[str, Path, List[Union[str, Path]]]
+    ):
+        """
+        Sets the value of the file input to these file paths.
+
+        Args:
+            files (Union[str, Path, List[Union[str, Path]]]): Files to upload.
+        """
+        if (
+            self._attributes.get('tag_name', '').lower() != 'input'
+            or self._attributes.get('type', '').lower() != 'file'
+        ):
+            raise exceptions.ElementNotInteractable(
+                'The element is not a file input.'
+            )
+        await self._execute_command(
+            DomCommands.upload_files(files=files, object_id=self._object_id)
+        )
+
+    async def type_keys(self, text: str, interval: float = 0.1):
         """
         Types in a realistic manner by sending keys one by one.
 
         Args:
             text (str): The text to send to the element.
+            interval (float): The interval between two keys.
         """
         for char in text:
             await self._execute_command(InputCommands.key_press(char))
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(interval)
+
+        self._last_input = text
+
+    async def key_down(self, key: list | tuple):
+        """
+        Simulates pressing down a key.
+
+        Args:
+            key (list|tuple): The key to press.
+        """
+        self._command_id += 1
+        await self._execute_command(
+            InputCommands.key_down(key, self._command_id)
+        )
+
+    async def key_up(self, key: list | tuple):
+        """
+        Simulates releasing a key.
+
+        Args:
+            key (list|tuple): The key to release.
+        """
+        self._command_id += 1
+        await self._execute_command(
+            InputCommands.key_up(key, self._command_id)
+        )
+
+    async def send_keys(self, keys: str | tuple, interval: float = 0.1):
+        """
+        Dispatches an event.
+
+        Args:
+            keys (str | tuple): The event to dispatch.
+            interval (float): The interval between two keys.
+        """
+        if isinstance(keys, str):
+            self._last_input = keys
+            keys = [(char, ord(char.upper())) for char in keys]
+        elif not all(isinstance(k, tuple) for k in keys):
+            keys = [keys]
+
+        for key in keys:
+            await self.key_down(key)
+            await self.key_up(key)
+            await asyncio.sleep(interval)
+
+    async def backspace(self, interval: float = 0.1):
+        """
+        Backspaces the key at the element.
+
+        Args:
+            interval (float): The interval between two keys.
+        """
+        for _ in range(len(self._last_input)):
+            await self.send_keys(('Backspace', 8))
+            await asyncio.sleep(interval)
+            self._last_input = self._last_input[:-1]
 
     def _is_option_tag(self):
         """

{pydoll_python-1.3.3 → pydoll_python-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pydoll-python"
-version = "1.3.3"
+version = "1.4.0"
 description = ""
 authors = ["Thalison Fernandes <thalissfernandes99@gmail.com>"]
 readme = "README.md"