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

osn_selenium/webdrivers/trio_threads/core/base.py

@@ -0,0 +1,191 @@
+import trio
+from osn_selenium.models import WindowRect
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Type
+)
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.common.bidi.session import Session
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT
+)
+from selenium.webdriver.remote.errorhandler import ErrorHandler
+from osn_selenium.executors.trio_threads.cdp import CDPExecutor
+from osn_selenium.executors.trio_threads.javascript import JSExecutor
+from selenium.webdriver.remote.locator_converter import LocatorConverter
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium.abstract.webdriver.core.base import (
+	AbstractCoreBaseMixin
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers._bridges import (
+	get_cdp_executor_bridge,
+	get_js_executor_bridge
+)
+
+
+__all__ = ["CoreBaseMixin"]
+
+
+class CoreBaseMixin(UnifiedCoreBaseMixin, TrioThreadMixin, AbstractCoreBaseMixin):
+	"""
+	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,
+			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,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	) -> None:
+		"""
+		Initializes the base mixin for Trio-based WebDrivers.
+
+		Sets up the core synchronization primitives, default timeouts,
+		and the browser flag manager.
+
+		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.
+			capacity_limiter (Optional[trio.CapacityLimiter]): A Trio capacity limiter used to
+				throttle concurrent thread-based operations. Defaults to None.
+		"""
+		
+		UnifiedCoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture="trio_threads",
+				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,
+		)
+		
+		TrioThreadMixin.__init__(
+				self,
+				lock=trio.Lock(),
+				limiter=capacity_limiter
+				if capacity_limiter is not None
+				else trio.CapacityLimiter(100),
+		)
+		
+		self._cdp_executor = CDPExecutor(
+				execute_function=get_cdp_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+		
+		self._js_executor = JSExecutor(
+				execute_function=get_js_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	@property
+	def architecture(self) -> ARCHITECTURES_TYPEHINT:
+		return self._architecture_impl
+	
+	@property
+	def capabilities(self) -> Dict[str, Any]:
+		return self._capabilities_impl()
+	
+	@property
+	def caps(self) -> Dict[str, Any]:
+		return self._caps_get_impl()
+	
+	@caps.setter
+	def caps(self, value: Dict[str, Any]) -> None:
+		self._caps_set_impl(value=value)
+	
+	@property
+	def cdp(self) -> CDPExecutor:
+		return self._cdp_executor
+	
+	@property
+	def command_executor(self) -> RemoteConnection:
+		return self._command_executor_get_impl()
+	
+	@command_executor.setter
+	def command_executor(self, value: RemoteConnection) -> None:
+		self._command_executor_set_impl(value=value)
+	
+	@property
+	def driver(self) -> Optional[legacyWebDriver]:
+		return self._driver_impl
+	
+	@property
+	def error_handler(self) -> ErrorHandler:
+		return self._error_handler_get_impl()
+	
+	@error_handler.setter
+	def error_handler(self, value: ErrorHandler) -> None:
+		self._error_handler_set_impl(value=value)
+	
+	async def execute(self, driver_command: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._execute_impl)(driver_command=driver_command, params=params)
+	
+	@property
+	def is_active(self) -> bool:
+		return self._is_active_impl
+	
+	@property
+	def javascript(self) -> JSExecutor:
+		return self._js_executor
+	
+	@property
+	def locator_converter(self) -> LocatorConverter:
+		return self._locator_converter_get_impl()
+	
+	@locator_converter.setter
+	def locator_converter(self, value: LocatorConverter) -> None:
+		self._locator_converter_set_impl(value=value)
+	
+	@property
+	def name(self) -> str:
+		return self._name_impl()
+	
+	@property
+	def pinned_scripts(self) -> Dict[str, Any]:
+		return self._pinned_scripts_get_impl()
+	
+	@pinned_scripts.setter
+	def pinned_scripts(self, value: Dict[str, Any]) -> None:
+		self._pinned_scripts_set_impl(value=value)
+	
+	async def session(self) -> Session:
+		return await self.sync_to_trio(sync_function=self._session_impl)()
+	
+	@property
+	def session_id(self) -> Optional[str]:
+		return self._session_id_get_impl()
+	
+	@session_id.setter
+	def session_id(self, value: Optional[str]) -> None:
+		self._session_id_set_impl(value=value)

osn_selenium/webdrivers/trio_threads/core/capture.py

@@ -0,0 +1,38 @@
+from typing import Any, Optional
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.core.capture import (
+	UnifiedCoreCaptureMixin
+)
+from osn_selenium.abstract.webdriver.core.capture import (
+	AbstractCoreCaptureMixin
+)
+
+
+__all__ = ["CoreCaptureMixin"]
+
+
+class CoreCaptureMixin(UnifiedCoreCaptureMixin, TrioThreadMixin, AbstractCoreCaptureMixin):
+	"""
+	Mixin enabling screen capture and page source retrieval for Core WebDrivers.
+
+	Offers methods to take screenshots (file, base64, png), print pages,
+	and extract the current DOM source.
+	"""
+	
+	async def get_screenshot_as_base64(self) -> str:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_base64_impl)()
+	
+	async def get_screenshot_as_file(self, filename: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_file_impl)(filename=filename)
+	
+	async def get_screenshot_as_png(self) -> bytes:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_png_impl)()
+	
+	async def page_source(self) -> str:
+		return await self.sync_to_trio(sync_function=self._page_source_impl)()
+	
+	async def print_page(self, print_options: Optional[Any] = None) -> str:
+		return await self.sync_to_trio(sync_function=self._print_page_impl)(print_options=print_options)
+	
+	async def save_screenshot(self, filename: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._save_screenshot_impl)(filename=filename)

osn_selenium/webdrivers/trio_threads/core/comonents.py

@@ -0,0 +1,92 @@
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.dialog import Dialog
+from osn_selenium.instances.trio_threads.mobile import Mobile
+from osn_selenium.instances.trio_threads.browser import Browser
+from osn_selenium.instances.trio_threads.permissions import Permissions
+from osn_selenium.instances.trio_threads.web_extension import WebExtension
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.instances.trio_threads.browsing_context import BrowsingContext
+from osn_selenium.webdrivers.unified.core.components import (
+	UnifiedCoreComponentsMixin
+)
+from osn_selenium.abstract.webdriver.core.components import (
+	AbstractCoreComponentsMixin
+)
+
+
+__all__ = ["CoreComponentsMixin"]
+
+
+class CoreComponentsMixin(
+		UnifiedCoreComponentsMixin,
+		TrioThreadMixin,
+		AbstractCoreComponentsMixin
+):
+	"""
+	Mixin providing access to specialized browser components for Core WebDrivers.
+
+	Exposes interfaces for interacting with specific browser domains such as
+	permissions, mobile emulation, dialog handling, and web extensions.
+	"""
+	
+	async def browser(self) -> Browser:
+		legacy = await self.sync_to_trio(sync_function=self._browser_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Browser,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def browsing_context(self) -> BrowsingContext:
+		legacy = await self.sync_to_trio(sync_function=self._browsing_context_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=BrowsingContext,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def dialog(self) -> Dialog:
+		legacy = await self.sync_to_trio(sync_function=self._dialog_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Dialog,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def mobile(self) -> Mobile:
+		legacy = await self.sync_to_trio(sync_function=self._mobile_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Mobile,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def permissions(self) -> Permissions:
+		legacy = await self.sync_to_trio(sync_function=self._permissions_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Permissions,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def webextension(self) -> WebExtension:
+		legacy = await self.sync_to_trio(sync_function=self._webextension_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebExtension,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/core/devtools.py

@@ -0,0 +1,53 @@
+from contextlib import asynccontextmanager
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	AsyncGenerator,
+	Dict,
+	Tuple
+)
+from osn_selenium.instances.trio_threads.network import Network
+from selenium.webdriver.remote.bidi_connection import BidiConnection
+from selenium.webdriver.remote.websocket_connection import WebSocketConnection
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.devtools import (
+	UnifiedCoreDevToolsMixin
+)
+from osn_selenium.abstract.webdriver.core.devtools import (
+	AbstractCoreDevToolsMixin
+)
+
+
+__all__ = ["CoreDevToolsMixin"]
+
+
+class CoreDevToolsMixin(UnifiedCoreDevToolsMixin, TrioThreadMixin, AbstractCoreDevToolsMixin):
+	"""
+	Mixin for Chrome DevTools Protocol (CDP) and BiDi interactions in Core WebDrivers.
+
+	Facilitates low-level browser control via CDP commands, network interception,
+	and bidirectional communication sessions.
+	"""
+	
+	@asynccontextmanager
+	async def bidi_connection(self) -> AsyncGenerator[BidiConnection, Any]:
+		async with self._bidi_connection_impl() as bidi:
+			yield bidi
+	
+	async def execute_cdp_cmd(self, cmd: str, cmd_args: Dict[str, Any]) -> Any:
+		return await self.sync_to_trio(sync_function=self._execute_cdp_cmd_impl)(cmd=cmd, cmd_args=cmd_args)
+	
+	async def network(self) -> Network:
+		legacy = await self.sync_to_trio(sync_function=self._network_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Network,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def start_devtools(self) -> Tuple[Any, WebSocketConnection]:
+		return await self.sync_to_trio(sync_function=self._start_devtools_impl)()

osn_selenium/webdrivers/trio_threads/core/element.py

@@ -0,0 +1,58 @@
+from typing import List, Optional
+from selenium.webdriver.common.by import By
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.web_element import WebElement
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.element import (
+	UnifiedCoreElementMixin
+)
+from osn_selenium.abstract.webdriver.core.element import (
+	AbstractCoreElementMixin
+)
+
+
+__all__ = ["CoreElementMixin"]
+
+
+class CoreElementMixin(UnifiedCoreElementMixin, TrioThreadMixin, AbstractCoreElementMixin):
+	"""
+	Mixin for DOM element retrieval in Core WebDrivers.
+
+	Provides standard methods to locate single or multiple elements within
+	the current page context.
+	"""
+	
+	async def create_web_element(self, element_id: str) -> WebElement:
+		legacy = await self.sync_to_trio(sync_function=self._create_web_element_impl)(element_id=element_id)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def find_element(self, by: str = By.ID, value: Optional[str] = None) -> WebElement:
+		legacy = await self.sync_to_trio(sync_function=self._find_element_impl)(by=by, value=value)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	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 [
+			get_trio_thread_instance_wrapper(
+					wrapper_class=WebElement,
+					legacy_object=element,
+					lock=self._lock,
+					limiter=self._capacity_limiter,
+			)
+			for element in legacy_elements
+		]

osn_selenium/webdrivers/trio_threads/core/file.py

@@ -0,0 +1,45 @@
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncGenerator,
+	List
+)
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.core.file import UnifiedCoreFileMixin
+from osn_selenium.abstract.webdriver.core.file import (
+	AbstractCoreFileMixin
+)
+
+
+__all__ = ["CoreFileMixin"]
+
+
+class CoreFileMixin(UnifiedCoreFileMixin, TrioThreadMixin, AbstractCoreFileMixin):
+	"""
+	Mixin for file system interactions within Core WebDrivers.
+
+	Manages file upload detection, download verification, and cleanup of
+	downloaded files.
+	"""
+	
+	async def delete_downloadable_files(self) -> None:
+		await self.sync_to_trio(sync_function=self._delete_downloadable_files_impl)()
+	
+	async def download_file(self, file_name: str, target_directory: str) -> None:
+		await self.sync_to_trio(sync_function=self._download_file_impl)(file_name=file_name, target_directory=target_directory)
+	
+	@property
+	async def file_detector(self) -> Any:
+		return await self.sync_to_trio(sync_function=self._file_detector_get_impl)()
+	
+	@file_detector.setter
+	async def file_detector(self, value: Any) -> None:
+		await self.sync_to_trio(sync_function=self._file_detector_set_impl)(value=value)
+	
+	@asynccontextmanager
+	async def file_detector_context(self, file_detector_class: Any, *args: Any, **kwargs: Any) -> AsyncGenerator[Any, Any]:
+		async with self.sync_to_trio_context(context_manager_factory=self.driver.file_detector_context)(file_detector_class, *args, **kwargs) as file_detector:
+			yield file_detector
+	
+	async def get_downloadable_files(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_downloadable_files_impl)()

osn_selenium/webdrivers/trio_threads/core/lifecycle.py

@@ -0,0 +1,60 @@
+from osn_selenium.models import WindowRect
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.webdrivers.unified.core.lifecycle import (
+	UnifiedCoreLifecycleMixin
+)
+from osn_selenium.abstract.webdriver.core.lifecycle import (
+	AbstractCoreLifecycleMixin
+)
+
+
+__all__ = ["CoreLifecycleMixin"]
+
+
+class CoreLifecycleMixin(UnifiedCoreLifecycleMixin, TrioThreadMixin, AbstractCoreLifecycleMixin):
+	"""
+	Mixin for managing the lifecycle of the Core WebDriver.
+
+	Handles the creation, startup, shutdown, and restarting processes of the
+	underlying browser instance, ensuring clean session management.
+	"""
+	
+	async def close_webdriver(self) -> None:
+		await self.sync_to_trio(sync_function=self._close_webdriver_impl)()
+	
+	async def quit(self) -> None:
+		await self.sync_to_trio(sync_function=self._quit_impl)()
+	
+	async def remote_connect_driver(self, command_executor: Union[str, RemoteConnection]) -> None:
+		await self.sync_to_trio(sync_function=self._remote_connect_driver_impl)(command_executor=command_executor)
+	
+	async def restart_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._restart_webdriver_impl)(flags=flags, window_rect=window_rect)
+	
+	async def start_client(self) -> None:
+		await self.sync_to_trio(sync_function=self._start_client_impl)()
+	
+	async def start_session(self, capabilities: Dict[str, Any]) -> None:
+		await self.sync_to_trio(sync_function=self._start_session_impl)(capabilities=capabilities)
+	
+	async def start_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._start_webdriver_impl)(flags=flags, window_rect=window_rect)
+	
+	async def stop_client(self) -> None:
+		await self.sync_to_trio(sync_function=self._stop_client_impl)()

osn_selenium/webdrivers/trio_threads/core/navigation.py

@@ -0,0 +1,41 @@
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.core.navigation import (
+	UnifiedCoreNavigationMixin
+)
+from osn_selenium.abstract.webdriver.core.navigation import (
+	AbstractCoreNavigationMixin
+)
+
+
+__all__ = ["CoreNavigationMixin"]
+
+
+class CoreNavigationMixin(
+		UnifiedCoreNavigationMixin,
+		TrioThreadMixin,
+		AbstractCoreNavigationMixin
+):
+	"""
+	Mixin controlling browser navigation for Core WebDrivers.
+
+	Includes standard navigation commands such as visiting URLs, history
+	traversal (back/forward), and page refreshing.
+	"""
+	
+	async def back(self) -> None:
+		await self.sync_to_trio(sync_function=self._back_impl)()
+	
+	async def current_url(self) -> str:
+		return await self.sync_to_trio(sync_function=self._current_url_impl)()
+	
+	async def forward(self) -> None:
+		await self.sync_to_trio(sync_function=self._forward_impl)()
+	
+	async def get(self, url: str) -> None:
+		await self.sync_to_trio(sync_function=self._get_impl)(url=url)
+	
+	async def refresh(self) -> None:
+		await self.sync_to_trio(sync_function=self._refresh_impl)()
+	
+	async def title(self) -> str:
+		return await self.sync_to_trio(sync_function=self._title_impl)()

osn_selenium/webdrivers/trio_threads/core/script.py

@@ -0,0 +1,59 @@
+from typing import Any, List, Optional
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.script import Script
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.script import (
+	UnifiedCoreScriptMixin
+)
+from osn_selenium.abstract.webdriver.core.script import (
+	AbstractCoreScriptMixin
+)
+from osn_selenium.webdrivers._args_helpers import (
+	unwrap_args,
+	wrap_trio_thread_args
+)
+
+
+__all__ = ["CoreScriptMixin"]
+
+
+class CoreScriptMixin(UnifiedCoreScriptMixin, TrioThreadMixin, AbstractCoreScriptMixin):
+	"""
+	Mixin for JavaScript execution and management in Core WebDrivers.
+
+	Allows execution of synchronous and asynchronous JavaScript, as well as
+	pinning scripts for repeated use.
+	"""
+	
+	async def execute_async_script(self, script: str, *args: Any) -> Any:
+		unwrapped = unwrap_args(args=args)
+		result = await self.sync_to_trio(sync_function=self._execute_async_script_impl)(script, *unwrapped)
+		
+		return wrap_trio_thread_args(args=result, lock=self._lock, limiter=self._capacity_limiter)
+	
+	async def execute_script(self, script: str, *args: Any) -> Any:
+		unwrapped = unwrap_args(args=args)
+		result = await self.sync_to_trio(sync_function=self._execute_script_impl)(script, *unwrapped)
+		
+		return wrap_trio_thread_args(args=result, lock=self._lock, limiter=self._capacity_limiter)
+	
+	async def get_pinned_scripts(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_pinned_scripts_impl)()
+	
+	async def pin_script(self, script: str, script_key: Optional[Any] = None) -> Any:
+		return await self.sync_to_trio(sync_function=self._pin_script_impl)(script=script, script_key=script_key)
+	
+	async def script(self) -> Script:
+		legacy = await self.sync_to_trio(sync_function=self._script_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Script,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def unpin(self, script_key: Any) -> None:
+		await self.sync_to_trio(sync_function=self._unpin_impl)(script_key=script_key)

osn_selenium/webdrivers/trio_threads/core/settings.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers.unified.core.settings import (
+	UnifiedCoreSettingsMixin
+)
+from osn_selenium.abstract.webdriver.core.settings import (
+	AbstractCoreSettingsMixin
+)
+
+
+__all__ = ["CoreSettingsMixin"]
+
+
+class CoreSettingsMixin(UnifiedCoreSettingsMixin, TrioThreadMixin, AbstractCoreSettingsMixin):
+	"""
+	Mixin for configuring and updating settings of the Core 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[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._reset_settings_impl)(flags=flags, window_rect=window_rect)
+	
+	async def update_settings(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._update_settings_impl)(flags=flags, window_rect=window_rect)