tir-framework 2.14.2__tar.gz → 2.14.4__tar.gz

{tir_framework-2.14.2/tir_framework.egg-info → tir_framework-2.14.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tir_framework
-Version: 2.14.2
+Version: 2.14.4
 Summary: Test Interface Robot
 Home-page: https://github.com/totvs/tir
 Download-URL: https://github.com/totvs/tir

{tir_framework-2.14.2 → tir_framework-2.14.4}/tir/technologies/core/base.py

@@ -232,6 +232,8 @@ class Base(unittest.TestCase):
         except StaleElementReferenceException:
             logger().debug("********Element Stale click*********")
             return False
+        except ElementClickInterceptedException as e:
+            logger().debug(e.msg)
         except Exception as e:
             logger().debug(f"Warning click method Exception: {str(e)}")
             return False
@@ -586,7 +588,14 @@ class Base(unittest.TestCase):
                 tries += 1
 
             if filtered_iframe:
-                self.driver.switch_to.frame(self.find_shadow_element('iframe', filtered_iframe)[0]) if self.webapp_shadowroot() else self.driver.switch_to.frame(filtered_iframe)
+                if self.webapp_shadowroot():
+                    shadow_iframe = self.find_shadow_element('iframe', filtered_iframe)
+                    if shadow_iframe:
+                        self.driver.switch_to.frame(shadow_iframe[0])
+                    else:
+                        self.driver.switch_to.frame(filtered_iframe)
+                else:
+                    self.driver.switch_to.frame(filtered_iframe)
 
 
     def filter_active_iframe(self, iframes):
@@ -1632,7 +1641,7 @@ class Base(unittest.TestCase):
 
         # Filter blocked elements only when WaitProcessing is not in the stack
         # and blocked-container filtering is enabled.
-        if not self.search_stack('WaitProcessing') and self.filter_blocked_containers:
+        if not self.search_stack('WaitProcessing') and not self.search_stack('IfExists') and self.filter_blocked_containers:
             non_blocked_elements = list(filter(lambda x: hasattr(x, 'attr') and 'blocked' not in x.attrs, elements))
 
         if isinstance(non_blocked_elements, list):

{tir_framework-2.14.2 → tir_framework-2.14.4}/tir/technologies/poui_internal.py

@@ -5768,6 +5768,90 @@ class PouiInternal(Base):
 
         self.set_program(program_name, program_desc, module)
 
+    def ensure_load_after_program(self, timeout: int = None) -> None:
+        """
+        [Internal]
+
+        Ensures the routine screen finished loading after ``set_program``.
+
+        After confirming the program there is a slow transition while the
+        elements load. On some routines the po-loading component takes longer
+        than the 15s handled by :func:`_po_loading` to even appear, so relying
+        only on it is not reliable.
+
+        This method loops until one of the *expected* landing screens is rendered
+        (the **browse** grid, a **wizard** dialog or the **parameters** dialog)
+        and no po-loading is active on top of it. While po-loading is present
+        (even if it shows up late) the screen is not considered ready and the
+        method keeps waiting for the transition to finish.
+
+        :param timeout: Maximum time, in seconds, to wait for an expected screen.
+            If ``None``, uses ``config.time_out``. - **Default:** None
+        :type timeout: int
+        :return: None
+        :rtype: None
+
+        Usage:
+
+        >>> self.ensure_load_after_program()
+        >>> self.ensure_load_after_program(timeout=90)
+        """
+
+        if timeout is None:
+            timeout = self.config.time_out
+
+        # CSS selectors that identify each expected landing screen after opening
+        # a routine. Adjust here if a new landing screen needs to be supported.
+        expected_screens = {
+            "browse": ("wa-tgrid, .dict-tgetdados, .dict-tcbrowse, .dict-tgrid, "
+                       ".dict-twbrowse, .dict-tsbrowse, .dict-msbrgetdbase, "
+                       ".dict-brgetddb, .dict-msselbr, thf-grid"),
+            "wizard": "wa-dialog wa-stepper, wa-dialog [class*='wizard'], .twizard",
+            "parameters": ("wa-dialog wa-text-input, wa-dialog .dict-tget, "
+                           ".tmodaldialog .tget"),
+        }
+
+        logger().info("Ensuring the routine screen finished loading...")
+
+        endtime = time.time() + timeout
+        loaded_screen = None
+
+        while time.time() < endtime:
+            # Find which expected screen is currently rendered (if any).
+            loaded_screen = None
+            for screen_name, selector in expected_screens.items():
+                if self.element_exists(term=selector,
+                                       scrap_type=enum.ScrapType.CSS_SELECTOR,
+                                       main_container='body',
+                                       check_error=False):
+                    loaded_screen = screen_name
+                    break
+
+            # Small delay so a late po-loading has time to appear on top of the
+            # screen before we check for it, avoiding a false "ready" result.
+            time.sleep(0.5)
+
+            loading = self.element_exists(term='po-loading',
+                                          scrap_type=enum.ScrapType.CSS_SELECTOR,
+                                          main_container='body',
+                                          check_error=False)
+
+            # Ready only when an expected screen is rendered and nothing is
+            # loading on top of it. While po-loading is present (even if it shows
+            # up late) we keep waiting for the transition to finish.
+            if loaded_screen and not loading:
+                break
+
+            loaded_screen = None
+            time.sleep(1)
+
+        if loaded_screen:
+            logger().info(f"Expected screen loaded: '{loaded_screen}'.")
+        else:
+            logger().warning("None of the expected screens (browse, wizard, "
+                             "parameters) finished loading within the timeout of "
+                             f"{timeout}s.")
+
     def set_program(self, program_name: str = "", program_desc: str = "", module: str = ""):
         
         self.escape_to_main_menu()
@@ -5844,8 +5928,8 @@ class PouiInternal(Base):
             self.log_error(message)
             message = 'setUpClass - ' + message if self.log.get_testcase_stack() == 'setUpClass' else message
             self.assertTrue(False, message)
-
-        self._po_loading()
+        
+        self.ensure_load_after_program()
 
         if not program_name in self.closed_user_guide_routines:
             closed_user_guide = self._close_user_guide()

{tir_framework-2.14.2 → tir_framework-2.14.4}/tir/technologies/webapp_internal.py

@@ -1968,6 +1968,7 @@ class WebappInternal(Base):
         except Exception as e:
             logger().exception(str(e))
 
+
     def escape_to_main_menu(self):
         """[Internal]
 
@@ -1997,6 +1998,7 @@ class WebappInternal(Base):
             logger().debug(f'wa-dialog layers: {container_layers}')
 
         if not success:
+            self.restart_counter += 1
             self.log_error('Home screen not found!')     
         
         # wait trasitions between screens to avoid errors in layers number
@@ -4862,6 +4864,68 @@ class WebappInternal(Base):
                 logger().warning(f"Warning SetLateralMenu click last item method exception: {str(e)} ")
 
 
+    def get_shadowroot_button(self, button, term_button, position, check_error=True):
+        """
+        [Internal]
+
+        Captures the button element inside a shadowroot container.
+
+        :param button: Button caption to be located.
+        :type button: str
+        :param term_button: CSS selector used to locate the button candidates.
+        :type term_button: str
+        :param position: Index of the button among the filtered candidates.
+        :type position: int
+        :param check_error: Whether errors should be checked while waiting. - **Default:** True
+        :type check_error: bool
+
+        :return: The located button element (Tag or Selenium element) or None if not found.
+
+        Usage:
+
+        >>> next_button = self.get_shadowroot_button(button, term_button, position, check_error)
+        """
+        regex = r"(<[^>]*>)?"
+        next_button = None
+        filtered_buttons = []
+
+        self.wait_element_timeout(term=button, scrap_type=enum.ScrapType.MIXED, optional_term=term_button, timeout=10, step=0.1, check_error=check_error)
+        self.containers_selectors["GetCurrentContainer"] = "wa-dialog, wa-message-box,.tmodaldialog, body"
+        container = self.get_current_container()
+        button_candidates = container.select(term_button)
+
+        if button_candidates:
+            filtered_buttons = list(filter(lambda x: hasattr(x, 'caption') and button.lower() in re.sub(regex, '', x['caption'].lower()) and self.element_is_displayed(x), button_candidates))
+
+            if not filtered_buttons:
+                filtered_buttons = self.return_soup_by_selenium(elements=button_candidates, term=button, selectors='label, span')
+        else:
+            footer = self.execute_js_selector('footer', self.soup_to_selenium(container), get_all=False)
+            if footer:
+                footer_buttons = self.execute_js_selector("wa-button", footer)
+                if not footer_buttons:
+                    footer_buttons = footer.find_elements(By.CSS_SELECTOR, "wa-button")
+                if footer_buttons:
+                    filtered_buttons = list(filter(lambda x: x.text.strip().replace('\n', '') == button.strip().replace(' \n ', ''), footer_buttons))
+
+        # Fallback: botao em foco entre os candidatos
+        if not (filtered_buttons and len(filtered_buttons) - 1 >= position):
+            focus_buttons = list(filter(lambda x: (hasattr(x, 'caption') and button.lower() in re.sub(regex, '', x['caption'].lower())) and 'focus' in x.get('class'), button_candidates))
+            if focus_buttons:
+                filtered_buttons = focus_buttons
+
+        # Fallback: busca ampla via web_scrap
+        if not filtered_buttons:
+            filtered_buttons = self.web_scrap(term=button, scrap_type=enum.ScrapType.MIXED, optional_term="wa-button", main_container=self.containers_selectors["SetButton"])
+
+        if filtered_buttons and len(filtered_buttons) - 1 >= position:
+            parents_actives = list(filter(lambda x: self.filter_active_tabs(x), filtered_buttons))
+            if parents_actives:
+                filtered_buttons = parents_actives
+            next_button = filtered_buttons[position]
+
+        return next_button
+
     def SetButton(self, button, sub_item="", position=1, check_error=True):
         """
         Method that clicks on a button on the screen.
@@ -4897,7 +4961,10 @@ class WebappInternal(Base):
         """
         logger().info(f"Clicking on {button}")
 
-        initial_program = ['sigaadv', 'sigamdi']
+        # Only the first SetButton usage in the session ignores the
+        # element_is_on_top filter. Subsequent calls keep the normal behavior.
+        first_setbutton_use = not getattr(self, "_setbutton_used", False)
+        self._setbutton_used = True
 
         self.wait_blocker()
 
@@ -4906,13 +4973,16 @@ class WebappInternal(Base):
         else:
             term_button="button, .thbutton"
 
+        id_container = None
         container = self.get_current_container()
         if container  and 'id' in container.attrs:
             id_container = container.attrs['id']
 
         try:
             restore_zoom = False
+            restore_zoom_recaptured = False
             soup_element  = ""
+            id_parent_element = None
             if (button.lower().strip() == "x"):
                 self.set_button_x(position, check_error)
                 return
@@ -4930,57 +5000,31 @@ class WebappInternal(Base):
             success = False
             endtime = time.time() + self.config.time_out
             starttime = time.time()
+            halftime = time.time() + (self.config.time_out / 2)
 
             if self.config.smart_test or self.config.debug_log:
                 logger().debug(f"***System Info*** Before Clicking on button:{button}")
                 system_info()
 
-            regex = r"(<[^>]*>)?"
-            filtered_button = []
             next_button = None
             while(time.time() < endtime and not soup_element):
+                # During the first half of the timeout, also require the element to be the
+                # topmost one at its center point (not intercepted by an overlay). After that,
+                # fall back to the legacy behavior (element_is_displayed only).
+                # The very first SetButton usage always skips this on_top check.
+                enforce_on_top = (not first_setbutton_use) and (time.time() < halftime)
                 if self.webapp_shadowroot():
-                    self.wait_element_timeout(term=button, scrap_type=enum.ScrapType.MIXED, optional_term=term_button, timeout=10, step=0.1, check_error=check_error)
-                    self.containers_selectors["GetCurrentContainer"] = "wa-dialog, wa-message-box,.tmodaldialog, body"
-                    soup = self.get_current_container()
-                    soup_objects = soup.select(term_button)
-
-                    if soup_objects and not filtered_button:
-                        filtered_button = list(filter(lambda x: hasattr(x,'caption') and button.lower() in re.sub(regex,'',x['caption'].lower()) and self.element_is_displayed(x), soup_objects ))
-
-                        if not filtered_button:
-                            filtered_button = self.return_soup_by_selenium(elements=soup_objects, term=button, selectors='label, span')
-
-                    if self.webapp_shadowroot():
-                        if not soup_objects:
-                            footer = self.execute_js_selector('footer', self.soup_to_selenium(soup), get_all=False)
-                            if footer:
-                                buttons = self.execute_js_selector("wa-button", footer)
-                                if not buttons:
-                                    buttons = footer.find_elements(By.CSS_SELECTOR, "wa-button")
-                                if buttons:
-                                    filtered_button = list(filter(lambda x: x.text.strip().replace('\n', '') == button.strip().replace(' \n ', ''), buttons))
-
-                    if filtered_button and len(filtered_button) - 1 >= position:
-                        parents_actives = list(filter(lambda x: self.filter_active_tabs(x), filtered_button ))
-                        if parents_actives:
-                            filtered_button = parents_actives
-                        next_button = filtered_button[position]
-                    else:
-                        filtered_button = list(filter(lambda x: (hasattr(x,'caption') and button.lower() in re.sub(regex,'',x['caption'].lower())) and 'focus' in x.get('class'), soup_objects ))
-
-                    if not filtered_button:
-                        filtered_button = self.web_scrap(term=button, scrap_type=enum.ScrapType.MIXED, optional_term="wa-button", main_container = self.containers_selectors["SetButton"])
+                    next_button = self.get_shadowroot_button(button, term_button, position, check_error)
 
                     if next_button:
                         id_parent_element = next_button['id'] if hasattr(next_button, 'id') and type(next_button) == Tag else None
                         soup_element = self.soup_to_selenium(next_button) if type(next_button) == Tag else next_button
                         self.scroll_to_element(soup_element)
-                        soup_element = soup_element if self.element_is_displayed(soup_element) else None
+                        soup_element = soup_element if self.element_is_displayed(soup_element) and (not enforce_on_top or self.element_is_on_top(soup_element)) else None
                         if soup_element == None:
                             bodySoup = self.get_current_DOM().select('body')
                             self.driver.execute_script("arguments[0].style.cssText+='transform: scale(0.8)';", self.soup_to_selenium(bodySoup[0]))
-                            soup_element = soup_element if self.element_is_displayed(soup_element) else None
+                            soup_element = soup_element if self.element_is_displayed(soup_element) and (not enforce_on_top or self.element_is_on_top(soup_element)) else None
                             restore_zoom = True
 
                 else:
@@ -5038,6 +5082,7 @@ class WebappInternal(Base):
 
                 button_element_id = None
                 button_element_id = soup_element.get_attribute('id') or 'unknow'
+                current_clicked_element = soup_element() if callable(soup_element) else soup_element
 
                 rows_box_state_before = []
                 rows = []
@@ -5056,46 +5101,90 @@ class WebappInternal(Base):
                 initial_layers = self.check_layers(".tmodaldialog, wa-dialog, wa-message-box, .ui-dialog")
                 popup_before = self.check_layers(".tmenupopupitem, wa-menu-popup")
 
-                # Configurações de retry (fixas, sem novos parâmetros)
-                max_click_attempts = 3
                 click_attempt = 0
                 click_verified = False
+                recaptured = False
+                # Primeira metade do time_out para a captura inicial; se o clique não for
+                # verificado até aqui, recaptura o botão (container já atualizado após a
+                # transição) e usa a metade restante.
+                half_time = starttime + (self.config.time_out / 2)
+                while not click_verified and ( time.time() < endtime):
+                    # Recaptura única, no meio do time_out, quando o clique ainda não foi
+                    # verificado — evita reutilizar um soup_element obsoleto capturado da
+                    # tela anterior durante uma transição.
+                    if not recaptured and time.time() >= half_time:
+                        logger().debug(
+                            f"  [RECAPTURE] Click on '{button}' not verified within first half of time_out; "
+                            f"recapturing element (container may have changed after transition)"
+                        )
+                        new_element, new_restore_zoom = self.recapture_setbutton_element(button, term_button, position, check_error)
+                        if new_element is not None:
+                            soup_element = new_element
+                            restore_zoom_recaptured = new_restore_zoom
+                            try:
+                                button_element_id = soup_element.get_attribute('id') or 'unknow'
+                            except Exception:
+                                button_element_id = 'unknow'
+                            current_clicked_element = soup_element() if callable(soup_element) else soup_element
+                            logger().debug(f"  [RECAPTURE] New element captured (id: {button_element_id})")
+                        else:
+                            logger().warning(f"  [RECAPTURE] Could not recapture '{button}'; keeping previously captured element")
+                        recaptured = True
+
+                        # Rebaseline do estado pré-clique após a transição, para que os
+                        # checks de verificação existentes comparem contra o estado correto.
+                        container_before_click = self.get_current_container()
+                        if container_before_click and 'id' in container_before_click.attrs:
+                            initial_container_id = container_before_click.attrs['id']
+                        initial_dom_hash = hash(str(self.get_current_DOM()))
+                        skip_focus_retry = True
+                        container_texts_before = self.get_current_container_texts()
+                        df_before, grids_on_screen_before = self.grid_dataframe(grid_number=0, wait=False, check_error=False, current_container=True, throw_error=False)
+                        rows = []
+                        rows_box_state_before = []
+                        if grids_on_screen_before:
+                            rows = self.execute_js_selector('tr', self.soup_to_selenium(grids_on_screen_before))
+                            if rows:
+                                rows_box_state_before = list(map(lambda x: self.get_row_divs_style(x), rows))
+                        initial_layers = self.check_layers(".tmodaldialog, wa-dialog, wa-message-box, .ui-dialog")
+                        popup_before = self.check_layers(".tmenupopupitem, wa-menu-popup")
 
-                while click_attempt < max_click_attempts and not click_verified:
                     click_attempt += 1
-                    current_clicked_element = None
-
-                    logger().debug(f"Click attempt {click_attempt}/{max_click_attempts} on '{button}' (id: {button_element_id} in container: {initial_container_id})")
 
-                    if self.webapp_shadowroot():
-                        self.scroll_to_element(soup_element)
-                        self.set_element_focus(soup_element)
-                        current_clicked_element = soup_element
-
-                        # Small delay to ensure stability (avoids clicking during transitions)
-                        time.sleep(0.5)
-
-                        if click_attempt == 1:
-                            self.send_action(action=self.click, element=lambda: soup_element)
-                        elif click_attempt == 2:
-                            logger().debug("  |-- Using ActionChains for greater robustness")
-                            self.click(soup_element, click_type=enum.ClickType.ACTIONCHAINS)
-                        else:
-                            logger().debug("  |-- Using JavaScript click as last resort")
-                            self.click(soup_element, click_type=enum.ClickType.JS)
+                    logger().debug(
+                        f"Click attempt {click_attempt} (recaptured={recaptured}) "
+                        f"on '{button}' (id: {button_element_id} in container: {initial_container_id})"
+                    )
 
-                        if button.lower() == self.language.other_actions.lower():
-                            popup_item = lambda: self.wait_element_timeout(term=".tmenupopupitem, wa-menu-popup", scrap_type=enum.ScrapType.CSS_SELECTOR, main_container="body", check_error=False)
-                            while time.time() < endtime and not popup_item():
-                                self.click(soup_element)
+                    self.scroll_to_element(soup_element)
+                    self.set_element_focus(soup_element)
 
-                        if restore_zoom:
-                            bodySoup = self.get_current_DOM().select('body')
-                            self.driver.execute_script("arguments[0].style.cssText+='transform: scale(1)';", self.soup_to_selenium(bodySoup[0]))
-                            soup_element = soup_element if self.element_is_displayed(soup_element) else None
+                    # Small delay to ensure stability (avoids clicking during transitions)
+                    time.sleep(0.5)
 
-                    if current_clicked_element is not None:
-                        self.wait_element_is_not_focused(lambda: current_clicked_element)
+                    # O send_action já cicla internamente entre JS, ActionChains e
+                    # Selenium, então uma única chamada cobre as técnicas de clique.
+                    # Limitamos o tempo para que o controle retorne a este laço e a
+                    # verificação/recaptura possam atuar: antes da recaptura, até o
+                    # half_time; depois, até o endtime restante (piso mínimo para
+                    # permitir ao menos um ciclo completo de tipos de clique).
+                    if not recaptured:
+                        send_action_timeout = half_time - time.time()
+                    else:
+                        send_action_timeout = endtime - time.time()
+                    if send_action_timeout < 10:
+                        send_action_timeout = 10
+                    self.send_action(action=self.click, element=lambda: soup_element, timeout=send_action_timeout)
+
+                    if button.lower() == self.language.other_actions.lower():
+                        popup_item = lambda: self.wait_element_timeout(term=".tmenupopupitem, wa-menu-popup", scrap_type=enum.ScrapType.CSS_SELECTOR, main_container="body", check_error=False)
+                        while time.time() < endtime and not popup_item():
+                            self.click(soup_element)
+
+                    if restore_zoom or restore_zoom_recaptured:
+                        bodySoup = self.get_current_DOM().select('body')
+                        self.driver.execute_script("arguments[0].style.cssText+='transform: scale(1)';", self.soup_to_selenium(bodySoup[0]))
+                        soup_element = soup_element if self.element_is_displayed(soup_element) else None
 
                     # Verification: waits up to 3s to detect click effect
                     verification_timeout = time.time() + 3
@@ -5204,7 +5293,7 @@ class WebappInternal(Base):
                         except Exception:
                             pass
 
-                    if not click_verified and click_attempt < max_click_attempts:
+                    if not click_verified:
                         logger().warning(f"  [WARN] Click on '{button}' had no detectable effect on attempt {click_attempt}")
                         time.sleep(0.5)
 
@@ -5213,7 +5302,7 @@ class WebappInternal(Base):
                 logger().debug(f"Container after click '{button}': {current_container_id}")
 
                 if not click_verified:
-                    logger().warning(f"  [WARN] Click on '{button}' may not have been effective after {max_click_attempts} attempts. Continuing execution...")
+                    logger().warning(f"  [WARN] Click on '{button}' may not have been effective after {click_attempt} attempts (recaptured={recaptured}). Continuing execution...")
 
             if sub_item and ',' not in sub_item:
                 logger().info(f"Clicking on {sub_item}")
@@ -5317,6 +5406,54 @@ class WebappInternal(Base):
         self.reset_container_position()
 
 
+    def recapture_setbutton_element(self, button, term_button, position, check_error=True):
+        """
+        [Internal]
+
+        Re-captures the SetButton target element using the same capture logic as the
+        initial capture in :meth:`SetButton` (respecting ``webapp_shadowroot()``,
+        ``restore_zoom``, ``position`` and ``element_is_displayed`` filtering, with the
+        fallback without ``filter_blocked_containers``).
+
+        This is used by ``SetButton`` when the initial single capture may have grabbed a
+        stale element from the previous container during a screen transition. After the
+        transition completes the container is already updated, so recapturing returns the
+        correct element.
+
+        :return: Tuple ``(soup_element, restore_zoom)``. ``soup_element`` is a Selenium
+                 element (or ``None`` when not found) and ``restore_zoom`` indicates that a
+                 zoom-out was applied to make the element visible.
+        :rtype: tuple
+        """
+        soup_element = None
+        restore_zoom = False
+        try:
+            if self.webapp_shadowroot():
+                next_button = self.get_shadowroot_button(button, term_button, position, check_error)
+                if next_button:
+                    soup_element = self.soup_to_selenium(next_button) if type(next_button) == Tag else next_button
+                    if soup_element is not None:
+                        self.scroll_to_element(soup_element)
+                        soup_element = soup_element if self.element_is_displayed(soup_element) else None
+                        if soup_element is None and next_button is not None:
+                            bodySoup = self.get_current_DOM().select('body')
+                            self.driver.execute_script("arguments[0].style.cssText+='transform: scale(0.8)';", self.soup_to_selenium(bodySoup[0]))
+                            soup_element = self.soup_to_selenium(next_button) if type(next_button) == Tag else next_button
+                            soup_element = soup_element if self.element_is_displayed(soup_element) else None
+                            restore_zoom = True
+            else:
+                soup_objects = self.web_scrap(term=button, scrap_type=enum.ScrapType.MIXED, optional_term="button, .thbutton", main_container=self.containers_selectors["SetButton"], check_error=check_error)
+                if isinstance(soup_objects, list):
+                    soup_objects = list(filter(lambda x: self.element_is_displayed(x), soup_objects))
+                if soup_objects and len(soup_objects) - 1 >= position:
+                    self.wait_until_to(expected_condition="element_to_be_clickable", element=soup_objects[position], locator=By.XPATH, timeout=True)
+                    soup_element = self.soup_to_selenium(soup_objects[position])
+        except Exception as e:
+            logger().debug(f"Recapture of button '{button}' failed: {e}")
+            soup_element = None
+        return soup_element, restore_zoom
+
+
     def get_current_container_texts(self):
         """This method returns a list of all texts from current container descendents
         """
@@ -7409,7 +7546,7 @@ class WebappInternal(Base):
                             cell_filled = self.select_combo(selenium_input(), user_value)
                             time.sleep(1)
                             # if modal opened close it
-                            if current_layers() > initial_layers:
+                            if current_layers() == initial_layers + 1:
                                 self.send_keys(selenium_column, Keys.TAB)
                         else:
                             if cell_opened:
@@ -8706,22 +8843,6 @@ class WebappInternal(Base):
         while( element_selenium and time.time() < endtime and self.switch_to_active_element() != element_selenium() ):
             time.sleep(step)
 
-    def wait_element_is_not_focused(self, element_selenium = None, time_out = 5, step = 0.1):
-        """
-        [Internal]
-
-        Waits until the element loses focus.
-
-        :param element_selenium: Lambda or callable returning the Selenium element to check.
-        :param time_out: Maximum time in seconds to wait. - **Default:** 5
-        :type time_out: float
-        :param step: Time in seconds between each check. - **Default:** 0.1
-        :type step: float
-        """
-        endtime = time.time() + time_out
-        while( element_selenium and time.time() < endtime and self.switch_to_active_element() == element_selenium() ):
-            time.sleep(step)
-
     def switch_to_active_element(self):
         """
         [Internal]
@@ -10845,20 +10966,59 @@ class WebappInternal(Base):
         """
         [Internal]
 
+        """
+        try:
+            if type(element) == Tag:
+                element_selenium = self.soup_to_selenium(element, twebview)
+            else:
+                element_selenium = element
+
+            if isinstance(element, list):
+                call_stack = list(filter(lambda x: 'webapp_internal.py' == x.filename.split(self.replace_slash('\\'))[-1], inspect.stack()))
+                for n in call_stack: logger().debug(f'element_is_displayed Error: {str(n.function)}')
+                element_selenium = next(iter(element),None)
+
+            if element_selenium:
+                return element_selenium.is_displayed()
+            else:
+                return False
+        except Exception as e:
+            logger().debug(f'element_is_displayed exception: {str(e)}')
+            return False
+
+
+    def element_is_on_top(self, element=None, twebview=False):
+        """
+        [Internal]
+
+        Checks whether the element is actually the topmost element at its center
+        point, i.e. it is not covered/intercepted by another element (which would
+        cause an ElementClickInterceptedException). Uses document.elementFromPoint
+        via JavaScript, since is_displayed() may return false positives.
         """
         if type(element) == Tag:
             element_selenium = self.soup_to_selenium(element, twebview)
+        elif isinstance(element, list):
+            element_selenium = next(iter(element), None)
         else:
             element_selenium = element
 
-        if isinstance(element, list):
-            call_stack = list(filter(lambda x: 'webapp_internal.py' == x.filename.split(self.replace_slash('\\'))[-1], inspect.stack()))
-            for n in call_stack: logger().debug(f'element_is_displayed Error: {str(n.function)}')
-            element_selenium = next(iter(element),None)
+        if not element_selenium:
+            return False
 
-        if element_selenium:
-            return element_selenium.is_displayed()
-        else:
+        try:
+            is_on_top = bool(self.driver.execute_script("""
+                const el = arguments[0];
+                if (!el) return false;
+                const r = el.getBoundingClientRect();
+                if (r.width === 0 || r.height === 0) return false;
+                const topo = document.elementFromPoint(r.left + r.width/2, r.top + r.height/2);
+                return topo === el || el.contains(topo);
+            """, element_selenium))
+            logger().debug(f"element_is_on_top return: {is_on_top}")
+            return is_on_top
+        except Exception as e:
+            logger().debug(f"element_is_on_top Error: {str(e)}")
             return False
 
 
@@ -11650,7 +11810,7 @@ class WebappInternal(Base):
         else:
             self.log_error("Doesn't contain that key in json object")
 
-    def send_action(self, action = None, element = None, value = None, right_click=False, click_type=None, wait_change=True):
+    def send_action(self, action = None, element = None, value = None, right_click=False, click_type=None, wait_change=True, timeout=None):
         """
 
         Sends an action to element and compare it object state change.
@@ -11661,6 +11821,12 @@ class WebappInternal(Base):
         :param right_click: True if you want a right click
         :param click_type: ClickType enum. 1-3 types- **Default:** None
         :type click_type: int
+        :param timeout: Optional upper bound (in seconds) for the internal retry loop.
+                        When ``None`` (default) the full ``self.config.time_out`` is used,
+                        preserving the original behavior. Callers such as ``SetButton`` pass
+                        a bounded value so control returns to their own retry/recapture loop
+                        instead of blocking here for the entire ``time_out``.
+        :type timeout: float
         :return: True if there was a change in the object
         """
 
@@ -11699,7 +11865,8 @@ class WebappInternal(Base):
 
         click_type = 1 if not main_click_type else click_type
 
-        endtime = time.time() + self.config.time_out
+        action_timeout = timeout if timeout is not None else self.config.time_out
+        endtime = time.time() + action_timeout
         try:
             while ((time.time() < endtime) and not check_changed()):
                 logger().debug(f"Trying to send action")
@@ -11716,7 +11883,7 @@ class WebappInternal(Base):
                     action(click_type=enum.ClickType(click_type), element=element())
                 elif action:
                     action()
-                    
+
                 time.sleep(1)
 
                 if soup_select:

tir_framework-2.14.4/tir/version.py

@@ -0,0 +1 @@
+__version__ = '2.14.4'

{tir_framework-2.14.2 → tir_framework-2.14.4/tir_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tir_framework
-Version: 2.14.2
+Version: 2.14.4
 Summary: Test Interface Robot
 Home-page: https://github.com/totvs/tir
 Download-URL: https://github.com/totvs/tir

tir_framework-2.14.2/tir/version.py

@@ -1 +0,0 @@
-__version__ = '2.14.2'