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

osn_selenium/instances/sync/shadow_root.py

@@ -0,0 +1,91 @@
+from selenium.webdriver.common.by import By
+from typing import (
+	List,
+	Optional,
+	Self,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import SHADOW_ROOT_TYPEHINT
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.shadow_root import UnifiedShadowRoot
+from osn_selenium.abstract.instances.shadow_root import AbstractShadowRoot
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_sync_instance_wrapper
+)
+
+
+__all__ = ["ShadowRoot"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.sync.web_element import WebElement
+
+
+class ShadowRoot(UnifiedShadowRoot, AbstractShadowRoot):
+	"""
+	Wrapper for the legacy Selenium ShadowRoot instance.
+
+	Represents the root of a Shadow DOM tree, allowing element search
+	within the encapsulated shadow scope.
+	"""
+	
+	def __init__(self, selenium_shadow_root: legacyShadowRoot) -> None:
+		"""
+		Initializes the ShadowRoot wrapper.
+
+		Args:
+			selenium_shadow_root (legacyShadowRoot): The legacy Selenium ShadowRoot instance to wrap.
+		"""
+		
+		UnifiedShadowRoot.__init__(self, selenium_shadow_root=selenium_shadow_root)
+	
+	def find_element(self, by: str = By.ID, value: Optional[str] = None) -> "WebElement":
+		legacy_element = self._find_element_impl(by=by, value=value)
+		
+		from osn_selenium.instances.sync.web_element import WebElement
+		
+		return get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy_element)
+	
+	def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List["WebElement"]:
+		legacy_elements = self._find_elements_impl(by=by, value=value)
+		
+		from osn_selenium.instances.sync.web_element import WebElement
+		
+		return [
+			get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy_element)
+			for legacy_element in legacy_elements
+		]
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: SHADOW_ROOT_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium ShadowRoot object.
+
+		This factory method is used to wrap an existing Selenium ShadowRoot
+		instance into the new interface.
+
+		Args:
+			legacy_object (SHADOW_ROOT_TYPEHINT): The legacy Selenium ShadowRoot instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing ShadowRoot.
+		"""
+		
+		legacy_shadow_root_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_shadow_root_obj, legacyShadowRoot):
+			raise CannotConvertTypeError(from_=legacyShadowRoot, to_=legacy_object)
+		
+		return cls(selenium_shadow_root=legacy_shadow_root_obj)
+	
+	def id(self) -> str:
+		return self._id_impl()
+	
+	@property
+	def legacy(self) -> legacyShadowRoot:
+		return self._legacy_impl

osn_selenium/instances/sync/storage.py

@@ -0,0 +1,91 @@
+from typing import (
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances._typehints import STORAGE_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.storage import UnifiedStorage
+from osn_selenium.abstract.instances.storage import AbstractStorage
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.storage import (
+	BrowsingContextPartitionDescriptor,
+	CookieFilter,
+	DeleteCookiesResult,
+	GetCookiesResult,
+	PartialCookie,
+	SetCookieResult,
+	Storage as legacyStorage,
+	StorageKeyPartitionDescriptor
+)
+
+
+__all__ = ["Storage"]
+
+
+class Storage(UnifiedStorage, AbstractStorage):
+	"""
+	Wrapper for the legacy Selenium BiDi Storage instance.
+
+	Manages browser storage mechanisms, primarily focusing on getting, setting,
+	and deleting cookies with specific filters and partition descriptors.
+	"""
+	
+	def __init__(self, selenium_storage: legacyStorage) -> None:
+		"""
+		Initializes the Storage wrapper.
+
+		Args:
+			selenium_storage (legacyStorage): The legacy Selenium Storage instance to wrap.
+		"""
+		
+		UnifiedStorage.__init__(self, selenium_storage=selenium_storage)
+	
+	def delete_cookies(
+			self,
+			filter: Optional[CookieFilter] = None,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> DeleteCookiesResult:
+		return self._delete_cookies_impl(filter=filter, partition=partition)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: STORAGE_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Storage object.
+
+		This factory method is used to wrap an existing Selenium Storage
+		instance into the new interface.
+
+		Args:
+			legacy_object (STORAGE_TYPEHINT): The legacy Selenium Storage instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Storage.
+		"""
+		
+		legacy_storage_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_storage_obj, legacyStorage):
+			raise CannotConvertTypeError(from_=legacyStorage, to_=legacy_object)
+		
+		return cls(selenium_storage=legacy_storage_obj)
+	
+	def get_cookies(
+			self,
+			filter: Optional[CookieFilter] = None,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> GetCookiesResult:
+		return self._get_cookies_impl(filter=filter, partition=partition)
+	
+	@property
+	def legacy(self) -> legacyStorage:
+		return self._legacy_impl
+	
+	def set_cookie(
+			self,
+			cookie: PartialCookie,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> SetCookieResult:
+		return self._set_cookie_impl(cookie=cookie, partition=partition)

osn_selenium/instances/sync/switch_to.py

@@ -0,0 +1,92 @@
+from typing import (
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.sync.alert import Alert
+from osn_selenium.instances.sync.web_element import WebElement
+from osn_selenium.instances.unified.switch_to import UnifiedSwitchTo
+from osn_selenium.abstract.instances.switch_to import AbstractSwitchTo
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from osn_selenium.instances._typehints import (
+	SWITCH_TO_TYPEHINT,
+	WEB_ELEMENT_TYPEHINT
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_sync_instance_wrapper
+)
+
+
+__all__ = ["SwitchTo"]
+
+
+class SwitchTo(UnifiedSwitchTo, AbstractSwitchTo):
+	"""
+	Wrapper for the legacy Selenium SwitchTo instance.
+
+	Provides mechanisms to change the driver's focus to different frames,
+	windows, or alerts.
+	"""
+	
+	def __init__(self, selenium_switch_to: legacySwitchTo) -> None:
+		"""
+		Initializes the SwitchTo wrapper.
+
+		Args:
+			selenium_switch_to (legacySwitchTo): The legacy Selenium SwitchTo instance to wrap.
+		"""
+		
+		UnifiedSwitchTo.__init__(self, selenium_switch_to=selenium_switch_to)
+	
+	def active_element(self) -> WebElement:
+		return get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=self._active_element_impl())
+	
+	def alert(self) -> Alert:
+		return get_sync_instance_wrapper(wrapper_class=Alert, legacy_object=self._alert_impl())
+	
+	def default_content(self) -> None:
+		self._default_content_impl()
+	
+	def frame(self, frame_reference: Union[str, int, WEB_ELEMENT_TYPEHINT]) -> None:
+		self._frame_impl(frame_reference=frame_reference)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: SWITCH_TO_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium SwitchTo object.
+
+		This factory method is used to wrap an existing Selenium SwitchTo
+		instance into the new interface.
+
+		Args:
+			legacy_object (SWITCH_TO_TYPEHINT): The legacy Selenium SwitchTo instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing SwitchTo.
+		"""
+		
+		legacy_switch_to_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_switch_to_obj, legacySwitchTo):
+			raise CannotConvertTypeError(from_=legacySwitchTo, to_=legacy_object)
+		
+		return cls(selenium_switch_to=legacy_switch_to_obj)
+	
+	@property
+	def legacy(self) -> legacySwitchTo:
+		return self._legacy_impl
+	
+	def new_window(self, type_hint: Optional[str] = None) -> None:
+		self._new_window_impl(type_hint=type_hint)
+	
+	def parent_frame(self) -> None:
+		self._parent_frame_impl()
+	
+	def window(self, window_name: str) -> None:
+		self._window_impl(window_name=window_name)

osn_selenium/instances/sync/web_driver_wait.py

@@ -0,0 +1,83 @@
+from typing import (
+	Callable,
+	Self,
+	TypeVar
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	WebDriverWaitInputType
+)
+from osn_selenium.instances.unified.web_driver_wait import UnifiedWebDriverWait
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+from osn_selenium.abstract.instances.web_driver_wait import (
+	AbstractWebDriverWait
+)
+
+
+__all__ = ["OUTPUT", "WebDriverWait"]
+
+OUTPUT = TypeVar("OUTPUT")
+
+
+class WebDriverWait(UnifiedWebDriverWait, AbstractWebDriverWait):
+	"""
+	Wrapper for the legacy Selenium WebDriverWait instance.
+
+	Provides conditional waiting functionality, pausing execution until
+	specific conditions (expected conditions) are met or a timeout occurs.
+	"""
+	
+	def __init__(self, selenium_webdriver_wait: legacyWebDriverWait) -> None:
+		"""
+		Initializes the WebDriverWait wrapper.
+
+		Args:
+			selenium_webdriver_wait (legacyWebDriverWait): The legacy Selenium WebDriverWait instance to wrap.
+		"""
+		
+		UnifiedWebDriverWait.__init__(self, selenium_webdriver_wait=selenium_webdriver_wait)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: legacyWebDriverWait) -> Self:
+		"""
+		Creates a WebDriverWait wrapper instance from a legacy Selenium object.
+
+		Args:
+			legacy_object (legacyWebDriverWait): The legacy object to convert.
+
+		Returns:
+			Self: An instance of the WebDriverWait wrapper.
+
+		Raises:
+			CannotConvertTypeError: If the provided object cannot be converted to legacyWebDriverWait.
+		"""
+		
+		legacy_wait_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_wait_obj, legacyWebDriverWait):
+			raise CannotConvertTypeError(from_=legacyWebDriverWait, to_=legacy_object)
+		
+		return cls(selenium_webdriver_wait=legacy_wait_obj)
+	
+	@property
+	def legacy(self) -> legacyWebDriverWait:
+		return self._legacy_impl
+	
+	def until(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return self._until_impl(method=method, message=message)
+	
+	def until_not(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return self._until_not_impl(method=method, message=message)

osn_selenium/instances/sync/web_element.py

@@ -0,0 +1,179 @@
+from selenium.webdriver.common.by import By
+from osn_selenium.instances.sync.shadow_root import ShadowRoot
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.sync.web_driver_wait import WebDriverWait
+from typing import (
+	Any,
+	Dict,
+	Iterable,
+	List,
+	Optional,
+	Self
+)
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.web_element import UnifiedWebElement
+from osn_selenium.abstract.instances.web_element import AbstractWebElement
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_sync_instance_wrapper
+)
+
+
+__all__ = ["WebElement"]
+
+
+class WebElement(UnifiedWebElement, AbstractWebElement):
+	"""
+	Represents an HTML element in the DOM, offering methods for interaction (click, type),
+	property retrieval, and finding child elements.
+	"""
+	
+	def __init__(self, selenium_web_element: legacyWebElement) -> None:
+		"""
+		Initializes the WebElement wrapper.
+
+		Args:
+			selenium_web_element (legacyWebElement): The legacy Selenium WebElement instance to wrap.
+		"""
+		
+		UnifiedWebElement.__init__(self, selenium_web_element=selenium_web_element)
+	
+	def accessible_name(self) -> str:
+		return self._accessible_name_impl()
+	
+	def aria_role(self) -> str:
+		return self._aria_role_impl()
+	
+	def clear(self) -> None:
+		self._clear_impl()
+	
+	def click(self) -> None:
+		self._click_impl()
+	
+	def find_element(self, by: str = By.ID, value: Any = None) -> Self:
+		web_element = self._find_element_impl(by=by, value=value)
+		
+		return get_sync_instance_wrapper(wrapper_class=self.__class__, legacy_object=web_element)
+	
+	def find_elements(self, by: str = By.ID, value: Any = None) -> List[Self]:
+		web_elements = self._find_elements_impl(by=by, value=value)
+		
+		return [
+			get_sync_instance_wrapper(wrapper_class=self.__class__, legacy_object=web_element)
+			for web_element in web_elements
+		]
+	
+	def get_attribute(self, name: str) -> Optional[str]:
+		return self._get_attribute_impl(name=name)
+	
+	def get_dom_attribute(self, name: str) -> Optional[str]:
+		return self._get_dom_attribute_impl(name=name)
+	
+	def get_property(self, name: str) -> Any:
+		return self._get_property_impl(name=name)
+	
+	def id(self) -> str:
+		return self._id_impl()
+	
+	def is_displayed(self) -> bool:
+		return self._is_displayed_impl()
+	
+	def is_enabled(self) -> bool:
+		return self._is_enabled_impl()
+	
+	def is_selected(self) -> bool:
+		return self._is_selected_impl()
+	
+	@property
+	def legacy(self) -> legacyWebElement:
+		return self._legacy_impl
+	
+	def location(self) -> Dict:
+		return self._location_impl()
+	
+	def location_once_scrolled_into_view(self) -> Dict:
+		return self._location_once_scrolled_into_view_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: WEB_ELEMENT_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium WebElement object.
+
+		This factory method is used to wrap an existing Selenium WebElement
+		instance into the new interface.
+
+		Args:
+			legacy_object (WEB_ELEMENT_TYPEHINT): The legacy Selenium WebElement instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing WebElement.
+		"""
+		
+		legacy_element_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_element_obj, legacyWebElement):
+			raise CannotConvertTypeError(from_=legacyWebElement, to_=legacy_object)
+		
+		return cls(selenium_web_element=legacy_element_obj)
+	
+	def parent(self) -> Self:
+		web_element = self._parent_impl()
+		
+		return self.from_legacy(legacy_object=web_element)
+	
+	def rect(self) -> Dict:
+		return self._rect_impl()
+	
+	def screenshot(self, filename: str) -> bool:
+		return self._screenshot_impl(filename=filename)
+	
+	def screenshot_as_base64(self) -> str:
+		return self._screenshot_as_base64_impl()
+	
+	def screenshot_as_png(self) -> bytes:
+		return self._screenshot_as_png_impl()
+	
+	def send_keys(self, *value: str) -> None:
+		self._send_keys_impl(*value)
+	
+	def session_id(self) -> str:
+		return self._session_id_impl()
+	
+	def shadow_root(self) -> ShadowRoot:
+		shadow_root = self._shadow_root_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=ShadowRoot, legacy_object=shadow_root)
+	
+	def size(self) -> Dict:
+		return self._size_impl()
+	
+	def submit(self) -> None:
+		self._submit_impl()
+	
+	def tag_name(self) -> str:
+		return self._tag_name_impl()
+	
+	def text(self) -> str:
+		return self._text_impl()
+	
+	def value_of_css_property(self, property_name: str) -> str:
+		return self._value_of_css_property_impl(property_name=property_name)
+	
+	def web_driver_wait(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> WebDriverWait:
+		web_driver_wait = self._web_driver_wait_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+		
+		return get_sync_instance_wrapper(wrapper_class=WebDriverWait, legacy_object=web_driver_wait)

osn_selenium/instances/sync/web_extension.py

@@ -0,0 +1,77 @@
+from typing import (
+	Dict,
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	WEB_EXTENSION_TYPEHINT
+)
+from osn_selenium.instances.unified.web_extension import UnifiedWebExtension
+from osn_selenium.abstract.instances.web_extension import AbstractWebExtension
+from selenium.webdriver.common.bidi.webextension import (
+	WebExtension as legacyWebExtension
+)
+
+
+__all__ = ["WebExtension"]
+
+
+class WebExtension(UnifiedWebExtension, AbstractWebExtension):
+	"""
+	Wrapper for the legacy Selenium WebExtension instance.
+
+	Manages the installation and uninstallation of browser extensions via the
+	WebDriver BiDi protocol.
+	"""
+	
+	def __init__(self, selenium_web_extension: legacyWebExtension) -> None:
+		"""
+		Initializes the WebExtension wrapper.
+
+		Args:
+			selenium_web_extension (legacyWebExtension): The legacy Selenium WebExtension instance to wrap.
+		"""
+		
+		UnifiedWebExtension.__init__(self, selenium_web_extension=selenium_web_extension)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: WEB_EXTENSION_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium WebExtension object.
+
+		This factory method is used to wrap an existing Selenium WebExtension
+		instance into the new interface.
+
+		Args:
+			legacy_object (WEB_EXTENSION_TYPEHINT): The legacy Selenium WebExtension instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing WebExtension.
+		"""
+		
+		legacy_web_extension_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_web_extension_obj, legacyWebExtension):
+			raise CannotConvertTypeError(from_=legacyWebExtension, to_=legacy_object)
+		
+		return cls(selenium_web_extension=legacy_web_extension_obj)
+	
+	def install(
+			self,
+			path: Optional[str] = None,
+			archive_path: Optional[str] = None,
+			base64_value: Optional[str] = None,
+	) -> Dict:
+		return self._install_impl(path=path, archive_path=archive_path, base64_value=base64_value)
+	
+	@property
+	def legacy(self) -> legacyWebExtension:
+		return self._legacy_impl
+	
+	def uninstall(self, extension_id_or_result: Union[str, Dict]) -> None:
+		self._uninstall_impl(extension_id_or_result=extension_id_or_result)

osn_selenium/instances/trio_threads/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/trio_threads/action_chains/__init__.py

@@ -0,0 +1,26 @@
+from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+from osn_selenium.instances.trio_threads.action_chains.click import ClickMixin
+from osn_selenium.instances.trio_threads.action_chains.utils import UtilsMixin
+from osn_selenium.instances.trio_threads.action_chains.hm_move import HMMoveMixin
+from osn_selenium.instances.trio_threads.action_chains.hm_scroll import HMScrollMixin
+from osn_selenium.instances.trio_threads.action_chains.hm_keyboard import HMKeyboardMixin
+from osn_selenium.instances.trio_threads.action_chains.drag_and_drop import DragAndDropMixin
+
+
+__all__ = ["ActionChains"]
+
+
+class ActionChains(
+		ClickMixin,
+		DragAndDropMixin,
+		UtilsMixin,
+		HMKeyboardMixin,
+		HMMoveMixin,
+		HMScrollMixin,
+		AbstractActionChains,
+):
+	"""
+	ActionChains class combining standard and human-like interaction mixins.
+	"""
+	
+	pass