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

osn_selenium/webdrivers/unified/blink/base.py

@@ -0,0 +1,135 @@
+import pathlib
+from typing import Mapping, Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.blink import BlinkFlagsManager
+from osn_selenium.flags.models.values import ArgumentValue
+from osn_selenium.browsers_handler import get_path_to_browser
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from selenium.webdriver.chromium.webdriver import (
+	ChromiumDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers._executable_tables.functions import (
+	find_browser_previous_session
+)
+from osn_selenium.flags.models.blink import (
+	BlinkArguments,
+	BlinkExperimentalOptions,
+	BlinkFlags
+)
+from osn_system_utils.api.network import (
+	get_localhost_free_port_of,
+	get_random_localhost_free_port
+)
+
+
+__all__ = ["UnifiedBlinkBaseMixin"]
+
+
+class UnifiedBlinkBaseMixin(UnifiedCoreBaseMixin):
+	def __init__(
+			self,
+			browser_exe: Optional[PATH_TYPEHINT],
+			browser_name_in_system: str,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			use_browser_exe: bool = True,
+			flags_manager_type: Type[BlinkFlagsManager] = BlinkFlagsManager,
+			flags: Optional[BlinkFlags] = None,
+			start_page_url: str = "",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+			cdp_versioned_packages_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_cdp_version_package_missing: bool = True,
+	):
+		UnifiedCoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)
+		
+		if browser_exe is not None:
+			self._webdriver_flags_manager.browser_exe = browser_exe
+		
+		if start_page_url is not None:
+			self._webdriver_flags_manager.start_page_url = start_page_url
+		
+		if window_rect is not None:
+			self._window_rect = window_rect
+		
+		if use_browser_exe is not None and browser_name_in_system is not None:
+			self._detect_browser_exe_impl(
+					browser_name_in_system=browser_name_in_system,
+					use_browser_exe=use_browser_exe
+			)
+	
+	def _detect_browser_exe_impl(self, browser_name_in_system: str, use_browser_exe: bool) -> None:
+		if self._browser_exe_impl is None and use_browser_exe:
+			self._webdriver_flags_manager.browser_exe = get_path_to_browser(browser_name_in_system)
+		elif self._browser_exe_impl is not None and not use_browser_exe:
+			self._webdriver_flags_manager.browser_exe = None
+	
+	@property
+	def _debugging_ip_impl(self) -> Optional[str]:
+		return self._webdriver_flags_manager.arguments.get("remote_debugging_address", ArgumentValue(command_line="", value=None)).value
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyWebDriver]:
+		return super()._driver_impl
+	
+	@property
+	def _debugging_port_impl(self) -> Optional[int]:
+		return self._webdriver_flags_manager.arguments.get("remote_debugging_port", ArgumentValue(command_line="", value=None)).value
+	
+	@property
+	def _browser_exe_impl(self) -> Optional[pathlib.Path]:
+		return self._webdriver_flags_manager.browser_exe
+	
+	def _find_debugging_port_impl(self, debugging_port: Optional[int]) -> int:
+		if self._browser_exe_impl is not None:
+			user_data_dir_command = self._webdriver_flags_manager.flags_definitions.get("user_data_dir", None)
+			user_data_dir_value = self._webdriver_flags_manager.arguments.get("user_data_dir", None)
+		
+			user_data_dir = None if user_data_dir_command is None else user_data_dir_value.value if user_data_dir_value is not None else None
+		
+			if user_data_dir_command is not None:
+				previous_session = find_browser_previous_session(self._browser_exe_impl, user_data_dir_command.command, user_data_dir)
+		
+				if previous_session is not None:
+					return previous_session
+		
+		if debugging_port is not None:
+			return get_localhost_free_port_of(ports_to_check=debugging_port, on_candidates="min")
+		
+		if self._debugging_port_impl is None or self._debugging_port_impl == 0:
+			return get_random_localhost_free_port()
+		
+		return self._debugging_port_impl
+	
+	def _set_debugging_port_impl(self, debugging_port: Optional[int], debugging_address: Optional[str]) -> None:
+		if self._browser_exe_impl is not None:
+			_debugging_address = "127.0.0.1" if debugging_address is None else debugging_address
+			_debugging_port = 0 if debugging_port is None else debugging_port
+		
+			self._webdriver_flags_manager.update_flags(
+					BlinkFlags(
+							argument=BlinkArguments(
+									remote_debugging_port=debugging_port,
+									remote_debugging_address=debugging_address,
+							),
+							experimental_option=BlinkExperimentalOptions(debugger_address=f"{_debugging_address}:{_debugging_port}"),
+					)
+			)

osn_selenium/webdrivers/unified/blink/casting.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkCastingMixin"]
+
+
+class UnifiedBlinkCastingMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_sinks_impl(self) -> List[Dict[str, Any]]:
+		return self._driver_impl.get_sinks()
+	
+	@requires_driver
+	def _set_sink_to_use_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.set_sink_to_use(sink_name=sink_name)
+	
+	@requires_driver
+	def _start_desktop_mirroring_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.start_desktop_mirroring(sink_name=sink_name)
+	
+	@requires_driver
+	def _start_tab_mirroring_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.start_tab_mirroring(sink_name=sink_name)
+	
+	@requires_driver
+	def _stop_casting_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.stop_casting(sink_name=sink_name)

osn_selenium/webdrivers/unified/blink/features.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkFeaturesMixin"]
+
+
+class UnifiedBlinkFeaturesMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_issue_message_impl(self) -> Any:
+		return self._driver_impl.get_issue_message()
+	
+	@requires_driver
+	def _launch_app_impl(self, id: str) -> Dict[str, Any]:
+		return self._driver_impl.launch_app(id=id)
+	
+	@requires_driver
+	def _set_permissions_impl(self, name: str, value: str) -> None:
+		self._driver_impl.set_permissions(name=name, value=value)

osn_selenium/webdrivers/unified/blink/lifecycle.py

@@ -0,0 +1,114 @@
+import re
+import time
+from typing import Optional
+from subprocess import Popen
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.blink import BlinkFlags
+from osn_system_utils.api.process import kill_process_by_pid
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+from osn_selenium.webdrivers.unified.core.lifecycle import (
+	UnifiedCoreLifecycleMixin
+)
+from osn_system_utils.api.network import (
+	get_localhost_pids_with_addresses,
+	get_localhost_pids_with_ports
+)
+
+
+__all__ = ["UnifiedBlinkLifecycleMixin"]
+
+
+class UnifiedBlinkLifecycleMixin(UnifiedBlinkSettingsMixin, UnifiedCoreLifecycleMixin):
+	def _create_driver_impl(self) -> None:
+		raise NotImplementedError("This function must be implemented in child classes.")
+	
+	def _check_browser_exe_active_impl(self) -> bool:
+		debugging_port = self._debugging_port_impl
+		debugging_ip = self._debugging_ip_impl
+		
+		for pid, addresses in get_localhost_pids_with_addresses().items():
+			for address_str in addresses:
+				if re.search(rf":{debugging_port}\Z", address_str) is not None:
+					found_ip = re.search(rf"\A(.+):{debugging_port}\Z", address_str).group(1)
+		
+					if found_ip != debugging_ip:
+						self._set_debugging_port_impl(debugging_port=debugging_port, debugging_address=found_ip)
+		
+					return True
+		return False
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[BlinkFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if self._driver_impl is None:
+			self._update_settings_impl(
+					flags=flags,
+					browser_exe=browser_exe,
+					browser_name_in_system=browser_name_in_system,
+					use_browser_exe=use_browser_exe,
+					start_page_url=start_page_url,
+					window_rect=window_rect,
+			)
+		
+			if self._browser_exe_impl is not None:
+				is_active = self._check_browser_exe_active_impl()
+		
+				if not is_active:
+					Popen(args=self._webdriver_flags_manager.start_command, shell=True)
+		
+					while not is_active:
+						is_active = self._check_browser_exe_active_impl()
+						if not is_active:
+							time.sleep(0.1)
+		
+			self._create_driver_impl()
+			self._is_active = True
+	
+	def _close_webdriver_impl(self) -> None:
+		if self._browser_exe_impl is not None:
+			debugging_port = self._debugging_port_impl
+			pids_with_ports = get_localhost_pids_with_ports()
+		
+			for pid, ports in pids_with_ports.items():
+				if debugging_port in ports and 1 <= len(ports) <= 2:
+					kill_process_by_pid(pid=pid, force=True)
+		
+					is_active = self._check_browser_exe_active_impl()
+					while is_active:
+						is_active = self._check_browser_exe_active_impl()
+						if is_active:
+							time.sleep(0.05)
+		
+		if self._driver_impl is not None:
+			self._quit_impl()
+			self._driver = None
+		
+		self._is_active = False
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[BlinkFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		self._close_webdriver_impl()
+		self._start_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect
+		)

osn_selenium/webdrivers/unified/blink/logging.py

@@ -0,0 +1,18 @@
+from typing import Any
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkLoggingMixin"]
+
+
+class UnifiedBlinkLoggingMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_log_impl(self, log_type: str) -> Any:
+		return self._driver_impl.get_log(log_type=log_type)
+	
+	@requires_driver
+	def _log_types_impl(self) -> Any:
+		return self._driver_impl.log_types

osn_selenium/webdrivers/unified/blink/network.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkNetworkMixin"]
+
+
+class UnifiedBlinkNetworkMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _delete_network_conditions_impl(self) -> None:
+		self._driver_impl.delete_network_conditions()
+	
+	@requires_driver
+	def _get_network_conditions_impl(self) -> Dict[str, Any]:
+		return self._driver_impl.get_network_conditions()
+	
+	@requires_driver
+	def _set_network_conditions_impl(self, **network_conditions: Any) -> None:
+		self._driver_impl.set_network_conditions(**network_conditions)

osn_selenium/webdrivers/unified/blink/settings.py

@@ -0,0 +1,86 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.blink import BlinkFlags
+from osn_selenium.exceptions.webdriver import (
+	WebDriverAlreadyRunningError
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkSettingsMixin"]
+
+
+class UnifiedBlinkSettingsMixin(UnifiedBlinkBaseMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[BlinkFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: str = "",
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active:
+			if flags is not None:
+				self._webdriver_flags_manager.set_flags(flags)
+			else:
+				self._webdriver_flags_manager.clear_flags()
+		
+			self._webdriver_flags_manager.browser_exe = browser_exe
+			self._webdriver_flags_manager.start_page_url = start_page_url
+			self._window_rect = window_rect
+		
+			if use_browser_exe is not None and browser_name_in_system is not None:
+				self._detect_browser_exe_impl(
+						browser_name_in_system=browser_name_in_system,
+						use_browser_exe=use_browser_exe
+				)
+		
+			if self._browser_exe_impl is not None and (
+					self._debugging_port_impl is not None
+					or self._debugging_ip_impl is not None
+			):
+				self._set_debugging_port_impl(
+						self._find_debugging_port_impl(self._debugging_port_impl),
+						self._debugging_ip_impl
+				)
+		else:
+			raise WebDriverAlreadyRunningError()
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[BlinkFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active:
+			if flags is not None:
+				self._webdriver_flags_manager.update_flags(flags)
+		
+			if browser_exe is not None:
+				self._webdriver_flags_manager.browser_exe = browser_exe
+		
+			if start_page_url is not None:
+				self._webdriver_flags_manager.start_page_url = start_page_url
+		
+			if window_rect is not None:
+				self._window_rect = window_rect
+		
+			if use_browser_exe is not None and browser_name_in_system is not None:
+				self._detect_browser_exe_impl(
+						browser_name_in_system=browser_name_in_system,
+						use_browser_exe=use_browser_exe
+				)
+		
+			self._set_debugging_port_impl(
+					self._find_debugging_port_impl(self._debugging_port_impl),
+					self._debugging_ip_impl
+			)
+		else:
+			raise WebDriverAlreadyRunningError()

osn_selenium/webdrivers/unified/chrome/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/chrome/base.py

@@ -0,0 +1,58 @@
+from typing import Mapping, Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.chrome import ChromeFlagsManager
+from osn_selenium.flags.models.chrome import ChromeFlags
+from selenium.webdriver import (
+	Chrome as legacyChrome
+)
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedChromeBaseMixin"]
+
+
+class UnifiedChromeBaseMixin(UnifiedBlinkBaseMixin):
+	def __init__(
+			self,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			flags_manager_type: Type[ChromeFlagsManager] = ChromeFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Google Chrome",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[ChromeFlags] = None,
+			start_page_url: str = "about:blank",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+			cdp_versioned_packages_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_cdp_version_package_missing: bool = True,
+	):
+		UnifiedBlinkBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				use_browser_exe=use_browser_exe,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				start_page_url=start_page_url,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyChrome]:
+		return super()._driver_impl

osn_selenium/webdrivers/unified/chrome/lifecycle.py

@@ -0,0 +1,88 @@
+from typing import Optional
+from selenium import webdriver
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from selenium.webdriver.chrome.service import Service
+from osn_selenium.flags.models.chrome import ChromeFlags
+from osn_selenium.webdrivers.unified.core.window import (
+	UnifiedCoreWindowMixin
+)
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+from osn_selenium.webdrivers.unified.blink.lifecycle import (
+	UnifiedBlinkLifecycleMixin
+)
+
+
+__all__ = ["UnifiedChromeLifecycleMixin"]
+
+
+class UnifiedChromeLifecycleMixin(
+		UnifiedBlinkLifecycleMixin,
+		UnifiedCoreTimeoutsMixin,
+		UnifiedCoreWindowMixin
+):
+	def _create_driver_impl(self) -> None:
+		webdriver_options = self._webdriver_flags_manager.options
+		webdriver_service = Service(
+				executable_path=self._webdriver_path,
+				port=self._debugging_port_impl
+				if self._browser_exe_impl is None
+				else 0,
+				service_args=self._webdriver_flags_manager.start_args
+				if self._browser_exe_impl is None
+				else None
+		)
+		
+		self._driver = webdriver.Chrome(options=webdriver_options, service=webdriver_service)
+		
+		if self._window_rect is not None:
+			self._set_window_rect_impl(
+					x=self._window_rect.x,
+					y=self._window_rect.y,
+					width=self._window_rect.width,
+					height=self._window_rect.height,
+			)
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=self._base_page_load_timeout,
+				implicit_wait_timeout=self._base_implicitly_wait,
+				script_timeout=self._base_implicitly_wait,
+		)
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._restart_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._start_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/chrome/settings.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.chrome import ChromeFlags
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+
+
+__all__ = ["UnifiedChromeSettingsMixin"]
+
+
+class UnifiedChromeSettingsMixin(UnifiedBlinkSettingsMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: str = "",
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._reset_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._update_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/core/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/core/actions.py

@@ -0,0 +1,43 @@
+from typing import (
+	Iterable,
+	List,
+	Optional
+)
+from osn_selenium._typehints import DEVICES_TYPEHINT
+from osn_selenium.webdrivers._decorators import requires_driver
+from selenium.webdriver import (
+	ActionChains as legacyActionChains
+)
+from osn_selenium.webdrivers.unified.core.script import (
+	UnifiedCoreScriptMixin
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+
+
+__all__ = ["UnifiedCoreActionsMixin"]
+
+
+class UnifiedCoreActionsMixin(UnifiedCoreScriptMixin):
+	@requires_driver
+	def _action_chains_impl(
+			self,
+			duration: int = 250,
+			devices: Optional[List[DEVICES_TYPEHINT]] = None,
+	) -> legacyActionChains:
+		return legacyActionChains(driver=self._driver_impl, duration=duration, devices=devices)
+	
+	@requires_driver
+	def _web_driver_wait_impl(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> legacyWebDriverWait:
+		return legacyWebDriverWait(
+				driver=self._driver_impl,
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)