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

osn_selenium/webdrivers/unified/core/navigation.py

@@ -0,0 +1,31 @@
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreNavigationMixin"]
+
+
+class UnifiedCoreNavigationMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _back_impl(self) -> None:
+		self._driver_impl.back()
+	
+	@requires_driver
+	def _current_url_impl(self) -> str:
+		return self._driver_impl.current_url
+	
+	@requires_driver
+	def _forward_impl(self) -> None:
+		self._driver_impl.forward()
+	
+	@requires_driver
+	def _get_impl(self, url: str) -> None:
+		self._driver_impl.get(url=url)
+	
+	@requires_driver
+	def _refresh_impl(self) -> None:
+		self._driver_impl.refresh()
+	
+	@requires_driver
+	def _title_impl(self) -> str:
+		return self._driver_impl.title

osn_selenium/webdrivers/unified/core/script.py

@@ -0,0 +1,32 @@
+from typing import Any, List, Optional
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreScriptMixin"]
+
+
+class UnifiedCoreScriptMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _execute_async_script_impl(self, script: str, *args: Any) -> Any:
+		return self._driver_impl.execute_async_script(script, *args)
+	
+	@requires_driver
+	def _execute_script_impl(self, script: str, *args: Any) -> Any:
+		return self._driver_impl.execute_script(script, *args)
+	
+	@requires_driver
+	def _get_pinned_scripts_impl(self) -> List[str]:
+		return self._driver_impl.get_pinned_scripts()
+	
+	@requires_driver
+	def _pin_script_impl(self, script: str, script_key: Optional[Any] = None) -> Any:
+		return self._driver_impl.pin_script(script=script, script_key=script_key)
+	
+	@requires_driver
+	def _script_impl(self) -> Any:
+		return self._driver_impl.script
+	
+	@requires_driver
+	def _unpin_impl(self, script_key: Any) -> None:
+		self._driver_impl.unpin(script_key=script_key)

osn_selenium/webdrivers/unified/core/settings.py

@@ -0,0 +1,44 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium.exceptions.webdriver import (
+	WebDriverAlreadyRunningError
+)
+
+
+__all__ = ["UnifiedCoreSettingsMixin"]
+
+
+class UnifiedCoreSettingsMixin(UnifiedCoreBaseMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active_impl:
+			if window_rect is None:
+				window_rect = WindowRect()
+		
+			if flags is not None:
+				self._webdriver_flags_manager.set_flags(flags=flags)
+			else:
+				self._webdriver_flags_manager.clear_flags()
+		
+			self._window_rect = window_rect
+		else:
+			raise WebDriverAlreadyRunningError()
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active_impl:
+			if flags is not None:
+				self._webdriver_flags_manager.update_flags(flags=flags)
+		
+			if window_rect is not None:
+				self._window_rect = window_rect
+		else:
+			raise WebDriverAlreadyRunningError()

osn_selenium/webdrivers/unified/core/storage.py

@@ -0,0 +1,37 @@
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreStorageMixin"]
+
+
+class UnifiedCoreStorageMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _add_cookie_impl(self, cookie_dict: Dict[str, Any]) -> None:
+		self._driver_impl.add_cookie(cookie_dict=cookie_dict)
+	
+	@requires_driver
+	def _delete_all_cookies_impl(self) -> None:
+		self._driver_impl.delete_all_cookies()
+	
+	@requires_driver
+	def _delete_cookie_impl(self, name: str) -> None:
+		self._driver_impl.delete_cookie(name=name)
+	
+	@requires_driver
+	def _get_cookie_impl(self, name: str) -> Optional[Dict[str, Any]]:
+		return self._driver_impl.get_cookie(name=name)
+	
+	@requires_driver
+	def _get_cookies_impl(self) -> List[Dict[str, Any]]:
+		return self._driver_impl.get_cookies()
+	
+	@requires_driver
+	def _storage_impl(self) -> Any:
+		return self._driver_impl.storage

osn_selenium/webdrivers/unified/core/timeouts.py

@@ -0,0 +1,56 @@
+from typing import Optional
+from selenium.webdriver.common.timeouts import Timeouts
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreTimeoutsMixin"]
+
+
+class UnifiedCoreTimeoutsMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _get_timeouts_impl(self) -> Timeouts:
+		return self._driver_impl.timeouts
+	
+	@requires_driver
+	def _implicitly_wait_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.implicitly_wait(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_page_load_timeout_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.set_page_load_timeout(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_script_timeout_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.set_script_timeout(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_timeouts_impl(self, timeouts: Timeouts) -> None:
+		self._driver_impl.timeouts = timeouts
+	
+	@requires_driver
+	def _set_driver_timeouts_impl(
+			self,
+			page_load_timeout: float,
+			implicit_wait_timeout: float,
+			script_timeout: float,
+	) -> None:
+		self._driver_impl.set_page_load_timeout(page_load_timeout)
+		self._driver_impl.implicitly_wait(implicit_wait_timeout)
+		self._driver_impl.set_script_timeout(script_timeout)
+	
+	def _update_times_impl(
+			self,
+			temp_implicitly_wait: Optional[float] = None,
+			temp_page_load_timeout: Optional[float] = None,
+			temp_script_timeout: Optional[float] = None,
+	) -> None:
+		implicitly_wait = temp_implicitly_wait if temp_implicitly_wait is not None else self._base_implicitly_wait
+		page_load_timeout = temp_page_load_timeout if temp_page_load_timeout is not None else self._base_page_load_timeout
+		script_timeout = temp_script_timeout if temp_script_timeout is not None else self._base_script_timeout
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=page_load_timeout,
+				implicit_wait_timeout=implicitly_wait,
+				script_timeout=script_timeout,
+		)

osn_selenium/webdrivers/unified/core/window.py

@@ -0,0 +1,135 @@
+from typing import (
+	Any,
+	List,
+	Literal,
+	Optional,
+	Union
+)
+from osn_selenium.webdrivers._decorators import requires_driver
+from selenium.common.exceptions import (
+	InvalidSessionIdException
+)
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium.exceptions.window import (
+	InvalidWindowHandleError,
+	InvalidWindowIndexError,
+	NoWindowHandlesFoundError
+)
+
+
+__all__ = ["UnifiedCoreWindowMixin"]
+
+
+class UnifiedCoreWindowMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _window_handles_impl(self) -> List[str]:
+		return self._driver_impl.window_handles
+	
+	@requires_driver
+	def _close_impl(self) -> None:
+		self._driver_impl.close()
+	
+	@requires_driver
+	def _switch_to_impl(self) -> Any:
+		return self._driver_impl.switch_to
+	
+	@requires_driver
+	def _current_window_handle_impl(self) -> str:
+		return self._driver_impl.current_window_handle
+	
+	def _get_window_handle_impl(self, window: Optional[Union[str, int]] = None) -> str:
+		handles = self._window_handles_impl()
+		
+		if not handles:
+			raise NoWindowHandlesFoundError()
+		
+		if isinstance(window, str):
+			if window not in handles:
+				raise InvalidWindowHandleError(handle=window)
+		
+			return window
+		
+		if isinstance(window, int):
+			idx = window if window >= 0 else len(handles) + window
+			if idx < 0 or idx >= len(handles):
+				raise InvalidWindowIndexError(index=window, handles_length=len(handles))
+			
+			return handles[idx]
+		
+		return self._current_window_handle_impl()
+	
+	def _close_window_impl(self, window: Optional[Union[str, int]] = None) -> None:
+		current = self._current_window_handle_impl()
+		target = self._get_window_handle_impl(window)
+		legacy_switch_to = self._switch_to_impl()
+		
+		if target == current:
+			self._close_impl()
+		
+			try:
+				remaining = self._window_handles_impl()
+		
+				if remaining:
+					legacy_switch_to.window(remaining[-1])
+			except InvalidSessionIdException:
+				pass
+		else:
+			legacy_switch_to.window(target)
+		
+			self._close_impl()
+		
+			legacy_switch_to.window(current)
+	
+	def _close_all_windows_impl(self) -> None:
+		for window_handle in reversed(self._window_handles_impl()):
+			self._close_window_impl(window_handle)
+	
+	@requires_driver
+	def _fullscreen_window_impl(self) -> None:
+		self._driver_impl.fullscreen_window()
+	
+	@requires_driver
+	def _get_window_position_impl(self, windowHandle: str = "current") -> Any:
+		return self._driver_impl.get_window_position(windowHandle=windowHandle)
+	
+	@requires_driver
+	def _get_window_rect_impl(self) -> Any:
+		return self._driver_impl.get_window_rect()
+	
+	@requires_driver
+	def _get_window_size_impl(self, windowHandle: str = "current") -> Any:
+		return self._driver_impl.get_window_size(windowHandle=windowHandle)
+	
+	@requires_driver
+	def _maximize_window_impl(self) -> None:
+		self._driver_impl.maximize_window()
+	
+	@requires_driver
+	def _minimize_window_impl(self) -> None:
+		self._driver_impl.minimize_window()
+	
+	@requires_driver
+	def _orientation_get_impl(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
+		return self._driver_impl.orientation["orientation"]
+	
+	@requires_driver
+	def _orientation_set_impl(self, value: Literal["LANDSCAPE", "PORTRAIT"]) -> None:
+		setattr(self._driver_impl, "orientation", value)
+	
+	@requires_driver
+	def _set_window_position_impl(self, x: int, y: int, windowHandle: str = "current") -> Any:
+		return self._driver_impl.set_window_position(x=x, y=y, windowHandle=windowHandle)
+	
+	@requires_driver
+	def _set_window_rect_impl(
+			self,
+			x: Optional[int] = None,
+			y: Optional[int] = None,
+			width: Optional[int] = None,
+			height: Optional[int] = None,
+	) -> Any:
+		return self._driver_impl.set_window_rect(x=x, y=y, width=width, height=height)
+	
+	@requires_driver
+	def _set_window_size_impl(self, width: int, height: int, windowHandle: str = "current") -> None:
+		self._driver_impl.set_window_size(width=width, height=height, windowHandle=windowHandle)

osn_selenium/webdrivers/unified/edge/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/edge/base.py

@@ -0,0 +1,52 @@
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from selenium.webdriver import Edge as legacyEdge
+from osn_selenium.flags.models.edge import EdgeFlags
+from osn_selenium.flags.edge import EdgeFlagsManager
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedEdgeBaseMixin"]
+
+
+class UnifiedEdgeBaseMixin(UnifiedBlinkBaseMixin):
+	def __init__(
+			self,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			flags_manager_type: Type[EdgeFlagsManager] = EdgeFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Microsoft Edge",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[EdgeFlags] = None,
+			start_page_url: str = "about:blank",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	):
+		UnifiedBlinkBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				use_browser_exe=use_browser_exe,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				start_page_url=start_page_url,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+		)
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyEdge]:
+		return super()._driver_impl

osn_selenium/webdrivers/unified/edge/lifecycle.py

@@ -0,0 +1,88 @@
+from typing import Optional
+from selenium import webdriver
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from selenium.webdriver.edge.service import Service
+from osn_selenium.flags.models.edge import EdgeFlags
+from osn_selenium.webdrivers.unified.core.window import (
+	UnifiedCoreWindowMixin
+)
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+from osn_selenium.webdrivers.unified.blink.lifecycle import (
+	UnifiedBlinkLifecycleMixin
+)
+
+
+__all__ = ["UnifiedEdgeLifecycleMixin"]
+
+
+class UnifiedEdgeLifecycleMixin(
+		UnifiedBlinkLifecycleMixin,
+		UnifiedCoreTimeoutsMixin,
+		UnifiedCoreWindowMixin
+):
+	def _create_driver_impl(self) -> None:
+		webdriver_options = self._webdriver_flags_manager.options
+		webdriver_service = Service(
+				executable_path=self._webdriver_path,
+				port=self._debugging_port_impl
+				if self._browser_exe_impl is None
+				else 0,
+				service_args=self._webdriver_flags_manager.start_args
+				if self._browser_exe_impl is None
+				else None
+		)
+		
+		self._driver = webdriver.Edge(options=webdriver_options, service=webdriver_service)
+		
+		if self._window_rect is not None:
+			self._set_window_rect_impl(
+					x=self._window_rect.x,
+					y=self._window_rect.y,
+					width=self._window_rect.width,
+					height=self._window_rect.height,
+			)
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=self._base_page_load_timeout,
+				implicit_wait_timeout=self._base_implicitly_wait,
+				script_timeout=self._base_implicitly_wait,
+		)
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[EdgeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._restart_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[EdgeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._start_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/edge/settings.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.edge import EdgeFlags
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+
+
+__all__ = ["UnifiedEdgeSettingsMixin"]
+
+
+class UnifiedEdgeSettingsMixin(UnifiedBlinkSettingsMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[EdgeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: str = "",
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._reset_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[EdgeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._update_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/yandex/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/yandex/base.py

@@ -0,0 +1,54 @@
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.flags.yandex import YandexFlagsManager
+from selenium.webdriver import (
+	Chrome as legacyYandex
+)
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.chrome.base import (
+	UnifiedChromeBaseMixin
+)
+
+
+__all__ = ["UnifiedYandexBaseMixin"]
+
+
+class UnifiedYandexBaseMixin(UnifiedChromeBaseMixin):
+	def __init__(
+			self,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			flags_manager_type: Type[YandexFlagsManager] = YandexFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Yandex",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[YandexFlags] = None,
+			start_page_url: str = "about:blank",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	):
+		UnifiedChromeBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				use_browser_exe=use_browser_exe,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				start_page_url=start_page_url,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+		)
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyYandex]:
+		return super()._driver_impl

osn_selenium/webdrivers/unified/yandex/lifecycle.py

@@ -0,0 +1,58 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.webdrivers.unified.core.window import (
+	UnifiedCoreWindowMixin
+)
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+from osn_selenium.webdrivers.unified.chrome.lifecycle import (
+	UnifiedChromeLifecycleMixin
+)
+
+
+__all__ = ["UnifiedYandexLifecycleMixin"]
+
+
+class UnifiedYandexLifecycleMixin(
+		UnifiedChromeLifecycleMixin,
+		UnifiedCoreTimeoutsMixin,
+		UnifiedCoreWindowMixin
+):
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[YandexFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._restart_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[YandexFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._start_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/yandex/settings.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.webdrivers.unified.chrome.settings import (
+	UnifiedChromeSettingsMixin
+)
+
+
+__all__ = ["UnifiedYandexSettingsMixin"]
+
+
+class UnifiedYandexSettingsMixin(UnifiedChromeSettingsMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[YandexFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: str = "",
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._reset_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[YandexFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._update_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)