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

osn_selenium/instances/trio_threads/alert.py

@@ -0,0 +1,87 @@
+import trio
+from typing import Optional, Self
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances._typehints import ALERT_TYPEHINT
+from osn_selenium.instances.unified.alert import UnifiedAlert
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.abstract.instances.alert import AbstractAlert
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+
+
+__all__ = ["Alert"]
+
+
+class Alert(UnifiedAlert, TrioThreadMixin, AbstractAlert):
+	"""
+	Wrapper for the legacy Selenium Alert instance.
+
+	Manages browser alerts, prompts, and confirmation dialogs, allowing
+	acceptance, dismissal, text retrieval, and input.
+	"""
+	
+	def __init__(
+			self,
+			selenium_alert: legacyAlert,
+			lock: trio.Lock,
+			limiter: Optional[trio.CapacityLimiter] = None,
+	) -> None:
+		"""
+		Initializes the Alert wrapper.
+
+		Args:
+			selenium_alert (legacyAlert): The legacy Selenium Alert instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedAlert.__init__(self, selenium_alert=selenium_alert)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def accept(self) -> None:
+		await self.sync_to_trio(sync_function=self._accept_impl)()
+	
+	async def dismiss(self) -> None:
+		await self.sync_to_trio(sync_function=self._dismiss_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: ALERT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Alert object.
+
+		This factory method is used to wrap an existing Selenium Alert
+		instance into the new interface.
+
+		Args:
+			legacy_object (ALERT_TYPEHINT): The legacy Selenium Alert instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing Alert.
+		"""
+		
+		legacy_alert_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_alert_obj, legacyAlert):
+			raise CannotConvertTypeError(from_=legacyAlert, to_=legacy_object)
+		
+		return cls(selenium_alert=legacy_alert_obj, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyAlert:
+		return self._legacy_impl
+	
+	async def send_keys(self, keysToSend: str) -> None:
+		await self.sync_to_trio(sync_function=self._send_keys_impl)(keysToSend=keysToSend)
+	
+	async def text(self) -> str:
+		return await self.sync_to_trio(sync_function=self._text_impl)()

osn_selenium/instances/trio_threads/browser.py

@@ -0,0 +1,90 @@
+import trio
+from typing import List, Self
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances._typehints import BROWSER_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.browser import UnifiedBrowser
+from osn_selenium.abstract.instances.browser import AbstractBrowser
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.browser import (
+	Browser as legacyBrowser,
+	ClientWindowInfo
+)
+
+
+__all__ = ["Browser"]
+
+
+class Browser(UnifiedBrowser, TrioThreadMixin, AbstractBrowser):
+	"""
+	Wrapper for the legacy Selenium BiDi Browser instance.
+
+	Provides methods to manage user contexts (profiles) and inspect client
+	window information via the WebDriver BiDi protocol.
+	"""
+	
+	def __init__(
+			self,
+			selenium_browser: legacyBrowser,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Browser wrapper.
+
+		Args:
+			selenium_browser (legacyBrowser): The legacy Selenium Browser instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedBrowser.__init__(self, selenium_browser=selenium_browser)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def create_user_context(self) -> str:
+		return await self.sync_to_trio(sync_function=self._create_user_context_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: BROWSER_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Browser object.
+
+		This factory method is used to wrap an existing Selenium Browser
+		instance into the new interface.
+
+		Args:
+			legacy_object (BROWSER_TYPEHINT): The legacy Selenium Browser instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing Browser.
+		"""
+		
+		legacy_browser_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_browser_obj, legacyBrowser):
+			raise CannotConvertTypeError(from_=legacyBrowser, to_=legacy_object)
+		
+		return cls(selenium_browser=legacy_browser_obj, limiter=limiter, lock=lock)
+	
+	async def get_client_windows(self) -> List[ClientWindowInfo]:
+		return await self.sync_to_trio(sync_function=self._get_client_windows_impl)()
+	
+	async def get_user_contexts(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_user_contexts_impl)()
+	
+	@property
+	def legacy(self) -> legacyBrowser:
+		return self._legacy_impl
+	
+	async def remove_user_context(self, user_context_id: str) -> None:
+		await self.sync_to_trio(sync_function=self._remove_user_context_impl)(user_context_id=user_context_id)

osn_selenium/instances/trio_threads/browsing_context.py

@@ -0,0 +1,216 @@
+import trio
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	BROWSING_CONTEXT_TYPEHINT
+)
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.unified.browsing_context import (
+	UnifiedBrowsingContext
+)
+from osn_selenium.abstract.instances.browsing_context import (
+	AbstractBrowsingContext
+)
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext,
+	BrowsingContextInfo
+)
+
+
+__all__ = ["BrowsingContext"]
+
+
+class BrowsingContext(UnifiedBrowsingContext, TrioThreadMixin, AbstractBrowsingContext):
+	"""
+	Wrapper for the legacy Selenium BiDi BrowsingContext instance (Trio/Async).
+
+	Controls browser tabs and windows (contexts), allowing navigation,
+	reloading, closing, screenshotting, and DOM tree inspection.
+	"""
+	
+	def __init__(
+			self,
+			selenium_browsing_context: legacyBrowsingContext,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the BrowsingContext wrapper.
+
+		Args:
+			selenium_browsing_context (legacyBrowsingContext): The legacy Selenium instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedBrowsingContext.__init__(self, selenium_browsing_context=selenium_browsing_context)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def activate(self, context: str) -> Any:
+		return await self.sync_to_trio(sync_function=self._activate_impl)(context=context)
+	
+	async def add_event_handler(
+			self,
+			event: str,
+			callback: Callable,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return await self.sync_to_trio(sync_function=self._add_event_handler_impl)(event=event, callback=callback, contexts=contexts)
+	
+	async def capture_screenshot(
+			self,
+			context: str,
+			origin: str = "viewport",
+			format: Optional[Dict] = None,
+			clip: Optional[Dict] = None,
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._capture_screenshot_impl)(context=context, origin=origin, format=format, clip=clip)
+	
+	async def clear_event_handlers(self) -> None:
+		await self.sync_to_trio(sync_function=self._clear_event_handlers_impl)()
+	
+	async def close(self, context: str, prompt_unload: bool = False) -> None:
+		await self.sync_to_trio(sync_function=self._close_impl)(context=context, prompt_unload=prompt_unload)
+	
+	async def create(
+			self,
+			type: str,
+			reference_context: Optional[str] = None,
+			background: bool = False,
+			user_context: Optional[str] = None,
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._create_impl)(
+				type=type,
+				reference_context=reference_context,
+				background=background,
+				user_context=user_context
+		)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: BROWSING_CONTEXT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium BrowsingContext object.
+
+		This factory method is used to wrap an existing Selenium BrowsingContext
+		instance into the new interface.
+
+		Args:
+			legacy_object (BROWSING_CONTEXT_TYPEHINT): The legacy Selenium BrowsingContext instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing BrowsingContext.
+		"""
+		
+		legacy_browsing_context_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_browsing_context_obj, legacyBrowsingContext):
+			raise CannotConvertTypeError(from_=legacyBrowsingContext, to_=legacy_object)
+		
+		return cls(
+				selenium_browsing_context=legacy_browsing_context_obj,
+				lock=lock,
+				limiter=limiter
+		)
+	
+	async def get_tree(self, max_depth: Optional[int] = None, root: Optional[str] = None) -> List[BrowsingContextInfo]:
+		return await self.sync_to_trio(sync_function=self._get_tree_impl)(max_depth=max_depth, root=root)
+	
+	async def handle_user_prompt(
+			self,
+			context: str,
+			accept: Optional[bool] = None,
+			user_text: Optional[str] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._handle_user_prompt_impl)(context=context, accept=accept, user_text=user_text)
+	
+	@property
+	def legacy(self) -> legacyBrowsingContext:
+		return self._legacy_impl
+	
+	async def locate_nodes(
+			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 await self.sync_to_trio(sync_function=self._locate_nodes_impl)(
+				context=context,
+				locator=locator,
+				max_node_count=max_node_count,
+				serialization_options=serialization_options,
+				start_nodes=start_nodes
+		)
+	
+	async def navigate(self, context: str, url: str, wait: Optional[str] = None) -> Dict:
+		return await self.sync_to_trio(sync_function=self._navigate_impl)(context=context, url=url, wait=wait)
+	
+	async def print(
+			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 await self.sync_to_trio(sync_function=self._print_impl)(
+				context=context,
+				background=background,
+				margin=margin,
+				orientation=orientation,
+				page=page,
+				page_ranges=page_ranges,
+				scale=scale,
+				shrink_to_fit=shrink_to_fit
+		)
+	
+	async def reload(
+			self,
+			context: str,
+			ignore_cache: Optional[bool] = None,
+			wait: Optional[str] = None,
+	) -> Dict:
+		return await self.sync_to_trio(sync_function=self._reload_impl)(context=context, ignore_cache=ignore_cache, wait=wait)
+	
+	async def remove_event_handler(self, event: str, callback_id: int) -> None:
+		await self.sync_to_trio(sync_function=self._remove_event_handler_impl)(event=event, callback_id=callback_id)
+	
+	async def set_viewport(
+			self,
+			context: Optional[str] = None,
+			viewport: Optional[Dict] = None,
+			device_pixel_ratio: Optional[float] = None,
+			user_contexts: Optional[List[str]] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._set_viewport_impl)(
+				context=context,
+				viewport=viewport,
+				device_pixel_ratio=device_pixel_ratio,
+				user_contexts=user_contexts
+		)
+	
+	async def traverse_history(self, context: str, delta: int) -> Dict:
+		return await self.sync_to_trio(sync_function=self._traverse_history_impl)(context=context, delta=delta)

osn_selenium/instances/trio_threads/dialog.py

@@ -0,0 +1,99 @@
+import trio
+from typing import List, Optional, Self
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from selenium.webdriver.common.fedcm.account import Account
+from osn_selenium.instances._typehints import DIALOG_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.dialog import UnifiedDialog
+from osn_selenium.abstract.instances.dialog import AbstractDialog
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.fedcm.dialog import (
+	Dialog as legacyDialog
+)
+
+
+__all__ = ["Dialog"]
+
+
+class Dialog(UnifiedDialog, TrioThreadMixin, AbstractDialog):
+	"""
+	Wrapper for the legacy Selenium FedCM Dialog instance.
+
+	Handles Federated Credential Management dialogs, including account selection
+	and dismissal.
+	"""
+	
+	def __init__(
+			self,
+			selenium_dialog: legacyDialog,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Dialog wrapper.
+
+		Args:
+			selenium_dialog (legacyDialog): The legacy Selenium Dialog instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedDialog.__init__(self, selenium_dialog=selenium_dialog)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def accept(self) -> None:
+		await self.sync_to_trio(sync_function=self._accept_impl)()
+	
+	async def dismiss(self) -> None:
+		await self.sync_to_trio(sync_function=self._dismiss_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: DIALOG_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Dialog object.
+
+		This factory method is used to wrap an existing Selenium Dialog
+		instance into the new interface.
+
+		Args:
+			legacy_object (DIALOG_TYPEHINT): The legacy Selenium Dialog instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing Dialog.
+		"""
+		
+		legacy_dialog_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_dialog_obj, legacyDialog):
+			raise CannotConvertTypeError(from_=legacyDialog, to_=legacy_object)
+		
+		return cls(selenium_dialog=legacy_dialog_obj, lock=lock, limiter=limiter)
+	
+	async def get_accounts(self) -> List[Account]:
+		return await self.sync_to_trio(sync_function=self._get_accounts_impl)()
+	
+	@property
+	def legacy(self) -> legacyDialog:
+		return self._legacy_impl
+	
+	async def select_account(self, index: int) -> None:
+		await self.sync_to_trio(sync_function=self._select_account_impl)(index=index)
+	
+	async def subtitle(self) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._subtitle_impl)()
+	
+	async def title(self) -> str:
+		return await self.sync_to_trio(sync_function=self._title_impl)()
+	
+	async def type(self) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._type_impl)()

osn_selenium/instances/trio_threads/fedcm.py

@@ -0,0 +1,110 @@
+import trio
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	Dict,
+	List,
+	Optional,
+	Self
+)
+from osn_selenium.instances._typehints import FEDCM_TYPEHINT
+from osn_selenium.instances.unified.fedcm import UnifiedFedCM
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.abstract.instances.fedcm import AbstractFedCM
+from selenium.webdriver.remote.fedcm import FedCM as legacyFedCM
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+
+
+__all__ = ["FedCM"]
+
+
+class FedCM(UnifiedFedCM, TrioThreadMixin, AbstractFedCM):
+	"""
+	Wrapper for the legacy Selenium FedCM instance.
+
+	Provides an interface for controlling the Federated Credential Management API,
+	including dialog delays and cooldown resets.
+	"""
+	
+	def __init__(
+			self,
+			selenium_fedcm: legacyFedCM,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the FedCM wrapper.
+
+		Args:
+			selenium_fedcm (legacyFedCM): The legacy Selenium FedCM instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedFedCM.__init__(self, selenium_fedcm=selenium_fedcm)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def accept(self) -> None:
+		await self.sync_to_trio(sync_function=self._accept_impl)()
+	
+	async def account_list(self) -> List[Dict]:
+		return await self.sync_to_trio(sync_function=self._account_list_impl)()
+	
+	async def dialog_type(self) -> str:
+		return await self.sync_to_trio(sync_function=self._dialog_type_impl)()
+	
+	async def disable_delay(self) -> None:
+		await self.sync_to_trio(sync_function=self._disable_delay_impl)()
+	
+	async def dismiss(self) -> None:
+		await self.sync_to_trio(sync_function=self._dismiss_impl)()
+	
+	async def enable_delay(self) -> None:
+		await self.sync_to_trio(sync_function=self._enable_delay_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: FEDCM_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium FedCM object.
+
+		This factory method is used to wrap an existing Selenium FedCM
+		instance into the new interface.
+
+		Args:
+			legacy_object (FEDCM_TYPEHINT): The legacy Selenium FedCM instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing FedCM.
+		"""
+		
+		legacy_fedcm_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_fedcm_obj, legacyFedCM):
+			raise CannotConvertTypeError(from_=legacyFedCM, to_=legacy_object)
+		
+		return cls(selenium_fedcm=legacy_fedcm_obj, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyFedCM:
+		return self._legacy_impl
+	
+	async def reset_cooldown(self) -> None:
+		await self.sync_to_trio(sync_function=self._reset_cooldown_impl)()
+	
+	async def select_account(self, index: int) -> None:
+		await self.sync_to_trio(sync_function=self._select_account_impl)(index=index)
+	
+	async def subtitle(self) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._subtitle_impl)()
+	
+	async def title(self) -> str:
+		return await self.sync_to_trio(sync_function=self._title_impl)()

osn_selenium/instances/trio_threads/mobile.py

@@ -0,0 +1,93 @@
+import trio
+from typing import List, Self, Union
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances._typehints import MOBILE_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.mobile import UnifiedMobile
+from osn_selenium.abstract.instances.mobile import AbstractMobile
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.remote.mobile import (
+	Mobile as legacyMobile,
+	_ConnectionType
+)
+
+
+__all__ = ["Mobile"]
+
+
+class Mobile(UnifiedMobile, TrioThreadMixin, AbstractMobile):
+	"""
+	Wrapper for the legacy Selenium Mobile instance.
+
+	Manages network connection types and context settings (e.g., native app vs web view)
+	for mobile emulation.
+	"""
+	
+	def __init__(
+			self,
+			selenium_mobile: legacyMobile,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Mobile wrapper.
+
+		Args:
+			selenium_mobile (legacyMobile): The legacy Selenium Mobile instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedMobile.__init__(self, selenium_mobile=selenium_mobile)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def context(self) -> str:
+		return await self.sync_to_trio(sync_function=self._get_context_impl)()
+	
+	async def contexts(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._contexts_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: MOBILE_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Mobile object.
+
+		This factory method is used to wrap an existing Selenium Mobile
+		instance into the new interface.
+
+		Args:
+			legacy_object (MOBILE_TYPEHINT): The legacy Selenium Mobile instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing Mobile.
+		"""
+		
+		legacy_mobile_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_mobile_obj, legacyMobile):
+			raise CannotConvertTypeError(from_=legacyMobile, to_=legacy_object)
+		
+		return cls(selenium_mobile=legacy_mobile_obj, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyMobile:
+		return self._legacy_impl
+	
+	async def network_connection(self) -> _ConnectionType:
+		return await self.sync_to_trio(sync_function=self._network_connection_impl)()
+	
+	async def set_context(self, new_context: str) -> None:
+		await self.sync_to_trio(sync_function=self._set_context_impl)(new_context=new_context)
+	
+	async def set_network_connection(self, network: Union[int, _ConnectionType]) -> _ConnectionType:
+		return await self.sync_to_trio(sync_function=self._set_network_connection_impl)(network=network)