csc-cia-stne 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

csc_cia_stne/__init__.py

@@ -15,6 +15,7 @@ from .stne_admin import StoneAdmin
 from .bc_sta import BC_STA
 from .bc_correios import BC_Correios
 from .gcp_bigquery import BigQuery
+from .email import Email
 #from .utilitarios.functions import titulo
 # Define os itens disponíveis para importação
 __all__ = [
@@ -25,5 +26,6 @@ __all__ = [
     "StoneAdmin",
     "ServiceNow",
     "Util",
-    "logger"
+    "logger",
+    "Email"
 ]

csc_cia_stne/bc_sta.py

@@ -1,10 +1,8 @@
 from requests.auth import HTTPBasicAuth
-import sys
-from pydantic import BaseModel
 import requests
 import xml.etree.ElementTree as ET
 import hashlib
-from pydantic import BaseModel, StrictStr, StrictInt, ValidationError, field_validator, FieldValidationInfo
+from pydantic import BaseModel, ValidationError, field_validator
 from typing import Literal, Dict, Union, Optional
 
 # Validações dos inputs

csc_cia_stne/email.py

@@ -0,0 +1,142 @@
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+from pydantic import BaseModel, ValidationError, field_validator
+
+class InitParamsValidator(BaseModel):
+    email_sender: str
+    email_password: str
+
+    @field_validator('email_sender','email_password')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value
+    
+class SendEmailParamsValidator(BaseModel):
+
+    to: list
+    message: str
+    title: str
+    reply_to:str
+    attachments: list = []
+    cc: list = []
+    cco: list = []
+
+    @field_validator('message','title','reply_to')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value
+    
+    @field_validator('to','attachments','cc','cco')
+    def check_list_input(cls, value, info):
+        if not isinstance(value, list):
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma lista")
+        
+        return value
+
+class Email():
+
+    def __init__(self, email_sender, email_password):
+
+        self.email_sender = email_sender
+        self.email_password = email_password
+
+        try:
+        
+            InitParamsValidator(email_sender=email_sender, email_password=email_password)
+
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
+
+
+        self.server = self.login_email()
+
+        if not isinstance(self.server, smtplib.SMTP) and 'status' in self.server and not self.server['status']:
+
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", self.server['error'])
+
+
+    def login_email(self):
+
+        try:
+
+            server = smtplib.SMTP('smtp.gmail.com', 587)
+            server.starttls()
+            server.login(self.email_sender, self.email_password)
+
+            return server
+
+        except Exception as e:
+
+            return {
+                'status':False,
+                'error':str(e)
+            }
+
+    
+    def send_email( self, to : list , message : str , title : str , reply_to: str, attachments : list = [] , cc : list = [] , cco : list = [] ) -> dict:
+
+        try:
+        
+            SendEmailParamsValidator(to=to, message=message, title=title, reply_to=reply_to, attachments=attachments, cc=cc, cco=cco)
+
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados para o envio do email:", e.errors())
+
+        try:
+
+            msg = MIMEMultipart()
+            
+            msg["From"] = self.email_sender
+            
+            msg["To"] = (",").join(to)
+            
+            msg["cc"] = (",").join(cc)
+            
+            msg['Reply-To'] = reply_to
+
+            msg["Subject"] = title
+
+            for file in attachments:
+
+                try:
+
+                    attachment = open(file, "rb")
+                    
+                    part = MIMEBase("application", "octet-stream")
+                    
+                    part.set_payload(attachment.read())
+                    
+                    encoders.encode_base64(part)
+                    
+                    part.add_header("Content-Disposition", f"attachment; filename={file.split('/')[-1]}")
+                    
+                    msg.attach(part)
+
+                    attachment.close()
+
+                except Exception as e:
+
+                    return {
+                        'status':False,
+                        'error':str(e)
+                    }
+
+            msg.attach(MIMEText(message))
+
+            self.server.sendmail(self.email_sender, to + cc + cco, msg.as_string())
+
+            return True
+
+        except Exception as e:
+
+            return {
+                'status':False,
+                'error':str(e)
+            }

csc_cia_stne/gcp_bigquery.py

@@ -2,10 +2,104 @@ from google.cloud import bigquery
 import json
 import os
 from google.oauth2 import service_account
+from pydantic import BaseModel, ValidationError, field_validator,model_validator
+
+class InitParamsValidator(BaseModel):
+    limit:int
+    id_project:str
+    creds_dict:dict
+    creds_file:str
+
+    @field_validator('limit')
+    def check_input_basic(cls, value, info):
+        if not isinstance(value, int):
+            raise ValueError(f"O parametro 'limit' deve ser um inteiro e não um {type(value)}")
+        
+        return value
+
+    @field_validator('id_project')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro 'id_project' deve ser uma string e não um {type(value)} e não vazio")
+        return value
+    
+    @model_validator(mode="after")
+    def check_others_input(cls, model):
+        creds_dict = model.creds_dict
+        creds_file = model.creds_file
+
+        if isinstance(creds_dict, dict):
+            return model
+
+        elif isinstance(creds_file, str) and creds_file.strip():
+            return model
+
+        else:
+            raise ValueError("Pelo menos um dos parâmetros 'creds_dict' ou 'creds_file' deve ser fornecido.")
+        
+
+class tryQueryValidator(BaseModel):
+
+    query_to_execute:str
+    organize:bool
+    use_legacy:bool
+    use_cache:bool
+    query_parameters:list
+
+    @field_validator('query_to_execute')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string não vazia")
+        
+        return value
+    
+    @field_validator('organize','use_legacy','use_cache')
+    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
+    
+    @field_validator('query_parameters')
+    def check_list_input(cls, value, info):
+        if not isinstance(value, list):
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma lista")
+        
+        return value
+
+
+class tryInsertListValidator(BaseModel):
+
+    insert_limit:int
+    list_to_insert:list
+    table:str
+
+    @field_validator('list_to_insert')
+    def check_list_input(cls, value, info):
+        if not isinstance(value, list) and len(value) > 0:
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma lista e não estar vazia")
+        
+        return value
+    
+    @field_validator('table')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string não vazia")
+        
+        return value
+    
+    @field_validator('insert_limit')
+    def check_int_input(cls, value, info):
+        if not isinstance(value, int) or value > 10000:
+            raise ValueError(f"O parametro '{info.field_name}' deve ser um inteiro não maior que 10000")
+        
+        return value
 
 class BigQuery():
 
-    def __init__(self, client: bigquery.Client, limit: int = 3):
+
+    def __init__(self, id_project: str, creds_dict: dict = None, creds_file: str = "", limit: int = 3):
+        
         """
         Inicializa a classe BigQuery.
         Parâmetros:
@@ -14,9 +108,21 @@ class BigQuery():
         """
 
         self.limit = limit
-        self.client = client
+        self.id_project = id_project
+        self.creds_dict = creds_dict
+        self.creds_file = creds_file
+        self.client = self.create_client()
 
-    def create_client(id_project: str, creds_dict: dict = None, creds_file: str = "") -> bigquery.Client:
+        try:
+        
+            InitParamsValidator(limit=limit, id_project=id_project, creds_dict=creds_dict, creds_file=creds_file)
+
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
+
+
+    def create_client(self) -> bigquery.Client:
         """
         Cria um cliente BigQuery com base nas credenciais fornecidas.
         Parâmetros:
@@ -34,19 +140,19 @@ class BigQuery():
 
         try:
 
-            if(creds_dict is not None):
+            if(self.creds_dict is not None):
 
                 credentials = service_account.Credentials.from_service_account_info(
-                    creds_dict,
+                    self.creds_dict,
                     scopes=["https://www.googleapis.com/auth/cloud-platform"],
                 )
 
-                client = bigquery.Client(credentials=credentials, project=id_project)
+                client = bigquery.Client(credentials=credentials, project=self.id_project)
 
-            elif(str(creds_file) > 0):
+            elif(str(self.creds_file) > 0):
 
                 credentials = service_account.Credentials.from_service_account_file(
-                    creds_file,
+                    self.creds_file,
                     scopes=["https://www.googleapis.com/auth/cloud-platform"],
                 )
 
@@ -67,7 +173,9 @@ class BigQuery():
                 'details':str(e)
             }
 
-    def try_query(self, query_to_execute:str,organize:bool=True) -> dict:
+
+    def try_query(self, query_to_execute: str, organize: bool = False, use_legacy: bool = False, use_cache: bool = False, query_parameters: list = []) -> dict:
+
         """
         Executa uma consulta no BigQuery e retorna o resultado.
         Args:
@@ -85,13 +193,28 @@ class BigQuery():
                     'status': False,
         """
         
+        try:
+
+            tryQueryValidator(query_to_execute=query_to_execute, organize=organize, use_legacy=use_legacy, use_cache=use_cache, query_parameters=query_parameters)
+
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da função para tentar executar a query:", e.errors())
+
         error = ""
 
         for try_out in range(self.limit):
 
             try:
 
-                result_query = self.client.query(query_to_execute).result()
+                job_config = bigquery.QueryJobConfig(
+                    priority=bigquery.QueryPriority.INTERACTIVE,
+                    use_legacy_sql=use_legacy,
+                    use_query_cache=use_cache,
+                    query_parameters=query_parameters,
+                )
+
+                result_query = self.client.query(query_to_execute,job_config=job_config).result()
 
                 error = False
 
@@ -121,14 +244,15 @@ class BigQuery():
                 'error': str(error)
             }
 
-    def insert_list(self,table:str,dict_to_insert:dict=[]) -> dict:
+
+    def insert_list(self, table: str, list_to_insert: list = [], insert_limit: int = 10000) -> dict:
         
         """
         Insere uma lista de dicionários em uma tabela do BigQuery.
         Args:
             client (bigquery.Client): Cliente do BigQuery.
             table (str): Nome da tabela onde os dados serão inseridos.
-            dict_to_insert (dict, optional): Lista de dicionários a serem inseridos. O padrão é [].
+            list_to_insert (dict, optional): Lista de dicionários a serem inseridos. O padrão é [].
             limit_trys (int, optional): Número máximo de tentativas de inserção. O padrão é 3.
         Returns:
             dict: Dicionário contendo o status da inserção e informações adicionais.
@@ -138,16 +262,24 @@ class BigQuery():
                     {'status': False, 'error': error, 'last_try': list_to_insert, 'inserted': inserted}
         """
 
+        try:
+
+            tryInsertListValidator(table=table, list_to_insert=list_to_insert, insert_limit=insert_limit)
+
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da função para tentar inserir dados em uma tabela:", e.errors())
+
         table_ref = self.client.get_table(table)
 
         error = ""
 
         inserted = []
 
-        for data in range(0, len(dict_to_insert), 10000):
+        for data in range(0, len(list_to_insert), insert_limit):
 
             # listagem que será inserida no big query
-            list_to_insert = dict_to_insert[data:data+10000]
+            list_to_insert = list_to_insert[data:data+10000]
 
             for try_out in range(self.limit):
 

csc_cia_stne/logger_rich.py

@@ -97,7 +97,8 @@ def add_log_level(level_name, level_num, method_name=None):
         
         if self.isEnabledFor(level_num):
 
-            self._log(level_num, message, args, **kwargs)
+            #self._log(level_num, message, args, **kwargs)
+            self._log(level_num, message, args, **{**kwargs, "stacklevel": 2})
             
     def log_to_root(message, *args, **kwargs):
         

{csc_cia_stne-0.0.24.dist-info → csc_cia_stne-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csc_cia_stne
-Version: 0.0.24
+Version: 0.0.26
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa
@@ -10,7 +10,7 @@ Requires-Dist: python-json-logger
 Requires-Dist: rich
 Requires-Dist: requests
 Requires-Dist: pydantic
-Requires-Dist: pydantic-settings
+Requires-Dist: pydantic_settings
 Requires-Dist: zeep
 Requires-Dist: google-cloud-bigquery
 Requires-Dist: google-cloud-storage

{csc_cia_stne-0.0.24.dist-info → csc_cia_stne-0.0.26.dist-info}/RECORD

@@ -1,10 +1,11 @@
-csc_cia_stne/__init__.py,sha256=IYTgLq8P6SHJM4EcpD91iex1u_hAuQ3-thxIlLQ91R4,720
+csc_cia_stne/__init__.py,sha256=xTOb4_9Z6FrZqXGT1zIjtgVady-GO5IwnddAaaV_gj0,758
 csc_cia_stne/bc_correios.py,sha256=ANsvLyL7wdkM0MvjjBHB2Ih4eyTcyWgt5IqiK0Rv89E,23014
-csc_cia_stne/bc_sta.py,sha256=I9N29wjTbd4ZmoM2yIW-xp3X-dMENZdSb0JhapfCegY,10988
-csc_cia_stne/gcp_bigquery.py,sha256=f8UEQgr6XyFacYX0bRq4UDmWoH-0XqZF8fA2LsLTtAU,5654
+csc_cia_stne/bc_sta.py,sha256=uyoCp-KTpkWwpyWNWp20JuDfMRYGCKxERnRQVso80iQ,10903
+csc_cia_stne/email.py,sha256=TGh4JrEPLcGV0djBxQf7yaCbQFRqXHGiHJfk1jTwzJo,4152
+csc_cia_stne/gcp_bigquery.py,sha256=U-m0vPmnzzVDFonY9YrDnB-93E-fSpzNO1JjGDSB7dY,10190
 csc_cia_stne/karavela.py,sha256=Q7MbQXXz_jtrLHM7QeenbSzcro07EpoFk4lKglivJ_I,3564
 csc_cia_stne/logger_json.py,sha256=2G0rm0lyCtHn4o2v7fzn4wMylb0A_nbxiQatnrSZxHs,1212
-csc_cia_stne/logger_rich.py,sha256=yW1py7k5yY5Fay5I_eY-ulMGGSmFGGhUl3Q4U8aczbo,3392
+csc_cia_stne/logger_rich.py,sha256=WcfmdbsQuVfz_lbZ1v1wtrGspaESu-PdQthyuLkKQjM,3472
 csc_cia_stne/servicenow.py,sha256=vSsNSANFyCZtDu2O7YmdoCbr-_bO1sgMWnOI29mFBOA,23311
 csc_cia_stne/stne_admin.py,sha256=G5ozXt18VjKL2BHtROQk4GnfVY1xM14RXSQ-rra_D54,15487
 csc_cia_stne/utilitarios/__init__.py,sha256=4YFhzxu8F_CDHU6iaNhpzz9mfX-8wfJc1XEQInJzwJ4,98
@@ -13,8 +14,8 @@ csc_cia_stne/utilitarios/functions/func_b64.py,sha256=XGU34BIQQXWXBS0yM2B4A2wDlc
 csc_cia_stne/utilitarios/functions/func_converters.py,sha256=EY1zvlBaRX7G1MceVSiRXwwKDQDZwUO9iECBL0fe5iU,481
 csc_cia_stne/utilitarios/functions/func_recriar_pastas.py,sha256=2_unoSoQHxShcMw_0XIL9F0NgiF1QCKsX4drvg0fEb8,415
 csc_cia_stne/utilitarios/functions/func_titulo.py,sha256=EhUtsiIOAz4yERNZl3EOHjiFLjj4rK3pr_KB0DxwGIA,3943
-csc_cia_stne-0.0.24.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
-csc_cia_stne-0.0.24.dist-info/METADATA,sha256=CiP_W79ifwOjgz6TbKMAVpl0BczsgxhdNQqpZN2G-ow,1003
-csc_cia_stne-0.0.24.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-csc_cia_stne-0.0.24.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
-csc_cia_stne-0.0.24.dist-info/RECORD,,
+csc_cia_stne-0.0.26.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.0.26.dist-info/METADATA,sha256=NRg5PPo6abhue9hU873kKPDiKmJSoJ4d2i5l21ALE4w,1003
+csc_cia_stne-0.0.26.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+csc_cia_stne-0.0.26.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.0.26.dist-info/RECORD,,

{csc_cia_stne-0.0.24.dist-info → csc_cia_stne-0.0.26.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any