pydoll-python 2.18.0__tar.gz → 2.19.0__tar.gz

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoll-python
-Version: 2.18.0
+Version: 2.19.0
 Summary: Pydoll is a library for automating chromium-based browsers without a WebDriver, offering realistic interactions.
 License-File: LICENSE
 Author: Thalison Fernandes
@@ -125,29 +125,28 @@ for sr in shadow_roots:
 </details>
 
 <details>
-<summary><b>Humanized Keyboard Input (<code>humanize=True</code>)</b></summary>
+<summary><b>Humanized Keyboard Input</b></summary>
 <br>
 
-Pydoll now includes a **humanized typing engine** that simulates realistic human typing behavior:
+Pydoll's typing engine simulates realistic human typing behavior out of the box:
 
 - **Variable keystroke timing**: 30-120ms between keys (not fixed intervals)
 - **Realistic typos**: ~2% error rate with automatic correction behavior
-- **No more `interval` parameter**: Just use `humanize=True` for anti-bot evasion
 
 ```python
-# Old way (detectable)
-await element.type_text("hello", interval=0.1)
+# Realistic typing by default
+await element.type_text("hello")
 
-# New way (human-like, anti-bot)
-await element.type_text("hello", humanize=True)
+# Opt out when speed is critical
+await element.type_text("hello", humanize=False)
 ```
 </details>
 
 <details>
-<summary><b>Humanized Scroll with Physics Engine (<code>humanize=True</code>)</b></summary>
+<summary><b>Humanized Scroll with Physics Engine</b></summary>
 <br>
 
-The scroll API now features a **Cubic Bezier curve physics engine** for realistic scrolling:
+The scroll API features a **Cubic Bezier curve physics engine** for realistic scrolling:
 
 - **Momentum & friction**: Natural acceleration and deceleration
 - **Micro-pauses**: Brief stops during long scrolls (simulates reading)
@@ -155,23 +154,52 @@ The scroll API now features a **Cubic Bezier curve physics engine** for realisti
 - **Overshoot correction**: Occasionally scrolls past target and corrects back
 
 ```python
-# Smooth scroll (CSS animation, predictable timing)
-await tab.scroll.by(ScrollPosition.DOWN, 500, smooth=True)
+# Humanized by default (physics engine, anti-bot)
+await tab.scroll.by(ScrollPosition.DOWN, 500)
+await tab.scroll.to_bottom()
 
-# Humanized scroll (physics engine, anti-bot)
-await tab.scroll.by(ScrollPosition.DOWN, 500, humanize=True)
-await tab.scroll.to_bottom(humanize=True)
+# CSS smooth scroll (predictable timing)
+await tab.scroll.by(ScrollPosition.DOWN, 500, humanize=False, smooth=True)
 ```
 
 | Mode | Parameter | Use Case |
 |------|-----------|----------|
-| **Instant** | `smooth=False` | Speed-critical operations |
-| **Smooth** | `smooth=True` | General browsing simulation |
-| **Humanized** | `humanize=True` | **Anti-bot evasion** |
+| **Humanized** | default | **Anti-bot evasion** |
+| **Smooth** | `humanize=False, smooth=True` | General browsing simulation |
+| **Instant** | `humanize=False, smooth=False` | Speed-critical operations |
 
 [**📖 Human-Like Interactions Docs**](https://pydoll.tech/docs/features/automation/human-interactions/)
 </details>
 
+<details>
+<summary><b>Humanized Mouse Movement</b></summary>
+<br>
+
+All mouse operations produce **human-like cursor movement** by default, using a multi-layered simulation pipeline:
+
+- **Bezier curve paths**: Curved trajectories with asymmetric control points
+- **Fitts's Law timing**: Movement duration scales naturally with distance
+- **Minimum-jerk velocity**: Bell-shaped speed profile (slow start, peak, slow end)
+- **Physiological tremor**: Gaussian noise (σ ≈ 1px) scaled inversely with velocity
+- **Overshoot correction**: ~70% chance of overshooting fast movements, then correcting back
+
+```python
+# All operations are humanized by default
+await tab.mouse.move(500, 300)
+await tab.mouse.click(500, 300)
+await tab.mouse.drag(100, 200, 500, 400)
+
+# Element clicks also use realistic Bezier curve movement
+button = await tab.find(id='submit')
+await button.click()
+
+# Opt out when speed matters
+await tab.mouse.click(500, 300, humanize=False)
+```
+
+[**📖 Mouse Control Docs**](https://pydoll.tech/docs/features/automation/mouse-control/)
+</details>
+
 ## 🚀 Getting Started in 60 Seconds
 
 Thanks to its `async` architecture and context managers, Pydoll is clean and efficient.

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/README.md

@@ -105,29 +105,28 @@ for sr in shadow_roots:
 </details>
 
 <details>
-<summary><b>Humanized Keyboard Input (<code>humanize=True</code>)</b></summary>
+<summary><b>Humanized Keyboard Input</b></summary>
 <br>
 
-Pydoll now includes a **humanized typing engine** that simulates realistic human typing behavior:
+Pydoll's typing engine simulates realistic human typing behavior out of the box:
 
 - **Variable keystroke timing**: 30-120ms between keys (not fixed intervals)
 - **Realistic typos**: ~2% error rate with automatic correction behavior
-- **No more `interval` parameter**: Just use `humanize=True` for anti-bot evasion
 
 ```python
-# Old way (detectable)
-await element.type_text("hello", interval=0.1)
+# Realistic typing by default
+await element.type_text("hello")
 
-# New way (human-like, anti-bot)
-await element.type_text("hello", humanize=True)
+# Opt out when speed is critical
+await element.type_text("hello", humanize=False)
 ```
 </details>
 
 <details>
-<summary><b>Humanized Scroll with Physics Engine (<code>humanize=True</code>)</b></summary>
+<summary><b>Humanized Scroll with Physics Engine</b></summary>
 <br>
 
-The scroll API now features a **Cubic Bezier curve physics engine** for realistic scrolling:
+The scroll API features a **Cubic Bezier curve physics engine** for realistic scrolling:
 
 - **Momentum & friction**: Natural acceleration and deceleration
 - **Micro-pauses**: Brief stops during long scrolls (simulates reading)
@@ -135,23 +134,52 @@ The scroll API now features a **Cubic Bezier curve physics engine** for realisti
 - **Overshoot correction**: Occasionally scrolls past target and corrects back
 
 ```python
-# Smooth scroll (CSS animation, predictable timing)
-await tab.scroll.by(ScrollPosition.DOWN, 500, smooth=True)
+# Humanized by default (physics engine, anti-bot)
+await tab.scroll.by(ScrollPosition.DOWN, 500)
+await tab.scroll.to_bottom()
 
-# Humanized scroll (physics engine, anti-bot)
-await tab.scroll.by(ScrollPosition.DOWN, 500, humanize=True)
-await tab.scroll.to_bottom(humanize=True)
+# CSS smooth scroll (predictable timing)
+await tab.scroll.by(ScrollPosition.DOWN, 500, humanize=False, smooth=True)
 ```
 
 | Mode | Parameter | Use Case |
 |------|-----------|----------|
-| **Instant** | `smooth=False` | Speed-critical operations |
-| **Smooth** | `smooth=True` | General browsing simulation |
-| **Humanized** | `humanize=True` | **Anti-bot evasion** |
+| **Humanized** | default | **Anti-bot evasion** |
+| **Smooth** | `humanize=False, smooth=True` | General browsing simulation |
+| **Instant** | `humanize=False, smooth=False` | Speed-critical operations |
 
 [**📖 Human-Like Interactions Docs**](https://pydoll.tech/docs/features/automation/human-interactions/)
 </details>
 
+<details>
+<summary><b>Humanized Mouse Movement</b></summary>
+<br>
+
+All mouse operations produce **human-like cursor movement** by default, using a multi-layered simulation pipeline:
+
+- **Bezier curve paths**: Curved trajectories with asymmetric control points
+- **Fitts's Law timing**: Movement duration scales naturally with distance
+- **Minimum-jerk velocity**: Bell-shaped speed profile (slow start, peak, slow end)
+- **Physiological tremor**: Gaussian noise (σ ≈ 1px) scaled inversely with velocity
+- **Overshoot correction**: ~70% chance of overshooting fast movements, then correcting back
+
+```python
+# All operations are humanized by default
+await tab.mouse.move(500, 300)
+await tab.mouse.click(500, 300)
+await tab.mouse.drag(100, 200, 500, 400)
+
+# Element clicks also use realistic Bezier curve movement
+button = await tab.find(id='submit')
+await button.click()
+
+# Opt out when speed matters
+await tab.mouse.click(500, 300, humanize=False)
+```
+
+[**📖 Mouse Control Docs**](https://pydoll.tech/docs/features/automation/mouse-control/)
+</details>
+
 ## 🚀 Getting Started in 60 Seconds
 
 Thanks to its `async` architecture and context managers, Pydoll is clean and efficient.

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/browser/chromium/base.py

@@ -21,7 +21,9 @@ from pydoll.browser.managers import (
 from pydoll.browser.tab import Tab
 from pydoll.commands import (
     BrowserCommands,
+    EmulationCommands,
     FetchCommands,
+    PageCommands,
     RuntimeCommands,
     StorageCommands,
     TargetCommands,
@@ -38,6 +40,7 @@ from pydoll.exceptions import (
 from pydoll.protocol.browser.types import DownloadBehavior
 from pydoll.protocol.fetch.events import FetchEvent
 from pydoll.protocol.fetch.types import AuthChallengeResponseType
+from pydoll.utils.user_agent_parser import UserAgentParser
 
 if TYPE_CHECKING:
     from tempfile import TemporaryDirectory
@@ -193,6 +196,7 @@ class Browser(ABC):  # noqa: PLR0904
         valid_tab_id = await self._get_valid_tab_id(await self.get_targets())
         tab = Tab(self, target_id=valid_tab_id, connection_port=self._connection_port)
         self._tabs_opened[valid_tab_id] = tab
+        await self._apply_user_agent_override(tab)
         logger.info(f'Initial tab attached: {valid_tab_id}')
         return tab
 
@@ -306,6 +310,7 @@ class Browser(ABC):  # noqa: PLR0904
         target_id = response['result']['targetId']
         tab = Tab(self, **self._get_tab_kwargs(target_id, browser_context_id))
         self._tabs_opened[target_id] = tab
+        await self._apply_user_agent_override(tab)
         await self._setup_context_proxy_auth_for_tab(tab, browser_context_id)
         if url:
             await tab.go_to(url)
@@ -347,10 +352,11 @@ class Browser(ABC):  # noqa: PLR0904
             target_id for target_id in all_target_ids if target_id not in existing_target_ids
         ]
         existing_tabs = [self._tabs_opened[target_id] for target_id in existing_target_ids]
-        new_tabs = [
-            Tab(self, **self._get_tab_kwargs(target_id))
-            for target_id in reversed(remaining_target_ids)
-        ]
+        new_tabs = []
+        for target_id in reversed(remaining_target_ids):
+            tab = Tab(self, **self._get_tab_kwargs(target_id))
+            await self._apply_user_agent_override(tab)
+            new_tabs.append(tab)
         self._tabs_opened.update(dict(zip(remaining_target_ids, new_tabs)))
         logger.debug(
             f'Opened tabs resolved: existing={len(existing_tabs)}, new={len(new_tabs)}',
@@ -358,7 +364,9 @@ class Browser(ABC):  # noqa: PLR0904
         return existing_tabs + new_tabs
 
     async def get_tab_by_target(self, target: TargetInfo) -> Tab:
-        return Tab(self, **self._get_tab_kwargs(target['targetId']))
+        tab = Tab(self, **self._get_tab_kwargs(target['targetId']))
+        await self._apply_user_agent_override(tab)
+        return tab
 
     async def set_download_path(self, path: str, browser_context_id: Optional[str] = None):
         """Set download directory path (convenience method for set_download_behavior)."""
@@ -754,6 +762,43 @@ class Browser(ABC):  # noqa: PLR0904
             temporary=True,
         )
 
+    async def _apply_user_agent_override(self, tab: Tab) -> None:
+        """Apply consistent User-Agent override to a tab if --user-agent= is set.
+
+        Detects the --user-agent= argument in browser options and automatically
+        synchronizes HTTP headers, navigator JS properties, and Client Hints
+        via CDP Emulation.setUserAgentOverride + JS injection.
+        """
+        user_agent = self._get_user_agent_from_options()
+        if not user_agent:
+            return
+
+        parsed = UserAgentParser.parse(user_agent)
+        logger.debug('Applying User-Agent override: %s', user_agent[:60])
+
+        await tab._execute_command(
+            EmulationCommands.set_user_agent_override(
+                user_agent=user_agent,
+                platform=parsed.platform,
+                user_agent_metadata=parsed.user_agent_metadata,
+            )
+        )
+
+        if parsed.navigator_override_js:
+            await tab._execute_command(
+                PageCommands.add_script_to_evaluate_on_new_document(
+                    source=parsed.navigator_override_js,
+                    run_immediately=True,
+                )
+            )
+
+    def _get_user_agent_from_options(self) -> Optional[str]:
+        """Extract User-Agent value from --user-agent= browser argument."""
+        for arg in self.options.arguments:
+            if arg.startswith('--user-agent='):
+                return arg[len('--user-agent=') :]
+        return None
+
     async def _verify_browser_running(self):
         """
         Verify browser started successfully.

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/browser/options.py

@@ -29,6 +29,7 @@ class ChromiumOptions(Options):
         self._start_timeout = 10
         self._browser_preferences = {}
         self._headless = False
+        self._webrtc_leak_protection = False
         self._page_load_state = PageLoadState.COMPLETE
 
     @property
@@ -319,6 +320,20 @@ class ChromiumOptions(Options):
             return
         methods_map[headless]('--headless')
 
+    @property
+    def webrtc_leak_protection(self) -> bool:
+        return self._webrtc_leak_protection
+
+    @webrtc_leak_protection.setter
+    def webrtc_leak_protection(self, enabled: bool):
+        self._webrtc_leak_protection = enabled
+        argument = '--force-webrtc-ip-handling-policy=disable_non_proxied_udp'
+        has_argument = argument in self.arguments
+        methods_map = {True: self.add_argument, False: self.remove_argument}
+        if enabled == has_argument:
+            return
+        methods_map[enabled](argument)
+
     @property
     def page_load_state(self) -> PageLoadState:
         return self._page_load_state

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/browser/tab.py

@@ -56,7 +56,7 @@ from pydoll.exceptions import (
     WaitElementTimeout,
     WebSocketConnectionClosed,
 )
-from pydoll.interactions import KeyboardAPI, ScrollAPI
+from pydoll.interactions import KeyboardAPI, MouseAPI, ScrollAPI
 from pydoll.interactions.iframe import IFrameContext
 from pydoll.protocol.browser.types import DownloadBehavior, DownloadProgressState
 from pydoll.protocol.dom.types import Node, ShadowRootType
@@ -160,6 +160,7 @@ class Tab(FindElementsMixin):
         self._request: Optional[Request] = None
         self._scroll: Optional[ScrollAPI] = None
         self._keyboard: Optional[KeyboardAPI] = None
+        self._mouse: MouseAPI = MouseAPI(self)
         logger.debug(
             (
                 f'Tab initialized: target_id={self._target_id}, '
@@ -229,6 +230,16 @@ class Tab(FindElementsMixin):
             self._keyboard = KeyboardAPI(self)
         return self._keyboard
 
+    @property
+    def mouse(self) -> MouseAPI:
+        """
+        Get the mouse API for controlling mouse input.
+
+        Returns:
+            MouseAPI: An instance of the MouseAPI class for mouse operations.
+        """
+        return self._mouse
+
     @property
     def intercept_file_chooser_dialog_enabled(self) -> bool:
         """Whether file chooser dialog interception is active."""
@@ -605,7 +616,9 @@ class Tab(FindElementsMixin):
         )
         host_object_id = host_response['result']['object']['objectId']
         host_attrs = await self._get_object_attributes(object_id=host_object_id)
-        return WebElement(host_object_id, self._connection_handler, attributes_list=host_attrs)
+        return WebElement(
+            host_object_id, self._connection_handler, attributes_list=host_attrs, mouse=self._mouse
+        )
 
     async def _collect_oopif_shadow_roots(self) -> list[ShadowRoot]:
         """Discover shadow roots inside cross-origin iframes (OOPIFs)."""
@@ -748,7 +761,12 @@ class Tab(FindElementsMixin):
             tag_name = node_info.get('nodeName', '').lower()
             attributes.extend(['tag_name', tag_name])
 
-            return WebElement(host_object_id, self._connection_handler, attributes_list=attributes)
+            return WebElement(
+                host_object_id,
+                self._connection_handler,
+                attributes_list=attributes,
+                mouse=self._mouse,
+            )
         except (CommandExecutionTimeout, WebSocketConnectionClosed, KeyError):
             logger.debug(f'Failed to resolve OOPIF shadow host: backend_node_id={host_backend_id}')
             return None

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/commands/__init__.py

@@ -1,6 +1,7 @@
 # global imports
 from pydoll.commands.browser_commands import BrowserCommands
 from pydoll.commands.dom_commands import DomCommands
+from pydoll.commands.emulation_commands import EmulationCommands
 from pydoll.commands.fetch_commands import FetchCommands
 from pydoll.commands.input_commands import InputCommands
 from pydoll.commands.network_commands import NetworkCommands
@@ -11,6 +12,7 @@ from pydoll.commands.target_commands import TargetCommands
 
 __all__ = [
     'DomCommands',
+    'EmulationCommands',
     'FetchCommands',
     'InputCommands',
     'NetworkCommands',

pydoll_python-2.19.0/pydoll/commands/emulation_commands.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from pydoll.protocol.base import Command
+from pydoll.protocol.emulation.methods import (
+    EmulationMethod,
+    SetUserAgentOverrideParams,
+)
+
+if TYPE_CHECKING:
+    from pydoll.protocol.emulation.methods import SetUserAgentOverrideCommand
+    from pydoll.protocol.emulation.types import UserAgentMetadata
+
+
+class EmulationCommands:
+    """
+    Implementation of Chrome DevTools Protocol for the Emulation domain.
+
+    This class provides commands for emulating different environments,
+    including user agent overrides, device metrics, and other browser
+    characteristics useful for testing and automation.
+
+    See https://chromedevtools.github.io/devtools-protocol/tot/Emulation/
+    """
+
+    @staticmethod
+    def set_user_agent_override(
+        user_agent: str,
+        accept_language: Optional[str] = None,
+        platform: Optional[str] = None,
+        user_agent_metadata: Optional[UserAgentMetadata] = None,
+    ) -> SetUserAgentOverrideCommand:
+        """
+        Overrides the browser's User-Agent string via the Emulation domain.
+
+        This is the canonical CDP method for User-Agent override. It modifies
+        both HTTP headers and navigator JavaScript properties, ensuring
+        consistency between all layers.
+
+        When userAgentMetadata is provided, Client Hint headers (Sec-CH-UA-*)
+        will also be sent consistently with the overridden User-Agent.
+
+        Args:
+            user_agent: Complete User-Agent string to use.
+            accept_language: Browser language preference (e.g., 'en-US,en;q=0.9').
+            platform: Value for navigator.platform (e.g., 'Win32', 'MacIntel').
+            user_agent_metadata: Client Hints metadata for Sec-CH-UA-* headers
+                and navigator.userAgentData.
+
+        Returns:
+            SetUserAgentOverrideCommand: CDP command to override user agent.
+        """
+        params = SetUserAgentOverrideParams(userAgent=user_agent)
+        if accept_language is not None:
+            params['acceptLanguage'] = accept_language
+        if platform is not None:
+            params['platform'] = platform
+        if user_agent_metadata is not None:
+            params['userAgentMetadata'] = user_agent_metadata
+        return Command(method=EmulationMethod.SET_USER_AGENT_OVERRIDE, params=params)

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/elements/mixins/find_elements_mixin.py

@@ -496,7 +496,14 @@ class FindElementsMixin:
         object_id = response_for_command['result']['result']['objectId']
         attributes = await self._get_object_attributes(object_id=object_id)
         logger.debug(f'_find_element() found object_id={object_id}')
-        element = create_web_element(object_id, self._connection_handler, by, value, attributes)
+        element = create_web_element(
+            object_id,
+            self._connection_handler,
+            by,
+            value,
+            attributes,
+            mouse=getattr(self, '_mouse', None),
+        )
         self._apply_iframe_context_to_element(
             element, iframe_context or getattr(self, '_iframe_context', None)
         )
@@ -571,7 +578,14 @@ class FindElementsMixin:
             tag_name = node_description.get('nodeName', '').lower()
             attributes.extend(['tag_name', tag_name])
 
-            child = create_web_element(object_id, self._connection_handler, by, value, attributes)
+            child = create_web_element(
+                object_id,
+                self._connection_handler,
+                by,
+                value,
+                attributes,
+                mouse=getattr(self, '_mouse', None),
+            )
             self._apply_iframe_context_to_element(child, inherited_context)
             elements.append(child)
         logger.debug(f'_find_elements() returning {len(elements)} elements')

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/elements/web_element.py

@@ -57,6 +57,7 @@ from pydoll.utils import (
 )
 
 if TYPE_CHECKING:
+    from pydoll.interactions.mouse import Mouse as MouseType
     from pydoll.protocol.dom.methods import (
         DescribeNodeResponse,
         GetBoxModelResponse,
@@ -90,6 +91,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         method: Optional[str] = None,
         selector: Optional[str] = None,
         attributes_list: list[str] = [],
+        mouse: Optional['MouseType'] = None,
     ):
         """
         Initialize WebElement wrapper.
@@ -100,6 +102,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
             method: Search method used to find this element (for debugging).
             selector: Selector string used to find this element (for debugging).
             attributes_list: Flat list of alternating attribute names and values.
+            mouse: Optional Mouse instance for humanized click behavior.
         """
         self._object_id = object_id
         self._search_method = method
@@ -107,6 +110,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         self._connection_handler = connection_handler
         self._attributes: dict[str, str] = {}
         self._keyboard: Optional[Keyboard] = None
+        self._mouse = mouse
         self._iframe_context: Optional[IFrameContext] = None
         self._iframe_resolver: Optional[IFrameContextResolver] = None
         self._def_attributes(attributes_list)
@@ -264,7 +268,9 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         object_id = result['result']['result']['objectId']
         attributes = await self._get_object_attributes(object_id=object_id)
         logger.debug(f'Parent element resolved: object_id={object_id}')
-        return WebElement(object_id, self._connection_handler, attributes_list=attributes)
+        return WebElement(
+            object_id, self._connection_handler, attributes_list=attributes, mouse=self._mouse
+        )
 
     async def get_shadow_root(self, timeout: float = 0) -> ShadowRoot:
         """
@@ -544,6 +550,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         x_offset: int = 0,
         y_offset: int = 0,
         hold_time: float = 0.1,
+        humanize: bool = True,
     ):
         """
         Click element using simulated mouse events.
@@ -551,7 +558,11 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         Args:
             x_offset: Horizontal offset from element center.
             y_offset: Vertical offset from element center.
-            hold_time: Duration to hold mouse button down.
+            hold_time: Duration to hold mouse button down (used when humanize=False).
+            humanize: When True and a Mouse instance is available, uses humanized
+                Bezier curve movement from the current tracked position to the
+                element center before clicking. When False, dispatches raw CDP
+                mousePressed/mouseReleased events directly.
 
         Raises:
             ElementNotVisible: If element is not visible.
@@ -578,14 +589,21 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
         except KeyError:
             element_bounds_js = await self.get_bounds_using_js()
             position_to_click = (
-                element_bounds_js['x'] + element_bounds_js['width'] / 2,
-                element_bounds_js['y'] + element_bounds_js['height'] / 2,
+                element_bounds_js['x'] + element_bounds_js['width'] / 2 + x_offset,
+                element_bounds_js['y'] + element_bounds_js['height'] / 2 + y_offset,
+            )
+
+        if humanize and self._mouse is not None:
+            logger.info(
+                f'Clicking element (humanized): x={position_to_click[0]}, y={position_to_click[1]}'
             )
+            await self._mouse.click(position_to_click[0], position_to_click[1])
+            return
+
         logger.info(
             f'Clicking element: x={position_to_click[0]}, '
             f'y={position_to_click[1]}, hold={hold_time}s'
         )
-
         press_command = InputCommands.dispatch_mouse_event(
             type=MouseEventType.MOUSE_PRESSED,
             x=int(position_to_click[0]),
@@ -681,7 +699,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
     async def type_text(
         self,
         text: str,
-        humanize: bool = False,
+        humanize: bool = True,
         interval: Optional[float] = None,
     ):
         """
@@ -689,7 +707,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
 
         Args:
             text: Text to type into the element.
-            humanize: When True, simulates human-like typing.
+            humanize: When True (default), simulates human-like typing.
             interval: Deprecated. Use humanize=True instead.
         """
         logger.info(f'Typing text (length={len(text)}, humanize={humanize})')
@@ -964,7 +982,12 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
             child_object_id = prop['value']['objectId']
             attributes = await self._get_object_attributes(object_id=child_object_id)
             family_elements.append(
-                WebElement(child_object_id, self._connection_handler, attributes_list=attributes)
+                WebElement(
+                    child_object_id,
+                    self._connection_handler,
+                    attributes_list=attributes,
+                    mouse=self._mouse,
+                )
             )
 
         logger.debug(f'Family elements found: {len(family_elements)}')

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/interactions/__init__.py

@@ -7,6 +7,7 @@ from pydoll.interactions.keyboard import (
     TypoConfig,
     TypoResult,
 )
+from pydoll.interactions.mouse import Mouse, MouseAPI, MouseTimingConfig
 from pydoll.interactions.scroll import Scroll, ScrollAPI, ScrollTimingConfig
 
 __all__ = [
@@ -15,6 +16,9 @@ __all__ = [
     'IFrameContextResolver',
     'Keyboard',
     'KeyboardAPI',
+    'Mouse',
+    'MouseAPI',
+    'MouseTimingConfig',
     'Scroll',
     'ScrollAPI',
     'ScrollTimingConfig',

{pydoll_python-2.18.0 → pydoll_python-2.19.0}/pydoll/interactions/keyboard.py

@@ -184,7 +184,7 @@ class Keyboard:
     async def type_text(
         self,
         text: str,
-        humanize: bool = False,
+        humanize: bool = True,
         interval: Optional[float] = None,
     ):
         """
@@ -192,13 +192,13 @@ class Keyboard:
 
         Args:
             text: Text to type.
-            humanize: When True, simulates human-like typing with
+            humanize: When True (default), simulates human-like typing with
                 variable delays and occasional typos (~2%).
             interval: Deprecated. Use humanize=True instead.
 
         Example:
             await tab.keyboard.type_text("Hello World")
-            await tab.keyboard.type_text("Hello World", humanize=True)
+            await tab.keyboard.type_text("Hello World", humanize=False)
         """
         if interval is not None:
             warnings.warn(