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

osn_selenium/instances/_typehints.py

@@ -0,0 +1,148 @@
+from typing import Union
+from osn_selenium.abstract.instances.alert import AbstractAlert
+from osn_selenium.abstract.instances.fedcm import AbstractFedCM
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from selenium.webdriver.remote.fedcm import FedCM as legacyFedCM
+from osn_selenium.abstract.instances.dialog import AbstractDialog
+from osn_selenium.abstract.instances.mobile import AbstractMobile
+from osn_selenium.abstract.instances.script import AbstractScript
+from osn_selenium.abstract.instances.browser import AbstractBrowser
+from osn_selenium.abstract.instances.network import AbstractNetwork
+from osn_selenium.abstract.instances.storage import AbstractStorage
+from osn_selenium.abstract.instances.switch_to import AbstractSwitchTo
+from selenium.webdriver.remote.mobile import (
+	Mobile as legacyMobile
+)
+from osn_selenium.abstract.instances.shadow_root import AbstractShadowRoot
+from osn_selenium.abstract.instances.web_element import AbstractWebElement
+from osn_selenium.abstract.instances.permissions import AbstractPermissions
+from selenium.webdriver.common.bidi.script import (
+	Script as legacyScript
+)
+from selenium.webdriver.common.fedcm.dialog import (
+	Dialog as legacyDialog
+)
+from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+from osn_selenium.abstract.instances.web_extension import AbstractWebExtension
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from selenium.webdriver.common.bidi.browser import (
+	Browser as legacyBrowser
+)
+from selenium.webdriver.common.bidi.network import (
+	Network as legacyNetwork
+)
+from selenium.webdriver.common.bidi.storage import (
+	Storage as legacyStorage
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+from osn_selenium.abstract.instances.web_driver_wait import (
+	AbstractWebDriverWait
+)
+from osn_selenium.abstract.instances.browsing_context import (
+	AbstractBrowsingContext
+)
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+from selenium.webdriver.common.bidi.permissions import (
+	Permissions as legacyPermissions
+)
+from selenium.webdriver.common.bidi.webextension import (
+	WebExtension as legacyWebExtension
+)
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext
+)
+
+
+__all__ = [
+	"ACTION_CHAINS_TYPEHINT",
+	"ALERT_TYPEHINT",
+	"ANY_ABSTRACT_INSTANCE_TYPEHINT",
+	"ANY_LEGACY_INSTANCE_TYPEHINT",
+	"BROWSER_TYPEHINT",
+	"BROWSING_CONTEXT_TYPEHINT",
+	"DIALOG_TYPEHINT",
+	"FEDCM_TYPEHINT",
+	"MOBILE_TYPEHINT",
+	"NETWORK_TYPEHINT",
+	"PERMISSIONS_TYPEHINT",
+	"SCRIPT_TYPEHINT",
+	"SHADOW_ROOT_TYPEHINT",
+	"STORAGE_TYPEHINT",
+	"SWITCH_TO_TYPEHINT",
+	"WEB_DRIVER_WAIT_TYPEHINT",
+	"WEB_ELEMENT_TYPEHINT",
+	"WEB_EXTENSION_TYPEHINT",
+	"WebDriverWaitInputType"
+]
+
+ACTION_CHAINS_TYPEHINT = Union[AbstractActionChains, legacyActionChains]
+ALERT_TYPEHINT = Union[AbstractAlert, legacyAlert]
+BROWSER_TYPEHINT = Union[AbstractBrowser, legacyBrowser]
+BROWSING_CONTEXT_TYPEHINT = Union[AbstractBrowsingContext, legacyBrowsingContext]
+DIALOG_TYPEHINT = Union[AbstractDialog, legacyDialog]
+FEDCM_TYPEHINT = Union[AbstractFedCM, legacyFedCM]
+MOBILE_TYPEHINT = Union[AbstractMobile, legacyMobile]
+NETWORK_TYPEHINT = Union[AbstractNetwork, legacyNetwork]
+PERMISSIONS_TYPEHINT = Union[AbstractPermissions, legacyPermissions]
+SCRIPT_TYPEHINT = Union[AbstractScript, legacyScript]
+SHADOW_ROOT_TYPEHINT = Union[AbstractShadowRoot, legacyShadowRoot]
+STORAGE_TYPEHINT = Union[AbstractStorage, legacyStorage]
+SWITCH_TO_TYPEHINT = Union[AbstractSwitchTo, legacySwitchTo]
+WEB_DRIVER_WAIT_TYPEHINT = Union[AbstractWebDriverWait, legacyWebDriverWait]
+WEB_ELEMENT_TYPEHINT = Union[AbstractWebElement, legacyWebElement]
+WEB_EXTENSION_TYPEHINT = Union[AbstractWebExtension, legacyWebExtension]
+
+ANY_ABSTRACT_INSTANCE_TYPEHINT = Union[
+	AbstractAlert,
+	AbstractFedCM,
+	AbstractWebElement,
+	AbstractActionChains,
+	AbstractBrowser,
+	AbstractBrowsingContext,
+	AbstractDialog,
+	AbstractMobile,
+	AbstractNetwork,
+	AbstractStorage,
+	AbstractSwitchTo,
+	AbstractScript,
+	AbstractShadowRoot,
+	AbstractPermissions,
+	AbstractWebExtension,
+	AbstractWebDriverWait,
+]
+
+ANY_LEGACY_INSTANCE_TYPEHINT = Union[
+	legacyAlert,
+	legacyFedCM,
+	legacyWebElement,
+	legacyActionChains,
+	legacyBrowser,
+	legacyBrowsingContext,
+	legacyDialog,
+	legacyMobile,
+	legacyNetwork,
+	legacyStorage,
+	legacySwitchTo,
+	legacyScript,
+	legacyShadowRoot,
+	legacyPermissions,
+	legacyWebExtension,
+	legacyWebDriverWait,
+]
+
+WebDriverWaitInputType = Union[legacyWebElement, legacyWebDriver]

osn_selenium/instances/_utils.py

@@ -0,0 +1,143 @@
+from osn_selenium.models import Point
+
+
+__all__ = [
+	"MoveOffset",
+	"MovePart",
+	"MoveStep",
+	"ScrollDelta",
+	"ScrollPart",
+	"TextInputPart"
+]
+
+
+class TextInputPart:
+	"""
+	Represents a segment of text input with an associated duration.
+
+	Attributes:
+		text (str): The chunk of text for this part.
+		duration (int): Duration (milliseconds) associated with this part.
+	"""
+	
+	def __init__(self, text: str, duration: int):
+		self.text: str = text
+		self.duration: int = duration
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return f"TextInputPart(text={self.text}, duration={self.duration})"
+
+
+class ScrollDelta:
+	"""
+	Represents the change in scroll position (dx, dy).
+
+	Attributes:
+		x (int): Horizontal scroll amount.
+		y (int): Vertical scroll amount.
+	"""
+	
+	def __init__(self, x: int, y: int):
+		self.x: int = x
+		self.y: int = y
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return f"ScrollDelta(x={self.x}, y={self.y})"
+
+
+class ScrollPart:
+	"""
+	Represents a segment of a simulated scroll action.
+
+	Attributes:
+		point (Point): Coordinate point before this scroll segment.
+		delta (ScrollDelta): Scroll amount (dx, dy) for this segment.
+		duration (int): Duration (milliseconds) for this scroll segment.
+	"""
+	
+	def __init__(self, point: Point, delta: ScrollDelta, duration: int):
+		self.point: Point = point
+		self.delta: ScrollDelta = delta
+		self.duration: int = duration
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return (
+				f"ScrollPart(point={self.point}, delta={self.delta}, duration={self.duration})"
+		)
+
+
+class MoveStep:
+	"""
+	Internal helper class representing a step in a movement calculation.
+
+	Attributes:
+		amplitude_x (int): The horizontal component or amplitude of this step.
+		amplitude_y (int): The vertical component or amplitude of this step.
+		index (int): An index identifying this step's position in a sequence.
+	"""
+	
+	def __init__(self, amplitude_x: int, amplitude_y: int, index: int):
+		self.amplitude_x: int = amplitude_x
+		self.amplitude_y: int = amplitude_y
+		self.index: int = index
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return (
+				f"MoveStep(amplitude_x={self.amplitude_x}, amplitude_y={self.amplitude_y})"
+		)
+
+
+class MoveOffset:
+	"""
+	Represents a 2D offset or displacement (dx, dy).
+
+	Attributes:
+		x (int): Horizontal offset component.
+		y (int): Vertical offset component.
+	"""
+	
+	def __init__(self, x: int, y: int):
+		self.x: int = x
+		self.y: int = y
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return f"MoveOffset(x={self.x}, y={self.y})"
+
+
+class MovePart:
+	"""
+	Represents a segment of a simulated mouse movement.
+
+	Attributes:
+		point (Point): Target coordinate point.
+		offset (MoveOffset): Offset (dx, dy) for this segment.
+		duration (int): Duration (milliseconds) for this movement segment.
+	"""
+	
+	def __init__(self, point: Point, offset: MoveOffset, duration: int):
+		self.point: Point = point
+		self.offset: MoveOffset = offset
+		self.duration: int = duration
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return (
+				f"MovePart(point={self.point}, offset={self.offset}, duration={self.duration})"
+		)

osn_selenium/instances/convert.py

@@ -0,0 +1,287 @@
+import trio
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from selenium.webdriver.remote.fedcm import FedCM as legacyFedCM
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.remote.mobile import (
+	Mobile as legacyMobile
+)
+from osn_selenium.exceptions.protocol import (
+	ProtocolComplianceError
+)
+from typing import (
+	Any,
+	Optional,
+	Type,
+	TypeVar,
+	Union,
+	overload
+)
+from selenium.webdriver.common.bidi.script import (
+	Script as legacyScript
+)
+from selenium.webdriver.common.fedcm.dialog import (
+	Dialog as legacyDialog
+)
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from selenium.webdriver.common.bidi.browser import (
+	Browser as legacyBrowser
+)
+from selenium.webdriver.common.bidi.network import (
+	Network as legacyNetwork
+)
+from selenium.webdriver.common.bidi.storage import (
+	Storage as legacyStorage
+)
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+from selenium.webdriver.common.bidi.permissions import (
+	Permissions as legacyPermissions
+)
+from selenium.webdriver.common.bidi.webextension import (
+	WebExtension as legacyWebExtension
+)
+from osn_selenium.instances.protocols import (
+	SyncInstanceWrapper,
+	TrioThreadInstanceWrapper
+)
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext
+)
+from osn_selenium.instances._typehints import (
+	ACTION_CHAINS_TYPEHINT,
+	ALERT_TYPEHINT,
+	ANY_ABSTRACT_INSTANCE_TYPEHINT,
+	ANY_LEGACY_INSTANCE_TYPEHINT,
+	BROWSER_TYPEHINT,
+	BROWSING_CONTEXT_TYPEHINT,
+	DIALOG_TYPEHINT,
+	FEDCM_TYPEHINT,
+	MOBILE_TYPEHINT,
+	NETWORK_TYPEHINT,
+	PERMISSIONS_TYPEHINT,
+	SCRIPT_TYPEHINT,
+	SHADOW_ROOT_TYPEHINT,
+	STORAGE_TYPEHINT,
+	SWITCH_TO_TYPEHINT,
+	WEB_DRIVER_WAIT_TYPEHINT,
+	WEB_ELEMENT_TYPEHINT,
+	WEB_EXTENSION_TYPEHINT
+)
+
+
+__all__ = [
+	"get_legacy_frame_reference",
+	"get_legacy_instance",
+	"get_sync_instance_wrapper",
+	"get_trio_thread_instance_wrapper"
+]
+
+_SYNC_WRAPPER_TYPE = TypeVar("_SYNC_WRAPPER_TYPE", bound=SyncInstanceWrapper)
+_TRIO_THREAD_WRAPPER_TYPE = TypeVar("_TRIO_THREAD_WRAPPER_TYPE", bound=TrioThreadInstanceWrapper)
+
+
+@overload
+def get_legacy_instance(instance: None) -> None:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[ALERT_TYPEHINT]) -> Optional[legacyAlert]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[FEDCM_TYPEHINT]) -> Optional[legacyFedCM]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[DIALOG_TYPEHINT]) -> Optional[legacyDialog]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[MOBILE_TYPEHINT]) -> Optional[legacyMobile]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[SCRIPT_TYPEHINT]) -> Optional[legacyScript]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[BROWSER_TYPEHINT]) -> Optional[legacyBrowser]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[NETWORK_TYPEHINT]) -> Optional[legacyNetwork]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[STORAGE_TYPEHINT]) -> Optional[legacyStorage]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[SWITCH_TO_TYPEHINT]) -> Optional[legacySwitchTo]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[SHADOW_ROOT_TYPEHINT]) -> Optional[legacyShadowRoot]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[WEB_ELEMENT_TYPEHINT]) -> Optional[legacyWebElement]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[PERMISSIONS_TYPEHINT]) -> Optional[legacyPermissions]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[ACTION_CHAINS_TYPEHINT]) -> Optional[legacyActionChains]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[WEB_EXTENSION_TYPEHINT]) -> Optional[legacyWebExtension]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[WEB_DRIVER_WAIT_TYPEHINT]) -> Optional[legacyWebDriverWait]:
+	...
+
+
+@overload
+def get_legacy_instance(instance: Optional[BROWSING_CONTEXT_TYPEHINT]) -> Optional[legacyBrowsingContext]:
+	...
+
+
+def get_legacy_instance(
+		instance: Optional[Union[ANY_ABSTRACT_INSTANCE_TYPEHINT, ANY_LEGACY_INSTANCE_TYPEHINT]]
+) -> Optional[ANY_LEGACY_INSTANCE_TYPEHINT]:
+	"""
+	Converts an abstract Selenium instance to its corresponding legacy Selenium instance.
+
+	This function handles various types of Selenium objects, including browser contexts,
+	web elements, alerts, and more. It returns the legacy object if the input is an
+	abstract instance, or the input itself if it's already a legacy instance or None.
+
+	Args:
+		instance (Optional[Union[ANY_ABSTRACT_TYPE, ANY_LEGACY_TYPE]]): The instance to convert.
+																	   Can be an abstract instance,
+																	   a legacy instance, or None.
+
+	Returns:
+		Optional[ANY_LEGACY_TYPE]: The converted legacy instance,
+															 or None if the input was None.
+
+	Raises:
+		ExpectedTypeError: If the input instance is of an unsupported type.
+	"""
+	
+	if instance is None:
+		return None
+	
+	if isinstance(instance, ANY_ABSTRACT_INSTANCE_TYPEHINT):
+		return instance.legacy
+	
+	if isinstance(instance, ANY_LEGACY_INSTANCE_TYPEHINT):
+		return instance
+	
+	raise NotExpectedTypeError(
+			expected_type=(ANY_ABSTRACT_INSTANCE_TYPEHINT, ANY_LEGACY_INSTANCE_TYPEHINT, None),
+			received_instance=instance
+	)
+
+
+def get_trio_thread_instance_wrapper(
+		wrapper_class: Type[_TRIO_THREAD_WRAPPER_TYPE],
+		legacy_object: Any,
+		lock: trio.Lock,
+		limiter: trio.CapacityLimiter,
+) -> _TRIO_THREAD_WRAPPER_TYPE:
+	"""
+	Creates a Trio-compatible thread instance wrapper for a legacy Selenium object.
+
+	Args:
+		wrapper_class (Type[_TRIO_THREAD_WRAPPER_TYPE]): The class used to wrap the legacy object.
+		legacy_object (Any): The legacy Selenium object to be wrapped.
+		lock (trio.Lock): The lock for Trio synchronization.
+		limiter (trio.CapacityLimiter): The capacity limiter for Trio.
+
+	Returns:
+		_TRIO_THREAD_WRAPPER_TYPE: An instance of the wrapper class.
+
+	Raises:
+		TypeIsNotWrapper: If the provided wrapper_class does not implement TrioThreadInstanceWrapper.
+	"""
+	
+	if not isinstance(wrapper_class, TrioThreadInstanceWrapper):
+		raise ProtocolComplianceError(instance=wrapper_class, expected_protocols=TrioThreadInstanceWrapper)
+	
+	return wrapper_class.from_legacy(legacy_object=legacy_object, lock=lock, limiter=limiter)
+
+
+def get_sync_instance_wrapper(wrapper_class: Type[_SYNC_WRAPPER_TYPE], legacy_object: Any) -> _SYNC_WRAPPER_TYPE:
+	"""
+	Creates a synchronous instance wrapper for a legacy Selenium object.
+
+	Args:
+		wrapper_class (Type[_SYNC_WRAPPER_TYPE]): The class used to wrap the legacy object.
+		legacy_object (Any): The legacy Selenium object to be wrapped.
+
+	Returns:
+		_SYNC_WRAPPER_TYPE: An instance of the wrapper class.
+
+	Raises:
+		TypeIsNotWrapper: If the provided wrapper_class does not implement SyncInstanceWrapper.
+	"""
+	
+	if not isinstance(wrapper_class, SyncInstanceWrapper):
+		raise ProtocolComplianceError(instance=wrapper_class, expected_protocols=SyncInstanceWrapper)
+	
+	return wrapper_class.from_legacy(legacy_object=legacy_object)
+
+
+def get_legacy_frame_reference(frame_reference: Optional[Union[str, int, WEB_ELEMENT_TYPEHINT]]) -> Optional[Union[str, int, legacyWebElement]]:
+	"""
+	Converts a frame reference to its legacy Selenium equivalent.
+
+	The frame reference can be a string (frame name), an integer (frame index),
+	an AbstractWebElement, or a legacy WebElement. If it's a web element,
+	it is converted to its legacy WebElement form using `get_legacy_instance`.
+
+	Args:
+		frame_reference (Optional[Union[str, int, WEB_ELEMENT_TYPEHINT]]): The reference to the frame.
+
+	Returns:
+		Optional[Union[str, int, legacyWebElement]]: The legacy frame reference,
+													which can be a string, integer,
+													or a legacy WebElement, or None.
+	"""
+	
+	if isinstance(frame_reference, (str, int)):
+		return frame_reference
+	
+	return get_legacy_instance(instance=frame_reference)

osn_selenium/instances/protocols.py

@@ -0,0 +1,105 @@
+import trio
+from typing import (
+	Protocol,
+	Self,
+	TypeVar,
+	runtime_checkable
+)
+
+
+__all__ = [
+	"AnyInstanceWrapper",
+	"SyncInstanceWrapper",
+	"TrioThreadInstanceWrapper"
+]
+
+_LEGACY_OBJECT = TypeVar("_LEGACY_OBJECT")
+
+
+@runtime_checkable
+class TrioThreadInstanceWrapper(Protocol):
+	"""
+	Protocol for instances that wrap legacy objects and operate within Trio threads.
+	"""
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: _LEGACY_OBJECT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	) -> Self:
+		"""
+		Creates an instance of the wrapper from a legacy object.
+
+		Args:
+			legacy_object (_LEGACY_OBJECT): The legacy Selenium object to wrap.
+			lock (trio.Lock): Trio lock for synchronization.
+			limiter (trio.CapacityLimiter): Trio capacity limiter.
+
+		Returns:
+			Self: An instance of the wrapper.
+		"""
+		
+		...
+	
+	@property
+	def legacy(self) -> _LEGACY_OBJECT:
+		"""
+		Returns the underlying legacy Selenium object.
+
+		Returns:
+			_LEGACY_OBJECT: The legacy Selenium instance.
+		"""
+		
+		...
+
+
+@runtime_checkable
+class SyncInstanceWrapper(Protocol):
+	"""
+	Protocol for instances that wrap legacy objects for synchronous use.
+	"""
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: _LEGACY_OBJECT) -> Self:
+		"""
+		Creates an instance of the wrapper from a legacy object.
+
+		Args:
+			legacy_object (_LEGACY_OBJECT): The legacy Selenium object to wrap.
+
+		Returns:
+			Self: An instance of the wrapper.
+		"""
+		
+		...
+	
+	@property
+	def legacy(self) -> _LEGACY_OBJECT:
+		"""
+		Returns the underlying legacy Selenium object.
+
+		Returns:
+			_LEGACY_OBJECT: The legacy Selenium instance.
+		"""
+		
+		...
+
+
+@runtime_checkable
+class AnyInstanceWrapper(Protocol):
+	"""
+	General protocol for any instance wrapper providing access to a legacy object.
+	"""
+	
+	@property
+	def legacy(self) -> _LEGACY_OBJECT:
+		"""
+		Returns the underlying legacy Selenium object.
+
+		Returns:
+			_LEGACY_OBJECT: The legacy Selenium instance.
+		"""
+		
+		...

osn_selenium/instances/sync/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/sync/action_chains/__init__.py

@@ -0,0 +1,26 @@
+from osn_selenium.instances.sync.action_chains.click import ClickMixin
+from osn_selenium.instances.sync.action_chains.utils import UtilsMixin
+from osn_selenium.instances.sync.action_chains.hm_move import HMMoveMixin
+from osn_selenium.instances.sync.action_chains.hm_scroll import HMScrollMixin
+from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+from osn_selenium.instances.sync.action_chains.hm_keyboard import HMKeyboardMixin
+from osn_selenium.instances.sync.action_chains.drag_and_drop import DragAndDropMixin
+
+
+__all__ = ["ActionChains"]
+
+
+class ActionChains(
+		ClickMixin,
+		DragAndDropMixin,
+		UtilsMixin,
+		HMKeyboardMixin,
+		HMMoveMixin,
+		HMScrollMixin,
+		AbstractActionChains,
+):
+	"""
+	ActionChains class combining standard and human-like interaction mixins.
+	"""
+	
+	pass