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

osn_selenium/instances/sync/action_chains/base.py

@@ -0,0 +1,74 @@
+from typing import (
+	Any,
+	Callable,
+	TYPE_CHECKING,
+	cast
+)
+from osn_selenium.instances.unified.action_chains.base import UnifiedBaseMixin
+from osn_selenium.abstract.instances.action_chains.base import AbstractBaseMixin
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["BaseMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class BaseMixin(UnifiedBaseMixin, AbstractBaseMixin):
+	"""
+	Base mixin class that bridges legacy Selenium actions with unified execution logic.
+	"""
+	
+	def __init__(
+			self,
+			selenium_action_chains: legacyActionChains,
+			execute_js_script_function: Callable[[str, Any], Any]
+	):
+		"""
+		Initializes an ActionChains instance from a legacy Selenium ActionChains object.
+
+		Args:
+			selenium_action_chains (legacyActionChains): The legacy Selenium action chain.
+			execute_js_script_function (Callable[[str, Any], Any]): The function used to execute JS.
+
+		Returns:
+			"ActionChains": The ActionChains instance.
+		"""
+		
+		UnifiedBaseMixin.__init__(
+				self,
+				selenium_action_chains=selenium_action_chains,
+				execute_js_script_function=execute_js_script_function,
+		)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: legacyActionChains,
+			execute_js_script_function: Callable[[str, Any], Any],
+	) -> "ActionChains":
+		"""
+		Creates an ActionChains instance from a legacy Selenium ActionChains object.
+
+		Args:
+			legacy_object (legacyActionChains): The legacy Selenium action chain.
+			execute_js_script_function (Callable[[str, Any], Any]): The function used to execute JS.
+
+		Returns:
+			"ActionChains": The ActionChains instance.
+		"""
+		
+		return cast(
+				"ActionChains",
+				cls(
+						selenium_action_chains=legacy_object,
+						execute_js_script_function=execute_js_script_function,
+				)
+		)
+	
+	@property
+	def legacy(self) -> legacyActionChains:
+		return self._legacy_impl

osn_selenium/instances/sync/action_chains/click.py

@@ -0,0 +1,61 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.click import UnifiedClickMixin
+from osn_selenium.abstract.instances.action_chains.click import AbstractClickMixin
+
+
+__all__ = ["ClickMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class ClickMixin(BaseMixin, UnifiedClickMixin, AbstractClickMixin):
+	"""
+	Mixin class providing mouse click interaction methods.
+	"""
+	
+	def click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._click_impl(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def click_and_hold(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._click_and_hold_impl(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def context_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._context_click_impl(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def double_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._double_click_impl(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def release(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._release_impl(on_element=get_legacy_instance(instance=on_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/drag_and_drop.py

@@ -0,0 +1,45 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.drag_and_drop import (
+	UnifiedDragAndDropMixin
+)
+from osn_selenium.abstract.instances.action_chains.drag_and_drop import (
+	AbstractDragAndDropMixin
+)
+
+
+__all__ = ["DragAndDropMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class DragAndDropMixin(BaseMixin, UnifiedDragAndDropMixin, AbstractDragAndDropMixin):
+	"""
+	Mixin class providing drag and drop interaction methods.
+	"""
+	
+	def drag_and_drop(self, source: WEB_ELEMENT_TYPEHINT, target: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = self._drag_and_drop_impl(
+				source=get_legacy_instance(instance=source),
+				target=get_legacy_instance(instance=target)
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def drag_and_drop_by_offset(self, source: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = self._drag_and_drop_by_offset_impl(
+				source=get_legacy_instance(instance=source),
+				xoffset=xoffset,
+				yoffset=yoffset
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/hm_keyboard.py

@@ -0,0 +1,37 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.hm_keyboard import (
+	UnifiedHMKeyboardMixin
+)
+from osn_selenium.abstract.instances.action_chains.hm_keyboard import (
+	AbstractHMKeyboardMixin
+)
+
+
+__all__ = ["HMKeyboardMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class HMKeyboardMixin(BaseMixin, UnifiedHMKeyboardMixin, AbstractHMKeyboardMixin):
+	"""
+	Mixin class providing human-like keyboard interaction methods.
+	"""
+	
+	def hm_send_keys(self, text: str) -> "ActionChains":
+		action_chains = self._hm_send_keys_impl(text=text)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def hm_send_keys_to_element(self, element: WEB_ELEMENT_TYPEHINT, text: str) -> "ActionChains":
+		action_chains = self._hm_send_keys_to_element_impl(element=element, text=text)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/hm_move.py

@@ -0,0 +1,81 @@
+from osn_selenium.models import Point
+from typing import TYPE_CHECKING, Tuple
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.hm_move import UnifiedHMMoveMixin
+from osn_selenium.abstract.instances.action_chains.hm_move import AbstractHMMoveMixin
+
+
+__all__ = ["HMMoveMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class HMMoveMixin(BaseMixin, UnifiedHMMoveMixin, AbstractHMMoveMixin):
+	"""
+	Mixin class providing human-like mouse movement interaction methods.
+	"""
+	
+	def hm_move(self, start_position: Point, end_position: Point) -> "ActionChains":
+		action_chains = self._hm_move_impl(start_position=start_position, end_position=end_position)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def hm_move_by_offset(self, start_position: Point, xoffset: int, yoffset: int) -> Tuple["ActionChains", Point]:
+		action_chains, point = self._hm_move_by_offset_impl(start_position=start_position, xoffset=xoffset, yoffset=yoffset)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+				),
+				point,
+		)
+	
+	def hm_move_to_element(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["ActionChains", Point]:
+		action_chains, point = self._hm_move_to_element_impl(start_position=start_position, element=element)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+				),
+				point,
+		)
+	
+	def hm_move_to_element_with_offset(
+			self,
+			start_position: Point,
+			element: WEB_ELEMENT_TYPEHINT,
+			xoffset: int,
+			yoffset: int
+	) -> Tuple["ActionChains", Point]:
+		action_chains, point = self._hm_move_to_element_with_offset_impl(
+				start_position=start_position,
+				element=element,
+				xoffset=xoffset,
+				yoffset=yoffset
+		)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+				),
+				point,
+		)
+	
+	def hm_move_to_element_with_random_offset(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["ActionChains", Point]:
+		action_chains, point = self._hm_move_to_element_with_random_offset_impl(start_position=start_position, element=element)
+		
+		return (
+				self.from_legacy(
+						legacy_object=action_chains,
+						execute_js_script_function=self._execute_js_script_function,
+				),
+				point,
+		)

osn_selenium/instances/sync/action_chains/hm_scroll.py

@@ -0,0 +1,60 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
+from osn_selenium.instances.unified.action_chains.hm_scroll import UnifiedHMScrollMixin
+from osn_selenium.abstract.instances.action_chains.hm_scroll import (
+	AbstractHMScrollMixin
+)
+
+
+__all__ = ["HMScrollMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class HMScrollMixin(BaseMixin, UnifiedHMScrollMixin, AbstractHMScrollMixin):
+	"""
+	Mixin class providing human-like scroll interaction methods.
+	"""
+	
+	def hm_scroll_by_amount(self, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = self._hm_scroll_by_amount_impl(delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def hm_scroll_from_origin(self, delta_x: int, delta_y: int, origin: Optional[ScrollOrigin] = None) -> "ActionChains":
+		action_chains = self._hm_scroll_from_origin_impl(delta_x=delta_x, delta_y=delta_y, origin=origin)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def hm_scroll_to_element(
+			self,
+			element: WEB_ELEMENT_TYPEHINT,
+			additional_lower_y_offset: int = 0,
+			additional_upper_y_offset: int = 0,
+			additional_right_x_offset: int = 0,
+			additional_left_x_offset: int = 0,
+	) -> "ActionChains":
+		action_chains = self._hm_scroll_to_element_impl(
+				element=element,
+				additional_lower_y_offset=additional_lower_y_offset,
+				additional_upper_y_offset=additional_upper_y_offset,
+				additional_right_x_offset=additional_right_x_offset,
+				additional_left_x_offset=additional_left_x_offset,
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/keyboard.py

@@ -0,0 +1,55 @@
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.keyboard import UnifiedKeyboardMixin
+from osn_selenium.abstract.instances.action_chains.keyboard import (
+	AbstractKeyboardMixin
+)
+
+
+__all__ = ["KeyboardMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class KeyboardMixin(BaseMixin, UnifiedKeyboardMixin, AbstractKeyboardMixin):
+	"""
+	Mixin class providing keyboard interaction methods.
+	"""
+	
+	def key_down(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._key_down_impl(value=value, element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def key_up(self, value: str, element: Optional[WEB_ELEMENT_TYPEHINT]) -> "ActionChains":
+		action_chains = self._key_up_impl(value=value, element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def send_keys(self, *keys_to_send: str) -> "ActionChains":
+		action_chains = self._send_keys_impl(*keys_to_send)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def send_keys_to_element(self, element: WEB_ELEMENT_TYPEHINT, *keys_to_send: str) -> "ActionChains":
+		action_chains = self._send_keys_to_element_impl(get_legacy_instance(instance=element), *keys_to_send)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/move.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.move import UnifiedMoveMixin
+from osn_selenium.abstract.instances.action_chains.move import AbstractMoveMixin
+
+
+__all__ = ["MoveMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class MoveMixin(BaseMixin, UnifiedMoveMixin, AbstractMoveMixin):
+	"""
+	Mixin class providing mouse movement interaction methods.
+	"""
+	
+	def move_by_offset(self, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = self._move_by_offset_impl(xoffset=xoffset, yoffset=yoffset)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def move_to_element(self, to_element: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = self._move_to_element_impl(to_element=get_legacy_instance(instance=to_element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def move_to_element_with_offset(self, to_element: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> "ActionChains":
+		action_chains = self._move_to_element_with_offset_impl(
+				to_element=get_legacy_instance(instance=to_element),
+				xoffset=xoffset,
+				yoffset=yoffset
+		)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/scroll.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
+from osn_selenium.instances.unified.action_chains.scroll import UnifiedScrollMixin
+from osn_selenium.abstract.instances.action_chains.scroll import AbstractScrollMixin
+
+
+__all__ = ["ScrollMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class ScrollMixin(BaseMixin, UnifiedScrollMixin, AbstractScrollMixin):
+	"""
+	Mixin class providing scroll and wheel interaction methods.
+	"""
+	
+	def scroll_by_amount(self, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = self._scroll_by_amount_impl(delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def scroll_from_origin(self, scroll_origin: ScrollOrigin, delta_x: int, delta_y: int) -> "ActionChains":
+		action_chains = self._scroll_from_origin_impl(scroll_origin=scroll_origin, delta_x=delta_x, delta_y=delta_y)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def scroll_to_element(self, element: WEB_ELEMENT_TYPEHINT) -> "ActionChains":
+		action_chains = self._scroll_to_element_impl(element=get_legacy_instance(instance=element))
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)

osn_selenium/instances/sync/action_chains/utils.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Union
+from osn_selenium.instances.sync.action_chains.base import BaseMixin
+from osn_selenium.instances.unified.action_chains.utils import UnifiedUtilsMixin
+from osn_selenium.abstract.instances.action_chains.utils import AbstractUtilsMixin
+
+
+__all__ = ["UtilsMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.action_chains import ActionChains
+
+
+class UtilsMixin(BaseMixin, UnifiedUtilsMixin, AbstractUtilsMixin):
+	"""
+	Mixin class providing utility methods for action chains.
+	"""
+	
+	def pause(self, seconds: Union[float, int]) -> "ActionChains":
+		action_chains = self._pause_impl(seconds=seconds)
+		
+		return self.from_legacy(
+				legacy_object=action_chains,
+				execute_js_script_function=self._execute_js_script_function,
+		)
+	
+	def perform(self) -> None:
+		self._perform_impl()
+	
+	def reset_actions(self) -> None:
+		self._reset_actions_impl()

osn_selenium/instances/sync/alert.py

@@ -0,0 +1,69 @@
+from typing import Self
+from osn_selenium.instances._typehints import ALERT_TYPEHINT
+from osn_selenium.instances.unified.alert import UnifiedAlert
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.abstract.instances.alert import AbstractAlert
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+
+
+__all__ = ["Alert"]
+
+
+class Alert(UnifiedAlert, AbstractAlert):
+	"""
+	Wrapper for the legacy Selenium Alert instance.
+
+	Manages browser alerts, prompts, and confirmation dialogs, allowing
+	acceptance, dismissal, text retrieval, and input.
+	"""
+	
+	def __init__(self, selenium_alert: legacyAlert) -> None:
+		"""
+		Initializes the Alert wrapper.
+
+		Args:
+			selenium_alert (legacyAlert): The legacy Selenium Alert instance to wrap.
+		"""
+		
+		UnifiedAlert.__init__(self, selenium_alert=selenium_alert)
+	
+	def accept(self) -> None:
+		self._accept_impl()
+	
+	def dismiss(self) -> None:
+		self._dismiss_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: ALERT_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Alert object.
+
+		This factory method is used to wrap an existing Selenium Alert
+		instance into the new interface.
+
+		Args:
+			legacy_object (ALERT_TYPEHINT): The legacy Selenium Alert instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Alert.
+		"""
+		
+		legacy_alert_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_alert_obj, legacyAlert):
+			raise CannotConvertTypeError(from_=legacyAlert, to_=legacy_object)
+		
+		return cls(selenium_alert=legacy_alert_obj)
+	
+	@property
+	def legacy(self) -> legacyAlert:
+		return self._legacy_impl
+	
+	def send_keys(self, keysToSend: str) -> None:
+		self._send_keys_impl(keysToSend=keysToSend)
+	
+	def text(self) -> str:
+		return self._text_impl()

osn_selenium/instances/sync/browser.py

@@ -0,0 +1,72 @@
+from typing import List, Self
+from osn_selenium.instances._typehints import BROWSER_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.browser import UnifiedBrowser
+from osn_selenium.abstract.instances.browser import AbstractBrowser
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.browser import (
+	Browser as legacyBrowser,
+	ClientWindowInfo
+)
+
+
+__all__ = ["Browser"]
+
+
+class Browser(UnifiedBrowser, AbstractBrowser):
+	"""
+	Wrapper for the legacy Selenium BiDi Browser instance.
+
+	Provides methods to manage user contexts (profiles) and inspect client
+	window information via the WebDriver BiDi protocol.
+	"""
+	
+	def __init__(self, selenium_browser: legacyBrowser) -> None:
+		"""
+		Initializes the Browser wrapper.
+
+		Args:
+			selenium_browser (legacyBrowser): The legacy Selenium Browser instance to wrap.
+		"""
+		
+		UnifiedBrowser.__init__(self, selenium_browser=selenium_browser)
+	
+	def create_user_context(self) -> str:
+		return self._create_user_context_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: BROWSER_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Browser object.
+
+		This factory method is used to wrap an existing Selenium Browser
+		instance into the new interface.
+
+		Args:
+			legacy_object (BROWSER_TYPEHINT): The legacy Selenium Browser instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Browser.
+		"""
+		
+		legacy_browser_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_browser_obj, legacyBrowser):
+			raise CannotConvertTypeError(from_=legacyBrowser, to_=legacy_object)
+		
+		return cls(selenium_browser=legacy_browser_obj)
+	
+	def get_client_windows(self) -> List[ClientWindowInfo]:
+		return self._get_client_windows_impl()
+	
+	def get_user_contexts(self) -> List[str]:
+		return self._get_user_contexts_impl()
+	
+	@property
+	def legacy(self) -> legacyBrowser:
+		return self._legacy_impl
+	
+	def remove_user_context(self, user_context_id: str) -> None:
+		self._remove_user_context_impl(user_context_id=user_context_id)