mops 3.1.0__tar.gz → 3.2.0__tar.gz

{mops-3.1.0 → mops-3.2.0}/PKG-INFO

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

{mops-3.1.0 → mops-3.2.0}/mops/__init__.py

@@ -1,2 +1,2 @@
-__version__ = '3.1.0'
+__version__ = '3.2.0'
 __project_name__ = 'mops'

{mops-3.1.0 → mops-3.2.0}/mops/abstraction/element_abc.py

@@ -143,10 +143,19 @@ class ElementABC(MixinABC, ABC):
         """
         raise NotImplementedError()
 
-    def wait_visibility(self, *, timeout: int = WAIT_EL, silent: bool = False) -> Element:
+    def wait_visibility(
+            self,
+            *,
+            timeout: int = WAIT_EL,
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
+    ) -> Element:
         """
         Waits until the element becomes visible.
-        **Note:** The method requires the use of named arguments.
+         **Note:** The method requires the use of named arguments.
+
+        A continuous visibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium:**
 
@@ -163,14 +172,26 @@ class ElementABC(MixinABC, ABC):
         :type timeout: int
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous visibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         raise NotImplementedError()
 
-    def wait_hidden(self, *, timeout: int = WAIT_EL, silent: bool = False) -> Element:
+    def wait_hidden(
+            self,
+            *,
+            timeout: int = WAIT_EL,
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
+    ) -> Element:
         """
         Waits until the element becomes hidden.
-        **Note:** The method requires the use of named arguments.
+         **Note:** The method requires the use of named arguments.
+
+        A continuous invisibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium:**
 
@@ -187,6 +208,9 @@ class ElementABC(MixinABC, ABC):
         :type timeout: int
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous invisibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         raise NotImplementedError()
@@ -194,7 +218,7 @@ class ElementABC(MixinABC, ABC):
     def wait_availability(self, *, timeout: int = WAIT_EL, silent: bool = False) -> Element:
         """
         Waits until the element becomes available in DOM tree. \n
-        **Note:** The method requires the use of named arguments.
+         **Note:** The method requires the use of named arguments.
 
         **Selenium:**
 
@@ -574,12 +598,15 @@ class ElementABC(MixinABC, ABC):
             self,
             *,
             timeout: Union[int, float] = QUARTER_WAIT_EL,
-            silent: bool = False
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
     ) -> Element:
         """
         Wait for the element to become visible, without raising an error if it does not.
+         **Note:** The method requires the use of named arguments.
 
-        **Note:** The method requires the use of named arguments.
+        A continuous visibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium & Playwright:**
 
@@ -596,6 +623,9 @@ class ElementABC(MixinABC, ABC):
         :type timeout: typing.Union[int, float]
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous visibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         raise NotImplementedError()
@@ -604,12 +634,15 @@ class ElementABC(MixinABC, ABC):
             self,
             *,
             timeout: Union[int, float] = QUARTER_WAIT_EL,
-            silent: bool = False
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
     ) -> Element:
         """
         Wait for the element to become hidden, without raising an error if it does not.
+         **Note:** The method requires the use of named arguments.
 
-        **Note:** The method requires the use of named arguments.
+        A continuous invisibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium & Playwright:**
 
@@ -626,6 +659,9 @@ class ElementABC(MixinABC, ABC):
         :type timeout: typing.Union[int, float]
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous invisibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         raise NotImplementedError()

{mops-3.1.0 → mops-3.2.0}/mops/base/element.py

@@ -35,8 +35,8 @@ from mops.utils.internal_utils import (
     set_parent_for_attr,
     is_page,
     QUARTER_WAIT_EL,
-    wait_condition,
 )
+from mops.utils.decorators import wait_condition, wait_continuous
 
 if TYPE_CHECKING:
     from mops.base.group import Group
@@ -193,11 +193,61 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
 
     # Elements waits
 
-    def wait_visibility_without_error(self, *, timeout: Union[int, float] = QUARTER_WAIT_EL, silent: bool = False) -> Element:
+    @wait_continuous
+    @wait_condition
+    def wait_visibility(
+            self,
+            *,
+            timeout: int = WAIT_EL,
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
+    ) -> Element:
+        """
+        Waits until the element becomes visible.
+         **Note:** The method requires the use of named arguments.
+
+        A continuous visibility verification may be applied for given
+        or default amount of time after the first condition is met.
+
+        **Selenium:**
+
+        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
+          during the waiting process.
+
+        **Appium:**
+
+        - Applied :func:`wait_condition` decorator integrates an exponential delay
+          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
+          with each iteration during the waiting process.
+
+        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
+        :type timeout: int
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :param continuous: If :obj:`True`, a continuous visibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
+        :return: :class:`Element`
+        """
+        return Result(  # noqa
+            execution_result=self.is_displayed(silent=True),
+            log=f'Wait until "{self.name}" becomes visible',
+            exc=TimeoutException(f'"{self.name}" not visible', info=self)
+        )
+
+    def wait_visibility_without_error(
+            self,
+            *,
+            timeout: Union[int, float] = QUARTER_WAIT_EL,
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
+    ) -> Element:
         """
         Wait for the element to become visible, without raising an error if it does not.
+         **Note:** The method requires the use of named arguments.
 
-        **Note:** The method requires the use of named arguments.
+        A continuous visibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium & Playwright:**
 
@@ -214,28 +264,77 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
         :type timeout: typing.Union[int, float]
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous visibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         if not silent:
-            self.log(f'Wait until "{self.name}" becomes visible without error exception')
+            strategy = 'continuous visible' if continuous else 'hidden'
+            self.log(f'Wait until "{self.name}" becomes {strategy} without error exception')
 
         try:
-            self.wait_visibility(timeout=timeout, silent=True)
-        except (TimeoutException, WebDriverException) as exception:
+            self.wait_visibility(timeout=timeout, silent=True, continuous=continuous)
+        except (TimeoutException, WebDriverException, ContinuousWaitException) as exception:
             if not silent:
                 self.log(f'Ignored exception: "{exception.msg}"')
         return self
 
+    @wait_continuous
+    @wait_condition
+    def wait_hidden(
+            self,
+            *,
+            timeout: int = WAIT_EL,
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
+    ) -> Element:
+        """
+        Waits until the element becomes hidden.
+         **Note:** The method requires the use of named arguments.
+
+        A continuous invisibility verification may be applied for given
+        or default amount of time after the first condition is met.
+
+        **Selenium:**
+
+        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
+          during the waiting process.
+
+        **Appium:**
+
+        - Applied :func:`wait_condition` decorator integrates an exponential delay
+          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
+          with each iteration during the waiting process.
+
+        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
+        :type timeout: int
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :param continuous: If :obj:`True`, a continuous invisibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
+        :return: :class:`Element`
+        """
+        return Result(  # noqa
+            execution_result=self.is_hidden(silent=True),
+            log=f'Wait until "{self.name}" becomes hidden',
+            exc=TimeoutException(f'"{self.name}" still visible', info=self),
+        )
+
     def wait_hidden_without_error(
             self,
             *,
             timeout: Union[int, float] = QUARTER_WAIT_EL,
-            silent: bool = False
+            silent: bool = False,
+            continuous: Union[bool, int, float] = False,
     ) -> Element:
         """
         Wait for the element to become hidden, without raising an error if it does not.
+         **Note:** The method requires the use of named arguments.
 
-        **Note:** The method requires the use of named arguments.
+        A continuous invisibility verification may be applied for given
+        or default amount of time after the first condition is met.
 
         **Selenium & Playwright:**
 
@@ -252,18 +351,51 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
         :type timeout: typing.Union[int, float]
         :param silent: If :obj:`True`, suppresses logging.
         :type silent: bool
+        :param continuous: If :obj:`True`, a continuous invisibility verification applied for another 2.5 seconds.
+          An :obj:`int` or :obj:`float` modifies the continuous wait timeout.
+        :type continuous: typing.Union[int, float, bool]
         :return: :class:`Element`
         """
         if not silent:
-            self.log(f'Wait until "{self.name}" becomes hidden without error exception')
+            strategy = 'continuous hidden' if continuous else 'hidden'
+            self.log(f'Wait until "{self.name}" becomes {strategy} without error exception')
 
         try:
-            self.wait_hidden(timeout=timeout, silent=True)
-        except (TimeoutException, WebDriverException) as exception:
+            self.wait_hidden(timeout=timeout, silent=silent, continuous=continuous)
+        except (TimeoutException, WebDriverException, ContinuousWaitException) as exception:
             if not silent:
                 self.log(f'Ignored exception: "{exception.msg}"')
         return self
 
+    @wait_condition
+    def wait_availability(self, *, timeout: int = WAIT_EL, silent: bool = False) -> Element:
+        """
+        Waits until the element becomes available in DOM tree. \n
+         **Note:** The method requires the use of named arguments.
+
+        **Selenium:**
+
+        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
+          during the waiting process.
+
+        **Appium:**
+
+        - Applied :func:`wait_condition` decorator integrates an exponential delay
+          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
+          with each iteration during the waiting process.
+
+        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
+        :type timeout: int
+        :param silent: If :obj:`True`, suppresses logging.
+        :type silent: bool
+        :return: :class:`Element`
+        """
+        return Result(  # noqa
+            execution_result=self.is_available(),
+            log=f'Wait until presence of "{self.name}"',
+            exc=TimeoutException(f'"{self.name}" not available in DOM', info=self),
+        )
+
     @wait_condition
     def wait_for_text(
             self,

{mops-3.1.0 → mops-3.2.0}/mops/exceptions.py

@@ -131,3 +131,10 @@ class InvalidLocatorException(DriverWrapperException):
     Thrown when locator is invalid
     """
     pass
+
+
+class ContinuousWaitException(DriverWrapperException):
+    """
+    Thrown when continuous wait is failed
+    """
+    pass

{mops-3.1.0 → mops-3.2.0}/mops/js_scripts.py

@@ -42,27 +42,37 @@ for (var i=0, max=elements.length; i < max; i++) {
 
 add_element_over_js = """
 function appendElement(given_obj) {
-    given_obj = given_obj.getBoundingClientRect();
-    driver_wrapper_obj = document.createElement("div");
-
-    driver_wrapper_obj.style.zIndex=9999999;
-    driver_wrapper_obj.setAttribute("class","driver-wrapper-comparison-support-element");
+    const rect = given_obj.getBoundingClientRect();
+    const driverWrapperObj = document.createElement("div");
+
+    driverWrapperObj.style.zIndex = 9999999;
+    driverWrapperObj.setAttribute("class", "driver-wrapper-comparison-support-element");
+    driverWrapperObj.style.backgroundColor = "#000";
+
+    // Determine position type based on scroll position
+    if (window.scrollY === 0) {
+        driverWrapperObj.style.position = "fixed";
+        driverWrapperObj.style.top = rect.top + "px";
+        driverWrapperObj.style.left = rect.left + "px";
+    } else {
+        driverWrapperObj.style.position = "absolute";
+        driverWrapperObj.style.top = (rect.top + window.scrollY) + "px";
+        driverWrapperObj.style.left = (rect.left + window.scrollX) + "px";
+    }
 
-    driver_wrapper_obj.style.position = "absolute";
-    driver_wrapper_obj.style.backgroundColor = "#000";
+    driverWrapperObj.style.width = rect.width + "px";
+    driverWrapperObj.style.height = rect.height + "px";
 
-    driver_wrapper_obj.style.width = given_obj.width + "px";
-    driver_wrapper_obj.style.height = given_obj.height + "px";
-    driver_wrapper_obj.style.top = (given_obj.top + window.scrollY) + "px";
-    driver_wrapper_obj.style.left = (given_obj.left + window.scrollX) + "px";
-    
-    document.body.appendChild(driver_wrapper_obj);
-};
+    document.body.appendChild(driverWrapperObj);
+}
 
 return appendElement(arguments[0]);
 """
 
 
+hide_caret_js_script = 'document.activeElement.blur();'
+
+
 add_driver_index_comment_js = """
 function addComment(driver_index) {
   comment = document.createComment(" " + driver_index + " ");

{mops-3.1.0 → mops-3.2.0}/mops/playwright/play_element.py

@@ -13,6 +13,7 @@ from playwright.sync_api import Locator, Page, Browser, BrowserContext
 
 from mops.mixins.objects.size import Size
 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
@@ -241,100 +242,6 @@ class PlayElement(ElementABC, Logging, ABC):
 
         return self
 
-    # Element waits
-
-    def wait_visibility(self, *, timeout: int = WAIT_EL, silent: bool = False) -> PlayElement:
-        """
-        Waits until the element becomes visible.
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`PlayElement`
-        """
-        if not silent:
-            self.log(f'Wait until "{self.name}" becomes visible')
-
-        try:
-            self._first_element.wait_for(state='visible', timeout=get_timeout_in_ms(timeout))
-        except PlayTimeoutError:
-            raise TimeoutException(f'"{self.name}" not visible', timeout=timeout, info=self)
-        return self
-
-    def wait_hidden(self, *, timeout: int = WAIT_EL, silent: bool = False) -> PlayElement:
-        """
-        Waits until the element becomes hidden.
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`PlayElement`
-        """
-        if not silent:
-            self.log(f'Wait until "{self.name}" becomes hidden')
-        try:
-            self._first_element.wait_for(state='hidden', timeout=get_timeout_in_ms(timeout))
-        except PlayTimeoutError:
-            raise TimeoutException(f'"{self.name}" still visible', timeout=timeout, info=self)
-        return self
-
-    def wait_availability(self, *, timeout: int = WAIT_EL, silent: bool = False) -> PlayElement:
-        """
-        Waits until the element becomes available in DOM tree. \n
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`PlayElement`
-        """
-        if not silent:
-            self.log(f'Wait until presence of "{self.name}"')
-
-        try:
-            self._first_element.wait_for(state='attached', timeout=get_timeout_in_ms(timeout))
-        except PlayTimeoutError:
-            raise TimeoutException(f'"{self.name}" not available in DOM', timeout=timeout, info=self)
-        return self
-
     # Element state
 
     def scroll_into_view(
@@ -495,6 +402,7 @@ class PlayElement(ElementABC, Logging, ABC):
 
         return len(self.all_elements)
 
+    @retry(AttributeError)
     def get_rect(self) -> dict:
         """
         Retrieve the size and position of the element as a dictionary.
@@ -505,6 +413,7 @@ class PlayElement(ElementABC, Logging, ABC):
         return dict(sorted_items)
 
     @property
+    @retry(TypeError)
     def size(self) -> Size:
         """
         Get the size of the current element, including width and height.
@@ -515,6 +424,7 @@ class PlayElement(ElementABC, Logging, ABC):
         return Size(width=box['width'], height=box['height'])
 
     @property
+    @retry(TypeError)
     def location(self) -> Location:
         """
         Get the location of the current element, including the x and y coordinates.

{mops-3.1.0 → mops-3.2.0}/mops/selenium/core/core_element.py

@@ -7,7 +7,6 @@ from typing import Union, List, Any, Callable, TYPE_CHECKING
 from PIL import Image
 
 from mops.mixins.internal_mixin import get_element_info
-from mops.mixins.objects.wait_result import Result
 from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
 from selenium.webdriver.remote.webelement import WebElement as SeleniumWebElement
 from appium.webdriver.webelement import WebElement as AppiumWebElement
@@ -16,21 +15,20 @@ from selenium.common.exceptions import (
     InvalidArgumentException as SeleniumInvalidArgumentException,
     InvalidSelectorException as SeleniumInvalidSelectorException,
     NoSuchElementException as SeleniumNoSuchElementException,
-    ElementNotInteractableException as SeleniumElementNotInteractableException,
-    ElementClickInterceptedException as SeleniumElementClickInterceptedException,
     StaleElementReferenceException as SeleniumStaleElementReferenceException,
+    WebDriverException as SeleniumWebDriverException,
 )
 from mops.abstraction.element_abc import ElementABC
 from mops.selenium.sel_utils import ActionChains
-from mops.js_scripts import get_element_size_js, get_element_position_on_screen_js
+from mops.js_scripts import get_element_size_js, get_element_position_on_screen_js, hide_caret_js_script
 from mops.keyboard_keys import KeyboardKeys
 from mops.mixins.objects.location import Location
 from mops.mixins.objects.scrolls import ScrollTo, ScrollTypes, scroll_into_view_blocks
 from mops.mixins.objects.size import Size
 from mops.shared_utils import cut_log_data, _scaled_screenshot
-from mops.utils.internal_utils import WAIT_EL, safe_call, get_dict, HALF_WAIT_EL, wait_condition, is_group
+from mops.utils.internal_utils import WAIT_EL, safe_call, get_dict, is_group
+from mops.utils.decorators import retry
 from mops.exceptions import (
-    TimeoutException,
     InvalidSelectorException,
     DriverWrapperException,
     NoSuchElementException,
@@ -80,6 +78,7 @@ class CoreElement(ElementABC, ABC):
 
     # Element interaction
 
+    @retry(ElementNotInteractableException)
     def click(self, *, force_wait: bool = True, **kwargs) -> CoreElement:
         """
         Clicks on the element.
@@ -101,26 +100,17 @@ class CoreElement(ElementABC, ABC):
         """
         self.log(f'Click into "{self.name}"')
 
-        self.element = self._get_element(force_wait=force_wait)
-
-        selenium_exc_msg = None
-        start_time = time.time()
-        while time.time() - start_time < HALF_WAIT_EL:
-            try:
-                element = self.wait_enabled(silent=True).element
-                element.click()
-                return self
-            except (
-                    SeleniumElementNotInteractableException,
-                    SeleniumElementClickInterceptedException,
-                    SeleniumStaleElementReferenceException,
-            ) as exc:
-                selenium_exc_msg = exc.msg
-            finally:
-                self.element = None
+        if force_wait:
+            self.wait_visibility(silent=True)
+
+        try:
+            self.wait_enabled(silent=True).element.click()
+            return self
+        except SeleniumWebDriverException as exc:
+            selenium_exc_msg = exc.msg
 
         raise ElementNotInteractableException(
-            f'Element "{self.name}" not interactable after {HALF_WAIT_EL} seconds. {self.get_element_info()}. '
+            f'Element "{self.name}" not interactable. {self.get_element_info()}. '
             f'Original error: {selenium_exc_msg}'
         )
 
@@ -140,6 +130,7 @@ class CoreElement(ElementABC, ABC):
             self.log(f'Type text "{cut_log_data(text)}" into "{self.name}"')
 
         self.element.send_keys(text)
+
         return self
 
     def type_slowly(self, text: str, sleep_gap: float = 0.05, silent: bool = False) -> CoreElement:
@@ -163,6 +154,7 @@ class CoreElement(ElementABC, ABC):
         for letter in str(text):
             element.send_keys(letter)
             time.sleep(sleep_gap)
+
         return self
 
     def clear_text(self, silent: bool = False) -> CoreElement:
@@ -177,6 +169,7 @@ class CoreElement(ElementABC, ABC):
             self.log(f'Clear text in "{self.name}"')
 
         self.element.clear()
+
         return self
 
     def check(self) -> CoreElement:
@@ -211,95 +204,6 @@ class CoreElement(ElementABC, ABC):
 
         return self
 
-    # Element waits
-
-    @wait_condition
-    def wait_visibility(self, *, timeout: int = WAIT_EL, silent: bool = False) -> CoreElement:
-        """
-        Waits until the element becomes visible.
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`CoreElement`
-        """
-        return Result(  # noqa
-            execution_result=self.is_displayed(silent=True),
-            log=f'Wait until "{self.name}" becomes visible',
-            exc=TimeoutException(f'"{self.name}" not visible', info=self)
-        )
-
-    @wait_condition
-    def wait_hidden(self, *, timeout: int = WAIT_EL, silent: bool = False) -> CoreElement:
-        """
-        Waits until the element becomes hidden.
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`CoreElement`
-        """
-        return Result(  # noqa
-            execution_result=self.is_hidden(silent=True),
-            log=f'Wait until "{self.name}" becomes hidden',
-            exc=TimeoutException(f'"{self.name}" still visible', info=self),
-        )
-
-    @wait_condition
-    def wait_availability(self, *, timeout: int = WAIT_EL, silent: bool = False) -> CoreElement:
-        """
-        Waits until the element becomes available in DOM tree. \n
-        **Note:** The method requires the use of named arguments.
-
-        **Selenium:**
-
-        - Applied :func:`wait_condition` decorator integrates a 0.1 seconds delay for each iteration
-          during the waiting process.
-
-        **Appium:**
-
-        - Applied :func:`wait_condition` decorator integrates an exponential delay
-          (starting at 0.1 seconds, up to a maximum of 1.6 seconds) which increases
-          with each iteration during the waiting process.
-
-        :param timeout: The maximum time to wait for the condition (in seconds). Default: :obj:`WAIT_EL`.
-        :type timeout: int
-        :param silent: If :obj:`True`, suppresses logging.
-        :type silent: bool
-        :return: :class:`CoreElement`
-        """
-        return Result(  # noqa
-            execution_result=self.is_available(),
-            log=f'Wait until presence of "{self.name}"',
-            exc=TimeoutException(f'"{self.name}" not available in DOM', info=self),
-        )
-
     # Element state
 
     def scroll_into_view(
@@ -354,9 +258,12 @@ class CoreElement(ElementABC, ABC):
 
         :return: :class:`bytes` - screenshot binary
         """
+        self.execute_script(hide_caret_js_script)
+
         return self.element.screenshot_as_png
 
     @property
+    @retry(SeleniumStaleElementReferenceException)
     def text(self) -> str:
         """
         Returns the text of the element.
@@ -410,14 +317,14 @@ class CoreElement(ElementABC, ABC):
         :type silent: bool
         :return: :class:`bool`
         """
-        if not silent:
-            self.log(f'Check displaying of "{self.name}"')
-
         is_displayed = self.is_available()
 
         if is_displayed:
             is_displayed = safe_call(self._cached_element.is_displayed)
 
+        if not silent:
+            self.log(f'Check displaying of "{self.name}" - {is_displayed}')
+
         return is_displayed
 
     def is_hidden(self, silent: bool = False) -> bool:
@@ -428,11 +335,14 @@ class CoreElement(ElementABC, ABC):
         :type silent: bool
         :return: :class:`bool`
         """
+        status = not self.is_displayed(silent=True)
+
         if not silent:
-            self.log(f'Check invisibility of "{self.name}"')
+            self.log(f'Check invisibility of "{self.name}" - {status}')
 
-        return not self.is_displayed(silent=True)
+        return status
 
+    @retry(SeleniumStaleElementReferenceException)
     def get_attribute(self, attribute: str, silent: bool = False) -> str:
         """
         Retrieve a specific attribute from the current element.
@@ -460,6 +370,7 @@ class CoreElement(ElementABC, ABC):
             self.log(f'Get all texts from "{self.name}"')
 
         self.wait_visibility(silent=True)
+
         return list(element_item.text for element_item in self.all_elements)
 
     def get_elements_count(self, silent: bool = False) -> int:
@@ -485,6 +396,7 @@ class CoreElement(ElementABC, ABC):
         return dict(sorted_items)
 
     @property
+    @retry(SeleniumStaleElementReferenceException)
     def size(self) -> Size:
         """
         Get the size of the current element, including width and height.
@@ -494,6 +406,7 @@ class CoreElement(ElementABC, ABC):
         return Size(**self.execute_script(get_element_size_js))
 
     @property
+    @retry(SeleniumStaleElementReferenceException)
     def location(self) -> Location:
         """
         Get the location of the current element, including the x and y coordinates.

mops-3.2.0/mops/utils/decorators.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import time
+from functools import wraps
+from typing import Callable, Union, Any, TYPE_CHECKING
+
+from mops.exceptions import ContinuousWaitException
+from mops.mixins.objects.wait_result import Result
+from mops.utils.internal_utils import HALF_WAIT_EL, WAIT_EL, validate_timeout, validate_silent, WAIT_METHODS_DELAY, \
+    increase_delay, QUARTER_WAIT_EL
+from mops.utils.logs import autolog, LogLevel
+
+
+if TYPE_CHECKING:
+    from mops.base.element import Element
+
+
+def retry(exceptions, timeout: int = HALF_WAIT_EL):
+    """
+    A decorator to retry a function when specified exceptions occur.
+
+    :param exceptions: Exception or tuple of exception classes to catch and retry on.
+    :param timeout: The maximum time (in seconds) to keep retrying before giving up.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            timestamp = None
+
+            while True:
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as exc:
+                    if not timestamp:
+                        timestamp = time.time()
+                    elif time.time() - timestamp >= timeout:
+                        raise exc
+                    autolog(
+                        f'Caught "{exc.__class__.__name__}" while executing "{func.__name__}", retrying...',
+                        level=LogLevel.WARNING
+                    )
+        return wrapper
+    return decorator
+
+
+def wait_condition(method: Callable):
+
+    @wraps(method)
+    def wrapper(
+        self: Element,
+        *args: Any,
+        timeout: Union[int, float] = WAIT_EL,
+        silent: bool = False,
+        continuous: bool = False,
+        **kwargs: Any,
+    ):
+        validate_timeout(timeout)
+        validate_silent(silent)
+
+        should_increase_delay = self.driver_wrapper.is_appium
+        delay = WAIT_METHODS_DELAY
+        is_log_needed = not silent
+        start_time = time.time()
+
+        if continuous:
+            return method(self, *args, **kwargs)
+
+        while time.time() - start_time < timeout:
+            result: Result = method(self, *args, **kwargs)
+
+            if is_log_needed:
+                self.log(result.log)
+                is_log_needed = False
+
+            if result.execution_result:
+                return self
+
+            time.sleep(delay)
+
+            if should_increase_delay:
+                delay = increase_delay(delay)
+
+        result.exc._timeout = timeout  # noqa
+        raise result.exc
+
+    return wrapper
+
+
+def wait_continuous(method: Callable):
+
+    @wraps(method)
+    def wrapper(
+        self: Element,
+        *args: Any,
+        silent: bool = False,
+        continuous: Union[int, float, bool] = False,
+        **kwargs: Any
+    ):
+        result: Element = method(self, *args, silent=silent, continuous=False, **kwargs)  # Wait for initial condition
+
+        if not continuous:
+            return result
+
+        should_increase_delay = self.driver_wrapper.is_appium
+        delay = WAIT_METHODS_DELAY
+        start_time = time.time()
+        is_log_needed = not silent
+        timeout = continuous if type(continuous) in (int, float) else QUARTER_WAIT_EL
+
+        while time.time() - start_time < timeout:
+            result: Result = method(self, *args, silent=silent, continuous=True, **kwargs)
+
+            if is_log_needed:
+                self.log(f'Starting continuous "{method.__name__}" for the "{self.name}" for next {timeout} seconds')
+                is_log_needed = False
+
+            if not result.execution_result:
+                raise ContinuousWaitException(
+                    f'The continuous "{method.__name__}" of the "{self.name}" is no met ' 
+                    f'after {(time.time() - start_time):.2f} seconds'
+                )
+
+            time.sleep(delay)
+
+            if should_increase_delay:
+                delay = increase_delay(delay)
+
+        return self
+
+    return wrapper

{mops-3.1.0 → mops-3.2.0}/mops/utils/internal_utils.py

@@ -2,18 +2,15 @@ from __future__ import annotations
 
 import sys
 import inspect
-import time
 from copy import copy
-from functools import lru_cache, wraps
+from functools import lru_cache
 from typing import Any, Union, Callable
 
 from mops.mixins.objects.size import Size
-from mops.mixins.objects.wait_result import Result
 from selenium.common.exceptions import StaleElementReferenceException as SeleniumStaleElementReferenceException
 
 from mops.exceptions import NoSuchElementException, InvalidSelectorException, TimeoutException, NoSuchParentException
 
-
 WAIT_METHODS_DELAY = 0.1
 WAIT_UNIT = 1
 WAIT_EL = 10
@@ -24,7 +21,7 @@ WAIT_PAGE = 15
 
 all_tags = {'h1', 'h2', 'h3', 'h4', 'h5', 'head', 'body', 'input', 'section', 'button', 'a', 'link', 'header', 'div',
             'textarea', 'svg', 'circle', 'iframe', 'label', 'p', 'tr', 'th', 'table', 'tbody', 'td', 'select', 'nav',
-            'li', 'form', 'footer', 'frame', 'area', 'span'}
+            'li', 'form', 'footer', 'frame', 'area', 'span', 'video'}
 
 
 def get_dict(obj: Any):
@@ -297,34 +294,3 @@ def increase_delay(delay, max_delay: Union[int, float] = 1.5) -> Union[int, floa
     if delay < max_delay:
         return delay + delay
     return delay
-
-
-def wait_condition(method: Callable):
-
-    @wraps(method)
-    def wrapper(self, *args, timeout: Union[int, float] = WAIT_EL, silent: bool = False, **kwargs):
-        validate_timeout(timeout)
-        validate_silent(silent)
-
-        start_time = time.time()
-        result: Result = method(self, *args, **kwargs)
-
-        if not silent:
-            self.log(result.log)
-
-        should_increase_delay = self.driver_wrapper.is_appium
-        delay = WAIT_METHODS_DELAY
-
-        while time.time() - start_time < timeout and not result.execution_result:
-            time.sleep(delay)
-            result: Result = method(self, *args, **kwargs)
-            if should_increase_delay:
-                delay = increase_delay(delay)
-
-        if result.execution_result:
-            return self
-
-        result.exc._timeout = timeout  # noqa
-        raise result.exc
-
-    return wrapper

{mops-3.1.0 → mops-3.2.0}/mops.egg-info/PKG-INFO

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

{mops-3.1.0 → mops-3.2.0}/mops.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ mops/selenium/elements/mobile_element.py
 mops/selenium/elements/web_element.py
 mops/selenium/pages/mobile_page.py
 mops/selenium/pages/web_page.py
+mops/utils/decorators.py
 mops/utils/internal_utils.py
 mops/utils/logs.py
 mops/utils/previous_object_driver.py