csc-cia-stne 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

csc_cia_stne/utilitarios/functions/func_get_secret.py

@@ -32,35 +32,35 @@ def get_secret(name: str, maestro: Optional[BotMaestroSDK] = None, activity_labe
         # verifica na pasta ./secrets
         if os.path.exists(f"./secrets/{name}"):
 
-            with open(f"./secrets/{name}",'r') as secret_file:
+            with open(f"./secrets/{name}",'r', encoding="utf-8") as secret_file:
         
                 secret = secret_file.read()
 
         # verifica na pasta ./.secrets
         elif os.path.exists(f"./.secrets/{name}"):
 
-            with open(f"./.secrets/{name}",'r') as secret_file:
+            with open(f"./.secrets/{name}",'r', encoding="utf-8") as secret_file:
         
                 secret = secret_file.read()
 
         # verifica na pasta ./private
         elif os.path.exists(f"./private/{name}"):
 
-            with open(f"./private/{name}",'r') as secret_file:
+            with open(f"./private/{name}",'r', encoding="utf-8") as secret_file:
         
                 secret = secret_file.read()
 
         # verifica na pasta ./.private
         elif os.path.exists(f"./.private/{name}"):
 
-            with open(f"./.private/{name}",'r') as secret_file:
+            with open(f"./.private/{name}",'r', encoding="utf-8") as secret_file:
         
                 secret = secret_file.read()
 
         # verifica na pasta /secrets
         elif os.path.exists(f"/secrets/{name}"):
 
-            with open(f"/secrets/{name}",'r') as secret_file:
+            with open(f"/secrets/{name}",'r', encoding="utf-8") as secret_file:
         
                 secret = secret_file.read()
 

csc_cia_stne/utilitarios/web_screen/__init__.py

@@ -0,0 +1,2 @@
+from .web_screen_selenium import WebScreenSelenium
+from .web_screen_botcity import WebScreenBotCity

csc_cia_stne/utilitarios/web_screen/web_screen_abstract.py

@@ -0,0 +1,84 @@
+from abc import ABC, abstractmethod
+
+
+class WebScreenAbstract(ABC):
+    """
+    Classe abstrata que define a interface para interações com a tela web.
+    Métodos Abstratos:
+        configuracao_inicial():
+            Configura o ambiente inicial para interações com a tela web.
+        click_on_screen(target: str, timeout: int = 10):
+            Clica em um elemento na tela web.
+        input_value(target: str, value: str, clear: bool = True):
+            Insere um valor em um campo de entrada na tela web.
+        select_value(target: str, value: str):
+            Seleciona um valor em um campo de seleção na tela web.
+    """
+
+    @abstractmethod
+    def select_one_element(
+        self,
+        target: str,
+        time: int = 15,
+        webdrive_type: str = "visibilidade_do_elemento",
+    ):
+        """
+        Seleciona um único elemento na página da web com base no alvo especificado.
+
+        Args:
+            target (str): O seletor ou identificador do elemento a ser selecionado.
+            time (int, opcional): O tempo máximo (em segundos) para aguardar o elemento estar disponível.
+                O padrão é 15 segundos.
+            webdrive_type (str, opcional): O tipo de condição de espera para o elemento.
+                Pode ser, por exemplo, "visibilidade_do_elemento". O padrão é "visibilidade_do_elemento".
+
+        Raises:
+            NotImplementedError: Indica que o método ainda não foi implementado.
+        """
+        raise NotImplementedError("Método 'select_element' ainda não implementado.")
+
+    @abstractmethod
+    def select_elements(
+        self,
+        target: str,
+        time: int = 15,
+    ):
+        """
+        Seleciona elementos na tela com base no alvo especificado.
+
+        Args:
+            target (str): O identificador do elemento ou grupo de elementos a serem selecionados.
+            time (int, opcional): O tempo máximo, em segundos, para aguardar a seleção dos elementos.
+                                  O padrão é 15 segundos.
+
+        Raises:
+            NotImplementedError: Exceção levantada indicando que o método ainda não foi implementado.
+        """
+        raise NotImplementedError("Método 'select_elements' ainda não implementado.")
+
+    @abstractmethod
+    def close_tab(self):
+        """
+        Fecha a aba atual do navegador.
+        Este método deve ser implementado para fechar a aba ativa do navegador.
+        """
+        raise NotImplementedError("Método 'close_tab' ainda não implementado.")
+
+    @abstractmethod
+    def get_driver(self):
+        """
+        Retorna o driver da instância atual.
+        Este método deve ser implementado para retornar a instância do driver web utilizado.
+        """
+        raise NotImplementedError("Método 'get_driver' ainda não implementado.")
+
+    @abstractmethod
+    def change_tab(self, tab_index: int):
+        """
+        Altera para a aba especificada pelo índice.
+        Args:
+            tab_index (int): Índice da aba para a qual mudar (0 para a primeira aba).
+        Raises:
+            NotImplementedError: Indica que o método ainda não foi implementado.
+        """
+        raise NotImplementedError("Método 'change_tab' ainda não implementado.")

csc_cia_stne/utilitarios/web_screen/web_screen_botcity.py

@@ -0,0 +1,285 @@
+from selenium.webdriver.common.by import By
+from webdriver_manager.chrome import ChromeDriverManager
+from selenium.common.exceptions import (
+    TimeoutException,
+    WebDriverException,
+    NoSuchElementException,
+)
+
+# Botcity
+from botcity.web import WebBot, Browser
+from botcity.web.util import element_as_select
+from .web_screen_abstract import WebScreenAbstract
+
+
+class WebScreenBotCity(WebScreenAbstract):
+    """
+    Classe que implementa a interface WebScreenAbstract usando BotCity.
+    Métodos:
+        configuracao_inicial():
+            Configura o ambiente inicial para interações com a tela web usando BotCity.
+        click_on_screen(target: str, timeout: int = 10):
+            Clica em um elemento na tela web usando BotCity.
+        input_value(target: str, value: str, clear: bool = True):
+            Insere um valor em um campo de entrada na tela web usando BotCity.
+        select_value(target: str, value: str):
+            Seleciona um valor em um campo de seleção na tela web usando BotCity.
+    """
+
+    def __init__(
+        self,
+        headless: bool = True,
+        disable_gpu: bool = True,
+        no_sandbox: bool = True,
+        timeout: int = 10,
+        security: bool = False,
+    ):
+        """
+        Inicializa a classe com as configurações para o WebBot.
+        Args:
+            headless (bool): Define se o navegador será executado em modo headless (sem interface gráfica).
+                             Padrão é True.
+            disable_gpu (bool): Define se o uso de GPU será desativado no navegador. Padrão é True.
+            no_sandbox (bool): Define se o navegador será executado sem o modo sandbox. Padrão é True.
+            timeout (int): Tempo limite (em segundos) para operações realizadas pelo WebBot. Padrão é 10.
+            security (bool): Define se configurações de segurança adicionais serão aplicadas. Padrão é False.
+        Raises:
+            ValueError: Caso ocorra algum erro durante a inicialização da classe.
+        """
+        self.web_bot = None
+        self.timeout = timeout
+        self.security = security
+        self.screenshot = []
+        try:
+
+            # Criação do drive para botcity
+
+            self.web_bot = WebBot()
+
+            # Configurar o navegador (por exemplo, Chrome)
+            self.web_bot.browser = Browser.CHROME
+
+            self.web_bot.driver_path = ChromeDriverManager().install()
+
+            # Configurar as opções do Chrome
+            self.web_bot.headless = headless
+            self.web_bot.disable_gpu = disable_gpu
+            self.web_bot.no_sandbox = no_sandbox
+
+        except Exception as e:
+            raise ValueError("Erro na inicialização da classe:", e)
+
+    def select_one_element(self, target):
+        """
+        Clica em um elemento na tela identificado pelo seletor fornecido.
+        Args:
+            target (str): O seletor XPATH do elemento a ser clicado.
+            timeout (int, opcional): O tempo máximo (em segundos) para aguardar
+                que o elemento esteja disponível e não esteja obsoleto.
+                O padrão é 10 segundos.
+        Returns:
+            dict: Um dicionário contendo:
+                - "success" (bool): Indica se a operação foi bem-sucedida.
+                - "error" (Exception ou None): A exceção capturada em caso de falha,
+                  ou None se não houver erro.
+                - "details" (None): Reservado para informações adicionais,
+                  atualmente sempre retorna None.
+        Raises:
+            Exception: Qualquer exceção capturada durante a execução será retornada
+            no campo "error" do dicionário de retorno.
+        """
+        try:
+            element_click = self.web_bot.find_element(target, By.XPATH)
+            self.web_bot.wait_for_stale_element(
+                element=element_click, timeout=self.timeout
+            )
+            return {"success": True, "error": None, "element": element_click}
+        except NoSuchElementException:
+            return {
+                "success": False,
+                "error": f"Elemento com o seletor '{target}' não encontrado.",
+            }
+        except TimeoutException:
+            return {
+                "success": False,
+                "error": f"Tempo limite excedido ao tentar localizar o elemento com o seletor '{target}'.",
+            }
+        except Exception as e:
+            return {"success": False, "error": e}
+
+    def close_tab(self):
+        try:
+            """
+            Fecha a aba atual do navegador.
+            Este método tenta fechar a aba ativa do navegador utilizando o método `close_tab` do WebBot.
+            Caso ocorra algum erro durante o processo, uma exceção será levantada com uma mensagem descritiva.
+            """
+            self.web_bot.close_page()
+            return {"success": True, "error": None}
+        except WebDriverException as e:
+            return {"success": False, "error": f"Erro ao fechar a aba: {e}"}
+        except TimeoutException:
+            return {
+                "success": False,
+                "error": "Tempo limite excedido ao tentar fechar a aba.",
+            }
+        except Exception as e:
+            return {"success": False, "error": f"Erro ao fechar a aba: {e}"}
+
+    def select_elements(self, target):
+        """
+        Clica em um elemento na tela identificado pelo seletor fornecido.
+        Args:
+            target (str): O seletor XPATH do elemento a ser clicado.
+            timeout (int, opcional): O tempo máximo (em segundos) para aguardar
+                que o elemento esteja disponível e não esteja obsoleto.
+                O padrão é 10 segundos.
+        Returns:
+            dict: Um dicionário contendo:
+                - "success" (bool): Indica se a operação foi bem-sucedida.
+                - "error" (Exception ou None): A exceção capturada em caso de falha,
+                  ou None se não houver erro.
+                - "details" (None): Reservado para informações adicionais,
+                  atualmente sempre retorna None.
+        Raises:
+            Exception: Qualquer exceção capturada durante a execução será retornada
+            no campo "error" do dicionário de retorno.
+        """
+        try:
+            element_click = self.web_bot.find_elements(target, By.XPATH)
+            self.web_bot.wait_for_stale_element(
+                element=element_click, timeout=self.timeout
+            )
+            return {"success": True, "error": None, "element": element_click}
+        except NoSuchElementException:
+            return {
+                "success": False,
+                "error": f"Elemento com o seletor '{target}' não encontrado.",
+            }
+        except TimeoutException:
+            return {
+                "success": False,
+                "error": f"Tempo limite excedido ao tentar localizar o elemento com o seletor '{target}'.",
+            }
+        except Exception as e:
+            return {"success": False, "error": e}
+
+    def input_value(self, target: str, value: str, clear: bool = True):
+        """
+        Insere um valor em um elemento da página web identificado pelo seletor XPath.
+
+        Args:
+            target (str): O seletor XPath do elemento onde o valor será inserido.
+            value (str): O valor a ser inserido no elemento.
+            clear (bool, opcional): Indica se o campo deve ser limpo antes de inserir o valor.
+                                    O padrão é True.
+
+        Returns:
+            dict: Um dicionário contendo:
+                - "success" (bool): Indica se a operação foi bem-sucedida.
+                - "details" (None): Reservado para informações adicionais (atualmente não utilizado).
+                - "error" (str ou Exception): Mensagem de erro ou exceção, caso ocorra.
+
+        Exceções Tratadas:
+            - NoSuchElementException: Lançada quando o elemento não é encontrado.
+            - TimeoutException: Lançada quando o tempo limite para localizar o elemento é excedido.
+            - Exception: Captura qualquer outra exceção que possa ocorrer.
+
+        """
+        try:
+            element_input = self.web_bot.find_element(target, By.XPATH)
+            self.web_bot.wait_for_stale_element(
+                element=element_input, timeout=self.timeout
+            )
+            if clear:
+                element_input.clear()
+            element_input.send_keys(value)
+            return {"success": True, "error": None}
+        except NoSuchElementException:
+            return {
+                "success": False,
+                "details": None,
+                "error": f"Elemento com o seletor '{target}' não encontrado.",
+            }
+        except TimeoutException:
+            return {
+                "success": False,
+                "details": None,
+                "error": f"Tempo limite excedido ao tentar localizar o elemento com o seletor '{target}'.",
+            }
+        except Exception as e:
+            return {"success": False, "details": None, "error": e}
+
+    def select_value(self, target: str, value: str):
+        """
+        Seleciona um valor em um elemento do tipo <select> na página da web.
+
+        Args:
+            target (str): O seletor XPath do elemento <select> que será manipulado.
+            value (str): O valor que será selecionado no elemento <select>.
+
+        Returns:
+            dict: Um dicionário contendo:
+                - "success" (bool): Indica se a operação foi bem-sucedida.
+                - "details" (None): Reservado para informações adicionais (atualmente não utilizado).
+                - "error" (str ou Exception): Mensagem de erro em caso de falha ou a exceção capturada.
+
+        Exceções Tratadas:
+            - NoSuchElementException: Lançada quando o elemento com o seletor especificado não é encontrado.
+            - TimeoutException: Lançada quando o tempo limite para localizar o elemento é excedido.
+            - Exception: Captura qualquer outra exceção inesperada.
+
+        Observação:
+            Certifique-se de que o elemento identificado pelo seletor seja um elemento <select> válido.
+        """
+        try:
+            element_select = self.web_bot.find_element(target, By.XPATH)
+            self.web_bot.wait_for_stale_element(
+                element=element_select, timeout=self.timeout
+            )
+            element_select = element_as_select(element_select)
+            element_select.select_by_value(value)
+            return {"success": True, "error": None}
+        except NoSuchElementException:
+            return {
+                "success": False,
+                "details": None,
+                "error": f"Elemento com o seletor '{target}' não encontrado.",
+            }
+        except TimeoutException:
+            return {
+                "success": False,
+                "details": None,
+                "error": f"Tempo limite excedido ao tentar localizar o elemento com o seletor '{target}'.",
+            }
+        except Exception as e:
+            return {"success": False, "details": None, "error": e}
+
+    def get_driver(self):
+        """
+        Retorna a instância do driver web associada ao bot.
+
+        Returns:
+            WebDriver: A instância do driver web utilizada pelo bot.
+        """
+        return self.web_bot
+
+    def change_tab(self, tab_index: int):
+        try:
+            """
+            Altera para a aba especificada pelo índice.
+            Args:
+                tab_index (int): Índice da aba para a qual mudar (0 para a primeira aba).
+            Raises:
+                IndexError: Se o índice fornecido não corresponder a uma aba existente.
+                Exception: Para outros erros que possam ocorrer ao tentar mudar de aba.
+            """
+            self.web_bot.activate_tab(tab_index)
+            return {"success": True, "error": None}
+        except IndexError:
+            return {
+                "success": False,
+                "error": f"A aba com índice {tab_index} não existe.",
+            }
+        except Exception as e:
+            return {"success": False, "error": f"Erro ao mudar de aba: {e}"}

csc_cia_stne/utilitarios/web_screen/web_screen_selenium.py

@@ -0,0 +1,350 @@
+import time
+
+# Selenium
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from webdriver_manager.chrome import ChromeDriverManager
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import (
+    TimeoutException,
+    WebDriverException,
+    NoSuchElementException,
+)
+from selenium.webdriver.chrome.options import Options
+from .web_screen_abstract import WebScreenAbstract
+
+
+class WebScreenSelenium(WebScreenAbstract):
+    """
+    Classe que implementa a interface WebScreenAbstract usando Selenium.
+    Métodos:
+        configuracao_inicial():
+            Configura o ambiente inicial para interações com a tela web usando Selenium.
+        click_on_screen(target: str, timeout: int = 10):
+            Clica em um elemento na tela web usando Selenium.
+        input_value(target: str, value: str, clear: bool = True):
+            Insere um valor em um campo de entrada na tela web usando Selenium.
+        select_value(target: str, value: str):
+            Seleciona um valor em um campo de seleção na tela web usando Selenium.
+    """
+
+    def __init__(
+        self,
+        headless: bool = True,
+        disable_gpu: bool = True,
+        no_sandbox: bool = True,
+        timeout: int = 10,
+        security: bool = False,
+        scale: float = 0.8,
+    ):
+        """
+        Inicializa a classe responsável por configurar e gerenciar o WebDriver do Selenium.
+
+        Args:
+            headless (bool, opcional): Define se o navegador será executado em modo headless (sem interface gráfica).
+                           Padrão é True.
+            disable_gpu (bool, opcional): Define se a GPU será desativada durante a execução do navegador.
+                          Padrão é True.
+            no_sandbox (bool, opcional): Define se o navegador será executado sem o modo sandbox.
+                         Padrão é True.
+            timeout (int, opcional): Tempo limite (em segundos) para operações do WebDriver.
+                         Padrão é 10.
+            security (bool, opcional): Define se configurações adicionais de segurança serão aplicadas.
+                           Padrão é False.
+            scale (float, opcional): Define o fator de escala da interface do navegador.
+                         Deve ser um número positivo. Padrão é 0.8.
+
+        Raises:
+            ValueError: Caso os parâmetros fornecidos sejam inválidos.
+            ModuleNotFoundError: Caso o módulo Selenium não esteja instalado.
+            WebDriverException: Caso ocorra um erro ao inicializar o WebDriver do Selenium.
+            Exception: Para outros erros durante a inicialização da classe.
+        """
+        if not isinstance(scale, (int, float)) or scale <= 0:
+            raise ValueError("O parâmetro 'scale' deve ser um número positivo.")
+        if not isinstance(headless, bool):
+            raise ValueError("O parâmetro 'headless' deve ser um booleano.")
+        if not isinstance(disable_gpu, bool):
+            raise ValueError("O parâmetro 'disable_gpu' deve ser um booleano.")
+        if not isinstance(no_sandbox, bool):
+            raise ValueError("O parâmetro 'no_sandbox' deve ser um booleano.")
+        if not isinstance(timeout, int) or timeout <= 0:
+            raise ValueError(
+                "O parâmetro 'timeout' deve ser um número inteiro positivo."
+            )
+        if not isinstance(security, bool):
+            raise ValueError("O parâmetro 'security' deve ser um booleano.")
+
+        self.driver = None
+        self.timeout = timeout
+        self.security = security
+        self.screenshot = []
+        try:
+
+            chrome_options = Options()
+
+            if headless:
+                chrome_options.add_argument("--headless")
+            if disable_gpu:
+                chrome_options.add_argument("--disable-gpu")
+            if no_sandbox:
+                chrome_options.add_argument("--no-sandbox")
+            chrome_options.add_argument("--disable-popup-blocking")
+            chrome_options.add_argument("--disable-extensions")
+            chrome_options.add_argument("--window-size=1920,1080")
+            chrome_options.add_argument(f"--force-device-scale-factor={scale}")
+
+            chrome_options.add_argument(
+                "user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
+            )
+
+            self.driver = webdriver.Chrome(options=chrome_options)
+            self.driver.maximize_window()
+            self.driver.implicitly_wait(20)
+
+        except ModuleNotFoundError:
+            raise ModuleNotFoundError(
+                "O módulo Selenium não está instalado. Por favor, instale-o usando 'pip install selenium'."
+            )
+        except WebDriverException:
+            raise WebDriverException(
+                "Erro ao inicializar o WebDriver do Selenium. Verifique se o ChromeDriver está instalado e configurado corretamente."
+            )
+        except Exception as e:
+            raise Exception("Erro na inicialização da classe:", e)
+
+    def select_one_element(
+        self,
+        target: str,
+        time: int = 15,
+        webdrive_type: str = "visibilidade_do_elemento",
+    ):
+        """
+        Seleciona um único elemento na página da web com base no XPath fornecido.
+        Args:
+            target (str): O XPath do elemento a ser localizado.
+            time (int, opcional): O tempo máximo (em segundos) para aguardar o elemento.
+                O padrão é 15 segundos.
+            webdrive_type (str, opcional): O tipo de condição de espera para localizar o elemento.
+                Pode ser "elemento_clicavel" para aguardar que o elemento seja clicável ou
+                "visibilidade_do_elemento" para aguardar que o elemento esteja visível.
+                O padrão é "visibilidade_do_elemento".
+        Returns:
+            WebElement: O elemento localizado.
+        Raises:
+            TimeoutError: Se o tempo de espera for excedido e o elemento não for localizado.
+            Exception: Para qualquer outro erro inesperado ao localizar o elemento.
+        """
+        webdrive_map = {
+            "elemento_clicavel": EC.element_to_be_clickable,
+            "visibilidade_do_elemento": EC.visibility_of_element_located,
+        }
+        try:
+            element = WebDriverWait(self.driver, time).until(
+                webdrive_map.get(webdrive_type, EC.visibility_of_element_located)(
+                    (By.XPATH, target)
+                )
+            )
+            return {"success": True, "element": element, "erro": None}
+        except TimeoutException as e:
+            return {"success": False, "element": None, "erro": e}
+        except Exception as e:
+            return {"success": False, "element": None, "erro": e}
+
+    def select_elements(
+        self,
+        target: str,
+        time: int = 15,
+    ):
+        """
+        Seleciona múltiplos elementos na página utilizando um XPath.
+        Args:
+            target (str): O XPath dos elementos a serem localizados.
+            time (int, opcional): O tempo máximo de espera (em segundos) para localizar os elementos.
+                                  O padrão é 15 segundos.
+        Returns:
+            list: Uma lista de elementos Web encontrados pelo XPath.
+        Raises:
+            Exception: Lança uma exceção se ocorrer um erro ao buscar os elementos.
+        """
+        try:
+            element = WebDriverWait(self.driver, time).until(
+                lambda driver: driver.find_elements(By.XPATH, target)
+            )
+            return {"success": True, "elements": element, "erro": None}
+        except Exception as e:
+            return {"success": False, "elements": None, "erro": e}
+
+    def close_tab(self):
+        """
+        Fecha a aba atual do navegador.
+
+        Este método tenta fechar a aba ativa do navegador utilizando o driver Selenium.
+        Caso ocorra algum erro durante o processo, uma exceção será levantada com uma
+        mensagem descritiva.
+
+        Raises:
+            Exception: Caso ocorra um erro ao tentar fechar a aba, uma exceção será
+            levantada contendo detalhes do erro.
+        """
+        try:
+            self.driver.close()
+            return {"success": True, "erro": None, "element": None}
+        except Exception as e:
+            return {"success": False, "erro": e, "element": None}
+
+    def get_driver(self):
+        """
+        Retorna o driver da instância atual.
+
+        Returns:
+            WebDriver: O driver associado a esta instância.
+        """
+        return {"success": True, "erro": None, "driver": self.driver}
+
+    def change_tab(self, tab_index: int):
+        """
+            Args:
+                tab_index (int): Índice da aba para a qual mudar (0 para a primeira aba).
+
+            Raises:
+                IndexError: Se o índice fornecido não corresponder a uma aba existente.
+                Exception: Para outros erros que possam ocorrer ao tentar mudar de aba.
+        Altera para a aba especificada pelo índice.
+        :param tab_index: Índice da aba para a qual mudar (0 para a primeira aba).
+        """
+        try:
+            self.driver.switch_to.window(self.driver.window_handles[tab_index])
+            return {"success": True, "erro": None, "element": None}
+        except IndexError as e:
+            return {"success": False, "erro": e, "element": None}
+        except Exception as e:
+            return {"success": False, "erro": e, "element": None}
+
+    def execute_script(self, script: str, *args):
+        """
+        Executa um script JavaScript na aba atual.
+        :param script: O script JavaScript a ser executado.
+        """
+        try:
+            self.driver.execute_script(script, *args)
+            return {"success": True, "erro": None, "element": None}
+        except Exception as e:
+            return {"success": False, "erro": e, "element": None}
+
+    def scroll_until_element_found(
+        self,
+        target: str,
+        max_scrolls: int = 20,
+        scroll_pause_time: int = 1,
+    ):
+        """
+        Rola a página até que um elemento seja encontrado ou o número máximo de rolagens seja atingido.
+
+        Args:
+            target (str): O XPath do elemento alvo que deve ser encontrado.
+            max_scrolls (int, opcional): O número máximo de rolagens permitidas. Padrão é 20.
+            scroll_pause_time (int, opcional): O tempo de pausa (em segundos) entre cada rolagem. Padrão é 1.
+
+        Returns:
+            WebElement: O elemento encontrado correspondente ao XPath fornecido.
+
+        Raises:
+            Exception: Se o elemento não for encontrado após o número máximo de rolagens.
+        """
+        for _ in range(max_scrolls):
+            try:
+                element = self.driver.find_element(By.XPATH, target)
+                ActionChains(self.driver).move_to_element(element).perform()
+                return {"success": True, "element": element, "erro": None}
+            except NoSuchElementException:
+                self.driver.execute_script("window.scrollBy(0, window.innerHeight);")
+                time.sleep(scroll_pause_time)
+        return {
+            "success": False,
+            "element": None,
+            "erro": f"Elemento com o xpath '{target}' não encontrado após {max_scrolls} rolagens.",
+        }
+
+    def scroll_virtuallist_until_element_found(
+        self,
+        list_target: str,
+        target: str,
+        max_scrolls: int = 20,
+        scroll_pause_time: int = 0.2,
+    ):
+        """
+        Rola uma lista virtual até que um elemento específico seja encontrado.
+        Este método tenta localizar um elemento em uma lista virtual rolando-a para baixo
+        até que o elemento seja encontrado ou até que o número máximo de rolagens seja atingido.
+        Args:
+            list_target (str): O alvo da lista virtual que será rolada.
+            target (str): O XPath do elemento que se deseja localizar.
+            max_scrolls (int, opcional): O número máximo de rolagens permitidas. Padrão é 20.
+            scroll_pause_time (int, opcional): O tempo de pausa (em segundos) entre as rolagens. Padrão é 0.2.
+        Returns:
+            WebElement: O elemento encontrado.
+        Raises:
+            Exception: Se o elemento não for encontrado após o número máximo de rolagens.
+        """
+        for _ in range(max_scrolls):
+            try:
+                element = self.driver.find_element(By.XPATH, target)
+                return {"success": True, "element": element, "erro": None}
+            except NoSuchElementException:
+                for _ in range(10):
+                    list_target.send_keys(Keys.ARROW_DOWN)
+                    time.sleep(0.1)
+                time.sleep(scroll_pause_time)
+        return {
+            "success": False,
+            "erro": f"Elemento com o xpath '{target}' não encontrado após {max_scrolls} rolagens.",
+            "element": None,
+        }
+
+    def refresh_page(self):
+        """
+        Atualiza a página atual no navegador.
+
+        Este método tenta atualizar a página atual utilizando o método `refresh` do driver.
+        Caso ocorra algum erro durante o processo, uma exceção será levantada com uma mensagem
+        descritiva.
+
+        Raises:
+            Exception: Caso ocorra algum erro ao tentar atualizar a página, uma exceção será
+            levantada contendo a mensagem de erro original.
+        """
+        try:
+            self.driver.refresh()
+            return {"success": True, "erro": None, "element": None}
+        except Exception as e:
+            return {"success": False, "erro": e, "element": None}
+
+    def save_screenshot(self, screenshot_path: str):
+        """
+        Captura uma captura de tela da página atual.
+
+        Este método tenta capturar uma captura de tela da página atual utilizando o método `screenshot` do driver.
+        A captura de tela é salva em um arquivo temporário e o caminho do arquivo é retornado.
+
+        Returns:
+            str: O caminho do arquivo onde a captura de tela foi salva.
+
+        Raises:
+            Exception: Caso ocorra algum erro ao capturar a captura de tela, uma exceção será levantada.
+        """
+        if not screenshot_path or not isinstance(screenshot_path, str):
+            return {
+                "success": False,
+                "erro": "O caminho para salvar a captura de tela deve ser uma string não vazia.",
+                "diretorio": None,
+            }
+        try:
+            screenshot_path = f"{screenshot_path}screenshot_{int(time.time())}.png"
+            self.driver.save_screenshot(screenshot_path)
+            return {"success": True, "erro": None, "diretorio": screenshot_path}
+        except Exception as e:
+            return {"success": False, "erro": e, "diretorio": None}

csc_cia_stne/web.py

@@ -1,30 +1,22 @@
-# Selenium
-from selenium import webdriver
-from webdriver_manager.chrome import ChromeDriverManager
-from selenium.webdriver.chrome.service import Service as ChromeService
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.support.ui import Select,WebDriverWait
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support import expected_conditions as EC
-
-# Botcity
-from botcity.web import WebBot, Browser
-from botcity.web.util import element_as_select
-
-# Externa
-import requests
-
 # Validador
 from pydantic import ValidationError
 
 # Validadores de parametros
-from .utilitarios.validations.web_validator import InitParamsValidator,ClickOnScreenValidator,InputValueValidator,SelectValueValidator,VerifyServerValueValidator,NavigateValidator
+from .utilitarios.validations.web_validator import InitParamsValidator
+from .utilitarios.web_screen import WebScreenSelenium, WebScreenBotCity
 
 
-class web_screen():
+class web_screen:
 
-
-    def __init__(self,model:str="selenium",timeout:int=60,headless:bool=True,disable_gpu:bool=True,no_sandbox:bool=True,security:bool=True):
+    def __init__(
+        self,
+        model: str = "selenium",
+        timeout: int = 60,
+        headless: bool = True,
+        disable_gpu: bool = True,
+        no_sandbox: bool = True,
+        security: bool = True,
+    ):
         """
         Inicializa a instância da classe Web.
         Parâmetros:
@@ -37,477 +29,43 @@ class web_screen():
         Raises:
         - ValueError: Se ocorrer um erro na validação dos dados de entrada da inicialização da instância.
         """
-        
+
         self.model = model
         self.timeout = timeout
         self.security = security
-
-        try:
-        
-            InitParamsValidator(model=model,timeout=timeout, headless=headless, disable_gpu=disable_gpu, no_sandbox=no_sandbox, security=security)
-
-        except ValidationError as e:
-        
-            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
-
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                chrome_options = Options()
-
-                if headless:
-                    chrome_options.add_argument('--headless')
-                if disable_gpu:
-                    chrome_options.add_argument('--disable-gpu')
-                if no_sandbox:
-                    chrome_options.add_argument('--no-sandbox')
-
-                # Criação do drive para selenium
-                service = ChromeService(executable_path=ChromeDriverManager().install())
-
-                self.web_bot = webdriver.Chrome(service=service, options=chrome_options)
-            
-            except Exception as e:
-
-                raise ValueError("Erro na inicialização da classe:", e)
-        
-        else:
-
-            try:
-
-                # Criação do drive para botcity
-
-                self.web_bot = WebBot()
-            
-                # Configurar o navegador (por exemplo, Chrome)
-                self.web_bot.browser = Browser.CHROME
-
-                self.web_bot.driver_path = ChromeDriverManager().install()
-
-                # Configurar as opções do Chrome
-                self.web_bot.headless = headless
-                self.web_bot.disable_gpu = disable_gpu
-                self.web_bot.no_sandbox = no_sandbox
-            
-            except Exception as e:
-
-                    raise ValueError("Erro na inicialização da classe:", e)
-
-
-    def get_bot(self):
-        """
-        Retorna o objeto web_bot associado a esta instância.
-        """
-
-        return self.web_bot
-
-
-    def verify_server(self,url:str):
-        """
-        Verifica se o servidor está ativo e acessível.
-        Args:
-            url (str): A URL do servidor a ser verificado.
-        Returns:
-            bool: True se o servidor estiver ativo e acessível, False caso contrário.
-        """
-
-        try:
-
-            VerifyServerValueValidator(url=url)
-
-        except ValidationError as e:
-
-            raise ValueError("Erro na validação dos dados de input:", e.errors())
-
-        try:
-
-            reply = requests.get(url, verify=self.security)
-
-        except:
-
-            return False
-        
-        if reply.status_code == 200:
-
-            return True
-        
-        return False
-
-
-    def navigate(self,url:str):
-        """
-        Navega para a URL especificada.
-        Args:
-            url (str): A URL para navegar.
-        Returns:
-            dict: Um dicionário contendo informações sobre o sucesso da navegação.
-                - 'success' (bool): Indica se a navegação foi bem-sucedida.
-                - 'details' (str): Detalhes adicionais sobre a navegação, caso haja algum erro.
-                - 'error' (Exception): A exceção ocorrida durante a navegação, caso haja algum erro.
-        """
-
-        try:
-
-            NavigateValidator(url=url)
-
-        except ValidationError as e:
-
-            raise ValueError("Erro na validação dos dados de input:", e.errors())
-
-        if not self.verify_server(url):
-
-            return {
-                'success': False,
-                'details': f"Não foi possível acessar o endereço {url}."
-            }
-        
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                self.bot.get(url)
-
-                return {
-                        "success": True,
-                        "error": None
-                    }
-                        
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-
-        else:
-
-            try:
-
-                self.bot.browse(url)
-
-                return {
-                        "success": True,
-                        "error": None
-                    }
-                        
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-
-
-    def click_on_screen(self, target:str):
-        """
-        Clica em um elemento na tela.
-        Parâmetros:
-        - target (str): O elemento alvo a ser clicado.
-        Retorna:
-        Um dicionário com as seguintes chaves:
-        - success (bool): Indica se o clique foi realizado com sucesso.
-        - details (str): Detalhes adicionais em caso de erro.
-        - error (Exception): A exceção ocorrida, se houver.
-        Raises:
-        Nenhum.
-        """
-
-        try:
-        
-            ClickOnScreenValidator(target=target)
-
-        except ValidationError as e:
-        
-            raise ValueError("Erro na validação dos dados de input para o click na tela:", e.errors())
-
-
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                WebDriverWait(self.web_bot, self.timeout).until(EC.element_to_be_clickable((By.XPATH, target))).click()
-
-                return {
-                    "success": True,
-                    "error": None
-                }
-            
-            except EC.NoSuchElementException:
-
-                return {
-                    "success": False,
-                    "details": f"Elemento {target} não encontrado.",
-                    "error": None
-                }
-            
-            except EC.TimeoutException:
-
-                return {
-                    "success": False,
-                    "details": f"O elemento {target} não foi encontrado dentro do tempo definido",
-                    "error": None
-                }
-
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-            
-        else:
-
-            try:
-
-                element_click = self.web_bot.find_element(target, By.XPATH)
-
-                self.web_bot.wait_for_stale_element(
-                    element=element_click,
-                    timeout=self.timeout
-                )
-
-                element_click.click()
-
-                return {
-                    "success": True,
-                    "error": None
-                }
-            
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details": None,
-                    "error": e
-                }
-            
-    
-    def input_value(self, target:str, value, clear:bool=True):
-        """
-        Insere um valor em um elemento de entrada na página web.
-        Parâmetros:
-        - target (str): O XPath do elemento de entrada.
-        - value: O valor a ser inserido no elemento de entrada.
-        - clear (bool): Indica se o elemento de entrada deve ser limpo antes de inserir o valor (padrão: True).
-        Retorna:
-        Um dicionário com as seguintes chaves:
-        - "success" (bool): Indica se a operação foi bem-sucedida.
-        - "details" (str): Detalhes adicionais sobre o resultado da operação.
-        - "error" (Exception): A exceção ocorrida, se houver.
-        """
-
+        self.driver = None
         try:
-        
-            InputValueValidator(target=target,clear=clear)
-
-        except ValidationError as e:
-        
-            raise ValueError("Erro na validação dos dados de input para realizar o input na tela:", e.errors())
-
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                element_input = WebDriverWait(self.web_bot, self.timeout).until(EC.EC.visibility_of_element_located(By.XPATH,target))
-
-                if clear:
-
-                    element_input.clear()
-
-                element_input.send_keys(value)
-
-            except EC.NoSuchElementException:
-
-                return {
-                    "success": False,
-                    "details": f"Elemento {target} não encontrado.",
-                    "error": None
-                }
-            
-            except EC.TimeoutException:
-
-                return {
-                    "success": False,
-                    "details": f"O elemento {target} não foi encontrado dentro do tempo definido",
-                    "error": None
-                }
-
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-            
-        else:
-
-            try:
-
-                element_input = self.web_bot.find_element(target, By.XPATH)
-
-                self.web_bot.wait_for_stale_element(
-                    element=element_input,
-                    timeout=self.timeout
-                )
-
-                if clear:
 
-                    element_input.clear()
-
-                element_input.send_keys(value)
-
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-            
-
-    def select_value(self, target:str, value):
-        """
-        Seleciona um valor em um elemento de seleção (select) na página web.
-        Args:
-            target (str): O seletor XPath do elemento de seleção.
-            value: O valor a ser selecionado.
-        Returns:
-            dict: Um dicionário com as seguintes chaves:
-                - "success" (bool): Indica se a seleção foi bem-sucedida.
-                - "details" (str): Detalhes adicionais sobre o resultado da seleção.
-                - "error" (Exception): A exceção ocorrida, se houver.
-        Raises:
-            ValueError: Se ocorrer um erro na validação dos dados para realizar o select na tela.
-        Note:
-            - Se o modelo for "SELENIUM", o método usará a biblioteca Selenium para realizar a seleção.
-            - Caso contrário, o método usará a biblioteca web_bot para realizar a seleção.
-        """
-
-        try:
-        
-            SelectValueValidator(target=target)
+            InitParamsValidator(
+                model=model,
+                timeout=timeout,
+                headless=headless,
+                disable_gpu=disable_gpu,
+                no_sandbox=no_sandbox,
+                security=security,
+            )
 
         except ValidationError as e:
-        
-            raise ValueError("Erro na validação dos dados para realizar o select na tela:", e.errors())
-
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                element_select = WebDriverWait(self.web_bot, self.timeout).until(EC.element_to_be_clickable((By.XPATH, target)))
-
-                element_select = Select(element_select)
-
-                element_select.select_by_value(value)
-
-            except EC.NoSuchElementException:
-
-                return {
-                    "success": False,
-                    "details": f"Elemento {target} não encontrado.",
-                    "error": None
-                }
-            
-            except EC.TimeoutException:
-
-                return {
-                    "success": False,
-                    "details": f"O elemento {target} não foi encontrado dentro do tempo definido",
-                    "error": None
-                }
-
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-            
-        else:
-
-            try:
-
-                element_select = self.web_bot.find_element(target, By.XPATH)
-
-                self.web_bot.wait_for_stale_element(
-                    element=element_select,
-                    timeout=self.timeout
-                )
-
-                element_select = element_as_select(element_select)
-
-                element_select.select_by_value(value)
-
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details":None,
-                    "error": e
-                }
-            
-    
-    def close(self):
-        """
-        Fecha o navegador web.
-        Retorna um dicionário com as seguintes chaves:
-        - 'success': Indica se o fechamento foi bem-sucedido (True) ou não (False).
-        - 'details': Detalhes adicionais, caso ocorra algum erro durante o fechamento.
-        - 'error': Exceção ocorrida durante o fechamento, caso haja.
-        Se o modelo for 'SELENIUM', o método utiliza o método 'quit()' do objeto 'web_bot' para fechar o navegador.
-        Caso contrário, utiliza o método 'stop_browser()'.
-        Exemplo de retorno em caso de sucesso:
-        {
-            'success': True,
-            'error': None
-        Exemplo de retorno em caso de erro:
-        {
-            'success': False,
-            'details': None,
-            'error': Exception
-        """
-
-        if self.model.upper() == "SELENIUM":
-
-            try:
-
-                self.web_bot.quit()
-
-                return {
-                    "success": True,
-                    "error": None
-                }
-            
-            except Exception as e:
-
-                return {
-                    "success": False,
-                    "details": None,
-                    "error": e
-                }
-            
-        else:
-
-            try:
-
-                self.web_bot.stop_browser()
-
-                return {
-                    "success": True,
-                    "error": None
-                }
-            
-            except Exception as e:
 
-                return {
-                    "success": False,
-                    "details": None,
-                    "error": e
-                }
+            raise ValueError(
+                "Erro na validação dos dados de input da inicialização da instância:",
+                e.errors(),
+            )
+
+        self.instancia = (
+            WebScreenSelenium(
+                headless=headless,
+                disable_gpu=disable_gpu,
+                no_sandbox=no_sandbox,
+                timeout=timeout,
+                security=security,
+            )
+            if model.upper() == "SELENIUM"
+            else WebScreenBotCity(
+                headless=headless,
+                disable_gpu=disable_gpu,
+                no_sandbox=no_sandbox,
+                timeout=timeout,
+                security=security,
+            )
+        )

{csc_cia_stne-0.1.0.dist-info → csc_cia_stne-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc_cia_stne
-Version: 0.1.0
+Version: 0.1.2
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa,botcity,stne

{csc_cia_stne-0.1.0.dist-info → csc_cia_stne-0.1.2.dist-info}/RECORD

@@ -14,13 +14,13 @@ csc_cia_stne/servicenow.py,sha256=cJtNtLZ8glWfs3OAzl78ZFlPyPz39CSBxHqpTdUU7i0,32
 csc_cia_stne/slack.py,sha256=sPLeaQh_JewLcrBDjjwUgbjtC7d1Np03OTy06JimMV4,8117
 csc_cia_stne/stne_admin.py,sha256=4v_BVQAwZeWmxvjDOkwFAl9yIxJ3r54BY7pRgAgSXEM,24220
 csc_cia_stne/wacess.py,sha256=g-bWZNpm_tU7UsW1G_rqh_2fW2KShvxZHGOerX8DuQw,26768
-csc_cia_stne/web.py,sha256=_pc6BzPy2x0RvqtZsByjtKcSuUqlVTevfmmmKbVWLhA,15417
+csc_cia_stne/web.py,sha256=g1T6GKfCZ77uRfzkHc_MGz8shUhyZ-VUIWdvAjQFk-Y,2377
 csc_cia_stne/utilitarios/__init__.py,sha256=eUaRttjY-F_zHAHC3L22VZxWyQd_k9zso-Mjz01Rj9o,306
 csc_cia_stne/utilitarios/functions/__init__.py,sha256=tBN1a6ZlvS1kLXIGopaqecJvlkOhLvLeYjp3JCAspWs,471
 csc_cia_stne/utilitarios/functions/func_b64.py,sha256=XGU34BIQQXWXBS0yM2B4A2wDlcrMl1unIJXjq4lpLnk,1254
 csc_cia_stne/utilitarios/functions/func_converters.py,sha256=EY1zvlBaRX7G1MceVSiRXwwKDQDZwUO9iECBL0fe5iU,481
 csc_cia_stne/utilitarios/functions/func_datetime.py,sha256=UA7ch4sQWTiYcz8r6LtGujIdpTU-Sht8qmTYvm9vhh0,257
-csc_cia_stne/utilitarios/functions/func_get_secret.py,sha256=cJZe_qtFFbISfQAo0iSCHjqutIjMvRF-L3I_bKUpM8I,2869
+csc_cia_stne/utilitarios/functions/func_get_secret.py,sha256=XFsAd9GnKnf9WLnARqNG2fFg5h_JEOxbVvt_78VFYh4,2959
 csc_cia_stne/utilitarios/functions/func_recriar_pastas.py,sha256=4whZpB3aJQaCPJ3osMAQpKrzEhqYtJbljGWlx_OvKIM,826
 csc_cia_stne/utilitarios/functions/func_settings.py,sha256=XwlfqdcfocXQ8kTsDKZ6GsAtpzr0_u44AOTIMtdem7U,2059
 csc_cia_stne/utilitarios/functions/func_titulo.py,sha256=bH4tYxovTARF-g2kWUK_GIzzXt8egbVdp6mWD6fc_3I,5345
@@ -32,8 +32,12 @@ csc_cia_stne/utilitarios/validations/ftp.py,sha256=LNYyS2c8eou3ML23bBtn87xJFIKSr
 csc_cia_stne/utilitarios/validations/gcp_bucket.py,sha256=vqj70jBAkazydUCPXIdE3zzgoz8Te2cCJNX_rICX1aM,6096
 csc_cia_stne/utilitarios/validations/waccess.py,sha256=8yfOrmIPUSLzbCt6P0F6vj3FkSgU_RgrJpJlRhlLyV0,7352
 csc_cia_stne/utilitarios/validations/web_validator.py,sha256=HYKYSpDv1RvRjZIuwTPt-AbEz-9392MxM_O329iYuSA,5722
-csc_cia_stne-0.1.0.dist-info/licenses/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
-csc_cia_stne-0.1.0.dist-info/METADATA,sha256=5H9EJPLrYpZK8Vf1is7VXykm_FngzrV0zj_PhEamR8c,1418
-csc_cia_stne-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-csc_cia_stne-0.1.0.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
-csc_cia_stne-0.1.0.dist-info/RECORD,,
+csc_cia_stne/utilitarios/web_screen/__init__.py,sha256=5QcOPXKd95SvP2DoZiHS0gaU68GlyFD9pQ9kae_9D1Q,100
+csc_cia_stne/utilitarios/web_screen/web_screen_abstract.py,sha256=PjL8Vgfj_JdKidia7RFyCkro3avYLQu4RZRos41sh3w,3241
+csc_cia_stne/utilitarios/web_screen/web_screen_botcity.py,sha256=3AzcP86nwBmitdXQNscv8fvg6dUogg2cAbG5KbuyqMM,12196
+csc_cia_stne/utilitarios/web_screen/web_screen_selenium.py,sha256=xtnU3gLHPhptrz7D4TzAXQNC_7xl01GxVFfE7VkMV_U,15104
+csc_cia_stne-0.1.2.dist-info/licenses/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.1.2.dist-info/METADATA,sha256=Zq5e13HVgOUHN0ysAvytwUCRX44jEbr7ZtfvCfYq4s8,1418
+csc_cia_stne-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+csc_cia_stne-0.1.2.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.1.2.dist-info/RECORD,,