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

osn_selenium/{webdrivers/BaseDriver/flags.py → flags/base.py}

@@ -1,132 +1,44 @@
+from copy import deepcopy
+from osn_selenium.models import DictModel
 from typing import (
 	Any,
-	Optional,
-	TypedDict,
-	Union
+	Dict,
+	List,
+	Optional
 )
-from osn_selenium.webdrivers.types import (
-	FlagDefinition,
-	FlagNotDefined,
-	FlagType,
-	_any_webdriver_option_type
+from osn_selenium.flags._functions import argument_to_flag
+from osn_selenium.exceptions.logic import (
+	AbstractImplementationError
+)
+from osn_selenium.flags._typehints import (
+	ANY_WEBDRIVER_OPTION_TYPEHINT
+)
+from osn_selenium.exceptions.flags import (
+	FlagNotDefinedError,
+	FlagTypeNotDefinedError
+)
+from osn_selenium.flags.models.values import (
+	ArgumentValue,
+	AttributeValue,
+	ExperimentalOptionValue
 )
-from osn_selenium.webdrivers._functions import (
+from osn_selenium.flags._validators import (
 	bool_adding_validation_function,
 	optional_bool_adding_validation_function
 )
+from osn_selenium.flags.models.base import (
+	BrowserArguments,
+	BrowserAttributes,
+	BrowserExperimentalOptions,
+	BrowserFlags,
+	FlagDefinition,
+	FlagNotDefined,
+	FlagType,
+	FlagTypeNotDefined
+)
 
 
-class ArgumentValue(TypedDict):
-	"""
-	Typed dictionary representing a single command-line argument and its value.
-
-	Attributes:
-		command_line (str): The command-line string for the argument.
-		value (Any): The value associated with the argument.
-	"""
-	
-	command_line: str
-	value: Any
-
-
-def _argument_to_flag(argument: ArgumentValue) -> str:
-	"""
-	Formats a command-line argument from an ArgumentValue dictionary.
-
-	If the command string contains '{value}', it will be replaced by the argument's value.
-	Otherwise, the command string is returned as is.
-
-	Args:
-		argument (ArgumentValue): A dictionary containing the command-line string and its value.
-
-	Returns:
-		str: The formatted command-line argument string.
-	"""
-	
-	argument_command = argument["command_line"]
-	argument_value = argument["value"]
-	
-	if "{value}" in argument_command:
-		return argument_command.format(value=argument_value)
-	else:
-		return argument_command
-
-
-class ExperimentalOptionValue(TypedDict):
-	"""
-	Typed dictionary representing a single experimental option and its value.
-
-	Attributes:
-		option_name (str): The name of the experimental option.
-		value (Any): The value of the experimental option.
-	"""
-	
-	option_name: str
-	value: Any
-
-
-class AttributeValue(TypedDict):
-	"""
-	Typed dictionary representing a single WebDriver attribute and its value.
-
-	Attributes:
-		attribute_name (str): The name of the attribute.
-		value (Any): The value of the attribute.
-	"""
-	
-	attribute_name: str
-	value: Any
-
-
-class FlagTypeNotDefined:
-	"""A sentinel class to indicate that a flag type definition was not found."""
-	
-	pass
-
-
-class BrowserExperimentalOptions(TypedDict, total=False):
-	"""
-	Typed dictionary for browser-agnostic experimental options.
-	"""
-	
-	pass
-
-
-class BrowserAttributes(TypedDict, total=False):
-	"""
-	Typed dictionary for browser-agnostic WebDriver attributes.
-
-	Attributes:
-		enable_bidi (Optional[bool]): Enables/disables BiDi (Bidirectional) protocol mapper.
-	"""
-	
-	enable_bidi: Optional[bool]
-
-
-class BrowserArguments(TypedDict, total=False):
-	"""
-	Typed dictionary for browser-agnostic command-line arguments.
-
-	Attributes:
-		se_downloads_enabled (bool): Enables/disables Selenium downloads.
-	"""
-	
-	se_downloads_enabled: bool
-
-
-class BrowserFlags(TypedDict, total=False):
-	"""
-	Typed dictionary representing a collection of all flag types.
-
-	Attributes:
-		argument (BrowserArguments): Command-line arguments for the browser.
-		experimental_option (BrowserExperimentalOptions): Experimental options for WebDriver.
-		attribute (BrowserAttributes): WebDriver attributes.
-	"""
-	
-	argument: BrowserArguments
-	experimental_option: BrowserExperimentalOptions
-	attribute: BrowserAttributes
+__all__ = ["BrowserFlagsManager"]
 
 
 class BrowserFlagsManager:
@@ -137,25 +49,25 @@ class BrowserFlagsManager:
 	for various Selenium WebDriver instances.
 
 	Attributes:
-		_flags_types (dict[str, FlagType]): A dictionary mapping flag types to their handler functions.
-		_flags_definitions (dict[str, FlagDefinition]): A dictionary of all available flag definitions.
-		_flags_definitions_by_types (dict[str, dict[str, FlagDefinition]]): Flags definitions grouped by type.
-		_arguments (dict[str, ArgumentValue]): Stores the configured command-line arguments.
-		_experimental_options (dict[str, ExperimentalOptionValue]): Stores the configured experimental options.
-		_attributes (dict[str, AttributeValue]): Stores the configured WebDriver attributes.
+		_flags_types (Dict[str, FlagType]): A dictionary mapping flag types to their handler functions.
+		_flags_definitions (Dict[str, FlagDefinition]): A dictionary of all available flag definitions.
+		_flags_definitions_by_types (Dict[str, Dict[str, FlagDefinition]]): Flags definitions grouped by type.
+		_arguments (Dict[str, ArgumentValue]): Stores the configured command-line arguments.
+		_experimental_options (Dict[str, ExperimentalOptionValue]): Stores the configured experimental options.
+		_attributes (Dict[str, AttributeValue]): Stores the configured WebDriver attributes.
 	"""
 	
 	def __init__(
 			self,
-			flags_types: Optional[dict[str, FlagType]] = None,
-			flags_definitions: Optional[dict[str, FlagDefinition]] = None
+			flags_types: Optional[Dict[str, FlagType]] = None,
+			flags_definitions: Optional[Dict[str, FlagDefinition]] = None
 	):
 		"""
 		Initializes the BrowserFlagsManager.
 
 		Args:
-			flags_types (Optional[dict[str, FlagType]]): Custom flag types and their corresponding functions.
-			flags_definitions (Optional[dict[str, FlagDefinition]]): Custom flag definitions to add or override.
+			flags_types (Optional[Dict[str, FlagType]]): Custom flag types and their corresponding functions.
+			flags_definitions (Optional[Dict[str, FlagDefinition]]): Custom flag definitions to add or override.
 		"""
 		
 		inner_flags_types = {
@@ -165,8 +77,8 @@ class BrowserFlagsManager:
 					set_flags_function=self.set_arguments,
 					update_flags_function=self.update_arguments,
 					clear_flags_function=self.clear_arguments,
-					build_options_function=self.build_options_arguments,
-					build_start_args_function=self.build_start_args_arguments
+					build_options_function=self._build_options_arguments,
+					build_start_args_function=self._build_start_args_arguments
 			),
 			"experimental_option": FlagType(
 					set_flag_function=self.set_experimental_option,
@@ -174,8 +86,8 @@ class BrowserFlagsManager:
 					set_flags_function=self.set_experimental_options,
 					update_flags_function=self.update_experimental_options,
 					clear_flags_function=self.clear_experimental_options,
-					build_options_function=self.build_options_experimental_options,
-					build_start_args_function=lambda: []
+					build_options_function=self._build_options_experimental_options,
+					build_start_args_function=lambda: [],
 			),
 			"attribute": FlagType(
 					set_flag_function=self.set_attribute,
@@ -183,8 +95,8 @@ class BrowserFlagsManager:
 					set_flags_function=self.set_attributes,
 					update_flags_function=self.update_attributes,
 					clear_flags_function=self.clear_attributes,
-					build_options_function=self.build_options_attributes,
-					build_start_args_function=lambda: []
+					build_options_function=self._build_options_attributes,
+					build_start_args_function=lambda: [],
 			),
 		}
 		
@@ -214,33 +126,33 @@ class BrowserFlagsManager:
 		self._flags_types = inner_flags_types
 		self._flags_definitions = inner_flags_definitions
 		
-		self._flags_definitions_by_types: dict[str, dict[str, FlagDefinition]] = {
+		self._flags_definitions_by_types: Dict[str, Dict[str, FlagDefinition]] = {
 			option_type: dict(
-					filter(lambda di: di[1]["type"] == option_type, self._flags_definitions.items())
+					filter(lambda di: di[1].type == option_type, self._flags_definitions.items())
 			)
 			for option_type in self._flags_types.keys()
 		}
 		
-		self._arguments: dict[str, ArgumentValue] = {}
-		self._experimental_options: dict[str, ExperimentalOptionValue] = {}
-		self._attributes: dict[str, AttributeValue] = {}
+		self._arguments: Dict[str, ArgumentValue] = {}
+		self._experimental_options: Dict[str, ExperimentalOptionValue] = {}
+		self._attributes: Dict[str, AttributeValue] = {}
 	
-	def build_options_attributes(self, options: _any_webdriver_option_type) -> _any_webdriver_option_type:
+	def _build_options_attributes(self, options: ANY_WEBDRIVER_OPTION_TYPEHINT) -> ANY_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Applies configured attributes to the WebDriver options object.
 
 		Only attributes with `mode` set to 'webdriver_option' or 'both' are applied.
 
 		Args:
-			options (_any_webdriver_option_type): The WebDriver options object to modify.
+			options (any_webdriver_option_type): The WebDriver options object to modify.
 
 		Returns:
-			_any_webdriver_option_type: The modified WebDriver options object.
+			any_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
 		for name, value in self._attributes.items():
-			if self._flags_definitions_by_types["attribute"][name]["mode"] in ["webdriver_option", "both"]:
-				setattr(options, value["attribute_name"], value["value"])
+			if self._flags_definitions_by_types["attribute"][name].mode in ["webdriver_option", "both"]:
+				setattr(options, value.attribute_name, value.value)
 		
 		return options
 	
@@ -262,73 +174,70 @@ class BrowserFlagsManager:
 		
 		self._attributes.pop(attribute_name, None)
 	
-	def set_attribute(self, attribute: FlagDefinition, value: Any):
+	def set_attribute(self, attribute: FlagDefinition, value: DictModel):
 		"""
 		Sets a browser attribute. If the attribute already exists, it is overwritten.
 
 		Args:
 			attribute (FlagDefinition): The definition of the attribute to set.
-			value (Any): The value to assign to the attribute.
+			value (DictModel): The value to assign to the attribute.
 		"""
 		
-		attribute_name = attribute["name"]
-		attribute_command = attribute["command"]
-		adding_validation_function = attribute["adding_validation_function"]
+		attribute_name = attribute.name
+		attribute_command = attribute.command
+		adding_validation_function = attribute.adding_validation_function
 		
 		self.remove_attribute(attribute_name)
 		
 		if adding_validation_function(value):
 			self._attributes[attribute_name] = AttributeValue(attribute_name=attribute_command, value=value)
 	
-	def update_attributes(self, attributes: Union[BrowserAttributes, dict[str, Any]]):
+	def update_attributes(self, attributes: BrowserAttributes):
 		"""
 		Updates browser attributes from a dictionary without clearing existing ones.
 
 		Args:
-			attributes (Union[BrowserAttributes, dict[str, Any]]): A dictionary of attributes to set or update.
+			attributes (BrowserAttributes): A dictionary of attributes to set or update.
 
 		Raises:
-			ValueError: If an unknown attribute key is provided.
+			FlagNotDefinedError: If an unknown attribute key is provided.
 		"""
 		
-		for key, value in attributes.items():
+		for key, value in attributes.model_dump(exclude_none=True).items():
 			flag_definition = self._flags_definitions_by_types["attribute"].get(key, FlagNotDefined())
 		
 			if isinstance(flag_definition, FlagNotDefined):
-				raise ValueError(f"Unknown attribute: {key}.")
+				raise FlagNotDefinedError(flag_name=key, flag_type="attributes")
 		
-			self.set_attribute(flag_definition, value)
+			self.set_attribute(flag_definition, getattr(attributes, key))
 	
-	def set_attributes(self, attributes: Union[BrowserAttributes, dict[str, Any]]):
+	def set_attributes(self, attributes: BrowserAttributes):
 		"""
 		Clears existing and sets new browser attributes from a dictionary.
 
 		Args:
-			attributes (Union[BrowserAttributes, dict[str, Any]]): A dictionary of attributes to set.
-
-		Raises:
-			ValueError: If an unknown attribute key is provided.
+			attributes (BrowserAttributes): A dictionary of attributes to set.
 		"""
 		
 		self.clear_attributes()
 		self.update_attributes(attributes)
 	
-	def build_options_experimental_options(self, options: _any_webdriver_option_type) -> _any_webdriver_option_type:
+	def _build_options_experimental_options(self, options: ANY_WEBDRIVER_OPTION_TYPEHINT) -> ANY_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Adds configured experimental options to the WebDriver options object.
 
 		Only options with `mode` set to 'webdriver_option' or 'both' are added.
 
 		Args:
-			options (_any_webdriver_option_type): The WebDriver options object to modify.
+			options (any_webdriver_option_type): The WebDriver options object to modify.
 
 		Returns:
-			_any_webdriver_option_type: The modified WebDriver options object.
+			any_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
 		for name, value in self._experimental_options.items():
-			if self._flags_definitions_by_types["experimental_option"][name]["mode"] in ["webdriver_option", "both"]:
-				options.add_experimental_option(value["option_name"], value["value"])
+			if self._flags_definitions_by_types["experimental_option"][name].mode in ["webdriver_option", "both"]:
+				options.add_experimental_option(value.option_name, value.value)
 		
 		return options
 	
@@ -351,95 +260,86 @@ class BrowserFlagsManager:
 		
 		self._experimental_options.pop(experimental_option_name, None)
 	
-	def set_experimental_option(self, experimental_option: FlagDefinition, value: Any):
+	def set_experimental_option(self, experimental_option: FlagDefinition, value: DictModel):
 		"""
 		Sets an experimental browser option. If the option already exists, it is overwritten.
 
 		Args:
 			experimental_option (FlagDefinition): The definition of the experimental option to set.
-			value (Any): The value to assign to the option.
+			value (DictModel): The value to assign to the option.
 		"""
 		
-		experimental_option_name = experimental_option["name"]
-		experimental_option_command = experimental_option["command"]
-		adding_validation_function = experimental_option["adding_validation_function"]
+		experimental_option_name = experimental_option.name
+		experimental_option_command = experimental_option.command
+		adding_validation_function = experimental_option.adding_validation_function
 		
 		self.remove_experimental_option(experimental_option_name)
 		
 		if adding_validation_function(value):
 			self._experimental_options[experimental_option_name] = ExperimentalOptionValue(option_name=experimental_option_command, value=value)
 	
-	def update_experimental_options(
-			self,
-			experimental_options: Union[BrowserExperimentalOptions, dict[str, Any]]
-	):
+	def update_experimental_options(self, experimental_options: BrowserExperimentalOptions):
 		"""
 		Updates experimental options from a dictionary without clearing existing ones.
 
 		Args:
-			experimental_options (Union[BrowserExperimentalOptions, dict[str, Any]]): A dictionary of experimental options to set or update.
+			experimental_options (BrowserExperimentalOptions): A dictionary of experimental options to set or update.
 
 		Raises:
-			ValueError: If an unknown experimental option key is provided.
+			FlagNotDefinedError: If an unknown experimental option key is provided.
 		"""
 		
-		for key, value in experimental_options.items():
+		for key, value in experimental_options.model_dump(exclude_none=True).items():
 			flag_definition = self._flags_definitions_by_types["experimental_option"].get(key, FlagNotDefined())
 		
 			if isinstance(flag_definition, FlagNotDefined):
-				raise ValueError(f"Unknown experimental option: {key}.")
+				raise FlagNotDefinedError(flag_name=key, flag_type="experimental options")
 		
-			self.set_experimental_option(flag_definition, value)
+			self.set_experimental_option(flag_definition, getattr(experimental_options, key))
 	
-	def set_experimental_options(
-			self,
-			experimental_options: Union[BrowserExperimentalOptions, dict[str, Any]]
-	):
+	def set_experimental_options(self, experimental_options: BrowserExperimentalOptions):
 		"""
 		Clears existing and sets new experimental options from a dictionary.
 
 		Args:
-			experimental_options (Union[BrowserExperimentalOptions, dict[str, Any]]): A dictionary of experimental options to set.
-
-		Raises:
-			ValueError: If an unknown experimental option key is provided.
+			experimental_options (BrowserExperimentalOptions): A dictionary of experimental options to set.
 		"""
 		
 		self.clear_experimental_options()
 		self.update_experimental_options(experimental_options)
 	
-	def build_start_args_arguments(self) -> list[str]:
+	def _build_start_args_arguments(self) -> List[str]:
 		"""
-		Builds a list of command-line arguments intended for browser startup.
+		Builds a List of command-line arguments intended for browser startup.
 
 		Only arguments with `mode` set to 'startup_argument' or 'both' are included.
 
 		Returns:
-			list[str]: A list of formatted command-line argument strings.
+			List[str]: A List of formatted command-line argument strings.
 		"""
 		
 		return [
-			_argument_to_flag(value)
+			argument_to_flag(value)
 			for name, value in self._arguments.items()
-			if self._flags_definitions_by_types["argument"][name]["mode"] in ["startup_argument", "both"]
+			if self._flags_definitions_by_types["argument"][name].mode in ["startup_argument", "both"]
 		]
 	
-	def build_options_arguments(self, options: _any_webdriver_option_type) -> _any_webdriver_option_type:
+	def _build_options_arguments(self, options: ANY_WEBDRIVER_OPTION_TYPEHINT) -> ANY_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Adds configured command-line arguments to the WebDriver options object.
 
 		Only arguments with `mode` set to 'webdriver_option' or 'both' are added.
 
 		Args:
-			options (_any_webdriver_option_type): The WebDriver options object to modify.
+			options (any_webdriver_option_type): The WebDriver options object to modify.
 
 		Returns:
-			_any_webdriver_option_type: The modified WebDriver options object.
+			any_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
 		for name, value in self._arguments.items():
-			if self._flags_definitions_by_types["argument"][name]["mode"] in ["webdriver_option", "both"]:
-				options.add_argument(_argument_to_flag(value))
+			if self._flags_definitions_by_types["argument"][name].mode in ["webdriver_option", "both"]:
+				options.add_argument(argument_to_flag(value))
 		
 		return options
 	
@@ -470,55 +370,76 @@ class BrowserFlagsManager:
 			value (Any): The value for the argument. This may be a boolean for a simple flag or a string/number for a valued flag.
 		"""
 		
-		argument_name = argument["name"]
-		argument_command = argument["command"]
-		adding_validation_function = argument["adding_validation_function"]
+		argument_name = argument.name
+		argument_command = argument.command
+		adding_validation_function = argument.adding_validation_function
 		
 		self.remove_argument(argument_name)
 		
 		if adding_validation_function(value):
 			self._arguments[argument_name] = ArgumentValue(command_line=argument_command, value=value)
 	
-	def update_arguments(self, arguments: Union[BrowserArguments, dict[str, Any]]):
+	def update_arguments(self, arguments: BrowserArguments):
 		"""
 		Updates command-line arguments from a dictionary without clearing existing ones.
 
 		Args:
-			arguments (Union[BrowserArguments, dict[str, Any]]): A dictionary of arguments to set or update.
+			arguments (BrowserArguments): A dictionary of arguments to set or update.
 
 		Raises:
-			ValueError: If an unknown argument key is provided.
+			FlagNotDefinedError: If an unknown argument key is provided.
 		"""
 		
-		for key, value in arguments.items():
+		for key, value in arguments.model_dump(exclude_none=True).items():
 			flag_definition = self._flags_definitions_by_types["argument"].get(key, FlagNotDefined())
 		
 			if isinstance(flag_definition, FlagNotDefined):
-				raise ValueError(f"Unknown argument: {key}.")
+				raise FlagNotDefinedError(flag_name=key, flag_type="arguments")
 		
-			self.set_argument(flag_definition, value)
+			self.set_argument(flag_definition, getattr(arguments, key))
 	
-	def set_arguments(self, arguments: Union[BrowserArguments, dict[str, Any]]):
+	def set_arguments(self, arguments: BrowserArguments):
 		"""
 		Clears existing and sets new command-line arguments from a dictionary.
 
 		Args:
-			arguments (Union[BrowserArguments, dict[str, Any]]): A dictionary of arguments to set.
-
-		Raises:
-			ValueError: If an unknown argument key is provided.
+			arguments (BrowserArguments): A dictionary of arguments to set.
 		"""
 		
 		self.clear_arguments()
 		self.update_arguments(arguments)
 	
+	@property
+	def arguments(self) -> Dict[str, ArgumentValue]:
+		return deepcopy(self._arguments)
+	
+	@property
+	def attributes(self) -> Dict[str, AttributeValue]:
+		return deepcopy(self._attributes)
+	
 	def clear_flags(self):
 		"""Clears all configured flags of all types (arguments, options, attributes)."""
 		
 		for type_name, type_functions in self._flags_types.items():
-			type_functions["clear_flags_function"]()
+			type_functions.clear_flags_function()
+	
+	@property
+	def experimental_options(self) -> Dict[str, ExperimentalOptionValue]:
+		return deepcopy(self._experimental_options)
 	
-	def _renew_webdriver_options(self) -> _any_webdriver_option_type:
+	@property
+	def flags_definitions(self) -> Dict[str, FlagDefinition]:
+		return deepcopy(self._flags_definitions)
+	
+	@property
+	def flags_definitions_by_types(self) -> Dict[str, Dict[str, FlagDefinition]]:
+		return deepcopy(self._flags_definitions_by_types)
+	
+	@property
+	def flags_types(self) -> Dict[str, FlagType]:
+		return deepcopy(self._flags_types)
+	
+	def _renew_webdriver_options(self) -> ANY_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Abstract method to renew WebDriver options. Must be implemented in child classes.
 
@@ -526,27 +447,30 @@ class BrowserFlagsManager:
 		browser-specific WebDriver options instances (e.g., ChromeOptions, FirefoxOptions).
 
 		Returns:
-			_any_webdriver_option_type: A new instance of WebDriver options (e.g., ChromeOptions, FirefoxOptions).
+			any_webdriver_option_type: A new instance of WebDriver options (e.g., ChromeOptions, FirefoxOptions).
 
 		Raises:
-			NotImplementedError: If the method is not implemented in a subclass.
+			AbstractImplementationError: If the method is not implemented in a subclass.
 		"""
 		
-		raise NotImplementedError("This function must be implemented in child classes.")
+		raise AbstractImplementationError(
+				method_name="_renew_webdriver_options",
+				class_name=self.__class__.__name__
+		)
 	
 	@property
-	def options(self) -> _any_webdriver_option_type:
+	def options(self) -> ANY_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Builds and returns a WebDriver options object with all configured flags applied.
 
 		Returns:
-			_any_webdriver_option_type: A configured WebDriver options object.
+			any_webdriver_option_type: A configured WebDriver options object.
 		"""
 		
 		options = self._renew_webdriver_options()
 		
 		for type_name, type_functions in self._flags_types.items():
-			options = type_functions["build_options_function"](options)
+			options = type_functions.build_options_function(options)
 		
 		return options
 	
@@ -562,16 +486,16 @@ class BrowserFlagsManager:
 			option (WebdriverOption): The configuration object defining the option to be removed.
 
 		Raises:
-			ValueError: If the option type is not recognized.
+			FlagTypeNotDefinedError: If the option type is not recognized.
 		"""
 		
 		for type_name, type_functions in self._flags_types.items():
-			if option["type"] == type_name:
-				type_functions["remove_flag_function"](option["name"])
+			if option.type == type_name:
+				type_functions.remove_flag_function(option.name)
 		
-		raise ValueError(f"Unknown option type ({option}).")
+		raise FlagTypeNotDefinedError(flag_type=option.type)
 	
-	def set_flags(self, flags: Union[BrowserFlags, dict[str, dict[str, Any]]]):
+	def set_flags(self, flags: BrowserFlags):
 		"""
 		Clears all existing flags and sets new ones from a comprehensive dictionary.
 
@@ -580,20 +504,20 @@ class BrowserFlagsManager:
 		previously configured flags for that type.
 
 		Args:
-			flags (Union[BrowserFlags, dict[str, dict[str, Any]]]): A dictionary where keys are flag types
+			flags (BrowserFlags): A dictionary where keys are flag types
 				and values are dictionaries of flags to set for that type.
 
 		Raises:
-			ValueError: If an unknown flag type is provided in the `flags` dictionary.
+			FlagTypeNotDefinedError: If an unknown flag type is provided in the `flags` dictionary.
 		"""
 		
-		for type_name, type_flags in flags.items():
+		for type_name, type_flags in flags.model_dump(exclude_none=True).items():
 			flags_type_definition = self._flags_types.get(type_name, FlagTypeNotDefined())
 		
 			if isinstance(flags_type_definition, FlagTypeNotDefined):
-				raise ValueError(f"Unknown flag type: {type_name}.")
+				raise FlagTypeNotDefinedError(flag_type=type_name)
 		
-			flags_type_definition["set_flags_function"](type_flags)
+			flags_type_definition.set_flags_function(getattr(flags, type_name))
 	
 	def set_option(self, option: FlagDefinition, value: Any):
 		"""
@@ -608,18 +532,16 @@ class BrowserFlagsManager:
 			value (Any): The value to be set for the option. The type and acceptable values depend on the specific browser option being configured.
 
 		Raises:
-			ValueError: If the option type is not recognized.
+			FlagTypeNotDefinedError: If the option type is not recognized.
 		"""
 		
 		for type_name, type_functions in self._flags_types.items():
-			if option["type"] == type_name:
-				type_functions["set_flag_function"](option, value)
+			if option.type == type_name:
+				type_functions.set_flag_function(option, value)
 		
-		raise ValueError(
-				f"Unknown option type ({option}). Acceptable types are: {', '.join(self._flags_types.keys())}."
-		)
+		raise FlagTypeNotDefinedError(flag_type=option.type)
 	
-	def update_flags(self, flags: Union[BrowserFlags, dict[str, dict[str, Any]]]):
+	def update_flags(self, flags: BrowserFlags):
 		"""
 		Updates all flags from a comprehensive dictionary without clearing existing ones.
 
@@ -628,17 +550,17 @@ class BrowserFlagsManager:
 		flags without affecting other existing flags.
 
 		Args:
-			flags (Union[BrowserFlags, dict[str, dict[str, Any]]]): A dictionary where keys are flag types
+			flags (BrowserFlags): A dictionary where keys are flag types
 				and values are dictionaries of flags to update for that type.
 
 		Raises:
-			ValueError: If an unknown flag type is provided in the `flags` dictionary.
+			FlagTypeNotDefinedError: If an unknown flag type is provided in the `flags` dictionary.
 		"""
 		
-		for type_name, type_flags in flags.items():
+		for type_name, type_flags in flags.model_dump(exclude_none=True).items():
 			flags_type_definition = self._flags_types.get(type_name, FlagTypeNotDefined())
 		
 			if isinstance(flags_type_definition, FlagTypeNotDefined):
-				raise ValueError(f"Unknown flag type: {type_name}.")
+				raise FlagTypeNotDefinedError(flag_type=type_name)
 		
-			flags_type_definition["update_flags_function"](type_flags)
+			flags_type_definition.update_flags_function(getattr(flags, type_name))