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

osn_selenium/instances/protocols.py

@@ -1,8 +1,10 @@
 import trio
 from typing import (
+	Optional,
 	Protocol,
 	Self,
 	TypeVar,
+	Union,
 	runtime_checkable
 )
 
@@ -10,6 +12,7 @@ from typing import (
 __all__ = [
 	"AnyInstanceWrapper",
 	"SyncInstanceWrapper",
+	"TrioBiDiInstanceWrapper",
 	"TrioThreadInstanceWrapper"
 ]
 
@@ -27,7 +30,7 @@ class TrioThreadInstanceWrapper(Protocol):
 			cls,
 			legacy_object: _LEGACY_OBJECT,
 			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
+			limiter: trio.CapacityLimiter,
 	) -> Self:
 		"""
 		Creates an instance of the wrapper from a legacy object.
@@ -55,6 +58,49 @@ class TrioThreadInstanceWrapper(Protocol):
 		...
 
 
+@runtime_checkable
+class TrioBiDiInstanceWrapper(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,
+			trio_token: Optional[trio.lowlevel.TrioToken],
+			bidi_buffer_size: Union[int, float],
+	) -> 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.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		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):
 	"""

osn_selenium/instances/sync/action_chains/__init__.py

@@ -1,6 +1,9 @@
+from osn_selenium.instances.sync.action_chains.move import MoveMixin
 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.scroll import ScrollMixin
 from osn_selenium.instances.sync.action_chains.hm_move import HMMoveMixin
+from osn_selenium.instances.sync.action_chains.keyboard import KeyboardMixin
 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
@@ -17,6 +20,9 @@ class ActionChains(
 		HMKeyboardMixin,
 		HMMoveMixin,
 		HMScrollMixin,
+		KeyboardMixin,
+		MoveMixin,
+		ScrollMixin,
 		AbstractActionChains,
 ):
 	"""

osn_selenium/instances/sync/browsing_context.py

@@ -47,8 +47,8 @@ class BrowsingContext(UnifiedBrowsingContext, AbstractBrowsingContext):
 		
 		UnifiedBrowsingContext.__init__(self, selenium_browsing_context=selenium_browsing_context)
 	
-	def activate(self, context: str) -> Any:
-		return self._activate_impl(context=context)
+	def activate(self, context: str) -> None:
+		self._activate_impl(context=context)
 	
 	def add_event_handler(
 			self,

osn_selenium/instances/sync/script.py

@@ -1,4 +1,9 @@
-from typing import Any, Callable, Self
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Self
+)
 from osn_selenium.instances._typehints import SCRIPT_TYPEHINT
 from osn_selenium.instances.convert import get_legacy_instance
 from osn_selenium.instances.unified.script import UnifiedScript
@@ -38,7 +43,7 @@ class Script(UnifiedScript, AbstractScript):
 	def add_javascript_error_handler(self, handler: Callable[[Any], None]) -> int:
 		return self._add_javascript_error_handler_impl(handler=handler)
 	
-	def execute(self, script: str, *args: Any) -> Any:
+	def execute(self, script: str, *args: Any) -> Dict[str, Any]:
 		return self._execute_impl(script, *args)
 	
 	@classmethod

osn_selenium/instances/sync/shadow_root.py

@@ -1,11 +1,12 @@
 from selenium.webdriver.common.by import By
+from osn_selenium.instances._typehints import SHADOW_ROOT_TYPEHINT
 from typing import (
 	List,
 	Optional,
 	Self,
-	TYPE_CHECKING
+	TYPE_CHECKING,
+	Type
 )
-from osn_selenium.instances._typehints import SHADOW_ROOT_TYPEHINT
 from osn_selenium.exceptions.instance import (
 	CannotConvertTypeError
 )
@@ -14,6 +15,9 @@ from osn_selenium.abstract.instances.shadow_root import AbstractShadowRoot
 from selenium.webdriver.remote.shadowroot import (
 	ShadowRoot as legacyShadowRoot
 )
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
 from osn_selenium.instances.convert import (
 	get_legacy_instance,
 	get_sync_instance_wrapper
@@ -25,6 +29,28 @@ __all__ = ["ShadowRoot"]
 if TYPE_CHECKING:
 	from osn_selenium.instances.sync.web_element import WebElement
 
+_WEB_ELEMENT_TYPE: Optional[Type["WebElement"]] = None
+
+
+def _build_web_element(legacy_element: legacyWebElement):
+	"""
+	Builds a wrapped WebElement from a legacy element.
+
+	Args:
+		legacy_element (legacyWebElement): The legacy Selenium WebElement instance.
+
+	Returns:
+		WebElement: The wrapped WebElement instance.
+	"""
+	
+	global _WEB_ELEMENT_TYPE
+	
+	if _WEB_ELEMENT_TYPE is None:
+		from osn_selenium.instances.sync.web_element import WebElement
+		_WEB_ELEMENT_TYPE = WebElement
+	
+	return get_sync_instance_wrapper(wrapper_class=_WEB_ELEMENT_TYPE, legacy_object=legacy_element)
+
 
 class ShadowRoot(UnifiedShadowRoot, AbstractShadowRoot):
 	"""
@@ -47,17 +73,13 @@ class ShadowRoot(UnifiedShadowRoot, AbstractShadowRoot):
 	def find_element(self, by: str = By.ID, value: Optional[str] = None) -> "WebElement":
 		legacy_element = self._find_element_impl(by=by, value=value)
 		
-		from osn_selenium.instances.sync.web_element import WebElement
-		
-		return get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy_element)
+		return _build_web_element(legacy_element=legacy_element)
 	
 	def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List["WebElement"]:
 		legacy_elements = self._find_elements_impl(by=by, value=value)
 		
-		from osn_selenium.instances.sync.web_element import WebElement
-		
 		return [
-			get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy_element)
+			_build_web_element(legacy_element=legacy_element)
 			for legacy_element in legacy_elements
 		]
 	

osn_selenium/instances/sync/web_element.py

@@ -126,7 +126,7 @@ class WebElement(UnifiedWebElement, AbstractWebElement):
 		
 		return self.from_legacy(legacy_object=web_element)
 	
-	def rect(self) -> Dict:
+	def rect(self) -> Dict[str, int]:
 		return self._rect_impl()
 	
 	def screenshot(self, filename: str) -> bool:

osn_selenium/instances/trio_bidi/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/trio_bidi/shadow_root.py

@@ -0,0 +1,180 @@
+import math
+import trio
+from selenium.webdriver.common.by import By
+from osn_selenium.trio_bidi.mixin import TrioBiDiMixin
+from osn_selenium.instances._typehints import SHADOW_ROOT_TYPEHINT
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.shadow_root import UnifiedShadowRoot
+from osn_selenium.abstract.instances.shadow_root import AbstractShadowRoot
+from typing import (
+	List,
+	Optional,
+	Self,
+	TYPE_CHECKING,
+	Type,
+	Union
+)
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_trio_bidi_instance_wrapper
+)
+
+
+__all__ = ["ShadowRoot"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_bidi.web_element import WebElement
+
+_WEB_ELEMENT_TYPE: Optional[Type["WebElement"]] = None
+
+
+def _build_web_element(
+		legacy_element: legacyWebElement,
+		lock: trio.Lock,
+		limiter: trio.CapacityLimiter,
+		trio_token: Optional[trio.lowlevel.TrioToken] = None,
+		bidi_buffer_size: Union[int, float] = math.inf,
+):
+	"""
+	Builds a wrapped WebElement from a legacy element.
+
+	Args:
+		legacy_element (legacyWebElement): The legacy Selenium WebElement instance.
+		lock (trio.Lock): A Trio lock for managing concurrent access.
+		limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+	Returns:
+		WebElement: The wrapped WebElement instance.
+	"""
+	
+	global _WEB_ELEMENT_TYPE
+	
+	if _WEB_ELEMENT_TYPE is None:
+		from osn_selenium.instances.trio_bidi.web_element import WebElement
+		_WEB_ELEMENT_TYPE = WebElement
+	
+	return get_trio_bidi_instance_wrapper(
+			wrapper_class=_WEB_ELEMENT_TYPE,
+			legacy_object=legacy_element,
+			lock=lock,
+			limiter=limiter,
+			trio_token=trio_token,
+			bidi_buffer_size=bidi_buffer_size,
+	)
+
+
+class ShadowRoot(UnifiedShadowRoot, TrioBiDiMixin, AbstractShadowRoot):
+	"""
+	Wrapper for the legacy Selenium ShadowRoot instance.
+
+	Represents the root of a Shadow DOM tree, allowing element search
+	within the encapsulated shadow scope.
+	"""
+	
+	def __init__(
+			self,
+			selenium_shadow_root: legacyShadowRoot,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> None:
+		"""
+		Initializes the ShadowRoot wrapper.
+
+		Args:
+			selenium_shadow_root (legacyShadowRoot): The legacy Selenium ShadowRoot instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		UnifiedShadowRoot.__init__(self, selenium_shadow_root=selenium_shadow_root)
+		
+		TrioBiDiMixin.__init__(
+				self,
+				lock=lock,
+				limiter=limiter,
+				token=trio_token,
+				buffer_size=bidi_buffer_size
+		)
+	
+	async def find_element(self, by: str = By.ID, value: Optional[str] = None) -> "WebElement":
+		legacy_element = await self.sync_to_trio(sync_function=self._find_element_impl)(by=by, value=value)
+		
+		return _build_web_element(
+				legacy_element=legacy_element,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+				trio_token=self._trio_token,
+				bidi_buffer_size=self._trio_bidi_buffer_size,
+		)
+	
+	async def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List["WebElement"]:
+		legacy_elements = await self.sync_to_trio(sync_function=self._find_elements_impl)(by=by, value=value)
+		
+		return [
+			_build_web_element(
+					legacy_element=legacy_element,
+					lock=self._lock,
+					limiter=self._capacity_limiter,
+					trio_token=self._trio_token,
+					bidi_buffer_size=self._trio_bidi_buffer_size,
+			)
+			for legacy_element in legacy_elements
+		]
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SHADOW_ROOT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium ShadowRoot object.
+
+		This factory method is used to wrap an existing Selenium ShadowRoot
+		instance into the new interface.
+
+		Args:
+			legacy_object (SHADOW_ROOT_TYPEHINT): The legacy Selenium ShadowRoot instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		Returns:
+			Self: A new instance of a class implementing ShadowRoot.
+		"""
+		
+		legacy_shadow_root_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_shadow_root_obj, legacyShadowRoot):
+			raise CannotConvertTypeError(from_=legacyShadowRoot, to_=legacy_object)
+		
+		return cls(
+				selenium_shadow_root=legacy_shadow_root_obj,
+				lock=lock,
+				limiter=limiter,
+				trio_token=trio_token,
+				bidi_buffer_size=bidi_buffer_size,
+		)
+	
+	async def id(self) -> str:
+		return await self.sync_to_trio(sync_function=self._id_impl)()
+	
+	@property
+	def legacy(self) -> legacyShadowRoot:
+		return self._legacy_impl

osn_selenium/instances/trio_bidi/switch_to.py

@@ -0,0 +1,143 @@
+import math
+import trio
+from typing_extensions import deprecated
+from typing import (
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.trio_bidi.mixin import TrioBiDiMixin
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.trio_bidi.web_element import WebElement
+from osn_selenium.instances.unified.switch_to import UnifiedSwitchTo
+from osn_selenium.abstract.instances.switch_to import AbstractSwitchTo
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from osn_selenium.exceptions.experimental import (
+	NotImplementedExperimentalFeatureError
+)
+from osn_selenium.instances._typehints import (
+	SWITCH_TO_TYPEHINT,
+	WEB_ELEMENT_TYPEHINT
+)
+
+
+__all__ = ["SwitchTo"]
+
+
+class SwitchTo(UnifiedSwitchTo, TrioBiDiMixin, AbstractSwitchTo):
+	"""
+	Wrapper for the legacy Selenium SwitchTo instance.
+
+	Provides mechanisms to change the driver's focus to different frames,
+	windows, or alerts.
+	"""
+	
+	def __init__(
+			self,
+			selenium_switch_to: legacySwitchTo,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> None:
+		"""
+		Initializes the SwitchTo wrapper.
+
+		Args:
+			selenium_switch_to (legacySwitchTo): The legacy Selenium SwitchTo instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		UnifiedSwitchTo.__init__(self, selenium_switch_to=selenium_switch_to)
+		
+		TrioBiDiMixin.__init__(
+				self,
+				lock=lock,
+				limiter=limiter,
+				token=trio_token,
+				buffer_size=bidi_buffer_size
+		)
+	
+	@deprecated(
+			"This method is currently not supported. It will raise 'NotImplementedExperimentalFeatureError' on call."
+	)
+	async def active_element(self) -> WebElement:
+		raise NotImplementedExperimentalFeatureError(name="SwitchTo.active_element")
+	
+	@deprecated(
+			"This method is currently not supported. It will raise 'NotImplementedExperimentalFeatureError' on call."
+	)
+	async def alert(self):
+		raise NotImplementedExperimentalFeatureError(name="SwitchTo.alert")
+	
+	@deprecated(
+			"This method is currently not supported. It will raise 'NotImplementedExperimentalFeatureError' on call."
+	)
+	async def default_content(self) -> None:
+		raise NotImplementedExperimentalFeatureError(name="SwitchTo.default_content")
+	
+	@deprecated(
+			"This method is currently not supported. It will raise 'NotImplementedExperimentalFeatureError' on call."
+	)
+	async def frame(self, frame_reference: Union[str, int, WEB_ELEMENT_TYPEHINT]) -> None:
+		raise NotImplementedExperimentalFeatureError(name="SwitchTo.frame")
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SWITCH_TO_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium SwitchTo object.
+
+		This factory method is used to wrap an existing Selenium SwitchTo
+		instance into the new interface.
+
+		Args:
+			legacy_object (SWITCH_TO_TYPEHINT): The legacy Selenium SwitchTo instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		Returns:
+			Self: A new instance of a class implementing SwitchTo.
+		"""
+		
+		legacy_switch_to_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_switch_to_obj, legacySwitchTo):
+			raise CannotConvertTypeError(from_=legacySwitchTo, to_=legacy_object)
+		
+		return cls(
+				selenium_switch_to=legacy_switch_to_obj,
+				lock=lock,
+				limiter=limiter,
+				trio_token=trio_token,
+				bidi_buffer_size=bidi_buffer_size,
+		)
+	
+	@property
+	def legacy(self) -> legacySwitchTo:
+		return self._legacy_impl
+	
+	async def new_window(self, type_hint: Optional[str] = None) -> None:
+		await self.sync_to_trio(sync_function=self._new_window_impl)(type_hint=type_hint)
+	
+	async def parent_frame(self) -> None:
+		raise NotImplementedExperimentalFeatureError(name="SwitchTo.parent_frame")
+	
+	async def window(self, window_name: str) -> None:
+		await self.sync_to_trio(sync_function=self._window_impl)(window_name=window_name)

osn_selenium/instances/trio_bidi/web_driver_wait.py

@@ -0,0 +1,124 @@
+import math
+import trio
+from osn_selenium.trio_bidi.mixin import TrioBiDiMixin
+from osn_selenium.instances.convert import get_legacy_instance
+from typing import (
+	Callable,
+	Optional,
+	Self,
+	TypeVar,
+	Union
+)
+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, TrioBiDiMixin, 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,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> 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.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		UnifiedWebDriverWait.__init__(self, selenium_webdriver_wait=selenium_webdriver_wait)
+		
+		TrioBiDiMixin.__init__(
+				self,
+				lock=lock,
+				limiter=limiter,
+				token=trio_token,
+				buffer_size=bidi_buffer_size
+		)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: legacyWebDriverWait,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> 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.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		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,
+				trio_token=trio_token,
+				bidi_buffer_size=bidi_buffer_size,
+		)
+	
+	@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)