csc-essentials 1.2.2__tar.gz → 1.2.4__tar.gz

{csc_essentials-1.2.2/src/csc_essentials.egg-info → csc_essentials-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc-essentials
-Version: 1.2.2
+Version: 1.2.4
 Summary: Biblioteca de utilitários essenciais para projetos CSC
 Author-email: David Braga <david.braga@stone.com.br>
 License: MIT

{csc_essentials-1.2.2 → csc_essentials-1.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csc-essentials"
-version = "1.2.2"
+version = "1.2.4"
 description = "Biblioteca de utilitários essenciais para projetos CSC"
 readme = "README.md"
 requires-python = ">=3.9"

{csc_essentials-1.2.2 → csc_essentials-1.2.4}/src/csc_essentials/utils.py

@@ -25,17 +25,12 @@ def ajusta_nome_coluna(nome_coluna):
 
 
 def converter_valor(row, schema_map, gerador_log):
-    """Converte e sanitiza os valores de uma linha segundo o `schema_map`.
-
-    - Recebe `row` (dict coluna->valor) e `schema_map` (coluna->TIPO BigQuery).
-    - Converte tipos básicos (STRING, INTEGER, FLOAT, BOOLEAN, DATE, DATETIME).
-    - Sanitiza NaN/Inf, strings nulas do Pandas e formata datas no padrão aceito pelo BigQuery.
-    - Trata formatos de moeda BR/US, datas BR (DD/MM/YYYY), datetime BR e padrão MMM-AA.
-    - Em falhas de conversão registra avisos e armazena `None` no campo.
+    """
+    Converte os valores e sanitiza para evitar erros de JSON parsing no BigQuery (NaN, Infinity).
     """
 
     if not schema_map:
-        return row
+        return row 
 
     nova_linha = {}
 
@@ -47,17 +42,15 @@ def converter_valor(row, schema_map, gerador_log):
     )
 
     for col, val in row.items():
-        # Captura "nan" vindo do Pandas e demais strings que representam nulo
+        # MELHORIA: Capturar "nan" vindo do Pandas ou strings que representam nulo
         val_str_check = str(val).strip().lower() if val is not None else ""
         if val is None or val_str_check in ("", "nan", "none", "null", "undefined"):
             nova_linha[col] = None
             continue
-
         if col == "data_import":
             nova_linha[col] = val
             continue
 
-        # Serializa estruturas complexas para JSON
         if isinstance(val, (dict, list)):
             try:
                 nova_linha[col] = json.dumps(val, ensure_ascii=False)
@@ -68,9 +61,9 @@ def converter_valor(row, schema_map, gerador_log):
         tipo_bq = schema_map.get(col, "STRING")
 
         try:
-            if tipo_bq == "STRING":
+            if tipo_bq == "STRING": 
                 # Remove quebras de linha e caracteres de controle que corrompem o JSONL
-                val_str = str(val).replace("\n", " ").replace("\r", "").replace("\t", " ").strip()
+                val_str = str(val).replace('\n', ' ').replace('\r', '').replace('\t', ' ').strip()
                 # Remove caracteres não-imprimíveis (ASCII < 32) exceto espaço
                 val_str = "".join(ch for ch in val_str if ord(ch) >= 32)
                 nova_linha[col] = val_str
@@ -80,28 +73,27 @@ def converter_valor(row, schema_map, gerador_log):
                 nova_linha[col] = int(float(str(val)))
 
             elif tipo_bq in ("FLOAT", "FLOAT64", "NUMERIC"):
-                # Limpeza inicial de moeda e espaços
-                val_str = str(val).replace("R$", "").replace(" ", "").strip()
+                # 1. Limpa moeda e espaços
+                val_str = str(val).replace('R$', '').replace(' ', '').strip()
 
-                # Trata traço como zero (comum em planilhas)
-                if val_str in ("-", ""):
+                if val_str in ('-', ''):
                     nova_linha[col] = 0.0
                 else:
-                    # Lógica inteligente para vírgulas e pontos
-                    if "," in val_str and "." in val_str:
-                        # Se a vírgula vem antes do ponto (ex: 1,510,000.00) -> padrão US
-                        if val_str.find(",") < val_str.rfind("."):
-                            val_str = val_str.replace(",", "")
+                    # 2. Lógica inteligente para vírgulas e pontos
+                    if ',' in val_str and '.' in val_str:
+                        # Se tem os dois, e a vírgula vem antes do ponto (ex: 1,510,000.00)
+                        if val_str.find(',') < val_str.rfind('.'):
+                            val_str = val_str.replace(',', '') # Padrão US: remove vírgula
                         else:
-                            # Padrão BR: 1.000,00
-                            val_str = val_str.replace(".", "").replace(",", ".")
-                    elif "," in val_str:
-                        # Só vírgula: se parte decimal tem <= 2 dígitos trata como decimal
-                        partes = val_str.split(",")
+                            val_str = val_str.replace('.', '').replace(',', '.') # Padrão BR
+                    elif ',' in val_str:
+                        # Se só tem vírgula, checamos se parece decimal (ex: 10,50) ou milhar (1,000)
+                        # Se houver apenas uma vírgula e ela estiver nas últimas 3 posições: decimal
+                        partes = val_str.split(',')
                         if len(partes[-1]) <= 2:
-                            val_str = val_str.replace(".", "").replace(",", ".")
+                            val_str = val_str.replace('.', '').replace(',', '.')
                         else:
-                            val_str = val_str.replace(",", "")
+                            val_str = val_str.replace(',', '')
 
                     try:
                         valor_float = float(val_str)
@@ -110,85 +102,71 @@ def converter_valor(row, schema_map, gerador_log):
                         else:
                             nova_linha[col] = valor_float
                     except ValueError:
-                        gerador_log.add(
-                            f"AVISO: Não foi possível converter '{val}' para FLOAT. Coluna: {col}. Enviando NULL.",
-                            severity="WARNING",
-                        )
+                        gerador_log.add(f"AVISO: Não foi possível converter '{val}' para FLOAT. Coluna: {col}. Enviando NULL.")
                         nova_linha[col] = None
 
             elif tipo_bq in ("BOOLEAN", "BOOL"):
                 nova_linha[col] = str(val).lower() in ("true", "1", "t", "yes")
 
             elif tipo_bq == "DATE":
-                val_str = str(val).strip().upper()
-
-                meses_pt_en = {
-                    "JAN": "01", "FEV": "02", "FEB": "02", "MAR": "03",
-                    "ABR": "04", "APR": "04", "MAI": "05", "MAY": "05",
-                    "JUN": "06", "JUL": "07", "AGO": "08", "AUG": "08",
-                    "SET": "09", "SEP": "09", "OUT": "10", "OCT": "10",
-                    "NOV": "11", "DEZ": "12", "DEC": "12",
-                }
-
-                # Trata formato DD/MMM/AA (ex: 22/JAN/26 ou 22/jan/26)
-                match_dma = re.match(r"^(\d{2})/([A-Z]{3})/(\d{2})$", val_str)
-                # Trata formato MMM-AA (ex: FEB-26)
-                match_ma = re.match(r"^([A-Z]{3})-(\d{2})$", val_str)
-                # Trata formato DD/MM/YYYY
-                match_br = regex_data_br.match(val_str)
-
-                if match_dma:
-                    mes = meses_pt_en.get(match_dma.group(2), "01")
-                    ano = f"20{match_dma.group(3)}"
-                    nova_linha[col] = f"{ano}-{mes}-{match_dma.group(1)}"
-                elif match_ma:
-                    mes = meses_pt_en.get(match_ma.group(1), "01")
-                    ano = f"20{match_ma.group(2)}"
+                val_str = str(val).strip().upper() # Garante que FEB-26 fique maiúsculo
+                
+                # 1. Trata o caso 'FEB-26' (Mês-Ano)
+                # Regex para capturar algo como AAA-99
+                regex_mes_ano = re.compile(r"^([A-Z]{3})-(\d{2})$")
+                match_ma = regex_mes_ano.match(val_str)
+                
+                if match_ma:
+                    meses = {
+                        'JAN': '01', 'FEB': '02', 'MAR': '03', 'APR': '04', 'MAY': '05', 'JUN': '06',
+                        'JUL': '07', 'AUG': '08', 'SEP': '09', 'OCT': '10', 'NOV': '11', 'DEC': '12'
+                    }
+                    mes = meses.get(match_ma.group(1), '01')
+                    ano = f"20{match_ma.group(2)}" # Assume 20xx
+                    # Como o BQ exige dia, vamos fixar no dia 01 do mês
                     nova_linha[col] = f"{ano}-{mes}-01"
-                elif match_br:
-                    nova_linha[col] = f"{match_br.group(3)}-{match_br.group(2)}-{match_br.group(1)}"
+                
                 else:
-                    nova_linha[col] = val_str[:10] if len(val_str) >= 10 else None
+                    # 2. Lógica que já tínhamos para DD/MM/YYYY
+                    val_str = val_str.replace('0224','2024').replace('0202','2022').replace('0204','2024')
+                    match_br = regex_data_br.match(val_str)
+                    if match_br:
+                        nova_linha[col] = f"{match_br.group(3)}-{match_br.group(2)}-{match_br.group(1)}"
+                    else:
+                        # Tenta pegar apenas os primeiros 10 caracteres (YYYY-MM-DD)
+                        nova_linha[col] = val_str[:10] if len(val_str) >= 10 else None
 
             elif tipo_bq == "DATETIME":
                 val_str = str(val).strip()
-
-                # Tenta formato brasileiro DD/MM/YYYY HH:MM:SS
-                regex_dt_br = re.compile(
-                    r"^(\d{2})/(\d{2})/(\d{4})\s+(\d{2}:\d{2}:\d{2})(?:\.\d+)?$"
-                )
+                
+                # Tenta detectar formato brasileiro DD/MM/YYYY HH:MM:SS
+                regex_dt_br = re.compile(r"^(\d{2})/(\d{2})/(\d{4})\s+(\d{2}:\d{2}:\d{2})(?:\.\d+)?$")
                 match_dt_br = regex_dt_br.match(val_str)
+                
                 if match_dt_br:
-                    nova_linha[col] = (
-                        f"{match_dt_br.group(3)}-{match_dt_br.group(2)}-{match_dt_br.group(1)}"
-                        f" {match_dt_br.group(4)}"
-                    )
+                    # Converte para YYYY-MM-DD HH:MM:SS
+                    nova_linha[col] = f"{match_dt_br.group(3)}-{match_dt_br.group(2)}-{match_dt_br.group(1)} {match_dt_br.group(4)}"
                 else:
                     match_iso = regex_iso_tz.match(val_str)
                     if match_iso:
                         nova_linha[col] = f"{match_iso.group(1)} {match_iso.group(2)}"
                     else:
-                        # Limpeza robusta de timezone para evitar erro de formato
+                        # Limpeza robusta existente
                         limpo = val_str.replace("T", " ").replace("Z", "")
-                        if "+" in limpo:
-                            limpo = limpo.split("+")[0]
-                        if "-" in limpo and len(limpo.split("-")[-1]) == 5:
-                            limpo = limpo.rsplit("-", 1)[0]
+                        if '+' in limpo: limpo = limpo.split('+')[0]
+                        if '-' in limpo and len(limpo.split('-')[-1]) == 5:
+                             limpo = limpo.rsplit('-', 1)[0]
                         nova_linha[col] = limpo.strip()[:23]
 
-            else:
-                # Tipo não tratado: devolve o valor como veio
-                nova_linha[col] = val
-
         except Exception:
-            # Se falhar a conversão, envia NULL para evitar Type Mismatch no BigQuery
-            gerador_log.add(
-                f"AVISO: Falha conversão coluna '{col}' valor '{val}'. Enviando NULL."
-            )
+            # CORREÇÃO DE FALLBACK:
+            # Se falhar a conversão (ex: texto em campo Inteiro), envia NULL
+            # Enviar str(val) causaria erro de "Type Mismatch" no BigQuery
+            gerador_log.add(f"AVISO: Falha conversão coluna '{col}' valor '{val}'. Enviando NULL.")
             nova_linha[col] = None
 
     return nova_linha
-
+    
 
 def executar_com_fallback(func, bq_client, timeout, project, dataset, tabela, gerador_log):
     """Executa `func` em um executor com timeout e captura falhas.

{csc_essentials-1.2.2 → csc_essentials-1.2.4/src/csc_essentials.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csc-essentials
-Version: 1.2.2
+Version: 1.2.4
 Summary: Biblioteca de utilitários essenciais para projetos CSC
 Author-email: David Braga <david.braga@stone.com.br>
 License: MIT