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

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

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: osn-selenium
-Version: 1.0.0
+Version: 1.1.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: oddshellnick
-Author-email: oddshellnick.programming@gmail.com
+Author-email: oddshellnick <oddshellnick.programming@gmail.com>
+Project-URL: Homepage, https://github.com/oddshellnick/osn-selenium
+Project-URL: Issues, https://github.com/oddshellnick/osn-selenium/issues
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: trio<1.0.0,>=0.32.0
 Requires-Dist: selenium<5.0.0,>=4.40.0
@@ -11,17 +13,13 @@ Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: trio-websocket<1.0.0,>=0.12.0
 Requires-Dist: pywin32>=310; sys_platform == "win32"
 Requires-Dist: osn-system-utils<0.1.0,>=0.0.4
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-Dynamic: summary
 
 # osn-selenium: Advanced Selenium Wrapper with Async Support and Fingerprinting Protection
 
 osn-selenium is a robust wrapper around Selenium WebDriver designed for automation of Blink-based browsers (Chrome, Edge, Yandex). It extends standard Selenium capabilities by providing native asynchronous support via Trio, deep integration with the Chrome DevTools Protocol (CDP), sophisticated browser fingerprint spoofing, and human-like user interaction simulation.
 
+For more detailed information, please visit the [wiki page](https://github.com/oddshellnick/osn-selenium/wiki).
+
 ## Technologies
 
 | Name       | Badge                                                                                                                                               | Description                                                                                                                                            |
@@ -67,12 +65,23 @@ osn-selenium is a robust wrapper around Selenium WebDriver designed for automati
         pip install osn-selenium
         ```
 
+        **With pip (beta versions):**
+        ```bash
+        pip install -i https://test.pypi.org/simple/ osn_system_utils
+        ```
+
     *   **With git:**
         ```bash
         pip install git+https://github.com/oddshellnick/osn-selenium.git
         ```
         *(Ensure you have git installed)*
 
+    *   **With git (beta versions):**
+        ```bash
+        pip install git+https://github.com/oddshellnick/osn-selenium.git@dev
+        ```
+        *(Ensure you have git installed)*
+
 2.  **Install the required Python packages using pip:**
 
     ```bash
@@ -224,6 +233,10 @@ Utilities for executing JS and managing browser fingerprints.
 
 ## Notes
 
+*   **CDP Versioning and External Packages:** 
+    This library supports a modular CDP (Chrome DevTools Protocol) architecture. Since standard Selenium distributions often deprecate or remove older protocol versions, we maintain a dedicated repository for all versions at [osn-selenium-cdp](https://github.com/oddshellnick/osn-selenium-cdp).
+    *   **Manual Installation:** You can install specific CDP support by targeting the corresponding branch (e.g., `pip install git+https://github.com/oddshellnick/osn-selenium-cdp.git@v131`).
+    *   **Structure Requirement:** If you choose to add or create CDP version packages manually, they **must strictly follow the directory structure** used in the `osn-selenium-cdp` repository. This ensures that the internal `MetaPathFinder` hook can correctly intercept and redirect imports from `selenium.webdriver.common.devtools`. Deviating from this structure will result in `CDPPackageError` or `ImportError`.
 *   **Concurrency Constraints in `trio_threads`:** 
     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:** 

osn_selenium-1.0.0/osn_selenium.egg-info/PKG-INFO → osn_selenium-1.1.0/README.md

@@ -1,27 +1,9 @@
-Metadata-Version: 2.4
-Name: osn-selenium
-Version: 1.0.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: oddshellnick
-Author-email: oddshellnick.programming@gmail.com
-Description-Content-Type: text/markdown
-Requires-Dist: trio<1.0.0,>=0.32.0
-Requires-Dist: selenium<5.0.0,>=4.40.0
-Requires-Dist: pydantic<3.0.0,>=2.0.0
-Requires-Dist: trio-websocket<1.0.0,>=0.12.0
-Requires-Dist: pywin32>=310; sys_platform == "win32"
-Requires-Dist: osn-system-utils<0.1.0,>=0.0.4
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-Dynamic: summary
-
 # osn-selenium: Advanced Selenium Wrapper with Async Support and Fingerprinting Protection
 
 osn-selenium is a robust wrapper around Selenium WebDriver designed for automation of Blink-based browsers (Chrome, Edge, Yandex). It extends standard Selenium capabilities by providing native asynchronous support via Trio, deep integration with the Chrome DevTools Protocol (CDP), sophisticated browser fingerprint spoofing, and human-like user interaction simulation.
 
+For more detailed information, please visit the [wiki page](https://github.com/oddshellnick/osn-selenium/wiki).
+
 ## Technologies
 
 | Name       | Badge                                                                                                                                               | Description                                                                                                                                            |
@@ -67,12 +49,23 @@ osn-selenium is a robust wrapper around Selenium WebDriver designed for automati
         pip install osn-selenium
         ```
 
+        **With pip (beta versions):**
+        ```bash
+        pip install -i https://test.pypi.org/simple/ osn_system_utils
+        ```
+
     *   **With git:**
         ```bash
         pip install git+https://github.com/oddshellnick/osn-selenium.git
         ```
         *(Ensure you have git installed)*
 
+    *   **With git (beta versions):**
+        ```bash
+        pip install git+https://github.com/oddshellnick/osn-selenium.git@dev
+        ```
+        *(Ensure you have git installed)*
+
 2.  **Install the required Python packages using pip:**
 
     ```bash
@@ -224,6 +217,10 @@ Utilities for executing JS and managing browser fingerprints.
 
 ## Notes
 
+*   **CDP Versioning and External Packages:** 
+    This library supports a modular CDP (Chrome DevTools Protocol) architecture. Since standard Selenium distributions often deprecate or remove older protocol versions, we maintain a dedicated repository for all versions at [osn-selenium-cdp](https://github.com/oddshellnick/osn-selenium-cdp).
+    *   **Manual Installation:** You can install specific CDP support by targeting the corresponding branch (e.g., `pip install git+https://github.com/oddshellnick/osn-selenium-cdp.git@v131`).
+    *   **Structure Requirement:** If you choose to add or create CDP version packages manually, they **must strictly follow the directory structure** used in the `osn-selenium-cdp` repository. This ensures that the internal `MetaPathFinder` hook can correctly intercept and redirect imports from `selenium.webdriver.common.devtools`. Deviating from this structure will result in `CDPPackageError` or `ImportError`.
 *   **Concurrency Constraints in `trio_threads`:** 
     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:** 
@@ -236,4 +233,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.
+*   **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.

osn_selenium-1.1.0/osn_selenium/_base_models.py

@@ -0,0 +1,41 @@
+from pydantic import (
+	BaseModel,
+	ConfigDict
+)
+
+
+__all__ = ["DictModel", "ExtraDictModel"]
+
+
+class ExtraDictModel(BaseModel):
+	"""
+	Base class for Pydantic models that allows extra fields.
+
+	This configuration allows the model to accept fields that are not
+	explicitly defined in the model's schema.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="allow",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)
+
+
+class DictModel(BaseModel):
+	"""
+	Base class for Pydantic models with a predefined configuration.
+
+	This configuration enforces strict validation rules such as forbidding extra
+	fields and stripping whitespace from string inputs.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="forbid",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)

osn_selenium-1.1.0/osn_selenium/_cdp_import.py

@@ -0,0 +1,253 @@
+import re
+import sys
+import pathlib
+import importlib.util
+import urllib.request
+from types import ModuleType
+from datetime import datetime, timedelta
+from importlib.abc import MetaPathFinder
+from importlib.machinery import ModuleSpec
+from osn_selenium._typehints import PATH_TYPEHINT
+from typing import (
+	Dict,
+	Mapping,
+	Optional,
+	Sequence,
+	Tuple,
+	Union
+)
+
+
+__all__ = ["check_cdp_version_exists_on_github", "install_cdp_hook"]
+
+_SELENIUM_CDP_PATTERN = re.compile(r"selenium\.webdriver\.common\.devtools\.v(\d+)(.*)")
+_INTERNAL_CDP_PATTERN = re.compile(r"osn_selenium_cdp_v(\d+)(?!\.legacy)(.*)")
+
+_GITHUB_VERSIONS_CACHE: Dict[str, Tuple[bool, datetime]] = {}
+_CDP_PACKAGE_ERROR = None
+
+
+def _build_cdp_package_error(version: int) -> Exception:
+	"""
+	Creates an instance of the CDPPackageError exception.
+
+	Args:
+		version (int): The version of the CDP package.
+
+	Returns:
+		Exception: An instance of the CDPPackageError.
+	"""
+	
+	global _CDP_PACKAGE_ERROR
+	
+	if _CDP_PACKAGE_ERROR is None:
+		from osn_selenium.exceptions.dependencies import CDPPackageError
+		_CDP_PACKAGE_ERROR = CDPPackageError
+	
+	return _CDP_PACKAGE_ERROR(version=version)
+
+
+def _get_external_spec(fullname: str, root_path: pathlib.Path, submodule_part: str) -> Optional[ModuleSpec]:
+	"""
+	Creates a module spec for an external path.
+
+	Args:
+		fullname (str): The full name of the module.
+		root_path (pathlib.Path): The root directory where the module is located.
+		submodule_part (str): The part of the name representing submodules.
+
+	Returns:
+		Optional[ModuleSpec]: The module spec if found, otherwise None.
+	"""
+	
+	if not submodule_part:
+		target_path = root_path / "__init__.py"
+		is_package = True
+	else:
+		rel_path = submodule_part.lstrip(".").replace(".", "/")
+		target_path = root_path / f"{rel_path}.py"
+	
+		if not target_path.exists():
+			target_path = root_path / rel_path / "__init__.py"
+			is_package = True
+		else:
+			is_package = False
+	
+	if target_path.exists():
+		spec = importlib.util.spec_from_file_location(
+				name=fullname,
+				location=str(target_path),
+				submodule_search_locations=[str(root_path)]
+				if is_package
+				else None
+		)
+	
+		return spec
+	
+	return None
+
+
+class _CdpMetaPathFinder(MetaPathFinder):
+	"""
+	A custom meta path finder to redirect Selenium CDP imports.
+	"""
+	
+	def __init__(
+			self,
+			cdp_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_package_missing: bool = True
+	) -> None:
+		"""
+		Initializes the finder with user-defined CDP paths.
+
+		Args:
+			cdp_paths (Optional[Mapping[int, PATH_TYPEHINT]]): Mapping of versions to paths.
+			ignore_package_missing (bool): Whether to ignore missing package errors.
+		"""
+		
+		self._user_cdp_paths = {k: pathlib.Path(v).resolve() for k, v in (cdp_paths or {}).items()}
+		
+		self._ignore_package_missing = ignore_package_missing
+	
+	def _find_spec_bypassing_self(self, fullname: str, path: Optional[Sequence[str]]) -> Optional[ModuleSpec]:
+		"""
+		Attempts to find the module specification using other finders in sys.meta_path.
+
+		Args:
+			fullname (str): The full name of the module.
+			path (Optional[Sequence[str]]): The search path for the module.
+
+		Returns:
+			Optional[ModuleSpec]: The module spec if found, otherwise None.
+		"""
+		
+		for finder in sys.meta_path:
+			if finder is self:
+				continue
+		
+			try:
+				if hasattr(finder, "find_spec"):
+					spec = finder.find_spec(fullname, path)
+		
+					if spec:
+						return spec
+			except (Exception,):
+				continue
+		
+		return None
+	
+	def find_spec(
+			self,
+			fullname: str,
+			path: Optional[Sequence[str]],
+			target: Optional[ModuleType] = None,
+	) -> Optional[ModuleSpec]:
+		"""
+		Finds the specification for the requested module if it matches the CDP pattern.
+
+		Args:
+			fullname (str): The full name of the module to find.
+			path (Optional[Sequence[str]]): The search path for the module.
+			target (Optional[ModuleType]): The module object if it is being reloaded.
+
+		Returns:
+			Optional[ModuleSpec]: The module spec if found, otherwise None.
+		"""
+		
+		selenium_match = _SELENIUM_CDP_PATTERN.match(fullname)
+		internal_match = _INTERNAL_CDP_PATTERN.match(fullname)
+		
+		if not (selenium_match or internal_match):
+			return None
+		
+		match = selenium_match or internal_match
+		version_part = int(match.group(1))
+		submodule_part = match.group(2)
+		
+		user_cdp_path = self._user_cdp_paths.get(version_part, None)
+		if user_cdp_path is not None:
+			root = (user_cdp_path / "legacy") if selenium_match else user_cdp_path
+			return _get_external_spec(fullname=fullname, root_path=root, submodule_part=submodule_part)
+		
+		spec = None
+		
+		if selenium_match:
+			target_name = f"osn_selenium_cdp_v{version_part}.legacy{submodule_part}"
+			spec = importlib.util.find_spec(target_name, path)
+		
+		if internal_match:
+			target_name = f"osn_selenium_cdp_v{version_part}{submodule_part}"
+			spec = self._find_spec_bypassing_self(target_name, path)
+		
+		try:
+			if spec:
+				return importlib.util.spec_from_file_location(
+						name=fullname,
+						location=spec.origin,
+						submodule_search_locations=spec.submodule_search_locations,
+				)
+		except ModuleNotFoundError:
+			if self._ignore_package_missing:
+				return None
+		
+			raise _build_cdp_package_error(version=version_part)
+		
+		return None
+
+
+def install_cdp_hook(
+		cdp_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+		ignore_package_missing: bool = True,
+) -> None:
+	"""
+	Installs the CDP meta path finder into sys.meta_path.
+
+	Args:
+		cdp_paths (Optional[Mapping[int, PATH_TYPEHINT]]): Mapping of versions to custom local paths.
+		ignore_package_missing (bool): Whether to ignore missing package errors.
+	"""
+	
+	for finder in sys.meta_path:
+		if isinstance(finder, _CdpMetaPathFinder):
+			finder._user_cdp_paths.update({k: pathlib.Path(v).resolve() for k, v in (cdp_paths or {}).items()})
+			finder._ignore_package_missing = ignore_package_missing
+	
+			return
+	
+	sys.meta_path.insert(
+			0,
+			_CdpMetaPathFinder(cdp_paths=cdp_paths, ignore_package_missing=ignore_package_missing)
+	)
+
+
+def check_cdp_version_exists_on_github(version: Union[int, str]) -> bool:
+	"""
+	Checks if a specific CDP version exists in the remote repository.
+
+	Args:
+		version (Union[int, str]): The version of package.
+
+	Returns:
+		bool: True if the version exists, False otherwise.
+	"""
+	
+	branch_name = version if isinstance(version, str) else f"v{version}"
+	
+	cached_answer = _GITHUB_VERSIONS_CACHE.get(branch_name, None)
+	if cached_answer and datetime.now() - cached_answer[1] < timedelta(hours=12):
+		return cached_answer[0]
+	
+	repo_url = f"https://api.github.com/repos/oddshellnick/osn-selenium-cdp/branches/{branch_name}"
+	
+	try:
+		request = urllib.request.Request(url=repo_url, headers={"User-Agent": "osn-selenium"})
+		request.get_method = lambda: "HEAD"
+	
+		with urllib.request.urlopen(url=request, timeout=5.0) as response:
+			existing = response.status == 200
+			_GITHUB_VERSIONS_CACHE[branch_name] = (existing, datetime.now())
+	
+			return existing
+	except (Exception,):
+		_GITHUB_VERSIONS_CACHE[branch_name] = (False, datetime.now())
+		return False

osn_selenium-1.1.0/osn_selenium/abstract/executors/cdp.py

@@ -0,0 +1,63 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+
+__all__ = ["AbstractCDPExecutor"]
+
+if TYPE_CHECKING:
+	from osn_selenium_cdp_v140.executors.abstract import AbstractCDP140Executor
+	from osn_selenium_cdp_v141.executors.abstract import AbstractCDP141Executor
+	from osn_selenium_cdp_v142.executors.abstract import AbstractCDP142Executor
+	from osn_selenium_cdp_v143.executors.abstract import AbstractCDP143Executor
+	from osn_selenium_cdp_v144.executors.abstract import AbstractCDP144Executor
+
+
+class AbstractCDPExecutor(ABC):
+	"""
+	Global abstract interface for accessing different versions of CDP.
+	"""
+
+	@property
+	@abstractmethod
+	def v140(self) -> "AbstractCDP140Executor":
+		"""
+		Access CDP version 140 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v141(self) -> "AbstractCDP141Executor":
+		"""
+		Access CDP version 141 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v142(self) -> "AbstractCDP142Executor":
+		"""
+		Access CDP version 142 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v143(self) -> "AbstractCDP143Executor":
+		"""
+		Access CDP version 143 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v144(self) -> "AbstractCDP144Executor":
+		"""
+		Access CDP version 144 interface.
+		"""
+
+		...

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/browsers_handler/models.py

@@ -1,5 +1,5 @@
 import pathlib
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 
 
 __all__ = ["Browser"]

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

@@ -10,7 +10,8 @@ from typing import (
 	Callable,
 	ParamSpec,
 	TYPE_CHECKING,
-	TypeVar
+	TypeVar,
+	Union
 )
 
 
@@ -19,6 +20,7 @@ __all__ = ["background_task_decorator", "log_on_error", "warn_if_active"]
 if TYPE_CHECKING:
 	from osn_selenium.dev_tools.manager import DevTools
 	from osn_selenium.dev_tools.target.base import BaseMixin
+	from osn_selenium.dev_tools.target import DevToolsTarget
 	from osn_selenium.dev_tools._typehints import DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT
 
 _METHOD_INPUT = ParamSpec("_METHOD_INPUT")
@@ -74,7 +76,7 @@ def warn_if_active(func: _METHOD) -> _METHOD:
 	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
 
 
-def log_on_error(func: Callable[_METHOD_INPUT, _METHOD_OUTPUT]) -> Callable[_METHOD_INPUT, _METHOD_OUTPUT]:
+def log_on_error(func: _METHOD) -> _METHOD:
 	"""
 	Decorator that logs any `BaseException` raised by the decorated async function.
 
@@ -115,26 +117,33 @@ def log_on_error(func: Callable[_METHOD_INPUT, _METHOD_OUTPUT]) -> Callable[_MET
 
 def background_task_decorator(func: "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT") -> "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT":
 	"""
-	Decorator for BaseTargetMixin background tasks to manage their lifecycle.
+	Decorator for target background tasks to manage their lifecycle.
 
 	This decorator wraps a target's background task function. It ensures that
 	`target.background_task_ended` event is set when the function completes,
 	allowing the `BaseTargetMixin` to track the task's termination.
 
 	Args:
-		func ("devtools_background_func_type"): The asynchronous background task function
-											  to be wrapped. It should accept a `BaseTargetMixin` instance.
+		func ("DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT"): The asynchronous background task function
+		to be wrapped. It should accept a target instance.
 
 	Returns:
-		"devtools_background_func_type": The wrapped function.
+		"DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT": The wrapped function.
 	"""
 	
 	@functools.wraps(func)
-	async def wrapper(target: "BaseMixin") -> Any:
-		target.background_task_ended = trio.Event()
+	async def wrapper(target: Union["BaseMixin", "DevToolsTarget"]) -> Any:
+		if not target.about_to_stop_event.is_set():
+			with trio.CancelScope() as cancel_scope:
+				target.cancel_scopes["background_task"] = cancel_scope
 		
-		await func(target)
+				try:
+					target.background_task_ended = trio.Event()
 		
-		target.background_task_ended.set()
+					await func(target)
+		
+					target.background_task_ended.set()
+				finally:
+					target.cancel_scopes.pop("background_task")
 	
 	return wrapper

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/dev_tools/_typehints.py

@@ -3,7 +3,8 @@ from typing import (
 	Callable,
 	Coroutine,
 	Literal,
-	TYPE_CHECKING
+	TYPE_CHECKING,
+	Union
 )
 
 
@@ -15,10 +16,12 @@ __all__ = [
 
 if TYPE_CHECKING:
 	from osn_selenium.dev_tools.target.base import BaseMixin as BaseTargetMixin
+	from osn_selenium.dev_tools.target import DevToolsTarget
 else:
 	BaseTargetMixin = Any
+	DevToolsTarget = Any
 
-DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT = Callable[[BaseTargetMixin], Coroutine[Any, Any, None]]
+DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT = Callable[[Union[BaseTargetMixin, DevToolsTarget]], Coroutine[Any, Any, None]]
 
 CDP_LOG_LEVELS_TYPEHINT = Literal[
 	"INFO",

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/dev_tools/_wrappers.py

@@ -46,9 +46,6 @@ def _yield_package_item_way(name: Union[str, Iterable[str]]) -> Generator[str, A
 class DevToolsPackage:
 	"""
 	Wrapper around the DevTools module to safely retrieve nested attributes/classes.
-
-	Attributes:
-		_package (ModuleType): The root DevTools module package.
 	"""
 	
 	def __init__(self, package: ModuleType):

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/dev_tools/domains/__init__.py

@@ -1,4 +1,4 @@
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import ExtraDictModel
 from typing import (
 	Literal,
 	Optional,
@@ -10,7 +10,7 @@ from osn_selenium.dev_tools.domains.fetch import FetchSettings
 __all__ = ["DomainsSettings", "domains_classes_type", "domains_type"]
 
 
-class DomainsSettings(DictModel):
+class DomainsSettings(ExtraDictModel):
 	"""
 	A dataclass container for configuration settings across different DevTools domains.
 

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/dev_tools/domains/abstract.py

@@ -1,5 +1,5 @@
 import trio
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from typing import (
 	Any,
 	Callable,

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

@@ -1,6 +1,6 @@
 import trio
 from pydantic import Field
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from osn_selenium.dev_tools._functions import execute_cdp_command
 from osn_selenium.exceptions.devtools import (
 	CDPEndExceptions,

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

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

{osn_selenium-1.0.0 → osn_selenium-1.1.0}/osn_selenium/dev_tools/filters.py

@@ -1,6 +1,6 @@
 from pydantic import Field
 from typing import List, Optional
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 
 
 __all__ = ["TargetFilter", "TargetsFilters"]