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

osn_selenium/instances/trio_threads/action_chains/base.py

@@ -0,0 +1,88 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	TYPE_CHECKING,
+	cast
+)
+from osn_selenium.instances.unified.action_chains.base import UnifiedBaseMixin
+from osn_selenium.abstract.instances.action_chains.base import AbstractBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["BaseMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class BaseMixin(UnifiedBaseMixin, TrioThreadMixin, AbstractBaseMixin):
+	"""
+	Base mixin class that bridges legacy Selenium actions with unified execution logic.
+	"""
+	
+	def __init__(
+			self,
+			selenium_action_chains: legacyActionChains,
+			execute_js_script_function: Callable[[str, Any], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	):
+		"""
+		Initializes an ActionChains instance from a legacy Selenium ActionChains object.
+
+		Args:
+			selenium_action_chains (legacyActionChains): The legacy Selenium action chain.
+			execute_js_script_function (Callable[[str, Any], Any]): The function used to execute JS.
+			lock (trio.Lock): A Trio Lock for synchronization.
+			limiter (trio.CapacityLimiter): A limiter to control thread pool concurrency.
+
+		Returns:
+			"ActionChains": The ActionChains instance.
+		"""
+		
+		UnifiedBaseMixin.__init__(
+				self,
+				selenium_action_chains=selenium_action_chains,
+				execute_js_script_function=execute_js_script_function,
+		)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: legacyActionChains,
+			execute_js_script_function: Callable[[str, Any], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> "ActionChains":
+		"""
+		Creates an ActionChains instance from a legacy Selenium ActionChains object.
+
+		Args:
+			legacy_object (legacyActionChains): The legacy Selenium action chain.
+			execute_js_script_function (Callable[[str, Any], Any]): The function used to execute JS.
+			lock (trio.Lock): A Trio Lock for synchronization.
+			limiter (trio.CapacityLimiter): A limiter to control thread pool concurrency.
+
+		Returns:
+			"ActionChains": The ActionChains instance.
+		"""
+		
+		return cast(
+				"ActionChains",
+				cls(
+						selenium_action_chains=legacy_object,
+						execute_js_script_function=execute_js_script_function,
+						lock=lock,
+						limiter=limiter,
+				)
+		)
+	
+	@property
+	def legacy(self) -> legacyActionChains:
+		return self._legacy_impl

osn_selenium/instances/trio_threads/action_chains/click.py

@@ -0,0 +1,71 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.click import UnifiedClickMixin
+from osn_selenium.abstract.instances.action_chains.click import AbstractClickMixin
+
+
+__all__ = ["ClickMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class ClickMixin(BaseMixin, UnifiedClickMixin, AbstractClickMixin):
+	"""
+	Mixin class providing mouse click interaction methods.
+	"""
+	
+	async def click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._click_impl)(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def click_and_hold(self, on_element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._click_and_hold_impl)(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def context_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._context_click_impl)(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def double_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._double_click_impl)(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def release(self, on_element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._release_impl)(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/drag_and_drop.py

@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.drag_and_drop import (
+	UnifiedDragAndDropMixin
+)
+from osn_selenium.abstract.instances.action_chains.drag_and_drop import (
+	AbstractDragAndDropMixin
+)
+
+
+__all__ = ["DragAndDropMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class DragAndDropMixin(BaseMixin, UnifiedDragAndDropMixin, AbstractDragAndDropMixin):
+	"""
+	Mixin class providing drag and drop interaction methods.
+	"""
+	
+	async def drag_and_drop(self, source: WEB_ELEMENT_TYPEHINT, target: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._drag_and_drop_impl)(
+				source=get_legacy_instance(instance=source),
+				target=get_legacy_instance(instance=target)
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def drag_and_drop_by_offset(self, source: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._drag_and_drop_by_offset_impl)(
+				source=get_legacy_instance(instance=source),
+				xoffset=xoffset,
+				yoffset=yoffset
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/hm_keyboard.py

@@ -0,0 +1,41 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.hm_keyboard import (
+	UnifiedHMKeyboardMixin
+)
+from osn_selenium.abstract.instances.action_chains.hm_keyboard import (
+	AbstractHMKeyboardMixin
+)
+
+
+__all__ = ["HMKeyboardMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class HMKeyboardMixin(BaseMixin, UnifiedHMKeyboardMixin, AbstractHMKeyboardMixin):
+	"""
+	Mixin class providing human-like keyboard interaction methods.
+	"""
+	
+	async def hm_send_keys(self, text: str) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_send_keys_impl)(text=text)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def hm_send_keys_to_element(self, element: WEB_ELEMENT_TYPEHINT, text: str) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_send_keys_to_element_impl)(element=element, text=text)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/hm_move.py

@@ -0,0 +1,91 @@
+from osn_selenium.models import Point
+from typing import TYPE_CHECKING, Tuple
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.hm_move import UnifiedHMMoveMixin
+from osn_selenium.abstract.instances.action_chains.hm_move import AbstractHMMoveMixin
+
+
+__all__ = ["HMMoveMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class HMMoveMixin(BaseMixin, UnifiedHMMoveMixin, AbstractHMMoveMixin):
+	"""
+	Mixin class providing human-like mouse movement interaction methods.
+	"""
+	
+	async def hm_move(self, start_position: Point, end_position: Point) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_move_impl)(start_position=start_position, end_position=end_position)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def hm_move_by_offset(self, start_position: Point, xoffset: int, yoffset: int) -> Tuple["ActionChains", Point]:
+		action_chains, point = await self.sync_to_trio(sync_function=self._hm_move_by_offset_impl)(start_position=start_position, xoffset=xoffset, yoffset=yoffset)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+						lock=self._lock,
+						limiter=self._capacity_limiter,
+				),
+				point,
+		)
+	
+	async def hm_move_to_element(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["ActionChains", Point]:
+		action_chains, point = await self.sync_to_trio(sync_function=self._hm_move_to_element_impl)(start_position=start_position, element=element)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+						lock=self._lock,
+						limiter=self._capacity_limiter,
+				),
+				point,
+		)
+	
+	async def hm_move_to_element_with_offset(
+			self,
+			start_position: Point,
+			element: WEB_ELEMENT_TYPEHINT,
+			xoffset: int,
+			yoffset: int
+	) -> Tuple["ActionChains", Point]:
+		action_chains, point = await self.sync_to_trio(sync_function=self._hm_move_to_element_with_offset_impl)(
+				start_position=start_position,
+				element=element,
+				xoffset=xoffset,
+				yoffset=yoffset,
+		)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+						lock=self._lock,
+						limiter=self._capacity_limiter,
+				),
+				point,
+		)
+	
+	async def hm_move_to_element_with_random_offset(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["ActionChains", Point]:
+		action_chains, point = await self.sync_to_trio(sync_function=self._hm_move_to_element_with_random_offset_impl)(start_position=start_position, element=element)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+						lock=self._lock,
+						limiter=self._capacity_limiter,
+				),
+				point,
+		)

osn_selenium/instances/trio_threads/action_chains/hm_scroll.py

@@ -0,0 +1,66 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.hm_scroll import UnifiedHMScrollMixin
+from osn_selenium.abstract.instances.action_chains.hm_scroll import (
+	AbstractHMScrollMixin
+)
+
+
+__all__ = ["HMScrollMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class HMScrollMixin(BaseMixin, UnifiedHMScrollMixin, AbstractHMScrollMixin):
+	"""
+	Mixin class providing human-like scroll interaction methods.
+	"""
+	
+	async def hm_scroll_by_amount(self, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_scroll_by_amount_impl)(delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def hm_scroll_from_origin(self, delta_x: int, delta_y: int, origin: Optional[ScrollOrigin] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_scroll_from_origin_impl)(delta_x=delta_x, delta_y=delta_y, origin=origin)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def hm_scroll_to_element(
+			self,
+			element: WEB_ELEMENT_TYPEHINT,
+			additional_lower_y_offset: int = 0,
+			additional_upper_y_offset: int = 0,
+			additional_right_x_offset: int = 0,
+			additional_left_x_offset: int = 0,
+	) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._hm_scroll_to_element_impl)(
+				element=element,
+				additional_lower_y_offset=additional_lower_y_offset,
+				additional_upper_y_offset=additional_upper_y_offset,
+				additional_right_x_offset=additional_right_x_offset,
+				additional_left_x_offset=additional_left_x_offset,
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/keyboard.py

@@ -0,0 +1,63 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.keyboard import UnifiedKeyboardMixin
+from osn_selenium.abstract.instances.action_chains.keyboard import (
+	AbstractKeyboardMixin
+)
+
+
+__all__ = ["KeyboardMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class KeyboardMixin(BaseMixin, UnifiedKeyboardMixin, AbstractKeyboardMixin):
+	"""
+	Mixin class providing keyboard interaction methods.
+	"""
+	
+	async def key_down(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._key_down_impl)(value=value, element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def key_up(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT] = None) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._key_up_impl)(value=value, element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def send_keys(self, *keys_to_send: str) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._send_keys_impl)(*keys_to_send)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def send_keys_to_element(self, element: WEB_ELEMENT_TYPEHINT, *keys_to_send: str) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._send_keys_to_element_impl)(get_legacy_instance(instance=element), *keys_to_send)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/move.py

@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.move import UnifiedMoveMixin
+from osn_selenium.abstract.instances.action_chains.move import AbstractMoveMixin
+
+
+__all__ = ["MoveMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class MoveMixin(BaseMixin, UnifiedMoveMixin, AbstractMoveMixin):
+	"""
+	Mixin class providing mouse movement interaction methods.
+	"""
+	
+	async def move_by_offset(self, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._move_by_offset_impl)(xoffset=xoffset, yoffset=yoffset)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def move_to_element(self, to_element: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._move_to_element_impl)(to_element=get_legacy_instance(instance=to_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def move_to_element_with_offset(self, to_element: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._move_to_element_with_offset_impl)(
+				to_element=get_legacy_instance(instance=to_element),
+				xoffset=xoffset,
+				yoffset=yoffset,
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/scroll.py

@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.scroll import UnifiedScrollMixin
+from osn_selenium.abstract.instances.action_chains.scroll import AbstractScrollMixin
+
+
+__all__ = ["ScrollMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class ScrollMixin(BaseMixin, UnifiedScrollMixin, AbstractScrollMixin):
+	"""
+	Mixin class providing scroll and wheel interaction methods.
+	"""
+	
+	async def scroll_by_amount(self, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._scroll_by_amount_impl)(delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def scroll_from_origin(self, scroll_origin: ScrollOrigin, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._scroll_from_origin_impl)(scroll_origin=scroll_origin, delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def scroll_to_element(self, element: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._scroll_to_element_impl)(element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/instances/trio_threads/action_chains/utils.py

@@ -0,0 +1,32 @@
+from typing import TYPE_CHECKING, Union
+from osn_selenium.instances.trio_threads.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.utils import UnifiedUtilsMixin
+from osn_selenium.abstract.instances.action_chains.utils import AbstractUtilsMixin
+
+
+__all__ = ["UtilsMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.action_chains import ActionChains
+
+
+class UtilsMixin(BaseMixin, UnifiedUtilsMixin, AbstractUtilsMixin):
+	"""
+	Mixin class providing utility methods for action chains.
+	"""
+	
+	async def pause(self, seconds: Union[float, int]) -> "ActionChains":
+		action_chains = await self.sync_to_trio(sync_function=self._pause_impl)(seconds=seconds)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def perform(self) -> None:
+		await self.sync_to_trio(sync_function=self._perform_impl)()
+	
+	async def reset_actions(self) -> None:
+		await self.sync_to_trio(sync_function=self._reset_actions_impl)()