csc-cia-stne 0.0.46__py3-none-any.whl → 0.0.47__py3-none-any.whl

csc_cia_stne/__init__.py

@@ -12,6 +12,7 @@ from .email import Email
 from .provio import Provio
 from .google_drive import GoogleDrive
 from .slack import Slack
+from .web import web_screen
 
 # Define os itens disponíveis para importação
 __all__ = [
@@ -26,7 +27,8 @@ __all__ = [
     "Provio",
     "Email", 
     "GoogleDrive",
-    "Slack"
+    "Slack",
+    "web_screen"
 ]
 
 _diretorio_inicial = os.getcwd()

csc_cia_stne/utilitarios/functions/func_settings.py

@@ -3,13 +3,13 @@ import os
 import sys
 
 
-def get_config(file_path:str="settings.yaml",file_path_local:str=None,prod:bool=False) -> dict:
+def get_config(file_path:str="settings.yaml",file_path_local:str=None,env:str='dev') -> dict:
     """
     Retorna as configurações carregadas a partir de um arquivo YAML.
     Parâmetros:
     - file_path (str): O caminho do arquivo YAML.
     - file_path_local (str, opcional): O caminho local do arquivo YAML, caso exista.
-    - prod (bool, opcional): Indica se as configurações de produção devem ser carregadas.
+    - prod (str, opcional): Indica se as configurações de produção devem ser carregadas.
     Retorna:
     - dict: Um dicionário contendo as configurações carregadas do arquivo YAML.
     Lança:
@@ -51,13 +51,34 @@ def get_config(file_path:str="settings.yaml",file_path_local:str=None,prod:bool=
 
             config = yaml.safe_load(f)
 
-        if prod:
+        if env.lower() == "prod":
+            try:
+                
+                config['env'] = config['prod']
 
-            config['env'] = config['prod']
+            except:
 
+                config['env'] = {}
+
+        elif env.lower() == "qa":
+
+            try:
+
+                config['env'] = config['qa']
+
+            except:
+
+                config['env'] = {}
+        
         else:
 
-            config['env'] = config['prod']
+            try:
+
+                config['env'] = config['dev']
+
+            except:
+
+                config['env'] = {}
 
         return config
 

csc_cia_stne/utilitarios/validations/web_validator.py

@@ -0,0 +1,103 @@
+from pydantic import BaseModel, field_validator
+
+
+class InitParamsValidator(BaseModel):
+    """
+    Classe para validar os parâmetros de inicialização.
+    Atributos:
+        model (str): O modelo a ser utilizado. Deve ser uma string e pode ser 'selenium' ou 'boticy'.
+        headless (bool): Define se o navegador será executado em modo headless.
+        disable_gpu (bool): Define se a aceleração de hardware será desabilitada.
+        no_sandbox (bool): Define se o sandbox do navegador será desabilitado.
+        timeout (int): O tempo limite para a execução de operações.
+    Métodos:
+        check_str_basic(cls, value, info): Valida se o valor é uma string não vazia e se está dentro das opções permitidas.
+        check_bool_input(cls, value, info): Valida se o valor é um booleano.
+    """
+    
+    model:str
+    headless:bool
+    disable_gpu:bool
+    no_sandbox:bool
+    timeout:int
+
+    @field_validator('model')
+    def check_str_basic(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro 'model' deve ser uma string e não um {type(value)} e não vazio")
+        if value.upper() not in ['SELENIUM', 'BOTCITY']:
+            raise ValueError(f"O parametro 'model' deve ser 'selenium' ou 'boticy' e não {value}")
+        return value
+    
+    @field_validator('timeout')
+    def check_str_basic(cls, value, info):
+        if not isinstance(value, int):
+            raise ValueError(f"O parametro 'model' deve ser um int e não um {type(value)} e não vazio")
+        return value
+    
+    @field_validator('headless','disable_gpu','no_sandbox')
+    def check_bool_input(cls, value, info):
+        if not isinstance(value, bool):
+            raise ValueError(f"O parametro '{info.field_name}' deve ser um boleano")
+        
+        return value
+    
+
+class ClickOnScreenValidator():
+    """
+    Classe para validar os parâmetros 'target' e 'timeout' da classe ClickOnScreenValidator.
+    Atributos:
+        target (str): O alvo a ser validado.
+    Métodos:
+        check_str_basic(value, info): Valida se o valor do parâmetro 'target' é uma string não vazia.
+    """
+    target:str
+
+    @field_validator('target')
+    def check_str_basic(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro 'target' deve ser uma string e não um {type(value)} e não vazio")
+        return value
+
+class InputValueValidator():
+    """
+    Classe para validar os valores de entrada.
+    Atributos:
+        target (str): O valor de destino a ser validado.
+        clear (bool): Indica se o valor deve ser limpo.
+    Métodos:
+        check_str_basic(value, info): Valida se o valor fornecido é uma string não vazia.
+        check_bool_input(value, info): Valida se o valor fornecido é um booleano.
+    """
+    target:str
+    clear:bool
+
+    @field_validator('target')
+    def check_str_basic(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro 'target' deve ser uma string e não um {type(value)} e não vazio")
+        return value
+
+    @field_validator('clear')
+    def check_bool_input(cls, value, info):
+        if not isinstance(value, bool):
+            raise ValueError(f"O parametro 'clear' deve ser um boleano")
+        return value
+    
+
+class SelectValueValidator():
+    """
+    Classe para validação de valores do seletor.
+    Atributos:
+        target (str): O valor do seletor.
+    Métodos:
+        check_str_basic(value, info): Valida se o valor do seletor é uma string não vazia.
+    """
+
+    target:str
+
+    @field_validator('target')
+    def check_str_basic(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro 'target' deve ser uma string e não um {type(value)} e não vazio")
+        return value

csc_cia_stne/web.py

@@ -0,0 +1,364 @@
+# 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
+
+# Validador
+from pydantic import ValidationError
+
+# Validadores de parametros
+from .utilitarios.validations.web_validator import InitParamsValidator,ClickOnScreenValidator,InputValueValidator,SelectValueValidator
+
+
+class web_screen():
+
+
+    def __init__(self,model:str="selenium",timeout:int=60,headless:bool=True,disable_gpu:bool=True,no_sandbox:bool=True):
+        """
+        Inicializa a instância da classe Web.
+        Parâmetros:
+        - model (str): O modelo a ser utilizado, pode ser "selenium" ou outro modelo suportado.
+        - timeout (int): O tempo limite em segundos para aguardar a resposta do navegador.
+        - headless (bool): Define se o navegador será executado em modo headless (sem interface gráfica).
+        - disable_gpu (bool): Define se a aceleração de hardware do GPU será desabilitada.
+        - no_sandbox (bool): Define se o sandbox do navegador será desabilitado.
+        Retorna:
+        Um dicionário com as seguintes chaves:
+        - "success" (bool): Indica se a inicialização foi bem-sucedida.
+        - "result" (object): O objeto do navegador (webdriver) ou do botcity, dependendo do modelo escolhido.
+        - "error" (Exception): O erro ocorrido durante a inicialização, caso a inicialização tenha falhado.
+        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
+
+        try:
+        
+            InitParamsValidator(model=model,timeout=timeout, headless=headless, disable_gpu=disable_gpu, no_sandbox=no_sandbox)
+
+        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)
+
+                return {
+                    "success": True,
+                    "result": self.web_bot
+                }
+            
+            except Exception as e:
+
+                return {
+                    "success": False,
+                    "error": 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
+
+                return {
+                    "success": True,
+                    "result": self.web_bot
+                }
+            
+            except Exception as e:
+
+                    return {
+                        "success": False,
+                        "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.
+        """
+
+        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)
+
+        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
+                }

{csc_cia_stne-0.0.46.dist-info → csc_cia_stne-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: csc_cia_stne
-Version: 0.0.46
+Version: 0.0.47
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa
@@ -21,6 +21,8 @@ Requires-Dist: pyjwt
 Requires-Dist: PyYAML
 Requires-Dist: python-dotenv
 Requires-Dist: slack_sdk
+Requires-Dist: webdriver-manager
+Requires-Dist: botcity-framework-web
 Requires-Dist: email-validator
 
 Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**

{csc_cia_stne-0.0.46.dist-info → csc_cia_stne-0.0.47.dist-info}/RECORD

@@ -1,4 +1,4 @@
-csc_cia_stne/__init__.py,sha256=lHYOTmSOu5K-G1lKYKqrK1evkjOW1WTAxSHjWHk99-k,2466
+csc_cia_stne/__init__.py,sha256=Io-gKis1evws5cHUqyOrcsZKNCQRviYj3zbp__5lgKU,2512
 csc_cia_stne/bc_correios.py,sha256=pQAnRrcXEMrx3N1MWydZVIhEQLerh3x8-0B045zZIzk,24174
 csc_cia_stne/bc_sta.py,sha256=f75HJ7FLIDSJFLDTvvSvCYo9z0HchzP7rDY5WIdiKXY,16830
 csc_cia_stne/email.py,sha256=RK_TzWBVnUfpP-s5NvjTJJjzhICy8e2fME9EuaiySMY,8162
@@ -11,19 +11,21 @@ csc_cia_stne/provio.py,sha256=G-pDnHYLSp97joc7S7dvwjNvl3omnTmvdi3rOPQf5GA,3987
 csc_cia_stne/servicenow.py,sha256=3eifPWOIGv2udGpI3cr2SkMMKcQR4xHlA_fiOdw_fmg,32136
 csc_cia_stne/slack.py,sha256=33_UNF7M529eIuWjmzSJFEZ4RmVNkFkuVxvxwsKY1tQ,8126
 csc_cia_stne/stne_admin.py,sha256=vnGSEzcmqWE42vg71oEuoRg6ENaGsZsXFOjxduSH4KU,23561
+csc_cia_stne/web.py,sha256=ubLN-t67bG6LGkPWOgfT6bZ-cRV6Gh9nfjJWRCeyWz4,11647
 csc_cia_stne/utilitarios/__init__.py,sha256=oWxCOFL2wxjs8KBgxoeA6-gVe4ulicVGDgdaw8jzvsY,253
 csc_cia_stne/utilitarios/functions/__init__.py,sha256=iSLKxM8lgPM1lJ51WZ1mwy36IW5iitfMRc_AnEtzpxg,364
 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_recriar_pastas.py,sha256=4whZpB3aJQaCPJ3osMAQpKrzEhqYtJbljGWlx_OvKIM,826
-csc_cia_stne/utilitarios/functions/func_settings.py,sha256=rlu4Ec5M-7UzrreiR92L_KLrpBSXv8Hlj4uuRYcPMUc,1709
+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
 csc_cia_stne/utilitarios/validations/GcpBigQueryValidator.py,sha256=PfCeeQquheZkrm07HTIjobleh3QQOjljRFGdxbQ1amQ,4630
 csc_cia_stne/utilitarios/validations/GoogleDriveValidator.py,sha256=PBo-AV2bjR__4o9jYxuXO-UyxjAZvVwYgMbtsrFK2sI,4537
 csc_cia_stne/utilitarios/validations/ServiceNowValidator.py,sha256=yleKUIo1ZfyloP9fDPNjv3JJXdLcocT81WIgRSYmqEA,14423
 csc_cia_stne/utilitarios/validations/__init__.py,sha256=O_qyEU2ji3u6LHUXZCXvUFsMpoMWL625qqHTXyXivTA,106
-csc_cia_stne-0.0.46.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
-csc_cia_stne-0.0.46.dist-info/METADATA,sha256=m3ty7x_xf90UxVSKQN3_BBGZ9m11C1iw6Z7wmiyiVjs,1121
-csc_cia_stne-0.0.46.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-csc_cia_stne-0.0.46.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
-csc_cia_stne-0.0.46.dist-info/RECORD,,
+csc_cia_stne/utilitarios/validations/web_validator.py,sha256=Mas_Jg_VjvM4f-RAHBDs7FTQELEGfFQ5yGPuu_t1Zmg,3919
+csc_cia_stne-0.0.47.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.0.47.dist-info/METADATA,sha256=29bgrZ4qEk-W_TWNH6q9WI_fJqwHEHI65B8az18ygRo,1191
+csc_cia_stne-0.0.47.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+csc_cia_stne-0.0.47.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.0.47.dist-info/RECORD,,