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

osn_selenium/instances/unified/action_chains/hm_scroll.py

@@ -0,0 +1,79 @@
+from typing import Optional
+from osn_selenium.models import Point
+from osn_selenium.instances._functions import scroll_to_parts
+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.unified.action_chains.utils import UnifiedUtilsMixin
+from osn_selenium.instances.unified.action_chains.scroll import UnifiedScrollMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedHMScrollMixin"]
+
+
+class UnifiedHMScrollMixin(UnifiedUtilsMixin, UnifiedScrollMixin):
+	def _hm_scroll_from_origin_impl(self, delta_x: int, delta_y: int, origin: Optional[ScrollOrigin] = None) -> legacyActionChains:
+		if origin is None:
+			viewport_size = self._js_executor._get_viewport_size_impl()
+		
+			origin_x = 0 if delta_x >= 0 else viewport_size.width
+			origin_y = 0 if delta_y >= 0 else viewport_size.height
+		
+			origin = ScrollOrigin.from_viewport(x_offset=origin_x, y_offset=origin_y)
+		
+		start = Point(x=int(origin.x_offset), y=int(origin.y_offset))
+		end = Point(x=int(origin.x_offset) + int(delta_x), y=int(origin.y_offset) + int(delta_y))
+		
+		parts = scroll_to_parts(start_position=start, end_position=end)
+		
+		for part in parts:
+			self._pause_impl(seconds=part.duration * 0.001)
+			self._scroll_from_origin_impl(scroll_origin=origin, delta_x=int(part.delta.x), delta_y=int(part.delta.y))
+		
+		return self._legacy_impl
+	
+	def _hm_scroll_by_amount_impl(self, delta_x: int, delta_y: int) -> legacyActionChains:
+		start = Point(x=0, y=0)
+		end = Point(x=int(delta_x), y=int(delta_y))
+		
+		parts = scroll_to_parts(start_position=start, end_position=end)
+		
+		for part in parts:
+			self._pause_impl(seconds=part.duration * 0.001)
+			self._scroll_by_amount_impl(delta_x=int(part.delta.x), delta_y=int(part.delta.y))
+		
+		return self._legacy_impl
+	
+	def _hm_scroll_to_element_impl(
+			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,
+	) -> legacyActionChains:
+		viewport_rect = self._js_executor._get_viewport_rect_impl()
+		element_rect = self._js_executor._get_element_rect_in_viewport_impl(element=get_legacy_instance(instance=element))
+		
+		if element_rect.x < additional_left_x_offset:
+			delta_x = int(element_rect.x - additional_left_x_offset)
+		elif element_rect.x + element_rect.width > viewport_rect.width - additional_right_x_offset:
+			delta_x = int(
+					element_rect.x + element_rect.width - (viewport_rect.width - additional_right_x_offset)
+			)
+		else:
+			delta_x = 0
+		
+		if element_rect.y < additional_upper_y_offset:
+			delta_y = int(element_rect.y - additional_upper_y_offset)
+		elif element_rect.y + element_rect.height > viewport_rect.height - additional_lower_y_offset:
+			delta_y = int(
+					element_rect.y + element_rect.height - (viewport_rect.height - additional_lower_y_offset)
+			)
+		else:
+			delta_y = 0
+		
+		return self._hm_scroll_by_amount_impl(delta_x=delta_x, delta_y=delta_y)

osn_selenium/instances/unified/action_chains/keyboard.py

@@ -0,0 +1,24 @@
+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__ = ["UnifiedKeyboardMixin"]
+
+
+class UnifiedKeyboardMixin(UnifiedBaseMixin):
+	def _key_down_impl(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.key_down(value=value, element=get_legacy_instance(instance=element))
+	
+	def _key_up_impl(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT]) -> legacyActionChains:
+		return self._legacy_impl.key_up(value=value, element=get_legacy_instance(instance=element))
+	
+	def _send_keys_impl(self, *keys_to_send: str) -> legacyActionChains:
+		return self._legacy_impl.send_keys(*keys_to_send)
+	
+	def _send_keys_to_element_impl(self, element: WEB_ELEMENT_TYPEHINT, *keys_to_send: str) -> legacyActionChains:
+		return self._legacy_impl.send_keys_to_element(get_legacy_instance(instance=element), *keys_to_send)

osn_selenium/instances/unified/action_chains/move.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__ = ["UnifiedMoveMixin"]
+
+
+class UnifiedMoveMixin(UnifiedBaseMixin):
+	def _move_by_offset_impl(self, xoffset: int, yoffset: int) -> legacyActionChains:
+		return self._legacy_impl.move_by_offset(xoffset=xoffset, yoffset=yoffset)
+	
+	def _move_to_element_impl(self, to_element: WEB_ELEMENT_TYPEHINT) -> legacyActionChains:
+		return self._legacy_impl.move_to_element(to_element=get_legacy_instance(instance=to_element))
+	
+	def _move_to_element_with_offset_impl(self, to_element: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> legacyActionChains:
+		return self._legacy_impl.move_to_element_with_offset(
+				to_element=get_legacy_instance(instance=to_element),
+				xoffset=xoffset,
+				yoffset=yoffset
+		)

osn_selenium/instances/unified/action_chains/scroll.py

@@ -0,0 +1,21 @@
+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.unified.action_chains.base import UnifiedBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedScrollMixin"]
+
+
+class UnifiedScrollMixin(UnifiedBaseMixin):
+	def _scroll_by_amount_impl(self, delta_x: int, delta_y: int) -> legacyActionChains:
+		return self._legacy_impl.scroll_by_amount(delta_x=delta_x, delta_y=delta_y)
+	
+	def _scroll_from_origin_impl(self, scroll_origin: ScrollOrigin, delta_x: int, delta_y: int) -> legacyActionChains:
+		return self._legacy_impl.scroll_from_origin(scroll_origin=scroll_origin, delta_x=delta_x, delta_y=delta_y)
+	
+	def _scroll_to_element_impl(self, element: WEB_ELEMENT_TYPEHINT) -> legacyActionChains:
+		return self._legacy_impl.scroll_to_element(element=get_legacy_instance(instance=element))

osn_selenium/instances/unified/action_chains/utils.py

@@ -0,0 +1,19 @@
+from typing import Union
+from osn_selenium.instances.unified.action_chains.base import UnifiedBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["UnifiedUtilsMixin"]
+
+
+class UnifiedUtilsMixin(UnifiedBaseMixin):
+	def _pause_impl(self, seconds: Union[float, int]) -> legacyActionChains:
+		return self._legacy_impl.pause(seconds=seconds)
+	
+	def _perform_impl(self) -> None:
+		self._legacy_impl.perform()
+	
+	def _reset_actions_impl(self) -> None:
+		self._legacy_impl.reset_actions()

osn_selenium/instances/unified/alert.py

@@ -0,0 +1,29 @@
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+
+
+__all__ = ["UnifiedAlert"]
+
+
+class UnifiedAlert:
+	def __init__(self, selenium_alert: legacyAlert):
+		if not isinstance(selenium_alert, legacyAlert):
+			raise NotExpectedTypeError(expected_type=legacyAlert, received_instance=selenium_alert)
+		
+		self._selenium_alert = selenium_alert
+	
+	def _accept_impl(self) -> None:
+		self._legacy_impl.accept()
+	
+	def _dismiss_impl(self) -> None:
+		self._legacy_impl.dismiss()
+	
+	@property
+	def _legacy_impl(self) -> legacyAlert:
+		return self._selenium_alert
+	
+	def _send_keys_impl(self, keysToSend: str) -> None:
+		self._legacy_impl.send_keys(keysToSend=keysToSend)
+	
+	def _text_impl(self) -> str:
+		return self._legacy_impl.text

osn_selenium/instances/unified/browser.py

@@ -0,0 +1,33 @@
+from typing import List
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.browser import (
+	Browser as legacyBrowser,
+	ClientWindowInfo
+)
+
+
+__all__ = ["UnifiedBrowser"]
+
+
+class UnifiedBrowser:
+	def __init__(self, selenium_browser: legacyBrowser):
+		if not isinstance(selenium_browser, legacyBrowser):
+			raise NotExpectedTypeError(expected_type=legacyBrowser, received_instance=selenium_browser)
+		
+		self._selenium_browser = selenium_browser
+	
+	def _create_user_context_impl(self) -> str:
+		return self._legacy_impl.create_user_context()
+	
+	def _get_client_windows_impl(self) -> List[ClientWindowInfo]:
+		return self._legacy_impl.get_client_windows()
+	
+	def _get_user_contexts_impl(self) -> List[str]:
+		return self._legacy_impl.get_user_contexts()
+	
+	@property
+	def _legacy_impl(self) -> legacyBrowser:
+		return self._selenium_browser
+	
+	def _remove_user_context_impl(self, user_context_id: str) -> None:
+		self._legacy_impl.remove_user_context(user_context_id=user_context_id)

osn_selenium/instances/unified/browsing_context.py

@@ -0,0 +1,151 @@
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Union
+)
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext,
+	BrowsingContextInfo
+)
+
+
+__all__ = ["UnifiedBrowsingContext"]
+
+
+class UnifiedBrowsingContext:
+	def __init__(self, selenium_browsing_context: legacyBrowsingContext):
+		if not isinstance(selenium_browsing_context, legacyBrowsingContext):
+			raise NotExpectedTypeError(
+					expected_type=legacyBrowsingContext,
+					received_instance=selenium_browsing_context
+			)
+		
+		self._selenium_browsing_context = selenium_browsing_context
+	
+	def _activate_impl(self, context: str) -> Any:
+		return self._legacy_impl.activate(context)
+	
+	def _add_event_handler_impl(
+			self,
+			event: str,
+			callback: Callable,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return self._legacy_impl.add_event_handler(event=event, callback=callback, contexts=contexts)
+	
+	def _capture_screenshot_impl(
+			self,
+			context: str,
+			origin: str = "viewport",
+			format: Optional[Dict] = None,
+			clip: Optional[Dict] = None,
+	) -> str:
+		return self._legacy_impl.capture_screenshot(context=context, origin=origin, format=format, clip=clip)
+	
+	def _clear_event_handlers_impl(self) -> None:
+		self._legacy_impl.clear_event_handlers()
+	
+	def _close_impl(self, context: str, prompt_unload: bool = False) -> None:
+		self._legacy_impl.close(context=context, prompt_unload=prompt_unload)
+	
+	def _create_impl(
+			self,
+			type: str,
+			reference_context: Optional[str] = None,
+			background: bool = False,
+			user_context: Optional[str] = None,
+	) -> str:
+		return self._legacy_impl.create(
+				type=type,
+				reference_context=reference_context,
+				background=background,
+				user_context=user_context
+		)
+	
+	def _get_tree_impl(self, max_depth: Optional[int] = None, root: Optional[str] = None) -> List[BrowsingContextInfo]:
+		return self._legacy_impl.get_tree(max_depth=max_depth, root=root)
+	
+	def _handle_user_prompt_impl(
+			self,
+			context: str,
+			accept: Optional[bool] = None,
+			user_text: Optional[str] = None,
+	) -> None:
+		self._legacy_impl.handle_user_prompt(context=context, accept=accept, user_text=user_text)
+	
+	@property
+	def _legacy_impl(self) -> legacyBrowsingContext:
+		return self._selenium_browsing_context
+	
+	def _locate_nodes_impl(
+			self,
+			context: str,
+			locator: Dict,
+			max_node_count: Optional[int] = None,
+			serialization_options: Optional[Dict] = None,
+			start_nodes: Optional[List[Dict]] = None,
+	) -> List[Dict]:
+		return self._legacy_impl.locate_nodes(
+				context=context,
+				locator=locator,
+				max_node_count=max_node_count,
+				serialization_options=serialization_options,
+				start_nodes=start_nodes
+		)
+	
+	def _navigate_impl(self, context: str, url: str, wait: Optional[str] = None) -> Dict:
+		return self._legacy_impl.navigate(context=context, url=url, wait=wait)
+	
+	def _print_impl(
+			self,
+			context: str,
+			background: bool = False,
+			margin: Optional[Dict] = None,
+			orientation: str = "portrait",
+			page: Optional[Dict] = None,
+			page_ranges: Optional[List[Union[int, str]]] = None,
+			scale: float = 1.0,
+			shrink_to_fit: bool = True,
+	) -> str:
+		return self._legacy_impl.print(
+				context=context,
+				background=background,
+				margin=margin,
+				orientation=orientation,
+				page=page,
+				page_ranges=page_ranges,
+				scale=scale,
+				shrink_to_fit=shrink_to_fit
+		)
+	
+	def _reload_impl(
+			self,
+			context: str,
+			ignore_cache: Optional[bool] = None,
+			wait: Optional[str] = None,
+	) -> Dict:
+		return self._legacy_impl.reload(context=context, ignore_cache=ignore_cache, wait=wait)
+	
+	def _remove_event_handler_impl(self, event: str, callback_id: int) -> None:
+		self._legacy_impl.remove_event_handler(event=event, callback_id=callback_id)
+	
+	def _set_viewport_impl(
+			self,
+			context: Optional[str] = None,
+			viewport: Optional[Dict] = None,
+			device_pixel_ratio: Optional[float] = None,
+			user_contexts: Optional[List[str]] = None,
+	) -> None:
+		self._legacy_impl.set_viewport(
+				context=context,
+				viewport=viewport,
+				device_pixel_ratio=device_pixel_ratio,
+				user_contexts=user_contexts
+		)
+	
+	def _traverse_history_impl(self, context: str, delta: int) -> Dict:
+		return self._legacy_impl.traverse_history(context=context, delta=delta)

osn_selenium/instances/unified/dialog.py

@@ -0,0 +1,42 @@
+from typing import List, Optional
+from selenium.webdriver.common.fedcm.account import Account
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.fedcm.dialog import (
+	Dialog as legacyDialog
+)
+
+
+__all__ = ["UnifiedDialog"]
+
+
+class UnifiedDialog:
+	def __init__(self, selenium_dialog: legacyDialog):
+		if not isinstance(selenium_dialog, legacyDialog):
+			raise NotExpectedTypeError(expected_type=legacyDialog, received_instance=selenium_dialog)
+		
+		self._selenium_dialog = selenium_dialog
+	
+	def _accept_impl(self) -> None:
+		self._legacy_impl.accept()
+	
+	def _dismiss_impl(self) -> None:
+		self._legacy_impl.dismiss()
+	
+	def _get_accounts_impl(self) -> List[Account]:
+		return self._legacy_impl.get_accounts()
+	
+	@property
+	def _legacy_impl(self) -> legacyDialog:
+		return self._selenium_dialog
+	
+	def _select_account_impl(self, index: int) -> None:
+		self._legacy_impl.select_account(index=index)
+	
+	def _subtitle_impl(self) -> Optional[str]:
+		return self._legacy_impl.subtitle
+	
+	def _title_impl(self) -> str:
+		return self._legacy_impl.title
+	
+	def _type_impl(self) -> Optional[str]:
+		return self._legacy_impl.type

osn_selenium/instances/unified/fedcm.py

@@ -0,0 +1,48 @@
+from typing import Dict, List, Optional
+from selenium.webdriver.remote.fedcm import FedCM as legacyFedCM
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+
+
+__all__ = ["UnifiedFedCM"]
+
+
+class UnifiedFedCM:
+	def __init__(self, selenium_fedcm: legacyFedCM):
+		if not isinstance(selenium_fedcm, legacyFedCM):
+			raise NotExpectedTypeError(expected_type=legacyFedCM, received_instance=selenium_fedcm)
+		
+		self._selenium_fedcm = selenium_fedcm
+	
+	def _accept_impl(self) -> None:
+		self._legacy_impl.accept()
+	
+	def _account_list_impl(self) -> List[Dict]:
+		return self._legacy_impl.account_list
+	
+	def _dialog_type_impl(self) -> str:
+		return self._legacy_impl.dialog_type
+	
+	def _disable_delay_impl(self) -> None:
+		self._legacy_impl.disable_delay()
+	
+	def _dismiss_impl(self) -> None:
+		self._legacy_impl.dismiss()
+	
+	def _enable_delay_impl(self) -> None:
+		self._legacy_impl.enable_delay()
+	
+	@property
+	def _legacy_impl(self) -> legacyFedCM:
+		return self._selenium_fedcm
+	
+	def _reset_cooldown_impl(self) -> None:
+		self._legacy_impl.reset_cooldown()
+	
+	def _select_account_impl(self, index: int) -> None:
+		self._legacy_impl.select_account(index=index)
+	
+	def _subtitle_impl(self) -> Optional[str]:
+		return self._legacy_impl.subtitle
+	
+	def _title_impl(self) -> str:
+		return self._legacy_impl.title

osn_selenium/instances/unified/mobile.py

@@ -0,0 +1,36 @@
+from typing import List, Union
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.remote.mobile import (
+	Mobile as legacyMobile,
+	_ConnectionType
+)
+
+
+__all__ = ["UnifiedMobile"]
+
+
+class UnifiedMobile:
+	def __init__(self, selenium_mobile: legacyMobile):
+		if not isinstance(selenium_mobile, legacyMobile):
+			raise NotExpectedTypeError(expected_type=legacyMobile, received_instance=selenium_mobile)
+		
+		self._selenium_mobile = selenium_mobile
+	
+	def _contexts_impl(self) -> List[str]:
+		return self._legacy_impl.contexts
+	
+	def _get_context_impl(self) -> str:
+		return self._legacy_impl.context
+	
+	@property
+	def _legacy_impl(self) -> legacyMobile:
+		return self._selenium_mobile
+	
+	def _network_connection_impl(self) -> _ConnectionType:
+		return self._legacy_impl.network_connection
+	
+	def _set_context_impl(self, new_context: str) -> None:
+		self._legacy_impl.context = new_context
+	
+	def _set_network_connection_impl(self, network: Union[int, _ConnectionType]) -> _ConnectionType:
+		return self._legacy_impl.set_network_connection(network)

osn_selenium/instances/unified/network.py

@@ -0,0 +1,50 @@
+from typing import (
+	Callable,
+	List,
+	Optional
+)
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.network import (
+	Network as legacyNetwork
+)
+
+
+__all__ = ["UnifiedNetwork"]
+
+
+class UnifiedNetwork:
+	def __init__(self, selenium_network: legacyNetwork):
+		if not isinstance(selenium_network, legacyNetwork):
+			raise NotExpectedTypeError(expected_type=legacyNetwork, received_instance=selenium_network)
+		
+		self._selenium_network = selenium_network
+	
+	def _add_auth_handler_impl(self, username: str, password: str) -> int:
+		return self._legacy_impl.add_auth_handler(username=username, password=password)
+	
+	def _add_request_handler_impl(
+			self,
+			event: str,
+			callback: Callable,
+			url_patterns: Optional[List[str]] = None,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return self._legacy_impl.add_request_handler(
+				event=event,
+				callback=callback,
+				url_patterns=url_patterns,
+				contexts=contexts
+		)
+	
+	def _clear_request_handlers_impl(self) -> None:
+		self._legacy_impl.clear_request_handlers()
+	
+	@property
+	def _legacy_impl(self) -> legacyNetwork:
+		return self._selenium_network
+	
+	def _remove_auth_handler_impl(self, callback_id: int) -> None:
+		self._legacy_impl.remove_auth_handler(callback_id=callback_id)
+	
+	def _remove_request_handler_impl(self, event: str, callback_id: int) -> None:
+		self._legacy_impl.remove_request_handler(event=event, callback_id=callback_id)

osn_selenium/instances/unified/permissions.py

@@ -0,0 +1,43 @@
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.permissions import (
+	PermissionDescriptor,
+	Permissions as legacyPermissions
+)
+
+
+__all__ = ["UnifiedPermissions"]
+
+
+class UnifiedPermissions:
+	def __init__(self, selenium_permissions: legacyPermissions):
+		if not isinstance(selenium_permissions, legacyPermissions):
+			raise NotExpectedTypeError(
+					expected_type=legacyPermissions,
+					received_instance=selenium_permissions
+			)
+		
+		self._selenium_permissions = selenium_permissions
+	
+	@property
+	def _legacy_impl(self) -> legacyPermissions:
+		return self._selenium_permissions
+	
+	def _set_permission_impl(
+			self,
+			descriptor: Union[Dict[str, Any], PermissionDescriptor],
+			state: str,
+			origin: str,
+			user_context: Optional[str] = None,
+	) -> None:
+		self._legacy_impl.set_permission(
+				descriptor=descriptor,
+				state=state,
+				origin=origin,
+				user_context=user_context
+		)

osn_selenium/instances/unified/script.py

@@ -0,0 +1,38 @@
+from typing import Any, Callable
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.script import (
+	Script as legacyScript
+)
+
+
+__all__ = ["UnifiedScript"]
+
+
+class UnifiedScript:
+	def __init__(self, selenium_script: legacyScript):
+		if not isinstance(selenium_script, legacyScript):
+			raise NotExpectedTypeError(expected_type=legacyScript, received_instance=selenium_script)
+		
+		self._selenium_script = selenium_script
+	
+	def _add_console_message_handler_impl(self, handler: Callable[[Any], None]) -> int:
+		return self._legacy_impl.add_console_message_handler(handler=handler)
+	
+	def _add_javascript_error_handler_impl(self, handler: Callable[[Any], None]) -> int:
+		return self._legacy_impl.add_javascript_error_handler(handler=handler)
+	
+	def _execute_impl(self, script: str, *args: Any) -> Any:
+		return self._legacy_impl.execute(script, *args)
+	
+	@property
+	def _legacy_impl(self) -> legacyScript:
+		return self._selenium_script
+	
+	def _pin_impl(self, script: str) -> str:
+		return self._legacy_impl.pin(script=script)
+	
+	def _remove_console_message_handler_impl(self, id: int) -> None:
+		self._legacy_impl.remove_console_message_handler(id=id)
+	
+	def _unpin_impl(self, script_id: str) -> None:
+		self._legacy_impl.unpin(script_id=script_id)