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

csc_cia_stne/google_drive.py

@@ -175,8 +175,7 @@ class GoogleDrive:
 
             return {"success": False, "result": None, "error": str(e)}
 
-
-    def _validate_folder_existence(self, folder:str, id_folder:str):
+    def _validate_folder_existence(self, folder: str, id_folder: str):
         """
         Verifica a existência de uma pasta no Google Drive.
         Args:
@@ -192,24 +191,39 @@ class GoogleDrive:
 
         try:
 
-            response = self.service.files().list(q=query, spaces='drive', fields='nextPageToken, files(id, name, mimeType)', pageToken=None, includeItemsFromAllDrives = True, supportsAllDrives = True).execute()
+            response = (
+                self.service.files()
+                .list(
+                    q=query,
+                    spaces="drive",
+                    fields="nextPageToken, files(id, name, mimeType)",
+                    pageToken=None,
+                    includeItemsFromAllDrives=True,
+                    supportsAllDrives=True,
+                )
+                .execute()
+            )
 
-            items = response.get('files', [])
+            items = response.get("files", [])
 
             for item in items:
 
-                if item['mimeType'] == 'application/vnd.google-apps.folder' and item['name'] == folder:
+                if (
+                    item["mimeType"] == "application/vnd.google-apps.folder"
+                    and item["name"] == folder
+                ):
 
                     return item
-                
+
             return None
-        
-        except Exception as e:
 
-            raise ValueError(f'Erro tentando procurar pela pasta:{e}')
+        except Exception as e:
 
+            raise ValueError(f"Erro tentando procurar pela pasta:{e}")
 
-    def create_folder(self, name: str, parent_folder_id: str, validate_existence:bool=False):
+    def create_folder(
+        self, name: str, parent_folder_id: str, validate_existence: bool = False
+    ):
         """
         Cria uma pasta no Google Drive dentro de uma pasta existente.
 
@@ -221,7 +235,11 @@ class GoogleDrive:
             str: ID da pasta criada.
         """
         try:
-            CreateFolderValidator(name=name, parent_folder_id=parent_folder_id,validate_existence=validate_existence)
+            CreateFolderValidator(
+                name=name,
+                parent_folder_id=parent_folder_id,
+                validate_existence=validate_existence,
+            )
         except ValidationError as e:
             raise ValueError(
                 "Erro na validação dos dados de input da inicialização da instância:",
@@ -250,7 +268,7 @@ class GoogleDrive:
                 return {"success": True, "result": folder}
             except Exception as e:
                 return {"success": False, "result": None, "error": str(e)}
-            
+
         return {"success": True, "result": status_existence}
 
     def list_items_folder(
@@ -342,7 +360,7 @@ class GoogleDrive:
         except Exception as e:
             return {"success": False, "result": None}
 
-    def download_others_files(self, file: str,  path: str):
+    def download_others_files(self, file: str, path: str):
         """
         Obtém o conteúdo de um arquivo armazenado nos seguintes formatos:
         .xlsx, .pdf, .jpg, etc.
@@ -373,9 +391,7 @@ class GoogleDrive:
         if not os.path.exists(path):
             os.makedirs(path)
         try:
-            request = self.service.files().get_media(
-                fileId=file.get("id")
-            )
+            request = self.service.files().get_media(fileId=file.get("id"))
             file_path = f"{path}{file["name"]}"
             with open(file_path, "wb") as f:
                 f.write(request.execute())

csc_cia_stne/servicenow.py

@@ -2,12 +2,15 @@ import requests
 import base64, json
 import os
 import logging
-from pydantic import  ValidationError
+from pydantic import ValidationError
 from .utilitarios.validations.ServiceNowValidator import *
 
+
 class ServiceNow:
-    
-    def __init__(self, username: str = None, password: str = None, env: str = None) -> None:
+
+    def __init__(
+        self, username: str = None, password: str = None, env: str = None
+    ) -> None:
         """
         Inicializa uma instância da classe ServiceNow.
 
@@ -15,10 +18,10 @@ class ServiceNow:
             username (str): Nome de usuário para autenticação. Obrigatório e não pode ser nulo ou vazio.
             password (str): Senha para autenticação. Obrigatória e não pode ser nula ou vazia.
             env (str): Ambiente no qual a instância será utilizada. Deve ser 'dev', 'qa', 'qas' ou 'prod'.
-        
+
         Raises:
             ValueError: Caso qualquer um dos parâmetros não seja fornecido, seja nulo ou vazio, ou se 'env' não for um valor válido.
-        
+
         Atributos:
             username (str): Nome de usuário normalizado.
             password (str): Senha normalizada.
@@ -27,47 +30,53 @@ class ServiceNow:
             api_header (dict): Cabeçalhos padrão para requisições API.
         """
         try:
-            InitParamsValidator(username=username, password=password, env=env )
+            InitParamsValidator(username=username, password=password, env=env)
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input da inicialização da instância 'ServiceNow':", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input da inicialização da instância 'ServiceNow':",
+                e.errors(),
+            )
+
         # Normaliza o valor de 'env' para maiúsculas
         env = env.strip().upper()
 
         # Dicionário de ambientes válidos e URLs correspondentes
         valid_envs = {
-            'DEV': 'https://stonedev.service-now.com/api',
-            'QA': 'https://stoneqas.service-now.com/api',
-            'QAS': 'https://stoneqas.service-now.com/api',
-            'PROD': 'https://stone.service-now.com/api'
+            "DEV": "https://stonedev.service-now.com/api",
+            "QA": "https://stoneqas.service-now.com/api",
+            "QAS": "https://stoneqas.service-now.com/api",
+            "PROD": "https://stone.service-now.com/api",
         }
 
         # Verifica se 'env' é válido
         if env not in valid_envs:
-            raise ValueError("O valor de 'env' precisa ser 'dev', 'qa', 'qas' ou 'prod'.")
+            raise ValueError(
+                "O valor de 'env' precisa ser 'dev', 'qa', 'qas' ou 'prod'."
+            )
 
         # Atribui as variáveis de instância
         self.__username = username.strip()
         self.__password = password.strip()
         self.env = env
         self.api_url = valid_envs[env]
-        self.api_header = {"Content-Type":"application/json","Accept":"application/json"}
-        
+        self.api_header = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
 
     def __auth(self):
         """
-            Retorna o e-mail e senha para realizar a autenticação.
+        Retorna o e-mail e senha para realizar a autenticação.
         """
         return (self.__username, self.__password)
-    
 
-    def request (self, url : str , params : str = "", timeout : int = 15):
+    def request(self, url: str, params: str = "", timeout: int = 15):
         """
         Realiza uma requisição GET para a URL especificada.
 
         Parâmetros:
             url (str): URL para a qual a requisição será enviada.
-            params (dict, opcional): Parâmetros de consulta (query parameters) a serem incluídos na requisição. 
+            params (dict, opcional): Parâmetros de consulta (query parameters) a serem incluídos na requisição.
                 Padrão é uma string vazia.
 
         Retorno:
@@ -93,49 +102,50 @@ class ServiceNow:
         try:
             RequestValidator(url=url, params=params, timeout=timeout)
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         try:
             response = requests.get(
-                url, 
+                url,
                 params=params,
                 auth=self.__auth(),
                 headers=self.api_header,
                 timeout=timeout,
-                verify=True
+                verify=True,
             )
 
             # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
             response.raise_for_status()
 
-             # Analisa o conteúdo da resposta JSON
+            # Analisa o conteúdo da resposta JSON
             result = response.json()
             if "result" in result:
-                return {"success" : True, "result" : result.get("result")}
+                return {"success": True, "result": result.get("result")}
             else:
                 logging.debug("A resposta não contém o campo 'result'.")
-                return {"success" : False, "result" : result}
+                return {"success": False, "result": result}
 
         except requests.exceptions.HTTPError as http_err:
             logging.debug(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
-            return {"success" : False, "result" : None, "error" : str(http_err)}
-        
+            return {"success": False, "result": None, "error": str(http_err)}
+
         except requests.exceptions.RequestException as req_err:
             logging.debug(f"Erro ao buscar os detalhes do ticket: {req_err}")
-            return {"success" : False, "result" : None, "error" : str(req_err)}
-        
+            return {"success": False, "result": None, "error": str(req_err)}
+
         except Exception as e:
             logging.debug(f"Erro inesperado: {e}")
-            return {"success" : False, "result" : None, "error" : str(e)}
-
+            return {"success": False, "result": None, "error": str(e)}
 
-    def __request_download(self, url, params = "", timeout = 15):
+    def __request_download(self, url, params="", timeout=15):
         """
         Realiza uma requisição GET para a URL especificada.
 
         Parâmetros:
             url (str): URL para a qual a requisição será enviada.
-            params (dict, opcional): Parâmetros de consulta (query parameters) a serem incluídos na requisição. 
+            params (dict, opcional): Parâmetros de consulta (query parameters) a serem incluídos na requisição.
                 Padrão é uma string vazia.
 
         Retorno:
@@ -160,37 +170,36 @@ class ServiceNow:
         """
         try:
             response = requests.get(
-                url, 
+                url,
                 params=params,
                 auth=self.__auth(),
                 headers=self.api_header,
                 timeout=timeout,
-                verify=True
+                verify=True,
             )
 
             # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
             response.raise_for_status()
-             # Analisa o conteúdo da resposta JSON
+            # Analisa o conteúdo da resposta JSON
             if response.status_code == 200:
-                return  {"success" : True, "result" : response}
+                return {"success": True, "result": response}
             else:
                 logging.debug("Erro ao realizar a consulta")
-                return {"success" : False, "result" : response.status_code}
+                return {"success": False, "result": response.status_code}
 
         except requests.exceptions.HTTPError as http_err:
             logging.debug(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
-            return {"success" : False, "error" : str(http_err), "result" : None}
-        
+            return {"success": False, "error": str(http_err), "result": None}
+
         except requests.exceptions.RequestException as req_err:
             logging.debug(f"Erro ao buscar os detalhes do ticket: {req_err}")
-            return {"success" : False, "error" : str(req_err), "result" : None}
-        
+            return {"success": False, "error": str(req_err), "result": None}
+
         except Exception as e:
             logging.debug(f"Erro inesperado: {e}")
-            return {"success" : False, "error" : str(e), "result" : None}
+            return {"success": False, "error": str(e), "result": None}
 
-
-    def put(self, url, payload, timeout = 15):
+    def put(self, url, payload, timeout=15):
         """
         Realiza uma requisição PUT para a URL especificada.
 
@@ -221,18 +230,20 @@ class ServiceNow:
         try:
             PutValidator(url=url, payload=payload, timeout=timeout)
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         payload = json.dumps(payload)
 
-        try: 
+        try:
             response = requests.put(
                 f"{url}",
                 auth=self.__auth(),
                 headers=self.api_header,
                 data=f"{payload}",
                 timeout=timeout,
-                verify=True
+                verify=True,
             )
 
             # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
@@ -242,43 +253,51 @@ class ServiceNow:
             result = response.json()
             if "result" in result:
                 update = result["result"]
-                logging.debug(f"Atualização concluída com sucesso. Registro atualizado: {update['sys_id']} | Alterações: {payload}")
-                return {"success" : True, "result" : update}
+                logging.debug(
+                    f"Atualização concluída com sucesso. Registro atualizado: {update['sys_id']} | Alterações: {payload}"
+                )
+                return {"success": True, "result": update}
             else:
-                logging.debug(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}")
-                return {"success" : False, "result" : result}
-        
-        #TRATAMENTOS DE ERRO 
+                logging.debug(
+                    f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}"
+                )
+                return {"success": False, "result": result}
+
+        # TRATAMENTOS DE ERRO
         except requests.exceptions.HTTPError as http_err:
-            logging.debug(f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get('error').get('message')}")
-            return {"success" : False, "error" : str(http_err) , "result" : None}
-        
+            logging.debug(
+                f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get('error').get('message')}"
+            )
+            return {"success": False, "error": str(http_err), "result": None}
+
         except requests.exceptions.RequestException as req_err:
             logging.debug(f"Erro ao tentar atualizar o ticket: \n {req_err}")
-            return {"success" : False, "error" : str(req_err) , "result" : None}
-        
+            return {"success": False, "error": str(req_err), "result": None}
+
         except Exception as e:
             logging.debug(f"Erro inesperado: \n {e}")
-            return {"success" : False, "error" : str(e) , "result" : None}
+            return {"success": False, "error": str(e), "result": None}
 
-    
-    def post(self, url : str, variables : dict, header_content_type = "", timeout : int = 15):
+    def post(
+        self, url: str, variables: dict, header_content_type="", timeout: int = 15
+    ):
         """
-            Função para criar um novo ticket no servicenow usando o API REST.
+        Função para criar um novo ticket no servicenow usando o API REST.
 
-                Parametros:
-                    - Payload (Dict): Dicionário contendo os dados que serão utilizados para criar o ticket
-                Retorno: 
-                    - Dict: Um dicionário contendo os detalhes do ticket criado
-                Raises:
-                    - Exception: Se ocorrer um erro ao criar o ticket.
+            Parametros:
+                - Payload (Dict): Dicionário contendo os dados que serão utilizados para criar o ticket
+            Retorno:
+                - Dict: Um dicionário contendo os detalhes do ticket criado
+            Raises:
+                - Exception: Se ocorrer um erro ao criar o ticket.
 
         """
-        try: 
+        try:
             PostValidator(url=url, variables=variables)
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
 
         if header_content_type:
             header = header_content_type
@@ -286,17 +305,14 @@ class ServiceNow:
             header = self.api_header
 
         # Ajustar o Payload para a abertura do ticket
-        payload = {
-            "sysparm_quantity" : "1",
-            "variables" : json.dumps(variables)
-        }
-        try: 
+        payload = {"sysparm_quantity": "1", "variables": json.dumps(variables)}
+        try:
             response = requests.post(
                 f"{url}",
                 auth=self.__auth(),
                 headers=header,
                 data=f"{payload}",
-                timeout=timeout
+                timeout=timeout,
             )
 
             # VALIDA SE HOUVE SUCESSO NA REQUISIÇÃO
@@ -307,28 +323,41 @@ class ServiceNow:
             if "result" in result:
                 ticket_number = result["result"].get("number")
                 ticket_sys_id = result["result"].get("sys_id")
-                logging.debug(f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}")
-                return {"success" : True, "result" : result["result"]}
+                logging.debug(
+                    f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}"
+                )
+                return {"success": True, "result": result["result"]}
             else:
-                logging.debug(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}")
-                return {"success" : False, "result" : result}
-        
-        #TRATAMENTOS DE ERRO 
+                logging.debug(
+                    f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}"
+                )
+                return {"success": False, "result": result}
+
+        # TRATAMENTOS DE ERRO
         except requests.exceptions.HTTPError as http_err:
 
-            logging.debug(f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get('error').get('message')}")
-            return {"success" : False, "error" : str(http_err) , "result" : None}
-        
+            logging.debug(
+                f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get('error').get('message')}"
+            )
+            return {"success": False, "error": str(http_err), "result": None}
+
         except requests.exceptions.RequestException as req_err:
             logging.debug(f"Erro ao tentar registrar o ticket: \n {req_err}")
-            return {"success" : False, "error" : str(req_err) , "result" : None}
-        
+            return {"success": False, "error": str(req_err), "result": None}
+
         except Exception as e:
             logging.debug(f"Erro inesperado: \n {e}")
-            return {"success" : False, "error" : str(e) , "result" : None}
-    
-
-    def listar_tickets(self, tabela: str = None, campos: list = None, query: str = None, limite: int = 50, timeout:int=15, sysparm_display_value: str = "")->dict:
+            return {"success": False, "error": str(e), "result": None}
+
+    def listar_tickets(
+        self,
+        tabela: str = None,
+        campos: list = None,
+        query: str = None,
+        limite: int = 50,
+        timeout: int = 15,
+        sysparm_display_value: str = "",
+    ) -> dict:
         """lista tickets do ServiceNow
 
         Args:
@@ -342,30 +371,42 @@ class ServiceNow:
             dict: dicionário com o resultado da query
         """
         try:
-            ListTicketValidator(tabela=tabela, campos=campos, query=query, limite=limite, timeout=timeout)
+            ListTicketValidator(
+                tabela=tabela,
+                campos=campos,
+                query=query,
+                limite=limite,
+                timeout=timeout,
+            )
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
 
         params = {
-            "sysparm_query" : query,
-            "sysparm_fields" : ','.join(campos),
-            "sysparm_display_value" : sysparm_display_value,
-            "sysparm_limit" : limite
+            "sysparm_query": query,
+            "sysparm_fields": ",".join(campos),
+            "sysparm_display_value": sysparm_display_value,
+            "sysparm_limit": limite,
         }
 
         url = f"{self.api_url}/now/table/{tabela}"
-        
+
         try:
             response = self.request(url=url, params=params, timeout=timeout)
             return response
-        
+
         except Exception as e:
             logging.debug(f"erro: {e}")
             return str(e)
 
-
-    def update_ticket(self, tabela: str = None, sys_id: str = None, payload: dict = None, timeout:int=15)->dict:
+    def update_ticket(
+        self,
+        tabela: str = None,
+        sys_id: str = None,
+        payload: dict = None,
+        timeout: int = 15,
+    ) -> dict:
         """Atualiza as informações de um ticket
 
         Args:
@@ -378,10 +419,14 @@ class ServiceNow:
             dict: resposta do ServiceNow
         """
         try:
-            UpdateTicketValidator(tabela=tabela, sys_id=sys_id, payload=payload, timeout=timeout)
+            UpdateTicketValidator(
+                tabela=tabela, sys_id=sys_id, payload=payload, timeout=timeout
+            )
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-    
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         payload["assigned_to"] = self.__username
 
         try:
@@ -393,8 +438,14 @@ class ServiceNow:
         except Exception as e:
             return str(e)
 
-
-    def anexar_arquivo_no_ticket(self,header_content_type:dict=None, anexo_path:str=None, tabela:str=None, sys_id:str=None, timeout:int=15):
+    def anexar_arquivo_no_ticket(
+        self,
+        header_content_type: dict = None,
+        anexo_path: str = None,
+        tabela: str = None,
+        sys_id: str = None,
+        timeout: int = 15,
+    ):
         """Anexa arquivo em um ticket do ServiceNow
 
         Args:
@@ -408,37 +459,53 @@ class ServiceNow:
             dict: resposta do ServiceNow
         """
         if header_content_type is None:
-            header_content_type = self.__valida_header_content_type(anexo_path, header_content_type)
-        
+            header_content_type = self.__valida_header_content_type(
+                anexo_path, header_content_type
+            )
+
         try:
-            AttachFileTicketValidator(header_content_type=header_content_type, anexo_path=anexo_path, tabela=tabela, sys_id=sys_id, timeout=timeout)
+            AttachFileTicketValidator(
+                header_content_type=header_content_type,
+                anexo_path=anexo_path,
+                tabela=tabela,
+                sys_id=sys_id,
+                timeout=timeout,
+            )
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         if not os.path.exists(anexo_path):
             raise FileExistsError(f"O arquivo não foi encontrado ({anexo_path})")
 
-        
-
         # Converte as chaves do dicionário para minúsculas
-        header_content_type_lower = {k.lower(): v for k, v in header_content_type.items()}
+        header_content_type_lower = {
+            k.lower(): v for k, v in header_content_type.items()
+        }
 
-        
         if "content-type" not in header_content_type_lower:
-            raise ValueError("O parâmetro 'header_content_type' não possui a chave 'Content-Type' com o tipo do anexo")
+            raise ValueError(
+                "O parâmetro 'header_content_type' não possui a chave 'Content-Type' com o tipo do anexo"
+            )
 
         nome_arquivo = os.path.basename(anexo_path)
         try:
-            with open(anexo_path, 'rb') as f:
+            with open(anexo_path, "rb") as f:
                 url = f"{self.api_url}/now/attachment/file?table_name={tabela}&table_sys_id={sys_id}&file_name={nome_arquivo}"
-                response = requests.post(url, headers=header_content_type, auth=(self.__username, self.__password), data=f, timeout=timeout)
-            
+                response = requests.post(
+                    url,
+                    headers=header_content_type,
+                    auth=(self.__username, self.__password),
+                    data=f,
+                    timeout=timeout,
+                )
+
             logging.debug("Arquivo adicionado no ticket")
-            return {"success": True, "result" : response}
-        
+            return {"success": True, "result": response}
+
         except Exception as e:
-            return {"success" : False, "result" : None, "error" : str(e)}
-        
+            return {"success": False, "result": None, "error": str(e)}
 
     def __valida_header_content_type(self, anexo_path, header_content_type):
         """
@@ -460,35 +527,49 @@ class ServiceNow:
 
         Observação:
             - O parâmetro `header_content_type` é uma variável local utilizada para compor os cabeçalhos HTTP, contendo informações do tipo de conteúdo do arquivo.
-            
+
         """
 
         # Pré validando 'header_content_type'
-        if os.path.splitext(anexo_path)[1].lower() == ".zip" and header_content_type is None:
-            
+        if (
+            os.path.splitext(anexo_path)[1].lower() == ".zip"
+            and header_content_type is None
+        ):
+
             header_content_type = {"Content-Type": "application/zip"}
-        
-        elif os.path.splitext(anexo_path)[1].lower() == ".xlsx" and header_content_type is None:
-        
-            header_content_type = {"Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"}
-        
-        elif os.path.splitext(anexo_path)[1].lower() == ".pdf" and header_content_type is None:
-        
+
+        elif (
+            os.path.splitext(anexo_path)[1].lower() == ".xlsx"
+            and header_content_type is None
+        ):
+
+            header_content_type = {
+                "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            }
+
+        elif (
+            os.path.splitext(anexo_path)[1].lower() == ".pdf"
+            and header_content_type is None
+        ):
+
             header_content_type = {"Content-Type": "application/pdf"}
-        
-        elif os.path.splitext(anexo_path)[1].lower() == ".txt" and header_content_type is None:
-        
+
+        elif (
+            os.path.splitext(anexo_path)[1].lower() == ".txt"
+            and header_content_type is None
+        ):
+
             header_content_type = {"Content-Type": "text/plain"}
 
         # Validação de 'header_content_type'
         if not isinstance(header_content_type, dict):
-            raise ValueError("O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})")
-        
-       
-        return header_content_type
+            raise ValueError(
+                "O parâmetro 'header_content_type' precisa ser um dicionário contendo o 'Content-Type' do arquivo a ser anexado. (Ex: {\"Content-Type\": \"application/zip\"})"
+            )
 
+        return header_content_type
 
-    def download_anexo(self, sys_id_file : str, file_path : str, timeout : int = 15):
+    def download_anexo(self, sys_id_file: str, file_path: str, timeout: int = 15):
         """
         Faz o download de um anexo do ServiceNow utilizando o `sys_id` do arquivo e salva no caminho especificado.
 
@@ -525,8 +606,10 @@ class ServiceNow:
         try:
             DownloadFileValidator(sys_id_file=sys_id_file, file_path=file_path)
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         url = f"{self.api_url}/now/attachment/{sys_id_file}/file"
         response = self.__request_download(url=url, timeout=timeout)
         response = response.get("result")
@@ -537,50 +620,56 @@ class ServiceNow:
                     print(diretorio)
                     os.makedirs(diretorio, exist_ok=True)
                     logging.debug(f"Diretorio criado: {diretorio}")
-                with open(file_path, 'wb') as f:
+                with open(file_path, "wb") as f:
                     f.write(response.content)
-                return {"success" : True, "path" : file_path }
-            
+                return {"success": True, "path": file_path}
+
             except FileNotFoundError:
                 try:
                     path = os.path.dirname(file_path)
                     os.makedirs(path)
-                    with open(file_path, 'wb') as f:
+                    with open(file_path, "wb") as f:
                         f.write(response.content)
-                    return {"success" : True, "path" : file_path }
+                    return {"success": True, "path": file_path}
                 except Exception as e:
                     logging.debug(f"Erro ao salvar o arquivo. Erro: {e}")
-                return {"success" : False, "error" : str(e) }
+                return {"success": False, "error": str(e)}
             except Exception as e:
                 logging.error(f"Erro ao salvar o arquivo. Erro: {e}")
-                return {"success" : False, "error" : str(e) }
+                return {"success": False, "error": str(e)}
         else:
             logging.debug(f"{response.status_code}")
-            return {"success" : False, "error" : f"Status code: {response.status_code }"}
+            return {"success": False, "error": f"Status code: {response.status_code }"}
 
-    def get_variables_from_ticket(self, sys_id : str, campos : str = ''):
+    def get_variables_from_ticket(self, sys_id: str, campos: str = ""):
         """
         Obtém as variáveis associadas ao ticket.
         args:
             sys_id : STR - Id do ticket
         """
         if isinstance(campos, list):
-            campos = ','.join(campos)
+            campos = ",".join(campos)
         if campos == "":
-            campos = 'name,question_text,type,default_value, sys_id'
+            campos = "name,question_text,type,default_value, sys_id"
 
         logging.debug(f"Obtendo variáveis do ticket {sys_id}")
         url = f"{self.api_url}/now/table/item_option_new"
         params = {
-            'sysparm_query': f'cat_item={sys_id}',
-            'sysparm_display_value': 'true',
-            'sysparm_fields': campos,
+            "sysparm_query": f"cat_item={sys_id}",
+            "sysparm_display_value": "true",
+            "sysparm_fields": campos,
         }
         response = self.request(url, params=params)
         return response
-    
 
-    def get_anexo(self, sys_id: str = None, tabela: str = None, campo: str = 'default', download_dir:str=None, timeout:int=15)->dict:
+    def get_anexo(
+        self,
+        sys_id: str = None,
+        tabela: str = None,
+        campo: str = "default",
+        download_dir: str = None,
+        timeout: int = 15,
+    ) -> dict:
         """Traz os anexos de um campo do ticket especificado
 
         Args:
@@ -593,50 +682,57 @@ class ServiceNow:
             dict: dicionário com os anexos do ticket
         """
         try:
-            GetAttachValidator(sys_id=sys_id,
-                               tabela=tabela,
-                               timeout=timeout,
-                               download_dir=download_dir)
+            GetAttachValidator(
+                sys_id=sys_id, tabela=tabela, timeout=timeout, download_dir=download_dir
+            )
         except ValidationError as e:
-            raise ValueError("Erro na validação dos dados de input do método:", e.errors())
-        
+            raise ValueError(
+                "Erro na validação dos dados de input do método:", e.errors()
+            )
+
         if download_dir is not None:
             if not isinstance(download_dir, str) or not download_dir.strip():
-                raise ValueError("O parâmetro 'download_dir' precisa ser a pasta pra onde o anexo será feito o download.")
-            if not os.path.exists(download_dir):            
-                raise NotADirectoryError(f"A pasta informada '{download_dir}' não existe")
-        
+                raise ValueError(
+                    "O parâmetro 'download_dir' precisa ser a pasta pra onde o anexo será feito o download."
+                )
+            if not os.path.exists(download_dir):
+                raise NotADirectoryError(
+                    f"A pasta informada '{download_dir}' não existe"
+                )
+
         # Validação de 'campo'
         if not isinstance(campo, str) or not campo.strip():
-            raise ValueError("O parâmetro 'campo' precisa ser uma string não vazia com o nome do campo do anexo.")
+            raise ValueError(
+                "O parâmetro 'campo' precisa ser uma string não vazia com o nome do campo do anexo."
+            )
 
         campo = str(campo).strip().lower()
 
         # Convert bytes to base64
         def __bytes_to_base64(image_bytes):
 
-            return base64.b64encode(image_bytes).decode('utf-8')
-        
+            return base64.b64encode(image_bytes).decode("utf-8")
+
         def __formatar_tamanho(tamanho_bytes):
             # Converte o valor de string para inteiro
             tamanho_bytes = int(tamanho_bytes)
-            
+
             # Define os múltiplos de bytes
-            unidades = ['B', 'KB', 'MB', 'GB', 'TB']
+            unidades = ["B", "KB", "MB", "GB", "TB"]
 
             # Itera sobre as unidades até encontrar a maior possível
             for unidade in unidades:
                 if tamanho_bytes < 1024:
                     return f"{tamanho_bytes:.2f} {unidade}"
                 tamanho_bytes /= 1024
-            
+
             # Caso o valor seja maior que o esperado (Exabyte ou superior)
             return f"{tamanho_bytes:.2f} PB"  # Petabyte
 
-        anexo_dict = {"var_servicenow": campo, "anexos":[]}
-        
+        anexo_dict = {"var_servicenow": campo, "anexos": []}
+
         try:
-            if campo == 'default':
+            if campo == "default":
                 url = f"{self.api_url}/now/attachment?sysparm_query=table_name={tabela}^table_sys_id={sys_id}"
                 response = self.__request_download(url, timeout=timeout)
                 response = response.get("result")
@@ -646,18 +742,27 @@ class ServiceNow:
                             "file_name": attachment["file_name"],
                             "size": __formatar_tamanho(attachment["size_bytes"]),
                             "content_type": attachment["content_type"],
-                            "base64": None
+                            "base64": None,
                         }
-                        byte_response = self.__request_download(attachment["download_link"], timeout=timeout)
+                        byte_response = self.__request_download(
+                            attachment["download_link"], timeout=timeout
+                        )
                         byte_response = byte_response.get("result")
                         if byte_response.status_code == 200:
                             arquivo["base64"] = __bytes_to_base64(byte_response.content)
                             if download_dir:
-                                with open(os.path.join(download_dir, arquivo["file_name"]), 'wb') as f:
+                                with open(
+                                    os.path.join(download_dir, arquivo["file_name"]),
+                                    "wb",
+                                ) as f:
                                     f.write(byte_response.content)
                             anexo_dict["anexos"].append(arquivo)
                     return {"success": True, "result": anexo_dict}
-                return {"success": False, "error": response.json(), "status_code": response.status_code}
+                return {
+                    "success": False,
+                    "error": response.json(),
+                    "status_code": response.status_code,
+                }
 
             else:
                 url = f"{self.api_url}/now/table/{tabela}?sysparm_query=sys_id={sys_id}&sysparm_fields={campo}&sysparm_display_value=all"
@@ -667,23 +772,38 @@ class ServiceNow:
                     campo_data = response.json()["result"][0].get(campo)
                     if campo_data:
                         attachment_id = campo_data["value"]
-                        attachment_url = f"{self.api_url}/now/attachment/{attachment_id}/file"
-                        byte_response = self.__request_download(attachment["download_link"], timeout=timeout)
+                        attachment_url = (
+                            f"{self.api_url}/now/attachment/{attachment_id}/file"
+                        )
+                        byte_response = self.__request_download(
+                            attachment["download_link"], timeout=timeout
+                        )
                         byte_response = byte_response.get("result")
                         if byte_response.status_code == 200:
                             arquivo = {
                                 "file_name": campo_data["display_value"],
-                                "size": __formatar_tamanho(byte_response.headers.get("Content-Length", 0)),
-                                "content_type": byte_response.headers.get("Content-Type"),
-                                "base64": __bytes_to_base64(byte_response.content)
+                                "size": __formatar_tamanho(
+                                    byte_response.headers.get("Content-Length", 0)
+                                ),
+                                "content_type": byte_response.headers.get(
+                                    "Content-Type"
+                                ),
+                                "base64": __bytes_to_base64(byte_response.content),
                             }
                             if download_dir:
-                                with open(os.path.join(download_dir, arquivo["file_name"]), 'wb') as f:
+                                with open(
+                                    os.path.join(download_dir, arquivo["file_name"]),
+                                    "wb",
+                                ) as f:
                                     f.write(byte_response.content)
                             anexo_dict["anexos"].append(arquivo)
-                    return {"success": True, "result": anexo_dict, "error" : None}
-                return {"success": False, "error": response.json(), "status_code": response.status_code}
+                    return {"success": True, "result": anexo_dict, "error": None}
+                return {
+                    "success": False,
+                    "error": response.json(),
+                    "status_code": response.status_code,
+                }
 
         except Exception as e:
             logging.debug("Erro ao obter anexos.")
-            return {"success": False, "error": str(e)}
+            return {"success": False, "error": str(e)}

csc_cia_stne/utilitarios/web_screen/web_screen_botcity.py

@@ -33,6 +33,7 @@ class WebScreenBotCity(WebScreenAbstract):
         no_sandbox: bool = True,
         timeout: int = 10,
         security: bool = False,
+        download_path: str = "./tmp/",
     ):
         """
         Inicializa a classe com as configurações para o WebBot.
@@ -65,6 +66,7 @@ class WebScreenBotCity(WebScreenAbstract):
             self.web_bot.headless = headless
             self.web_bot.disable_gpu = disable_gpu
             self.web_bot.no_sandbox = no_sandbox
+            self.web_bot.download_folder_path = download_path
 
         except Exception as e:
             raise ValueError("Erro na inicialização da classe:", e)

csc_cia_stne/utilitarios/web_screen/web_screen_selenium.py

@@ -1,10 +1,10 @@
 import time
+import os
 
 # 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
@@ -39,6 +39,7 @@ class WebScreenSelenium(WebScreenAbstract):
         timeout: int = 10,
         security: bool = False,
         scale: float = 0.8,
+        download_path: str = "./tmp/",
     ):
         """
         Inicializa a classe responsável por configurar e gerenciar o WebDriver do Selenium.
@@ -96,6 +97,16 @@ class WebScreenSelenium(WebScreenAbstract):
             chrome_options.add_argument("--disable-extensions")
             chrome_options.add_argument("--window-size=1920,1080")
             chrome_options.add_argument(f"--force-device-scale-factor={scale}")
+            os.makedirs(download_path, exist_ok=True)
+            chrome_options.add_experimental_option(
+                "prefs",
+                {
+                    "download.default_directory": os.path.abspath(download_path),
+                    "download.prompt_for_download": False,  # Não perguntar onde salvar
+                    "directory_upgrade": True,
+                    "safebrowsing.enabled": True,  # Para evitar bloqueios do Chrome
+                },
+            )
 
             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"

csc_cia_stne/web.py

@@ -16,6 +16,7 @@ class web_screen:
         disable_gpu: bool = True,
         no_sandbox: bool = True,
         security: bool = True,
+        download_path: str = "./tmp/",
     ):
         """
         Inicializa a instância da classe Web.
@@ -59,6 +60,7 @@ class web_screen:
                 no_sandbox=no_sandbox,
                 timeout=timeout,
                 security=security,
+                download_path=download_path,
             )
             if model.upper() == "SELENIUM"
             else WebScreenBotCity(
@@ -67,5 +69,6 @@ class web_screen:
                 no_sandbox=no_sandbox,
                 timeout=timeout,
                 security=security,
+                download_path=download_path,
             )
         )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc_cia_stne
-Version: 0.1.2
+Version: 0.1.3
 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.2.dist-info → csc_cia_stne-0.1.3.dist-info}/RECORD

@@ -5,16 +5,16 @@ csc_cia_stne/email.py,sha256=K0DcgxTPKa_Rz_SJekjbW8Nw_1L9s_iuDDxZ-69bZfM,8387
 csc_cia_stne/ftp.py,sha256=M9WCaq2hm56jGyszNaPinliFaZS0BNrT7VrVPMjkMg4,10988
 csc_cia_stne/gcp_bigquery.py,sha256=foq8azvvv_f7uikMDslX9RcUIrx7RAS-Sn0AGW0QFQc,7231
 csc_cia_stne/gcp_bucket.py,sha256=nP77BtagZ7jQq6lS88ZEa1qshzBza6e_LvhgS3_JJJk,10268
-csc_cia_stne/google_drive.py,sha256=k6GnM8bxQUPbXhaK6Sa4JpWrCcJ0vzYgXP8Uexy7YR0,16073
+csc_cia_stne/google_drive.py,sha256=VOaI_ZehDTqqNqk5aVqaU4g6yz_ClsPLYArqgg6-SPs,16348
 csc_cia_stne/karavela.py,sha256=jJCYX43D49gGuzmwwK6bN9XVnv2dXdp9iHnnV5H1LMQ,4794
 csc_cia_stne/logger_json.py,sha256=CXxSCOFGMymDi8XE9SKnPKjW4D0wJLqDLnxqePS26i8,3187
 csc_cia_stne/logger_rich.py,sha256=fklgkBb4rblKQd7YZ3q-eWfhGg9eflO2k2-z4pGh_yo,5201
 csc_cia_stne/provio.py,sha256=G-pDnHYLSp97joc7S7dvwjNvl3omnTmvdi3rOPQf5GA,3987
-csc_cia_stne/servicenow.py,sha256=cJtNtLZ8glWfs3OAzl78ZFlPyPz39CSBxHqpTdUU7i0,32136
+csc_cia_stne/servicenow.py,sha256=2AeG9icBOjwKVVmGbcJvM2mPEFFzYSA1pN1qJYbnM2c,33721
 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=g1T6GKfCZ77uRfzkHc_MGz8shUhyZ-VUIWdvAjQFk-Y,2377
+csc_cia_stne/web.py,sha256=TBXUJ5eS36fytU3oFDuJsogi0sgw_qKgK-uphx4Nvxo,2506
 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
@@ -34,10 +34,10 @@ csc_cia_stne/utilitarios/validations/waccess.py,sha256=8yfOrmIPUSLzbCt6P0F6vj3Fk
 csc_cia_stne/utilitarios/validations/web_validator.py,sha256=HYKYSpDv1RvRjZIuwTPt-AbEz-9392MxM_O329iYuSA,5722
 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,,
+csc_cia_stne/utilitarios/web_screen/web_screen_botcity.py,sha256=Xi5YJjl2pcxlX3OimqcBWRNXZEpAE7asyUjDJ4Oho5U,12297
+csc_cia_stne/utilitarios/web_screen/web_screen_selenium.py,sha256=JLIcPJE9ZX3Pd6zG6oTRMqqUAY063UzLY3ReRlxmiSM,15581
+csc_cia_stne-0.1.3.dist-info/licenses/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.1.3.dist-info/METADATA,sha256=9m7R6yZRqbL9ozjOe7vBBzsSh_uyiPnlftqacP0jDUY,1418
+csc_cia_stne-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+csc_cia_stne-0.1.3.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.1.3.dist-info/RECORD,,