osn-selenium 1.1.0__tar.gz → 1.2.0__tar.gz

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osn-selenium
-Version: 1.1.0
+Version: 1.2.0
 Summary: An advanced, asynchronous wrapper for Selenium designed for fine-grained browser control. It leverages `trio` for async operations, provides human-like action chains for more natural automation, and offers deep integration with the Chrome DevTools Protocol (CDP) for advanced features like network interception. The library is structured to be extensible, with built-in support for Blink-based browsers like Chrome, Edge, and Yandex.
 Author-email: oddshellnick <oddshellnick.programming@gmail.com>
 Project-URL: Homepage, https://github.com/oddshellnick/osn-selenium
@@ -241,6 +241,7 @@ Utilities for executing JS and managing browser fingerprints.
     The `trio_threads` implementation is built using a unified `trio.Lock`. This means that every driver function and every associated instance (including `ActionChains`, `WebElement`, `Alert`, etc.) can execute only one operation at a time. Do not attempt to parallelize multiple operations (coroutines) within a single browser instance, as they will be queued sequentially. The primary purpose of this asynchronous implementation is to enable the simultaneous management of **multiple browser instances** within a single event loop, rather than concurrent interactions with one browser.
 *   **CDP Domains and Background Tasks:** 
     When configuring the domains for network interception, it is highly recommended to provide a `target_background_task` in your `DevToolsSettings`. This is especially critical for websites that dynamically create numerous targets (such as iframes or workers). Without a proper background task to handle these events, the browser's execution flow might hang or fail to process requests for nested targets properly.
+*   **Experimental `trio_bidi` Architecture:** A new experimental architecture, `trio_bidi`, has been introduced. While it currently does not cover 100% of browser capabilities, it supports all core functionalities, including page navigation and element interactions, through native BiDi communication.
 
 ## Future Notes
 
@@ -249,4 +250,4 @@ Utilities for executing JS and managing browser fingerprints.
 *   **macOS Support:** Extending browser auto-detection and lifecycle management for macOS environments.
 *   **High-Level CDP Handlers:** Expanding the `dev_tools.domains` module to include simplified event-driven logic for `Network`, `Page`, and `Runtime` domains, similar to the current `Fetch` implementation.
 *   **Enhanced Human-Like Actions:** Adding more complex Bezier-based mouse movement patterns and advanced typing jitter to further decrease automation footprints.
-*   **Single-Instance Internal Concurrency Research:** While the current `trio_threads` implementation is optimized for managing multiple browser instances concurrently, we are researching ways to enable parallel command execution within a *single* browser instance. This long-term goal involves moving away from the global `trio.Lock` toward a more granular task-dispatching system (potentially using `trio.MemorySendChannel` or direct CDP interaction) to allow simultaneous operations without protocol desynchronization.
+*   **Full BiDi Coverage:** Implementing comprehensive Selenium feature coverage using BiDi mappings to eventually replace the need for synchronous thread pools in async mode.

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/README.md

@@ -225,6 +225,7 @@ Utilities for executing JS and managing browser fingerprints.
     The `trio_threads` implementation is built using a unified `trio.Lock`. This means that every driver function and every associated instance (including `ActionChains`, `WebElement`, `Alert`, etc.) can execute only one operation at a time. Do not attempt to parallelize multiple operations (coroutines) within a single browser instance, as they will be queued sequentially. The primary purpose of this asynchronous implementation is to enable the simultaneous management of **multiple browser instances** within a single event loop, rather than concurrent interactions with one browser.
 *   **CDP Domains and Background Tasks:** 
     When configuring the domains for network interception, it is highly recommended to provide a `target_background_task` in your `DevToolsSettings`. This is especially critical for websites that dynamically create numerous targets (such as iframes or workers). Without a proper background task to handle these events, the browser's execution flow might hang or fail to process requests for nested targets properly.
+*   **Experimental `trio_bidi` Architecture:** A new experimental architecture, `trio_bidi`, has been introduced. While it currently does not cover 100% of browser capabilities, it supports all core functionalities, including page navigation and element interactions, through native BiDi communication.
 
 ## Future Notes
 
@@ -233,4 +234,4 @@ Utilities for executing JS and managing browser fingerprints.
 *   **macOS Support:** Extending browser auto-detection and lifecycle management for macOS environments.
 *   **High-Level CDP Handlers:** Expanding the `dev_tools.domains` module to include simplified event-driven logic for `Network`, `Page`, and `Runtime` domains, similar to the current `Fetch` implementation.
 *   **Enhanced Human-Like Actions:** Adding more complex Bezier-based mouse movement patterns and advanced typing jitter to further decrease automation footprints.
-*   **Single-Instance Internal Concurrency Research:** While the current `trio_threads` implementation is optimized for managing multiple browser instances concurrently, we are researching ways to enable parallel command execution within a *single* browser instance. This long-term goal involves moving away from the global `trio.Lock` toward a more granular task-dispatching system (potentially using `trio.MemorySendChannel` or direct CDP interaction) to allow simultaneous operations without protocol desynchronization.
+*   **Full BiDi Coverage:** Implementing comprehensive Selenium feature coverage using BiDi mappings to eventually replace the need for synchronous thread pools in async mode.

osn_selenium-1.2.0/osn_selenium/_decorators.py

@@ -0,0 +1,57 @@
+import inspect
+import functools
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium._exception_helpers import log_exception
+from typing import (
+	Any,
+	Callable,
+	ParamSpec,
+	TypeVar
+)
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+
+
+__all__ = ["log_on_error"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+_METHOD = TypeVar("_METHOD", bound=Callable[..., Any])
+
+
+def log_on_error(func: _METHOD) -> _METHOD:
+	"""
+	Decorator that logs any `BaseException` raised by the decorated async function.
+
+	If an exception occurs, it is logged using `log_exception`, and an `ExceptionThrown`
+	object wrapping the exception is returned instead of re-raising it.
+
+	Args:
+		func (_METHOD): The asynchronous function to be wrapped.
+
+	Returns:
+		_METHOD: The wrapped asynchronous function.
+	"""
+	
+	@functools.wraps(func)
+	def sync_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
+		try:
+			return func(*args, **kwargs)
+		except BaseException as exception:
+			log_exception(exception)
+			return ExceptionThrown(exception)
+	
+	@functools.wraps(func)
+	async def async_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
+		try:
+			return await func(*args, **kwargs)
+		except BaseException as exception:
+			log_exception(exception)
+			return ExceptionThrown(exception)
+	
+	if inspect.iscoroutinefunction(func):
+		return async_wrapper
+	
+	if inspect.isfunction(func):
+		return sync_wrapper
+	
+	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)

osn_selenium-1.2.0/osn_selenium/_trio_threads_helpers.py

@@ -0,0 +1,157 @@
+import sys
+import trio
+import contextvars
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncContextManager,
+	AsyncIterator,
+	Callable,
+	ContextManager,
+	Coroutine,
+	ParamSpec,
+	Tuple,
+	TypeVar
+)
+
+
+__all__ = ["sync_to_trio", "sync_to_trio_context"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+
+
+def sync_to_trio_context(
+		context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]],
+		lock_object: trio.Lock,
+		capacity_limiter_object: trio.CapacityLimiter,
+		lock: bool,
+		exchange_context: bool,
+) -> Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]:
+	"""
+	Converts a synchronous context manager factory to an asynchronous Trio-compatible context manager.
+
+	Args:
+		context_manager_factory (Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]]): Factory function returning a context manager.
+		lock_object (trio.Lock): Trio lock for synchronization.
+		capacity_limiter_object (trio.CapacityLimiter): Trio capacity limiter.
+		lock (bool): Whether to use the internal lock for synchronization.
+		exchange_context (bool): Whether to synchronize context variables between threads.
+
+	Returns:
+		Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]: An async function returning an async context manager.
+	"""
+	
+	@asynccontextmanager
+	async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> AsyncIterator[_METHOD_OUTPUT]:
+		"""
+		Internal async context manager wrapper.
+
+		Args:
+			*args (_METHOD_INPUT.args): Positional arguments for the factory.
+			**kwargs (_METHOD_INPUT.kwargs): Keyword arguments for the factory.
+
+		Returns:
+			AsyncIterator[_METHOD_OUTPUT]: An async iterator yielding the context resource.
+		"""
+		
+		sync_context_manager = await sync_to_trio(
+				sync_function=context_manager_factory,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)(*args, **kwargs)
+		
+		enter_ = sync_to_trio(
+				sync_function=sync_context_manager.__enter__,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+		exit_ = sync_to_trio(
+				sync_function=sync_context_manager.__exit__,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+		
+		try:
+			result = await enter_()
+		
+			yield result
+		except Exception as e:
+			exc_type, exc_val, exc_tb = sys.exc_info()
+		
+			if not await exit_(exc_type, exc_val, exc_tb):
+				raise e
+		else:
+			await exit_(None, None, None)
+	
+	return wrapper
+
+
+def sync_to_trio(
+		sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT],
+		lock_object: trio.Lock,
+		capacity_limiter_object: trio.CapacityLimiter,
+		lock: bool,
+		exchange_context: bool,
+) -> Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]:
+	"""
+	Wraps a synchronous function to run within a Trio thread pool using a lock and limiter.
+
+	Args:
+		sync_function (Callable[_METHOD_INPUT, _METHOD_OUTPUT]): The synchronous function to wrap.
+		lock_object (trio.Lock): Trio lock for synchronization.
+		capacity_limiter_object (trio.CapacityLimiter): Trio capacity limiter.
+		lock (bool): Whether to use the provided lock.
+		exchange_context (bool): Whether to synchronize context variables between threads.
+
+	Returns:
+		Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]: An async wrapper for the sync function.
+	"""
+	
+	async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
+		"""
+	Internal async wrapper for the synchronous function.
+
+	Args:
+		*args (_METHOD_INPUT.args): Positional arguments for the sync function.
+		**kwargs (_METHOD_INPUT.kwargs): Keyword arguments for the sync function.
+
+	Returns:
+		_METHOD_OUTPUT: The result of the synchronous function execution.
+	"""
+		
+		def function_with_kwargs(*args_) -> Tuple[_METHOD_OUTPUT, contextvars.Context]:
+			"""
+		Helper to pass keyword arguments to trio.to_thread.run_sync.
+
+		Args:
+			*args_: Positional arguments passed from the outer scope.
+
+		Returns:
+			Tuple[_METHOD_OUTPUT, contextvars.Context]: Result of original sync function and the thread context.
+		"""
+			
+			sync_result = sync_function(*args_, **kwargs)
+			context_vars = contextvars.copy_context()
+			
+			return sync_result, context_vars
+		
+		if lock:
+			async with lock_object:
+				result, child_context_vars = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=capacity_limiter_object)
+		else:
+			result, child_context_vars = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=capacity_limiter_object)
+		
+		if exchange_context:
+			for var, value in child_context_vars.items():
+				var.set(value)
+		
+		return result
+	
+	return wrapper

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/_typehints.py

@@ -14,6 +14,6 @@ __all__ = [
 ]
 
 DEVICES_TYPEHINT = Union[PointerInput, KeyInput, WheelInput]
-ARCHITECTURES_TYPEHINT = Literal["sync", "trio_threads"]
+ARCHITECTURES_TYPEHINT = Literal["sync", "trio_threads", "trio_bidi"]
 PATH_TYPEHINT = Union[str, bytes, pathlib.Path, os.PathLike]
 TYPES_FOR_FLATTENING_TYPEHINT = Union[str, Type]

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/blink/base.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from selenium import webdriver
 from typing import Optional, Union
 from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.abstract.executors.cdp import AbstractCDPExecutor
 from osn_selenium.abstract.webdriver.core.base import (
 	AbstractCoreBaseMixin
 )
@@ -31,6 +32,19 @@ class AbstractBlinkBaseMixin(AbstractCoreBaseMixin):
 		
 		...
 	
+	@property
+	@abstractmethod
+	def cdp(self) -> AbstractCDPExecutor:
+		"""
+		Returns the CDP (Chrome DevTools Protocol) executor.
+
+		Returns:
+			AbstractCDPExecutor: The CDP executor instance used for sending
+			commands directly to the browser via the DevTools protocol.
+		"""
+		
+		...
+	
 	@property
 	@abstractmethod
 	def debugging_ip(self) -> Optional[str]:

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/blink/lifecycle.py

@@ -19,14 +19,6 @@ class AbstractBlinkLifecycleMixin(AbstractCoreLifecycleMixin):
 	and the associated browser process.
 	"""
 	
-	@abstractmethod
-	async def close_webdriver(self) -> None:
-		"""
-		Closes the WebDriver connection and terminates the browser process.
-		"""
-		
-		...
-	
 	@abstractmethod
 	async def restart_webdriver(
 			self,
@@ -74,3 +66,11 @@ class AbstractBlinkLifecycleMixin(AbstractCoreLifecycleMixin):
 		"""
 		
 		...
+	
+	@abstractmethod
+	async def stop_webdriver(self) -> None:
+		"""
+		Stops the WebDriver connection and terminates the browser process.
+		"""
+		
+		...

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/core/base.py

@@ -11,7 +11,6 @@ from osn_selenium._typehints import (
 	ARCHITECTURES_TYPEHINT
 )
 from selenium.webdriver.remote.errorhandler import ErrorHandler
-from osn_selenium.abstract.executors.cdp import AbstractCDPExecutor
 from selenium.webdriver.remote.locator_converter import LocatorConverter
 from selenium.webdriver.remote.remote_connection import RemoteConnection
 from osn_selenium.abstract.executors.javascript import AbstractJSExecutor
@@ -90,19 +89,6 @@ class AbstractCoreBaseMixin(ABC):
 		
 		...
 	
-	@property
-	@abstractmethod
-	def cdp(self) -> AbstractCDPExecutor:
-		"""
-		Returns the CDP (Chrome DevTools Protocol) executor.
-
-		Returns:
-			AbstractCDPExecutor: The CDP executor instance used for sending
-			commands directly to the browser via the DevTools protocol.
-		"""
-		
-		...
-	
 	@property
 	@abstractmethod
 	def command_executor(self) -> RemoteConnection:

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/core/capture.py

@@ -1,5 +1,6 @@
-from typing import Any, Optional
+from typing import Optional
 from abc import ABC, abstractmethod
+from selenium.webdriver.common.print_page_options import PrintOptions
 
 
 __all__ = ["AbstractCoreCaptureMixin"]
@@ -56,12 +57,12 @@ class AbstractCoreCaptureMixin(ABC):
 		...
 	
 	@abstractmethod
-	def print_page(self, print_options: Optional[Any] = None) -> str:
+	def print_page(self, print_options: Optional[PrintOptions] = None) -> str:
 		"""
 		Prints the current page to a PDF.
 
 		Args:
-			print_options (Optional[Any]): Options for printing the page.
+			print_options (Optional[PrintOptions]): Options for printing the page.
 
 		Returns:
 			str: A base64-encoded string of the PDF.

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/core/lifecycle.py

@@ -16,14 +16,6 @@ __all__ = ["AbstractCoreLifecycleMixin"]
 class AbstractCoreLifecycleMixin(ABC):
 	"""Mixin responsible for driver lifecycle, creation, session, and connection management."""
 	
-	@abstractmethod
-	def close_webdriver(self) -> None:
-		"""
-		Closes the WebDriver instance and all associated windows.
-		"""
-		
-		...
-	
 	@abstractmethod
 	def quit(self) -> None:
 		"""
@@ -101,3 +93,11 @@ class AbstractCoreLifecycleMixin(ABC):
 		"""
 		
 		...
+	
+	@abstractmethod
+	def stop_webdriver(self) -> None:
+		"""
+		Stops the WebDriver instance and all associated windows.
+		"""
+		
+		...

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/core/script.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from typing import Any, List, Optional
+from selenium.webdriver.remote.script_key import ScriptKey
 from osn_selenium.abstract.instances.script import AbstractScript
 
 
@@ -51,7 +52,7 @@ class AbstractCoreScriptMixin(ABC):
 		...
 	
 	@abstractmethod
-	def pin_script(self, script: str, script_key: Optional[Any] = None) -> Any:
+	def pin_script(self, script: str, script_key: Optional[Any] = None) -> ScriptKey:
 		"""
 		Pins a script to the browser for faster execution.
 
@@ -60,7 +61,7 @@ class AbstractCoreScriptMixin(ABC):
 			script_key (Optional[Any]): An optional key to identify the script.
 
 		Returns:
-			Any: The key associated with the pinned script.
+			ScriptKey: The key associated with the pinned script.
 		"""
 		
 		...
@@ -77,12 +78,12 @@ class AbstractCoreScriptMixin(ABC):
 		...
 	
 	@abstractmethod
-	def unpin(self, script_key: Any) -> None:
+	def unpin(self, script_key: ScriptKey) -> None:
 		"""
 		Unpins a previously pinned script.
 
 		Args:
-			script_key (Any): The key of the script to unpin.
+			script_key (ScriptKey): The key of the script to unpin.
 		"""
 		
 		...

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/abstract/webdriver/core/window.py

@@ -66,6 +66,17 @@ class AbstractCoreWindowMixin(ABC):
 		
 		...
 	
+	@abstractmethod
+	def get_orientation(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
+		"""
+		Gets the current orientation of the browser.
+
+		Returns:
+			Literal["LANDSCAPE", "PORTRAIT"]: The current orientation.
+		"""
+		
+		...
+	
 	@abstractmethod
 	def get_window_handle(self, window: Optional[Union[str, int]] = None) -> str:
 		"""
@@ -140,17 +151,6 @@ class AbstractCoreWindowMixin(ABC):
 		
 		...
 	
-	@abstractmethod
-	def orientation(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
-		"""
-		Gets the current orientation of the browser.
-
-		Returns:
-			Literal["LANDSCAPE", "PORTRAIT"]: The current orientation.
-		"""
-		
-		...
-	
 	@abstractmethod
 	def set_orientation(self, value: Literal["LANDSCAPE", "PORTRAIT"]) -> None:
 		"""

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/dev_tools/_decorators.py

@@ -2,9 +2,7 @@ import trio
 import inspect
 import warnings
 import functools
-from osn_selenium.exceptions.devtools import ExceptionThrown
 from osn_selenium.exceptions.instance import NotExpectedTypeError
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from typing import (
 	Any,
 	Callable,
@@ -15,7 +13,7 @@ from typing import (
 )
 
 
-__all__ = ["background_task_decorator", "log_on_error", "warn_if_active"]
+__all__ = ["background_task_decorator", "warn_if_active"]
 
 if TYPE_CHECKING:
 	from osn_selenium.dev_tools.manager import DevTools
@@ -76,45 +74,6 @@ def warn_if_active(func: _METHOD) -> _METHOD:
 	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
 
 
-def log_on_error(func: _METHOD) -> _METHOD:
-	"""
-	Decorator that logs any `BaseException` raised by the decorated async function.
-
-	If an exception occurs, it is logged using `log_exception`, and an `ExceptionThrown`
-	object wrapping the exception is returned instead of re-raising it.
-
-	Args:
-		func (_METHOD): The asynchronous function to be wrapped.
-
-	Returns:
-		_METHOD: The wrapped asynchronous function.
-	"""
-	
-	@functools.wraps(func)
-	def sync_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
-		try:
-			return func(*args, **kwargs)
-		except BaseException as exception:
-			log_exception(exception)
-			return ExceptionThrown(exception)
-	
-	@functools.wraps(func)
-	async def async_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
-		try:
-			return await func(*args, **kwargs)
-		except BaseException as exception:
-			log_exception(exception)
-			return ExceptionThrown(exception)
-	
-	if inspect.iscoroutinefunction(func):
-		return async_wrapper
-	
-	if inspect.isfunction(func):
-		return sync_wrapper
-	
-	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
-
-
 def background_task_decorator(func: "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT") -> "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT":
 	"""
 	Decorator for target background tasks to manage their lifecycle.

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/dev_tools/_functions.py

@@ -1,5 +1,7 @@
 import trio
 import random
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium.exceptions.devtools import CDPEndExceptions
 from typing import (
 	Any,
 	Callable,
@@ -10,10 +12,6 @@ from typing import (
 from osn_selenium.exceptions.configuration import (
 	NotExpectedValueError
 )
-from osn_selenium.exceptions.devtools import (
-	CDPEndExceptions,
-	ExceptionThrown
-)
 
 
 __all__ = ["cdp_command_error", "execute_cdp_command", "wait_one"]

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/dev_tools/domains/fetch.py

@@ -1,11 +1,9 @@
 import trio
 from pydantic import Field
 from osn_selenium._base_models import DictModel
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium.exceptions.devtools import CDPEndExceptions
 from osn_selenium.dev_tools._functions import execute_cdp_command
-from osn_selenium.exceptions.devtools import (
-	CDPEndExceptions,
-	ExceptionThrown
-)
 from typing import (
 	Any,
 	Callable,
@@ -134,7 +132,7 @@ async def _build_kwargs_from_handlers_func(self: DevToolsTarget, handlers: DictM
 				kwargs_ready_event = trio.Event()
 				kwargs_ready_events.append(kwargs_ready_event)
 	
-				self._nursery_object.start_soon(
+				self._nursery.start_soon(
 						handler_settings.func,
 						self,
 						kwargs_ready_event,
@@ -243,7 +241,7 @@ async def _handle_auth_required(
 				)
 	
 				if response_handle_func is not None:
-					self._nursery_object.start_soon(response_handle_func, self, response)
+					self._nursery.start_soon(response_handle_func, self, response)
 			except* CDPEndExceptions:
 				pass
 			except* BaseException as error:
@@ -505,7 +503,7 @@ async def _handle_request_paused(
 				)
 	
 				if response_handle_func is not None:
-					self._nursery_object.start_soon(response_handle_func, self, response)
+					self._nursery.start_soon(response_handle_func, self, response)
 			except* CDPEndExceptions:
 				pass
 			except* BaseException as error:

{osn_selenium-1.1.0 → osn_selenium-1.2.0}/osn_selenium/dev_tools/domains_default/fetch.py

@@ -1,7 +1,7 @@
 import trio
 from datetime import datetime
 from osn_selenium._base_models import DictModel
-from osn_selenium.dev_tools._exception_helpers import log_exception
+from osn_selenium._exception_helpers import log_exception
 from typing import (
 	Any,
 	Dict,