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

osn_selenium/webdrivers/trio_threads/blink/settings.py

@@ -0,0 +1,63 @@
+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.webdrivers.trio_threads.core.settings import CoreSettingsMixin
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+from osn_selenium.abstract.webdriver.blink.settings import (
+	AbstractBlinkSettingsMixin
+)
+
+
+__all__ = ["BlinkSettingsMixin"]
+
+
+class BlinkSettingsMixin(
+		UnifiedBlinkSettingsMixin,
+		CoreSettingsMixin,
+		AbstractBlinkSettingsMixin
+):
+	"""
+	Mixin for configuring and updating settings of the Blink WebDriver.
+
+	Provides methods to modify browser flags, window rectangles, and other
+	configuration parameters either before startup or during a reset.
+	"""
+	
+	async def reset_settings(
+			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:
+		await self.sync_to_trio(sync_function=self._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
+		)
+	
+	async def update_settings(
+			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:
+		await self.sync_to_trio(sync_function=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
+		)

osn_selenium/webdrivers/trio_threads/chrome/__init__.py

@@ -0,0 +1,81 @@
+import trio
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.chrome import ChromeFlagsManager
+from osn_selenium.flags.models.chrome import ChromeFlags
+from osn_selenium.dev_tools.settings import DevToolsSettings
+from osn_selenium.webdrivers.trio_threads.blink import BlinkWebDriver
+from osn_selenium.webdrivers.trio_threads.chrome.base import ChromeBaseMixin
+from osn_selenium.abstract.webdriver.chrome import (
+	AbstractChromeWebDriver
+)
+from osn_selenium.webdrivers.trio_threads.chrome.settings import ChromeSettingsMixin
+from osn_selenium.webdrivers.trio_threads.chrome.lifecycle import ChromeLifecycleMixin
+
+
+__all__ = ["ChromeWebDriver"]
+
+
+class ChromeWebDriver(
+		ChromeBaseMixin,
+		ChromeLifecycleMixin,
+		ChromeSettingsMixin,
+		BlinkWebDriver,
+		AbstractChromeWebDriver,
+):
+	"""
+	Concrete Chrome WebDriver implementation combining all functional mixins.
+
+	This class aggregates lifecycle management, element interaction, navigation,
+	and browser-specific features into a single usable driver instance.
+	"""
+	
+	def __init__(
+			self,
+			webdriver_path: str,
+			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,
+			devtools_settings: Optional[DevToolsSettings] = None,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	):
+		BlinkWebDriver.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				use_browser_exe=use_browser_exe,
+				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,
+				devtools_settings=devtools_settings,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		ChromeBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				webdriver_path=webdriver_path,
+				architecture="trio_threads",
+				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,
+				capacity_limiter=capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/chrome/base.py

@@ -0,0 +1,107 @@
+import trio
+from typing import 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.webdrivers.trio_threads.blink.base import BlinkBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.chrome.base import (
+	UnifiedChromeBaseMixin
+)
+from osn_selenium.abstract.webdriver.chrome.base import (
+	AbstractChromeBaseMixin
+)
+
+
+__all__ = ["ChromeBaseMixin"]
+
+
+class ChromeBaseMixin(UnifiedChromeBaseMixin, BlinkBaseMixin, AbstractChromeBaseMixin):
+	"""
+	Base mixin for Chrome WebDrivers handling core initialization and state management.
+
+	This class serves as the foundation for browser-specific implementations, managing
+	the WebDriver executable path, configuration flags, timeouts, and the active
+	driver instance.
+	"""
+	
+	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,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	):
+		"""
+		Initializes the Trio-based Chrome WebDriver mixin.
+
+		Args:
+			webdriver_path (str): Path to the ChromeDriver executable.
+			architecture (ARCHITECTURE_TYPEHINT): System architecture.
+			flags_manager_type (Type[ChromeFlagsManager]): The class type used for managing Chrome flags.
+				Defaults to ChromeFlagsManager.
+			use_browser_exe (bool): Whether to use a specific browser executable path or auto-detect.
+				Defaults to True.
+			browser_name_in_system (str): The name of the browser in the system registry or path.
+				Defaults to "Google Chrome".
+			browser_exe (Optional[PATH_TYPEHINT]): Explicit path to the Chrome browser executable.
+			flags (Optional[ChromeFlags]): Initial set of flags.
+			start_page_url (str): The initial URL. Defaults to "about:blank".
+			implicitly_wait (int): Default implicit wait time.
+			page_load_timeout (int): Default page load timeout.
+			script_timeout (int): Default script timeout.
+			window_rect (Optional[WindowRect]): Initial window dimensions.
+			capacity_limiter (Optional[trio.CapacityLimiter]): Trio capacity limiter.
+		"""
+		
+		BlinkBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				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,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		UnifiedChromeBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				flags_manager_type=flags_manager_type,
+				use_browser_exe=use_browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				browser_exe=browser_exe,
+				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,
+		)
+	
+	@property
+	def driver(self) -> Optional[legacyChrome]:
+		return self._driver_impl

osn_selenium/webdrivers/trio_threads/chrome/lifecycle.py

@@ -0,0 +1,63 @@
+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.trio_threads.blink import BlinkLifecycleMixin
+from osn_selenium.webdrivers.unified.chrome.lifecycle import (
+	UnifiedChromeLifecycleMixin
+)
+from osn_selenium.abstract.webdriver.chrome.lifecycle import (
+	AbstractChromeLifecycleMixin
+)
+
+
+__all__ = ["ChromeLifecycleMixin"]
+
+
+class ChromeLifecycleMixin(
+		UnifiedChromeLifecycleMixin,
+		BlinkLifecycleMixin,
+		AbstractChromeLifecycleMixin
+):
+	"""
+	Mixin for managing the lifecycle of the Chrome WebDriver.
+
+	Handles the creation, startup, shutdown, and restarting processes of the
+	underlying browser instance, ensuring clean session management.
+	"""
+	
+	async def restart_webdriver(
+			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:
+		await self.sync_to_trio(sync_function=self._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,
+		)
+	
+	async def start_webdriver(
+			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:
+		await self.sync_to_trio(sync_function=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/trio_threads/chrome/settings.py

@@ -0,0 +1,63 @@
+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.trio_threads.blink import BlinkSettingsMixin
+from osn_selenium.webdrivers.unified.chrome.settings import (
+	UnifiedChromeSettingsMixin
+)
+from osn_selenium.abstract.webdriver.chrome.settings import (
+	AbstractChromeSettingsMixin
+)
+
+
+__all__ = ["ChromeSettingsMixin"]
+
+
+class ChromeSettingsMixin(
+		UnifiedChromeSettingsMixin,
+		BlinkSettingsMixin,
+		AbstractChromeSettingsMixin
+):
+	"""
+	Mixin for configuring and updating settings of the Chrome WebDriver.
+
+	Provides methods to modify browser flags, window rectangles, and other
+	configuration parameters either before startup or during a reset.
+	"""
+	
+	async def reset_settings(
+			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:
+		await self.sync_to_trio(sync_function=self._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,
+		)
+	
+	async def update_settings(
+			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:
+		await self.sync_to_trio(sync_function=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,
+		)

osn_selenium/webdrivers/trio_threads/core/__init__.py

@@ -0,0 +1,109 @@
+import trio
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.dev_tools.manager import DevTools
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.dev_tools.settings import DevToolsSettings
+from osn_selenium.webdrivers.trio_threads.core.auth import CoreAuthMixin
+from osn_selenium.webdrivers.trio_threads.core.base import CoreBaseMixin
+from osn_selenium.webdrivers.trio_threads.core.file import CoreFileMixin
+from osn_selenium.abstract.webdriver.core import (
+	AbstractCoreWebDriver
+)
+from osn_selenium.webdrivers.trio_threads.core.script import CoreScriptMixin
+from osn_selenium.webdrivers.trio_threads.core.window import CoreWindowMixin
+from osn_selenium.webdrivers.trio_threads.core.actions import CoreActionsMixin
+from osn_selenium.webdrivers.trio_threads.core.capture import CoreCaptureMixin
+from osn_selenium.webdrivers.trio_threads.core.element import CoreElementMixin
+from osn_selenium.webdrivers.trio_threads.core.storage import CoreStorageMixin
+from osn_selenium.webdrivers.trio_threads.core.devtools import CoreDevToolsMixin
+from osn_selenium.webdrivers.trio_threads.core.settings import CoreSettingsMixin
+from osn_selenium.webdrivers.trio_threads.core.timeouts import CoreTimeoutsMixin
+from osn_selenium.webdrivers.trio_threads.core.lifecycle import CoreLifecycleMixin
+from osn_selenium.webdrivers.trio_threads.core.comonents import CoreComponentsMixin
+from osn_selenium.webdrivers.trio_threads.core.navigation import CoreNavigationMixin
+
+
+__all__ = ["CoreWebDriver"]
+
+
+class CoreWebDriver(
+		CoreActionsMixin,
+		CoreAuthMixin,
+		CoreBaseMixin,
+		CoreCaptureMixin,
+		CoreComponentsMixin,
+		CoreDevToolsMixin,
+		CoreElementMixin,
+		CoreFileMixin,
+		CoreLifecycleMixin,
+		CoreNavigationMixin,
+		CoreScriptMixin,
+		CoreSettingsMixin,
+		CoreStorageMixin,
+		CoreTimeoutsMixin,
+		CoreWindowMixin,
+		AbstractCoreWebDriver,
+):
+	"""
+	Concrete Core WebDriver implementation combining all functional mixins.
+
+	This class aggregates lifecycle management, element interaction, navigation,
+	and browser-specific features into a single usable driver instance.
+	"""
+	
+	def __init__(
+			self,
+			webdriver_path: str,
+			flags_manager_type: Type[BrowserFlagsManager] = BrowserFlagsManager,
+			flags: Optional[BrowserFlags] = None,
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+			devtools_settings: Optional[DevToolsSettings] = None,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	) -> None:
+		"""
+		Initializes the main WebDriver instance with Trio thread support.
+
+		Combines multiple functional mixins and initializes the JavaScript executor
+		along with base configuration components.
+
+		Args:
+			webdriver_path (str): The file path to the WebDriver executable.
+			flags_manager_type (Type[BrowserFlagsManager]): The class type used to manage
+				browser-specific configuration flags. Defaults to BrowserFlagsManager.
+			flags (Optional[BrowserFlags]): Initial set of browser flags or options
+				to apply upon startup. Defaults to None.
+			implicitly_wait (int): The amount of time (in seconds) that the driver should
+				wait when searching for elements. Defaults to 5.
+			page_load_timeout (int): The amount of time (in seconds) to wait for a page
+				load to complete. Defaults to 5.
+			script_timeout (int): The amount of time (in seconds) to wait for an
+				asynchronous script to finish execution. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial size and position of the
+				browser window. Defaults to None.
+			devtools_settings (Optional[DevToolsSettings]): Configuration for Chrome DevTools Protocol.
+			capacity_limiter (Optional[trio.CapacityLimiter]): A Trio capacity limiter used to
+				throttle concurrent thread-based operations. Defaults to None.
+		"""
+		
+		CoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				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,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		self._devtools = DevTools(parent_webdriver=self, devtools_settings=devtools_settings)
+	
+	@property
+	def devtools(self) -> DevTools:
+		return self._devtools

osn_selenium/webdrivers/trio_threads/core/actions.py

@@ -0,0 +1,72 @@
+from typing import (
+	Iterable,
+	List,
+	Optional
+)
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium._typehints import DEVICES_TYPEHINT
+from osn_selenium.webdrivers._bridges import (
+	get_js_executor_bridge
+)
+from osn_selenium.instances.trio_threads.action_chains import ActionChains
+from osn_selenium.webdrivers.trio_threads.core.script import CoreScriptMixin
+from osn_selenium.instances.trio_threads.web_driver_wait import WebDriverWait
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.actions import (
+	UnifiedCoreActionsMixin
+)
+from osn_selenium.abstract.webdriver.core.actions import (
+	AbstractCoreActionsMixin
+)
+
+
+__all__ = ["CoreActionsMixin"]
+
+
+class CoreActionsMixin(
+		UnifiedCoreActionsMixin,
+		CoreScriptMixin,
+		TrioThreadMixin,
+		AbstractCoreActionsMixin
+):
+	"""
+	Mixin providing high-level interaction capabilities for Core WebDrivers.
+
+	Includes factories for standard and human-like ActionChains, as well as
+	custom WebDriverWait implementations.
+	"""
+	
+	def action_chains(
+			self,
+			duration: int = 250,
+			devices: Optional[List[DEVICES_TYPEHINT]] = None,
+	) -> ActionChains:
+		legacy = self._action_chains_impl(duration=duration, devices=devices)
+		
+		return ActionChains(
+				selenium_action_chains=legacy,
+				execute_js_script_function=get_js_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	def web_driver_wait(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> WebDriverWait:
+		legacy = self._web_driver_wait_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions
+		)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebDriverWait,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/core/auth.py

@@ -0,0 +1,88 @@
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	List,
+	Optional,
+	Union
+)
+from osn_selenium.instances.trio_threads.fedcm import FedCM
+from osn_selenium.instances.trio_threads.dialog import Dialog
+from osn_selenium.webdrivers.unified.core.auth import UnifiedCoreAuthMixin
+from osn_selenium.abstract.webdriver.core.auth import (
+	AbstractCoreAuthMixin
+)
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from selenium.webdriver.common.virtual_authenticator import (
+	Credential,
+	VirtualAuthenticatorOptions
+)
+
+
+__all__ = ["CoreAuthMixin"]
+
+
+class CoreAuthMixin(UnifiedCoreAuthMixin, TrioThreadMixin, AbstractCoreAuthMixin):
+	"""
+	Mixin handling authentication and credential management for Core WebDrivers.
+
+	Provides interfaces for adding/removing credentials, managing virtual
+	authenticators, and handling Federated Credential Management (FedCM) dialogs.
+	"""
+	
+	async def add_credential(self, credential: Credential) -> None:
+		await self.sync_to_trio(sync_function=self._add_credential_impl)(credential=credential)
+	
+	async def add_virtual_authenticator(self, options: VirtualAuthenticatorOptions) -> None:
+		await self.sync_to_trio(sync_function=self._add_virtual_authenticator_impl)(options=options)
+	
+	async def fedcm(self) -> FedCM:
+		legacy = await self.sync_to_trio(sync_function=self._fedcm_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=FedCM,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def fedcm_dialog(
+			self,
+			timeout: int = 5,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Any = None,
+	) -> Dialog:
+		legacy = await self.sync_to_trio(sync_function=self._fedcm_dialog_impl)(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Dialog,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def get_credentials(self) -> List[Credential]:
+		return await self.sync_to_trio(sync_function=self._get_credentials_impl)()
+	
+	async def remove_all_credentials(self) -> None:
+		await self.sync_to_trio(sync_function=self._remove_all_credentials_impl)()
+	
+	async def remove_credential(self, credential_id: Union[str, bytearray]) -> None:
+		await self.sync_to_trio(sync_function=self._remove_credential_impl)(credential_id=credential_id)
+	
+	async def remove_virtual_authenticator(self) -> None:
+		await self.sync_to_trio(sync_function=self._remove_virtual_authenticator_impl)()
+	
+	async def set_user_verified(self, verified: bool) -> None:
+		await self.sync_to_trio(sync_function=self._set_user_verified_impl)(verified=verified)
+	
+	async def supports_fedcm(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._supports_fedcm_impl)()
+	
+	async def virtual_authenticator_id(self) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._virtual_authenticator_id_impl)()