pomcorn 0.9.3__tar.gz → 0.10.1__tar.gz

{pomcorn-0.9.3 → pomcorn-0.10.1}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pomcorn
-Version: 0.9.3
+Version: 0.10.1
 Summary: Base implementation of Page Object Model
-Home-page: https://pypi.org/project/pomcorn/
 License: MIT
+License-File: LICENSE
 Keywords: python,selenium,webdriver,autotests,page object model,page object pattern,page object,pom,parsing,browser
 Author: Saritasa
 Author-email: pypi@saritasa.com
@@ -18,9 +18,12 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: selenium (>=4.12)
 Project-URL: Documentation, http://pomcorn.rtfd.io/
+Project-URL: Homepage, https://pypi.org/project/pomcorn/
 Project-URL: Repository, https://github.com/saritasa-nest/pomcorn/
 Description-Content-Type: text/markdown
 

{pomcorn-0.9.3 → pomcorn-0.10.1}/pomcorn/component.py

@@ -62,7 +62,7 @@ class Component(Generic[TPage], WebView):
         super().__init__(
             page.webdriver,
             app_root=page.app_root,
-            wait_timeout=page.wait_timeout,
+            wait_timeout=page.wait._timeout,
         )
         self.page = page
         self.base_locator = base_locator or self.base_locator
@@ -174,13 +174,25 @@ class Component(Generic[TPage], WebView):
             return locator
         return self.base_locator // relative_locator
 
-    def wait_until_visible(self, **kwargs):
-        """Wait until component becomes visible."""
-        self.body.wait_until_visible()
+    def wait_until_visible(self, timeout: float | None = None, **kwargs):
+        """Wait until component becomes visible.
 
-    def wait_until_invisible(self, **kwargs):
-        """Wait until component becomes invisible."""
-        self.body.wait_until_invisible()
+        By default, method waits for `self.wait._timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
+        """
+        self.body.wait_until_visible(timeout)
+
+    def wait_until_invisible(self, timeout: float | None = None, **kwargs):
+        """Wait until component becomes invisible.
+
+        By default, method waits for `self.wait._timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
+        """
+        self.body.wait_until_invisible(timeout)
 
 
 # Here type ignore added because we can't specify TPage as generic for
@@ -349,12 +361,11 @@ class ListComponent(Generic[ListItemType, TPage], Component[TPage]):
 
         return False
 
-    def get_item_by_text(self, text: str) -> ListItemType:
+    def get_item_by_text(self, text: str, exact: bool = False) -> ListItemType:
         """Get list item by text."""
-        locator = self.base_item_locator.extend_query(
-            extra_query=(
-                f"[contains(., {self.base_item_locator._escape_quotes(text)})]"
-            ),
+        locator = self.base_item_locator.contains(
+            text=text,
+            exact=exact,
         )
         return self._item_class(page=self.page, base_locator=locator)
 

{pomcorn-0.9.3 → pomcorn-0.10.1}/pomcorn/element.py

@@ -33,58 +33,101 @@ class PomcornElement(Generic[locators.TLocator]):
         self.web_view = web_view
         self.locator = locator
 
-    def wait_until_visible(self):
+    def wait_until_visible(self, timeout: float | None = None):
         """Wait until element becomes visible.
 
+        By default, method waits for `self.web_view.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
-                has not ended.
+            TimeoutException: If after `self.web_view.wait_timeout` seconds
+                the wait has not ended.
 
         """
-        self.web_view.wait_until_locator_visible(locator=self.locator)
+        self.web_view.wait_until_locator_visible(
+            locator=self.locator,
+            timeout=timeout,
+        )
 
-    def wait_until_invisible(self):
+    def wait_until_invisible(
+        self,
+        timeout: float | None = None,
+    ):
         """Wait until element becomes invisible.
 
+        By default, method waits for `self.web_view.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
-                has not ended.
+            TimeoutException: If after `self.web_view.wait_timeout` seconds
+                the wait has not ended.
 
         """
-        self.web_view.wait_until_locator_invisible(locator=self.locator)
+        self.web_view.wait_until_locator_invisible(
+            locator=self.locator,
+            timeout=timeout,
+        )
 
-    def wait_until_clickable(self):
+    def wait_until_clickable(
+        self,
+        timeout: float | None = None,
+    ):
         """Wait until element becomes clickable.
 
+        By default, method waits for `self.web_view.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
-                has not ended.
+            TimeoutException: If after `self.web_view.wait_timeout` seconds
+                the wait has not ended.
 
         """
-        self.web_view.wait_until_clickable(locator=self.locator)
+        self.web_view.wait_until_clickable(
+            locator=self.locator,
+            timeout=timeout,
+        )
 
-    def wait_until_text_is_in_element(self, text: str):
+    def wait_until_text_is_in_element(
+        self,
+        text: str,
+        timeout: float | None = None,
+    ):
         """Wait until text is present in element.
 
+        By default, method waits for `self.web_view.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
-                has not ended.
+            TimeoutException: If after `self.web_view.wait_timeout` seconds
+                the wait has not ended.
 
         """
         self.web_view.wait_until_text_is_in_element(
             text=text,
             locator=self.locator,
+            timeout=timeout,
         )
 
-    def wait_until_not_exists_in_dom(self):
+    def wait_until_not_exists_in_dom(self, timeout: float | None = None):
         """Wait until element ceases to exist in DOM.
 
+        By default, method waits for `self.web_view.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
-                has not ended.
+            TimeoutException: If after `self.web_view.wait_timeout` seconds
+                the wait has not ended.
 
         """
-        self.web_view.wait_until_not_exists_in_dom(self.locator)
+        self.web_view.wait_until_not_exists_in_dom(
+            element=self.locator,
+            timeout=timeout,
+        )
 
     def get_element(self, only_visible: bool = True) -> WebElement:
         """Get selenium instance(WebElement) of element.

{pomcorn-0.9.3 → pomcorn-0.10.1}/pomcorn/page.py

@@ -122,13 +122,14 @@ class Page(WebView):
         self.webdriver.refresh()
         self.wait_until_loaded()
 
-    def wait_until_loaded(self) -> None:
+    def wait_until_loaded(self, timeout: float | None = None) -> None:
         """Wait until page is loaded."""
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=lambda _: self.check_page_is_loaded(),
             message=(
                 f"Page `{self.__class__}` didn't loaded in "
-                f"{self.wait_timeout} seconds! Didn't wait for `True` from "
+                f"{wait._timeout} seconds! Didn't wait for `True` from "
                 "`check_page_is_loaded` method."
             ),
         )

{pomcorn-0.9.3 → pomcorn-0.10.1}/pomcorn/web_view.py

@@ -20,7 +20,7 @@ class WebView:
         webdriver: WebDriver,
         *,
         app_root: str,
-        wait_timeout: int,
+        wait_timeout: float,
         poll_frequency: float = 0,
     ):
         """Initialize webview.
@@ -37,11 +37,8 @@ class WebView:
         self.webdriver = webdriver
         self.app_root = app_root
         self.wait_timeout = wait_timeout
-        self.wait = WebDriverWait(
-            driver=webdriver,
-            timeout=wait_timeout,
-            poll_frequency=poll_frequency,
-        )
+        self.poll_frequency = poll_frequency
+        self.wait = self.get_wait(self.wait_timeout)
 
     def init_element(
         self,
@@ -125,6 +122,24 @@ class WebView:
             )
         return result
 
+    def get_wait(
+        self,
+        timeout: float | None = None,
+    ) -> WebDriverWait[WebDriver]:
+        """Get `WebDriverWait` instance.
+
+        If no arguments are provided, returns the default wait instance.
+
+        """
+        if not timeout:
+            return self.wait
+
+        return WebDriverWait(
+            driver=self.webdriver,
+            timeout=timeout,
+            poll_frequency=self.poll_frequency,
+        )
+
     @property
     def current_url(self) -> str:
         """Return the current webdriver URL."""
@@ -168,116 +183,162 @@ class WebView:
             self.wait_until_locator_visible(locator=locator)
         return self.webdriver.find_elements(*locator)
 
-    def wait_until_url_contains(self, url: str):
+    def wait_until_url_contains(
+        self,
+        url: str,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until browser's url contains input url.
 
+        By default, method waits for `self.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.url_contains(url),
             message=(
-                f"Url doesn't contain `{url}` in {self.wait_timeout} seconds! "
-                f"The current URL is `{self.current_url}`."
+                f"Url doesn't contain `{url}` in {wait._timeout} "
+                f"seconds! The current URL is `{self.current_url}`."
             ),
         )
 
-    def wait_until_url_not_contains(self, url: str):
+    def wait_until_url_not_contains(
+        self,
+        url: str,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until browser's url doesn't not contains input url.
 
+        By default, method waits for `self.wait_timeout` seconds.
+        If you need to change timeout, you can specify it in `timeout`
+        argument.
+
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=waits_conditions.url_not_matches(url),
             message=(
-                f"Url does contain `{url}` in {self.wait_timeout} seconds! "
+                f"Url does contain `{url}` in {wait._timeout} seconds! "
                 f"The current URL is `{self.current_url}`."
             ),
         )
 
-    def wait_until_url_changes(self, url: str | None = None):
+    def wait_until_url_changes(
+        self,
+        url: str | None = None,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until url changes.
 
         Args:
             url: Browser URL which should be changed. If the argument is not
                 input, will be used `self.current_url`.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
         url = url or self.current_url
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.url_changes(url),
             message=(
-                f"Url didn't changed from {url} in {self.wait_timeout} "
+                f"Url didn't changed from {url} in {wait._timeout} "
                 f"seconds! The current URL is `{self.current_url}`."
             ),
         )
 
-    def wait_until_locator_visible(self, locator: locators.Locator):
+    def wait_until_locator_visible(
+        self,
+        locator: locators.Locator,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until element matching locator becomes visible.
 
         Args:
             locator: Instance of a class to locate the element in the browser.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.visibility_of_element_located(
                 locator=(locator.by, locator.query),
             ),
             message=(
-                f"Unable to locate {locator} in {self.wait_timeout} seconds!"
+                f"Unable to locate {locator} in {wait._timeout} seconds!"
             ),
         )
 
-    def wait_until_locator_invisible(self, locator: locators.Locator):
+    def wait_until_locator_invisible(
+        self,
+        locator: locators.Locator,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until element matching locator becomes invisible.
 
         Args:
             locator: Instance of a class to locate the element in the browser.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.invisibility_of_element_located(
                 locator=(locator.by, locator.query),
             ),
             message=(
-                f"{locator} is still visible in {self.wait_timeout} seconds!"
+                f"{locator} is still visible in {wait._timeout} seconds!"
             ),
         )
 
-    def wait_until_clickable(self, locator: locators.Locator):
+    def wait_until_clickable(
+        self,
+        locator: locators.Locator,
+        timeout: float | None = None,
+    ) -> None:
         """Wait until element matching locator becomes clickable.
 
         Args:
             locator: Instance of a class to locate the element in the browser.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.element_to_be_clickable(
                 mark=(locator.by, locator.query),
             ),
             message=(
-                f"{locator} isn't clickable after {self.wait_timeout} seconds!"
+                f"{locator} isn't clickable after {wait._timeout} seconds!"
             ),
         )
 
@@ -285,25 +346,29 @@ class WebView:
         self,
         text: str,
         locator: locators.Locator,
-    ):
+        timeout: float | None = None,
+    ) -> None:
         """Wait until text is present in the specified element by locator.
 
         Args:
             locator: Instance of a class to locate the element in the browser.
             text: Text that should be presented in element.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=expected_conditions.text_to_be_present_in_element(
                 locator=(locator.by, locator.query),
                 text_=text,
             ),
             message=(
-                f"{locator} doesn't have `{text}` after {self.wait_timeout} "
+                f"{locator} doesn't have `{text}` after {wait._timeout} "
                 "seconds!"
             ),
         )
@@ -311,22 +376,26 @@ class WebView:
     def wait_until_not_exists_in_dom(
         self,
         element: PomcornElement[locators.TLocator] | locators.TLocator,
+        timeout: float | None = None,
     ):
         """Wait until element ceases to exist in DOM.
 
         Args:
             element: Instance of a class to locate the element in the browser
                 or instance of element.
+            timeout: Number of seconds to wait until timing out. By default,
+                method waits for `self.wait_timeout` seconds.
 
         Raises:
-            TimeoutException: If after `self.wait_timeout` seconds the wait
+            TimeoutException: If after `self.wait._timeout` seconds the wait
                 has not ended.
 
         """
-        self.wait.until(
+        wait = self.get_wait(timeout)
+        wait.until(
             method=waits_conditions.element_not_exists_in_dom(element),
             message=(
-                f"{element} is still exists in DOM after {self.wait_timeout} "
+                f"{element} is still exists in DOM after {wait._timeout} "
                 "seconds!"
             ),
         )

{pomcorn-0.9.3 → pomcorn-0.10.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pomcorn"
-version = "0.9.3"
+version = "0.10.1"
 description = "Base implementation of Page Object Model"
 authors = [
   "Saritasa <pypi@saritasa.com>",