mops 3.2.1__tar.gz → 3.3.1__tar.gz

{mops-3.2.1 → mops-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mops
-Version: 3.2.1
+Version: 3.3.1
 Summary: Wrapper of Selenium, Appium and Playwright with single API
 Author-email: Podolian Vladimir <vladimir.podolyan64@gmail.com>
 License: MIT

{mops-3.2.1 → mops-3.3.1}/mops/__init__.py

@@ -1,2 +1,2 @@
-__version__ = '3.2.1'
+__version__ = '3.3.1'
 __project_name__ = 'mops'

{mops-3.2.1 → mops-3.3.1}/mops/abstraction/driver_wrapper_abc.py

@@ -95,13 +95,16 @@ class DriverWrapperABC(ABC):
         """
         raise NotImplementedError()
 
-    def wait(self, timeout: Union[int, float] = WAIT_UNIT) -> DriverWrapper:
+    def wait(self, timeout: Union[int, float] = WAIT_UNIT, reason: str = '') -> DriverWrapper:
         """
         Pauses the execution for a specified amount of time.
 
         :param timeout: The time to sleep in seconds (can be an integer or float).
         :type timeout: typing.Union[int, float]
 
+        :param reason: The waiting reason.
+        :type reason: str
+
         :return: :obj:`.DriverWrapper` - The current instance of the driver wrapper.
         """
         raise NotImplementedError()
@@ -222,15 +225,15 @@ class DriverWrapperABC(ABC):
         """
         raise NotImplementedError()
 
-    def execute_script(self, script: str, *args) -> Any:
+    def execute_script(self, script: str, *args: Any) -> Any:
         """
         Synchronously executes JavaScript in the current window or frame.
         Compatible with Selenium's `execute_script` method.
 
         :param script: The JavaScript code to execute.
         :type script: str
-        :param args: Any arguments to pass to the JavaScript (e.g., Element object).
-        :type args: list
+        :param args: Any arguments to pass to the JavaScript.
+        :type args: :obj:`typing.Any`
         :return: :obj:`typing.Any` - The result of the JavaScript execution.
         """
         raise NotImplementedError()
@@ -307,6 +310,14 @@ class DriverWrapperABC(ABC):
         """
         raise NotImplementedError()
 
+    def get_scroll_position(self) -> int:
+        """
+        Returns the current vertical scroll position of the page.
+
+        :return: :class:`int` - Current vertical scroll offset in pixels.
+        """
+        raise NotImplementedError()
+
     def assert_screenshot(
             self,
             filename: str = '',

{mops-3.2.1 → mops-3.3.1}/mops/abstraction/element_abc.py

@@ -258,22 +258,34 @@ class ElementABC(MixinABC, ABC):
         """
         raise NotImplementedError()
 
-    def hide(self) -> Element:
+    def hide(self, silent: bool = False) -> Element:
         """
-        Hides the element.
+        Make the element invisible by setting its opacity to 0.
 
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :return: :class:`Element`
+        """
+        raise NotImplementedError()
+
+    def show(self, silent: bool = False) -> Element:
+        """
+        Make the element visible by setting its opacity to 1.
+
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
         :return: :class:`Element`
         """
         raise NotImplementedError()
 
-    def execute_script(self, script: str, *args) -> Any:
+    def execute_script(self, script: str, *args: Any) -> Any:
         """
         Executes a JavaScript script on the element.
 
         :param script: JavaScript code to be executed, referring to the element as ``arguments[0]``.
         :type script: str
-        :param args: Additional arguments for the script,
-          that appear in script as ``arguments[1]`` ``arguments[2]`` etc.
+        :param args: Any arguments to pass to the JavaScript.
+        :type args: :obj:`typing.Any`
         :return: :obj:`typing.Any` result from the script.
         """
         raise NotImplementedError()

{mops-3.2.1 → mops-3.3.1}/mops/base/driver_wrapper.py

@@ -13,6 +13,7 @@ from playwright.sync_api import (
 
 from mops.mixins.objects.box import Box
 from mops.mixins.objects.driver import Driver
+from mops.mixins.objects.visual_comaprison_mixin import hide_before_screenshot, reveal_after_screenshot
 from mops.visual_comparison import VisualComparison
 from mops.abstraction.driver_wrapper_abc import DriverWrapperABC
 from mops.playwright.play_driver import PlayDriver
@@ -220,6 +221,14 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
 
         return image_object
 
+    def get_scroll_position(self) -> int:
+        """
+        Returns the current vertical scroll position of the page.
+
+        :return: :class:`int` - Current vertical scroll offset in pixels.
+        """
+        return self.execute_script('return window.pageYOffset')
+
     def assert_screenshot(
             self,
             filename: str = '',
@@ -263,17 +272,17 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
         delay = delay or VisualComparison.default_delay
         remove = [remove] if type(remove) is not list and remove else remove
 
-        if hide:
-            if not isinstance(hide, list):
-                hide = [hide]
-            for object_to_hide in hide:
-                object_to_hide.hide()
+        hide_before_screenshot(hide, is_optional=False, dw=self)
+        self.wait(delay)
+        hide_before_screenshot(VisualComparison.always_hide, is_optional=True, dw=self)
 
         VisualComparison(self).assert_screenshot(
-            filename=filename, test_name=test_name, name_suffix=name_suffix, threshold=threshold, delay=delay,
-            scroll=False, remove=remove, fill_background=False, cut_box=cut_box
+            filename=filename, test_name=test_name, name_suffix=name_suffix, threshold=threshold,
+            remove=remove, fill_background=False, cut_box=cut_box
         )
 
+        reveal_after_screenshot(VisualComparison.always_hide, dw=self)
+
     def soft_assert_screenshot(
             self,
             filename: str = '',

{mops-3.2.1 → mops-3.3.1}/mops/base/element.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import time
 from copy import copy
 from typing import Union, List, Type, Tuple, Optional, TYPE_CHECKING
 
 from PIL.Image import Image
 
+from mops.mixins.objects.scrolls import ScrollTo, ScrollTypes, scroll_into_view_blocks
+from mops.mixins.objects.visual_comaprison_mixin import hide_before_screenshot, reveal_after_screenshot
 from mops.mixins.objects.wait_result import Result
 from playwright.sync_api import Page as PlaywrightDriver
 from appium.webdriver.webdriver import WebDriver as AppiumDriver
@@ -696,6 +699,43 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
 
         return is_visible
 
+    def scroll_into_view(
+            self,
+            block: ScrollTo = ScrollTo.CENTER,
+            behavior: ScrollTypes = ScrollTypes.INSTANT,
+            sleep: Union[int, float] = 0,
+            silent: bool = False,
+    ) -> Element:
+        """
+        Scrolls the element into view using a JavaScript script.
+
+        :param block: The scrolling block alignment. One of the :class:`.ScrollTo` options.
+        :type block: ScrollTo
+        :param behavior: The scrolling behavior. One of the :class:`.ScrollTypes` options.
+        :type behavior: ScrollTypes
+        :param sleep: Delay in seconds after scrolling. Can be an integer or a float.
+        :type sleep: typing.Union[int, float]
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :return: :class:`Element`
+        """
+        if not silent:
+            self.log(f'Scroll element "{self.name}" into view')
+
+        if block not in scroll_into_view_blocks:
+            message = f'Provide one of {scroll_into_view_blocks} option in `block` argument'
+            raise UnsuitableArgumentsException(message)
+
+        self.execute_script(
+            'arguments[0].scrollIntoView({block: arguments[1], behavior: arguments[2]});',
+            block, behavior
+        )
+
+        if sleep:
+            time.sleep(sleep)
+
+        return self
+
     def save_screenshot(
             self,
             file_name: str,
@@ -726,23 +766,42 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
 
         return image_object
 
-    def hide(self) -> Element:
+    def hide(self, silent: bool = False) -> Element:
         """
-        Hides the element.
+        Make the element invisible by setting its opacity to 0.
 
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
         :return: :class:`Element`
         """
+        if not silent:
+            self.log(f'Hiding element "{self.name}"')
+
         self.execute_script('arguments[0].style.opacity = "0";')
         return self
 
-    def execute_script(self, script: str, *args) -> Any:
+    def show(self, silent: bool = False) -> Element:
+        """
+        Make the element visible by setting its opacity to 1.
+
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :return: :class:`Element`
+        """
+        if not silent:
+            self.log(f'Showing element "{self.name}"')
+
+        self.execute_script('arguments[0].style.opacity = "1";')
+        return self
+
+    def execute_script(self, script: str, *args: Any) -> Any:
         """
         Executes a JavaScript script on the element.
 
         :param script: JavaScript code to be executed, referring to the element as ``arguments[0]``.
         :type script: str
-        :param args: Additional arguments for the script,
-          that appear in script as ``arguments[1]`` ``arguments[2]`` etc.
+        :param args: Any arguments to pass to the JavaScript.
+        :type args: :obj:`typing.Any`
         :return: :obj:`typing.Any` result from the script.
         """
         return self.driver_wrapper.execute_script(script, *[self, *[arg for arg in args]])
@@ -797,17 +856,20 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
         delay = delay or VisualComparison.default_delay
         remove = [remove] if type(remove) is not list and remove else remove
 
-        if hide:
-            if not isinstance(hide, list):
-                hide = [hide]
-            for object_to_hide in hide:
-                object_to_hide.hide()
+        if scroll:
+            self.scroll_into_view()
+
+        hide_before_screenshot(hide, is_optional=False, dw=self.driver_wrapper)
+        self.driver_wrapper.wait(delay)
+        hide_before_screenshot(VisualComparison.always_hide, is_optional=True, dw=self.driver_wrapper)
 
         VisualComparison(self.driver_wrapper, self).assert_screenshot(
-            filename=filename, test_name=test_name, name_suffix=name_suffix, threshold=threshold, delay=delay,
-            scroll=scroll, remove=remove, fill_background=fill_background, cut_box=cut_box
+            filename=filename, test_name=test_name, name_suffix=name_suffix, threshold=threshold,
+            remove=remove, fill_background=fill_background, cut_box=cut_box
         )
 
+        reveal_after_screenshot(VisualComparison.always_hide, dw=self.driver_wrapper)
+
     def soft_assert_screenshot(
             self,
             filename: str = '',

{mops-3.2.1 → mops-3.3.1}/mops/js_scripts.py

@@ -70,7 +70,7 @@ return appendElement(arguments[0]);
 """
 
 
-hide_caret_js_script = 'document.activeElement.blur();'
+hide_caret_js_script = "arguments[0].style.caretColor = 'transparent';"
 
 
 add_driver_index_comment_js = """

mops-3.3.1/mops/mixins/capabilities.py

@@ -0,0 +1,4 @@
+CUSTOM_TOP_BAR_LOCATOR_CAPABILITY = 'mops:customTopBarLocator'
+CUSTOM_BOTTOM_BAR_LOCATOR_CAPABILITY = 'mops:customBottomBarLocator'
+CUSTOM_DONE_BUTTON_LOCATOR_CAPABILITY = 'mops:customDoneButtonLocator'
+CUSTOM_DEVICE_NAME_CAPABILITY = 'mops:customDeviceName'

mops-3.3.1/mops/mixins/native_context.py

@@ -0,0 +1,89 @@
+from mops.mixins.objects.locator import Locator
+from mops.mixins.capabilities import (
+    CUSTOM_BOTTOM_BAR_LOCATOR_CAPABILITY,
+    CUSTOM_DONE_BUTTON_LOCATOR_CAPABILITY,
+    CUSTOM_TOP_BAR_LOCATOR_CAPABILITY,
+)
+
+
+class NativeContext:
+
+    def __init__(self, driver_wrapper):
+        self.driver_wrapper = driver_wrapper
+
+    def __enter__(self):
+        self.driver_wrapper.switch_to_native()
+
+    def __exit__(self, *args):
+        self.driver_wrapper.switch_to_web()
+
+
+class NativeSafari:
+
+    ios_keyboard_hide_button = "//XCUIElementTypeButton[@name='Done']"
+
+    ios_18_bottom_bar_locator = (
+        '//*[@name="CapsuleViewController"]/XCUIElementTypeOther/'
+        'XCUIElementTypeOther[1]/XCUIElementTypeOther[1]'
+    )  # `Tab Bar` at Safari settings
+    ios_26_bottom_bar_locator = (
+        '//*[@name="CapsuleViewController"]'
+        '/XCUIElementTypeOther[2]'
+    )  # `Compact` at Safari settings
+
+    ipados_top_bar_locator = (
+        '//XCUIElementTypeOther[@name="UnifiedBar?isStandaloneBar=true"]'
+        '/XCUIElementTypeOther[1]'
+    )
+    ios_mobile_top_bar_locator = (
+        '//*[contains(@name, "SafariWindow")]/XCUIElementTypeOther[1]'
+        '/XCUIElementTypeOther/XCUIElementTypeOther'
+    )
+
+    def __init__(self, driver_wrapper):
+        from mops.base.element import Element
+        self.driver_wrapper = driver_wrapper
+
+        self.custom_top_bar_locator = self.driver_wrapper.caps.get(CUSTOM_TOP_BAR_LOCATOR_CAPABILITY, '')
+        self.top_bar = Element(
+            Locator(
+                mobile=self.custom_top_bar_locator or self.ios_mobile_top_bar_locator,
+                tablet=self.custom_top_bar_locator or self.ipados_top_bar_locator
+            ),
+            name='safari top bar',
+            driver_wrapper=driver_wrapper
+        )
+
+        self.custom_bottom_bar_locator = self.driver_wrapper.caps.get(CUSTOM_BOTTOM_BAR_LOCATOR_CAPABILITY, '')
+        self.bottom_bar = Element(
+            self.custom_bottom_bar_locator or self.ios_18_bottom_bar_locator,
+            name='safari bottom bar',
+            driver_wrapper=driver_wrapper
+        )
+
+        self.custom_done_button_locator = self.driver_wrapper.caps.get(CUSTOM_DONE_BUTTON_LOCATOR_CAPABILITY, '')
+        self.keyboard_done_button = Element(
+            locator=self.custom_done_button_locator or self.ios_keyboard_hide_button,
+            name='keyboard Done button',
+            driver_wrapper=driver_wrapper
+        )
+
+    def get_bottom_bar_height(self) -> int:
+        """
+        Get iOS/iPadOS bottom bar height
+
+        :return: int
+        """
+        if self.driver_wrapper.is_tablet:
+            return 0  # iPad does not have bottom bar
+
+        if not self.custom_bottom_bar_locator:
+            ios_version = float(self.driver_wrapper.driver.caps.get('platformVersion', 18.2))
+
+            if ios_version >= 18.2:
+                self.bottom_bar.locator = self.ios_18_bottom_bar_locator
+            elif ios_version >= 26.0:
+                self.bottom_bar.locator = self.ios_26_bottom_bar_locator
+
+
+        return self.bottom_bar.size.height

mops-3.3.1/mops/mixins/objects/visual_comaprison_mixin.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Union, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mops.base.element import Element
+    from mops.base.driver_wrapper import DriverWrapper
+
+
+def hide_elements(objects_to_hide: Union[list[Element], Element], is_optional: bool, dw: DriverWrapper):
+    for object_to_hide in objects_to_hide:
+
+        if is_optional:
+            object_to_hide = object_to_hide(dw)
+            if object_to_hide.is_displayed(silent=True):
+                object_to_hide.hide(silent=True)
+        else:
+            object_to_hide.hide(silent=True)
+
+
+
+def hide_before_screenshot(objects_to_hide: Union[list, Any], is_optional: bool, dw: DriverWrapper = None):
+    if objects_to_hide:
+        if not isinstance(objects_to_hide, list):
+            objects_to_hide = [objects_to_hide]
+
+        hide_elements(objects_to_hide, is_optional=is_optional, dw=dw)
+
+
+def reveal_after_screenshot(objects_to_reveal: Union[list, Any], dw: DriverWrapper):
+    for object_to_reveal in objects_to_reveal:
+        object_to_reveal = object_to_reveal(dw)
+        if object_to_reveal.is_displayed(silent=True):
+            object_to_reveal.show(silent=True)

{mops-3.2.1 → mops-3.3.1}/mops/playwright/play_driver.py

@@ -66,15 +66,21 @@ class PlayDriver(Logging, DriverWrapperABC):
         """
         return self.browser_name.lower() == 'firefox'
 
-    def wait(self, timeout: Union[int, float] = WAIT_UNIT) -> PlayDriver:
+    def wait(self, timeout: Union[int, float] = WAIT_UNIT, reason: str = '') -> PlayDriver:
         """
         Pauses the execution for a specified amount of time.
 
         :param timeout: The time to sleep in seconds (can be an integer or float).
         :type timeout: typing.Union[int, float]
 
+        :param reason: The waiting reason.
+        :type reason: str
+
         :return: :obj:`.PlayDriver` - The current instance of the driver wrapper.
         """
+        if reason:
+            self.log(reason)
+
         self.driver.wait_for_timeout(get_timeout_in_ms(timeout))
         return self
 
@@ -245,15 +251,15 @@ class PlayDriver(Logging, DriverWrapperABC):
         self.driver = self._base_driver
         return self
 
-    def execute_script(self, script: str, *args) -> Any:
+    def execute_script(self, script: str, *args: Any) -> Any:
         """
         Synchronously executes JavaScript in the current window or frame.
         Compatible with Selenium's `execute_script` method.
 
         :param script: The JavaScript code to execute.
         :type script: str
-        :param args: Any arguments to pass to the JavaScript (e.g., Element object).
-        :type args: list
+        :param args: Any arguments to pass to the JavaScript.
+        :type args: :obj:`typing.Any`
         :return: :obj:`typing.Any` - The result of the JavaScript execution.
         """
         script = script.replace('return ', '')

{mops-3.2.1 → mops-3.3.1}/mops/playwright/play_element.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-import time
 from abc import ABC
 from typing import Union, List, Any
 
 from PIL.Image import Image
 from mops.keyboard_keys import KeyboardKeys
-from mops.mixins.objects.scrolls import ScrollTo, ScrollTypes
-from playwright.sync_api import TimeoutError as PlayTimeoutError, Error
+from playwright.sync_api import Error
 from playwright.sync_api import Page as PlaywrightPage
 from playwright.sync_api import Locator, Page, Browser, BrowserContext
 
@@ -16,12 +14,10 @@ from mops.mixins.objects.location import Location
 from mops.utils.decorators import retry
 from mops.utils.selector_synchronizer import get_platform_locator, set_playwright_locator
 from mops.abstraction.element_abc import ElementABC
-from mops.exceptions import TimeoutException, InvalidSelectorException
+from mops.exceptions import InvalidSelectorException
 from mops.utils.logs import Logging
 from mops.shared_utils import cut_log_data, get_image
 from mops.utils.internal_utils import (
-    WAIT_EL,
-    get_timeout_in_ms,
     calculate_coordinate_to_click,
     is_group,
     is_element,
@@ -105,7 +101,11 @@ class PlayElement(ElementABC, Logging, ABC):
         if force_wait:
             self.wait_visibility(silent=True)
 
-        self._first_element.click(**kwargs)
+        if self.driver_wrapper.is_mobile_resolution:
+            self._first_element.tap(**kwargs)
+        else:
+            self._first_element.click(**kwargs)
+
         return self
 
     def click_outside(self, x: int = -5, y: int = -5) -> PlayElement:
@@ -244,36 +244,6 @@ class PlayElement(ElementABC, Logging, ABC):
 
     # Element state
 
-    def scroll_into_view(
-            self,
-            block: ScrollTo = ScrollTo.CENTER,
-            behavior: ScrollTypes = ScrollTypes.INSTANT,
-            sleep: Union[int, float] = 0,
-            silent: bool = False,
-    ) -> PlayElement:
-        """
-        Scrolls the element into view using a JavaScript script.
-
-        :param block: The scrolling block alignment. One of the :class:`.ScrollTo` options.
-        :type block: ScrollTo
-        :param behavior: The scrolling behavior. One of the :class:`.ScrollTypes` options.
-        :type behavior: ScrollTypes
-        :param sleep: Delay in seconds after scrolling. Can be an integer or a float.
-        :type sleep: typing.Union[int, float]
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`PlayElement`
-        """
-        if not silent:
-            self.log(f'Scroll element "{self.name}" into view')
-
-        self._first_element.scroll_into_view_if_needed()
-
-        if sleep:
-            time.sleep(sleep)
-
-        return self
-
     def screenshot_image(self, screenshot_base: bytes = None) -> Image:
         """
         Returns a :class:`PIL.Image.Image` object representing the screenshot of the web element.

{mops-3.2.1 → mops-3.3.1}/mops/selenium/core/core_driver.py

@@ -89,15 +89,21 @@ class CoreDriver(Logging, DriverWrapperABC):
         """
         return Size(**self.driver.get_window_size())
 
-    def wait(self, timeout: Union[int, float] = WAIT_UNIT) -> CoreDriver:
+    def wait(self, timeout: Union[int, float] = WAIT_UNIT, reason: str = '') -> CoreDriver:
         """
         Pauses the execution for a specified amount of time.
 
         :param timeout: The time to sleep in seconds (can be an integer or float).
         :type timeout: typing.Union[int, float]
 
+        :param reason: The waiting reason.
+        :type reason: str
+
         :return: :obj:`.CoreDriver` - The current instance of the driver wrapper.
         """
+        if reason:
+            self.log(reason)
+
         time.sleep(timeout)
         return self
 
@@ -285,15 +291,15 @@ class CoreDriver(Logging, DriverWrapperABC):
         self.driver.switch_to.default_content()
         return self
 
-    def execute_script(self, script: str, *args) -> Any:
+    def execute_script(self, script: str, *args: Any) -> Any:
         """
         Synchronously executes JavaScript in the current window or frame.
         Compatible with Selenium's `execute_script` method.
 
         :param script: The JavaScript code to execute.
         :type script: str
-        :param args: Any arguments to pass to the JavaScript (e.g., Element object).
-        :type args: list
+        :param args: Any arguments to pass to the JavaScript.
+        :type args: :obj:`typing.Any`
         :return: :obj:`typing.Any` - The result of the JavaScript execution.
         """
         args = [getattr(arg, 'element', arg) for arg in args]