Tjson.py

import pandas as pd
import numpy as np
import os
import json
from sentence_transformers import SentenceTransformer

print("🚀 Carregando modelo LOCAL (gratuito)...")

# Carrega o modelo local - funciona offline!
modelo = SentenceTransformer('all-MiniLM-L6-v2')


def carregar_jsons_pandas(pasta):
    """
    Carrega todos os JSONs para um DataFrame do pandas
    """
    print(f"📂 Procurando JSONs na pasta: {pasta}")

    dados_lista = []

    # Verifica se a pasta existe
    if not os.path.exists(pasta):
        print(f"❌ Pasta '{pasta}' não encontrada!")
        print("💡 Dica: Crie uma pasta chamada 'pasta_jsons' com seus arquivos JSON")
        return pd.DataFrame()

    # Lista arquivos na pasta
    arquivos = os.listdir(pasta)
    arquivos_json = [f for f in arquivos if f.endswith('.json')]

    if not arquivos_json:
        print("❌ Nenhum arquivo JSON encontrado na pasta!")
        return pd.DataFrame()

    print(f"📄 Encontrados {len(arquivos_json)} arquivos JSON")

    for arquivo in arquivos_json:
        caminho_completo = os.path.join(pasta, arquivo)

        try:
            with open(caminho_completo, 'r', encoding='utf-8') as f:
                conteudo_json = json.load(f)

            # Extrai texto para embedding
            texto = extrair_texto_json(conteudo_json)

            dados_lista.append({
                'nome_arquivo': arquivo,
                'conteudo_original': str(conteudo_json),
                'texto_para_embedding': texto,
                'tamanho_texto': len(texto)
            })

            print(f"✅ {arquivo} - carregado!")

        except Exception as e:
            print(f"❌ Erro em {arquivo}: {e}")

    # Cria DataFrame
    df = pd.DataFrame(dados_lista)
    print(f"📊 DataFrame criado com {len(df)} registros")
    return df


def extrair_texto_json(dados_json):
    """
    Extrai texto de um JSON para criar embeddings
    """
    if isinstance(dados_json, dict):
        # Se for dicionário, junta todos os valores de texto
        textos = []
        for key, value in dados_json.items():
            if isinstance(value, (str, int, float)):
                textos.append(str(value))
            elif isinstance(value, list):
                textos.extend([str(item) for item in value if isinstance(item, (str, int, float))])
        return " ".join(textos)
    elif isinstance(dados_json, list):
        # Se for lista, converte todos os itens para string
        return " ".join([str(item) for item in dados_json])
    else:
        # Se for outra coisa, converte para string
        return str(dados_json)


def criar_embeddings_locais(df):
    """
    Cria embeddings usando modelo LOCAL gratuito
    """
    print("🔮 Criando embeddings LOCAIS...")

    if df.empty:
        print("❌ DataFrame vazio!")
        return df

    # Pega todos os textos
    textos = df['texto_para_embedding'].tolist()

    # Cria embeddings em lote (mais rápido)
    print("⏳ Gerando embeddings... (pode levar alguns segundos)")
    embeddings = modelo.encode(textos)

    # Adiciona ao DataFrame
    df['embedding'] = embeddings.tolist()
    df['tamanho_embedding'] = df['embedding'].apply(len)

    print(f"🎯 Embeddings criados para {len(df)} textos")
    print(f"📐 Dimensões do embedding: {embeddings.shape[1]}")

    return df


def salvar_resultados_simples(df, nome_base='embeddings_locais'):
    """
    Salva resultados APENAS em CSV e JSON (sem Excel)
    """
    if df.empty:
        print("❌ Nada para salvar!")
        return

    # 1. CSV com embeddings como string
    df_csv = df.copy()
    df_csv['embedding_str'] = df_csv['embedding'].apply(str)

    # Salva CSV principal
    colunas_principais = ['nome_arquivo', 'texto_para_embedding', 'tamanho_texto', 'tamanho_embedding', 'embedding_str']
    df_csv[colunas_principais].to_csv(f'{nome_base}.csv', index=False, encoding='utf-8')

    # 2. JSON com estrutura completa
    df[['nome_arquivo', 'embedding']].to_json(f'{nome_base}.json', orient='records', indent=2)

    # 3. CSV só com nomes e embeddings (mais leve)
    df[['nome_arquivo', 'embedding']].to_csv(f'{nome_base}_simples.csv', index=False)

    print(f"💾 Resultados salvos:")
    print(f"   📄 {nome_base}.csv (completo)")
    print(f"   📊 {nome_base}.json (estrutura JSON)")
    print(f"   📋 {nome_base}_simples.csv (apenas embeddings)")


def analisar_com_pandas(df):
    """
    Análise detalhada usando pandas
    """
    print("\n📈 ANÁLISE DETALHADA:")
    print("=" * 50)

    # Informações básicas
    print(f"📊 Total de arquivos: {len(df)}")
    print(f"📝 Tamanho médio do texto: {df['tamanho_texto'].mean():.0f} caracteres")
    print(f"🎯 Dimensões do embedding: {df['tamanho_embedding'].iloc[0]}")

    # Estatísticas com pandas
    print(f"\n📋 Estatísticas dos textos:")
    print(df['tamanho_texto'].describe())

    # Top 3 maiores textos
    print(f"\n🏆 Top 3 textos mais longos:")
    top_longs = df.nlargest(3, 'tamanho_texto')[['nome_arquivo', 'tamanho_texto']]
    for idx, row in top_longs.iterrows():
        print(f"   {row['nome_arquivo']} - {row['tamanho_texto']} chars")

    # Distribuição por tamanho
    df['categoria_tamanho'] = pd.cut(df['tamanho_texto'],
                                     bins=[0, 100, 500, 1000, float('inf')],
                                     labels=['Muito Curto (<100)', 'Curto (100-500)',
                                             'Médio (500-1000)', 'Longo (>1000)'])

    print(f"\n📦 Distribuição por tamanho:")
    print(df['categoria_tamanho'].value_counts().sort_index())


# 🎯 PROGRAMA PRINCIPAL
if __name__ == "__main__":
    # CONFIGURAÇÃO - MUDE AQUI PARA SUA PASTA!
    pasta_jsons = "pasta_json"  # ⚠️ SUBSTITUA pelo caminho da SUA pasta!

    print("=" * 60)
    print("🎊 SISTEMA DE EMBEDDINGS LOCAIS (GRATUITO)")
    print("=" * 60)

    # 1. Carregar JSONs
    df = carregar_jsons_pandas(pasta_jsons)

    if not df.empty:
        # 2. Criar embeddings
        df_embeddings = criar_embeddings_locais(df)

        # 3. Salvar resultados (SEM Excel)
        salvar_resultados_simples(df_embeddings)

        # 4. Análise
        analisar_com_pandas(df_embeddings)

        # 5. Mostrar preview
        print(f"\n👀 PRÉVIA DOS DADOS:")
        print(df_embeddings[['nome_arquivo', 'tamanho_texto', 'tamanho_embedding']].head())

        # 6. Exemplo de como usar os embeddings
        print(f"\n💡 EXEMPLO: Como usar os embeddings:")
        print(f"   df = pd.read_csv('embeddings_locais.csv')")
        print(f"   print(df.head())")

    else:
        print("❌ Não foi possível carregar os dados.")
        print("\n💡 SOLUÇÃO DE PROBLEMAS:")
        print("1. Crie uma pasta chamada 'pasta_jsons'")
        print("2. Coloque arquivos .json dentro dela")
        print("3. Execute o script novamente")

    print("\n✅ Processo concluído!")