csc-cia-stne 0.0.56__tar.gz → 0.1.49__tar.gz

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/PKG-INFO

@@ -1,12 +1,13 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: csc_cia_stne
-Version: 0.0.56
+Version: 0.1.49
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa,botcity,stne
 Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: setuptools
+Requires-Dist: tzdata
 Requires-Dist: python-json-logger
 Requires-Dist: rich
 Requires-Dist: requests
@@ -15,17 +16,27 @@ Requires-Dist: pydantic_settings
 Requires-Dist: zeep
 Requires-Dist: google-cloud-bigquery
 Requires-Dist: google-cloud-storage
+Requires-Dist: google-cloud-bigquery-storage
+Requires-Dist: google-auth
 Requires-Dist: google-auth-oauthlib
 Requires-Dist: google-auth-httplib2
 Requires-Dist: google-api-python-client
+Requires-Dist: google-cloud-documentai
 Requires-Dist: pyjwt
 Requires-Dist: PyYAML
 Requires-Dist: python-dotenv
 Requires-Dist: slack_sdk
 Requires-Dist: webdriver-manager
+Requires-Dist: botcity-framework-core
 Requires-Dist: botcity-framework-web
 Requires-Dist: email-validator
 Requires-Dist: botcity-maestro-sdk
+Requires-Dist: psutil
+Requires-Dist: cryptography
+Requires-Dist: PyPDF2
+Requires-Dist: openai
+Requires-Dist: pycurl
+Dynamic: license-file
 
 Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**
 

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csc_cia_stne"
-version = "0.0.56"
+version = "0.1.49"
 license = { text = "MIT" }
 description = "Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs"
 keywords = ["karavela", "csc", "cia", "stone", "rpa", "botcity", "stne"]
@@ -13,6 +13,7 @@ readme = "README_PYPI.md"  # Referência ao arquivo README
 # Dependências
 dependencies = [
     "setuptools",
+    "tzdata",
     "python-json-logger",
     "rich",
     "requests",
@@ -21,15 +22,24 @@ dependencies = [
     "zeep",
     "google-cloud-bigquery",
     "google-cloud-storage",
+    "google-cloud-bigquery-storage",
+    "google-auth",
     "google-auth-oauthlib",
     "google-auth-httplib2",
     "google-api-python-client",
+    "google-cloud-documentai",
     "pyjwt",
     "PyYAML",
     "python-dotenv",
     "slack_sdk",
     "webdriver-manager",
+    "botcity-framework-core",
     "botcity-framework-web",
     "email-validator",
-    "botcity-maestro-sdk"
+    "botcity-maestro-sdk",
+    "psutil",
+    "cryptography",
+    "PyPDF2",
+    "openai",
+    "pycurl"
 ]

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/src/csc_cia_stne/__init__.py

@@ -13,6 +13,11 @@ from .provio import Provio
 from .google_drive import GoogleDrive
 from .slack import Slack
 from .web import web_screen
+from .wacess import Waccess
+from .gcp_bucket import GCPBucket
+from .ftp import FTP
+from .gcp_document_ai import GCPDocumentAIClient
+from .jerry import JerryClient
 
 # Define os itens disponíveis para importação
 __all__ = [
@@ -27,8 +32,13 @@ __all__ = [
     "Provio",
     "Email", 
     "GoogleDrive",
+    "GCPDocumentAIClient"
     "Slack",
-    "web_screen"
+    "web_screen",
+    "Waccess",
+    "GCPBucket",
+    "JerryClient"
+    "FTP"
 ]
 
 _diretorio_inicial = os.getcwd()

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/src/csc_cia_stne/bc_correios.py

@@ -7,7 +7,7 @@ from requests.auth import HTTPBasicAuth
 from datetime import timedelta, datetime, time
 from typing import List, Tuple, Union, Optional
 from pydantic import BaseModel
-
+log = logging.getLogger(__name__)
 class PastasAutorizadas(BaseModel):
     MensagemErro: Optional[str] = None
     OcorreuErro: bool
@@ -218,7 +218,7 @@ class BC_Correios:
                     break
                 
                 for correio in correios:
-
+                    
                     item_de_lista_de_correios = ItemListaCorreio(
                         Assunto=correio.Assunto,
                         Data=correio.Data,
@@ -248,17 +248,18 @@ class BC_Correios:
 
                 if len(correios_filtrados) >= proxima_centena:
 
-                    logging.info(f"Página #{pagina_atual}: {len(correios_filtrados)} correios armazenados no total")
+                    log.info(f"Página #{pagina_atual}: {len(correios_filtrados)} correios armazenados no total")
                     proxima_centena = proxima_centena + 100
 
                 # Avança para a próxima página
                 pagina_atual += 1
 
-            return True, correios_filtrados
-        
+            #return True, correios_filtrados
+            return {"success": True, "data": correios_filtrados, "error": None}
+
         except Exception as e:
-            
-            return False, e
+
+            return {"success": False, "data": None, "error": str(e)}
 
     def ler_correio(self, numero:int,data_rebimento:datetime,tipo:str,transicao:int,versao:int,pasta:str)-> Tuple[bool, Union[ItemMsgCorreio, Exception]]:
         """
@@ -425,7 +426,8 @@ class BC_Correios:
             #novo end
 
             #return True, response
-            return True, msg_detail
+            #return True, msg_detail
+            return {"success": True, "data": msg_detail, "error": None}
 
             # Serializa o objeto SOAP em um dicionário Python
             #serialized_response = serialize_object(response)
@@ -437,7 +439,8 @@ class BC_Correios:
 
         except Exception as e:
 
-            return False, e
+            #return False, e
+            return {"success": False, "data": None, "error": str(e)}
         
     def obter_anexo(self, numero:int, versao:int, transicao:int,pasta:str,anexo_id:int,file_name:str,conteudo:str)-> Tuple[bool,Union[dict, Exception]]:
         """
@@ -504,17 +507,20 @@ class BC_Correios:
                 conteudo_anexo = response.Anexo.Conteudo
                 
                 # Retorna os dados capturados como um dicionário
-                return True, {
-                    'IdAnexo': id_anexo,
-                    'NomeAnexo': nome_anexo,
-                    'Conteudo': conteudo_anexo
-                }
+                #return True, {
+                #    'IdAnexo': id_anexo,
+                #    'NomeAnexo': nome_anexo,
+                #    'Conteudo': conteudo_anexo
+                #}
+                return {"success": True, "error": None, "data": conteudo_anexo}
             else:
-                return False, Exception("Correio não possui anexo")
+                return {"success": True, "error": "Correio não possui anexo", "data": None}
+                #return False, Exception("Correio não possui anexo")
         
         except Exception as e:
             
-            return False, e
+            return {"success": False, "error": str(e), "data": None}
+            #return False, e
 
     def encerrar(self):
         """Fecha o cliente e libera a sessão."""

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/src/csc_cia_stne/bc_sta.py

@@ -1,9 +1,57 @@
-from requests.auth import HTTPBasicAuth
+import logging
+import hashlib
 import requests
+from requests.auth import HTTPBasicAuth
 import xml.etree.ElementTree as ET
-import hashlib
-from pydantic import BaseModel, ValidationError, field_validator
-from typing import Literal, Dict, Union, Optional
+from xml.dom.minidom import parseString
+from pydantic import BaseModel, ValidationError, field_validator, Field, HttpUrl
+from typing import Literal, Dict, Union, Optional, List
+from datetime import datetime, timedelta
+
+log = logging.getLogger('__main__')
+
+def xml_to_dict(element):
+    """Converte um elemento XML recursivamente para um dicionário."""
+    if not list(element):  # Se não tem filhos, retorna apenas o texto
+        return element.text.strip() if element.text else ""
+
+    result = {}
+    for child in element:
+        child_data = xml_to_dict(child)
+        if child.tag in result:
+            if isinstance(result[child.tag], list):
+                result[child.tag].append(child_data)
+            else:
+                result[child.tag] = [result[child.tag], child_data]
+        else:
+            result[child.tag] = child_data
+
+    if element.attrib:
+        result["@atributos"] = element.attrib  # Adiciona atributos XML se existirem
+
+    return result
+
+def xml_response_to_json(response_text):
+    """Converte a resposta XML para um dicionário JSON válido."""
+
+    root = ET.fromstring(response_text)
+    lista = xml_to_dict(root)
+    if not isinstance(lista, dict):
+        return []
+    return list(lista.values())[0]  # Agora retorna um dicionário em vez de uma string JSON
+
+def print_element(element, indent=0):
+    """Função recursiva para exibir campos e subcampos"""
+    prefix = " " * (indent * 2)  # Indentação para visualização hierárquica
+    print(f"{prefix}- {element.tag}: {element.text.strip() if element.text else ''}")
+    
+    # Se o elemento tiver atributos, exibir
+    if element.attrib:
+        print(f"{prefix}  Atributos: {element.attrib}")
+    
+    # Percorrer subelementos
+    for child in element:
+        print_element(child, indent + 1)
 
 # Validações dos inputs
 class InitParamsValidator(BaseModel):
@@ -118,7 +166,44 @@ class EnviarArquivoValidator(BaseModel):
                     raise ValueError("Cada destinatário deve conter as chaves 'unidade', 'dependencia' e 'operador'. Verifique a documentação da API BC STA para entender o que colocar cada campo")
         
         return value
-    
+
+class ListarArquivosParams(BaseModel):
+    """
+    Parâmetros para listar arquivos disponíveis na API STA.
+
+    Atributos:
+        nivel (str): Nível de detalhe da consulta. Aceita apenas 'RES', 'BAS' ou 'COMPL'.
+        inicio (str): Data e hora de início no formato ISO 8601 (yyyy-MM-ddTHH:mm:ss).
+        fim (str): Data e hora de fim no formato ISO 8601 (yyyy-MM-ddTHH:mm:ss).
+        situacao (Optional[str]): Situação da transmissão, podendo ser 'REC' ou 'A_REC'.
+        identificadorDocumento (Optional[str]): Identificador do documento, se aplicável.
+        qtd (int): Quantidade máxima de resultados (valor padrão: 100, máximo permitido: 100).
+        tipo_arquivo (list): lista de tipos de arquivo para filtrar ['ACCS002','ACCS003','AJUD301','AJUD302','AJUD303','AJUD304','AJUD305','AJUD308','AJUD309','AJUD310','AJUD331','AMES102','AMTF102','ASVR9810','ATXB001']
+    """
+    nivel: Literal['RES', 'BAS', 'COMPL']
+    #inicio: str = Field(..., regex=r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
+    inicio: str = Field(..., pattern=r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
+    fim: Optional[str] = Field(None, pattern=r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$")
+    situacao: Optional[Literal['REC', 'A_REC']] = None
+    identificadorDocumento: Optional[str] = None
+    qtd: int = Field(default=100, le=100)
+    #tipo_arquivo: Optional[str] = None
+    tipo_arquivo: Optional[List[
+        Literal[
+            'ACCS002', 'ACCS003', 'AJUD301', 'AJUD302', 'AJUD303', 'AJUD304', 'AJUD305', 'AJUD308',
+            'AJUD309', 'AJUD310', 'AJUD331', 'AMES102', 'AMTF102', 'ASVR9810', 'ATXB001'
+        ]
+    ]] = None
+
+class DownloadArquivoParams(BaseModel):
+    protocolo: str = Field(..., min_length=1, description="Código do protocolo")
+    filename: Optional[str] = Field(None, description="Nome e caminho do arquivo")
+
+class DownloadArquivoResponse(BaseModel):
+    success: bool = Field(..., description="Indica se o download foi bem-sucedido")
+    status_code: int = Field(..., ge=100, le=599, description="Código de status HTTP")
+    content: Union[bytes, str] = Field(..., description="Conteúdo do arquivo (em bytes se sucesso, em string se erro)")
+
 class BC_STA:
     
     def __init__(self, usuario:str, senha:str, ambiente:str):
@@ -183,11 +268,17 @@ class BC_STA:
             
             # Verificando o status e retornando a resposta
             if response.status_code == 200:
-
+                
                 return True
 
+            elif response.status_code == 401:
+                
+                log.error(f"Erro de autenticação no BC STA: Verifique o usuário e a senha.\n{response.text}")
+                return False
+            
             else:
 
+                log.error(f"Erro ao autenticar no BC STA: {response.text}")
                 return False
 
 
@@ -414,3 +505,194 @@ class BC_STA:
             #return f"Failed to create protocol. Status code: {response.status_code}, Reason: {response.reason}"
             return resposta
 
+    def listar_arquivos(self, 
+                        nivel: Literal['RES', 'BAS', 'COMPL'], 
+                        inicio: str, 
+                        fim: str = None,
+                        situacao: Optional[Literal['REC', 'A_REC']] = None, 
+                        identificadorDocumento: Optional[str] = None, 
+                        qtd: int = 100, 
+                        tipo_arquivo: list = None):
+        resultados = []
+
+        try:
+            # Parse seguro para datetime (assume formato ISO 'AAAA-MM-DDTHH:MM:SS')
+            dt_inicio = datetime.fromisoformat(inicio)
+            dt_fim = datetime.fromisoformat(fim) if fim else None
+            ultima_dt = dt_inicio
+
+            while True:
+                # Se já passamos do fim, encerra antes de chamar a API
+                if dt_fim and ultima_dt >= dt_fim:
+                    break
+
+                # Monta a URL usando a data atual do cursor
+                _inicio_str = ultima_dt.strftime("%Y-%m-%dT%H:%M:%S")
+                url = f"{self.base_url}/arquivos?tipoConsulta=AVANC&nivelDetalhe={nivel}"
+                url += f"&dataHoraInicio={_inicio_str}"
+                if situacao:
+                    url += f"&situacaoTransmissao={situacao}"
+                if identificadorDocumento:
+                    url += f"&identificadorDocumento={identificadorDocumento}"
+                if dt_fim:
+                    _fim_str = dt_fim.strftime("%Y-%m-%dT%H:%M:%S")
+                    url += f"&dataHoraFim={_fim_str}"
+                url += f"&qtdMaxResultados={qtd}"
+
+                response = requests.get(
+                    url, headers=self.headers, auth=self.auth, timeout=60,
+                )
+
+                if response.status_code != 200:
+                    resposta = {"success": False, "status_code": int(response.status_code), "content": f"Erro ao listar arquivos: {response.text}"}
+                    return resposta
+
+                try:
+                    dados = xml_response_to_json(response.text)
+                    if not dados:
+                        break  # sem mais resultados
+
+                    # Normaliza dados para lista
+                    itens = dados if isinstance(dados, list) else [dados]
+
+                    # (opcional) filtra por tipo_arquivo
+                    if tipo_arquivo is not None:
+                        itens = [a for a in itens if a.get("TipoArquivo") in tipo_arquivo]
+
+                    resultados.extend(itens)
+
+                    # Atualiza o cursor a partir do último item retornado
+                    # Busca o último com DataHoraDisponibilizacao
+                    ultimo = None
+                    for cand in reversed(itens):
+                        if "DataHoraDisponibilizacao" in cand and cand["DataHoraDisponibilizacao"]:
+                            ultimo = cand["DataHoraDisponibilizacao"]
+                            break
+
+                    if not ultimo:
+                        # fallback: se o JSON bruto vier como dict/list diferente, tente no original
+                        if isinstance(dados, list) and dados and "DataHoraDisponibilizacao" in dados[-1]:
+                            ultimo = dados[-1]["DataHoraDisponibilizacao"]
+                        elif isinstance(dados, dict) and "DataHoraDisponibilizacao" in dados:
+                            ultimo = dados["DataHoraDisponibilizacao"]
+
+                    if not ultimo:
+                        resposta = {"success": False, "status_code": 500, "content": "Campo 'DataHoraDisponibilizacao' não encontrado ou estrutura inesperada."}
+                        return resposta
+
+                    # Cursor: último + 1s para evitar repetir o mesmo registro
+                    proxima_dt = datetime.fromisoformat(ultimo) + timedelta(seconds=1)
+
+                    # Se a próxima dt já ultrapassa o fim, encerramos sem nova chamada
+                    if dt_fim and proxima_dt > dt_fim:
+                        break
+
+                    ultima_dt = proxima_dt
+
+                except ET.ParseError as e:
+                    resposta = {"success": False, "status_code": 500, "content": f"Erro ao processar XML: {e}"}
+                    return resposta
+
+            return {"success": True, "status_code": 200, "content": resultados}
+
+        except Exception as e:
+            resposta = {"success": False, "status_code": 500, "content": f"Erro em BC_STA:listar_arquivos: {e}"}
+            return resposta
+
+    def download_arquivo(self,protocolo:str,filename:str=None):
+        """Faz o download de um arquivo de um protocolo especifico
+
+        Args:
+            protocolo (str): protocolo
+            filename (str): path+nome do arquivo
+
+        Returns:
+            dict: {"success": bool, "status_code": int, "content": bytes/str}
+        """
+        
+        # Validação dos parâmetros
+        try:
+        
+            params = DownloadArquivoParams(protocolo=protocolo, filename=filename)
+        
+        except ValidationError as e:
+        
+            return Exception(str(e))
+        
+        url = f"/arquivos/{protocolo}/conteudo"
+        response = requests.get(
+            self.base_url + url,
+            auth=self.auth, 
+            timeout=60,
+            headers={"Connection": "keep-alive"},
+        )
+
+        if response.status_code == 200:
+            
+            if filename is not None:
+                
+                try:
+                
+                    with open(filename, "wb") as arquivo:
+                
+                        arquivo.write(response.content)
+                
+                except Exception as e:
+                
+                    raise Exception(f"Falha ao salvar o arquivo em disco\n{str(e)}")
+                
+            return {"success": True, "status_code": int(response.status_code), "content": response.content }
+        
+        else:
+        
+            return {"success": False, "status_code": int(response.status_code), "content": response.text}
+
+    def qs_gerar_xml_string_responder_nao_cliente(self,protocolo_inicial_ordem:str,numctrlccs:str,cnpj_cpf:str,numctrlenvio:str,numprocjud:str,identdemissor:str,identddestinatario:str,domsist:str,nuop:str,dtmovto:datetime,cnpjbaseentrespons:str):
+        
+        """Gera a string do arquivo XML de resposta para nao-cliente para ser enviado ao STA
+        Args:
+            protocolo_inicial_ordem (str): protocolo inicial da ordem de quebra de sigilo, do arquivo AMES102
+            numctrlccs (str): numero de controle ccs
+            cnpj_cpf (str): documento do solicitado
+            numctrlenvio (str): numero de controle de envio
+            numprocjud (str): numero do processo judicial
+            identdemissor (str): identificacao do emissor
+            identddestinatario (str): identificacao do destinatario
+            domsist (str): domsist
+            nuop (str): numero da operacao
+            dtmovto (datetime): data da movimentacao
+            cnpjbaseentrespons (str): cnpjbaseentrespons
+        Returns:
+            str: string formatada para gerar um arquivo xml de resposta
+        """
+        try:
+
+            ns = "http://www.bcb.gov.br/MES/CCS0012.xsd"
+            
+            doc = ET.Element("DOC", xmlns=ns)
+            
+            bcmsg = ET.SubElement(doc, "BCMSG")
+            ET.SubElement(bcmsg, "IdentdEmissor").text = identdemissor
+            ET.SubElement(bcmsg, "IdentdDestinatario").text = identddestinatario
+            ET.SubElement(bcmsg, "DomSist").text = domsist
+            ET.SubElement(bcmsg, "NUOp").text = nuop
+            
+            sismsg = ET.SubElement(doc, "SISMSG")
+            ccs0012 = ET.SubElement(sismsg, "CCS0012")
+            ET.SubElement(ccs0012, "CodMsg").text = "CCS0012"
+            ET.SubElement(ccs0012, "CNPJBaseEntRespons").text = cnpjbaseentrespons
+            ET.SubElement(ccs0012, "NumCtrlCCSOr").text = numctrlccs
+            ET.SubElement(ccs0012, "SitAtedmntReq").text = "03"
+            ET.SubElement(ccs0012, "DtMovto").text = dtmovto.strftime("%Y-%m-%d")
+            
+            #return ET.tostring(doc, encoding="utf-8", xml_declaration=True).decode("utf-8")
+            xml_str = ET.tostring(doc, encoding="utf-8", xml_declaration=True).decode("utf-8")
+
+            # Formatando XML com indentação para melhor visualização
+            xml_formatado = parseString(xml_str).toprettyxml(indent="  ")
+            return xml_formatado
+        
+        except Exception as e:
+        
+            raise Exception(f"Falha ao gerar XML de resposta de Quebra de Sigilo:\n{e}")
+        

{csc_cia_stne-0.0.56 → csc_cia_stne-0.1.49}/src/csc_cia_stne/email.py

@@ -150,7 +150,7 @@ class Email():
             }
 
     
-    def send_email( self, to : list , message : str , title : str , reply_to: str, attachments : list = [] , cc : list = [] , cco : list = [] ) -> dict:
+    def send_email( self, to : list , message : str , title : str , reply_to: str, attachments : list = [] , cc : list = [] , cco : list = [], from_mask: str = "", block_by_attachments:bool=False) -> dict:
         """
         Envia um email com os parâmetros fornecidos.
         Args:
@@ -161,6 +161,7 @@ class Email():
             attachments (list, optional): Lista de caminhos dos arquivos anexos. Defaults to [].
             cc (list, optional): Lista de destinatários em cópia. Defaults to [].
             cco (list, optional): Lista de destinatários em cópia oculta. Defaults to [].
+            from_mask (str, optional): Mascara para definir como se o envio estivesse vindo de outro email
         Returns:
             dict: Dicionário com o status do envio do email. Se o envio for bem-sucedido, o dicionário terá a chave 'status' com valor True. Caso contrário, terá a chave 'status' com valor False e a chave 'error' com a descrição do erro.
         Raises:
@@ -189,8 +190,14 @@ class Email():
         try:
 
             msg = MIMEMultipart()
+
+            if from_mask != "":
             
-            msg["From"] = self.email_sender
+                msg["From"] = from_mask
+
+            else:
+
+                msg["From"] = self.email_sender
             
             msg["To"] = (",").join(to)
             
@@ -220,10 +227,12 @@ class Email():
 
                 except Exception as e:
 
-                    return {
-                        'status':False,
-                        'error':str(e)
-                    }
+                    if block_by_attachments:
+
+                        return {
+                            'status':False,
+                            'error':str(e)
+                        }
 
             msg.attach(MIMEText(message, 'html'))