osn-selenium 0.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

osn_selenium/instances/trio_threads/web_driver_wait.py

@@ -0,0 +1,101 @@
+import trio
+from typing import (
+	Callable,
+	Self,
+	TypeVar
+)
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	WebDriverWaitInputType
+)
+from osn_selenium.instances.unified.web_driver_wait import UnifiedWebDriverWait
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+from osn_selenium.abstract.instances.web_driver_wait import (
+	AbstractWebDriverWait
+)
+
+
+__all__ = ["OUTPUT", "WebDriverWait"]
+
+OUTPUT = TypeVar("OUTPUT")
+
+
+class WebDriverWait(UnifiedWebDriverWait, TrioThreadMixin, AbstractWebDriverWait):
+	"""
+	Wrapper for the legacy Selenium WebDriverWait instance.
+
+	Provides conditional waiting functionality, pausing execution until
+	specific conditions (expected conditions) are met or a timeout occurs.
+	"""
+	
+	def __init__(
+			self,
+			selenium_webdriver_wait: legacyWebDriverWait,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the WebDriverWait wrapper.
+
+		Args:
+			selenium_webdriver_wait (legacyWebDriverWait): The legacy Selenium WebDriverWait instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedWebDriverWait.__init__(self, selenium_webdriver_wait=selenium_webdriver_wait)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: legacyWebDriverWait,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates a WebDriverWait wrapper instance from a legacy Selenium object.
+
+		Args:
+			legacy_object (legacyWebDriverWait): The legacy object to convert.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: An instance of the WebDriverWait wrapper.
+
+		Raises:
+			CannotConvertTypeError: If the provided object cannot be converted to legacyWebDriverWait.
+		"""
+		
+		legacy_wait_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_wait_obj, legacyWebDriverWait):
+			raise CannotConvertTypeError(from_=legacyWebDriverWait, to_=legacy_object)
+		
+		return cls(selenium_webdriver_wait=legacy_wait_obj, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyWebDriverWait:
+		return self._legacy_impl
+	
+	async def until(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return await self.sync_to_trio(sync_function=self._until_impl)(method=method, message=message)
+	
+	async def until_not(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return await self.sync_to_trio(sync_function=self._until_not_impl)(method=method, message=message)

osn_selenium/instances/trio_threads/web_element.py

@@ -0,0 +1,217 @@
+import trio
+from selenium.webdriver.common.by import By
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from typing import (
+	Any,
+	Dict,
+	Iterable,
+	List,
+	Optional,
+	Self
+)
+from osn_selenium.instances.trio_threads.shadow_root import ShadowRoot
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.web_element import UnifiedWebElement
+from osn_selenium.abstract.instances.web_element import AbstractWebElement
+from osn_selenium.instances.trio_threads.web_driver_wait import WebDriverWait
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_trio_thread_instance_wrapper
+)
+
+
+__all__ = ["WebElement"]
+
+
+class WebElement(UnifiedWebElement, TrioThreadMixin, AbstractWebElement):
+	"""
+	Represents an HTML element in the DOM, offering methods for interaction (click, type),
+	property retrieval, and finding child elements.
+	"""
+	
+	def __init__(
+			self,
+			selenium_web_element: legacyWebElement,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the WebElement wrapper.
+
+		Args:
+			selenium_web_element (legacyWebElement): The legacy Selenium WebElement instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedWebElement.__init__(self, selenium_web_element=selenium_web_element)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def accessible_name(self) -> str:
+		return await self.sync_to_trio(sync_function=self._accessible_name_impl)()
+	
+	async def aria_role(self) -> str:
+		return await self.sync_to_trio(sync_function=self._aria_role_impl)()
+	
+	async def clear(self) -> None:
+		await self.sync_to_trio(sync_function=self._clear_impl)()
+	
+	async def click(self) -> None:
+		await self.sync_to_trio(sync_function=self._click_impl)()
+	
+	async def find_element(self, by: str = By.ID, value: Any = None) -> Self:
+		web_element = await self.sync_to_trio(sync_function=self._find_element_impl)(by=by, value=value)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=self.__class__,
+				legacy_object=web_element,
+				lock=self._lock,
+				limiter=self._capacity_limiter
+		)
+	
+	async def find_elements(self, by: str = By.ID, value: Any = None) -> List[Self]:
+		web_elements = await self.sync_to_trio(sync_function=self._find_elements_impl)(by=by, value=value)
+		
+		return [
+			get_trio_thread_instance_wrapper(
+					wrapper_class=self.__class__,
+					legacy_object=web_element,
+					lock=self._lock,
+					limiter=self._capacity_limiter,
+			)
+			for web_element in web_elements
+		]
+	
+	async def get_attribute(self, name: str) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._get_attribute_impl)(name=name)
+	
+	async def get_dom_attribute(self, name: str) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._get_dom_attribute_impl)(name=name)
+	
+	async def get_property(self, name: str) -> Any:
+		return await self.sync_to_trio(sync_function=self._get_property_impl)(name=name)
+	
+	async def id(self) -> str:
+		return await self.sync_to_trio(sync_function=self._id_impl)()
+	
+	async def is_displayed(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._is_displayed_impl)()
+	
+	async def is_enabled(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._is_enabled_impl)()
+	
+	async def is_selected(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._is_selected_impl)()
+	
+	@property
+	def legacy(self) -> legacyWebElement:
+		return self._legacy_impl
+	
+	async def location(self) -> Dict:
+		return await self.sync_to_trio(sync_function=self._location_impl)()
+	
+	async def location_once_scrolled_into_view(self) -> Dict:
+		return await self.sync_to_trio(sync_function=self._location_once_scrolled_into_view_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: WEB_ELEMENT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium WebElement object.
+
+		This factory method is used to wrap an existing Selenium WebElement
+		instance into the new interface.
+
+		Args:
+			legacy_object (WEB_ELEMENT_TYPEHINT): The legacy Selenium WebElement instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing WebElement.
+		"""
+		
+		legacy_element_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_element_obj, legacyWebElement):
+			raise CannotConvertTypeError(from_=legacyWebElement, to_=legacy_object)
+		
+		return cls(selenium_web_element=legacy_element_obj, lock=lock, limiter=limiter)
+	
+	async def parent(self) -> Self:
+		parent = await self.sync_to_trio(sync_function=self._parent_impl)()
+		
+		return self.from_legacy(legacy_object=parent, lock=self._lock, limiter=self._capacity_limiter,)
+	
+	async def rect(self) -> Dict:
+		return await self.sync_to_trio(sync_function=self._rect_impl)()
+	
+	async def screenshot(self, filename: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._screenshot_impl)(filename=filename)
+	
+	async def screenshot_as_base64(self) -> str:
+		return await self.sync_to_trio(sync_function=self._screenshot_as_base64_impl)()
+	
+	async def screenshot_as_png(self) -> bytes:
+		return await self.sync_to_trio(sync_function=self._screenshot_as_png_impl)()
+	
+	async def send_keys(self, *value: str) -> None:
+		await self.sync_to_trio(sync_function=self._send_keys_impl)(*value)
+	
+	async def session_id(self) -> str:
+		return await self.sync_to_trio(sync_function=self._session_id_impl)()
+	
+	async def shadow_root(self) -> ShadowRoot:
+		shadow_root = await self.sync_to_trio(sync_function=self._shadow_root_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=ShadowRoot,
+				legacy_object=shadow_root,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def size(self) -> Dict:
+		return await self.sync_to_trio(sync_function=self._size_impl)()
+	
+	async def submit(self) -> None:
+		await self.sync_to_trio(sync_function=self._submit_impl)()
+	
+	async def tag_name(self) -> str:
+		return await self.sync_to_trio(sync_function=self._tag_name_impl)()
+	
+	async def text(self) -> str:
+		return await self.sync_to_trio(sync_function=self._text_impl)()
+	
+	async def value_of_css_property(self, property_name: str) -> str:
+		return await self.sync_to_trio(sync_function=self._value_of_css_property_impl)(property_name=property_name)
+	
+	def web_driver_wait(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> WebDriverWait:
+		web_driver_wait = self._web_driver_wait_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebDriverWait,
+				legacy_object=web_driver_wait,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/web_extension.py

@@ -0,0 +1,99 @@
+import trio
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	Dict,
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	WEB_EXTENSION_TYPEHINT
+)
+from osn_selenium.instances.unified.web_extension import UnifiedWebExtension
+from osn_selenium.abstract.instances.web_extension import AbstractWebExtension
+from selenium.webdriver.common.bidi.webextension import (
+	WebExtension as legacyWebExtension
+)
+
+
+__all__ = ["WebExtension"]
+
+
+class WebExtension(UnifiedWebExtension, TrioThreadMixin, AbstractWebExtension):
+	"""
+	Wrapper for the legacy Selenium WebExtension instance.
+
+	Manages the installation and uninstallation of browser extensions via the
+	WebDriver BiDi protocol.
+	"""
+	
+	def __init__(
+			self,
+			selenium_web_extension: legacyWebExtension,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the WebExtension wrapper.
+
+		Args:
+			selenium_web_extension (legacyWebExtension): The legacy Selenium WebExtension instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedWebExtension.__init__(self, selenium_web_extension=selenium_web_extension)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: WEB_EXTENSION_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium WebExtension object.
+
+		This factory method is used to wrap an existing Selenium WebExtension
+		instance into the new interface.
+
+		Args:
+			legacy_object (WEB_EXTENSION_TYPEHINT): The legacy Selenium WebExtension instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing WebExtension.
+		"""
+		
+		legacy_web_extension_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_web_extension_obj, legacyWebExtension):
+			raise CannotConvertTypeError(from_=legacyWebExtension, to_=legacy_object)
+		
+		return cls(
+				selenium_web_extension=legacy_web_extension_obj,
+				lock=lock,
+				limiter=limiter
+		)
+	
+	async def install(
+			self,
+			path: Optional[str] = None,
+			archive_path: Optional[str] = None,
+			base64_value: Optional[str] = None,
+	) -> Dict:
+		return await self.sync_to_trio(sync_function=self._install_impl)(path=path, archive_path=archive_path, base64_value=base64_value)
+	
+	@property
+	def legacy(self) -> legacyWebExtension:
+		return self._legacy_impl
+	
+	async def uninstall(self, extension_id_or_result: Union[str, Dict]) -> None:
+		await self.sync_to_trio(sync_function=self._uninstall_impl)(extension_id_or_result=extension_id_or_result)

osn_selenium/instances/unified/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/unified/action_chains/__init__.py

@@ -0,0 +1,22 @@
+from osn_selenium.instances.unified.action_chains.click import UnifiedClickMixin
+from osn_selenium.instances.unified.action_chains.hm_move import UnifiedHMMoveMixin
+from osn_selenium.instances.unified.action_chains.hm_scroll import UnifiedHMScrollMixin
+from osn_selenium.instances.unified.action_chains.hm_keyboard import (
+	UnifiedHMKeyboardMixin
+)
+from osn_selenium.instances.unified.action_chains.drag_and_drop import (
+	UnifiedDragAndDropMixin
+)
+
+
+__all__ = ["UnifiedActionChains"]
+
+
+class UnifiedActionChains(
+		UnifiedClickMixin,
+		UnifiedDragAndDropMixin,
+		UnifiedHMKeyboardMixin,
+		UnifiedHMMoveMixin,
+		UnifiedHMScrollMixin,
+):
+	pass

osn_selenium/instances/unified/action_chains/base.py

@@ -0,0 +1,31 @@
+from typing import Any, Callable
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from osn_selenium.executors.unified.javascript import UnifiedJSExecutor
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedBaseMixin"]
+
+
+class UnifiedBaseMixin:
+	def __init__(
+			self,
+			selenium_action_chains: legacyActionChains,
+			execute_js_script_function: Callable[[str, Any], Any]
+	):
+		if not isinstance(selenium_action_chains, legacyActionChains):
+			raise NotExpectedTypeError(
+					expected_type=legacyActionChains,
+					received_instance=selenium_action_chains
+			)
+		
+		self._selenium_action_chains = selenium_action_chains
+		self._execute_js_script_function = execute_js_script_function
+		
+		self._js_executor = UnifiedJSExecutor(execute_function=execute_js_script_function)
+	
+	@property
+	def _legacy_impl(self) -> legacyActionChains:
+		return self._selenium_action_chains

osn_selenium/instances/unified/action_chains/click.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.unified.action_chains.base import UnifiedBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedClickMixin"]
+
+
+class UnifiedClickMixin(UnifiedBaseMixin):
+	def _click_and_hold_impl(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.click_and_hold(on_element=get_legacy_instance(instance=on_element))
+	
+	def _click_impl(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.click(on_element=get_legacy_instance(instance=on_element))
+	
+	def _context_click_impl(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.context_click(on_element=get_legacy_instance(instance=on_element))
+	
+	def _double_click_impl(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.double_click(on_element=get_legacy_instance(instance=on_element))
+	
+	def _release_impl(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.release(on_element=get_legacy_instance(instance=on_element))

osn_selenium/instances/unified/action_chains/drag_and_drop.py

@@ -0,0 +1,24 @@
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.unified.action_chains.base import UnifiedBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedDragAndDropMixin"]
+
+
+class UnifiedDragAndDropMixin(UnifiedBaseMixin):
+	def _drag_and_drop_by_offset_impl(self, source: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> legacyActionChains:
+		return self._legacy_impl.drag_and_drop_by_offset(
+				source=get_legacy_instance(instance=source),
+				xoffset=xoffset,
+				yoffset=yoffset
+		)
+	
+	def _drag_and_drop_impl(self, source: WEB_ELEMENT_TYPEHINT, target: WEB_ELEMENT_TYPEHINT) -> legacyActionChains:
+		return self._legacy_impl.drag_and_drop(
+				source=get_legacy_instance(instance=source),
+				target=get_legacy_instance(instance=target)
+		)

osn_selenium/instances/unified/action_chains/hm_keyboard.py

@@ -0,0 +1,30 @@
+from osn_selenium.instances._functions import text_input_to_parts
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.unified.action_chains.utils import UnifiedUtilsMixin
+from osn_selenium.instances.unified.action_chains.keyboard import UnifiedKeyboardMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedHMKeyboardMixin"]
+
+
+class UnifiedHMKeyboardMixin(UnifiedUtilsMixin, UnifiedKeyboardMixin):
+	def _hm_send_keys_impl(self, text: str) -> legacyActionChains:
+		parts = text_input_to_parts(text=text)
+		
+		for part in parts:
+			self._pause_impl(seconds=part.duration * 0.001)
+			self._send_keys_impl(part.text)
+		
+		return self._legacy_impl
+	
+	def _hm_send_keys_to_element_impl(self, element: WEB_ELEMENT_TYPEHINT, text: str) -> legacyActionChains:
+		parts = text_input_to_parts(text=text)
+		
+		for part in parts:
+			self._pause_impl(seconds=part.duration * 0.001)
+			self._send_keys_to_element_impl(element, part.text)
+		
+		return self._legacy_impl

osn_selenium/instances/unified/action_chains/hm_move.py

@@ -0,0 +1,66 @@
+from typing import Tuple
+from osn_selenium.models import Point
+from osn_selenium.instances._functions import move_to_parts
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.exceptions.instance import (
+	ElementNotVisibleError
+)
+from osn_selenium.instances.unified.web_element import UnifiedWebElement
+from osn_selenium.instances.unified.action_chains.move import UnifiedMoveMixin
+from osn_selenium.instances.unified.action_chains.utils import UnifiedUtilsMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedHMMoveMixin"]
+
+
+class UnifiedHMMoveMixin(UnifiedUtilsMixin, UnifiedMoveMixin):
+	def _hm_move_impl(self, start_position: Point, end_position: Point) -> legacyActionChains:
+		parts = move_to_parts(start_position=start_position, end_position=end_position)
+		
+		for part in parts:
+			self._pause_impl(seconds=part.duration * 0.001)
+			self._move_by_offset_impl(xoffset=part.offset.x, yoffset=part.offset.y)
+		
+		return self._legacy_impl
+	
+	def _hm_move_by_offset_impl(self, start_position: Point, xoffset: int, yoffset: int) -> Tuple[legacyActionChains, Point]:
+		end_position = Point(x=start_position.x + xoffset, y=start_position.y + yoffset)
+		
+		return self._hm_move_impl(start_position=start_position, end_position=end_position), end_position
+	
+	def _hm_move_to_element_impl(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple[legacyActionChains, Point]:
+		element_rect = UnifiedWebElement(selenium_web_element=get_legacy_instance(instance=element))._rect_impl()
+		end_position = Point(
+				x=element_rect["x"] +
+				element_rect["width"] //
+				2,
+				y=element_rect["y"] +
+				element_rect["height"] //
+				2
+		)
+		
+		return self._hm_move_impl(start_position=start_position, end_position=end_position), end_position
+	
+	def _hm_move_to_element_with_offset_impl(
+			self,
+			start_position: Point,
+			element: WEB_ELEMENT_TYPEHINT,
+			xoffset: int,
+			yoffset: int
+	) -> Tuple[legacyActionChains, Point]:
+		element_rect = UnifiedWebElement(selenium_web_element=get_legacy_instance(instance=element))._rect_impl()
+		end_position = Point(x=element_rect["x"] + xoffset, y=element_rect["y"] + yoffset)
+		
+		return self._hm_move_impl(start_position=start_position, end_position=end_position), end_position
+	
+	def _hm_move_to_element_with_random_offset_impl(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple[legacyActionChains, Point]:
+		end_position = self._js_executor._get_random_element_point_impl(element=get_legacy_instance(instance=element))
+		
+		if end_position is None:
+			raise ElementNotVisibleError(element_id=get_legacy_instance(instance=element).id)
+		
+		return self._hm_move_impl(start_position=start_position, end_position=end_position), end_position