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

osn_selenium/javascript/fingerprint/spoof/rules.py

@@ -0,0 +1,313 @@
+from pydantic import Field
+from typing import (
+	Dict,
+	Literal,
+	Optional
+)
+from osn_selenium.javascript._functions import convert_to_js_value
+from osn_selenium.javascript.fingerprint._functions import add_code_level
+from osn_selenium.javascript.fingerprint.spoof.noise import (
+	RandomNoise,
+	StaticNoise
+)
+from osn_selenium.javascript.fingerprint.spoof._typehints import (
+	RANDOM_VALUE_TYPEHINT
+)
+from osn_selenium.javascript.fingerprint.spoof.core_rules import (
+	ArrayRule,
+	BaseRule,
+	RandomRule
+)
+from osn_selenium.javascript.fingerprint.spoof._functions import (
+	get_noise_js,
+	get_random_expression_js
+)
+from osn_selenium.javascript.fingerprint.spoof._templates import (
+	CUSTOM_RULE,
+	PERSISTED_RANDOM_ITEM_NOISE,
+	PERSISTED_RANDOM_ITEM_SET,
+	PERSISTENCE_CHECK_NOISE,
+	PERSISTENCE_CHECK_RETURN,
+	PERSISTENCE_SAVE_NOISE,
+	PERSISTENCE_SAVE_RESULT,
+	RANDOM_ITEM_NOISE,
+	RANDOM_ITEM_SET,
+	STATIC_ITEM_NOISE,
+	STATIC_ITEM_SET
+)
+
+
+__all__ = [
+	"CustomRule",
+	"RandomArrayNoiseRule",
+	"RandomArraySetRule",
+	"RandomItemNoiseRule",
+	"RandomItemSetRule",
+	"StaticArrayNoiseRule",
+	"StaticArraySetRule",
+	"StaticItemNoiseRule",
+	"StaticItemSetRule"
+]
+
+
+class StaticItemSetRule(BaseRule):
+	"""
+	Rule to replace a value with a static constant.
+	"""
+	
+	mode: Literal["static_item_set"] = "static_item_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to return a fixed value.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		return STATIC_ITEM_SET.format(result_value=convert_to_js_value(self.value))
+
+
+class StaticItemNoiseRule(BaseRule):
+	"""
+	Rule to apply static noise to a value.
+	"""
+	
+	mode: Literal["static_item_noise"] = "static_item_noise"
+	value: StaticNoise
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to apply calculated static noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		expression = get_noise_js(
+				target="originalValue",
+				noise=str(self.value.value),
+				operation=self.value.operation,
+				round_result=self.value.round,
+				precision=self.value.precision,
+		)
+		
+		return STATIC_ITEM_NOISE.format(math_expression=expression)
+
+
+class StaticArraySetRule(ArrayRule):
+	"""
+	Rule to replace elements in an array with static values.
+	"""
+	
+	mode: Literal["static_array_set"] = "static_array_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and set static values.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return convert_to_js_value(item)
+		
+		return self._generate_array_js(get_expr)
+
+
+class StaticArrayNoiseRule(ArrayRule):
+	"""
+	Rule to apply static noise to elements in an array.
+	"""
+	
+	mode: Literal["static_array_noise"] = "static_array_noise"
+	value_by_channel: Dict[int, StaticNoise] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and apply static noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return get_noise_js(
+					target="dataArray[i]",
+					noise=str(item.value),
+					operation=item.operation,
+					round_result=item.round,
+					precision=item.precision,
+			)
+		
+		return self._generate_array_js(get_expr)
+
+
+class RandomItemSetRule(RandomRule):
+	"""
+	Rule to replace a value with a randomly generated one.
+	"""
+	
+	mode: Literal["random_item_set"] = "random_item_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to return a random value, optionally persisted.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		if self.persist:
+			storage_key = f"prop_{path.replace('.', '_')}"
+		
+			return PERSISTED_RANDOM_ITEM_SET.format(
+					persistence_check_code=add_code_level(code=PERSISTENCE_CHECK_RETURN.format(storage_key=storage_key), num=1),
+					calculation_expression=get_random_expression_js(self.value),
+					persistence_save_code=PERSISTENCE_SAVE_RESULT.format(storage_key=storage_key)
+			)
+		
+		return RANDOM_ITEM_SET.format(calculation_expression=get_random_expression_js(self.value))
+
+
+class RandomItemNoiseRule(RandomRule):
+	"""
+	Rule to apply random noise to a value.
+	"""
+	
+	mode: Literal["random_item_noise"] = "random_item_noise"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to apply random noise, optionally persisted.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		storage_key = f"prop_{path.replace('.', '_')}"
+		
+		math_expression = get_noise_js(
+				target="originalValue",
+				noise="noiseValue",
+				operation=self.value.operation,
+				round_result=self.value.round,
+				precision=self.value.precision,
+		)
+		
+		if self.persist:
+			return PERSISTED_RANDOM_ITEM_NOISE.format(
+					persistence_check_code=add_code_level(
+							code=PERSISTENCE_CHECK_NOISE.format(storage_key=storage_key, math_expression_with_noise=math_expression),
+							num=1
+					),
+					calculation_expression=get_random_expression_js(self.value.value),
+					persistence_save_code=PERSISTENCE_SAVE_NOISE.format(storage_key=storage_key),
+					math_expression=math_expression
+			)
+		
+		return RANDOM_ITEM_NOISE.format(
+				calculation_expression=get_random_expression_js(self.value.value),
+				math_expression=math_expression
+		)
+
+
+class RandomArraySetRule(ArrayRule):
+	"""
+	Rule to replace elements in an array with random values.
+	"""
+	
+	mode: Literal["random_array_set"] = "random_array_set"
+	value: Optional[RANDOM_VALUE_TYPEHINT]
+	value_by_channel: Dict[int, RANDOM_VALUE_TYPEHINT] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and set random values.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return get_random_expression_js(item)
+		
+		return self._generate_array_js(get_expr)
+
+
+class RandomArrayNoiseRule(ArrayRule):
+	"""
+	Rule to apply random noise to elements in an array.
+	"""
+	
+	mode: Literal["random_array_noise"] = "random_array_noise"
+	value: Optional[RandomNoise]
+	value_by_channel: Dict[int, RandomNoise] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and apply random noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			noise_expr = get_random_expression_js(item.value)
+			
+			return get_noise_js(
+					target="dataArray[i]",
+					noise=noise_expr,
+					operation=item.operation,
+					round_result=item.round,
+					precision=item.precision,
+			)
+		
+		return self._generate_array_js(get_expr)
+
+
+class CustomRule(BaseRule):
+	"""
+	Rule to apply custom JavaScript code.
+	"""
+	
+	mode: Literal["custom"] = "custom"
+	value: str
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates the custom JS injection.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		return CUSTOM_RULE.format(custom_javascript_code=self.value)

osn_selenium/javascript/functions.py

@@ -0,0 +1,44 @@
+import pathlib
+from typing import Optional
+from pydantic import ValidationError
+from osn_selenium.javascript.models import JS_Scripts
+from osn_selenium.exceptions.javascript import (
+	JavaScriptResourceError
+)
+
+
+__all__ = ["get_js_scripts"]
+
+_CACHED_JS_SCRIPTS: Optional[JS_Scripts] = None
+
+
+def get_js_scripts() -> JS_Scripts:
+	"""
+	Reads JavaScript scripts from files and returns them in a JS_Scripts object.
+
+	This function locates all `.js` files within the 'scripts' directory, which is expected
+	to be located in the same parent directory as this module. It reads the content of each
+	JavaScript file using UTF-8 encoding and stores these scripts in a `JS_Scripts` model.
+	The filenames (without the `.js` extension) are used as keys.
+
+	Returns:
+		JS_Scripts: An object containing the content of each JavaScript file as attributes.
+	"""
+	
+	global _CACHED_JS_SCRIPTS
+	
+	if _CACHED_JS_SCRIPTS is None:
+		scripts = {}
+		path_to_js_scripts = pathlib.Path(__file__).parent / "scripts"
+	
+		for script_file in path_to_js_scripts.iterdir():
+			scripts[script_file.stem] = script_file.read_text(encoding="utf-8")
+	
+		try:
+			_CACHED_JS_SCRIPTS = JS_Scripts.model_validate(scripts)
+		except ValidationError as exception:
+			missing_fields = [error["loc"][0] for error in exception.errors()]
+	
+			raise JavaScriptResourceError(missing_script=missing_fields)
+	
+	return _CACHED_JS_SCRIPTS

osn_selenium/javascript/models.py

@@ -0,0 +1,35 @@
+from osn_selenium._base_models import DictModel
+
+
+__all__ = ["JS_Scripts"]
+
+
+class JS_Scripts(DictModel):
+	"""
+	Represents a collection of JavaScript script snippets for use with WebDriver.
+
+	Attributes:
+		check_element_in_viewport (str): JS to check if element is in the viewport.
+		get_document_scroll_size (str): JS to get total scrollable dimensions.
+		get_element_css (str): JS to get computed CSS styles of an element.
+		get_element_rect_in_viewport (str): JS to get element bounds in viewport.
+		get_random_element_point_in_viewport (str): JS to get a random visible point in element.
+		get_viewport_position (str): JS to get scroll position of viewport.
+		get_viewport_rect (str): JS to get viewport scroll offset and dimensions.
+		get_viewport_size (str): JS to get dimensions of the viewport.
+		open_new_tab (str): JS to open a new tab.
+		start_fingerprint_detection (str): JS to initialize fingerprint detection hooks.
+		stop_window_loading (str): JS to stop the page from loading.
+	"""
+	
+	check_element_in_viewport: str
+	get_document_scroll_size: str
+	get_element_css: str
+	get_element_rect_in_viewport: str
+	get_random_element_point_in_viewport: str
+	get_viewport_position: str
+	get_viewport_rect: str
+	get_viewport_size: str
+	open_new_tab: str
+	start_fingerprint_detection: str
+	stop_window_loading: str

osn_selenium/javascript/scripts/start_fingerprint_detection.js

@@ -0,0 +1,56 @@
+function start_fingerprint_detection(settings) {
+    const CONFIG = {
+        BINDING: '__osn_fingerprint_report__',
+        SILENT_ERRORS: true,
+        EVENTS_OPTIMIZATION: settings.optimize_events
+    };
+
+    const MODIFIERS = {};
+__MODIFIERS_PLACEHOLDER__
+
+    const STORAGE = new Map();
+
+    const hookedRegistry = new WeakSet();
+    const sentEvents = new Set();
+
+    function guard(fn, fallback = undefined) {
+        try {
+            return fn();
+        } catch (e) {
+            if (!CONFIG.SILENT_ERRORS) console.error('FingerprintHook Error:', e);
+            return fallback;
+        }
+    }
+
+    const Reporter = {
+        send(api, target, method) {
+            guard(() => {
+                if (CONFIG.EVENTS_OPTIMIZATION) {
+                    const key = `${api}:${target}:${method}`;
+
+                    if (sentEvents.has(key)) return;
+
+                    sentEvents.add(key);
+                }
+
+                const reportFn = window[CONFIG.BINDING];
+
+                if (typeof reportFn === 'function') {
+                    const stack = (new Error()).stack;
+
+                    const payload = JSON.stringify({
+                        api: api,
+                        used_method: `${target}.${method}`,
+                        stacktrace: stack
+                    });
+
+                    reportFn(payload);
+                }
+            });
+        }
+    };
+
+__DETECTION_PLACEHOLDER__
+}
+
+start_fingerprint_detection(__SETTINGS__PLACEHOLDER__);

osn_selenium/models.py

@@ -0,0 +1,94 @@
+from typing import Self
+from osn_selenium._base_models import DictModel
+
+
+__all__ = ["Point", "Position", "Rectangle", "Size", "WindowRect"]
+
+
+class WindowRect(DictModel):
+	"""
+	Defines a window's geometry with default values relative to screen size.
+
+	The default values position the window in the center of the screen,
+	occupying a significant portion of it.
+
+	Attributes:
+		x (int): The x-coordinate of the window's top-left corner. Defaults to 100.
+		y (int): The y-coordinate of the window's top-left corner. Defaults to 100.
+		width (int): The width of the window. Defaults to 400.
+		height (int): The height of the window. Defaults to 400.
+	"""
+	
+	x: int = 100
+	y: int = 100
+	width: int = 1024
+	height: int = 768
+
+
+class Size(DictModel):
+	"""
+	Represents a 2D size.
+
+	Attributes:
+		width (int): The width dimension.
+		height (int): The height dimension.
+	"""
+	
+	width: int
+	height: int
+
+
+class Rectangle(DictModel):
+	"""
+	Defines a rectangle by its top-left corner and dimensions.
+
+	Attributes:
+		x (int): The x-coordinate of the top-left corner.
+		y (int): The y-coordinate of the top-left corner.
+		width (int): The width of the rectangle.
+		height (int): The height of the rectangle.
+	"""
+	
+	x: int
+	y: int
+	width: int
+	height: int
+
+
+class Position(DictModel):
+	"""
+	Represents a 2D coordinate.
+
+	Attributes:
+		x (int): The x-coordinate.
+		y (int): The y-coordinate.
+	"""
+	
+	x: int
+	y: int
+
+
+class Point:
+	"""
+	Represents a 2D point with integer coordinates (x, y).
+
+	Attributes:
+		x (int): The horizontal coordinate.
+		y (int): The vertical coordinate.
+	"""
+	
+	def __init__(self, x: int, y: int):
+		self.x: int = x
+		self.y: int = y
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return f"Point(x={self.x}, y={self.y})"
+	
+	def __eq__(self, other: Self) -> bool:
+		return self.x == other.x and self.y == other.y
+	
+	def __ne__(self, other: Self) -> bool:
+		return not self.__eq__(other)

osn_selenium/trio_threads_mixin.py

@@ -0,0 +1,159 @@
+import sys
+import trio
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncContextManager,
+	AsyncIterator,
+	Callable,
+	ContextManager,
+	Coroutine,
+	ParamSpec,
+	TypeVar
+)
+
+
+__all__ = ["TrioThreadMixin"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+
+
+class TrioThreadMixin:
+	"""
+	Provides utilities for running synchronous functions in a Trio event loop
+	with a controlled concurrency, ensuring thread safety and resource limits.
+	"""
+	
+	def __init__(self, lock: trio.Lock, limiter: trio.CapacityLimiter) -> None:
+		"""
+		Initializes the TrioThreadMixin with a Trio Lock and CapacityLimiter.
+
+		Args:
+			lock (trio.Lock): A Trio Lock for synchronization.
+			limiter (trio.CapacityLimiter): A limiter to control thread pool concurrency.
+		"""
+		
+		self._lock = lock
+		self._capacity_limiter = limiter
+	
+	@property
+	def capacity_limiter(self) -> trio.CapacityLimiter:
+		"""
+		The Trio CapacityLimiter used for concurrency control.
+
+		Returns:
+			trio.CapacityLimiter: The limiter instance.
+		"""
+		
+		return self._capacity_limiter
+	
+	@property
+	def lock(self) -> trio.Lock:
+		"""
+		The Trio Lock used for synchronization.
+
+		Returns:
+			trio.Lock: The lock instance.
+		"""
+		
+		return self._lock
+	
+	def sync_to_trio(
+			self,
+			sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT],
+			lock: bool = True,
+	) -> 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 (bool): Whether to use the internal lock for synchronization.
+
+		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_) -> _METHOD_OUTPUT:
+				"""
+				Helper to pass keyword arguments to trio.to_thread.run_sync.
+
+				Args:
+					*args_: Positional arguments passed from the outer scope.
+
+				Returns:
+					_METHOD_OUTPUT: Result of the original sync function.
+				"""
+				
+				return sync_function(*args_, **kwargs)
+			
+			if lock:
+				async with self._lock:
+					result = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=self._capacity_limiter)
+			else:
+				result = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=self._capacity_limiter)
+			
+			return result
+		
+		return wrapper
+	
+	def sync_to_trio_context(
+			self,
+			context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]],
+			lock: bool = True,
+	) -> 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]]): A factory function returning a context manager.
+			lock (bool): Whether to use the internal lock for synchronization.
+
+		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 self.sync_to_trio(sync_function=context_manager_factory, lock=lock)(*args, **kwargs)
+			
+			enter_ = self.sync_to_trio(sync_function=sync_context_manager.__enter__, lock=lock)
+			exit_ = self.sync_to_trio(sync_function=sync_context_manager.__exit__, lock=lock)
+			
+			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