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

osn_selenium/{webdrivers/Yandex/flags.py → flags/models/yandex.py}

@@ -1,79 +1,23 @@
-import pathlib
-from typing import (
-	Optional,
-	TypedDict,
-	Union
-)
-from selenium.webdriver.chrome.options import Options
-from osn_selenium.webdrivers.Blink.flags import BlinkFeatures
-from osn_selenium.webdrivers.types import (
-	FlagDefinition,
-	FlagType
-)
-from osn_selenium.webdrivers.Chrome.flags import (
+from pydantic import Field
+from typing import Optional
+from osn_selenium.flags.models.blink import BlinkFeatures
+from osn_selenium.flags.models.chrome import (
 	ChromeArguments,
 	ChromeAttributes,
 	ChromeExperimentalOptions,
-	ChromeFlagsManager
+	ChromeFlags
 )
 
 
-class YandexFlagsManager(ChromeFlagsManager):
-	"""
-	Manages Yandex Browser-specific options for Selenium WebDriver.
+__all__ = [
+	"YandexArguments",
+	"YandexAttributes",
+	"YandexExperimentalOptions",
+	"YandexFlags"
+]
 
-	This class extends BrowserOptionsManager to provide specific configurations
-	for Yandex Browser options, such as experimental options and arguments.
 
-	Attributes:
-	"""
-	
-	def __init__(
-			self,
-			browser_exe: Optional[Union[str, pathlib.Path]] = None,
-			start_page_url: Optional[str] = None,
-			flags_types: Optional[dict[str, FlagType]] = None,
-			flags_definitions: Optional[dict[str, FlagDefinition]] = None
-	):
-		"""
-		Initializes YandexOptionsManager.
-
-		Sets up the Yandex Browser options manager with specific option configurations for
-		debugging port, user agent, proxy, and BiDi protocol.
-		"""
-		
-		yandex_flags_types = {}
-		
-		if flags_types is not None:
-			yandex_flags_types.update(flags_types)
-		
-		yandex_flags_definitions = {}
-		
-		if flags_definitions is not None:
-			yandex_flags_definitions.update(flags_definitions)
-		
-		super().__init__(
-				browser_exe=browser_exe,
-				start_page_url=start_page_url,
-				flags_types=yandex_flags_types,
-				flags_definitions=yandex_flags_definitions,
-		)
-	
-	def _renew_webdriver_options(self) -> Options:
-		"""
-		Creates and returns a new Options object.
-
-		Returns a fresh instance of `webdriver.ChromeOptions`, as Yandex Browser is based on Chromium,
-		allowing for a clean state of browser options to be configured.
-
-		Returns:
-			Options: A new Selenium Yandex Browser options object, based on ChromeOptions.
-		"""
-		
-		return Options()
-
-
-class YandexAttributes(ChromeAttributes, total=False):
+class YandexAttributes(ChromeAttributes):
 	"""
 	Typed dictionary for WebDriver attributes specific to Yandex browsers.
 
@@ -84,7 +28,7 @@ class YandexAttributes(ChromeAttributes, total=False):
 	pass
 
 
-class YandexExperimentalOptions(ChromeExperimentalOptions, total=False):
+class YandexExperimentalOptions(ChromeExperimentalOptions):
 	"""
 	Typed dictionary for experimental options specific to Yandex browsers.
 
@@ -95,7 +39,7 @@ class YandexExperimentalOptions(ChromeExperimentalOptions, total=False):
 	pass
 
 
-class YandexArguments(ChromeArguments, total=False):
+class YandexArguments(ChromeArguments):
 	"""
 	Typed dictionary for command-line arguments specific to Yandex browsers.
 
@@ -162,7 +106,7 @@ class YandexArguments(ChromeArguments, total=False):
 		proxy_server (Optional[str]): Specifies a proxy server to use.
 		remote_debugging_port (Optional[int]): Specifies the remote debugging port.
 		remote_debugging_address (Optional[str]): Specifies the remote debugging address.
-		use_file_for_fake_video_capture (Optional[Union[str, pathlib.Path]]): Uses a file for fake video capture.
+		use_file_for_fake_video_capture (Optional[PATH_TYPEHINT]): Uses a file for fake video capture.
 		autoplay_policy (Optional[AutoplayPolicyType]): Sets the autoplay policy.
 		log_level (Optional[LogLevelType]): Sets the browser's log level.
 		use_gl (Optional[UseGLType]): Specifies the GL backend to use.
@@ -172,7 +116,7 @@ class YandexArguments(ChromeArguments, total=False):
 	pass
 
 
-class YandexFlags(TypedDict, total=False):
+class YandexFlags(ChromeFlags):
 	"""
 	Typed dictionary representing a collection of all flag types for Yandex browsers.
 
@@ -186,7 +130,13 @@ class YandexFlags(TypedDict, total=False):
 		blink_feature (BlinkFeatures): Blink-specific feature flags.
 	"""
 	
-	argument: YandexArguments
-	experimental_option: YandexExperimentalOptions
-	attribute: YandexAttributes
-	blink_feature: BlinkFeatures
+	argument: YandexArguments = Field(default_factory=YandexArguments)
+	experimental_option: YandexExperimentalOptions = Field(default_factory=YandexExperimentalOptions)
+	attribute: YandexAttributes = Field(default_factory=YandexAttributes)
+	blink_feature: BlinkFeatures = Field(default_factory=BlinkFeatures)
+
+
+YandexArguments.model_rebuild()
+YandexExperimentalOptions.model_rebuild()
+YandexAttributes.model_rebuild()
+YandexFlags.model_rebuild()

osn_selenium/flags/yandex.py

@@ -0,0 +1,259 @@
+from typing import Dict, Optional
+from osn_selenium._typehints import PATH_TYPEHINT
+from selenium.webdriver.chrome.options import Options
+from osn_selenium.flags.chrome import ChromeFlagsManager
+from osn_selenium.flags.models.blink import BlinkFeatures
+from osn_selenium.flags.models.base import (
+	FlagDefinition,
+	FlagType
+)
+from osn_selenium.flags.models.yandex import (
+	YandexArguments,
+	YandexAttributes,
+	YandexExperimentalOptions,
+	YandexFlags
+)
+
+
+__all__ = ["YandexFlagsManager"]
+
+
+class YandexFlagsManager(ChromeFlagsManager):
+	"""
+	Manages Yandex Browser-specific options for Selenium WebDriver.
+
+	This class extends BrowserOptionsManager to provide specific configurations
+	for Yandex Browser options, such as experimental options and arguments.
+
+	Attributes:
+	"""
+	
+	def __init__(
+			self,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			start_page_url: Optional[str] = None,
+			flags_types: Optional[Dict[str, FlagType]] = None,
+			flags_definitions: Optional[Dict[str, FlagDefinition]] = None
+	):
+		"""
+		Initializes YandexOptionsManager.
+
+		Sets up the Yandex Browser options manager with specific option configurations for
+		debugging port, user agent, proxy, and BiDi protocol.
+		"""
+		
+		yandex_flags_types = {}
+		
+		if flags_types is not None:
+			yandex_flags_types.update(flags_types)
+		
+		yandex_flags_definitions = {}
+		
+		if flags_definitions is not None:
+			yandex_flags_definitions.update(flags_definitions)
+		
+		super().__init__(
+				browser_exe=browser_exe,
+				start_page_url=start_page_url,
+				flags_types=yandex_flags_types,
+				flags_definitions=yandex_flags_definitions,
+		)
+	
+	def _build_options_arguments(self, options: Options) -> Options:
+		"""
+		Adds configured command-line arguments to the WebDriver options.
+
+		Args:
+			options (Options): The WebDriver options object.
+
+		Returns:
+			Options: The modified WebDriver options object.
+		"""
+		
+		return super()._build_options_arguments(options)
+	
+	def _build_options_attributes(self, options: Options) -> Options:
+		"""
+		Applies configured attributes to the WebDriver options.
+
+		Args:
+			options (Options): The WebDriver options object.
+
+		Returns:
+			Options: The modified WebDriver options object.
+		"""
+		
+		return super()._build_options_attributes(options)
+	
+	def _build_options_blink_features(self, options: Options) -> Options:
+		"""
+		Adds configured Yandex features (`--enable-blink-features` and `--disable-blink-features`) to the WebDriver options.
+
+		Args:
+			options (Options): The WebDriver options object to modify.
+
+		Returns:
+			Options: The modified WebDriver options object.
+		"""
+		
+		return super()._build_options_blink_features(options)
+	
+	def _build_options_experimental_options(self, options: Options) -> Options:
+		"""
+		Adds experimental options to the WebDriver options.
+
+		Args:
+			options (Options): The WebDriver options object.
+
+		Returns:
+			Options: The modified WebDriver options object.
+		"""
+		
+		return super()._build_options_experimental_options(options)
+	
+	def _renew_webdriver_options(self) -> Options:
+		"""
+		Creates and returns a new Options object.
+
+		Returns a fresh instance of `webdriver.ChromeOptions`, as Yandex Browser is based on Chromium,
+		allowing for a clean state of browser options to be configured.
+
+		Returns:
+			Options: A new Selenium Yandex Browser options object, based on ChromeOptions.
+		"""
+		
+		return Options()
+	
+	def set_arguments(self, arguments: YandexArguments):
+		"""
+		Clears existing and sets new command-line arguments from a dictionary.
+
+		Args:
+			arguments (YandexArguments): A dictionary of arguments to set.
+
+		Raises:
+			ValueError: If an unknown argument key is provided.
+		"""
+		
+		super().set_arguments(arguments)
+	
+	def set_attributes(self, attributes: YandexAttributes):
+		"""
+		Clears existing and sets new browser attributes from a dictionary.
+
+		Args:
+			attributes (YandexAttributes): A dictionary of attributes to set.
+
+		Raises:
+			ValueError: If an unknown attribute key is provided.
+		"""
+		
+		super().set_attributes(attributes)
+	
+	def set_blink_features(self, blink_features: BlinkFeatures):
+		"""
+		Clears existing and sets new Yandex features from a dictionary.
+
+		Args:
+			blink_features (BlinkFeatures): A dictionary of Yandex features to set.
+
+		Raises:
+			ValueError: If an unknown Yandex feature key is provided.
+		"""
+		
+		super().set_blink_features(blink_features)
+	
+	def set_experimental_options(self, experimental_options: YandexExperimentalOptions):
+		"""
+		Clears existing and sets new experimental options from a dictionary.
+
+		Args:
+			experimental_options (YandexExperimentalOptions): A dictionary of experimental options to set.
+
+		Raises:
+			ValueError: If an unknown experimental option key is provided.
+		"""
+		
+		super().set_experimental_options(experimental_options)
+	
+	def set_flags(self, flags: YandexFlags):
+		"""
+		Clears all existing flags and sets new ones, including Yandex features.
+
+		This method delegates to the parent `set_flags` method, allowing it to handle
+		all flag types defined in this manager, including 'arguments', 'experimental_options',
+		'attributes', and 'blink_features'.
+
+		Args:
+			flags (YandexFlags): A dictionary where keys are flag types
+				and values are dictionaries of flags to set for that type.
+		"""
+		
+		super().set_flags(flags)
+	
+	def update_arguments(self, arguments: YandexArguments):
+		"""
+		Updates command-line arguments from a dictionary without clearing existing ones.
+
+		Args:
+			arguments (YandexArguments): A dictionary of arguments to set or update.
+
+		Raises:
+			ValueError: If an unknown argument key is provided.
+		"""
+		
+		super().update_arguments(arguments)
+	
+	def update_attributes(self, attributes: YandexAttributes):
+		"""
+		Updates browser attributes from a dictionary without clearing existing ones.
+
+		Args:
+			attributes (YandexAttributes): A dictionary of attributes to set or update.
+
+		Raises:
+			ValueError: If an unknown attribute key is provided.
+		"""
+		
+		super().update_attributes(attributes)
+	
+	def update_blink_features(self, blink_features: BlinkFeatures):
+		"""
+		Updates Yandex features from a dictionary without clearing existing ones.
+
+		Args:
+			blink_features (BlinkFeatures): A dictionary of Yandex features to set or update.
+
+		Raises:
+			ValueError: If an unknown Yandex feature key is provided.
+		"""
+		
+		super().update_blink_features(blink_features)
+	
+	def update_experimental_options(self, experimental_options: YandexExperimentalOptions):
+		"""
+		Updates experimental options from a dictionary without clearing existing ones.
+
+		Args:
+			experimental_options (YandexExperimentalOptions): A dictionary of experimental options to set or update.
+
+		Raises:
+			ValueError: If an unknown experimental option key is provided.
+		"""
+		
+		super().update_experimental_options(experimental_options)
+	
+	def update_flags(self, flags: YandexFlags):
+		"""
+		Updates all flags, including Yandex features, without clearing existing ones.
+
+		This method delegates to the parent `update_flags` method, allowing it to handle
+		all flag types defined in this manager, including 'arguments', 'experimental_options',
+		'attributes', and 'blink_features'.
+
+		Args:
+			flags (YandexFlags): A dictionary where keys are flag types
+				and values are dictionaries of flags to update for that type.
+		"""
+		
+		super().update_flags(flags)

osn_selenium/instances/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/_functions.py

@@ -0,0 +1,242 @@
+import math
+from typing import List
+from copy import deepcopy
+from random import randint
+from osn_selenium.models import Point
+from osn_selenium.instances._utils import (
+	MoveOffset,
+	MovePart,
+	MoveStep,
+	ScrollDelta,
+	ScrollPart,
+	TextInputPart
+)
+
+
+__all__ = ["move_to_parts", "scroll_to_parts", "text_input_to_parts"]
+
+
+def text_input_to_parts(text: str) -> List[TextInputPart]:
+	"""
+	Breaks down a text string into smaller parts for simulating human-like typing.
+
+	Generates a List of `TextInputPart` objects, where each part contains a character
+	or sequence of characters and a calculated duration. The duration simulates pauses
+	between key presses, with potentially longer pauses between different consecutive
+	characters.
+
+	Args:
+		text (str): The input string to be broken down.
+
+	Returns:
+		List[TextInputPart]: A List of `TextInputPart` objects representing the sequence
+							 of text segments and their associated durations for simulated typing.
+	"""
+	
+	parts = []
+	previous_sign = None
+	
+	for sign in text:
+		if previous_sign is None or sign == previous_sign:
+			parts.append(TextInputPart(text=sign, duration=randint(50, 70)))
+		else:
+			parts.append(TextInputPart(text=sign, duration=randint(100, 200)))
+	
+		previous_sign = sign
+	
+	return parts
+
+
+def scroll_to_parts(start_position: Point, end_position: Point) -> List[ScrollPart]:
+	"""
+	Calculates a sequence of smaller scroll steps with durations for human-like scrolling.
+
+	Simulates scrolling by generating a series of vertical steps followed by horizontal steps
+	until the target coordinates are reached. Each step is represented by a `ScrollPart`
+	containing the scroll delta for that step and a random duration.
+
+	Args:
+		start_position (Point): The starting conceptual scroll position.
+		end_position (Point): The target conceptual scroll position.
+
+	Returns:
+		List[ScrollPart]: A List of `ScrollPart` objects representing the sequence of scroll
+						  movements and their associated durations. The `delta` in each part
+						  represents the scroll amount for that step, and the `point` represents
+						  the conceptual position *after* applying that delta.
+	"""
+	
+	parts = []
+	
+	current_position = deepcopy(start_position)
+	
+	if start_position.y != end_position.y:
+		while current_position.y != end_position.y:
+			offset = randint(5, 20)
+	
+			if start_position.y > end_position.y:
+				offset *= -1
+	
+			if start_position.y < end_position.y:
+				if current_position.y + offset > end_position.y:
+					offset = end_position.y - current_position.y
+			elif start_position.y > end_position.y:
+				if current_position.y + offset < end_position.y:
+					offset = end_position.y - current_position.y
+	
+			current_position.y += offset
+			parts.append(
+					ScrollPart(
+							point=deepcopy(current_position),
+							delta=ScrollDelta(x=0, y=offset),
+							duration=randint(1, 4)
+					)
+			)
+	
+	if start_position.x != end_position.x:
+		while current_position.x != end_position.x:
+			offset = randint(5, 20)
+	
+			if start_position.x > end_position.x:
+				offset *= -1
+	
+			if start_position.x <= end_position.x:
+				if current_position.x + offset > end_position.x:
+					offset = end_position.x - current_position.x
+			elif start_position.x > end_position.x:
+				if current_position.x + offset < end_position.x:
+					offset = current_position.x - end_position.x
+	
+			current_position.x += offset
+			parts.append(
+					ScrollPart(
+							point=deepcopy(current_position),
+							delta=ScrollDelta(x=offset, y=0),
+							duration=randint(1, 4)
+					)
+			)
+	
+	return parts
+
+
+def move_to_parts(start_position: Point, end_position: Point) -> List[MovePart]:
+	"""
+	Calculates a sequence of smaller move steps with durations for human-like mouse movement.
+
+	Generates a path between a start and end point that deviates slightly from a
+	straight line using a sinusoidal function, simulating more natural mouse movement.
+	The path is broken into segments, each represented by a `MovePart` object specifying
+	the target point for that segment, the offset from the previous point, and a random duration.
+
+	Args:
+		start_position (Point): The starting coordinates for the movement.
+		end_position (Point): The target coordinates for the movement.
+
+	Returns:
+		List[MovePart]: A List of `MovePart` objects representing the sequence of mouse
+						movements and their associated durations. Each `MovePart` indicates
+						the `point` to move to, the `offset` from the previous point,
+						and the `duration` for that movement segment.
+	"""
+	
+	def get_new_position():
+		"""Calculates random horizontal and vertical amplitudes for deviation."""
+		
+		linear_progress = step.index / len(steps)
+		
+		deviation_x = step.amplitude_x * math.sin(linear_progress * 2 * math.pi)
+		current_x_linear = start_position.x + (end_position.x - start_position.x) * linear_progress
+		
+		deviation_y = step.amplitude_y * math.cos(linear_progress * 2 * math.pi)
+		current_y_linear = start_position.y + (end_position.y - start_position.y) * linear_progress
+		
+		return Point(
+				x=int(current_x_linear + deviation_x),
+				y=int(current_y_linear + deviation_y)
+		)
+	
+	def get_amplitude():
+		"""Generates a sequence of internal _MoveStep objects."""
+		
+		amplitude_x = randint(10, 20)
+		amplitude_y = randint(10, 20)
+		
+		if start_position.x > end_position.x:
+			amplitude_x *= -1
+		
+		if start_position.y > end_position.y:
+			amplitude_y *= -1
+		
+		return amplitude_x, amplitude_y
+	
+	def calculate_steps():
+		"""Calculates the target point for a move step, including sinusoidal deviation."""
+		
+		steps_ = []
+		current_point = deepcopy(start_position)
+		index = 0
+		
+		while current_point != end_position:
+			amplitude_x, amplitude_y = get_amplitude()
+			steps_.append(MoveStep(amplitude_x=amplitude_x, amplitude_y=amplitude_y, index=index))
+		
+			index += 1
+		
+			if start_position.x <= end_position.x:
+				current_point.x += amplitude_x if current_point.x + amplitude_x <= end_position.x else end_position.x - current_point.x
+			else:
+				current_point.x += amplitude_x if current_point.x + amplitude_x >= end_position.x else end_position.x - current_point.x
+		
+			if start_position.y <= end_position.y:
+				current_point.y += amplitude_y if current_point.y + amplitude_y <= end_position.y else end_position.y - current_point.y
+			else:
+				current_point.y += amplitude_y if current_point.y + amplitude_y >= end_position.y else end_position.y - current_point.y
+		
+		return steps_
+	
+	parts = []
+	steps = calculate_steps()
+	previous_position = deepcopy(start_position)
+	
+	for step in steps:
+		new_position = get_new_position()
+	
+		if start_position.x <= end_position.x:
+			new_position.x = int(new_position.x if new_position.x < end_position.x else end_position.x)
+		else:
+			new_position.x = int(new_position.x if new_position.x > end_position.x else end_position.x)
+	
+		if start_position.y <= end_position.y:
+			new_position.y = int(new_position.y if new_position.y < end_position.y else end_position.y)
+		else:
+			new_position.y = int(new_position.y if new_position.y > end_position.y else end_position.y)
+	
+		parts.append(
+				MovePart(
+						point=new_position,
+						offset=MoveOffset(
+								x=new_position.x - previous_position.x,
+								y=new_position.y - previous_position.y
+						),
+						duration=randint(1, 4)
+				)
+		)
+	
+		previous_position = deepcopy(new_position)
+	
+		if parts[-1].point == end_position:
+			break
+	
+	if parts[-1].point != end_position:
+		parts.append(
+				MovePart(
+						point=end_position,
+						offset=MoveOffset(
+								x=end_position.x - previous_position.x,
+								y=end_position.y - previous_position.y
+						),
+						duration=randint(1, 4)
+				)
+		)
+	
+	return parts