🔄 Sync do experimento: Fix AzMina + ALESP + Câmara SP + UX melhorada

- Fix crítico: Carregamento do modelo AzMina com tokenizer explícito
- Novas fontes: ALESP e Câmara Municipal SP implementadas
- Termos expandidos: +20 novos termos LGBTQIA+
- UX melhorada: campos interativos, ano final dinâmico
- API Senado: endpoint mais robusto (/materia/pesquisa/lista)
- Pesos adaptativos: Sistema funciona mesmo se AzMina falhar

Mudanças: +568 linhas, -165 linhas em 3 arquivos

SYNC_PLAN.md

@@ -0,0 +1,175 @@
+# 🔄 Plano de Sincronização: Experimento → Space Deployado
+
+## 📊 Mudanças Detectadas no Experimento Original
+
+### 1. **app.py** - Mudanças Significativas
+- ✅ **Novas fontes**: Adicionadas ALESP e Câmara Municipal SP
+- ✅ **Melhor UX**: Campos com `interactive=True`, ano final dinâmico
+- ✅ **Mais checkboxes**: 4 fontes (Câmara, Senado, ALESP, Câmara SP)
+- ✅ **Debug melhorado**: Prints de debug adicionados
+- ✅ **Descrições atualizadas**: Menciona todas as 4 fontes
+
+### 2. **ensemble_híbrido.py** - Fix Crítico
+- ✅ **Fix do AzMina**: Carrega tokenizer do modelo base (neuralmind/bert-base-portuguese-cased)
+- ✅ **Fallback**: Sistema funciona mesmo se AzMina falhar
+- ✅ **Pesos adaptativos**: Redistribui pesos se AzMina não carregar
+- 🔥 **CRÍTICO**: Resolve erro de carregamento do modelo AzMina
+
+### 3. **api_radar.py** - Expansão Massiva
+- ✅ **Termos expandidos**: +20 novos termos LGBTQIA+
+- ✅ **ALESP implementada**: Busca na Assembleia Legislativa de SP
+- ✅ **Câmara SP implementada**: Busca na Câmara Municipal de SP
+- ✅ **Senado melhorado**: Endpoint `/materia/pesquisa/lista` (mais robusto)
+- ✅ **XML parsing**: Suporte a XML do Senado
+- 🔥 **IMPORTANTE**: Implementações completas de ALESP e Câmara SP
+
+## 🎯 Estratégia de Sincronização
+
+### Opção Recomendada: Rsync Seletivo + Git
+
+```bash
+# 1. Backup do atual (segurança)
+cd "/Users/vektra/Desenvolvimento/Radar Social LGBTQIA/pacote-radar-social-lgbtqia-v2.1"
+cp -r radar-legislativo-lgbtqia radar-legislativo-lgbtqia-backup
+
+# 2. Sync dos arquivos principais
+rsync -av --exclude='__pycache__' --exclude='*.pyc' --exclude='.git' \
+  "/Users/vektra/Desenvolvimento/AzMina QuiterIA/app.py" \
+  "/Users/vektra/Desenvolvimento/AzMina QuiterIA/ensemble_híbrido.py" \
+  "/Users/vektra/Desenvolvimento/AzMina QuiterIA/api_radar.py" \
+  "radar-legislativo-lgbtqia/"
+
+# 3. Git diff para revisar
+cd radar-legislativo-lgbtqia
+git diff
+
+# 4. Se tudo ok, commit e push
+git add app.py ensemble_híbrido.py api_radar.py
+git commit -m "🔄 Sync: Fix AzMina + ALESP + Câmara SP + UX melhorada"
+git push origin main
+```
+
+## 📋 Checklist de Mudanças
+
+### Arquivos para Sincronizar
+- [x] `app.py` ⭐ (novas fontes + UX)
+- [x] `ensemble_híbrido.py` ⭐⭐⭐ (fix crítico AzMina)
+- [x] `api_radar.py` ⭐⭐ (ALESP + Câmara SP implementadas)
+
+### Arquivos Opcionais
+- [ ] `requirements.txt` (verificar se precisa atualizar)
+- [ ] README/docs (atualizar mencionando novas fontes)
+
+### Validações Necessárias
+- [ ] Testar carregamento do AzMina (não deve dar erro)
+- [ ] Testar busca na Câmara (deve funcionar)
+- [ ] Testar busca no Senado (endpoint novo)
+- [ ] Testar busca na ALESP (nova implementação)
+- [ ] Testar busca na Câmara SP (nova implementação)
+
+## 🚨 Pontos de Atenção
+
+### 1. Fix do AzMina é CRÍTICO
+O modelo AzMina estava falhando ao carregar porque não tem `tokenizer_config.json`. 
+A nova versão:
+- Carrega explicitamente o tokenizer do modelo base
+- Tem fallback se ainda assim falhar
+- Redistribui pesos se AzMina não estiver disponível
+
+**Status atual no Space**: Provavelmente está falhando sem esse fix
+
+### 2. Novas Fontes (ALESP + Câmara SP)
+Implementações completas com:
+- Parsing de XML (Senado, ALESP)
+- Estrutura de dados padronizada
+- Tratamento de erros robusto
+
+**Benefício**: Cobertura legislativa municipal e estadual (SP)
+
+### 3. Termos LGBTQIA+ Expandidos
++20 novos termos incluindo:
+- Identidades: bissexual, pansexual, não-binário
+- Direitos: casamento igualitário, adoção homoafetiva
+- Procedimentos: mudança de nome, retificação de registro
+
+**Benefício**: Captura mais PLs relevantes
+
+## 📈 Impacto Esperado Após Sync
+
+### Performance
+- ✅ AzMina carrega sem erro (fix crítico)
+- ✅ Mais PLs encontradas (termos expandidos)
+- ✅ Mais fontes disponíveis (4 vs 2)
+
+### User Experience
+- ✅ Campos interativos (sliders respondem melhor)
+- ✅ Ano final dinâmico (sempre ano atual)
+- ✅ 4 checkboxes (mais opções de busca)
+- ✅ Descrições claras sobre cada fonte
+
+### Cobertura
+- 📊 **Antes**: Câmara + Senado (federal)
+- 📊 **Depois**: Câmara + Senado + ALESP + Câmara SP (federal + estadual + municipal)
+
+## ⚙️ Execução do Sync
+
+### Método Automático (Recomendado)
+```bash
+cd "/Users/vektra/Desenvolvimento/Radar Social LGBTQIA/pacote-radar-social-lgbtqia-v2.1/radar-legislativo-lgbtqia"
+
+# Copiar arquivos atualizados
+cp "/Users/vektra/Desenvolvimento/AzMina QuiterIA/app.py" .
+cp "/Users/vektra/Desenvolvimento/AzMina QuiterIA/ensemble_híbrido.py" .
+cp "/Users/vektra/Desenvolvimento/AzMina QuiterIA/api_radar.py" .
+
+# Revisar mudanças
+git diff
+
+# Commit
+git add app.py ensemble_híbrido.py api_radar.py
+git commit -m "🔄 Sync do experimento: Fix AzMina + ALESP + Câmara SP + UX melhorada
+
+- Fix crítico: Carregamento do modelo AzMina com tokenizer explícito
+- Novas fontes: ALESP e Câmara Municipal SP implementadas
+- Termos expandidos: +20 novos termos LGBTQIA+
+- UX melhorada: campos interativos, ano final dinâmico
+- API Senado: endpoint mais robusto (/materia/pesquisa/lista)"
+
+# Push para HF Space
+git push origin main
+```
+
+### Método Manual (Mais Controle)
+1. Abrir cada arquivo lado a lado
+2. Copiar mudanças manualmente
+3. Testar localmente antes de commit
+4. Commit e push
+
+## 🧪 Teste Local Antes de Deploy
+
+```bash
+cd "/Users/vektra/Desenvolvimento/Radar Social LGBTQIA/pacote-radar-social-lgbtqia-v2.1/radar-legislativo-lgbtqia"
+
+# Instalar/atualizar dependências
+pip install -r requirements.txt
+
+# Testar app
+python app.py
+
+# Verificar:
+# 1. AzMina carrega sem erro
+# 2. Interface mostra 4 checkboxes
+# 3. Busca funciona em todas as fontes
+```
+
+## 📝 Atualizar Documentação
+
+Após sync, atualizar:
+- [ ] `README.md`: Mencionar ALESP e Câmara SP
+- [ ] `DEPLOY_COMPLETO.md`: Adicionar novas fontes
+- [ ] Card do Space: Atualizar descrição
+
+---
+
+**Recomendação**: Executar sync automático agora, é safe e traz melhorias críticas! 🚀
+

api_radar.py

@@ -9,6 +9,9 @@ from datetime import datetime, timedelta
 from typing import List, Dict, Optional
 import re
 import time
+import xml.etree.ElementTree as ET
+import zipfile
+from io import BytesIO
 
 # URLs das APIs
 API_CAMARA = "https://dadosabertos.camara.leg.br/api/v2"
@@ -19,6 +22,7 @@ API_ALESP = None  # Verificar se há API pública
 # Termos para filtrar PLs relacionadas a LGBTQIA+
 # TERMOS ESPECÍFICOS primeiro (mais relevantes)
 TERMOS_BUSCA_ESPECIFICOS = [
+    # Termos básicos
     "lgbt",
     "lgbtqia",
     "lgbtqia+",
@@ -29,10 +33,29 @@ TERMOS_BUSCA_ESPECIFICOS = [
     "homofobia",
     "transfobia",
     "homossexual",
+    
+    # Identidade e orientação
     "identidade de gênero",
     "orientação sexual",
     "diversidade sexual",
+    "bissexual",
+    "pansexual",
+    "não-binário",
+    "não binário",
+    "cisgênero",
+    
+    # Direitos e procedimentos
     "nome social",
+    "casamento igualitário",
+    "união homoafetiva",
+    "adoção homoafetiva",
+    "mudança de nome",
+    "retificação de registro",
+    
+    # Discriminação e violência
+    "discriminação sexual",
+    "preconceito sexual",
+    "criminalização da homofobia",
     "terapia de conversão",
     "cura gay",
     "reparação sexual"
@@ -51,7 +74,11 @@ TERMOS_BUSCA_CONTEXTUAIS = [
     "lules",
     "símbolos religiosos.*parada",
     "menor.*evento.*lgbt",
-    "comunidade lgbt"
+    "comunidade lgbt",
+    "sexo biológico",
+    "gênero biológico",
+    "família tradicional",
+    "masculino e feminino"
 ]
 
 TERMOS_BUSCA = TERMOS_BUSCA_ESPECIFICOS + TERMOS_BUSCA_CONTEXTUAIS
@@ -249,7 +276,10 @@ def buscar_senado_federal(
     Busca PLs no Senado Federal
     
     API: https://legis.senado.leg.br/dadosabertos
-    Nota: API do Senado é mais complexa, esta é uma implementação básica que busca PLS por ano
+    Endpoint: /materia/pesquisa/lista
+    
+    ✅ Este endpoint permite buscar matérias por ano de apresentação, resolvendo 
+    o problema de lacunas em dados históricos.
     """
     if termos is None:
         termos = TERMOS_BUSCA
@@ -257,167 +287,412 @@ def buscar_senado_federal(
     # Determinar anos para buscar
     ano_atual = datetime.now().year
     if ano_inicio_manual is not None and ano_fim_manual is not None:
-        anos_para_buscar = [ano_inicio_manual] if ano_inicio_manual == ano_fim_manual else list(range(ano_inicio_manual, ano_fim_manual + 1))
+        anos_para_buscar = list(range(ano_inicio_manual, ano_fim_manual + 1))
     else:
         anos_para_buscar = [ano_atual]
     
     pls_encontradas = []
     
-    # API do Senado Federal
-    # Endpoint: /dadosabertos/materia/atualizadas
-    # Retorna matérias atualizadas com ementa completa
-    # Estrutura: ListaMateriasAtualizadas -> Materias -> Materia[] -> DadosBasicosMateria.EmentaMateria
-    # Documentação: https://legis.senado.leg.br/dadosabertos/api-docs/swagger-ui/index.html
-    
-    print(f"   📥 Buscando matérias atualizadas no Senado...")
+    # API do Senado Federal - endpoint /materia/pesquisa/lista
+    url_base = "https://legis.senado.leg.br/dadosabertos/materia/pesquisa/lista"
     
-    url_base = "https://legis.senado.leg.br/dadosabertos/materia/atualizadas"
+    print(f"   📥 Buscando no Senado (anos {min(anos_para_buscar)}-{max(anos_para_buscar)})...")
     
     try:
-        headers = {"Accept": "application/json"}
-        response = requests.get(url_base, headers=headers, timeout=20)
-        response.raise_for_status()
-        
-        data = response.json()
-        
-        if 'ListaMateriasAtualizadas' not in data:
-            print(f"   ⚠️ Estrutura de resposta inesperada do Senado")
-            return []
-        
-        lista = data['ListaMateriasAtualizadas']
-        materias_data = lista.get('Materias', {})
-        
-        if isinstance(materias_data, dict) and 'Materia' in materias_data:
-            materias_list = materias_data['Materia']
-            materias_list = materias_list if isinstance(materias_list, list) else [materias_list]
-        elif isinstance(materias_data, list):
-            materias_list = materias_data
-        else:
-            materias_list = []
-        
-        if not materias_list:
-            print(f"   ℹ️ Nenhuma matéria encontrada no Senado")
-            return []
-        
-        print(f"   📊 Total de matérias atualizadas: {len(materias_list)} (antes do filtro)")
-        
-        # Filtrar por ano e termos LGBTQIA+
-        for materia in materias_list:
+        for ano in reversed(anos_para_buscar):
             if len(pls_encontradas) >= limite:
                 break
             
-            # Extrair informações
-            ident = materia.get('IdentificacaoMateria', {})
-            dados = materia.get('DadosBasicosMateria', {})
-            
-            ano_materia = ident.get('AnoMateria', '')
-            sigla = ident.get('SiglaSubtipoMateria', '')
-            numero = ident.get('NumeroMateria', '')
-            codigo = ident.get('CodigoMateria', '')
-            
-            # Filtrar por ano se especificado
-            if ano_inicio_manual is not None and ano_fim_manual is not None:
-                try:
-                    ano_int = int(ano_materia) if ano_materia else 0
-                    if not (ano_inicio_manual <= ano_int <= ano_fim_manual):
-                        continue
-                except:
+            try:
+                # Buscar todas as matérias apresentadas no ano especificado
+                params = {'ano': str(ano)}
+                
+                response = requests.get(url_base, params=params, headers={'Accept': 'application/json'}, timeout=30)
+                response.raise_for_status()
+                
+                data = response.json()
+                
+                if 'PesquisaBasicaMateria' not in data:
+                    print(f"   ℹ️ Resposta inesperada do Senado em {ano}")
                     continue
-            
-            # Filtrar apenas PLS (ou outras siglas de projeto de lei)
-            if sigla not in ['PLS', 'PLC', 'PL']:
-                continue
-            
-            # Obter ementa
-            ementa = dados.get('EmentaMateria', '')
-            if not ementa or len(ementa) < 10:
-                continue
-            
-            ementa_lower = ementa.lower()
-            
-            # Filtrar por termos LGBTQIA+ (mesma lógica da Câmara)
-            tem_termo_especifico = False
-            for termo in TERMOS_BUSCA_ESPECIFICOS:
-                if termo == 'trans' and 'trans' in ementa_lower:
-                    if re.search(r'\btrans\b', ementa_lower) and (
-                        any(palavra in ementa_lower for palavra in ['gênero', 'sexual', 'identidade', 'lgbt', 'transfobia', 'transexual', 'transgênero']) or
-                        any(palavra in ementa_lower for palavra in ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 'direito', 'direitos'])
-                    ):
-                        tem_termo_especifico = True
-                        break
-                elif termo.lower() in ementa_lower:
-                    tem_termo_especifico = True
-                    break
-            
-            palavras_legislativas = ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 
-                                    'orientação', 'identidade', 'gênero', 'sexual', 'direito', 'direitos',
-                                    'dispõe', 'altera', 'estabelece', 'define']
-            tem_termo_contextual = any(
-                termo.lower() in ementa_lower 
-                for termo in TERMOS_BUSCA_CONTEXTUAIS[:8]
-            ) and any(
-                palavra in ementa_lower for palavra in palavras_legislativas
-            )
-            
-            if tem_termo_especifico or tem_termo_contextual:
-                autor = 'N/A'
-                if 'AutoresPrincipais' in materia:
-                    autor_data = materia.get('AutoresPrincipais', {})
-                    if isinstance(autor_data, dict) and 'AutorPrincipal' in autor_data:
-                        autor_obj = autor_data['AutorPrincipal']
-                        if isinstance(autor_obj, dict):
-                            autor = autor_obj.get('NomeAutor', 'N/A')
                 
-                data_apresentacao = dados.get('DataApresentacao', 'N/A')
+                materias_data = data['PesquisaBasicaMateria'].get('Materias', {})
                 
-                link = f"https://www25.senado.leg.br/web/atividade/materias/-/materia/{codigo}" if codigo else f"https://www25.senado.leg.br/web/atividade/materias"
+                if isinstance(materias_data, dict) and 'Materia' in materias_data:
+                    materias = materias_data['Materia']
+                    materias = materias if isinstance(materias, list) else [materias]
+                elif isinstance(materias_data, list):
+                    materias = materias_data
+                else:
+                    materias = []
                 
-                pls_encontradas.append({
-                    'Nº': f"{sigla} {numero}/{ano_materia}",
-                    'Ano': str(ano_materia),
-                    'Casa': 'Senado',
-                    'Ementa': ementa,
-                    'Autores': autor,
-                    'Data': data_apresentacao,
-                    'Link': link,
-                    'Status': ident.get('DescricaoIdentificacaoMateria', 'N/A'),
-                    'Fonte': 'Senado Federal'
-                })
-        
-        print(f"   ✅ {len(pls_encontradas)} PLs relevantes encontradas no Senado")
+                if not materias:
+                    print(f"   ℹ️ Nenhuma matéria encontrada no Senado em {ano}")
+                    continue
+                
+                print(f"   📊 Senado {ano}: {len(materias)} matérias (antes do filtro)")
+                
+                # Processar cada matéria
+                materias_ano = 0
+                for materia in materias:
+                    if len(pls_encontradas) >= limite:
+                        break
+                    
+                    try:
+                        # Extrair informações da matéria (estrutura simplificada da API /pesquisa/lista)
+                        sigla = materia.get('Sigla', '')
+                        numero = materia.get('Numero', '')
+                        ano_materia = materia.get('Ano', '')
+                        codigo = materia.get('Codigo', '')
+                        ementa = materia.get('Ementa', '')
+                        autor = materia.get('Autor', 'N/A')
+                        data = materia.get('Data', 'N/A')
+                        
+                        # Filtrar apenas Projetos de Lei (PL, PLS, PLC, PLP)
+                        if sigla not in ['PLS', 'PLC', 'PL', 'PLP']:
+                            continue
+                        
+                        if not ementa or len(ementa) < 10:
+                            continue
+                        
+                        ementa_lower = ementa.lower()
+                        
+                        # Filtrar por termos LGBTQIA+ (mesma lógica das outras fontes)
+                        tem_termo_especifico = False
+                        for termo in TERMOS_BUSCA_ESPECIFICOS:
+                            if termo == 'trans' and 'trans' in ementa_lower:
+                                if re.search(r'\btrans\b', ementa_lower) and (
+                                    any(p in ementa_lower for p in ['gênero', 'sexual', 'identidade', 'lgbt', 'transfobia', 'transexual', 'transgênero']) or
+                                    any(p in ementa_lower for p in ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 'direito', 'direitos'])
+                                ):
+                                    tem_termo_especifico = True
+                                    break
+                            elif termo.lower() in ementa_lower:
+                                tem_termo_especifico = True
+                                break
+                        
+                        palavras_legislativas = ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 
+                                                'orientação', 'identidade', 'gênero', 'sexual', 'direito', 'direitos',
+                                                'dispõe', 'altera', 'estabelece', 'define']
+                        tem_termo_contextual = any(
+                            termo.lower() in ementa_lower 
+                            for termo in TERMOS_BUSCA_CONTEXTUAIS[:8]
+                        ) and any(
+                            palavra in ementa_lower for palavra in palavras_legislativas
+                        )
+                        
+                        if tem_termo_especifico or tem_termo_contextual:
+                            # Construir link para matéria
+                            link = f"https://www25.senado.leg.br/web/atividade/materias/-/materia/{codigo}" if codigo else "https://www25.senado.leg.br/web/atividade/materias"
+                            
+                            pls_encontradas.append({
+                                'Nº': f"{sigla} {numero}/{ano_materia}",
+                                'Ano': str(ano_materia),
+                                'Casa': 'Senado',
+                                'Ementa': ementa,
+                                'Autores': autor,
+                                'Data': data[:10] if isinstance(data, str) and len(data) >= 10 else str(data),
+                                'Link': link,
+                                'Status': materia.get('DescricaoIdentificacao', 'N/A'),
+                                'Fonte': 'Senado Federal'
+                            })
+                            
+                            materias_ano += 1
+                    
+                    except Exception as e:
+                        # Pular matéria se houver erro no parse
+                        continue
+                
+                if materias_ano > 0:
+                    print(f"   ✅ Senado {ano}: {materias_ano} PLs relevantes")
+                
+            except requests.exceptions.HTTPError as e:
+                print(f"   ⚠️ Erro HTTP no Senado ({ano}): {e.response.status_code}")
+                continue
+            except Exception as e:
+                print(f"   ⚠️ Erro no Senado ({ano}): {str(e)[:80]}")
+                continue
         
+        print(f"   📊 Total Senado: {len(pls_encontradas)} PLs")
         return pls_encontradas[:limite]
         
-    except requests.exceptions.HTTPError as e:
-        print(f"   ⚠️ Erro HTTP ao buscar no Senado: {e.response.status_code}")
-        return []
     except Exception as e:
-        print(f"   ⚠️ Erro ao buscar no Senado: {str(e)[:100]}")
+        print(f"   ⚠️ Erro geral ao buscar no Senado: {str(e)[:100]}")
         return []
 
 def buscar_camara_sao_paulo(
     termos: List[str] = None,
+    ano_inicio_manual: Optional[int] = None,
+    ano_fim_manual: Optional[int] = None,
     limite: int = 50
 ) -> List[Dict]:
     """
     Busca PLs na Câmara Municipal de São Paulo
     
-    Nota: Pode não ter API pública - implementação futura via scraping
+    Web Service: https://splegisws.saopaulo.sp.leg.br/ws/ws2.asmx
+    Método: ProjetosPorAnoJSON
+    Portal de Dados Abertos: https://www.saopaulo.sp.leg.br/transparencia/dados-abertos/dados-disponibilizados-em-formato-aberto/
     """
-    print("⚠️ Busca na Câmara Municipal de SP ainda não implementada")
-    return []
+    if termos is None:
+        termos = TERMOS_BUSCA
+    
+    print(f"📥 Buscando projetos na Câmara Municipal de SP...")
+    
+    # URL do web service
+    base_url = "https://splegisws.saopaulo.sp.leg.br/ws/ws2.asmx/ProjetosPorAnoJSON"
+    
+    pls_encontradas = []
+    
+    # Determinar anos para buscar
+    ano_atual = datetime.now().year
+    
+    if ano_inicio_manual is not None and ano_fim_manual is not None:
+        anos_para_buscar = list(range(ano_inicio_manual, ano_fim_manual + 1))
+    else:
+        # Padrão: ano atual
+        anos_para_buscar = [ano_atual]
+    
+    try:
+        # Buscar projetos por ano
+        for ano in reversed(anos_para_buscar):
+            if len(pls_encontradas) >= limite:
+                break
+            
+            print(f"   📅 Buscando projetos de {ano}...")
+            
+            try:
+                # Chamar web service
+                params = {'Ano': ano}
+                response = requests.get(base_url, params=params, timeout=30)
+                response.raise_for_status()
+                
+                projetos = response.json()
+                if not isinstance(projetos, list):
+                    print(f"   ⚠️ Resposta não é lista: {type(projetos)}")
+                    continue
+                
+                print(f"   📊 {len(projetos)} projetos encontrados em {ano} (antes do filtro)")
+                
+                # Filtrar por termos LGBTQIA+
+                for projeto in projetos:
+                    if len(pls_encontradas) >= limite:
+                        break
+                    
+                    ementa = projeto.get('ementa', '')
+                    if not ementa or len(ementa) < 10:
+                        continue
+                    
+                    ementa_lower = ementa.lower()
+                    
+                    # Filtrar por termos específicos primeiro
+                    tem_termo_especifico = False
+                    for termo in TERMOS_BUSCA_ESPECIFICOS:
+                        if termo == 'trans' and 'trans' in ementa_lower:
+                            if re.search(r'\btrans\b', ementa_lower) and (
+                                any(palavra in ementa_lower for palavra in ['gênero', 'sexual', 'identidade', 'lgbt', 'transfobia', 'transexual', 'transgênero']) or
+                                any(palavra in ementa_lower for palavra in ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 'direito', 'direitos'])
+                            ):
+                                tem_termo_especifico = True
+                                break
+                        elif termo.lower() in ementa_lower:
+                            tem_termo_especifico = True
+                            break
+                    
+                    # Verificar termos contextuais
+                    palavras_legislativas = ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 
+                                            'orientação', 'identidade', 'gênero', 'sexual', 'direito', 'direitos',
+                                            'dispõe', 'altera', 'estabelece', 'define']
+                    tem_termo_contextual = any(
+                        termo.lower() in ementa_lower 
+                        for termo in TERMOS_BUSCA_CONTEXTUAIS[:8]
+                    ) and any(
+                        palavra in ementa_lower for palavra in palavras_legislativas
+                    )
+                    
+                    if tem_termo_especifico or tem_termo_contextual:
+                        tipo = projeto.get('tipo', 'PL')
+                        numero = projeto.get('numero', 'N/A')
+                        ano_projeto = projeto.get('ano', 'N/A')
+                        data_projeto = projeto.get('data', 'N/A')
+                        chave = projeto.get('chave', '')
+                        
+                        # Construir link (baseado na estrutura comum da Câmara SP)
+                        link = f"https://www.saopaulo.sp.leg.br/vereadores/projetos-de-lei/?projeto={chave}" if chave else f"https://www.saopaulo.sp.leg.br/"
+                        
+                        pls_encontradas.append({
+                            'Nº': f"{tipo} {numero}/{ano_projeto}",
+                            'Ano': str(ano_projeto),
+                            'Casa': 'Câmara Municipal SP',
+                            'Ementa': ementa,
+                            'Autores': 'N/A',  # Pode obter via ProjetosAutoresJSON se necessário
+                            'Data': data_projeto[:10] if isinstance(data_projeto, str) and len(data_projeto) >= 10 else str(data_projeto),
+                            'Link': link,
+                            'Status': 'N/A',
+                            'Fonte': 'Câmara Municipal de São Paulo'
+                        })
+                
+                if pls_encontradas:
+                    print(f"   ✅ {len(pls_encontradas)} projetos relevantes encontrados em {ano}")
+                    
+            except requests.exceptions.HTTPError as e:
+                print(f"   ⚠️ Erro HTTP ao buscar projetos de {ano}: {e.response.status_code}")
+                continue
+            except Exception as e:
+                print(f"   ⚠️ Erro ao buscar projetos de {ano}: {str(e)[:100]}")
+                continue
+        
+        print(f"   ✅ Total: {len(pls_encontradas)} projetos relevantes encontrados na Câmara Municipal SP")
+        
+        return pls_encontradas[:limite]
+        
+    except Exception as e:
+        print(f"   ⚠️ Erro geral ao buscar na Câmara Municipal SP: {str(e)[:150]}")
+        return []
 
 def buscar_alesp(
     termos: List[str] = None,
+    ano_inicio_manual: Optional[int] = None,
+    ano_fim_manual: Optional[int] = None,
     limite: int = 50
 ) -> List[Dict]:
     """
-    Busca PLs na ALESP
+    Busca PLs na ALESP (Assembleia Legislativa de São Paulo)
+    
+    Portal: https://www.al.sp.gov.br/dados-abertos/
+    Arquivo: https://www.al.sp.gov.br/repositorioDados/processo_legislativo/proposituras.zip
+    Formato: ZIP contendo XML com todas as proposituras (atualizado diariamente)
     
-    Nota: Pode não ter API pública - implementação futura via scraping
+    Frequência de atualização: Diária
+    Portal de dados abertos: https://www.al.sp.gov.br/dados-abertos/recurso/56
     """
-    print("⚠️ Busca na ALESP ainda não implementada")
-    return []
+    if termos is None:
+        termos = TERMOS_BUSCA
+    
+    print(f"   📥 Buscando proposituras na ALESP...")
+    # NOTA: O arquivo proposituras.zip é atualizado DIARIAMENTE no portal da ALESP.
+    # Para garantir dados atualizados, baixamos o arquivo toda vez que uma busca é feita.
+    # Isso garante que mesmo no Hugging Face Space, sempre teremos os dados mais recentes.
+    
+    # URL do arquivo ZIP
+    url_zip = "https://www.al.sp.gov.br/repositorioDados/processo_legislativo/proposituras.zip"
+    
+    pls_encontradas = []
+    
+    try:
+        # Baixar arquivo ZIP (sob demanda - sempre busca a versão mais recente)
+        print(f"   📦 Baixando arquivo proposituras.zip atualizado (última atualização do portal)...")
+        print(f"   ⏱️ Isso garante dados atualizados diariamente (pode levar 10-20 segundos)")
+        response = requests.get(url_zip, timeout=120, stream=True)
+        response.raise_for_status()
+        
+        zip_data = BytesIO(response.content)
+        
+        with zipfile.ZipFile(zip_data, 'r') as zip_ref:
+            files = zip_ref.namelist()
+            if not files:
+                print(f"   ⚠️ ZIP vazio")
+                return []
+            
+            xml_file = files[0]
+            print(f"   📄 Extraindo {xml_file}...")
+            
+            # Ler XML (pode ser grande, mas preciso parsear)
+            xml_content = zip_ref.read(xml_file)
+            print(f"   📊 XML extraído: {len(xml_content)/1024/1024:.1f}MB")
+            
+            # Parsear XML
+            root = ET.fromstring(xml_content)
+            
+            # Buscar todas as proposituras
+            proposituras = root.findall('.//propositura')
+            total_props = len(proposituras)
+            print(f"   📋 Total de proposituras no arquivo: {total_props}")
+            
+            # Filtrar proposituras
+            for propositura in proposituras:
+                if len(pls_encontradas) >= limite:
+                    break
+                
+                # Extrair campos do XML
+                ano_text = propositura.findtext('AnoLegislativo', '')
+                numero_text = propositura.findtext('NroLegislativo', '')
+                ementa = propositura.findtext('Ementa', '')
+                id_doc = propositura.findtext('IdDocumento', '')
+                data_entrada = propositura.findtext('DtEntradaSistema', '')
+                natureza_id = propositura.findtext('IdNatureza', '')
+                
+                if not ementa or len(ementa) < 10:
+                    continue
+                
+                # Filtrar por ano se especificado
+                if ano_inicio_manual is not None and ano_fim_manual is not None:
+                    try:
+                        ano_int = int(ano_text) if ano_text else 0
+                        if not (ano_inicio_manual <= ano_int <= ano_fim_manual):
+                            continue
+                    except:
+                        continue
+                
+                # Filtrar por termos LGBTQIA+
+                ementa_lower = ementa.lower()
+                
+                tem_termo_especifico = False
+                for termo in TERMOS_BUSCA_ESPECIFICOS:
+                    if termo == 'trans' and 'trans' in ementa_lower:
+                        if re.search(r'\btrans\b', ementa_lower) and (
+                            any(palavra in ementa_lower for palavra in ['gênero', 'sexual', 'identidade', 'lgbt', 'transfobia', 'transexual', 'transgênero']) or
+                            any(palavra in ementa_lower for palavra in ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 'direito', 'direitos'])
+                        ):
+                            tem_termo_especifico = True
+                            break
+                    elif termo.lower() in ementa_lower:
+                        tem_termo_especifico = True
+                        break
+                
+                palavras_legislativas = ['proíbe', 'veda', 'restringe', 'garante', 'reconhece', 'criminaliza', 
+                                        'orientação', 'identidade', 'gênero', 'sexual', 'direito', 'direitos',
+                                        'dispõe', 'altera', 'estabelece', 'define']
+                tem_termo_contextual = any(
+                    termo.lower() in ementa_lower 
+                    for termo in TERMOS_BUSCA_CONTEXTUAIS[:8]
+                ) and any(
+                    palavra in ementa_lower for palavra in palavras_legislativas
+                )
+                
+                if tem_termo_especifico or tem_termo_contextual:
+                    # Determinar sigla do tipo (pode estar em outros campos)
+                    sigla = 'PL'  # Padrão
+                    tipo_text = propositura.findtext('Sigla', '') or propositura.findtext('Tipo', '')
+                    if tipo_text:
+                        sigla = tipo_text.upper()
+                    
+                    # Link para propositura (formato comum da ALESP)
+                    link = f"https://www.al.sp.gov.br/propositura/?id={id_doc}" if id_doc else "https://www.al.sp.gov.br/"
+                    
+                    pls_encontradas.append({
+                        'Nº': f"{sigla} {numero_text}/{ano_text}" if numero_text and ano_text else f"Nº {id_doc}",
+                        'Ano': ano_text or 'N/A',
+                        'Casa': 'ALESP',
+                        'Ementa': ementa,
+                        'Autores': propositura.findtext('Autor', 'N/A'),
+                        'Data': data_entrada[:10] if data_entrada else 'N/A',  # Apenas data, sem hora
+                        'Link': link,
+                        'Status': 'N/A',
+                        'Fonte': 'ALESP'
+                    })
+        
+        print(f"   ✅ {len(pls_encontradas)} proposituras relevantes encontradas na ALESP")
+        
+        return pls_encontradas[:limite]
+        
+    except requests.exceptions.HTTPError as e:
+        print(f"   ⚠️ Erro HTTP ao buscar na ALESP: {e.response.status_code}")
+        return []
+    except Exception as e:
+        print(f"   ⚠️ Erro ao buscar na ALESP: {str(e)[:150]}")
+        import traceback
+        print(f"   Detalhes: {traceback.format_exc()[:200]}")
+        return []
 
 def buscar_todas_fontes(
     termos: List[str] = None,

app.py

@@ -8,7 +8,7 @@ import pandas as pd
 import re
 from datetime import datetime
 from ensemble_híbrido import classificar_ensemble, carregar_modelos
-from api_radar import buscar_camara_deputados, buscar_senado_federal, filtrar_pls_relevantes
+from api_radar import buscar_camara_deputados, buscar_senado_federal, buscar_alesp, buscar_camara_sao_paulo, filtrar_pls_relevantes
 
 # Carregar modelos uma vez no início
 print("🏳️‍🌈 Carregando modelos...")
@@ -26,7 +26,8 @@ with gr.Blocks(
     # 🏳️‍🌈 Radar Legislativo LGBTQIA+
     
     Sistema de busca e análise automática de Projetos de Lei relacionados a direitos LGBTQIA+ 
-    no **Congresso Nacional** (Câmara dos Deputados e Senado Federal).
+    no **Congresso Nacional** (Câmara dos Deputados e Senado Federal), **ALESP** (Assembleia Legislativa de São Paulo) 
+    e **Câmara Municipal de São Paulo**.
     
     Utiliza **Ensemble Híbrido** (Radar Social + AzMina/QuiterIA + Keywords + Padrões) para identificar
     se PLs são **favoráveis** ou **desfavoráveis** aos direitos da comunidade LGBTQIA+.
@@ -38,13 +39,15 @@ with gr.Blocks(
     
     
     # RADAR AUTOMÁTICO - Única aba
-    with gr.Tab("🔍 Radar Automático - Congresso Nacional"):
+    with gr.Tab("🔍 Radar Automático"):
         gr.Markdown("""
-        ### 🔍 Radar Automático de PLs LGBTQIA+ - Congresso Nacional
+        ### 🔍 Radar Automático de PLs LGBTQIA+
         
         Busca e analisa automaticamente PLs relacionadas a direitos LGBTQIA+ nas APIs oficiais:
-        - **Câmara dos Deputados** ✅
-        - **Senado Federal** ✅
+        - **Câmara dos Deputados** ✅ (dados atualizados diariamente)
+        - **Senado Federal** ✅ (matérias atualizadas recentemente)
+        - **ALESP (Assembleia Legislativa de SP)** ✅ (atualizado diariamente)
+        - **Câmara Municipal de São Paulo** ✅ (dados atualizados)
         
         ⚠️ **Atenção:** A busca pode levar alguns segundos, especialmente em períodos longos.
         """)
@@ -56,6 +59,7 @@ with gr.Blocks(
                 maximum=2025,
                 value=2020,
                 step=1,
+                interactive=True,
                 info="Ano mais antigo para buscar"
             )
             
@@ -63,8 +67,9 @@ with gr.Blocks(
                 label="Ano Final",
                 minimum=2010,
                 maximum=2025,
-                value=2025,
+                value=datetime.now().year,
                 step=1,
+                interactive=True,
                 info="Ano mais recente para buscar"
             )
             
@@ -74,21 +79,33 @@ with gr.Blocks(
                 maximum=100,
                 value=50,
                 step=5,
+                interactive=True,
                 info="Número máximo de PLs encontradas"
             )
         
         with gr.Row():
             btn_buscar = gr.Button("🔍 Buscar e Analisar PLs", variant="primary", scale=2)
+        
+        with gr.Row():
             checkbox_camara = gr.Checkbox(label="Câmara dos Deputados", value=True)
             checkbox_senado = gr.Checkbox(label="Senado Federal", value=True)
+            checkbox_alesp = gr.Checkbox(
+                label="ALESP (Assembleia Legislativa SP)", 
+                value=False,
+                info="Dados atualizados diariamente"
+            )
+            checkbox_camara_sp = gr.Checkbox(label="Câmara Municipal SP", value=False)
         
         output_busca = gr.Markdown(label="📊 PLs Encontradas e Analisadas")
         
-        def buscar_e_analisar(ano_inicio, ano_fim, limite, buscar_camara, buscar_senado):
+        def buscar_e_analisar(ano_inicio, ano_fim, limite, checkbox_camara, checkbox_senado, checkbox_alesp, checkbox_camara_sp):
             """Busca PLs e analisa automaticamente"""
             import sys
             from io import StringIO
             
+            # Debug: verificar se função está sendo chamada
+            print("🔍 Função buscar_e_analisar chamada!", flush=True)
+            
             # Validar anos
             if ano_inicio > ano_fim:
                 return "❌ **Erro:** Ano inicial deve ser menor ou igual ao ano final."
@@ -96,8 +113,8 @@ with gr.Blocks(
             if ano_fim > datetime.now().year:
                 return f"❌ **Erro:** Ano final não pode ser maior que {datetime.now().year}."
             
-            if not buscar_camara and not buscar_senado:
-                return "❌ **Erro:** Selecione pelo menos uma fonte (Câmara ou Senado)."
+            if not checkbox_camara and not checkbox_senado and not checkbox_alesp and not checkbox_camara_sp:
+                return "❌ **Erro:** Selecione pelo menos uma fonte."
             
             # Capturar prints para exibir na interface
             old_stdout = sys.stdout
@@ -107,17 +124,37 @@ with gr.Blocks(
                 pls_encontradas = []
                 anos_para_buscar = list(range(int(ano_inicio), int(ano_fim) + 1))
                 
+                # Contar quantas fontes foram selecionadas para distribuir o limite
+                fontes_selecionadas = []
+                if checkbox_camara:
+                    fontes_selecionadas.append("Câmara")
+                if checkbox_senado:
+                    fontes_selecionadas.append("Senado")
+                if checkbox_alesp:
+                    fontes_selecionadas.append("ALESP")
+                if checkbox_camara_sp:
+                    fontes_selecionadas.append("Câmara Municipal SP")
+                
+                num_fontes = len(fontes_selecionadas)
+                
+                # Distribuir limite entre as fontes (cada fonte busca uma proporção do limite)
+                # Usar limite * 1.1 para garantir que distribuímos bem, mas depois limitamos o total
+                limite_por_fonte = max(5, int(int(limite) * 1.1 / num_fontes)) if num_fontes > 0 else int(limite)
+                
                 print(f"🔍 Buscando PLs LGBTQIA+ no Congresso Nacional...")
                 print(f"📅 Período: {ano_inicio} a {ano_fim} ({len(anos_para_buscar)} anos)")
+                print(f"📊 Fontes selecionadas: {', '.join(fontes_selecionadas)} ({num_fontes} fontes)")
+                print(f"📋 Distribuindo limite: até ~{limite_por_fonte} PLs por fonte (total máximo: {limite})")
                 
                 # 1. Câmara dos Deputados
-                if buscar_camara:
-                    print(f"\n📥 Buscando na Câmara dos Deputados...")
+                if checkbox_camara:
+                    print(f"\n📥 Buscando na Câmara dos Deputados (limite: ~{limite_por_fonte})...")
+                    pls_camara = []
                     for ano in reversed(anos_para_buscar):
-                        if len(pls_encontradas) >= int(limite):
+                        if len(pls_camara) >= limite_por_fonte:
                             break
                         
-                        limite_restante = int(limite) - len(pls_encontradas)
+                        limite_restante = limite_por_fonte - len(pls_camara)
                         if limite_restante <= 0:
                             break
                         
@@ -127,18 +164,22 @@ with gr.Blocks(
                             ano_inicio_manual=ano,
                             ano_fim_manual=ano
                         )
-                        pls_encontradas.extend(pls_ano)
+                        pls_camara.extend(pls_ano)
                         if pls_ano:
                             print(f"   ✅ {len(pls_ano)} PLs encontradas na Câmara em {ano}")
+                    
+                    pls_encontradas.extend(pls_camara)
+                    print(f"   📊 Total Câmara: {len(pls_camara)} PLs")
                 
                 # 2. Senado Federal
-                if buscar_senado and len(pls_encontradas) < int(limite):
-                    print(f"\n📥 Buscando no Senado Federal...")
+                if checkbox_senado:
+                    print(f"\n📥 Buscando no Senado Federal (limite: ~{limite_por_fonte})...")
+                    pls_senado = []
                     for ano in reversed(anos_para_buscar):
-                        if len(pls_encontradas) >= int(limite):
+                        if len(pls_senado) >= limite_por_fonte:
                             break
                         
-                        limite_restante = int(limite) - len(pls_encontradas)
+                        limite_restante = limite_por_fonte - len(pls_senado)
                         if limite_restante <= 0:
                             break
                         
@@ -147,9 +188,46 @@ with gr.Blocks(
                             ano_inicio_manual=ano,
                             ano_fim_manual=ano
                         )
-                        pls_encontradas.extend(pls_ano)
+                        pls_senado.extend(pls_ano)
                         if pls_ano:
                             print(f"   ✅ {len(pls_ano)} PLs encontradas no Senado em {ano}")
+                    
+                    pls_encontradas.extend(pls_senado)
+                    print(f"   📊 Total Senado: {len(pls_senado)} PLs")
+                
+                # 3. ALESP (Assembleia Legislativa de São Paulo)
+                if checkbox_alesp:
+                    print(f"\n📥 Buscando na ALESP (limite: ~{limite_por_fonte})...")
+                    pls_alesp = buscar_alesp(
+                        limite=limite_por_fonte,
+                        ano_inicio_manual=int(ano_inicio),
+                        ano_fim_manual=int(ano_fim)
+                    )
+                    pls_encontradas.extend(pls_alesp)
+                    if pls_alesp:
+                        print(f"   ✅ {len(pls_alesp)} PLs encontradas na ALESP")
+                    else:
+                        print(f"   ℹ️ Nenhuma PL relevante encontrada na ALESP")
+                
+                # 4. Câmara Municipal de São Paulo
+                if checkbox_camara_sp:
+                    print(f"\n📥 Buscando na Câmara Municipal de SP (limite: ~{limite_por_fonte})...")
+                    pls_camara_sp = buscar_camara_sao_paulo(
+                        limite=limite_por_fonte,
+                        ano_inicio_manual=int(ano_inicio),
+                        ano_fim_manual=int(ano_fim)
+                    )
+                    pls_encontradas.extend(pls_camara_sp)
+                    if pls_camara_sp:
+                        print(f"   ✅ {len(pls_camara_sp)} PLs encontradas na Câmara Municipal SP")
+                    else:
+                        print(f"   ℹ️ Nenhuma PL relevante encontrada na Câmara Municipal SP")
+                
+                # Limitar o total final ao limite solicitado (caso tenha ultrapassado)
+                if len(pls_encontradas) > int(limite):
+                    print(f"\n📊 Total encontrado: {len(pls_encontradas)} PLs")
+                    print(f"   ⚙️ Limitando a {limite} PLs (mantendo diversidade de fontes)...")
+                    pls_encontradas = pls_encontradas[:int(limite)]
                 
                 # Restaurar stdout
                 sys.stdout = old_stdout
@@ -157,10 +235,14 @@ with gr.Blocks(
                 
                 if not pls_encontradas:
                     fontes = []
-                    if buscar_camara:
+                    if checkbox_camara:
                         fontes.append("Câmara dos Deputados")
-                    if buscar_senado:
+                    if checkbox_senado:
                         fontes.append("Senado Federal")
+                    if checkbox_alesp:
+                        fontes.append("ALESP")
+                    if checkbox_camara_sp:
+                        fontes.append("Câmara Municipal SP")
                     fontes_str = " e ".join(fontes)
                     
                     return f"""⚠️ Nenhuma PL encontrada em {fontes_str} para o período {int(ano_inicio)}-{int(ano_fim)}.
@@ -236,10 +318,14 @@ with gr.Blocks(
                 revisao = sum(1 for r in resultados if r['Classificação'] == 'REVISÃO')
                 
                 fontes_usadas = []
-                if buscar_camara:
+                if checkbox_camara:
                     fontes_usadas.append("Câmara")
-                if buscar_senado:
+                if checkbox_senado:
                     fontes_usadas.append("Senado")
+                if checkbox_alesp:
+                    fontes_usadas.append("ALESP")
+                if checkbox_camara_sp:
+                    fontes_usadas.append("Câmara Municipal SP")
                 
                 relatorio = f"""## 🔍 Radar de PLs LGBTQIA+ - Resultados
 
@@ -284,7 +370,7 @@ with gr.Blocks(
         
         btn_buscar.click(
             fn=buscar_e_analisar,
-            inputs=[ano_inicio, ano_fim, limite_resultados, checkbox_camara, checkbox_senado],
+            inputs=[ano_inicio, ano_fim, limite_resultados, checkbox_camara, checkbox_senado, checkbox_alesp, checkbox_camara_sp],
             outputs=output_busca
         )
         
@@ -307,11 +393,13 @@ with gr.Blocks(
         - **Período médio (3-5 anos):** Balanceado, mais resultados
         - **Período grande (2010-2025):** Pode levar alguns minutos, muitos resultados
         
-        ### ⚠️ Limitações:
-        - A busca pode levar alguns segundos (até minutos para períodos longos)
-        - A API da Câmara permite até 100 itens por página (buscamos múltiplas páginas)
-        - A API do Senado ainda está em desenvolvimento básico
-        - Depende da disponibilidade das APIs públicas
+                ### ⚠️ Limitações e Avisos:
+                - A busca pode levar alguns segundos (até minutos para períodos longos)
+                - **Câmara dos Deputados**: API permite até 100 itens por página (buscamos múltiplas páginas)
+                - **Senado Federal**: Busca todas as matérias apresentadas no ano via `/materia/pesquisa/lista` ✅
+                - **ALESP**: Baixa arquivo ZIP completo (~16MB) toda vez, garantindo dados atualizados. Pode levar 10-20 segundos. Atualizado diariamente.
+                - **Câmara Municipal SP**: Busca todos os projetos do ano (pode ter 20k+), filtra localmente
+                - Depende da disponibilidade das APIs públicas
         """)
     
     gr.Markdown("""

ensemble_híbrido.py

@@ -125,15 +125,44 @@ def carregar_modelos():
         radar = None
     
     try:
+        # AzMina não tem tokenizer_config.json no repositório, então usamos o tokenizer do modelo base
+        # Conforme README do modelo: base_model = neuralmind/bert-base-portuguese-cased
+        from transformers import AutoTokenizer, AutoModelForSequenceClassification
+        
+        # Modelo base conforme documentado no README do repositório AzMina
+        base_model = "neuralmind/bert-base-portuguese-cased"
+        
+        print("   🔧 Carregando AzMina com tokenizer do modelo base...")
+        # Carregar tokenizer do modelo base (mesmo usado no treinamento do AzMina)
+        tokenizer = AutoTokenizer.from_pretrained(base_model)
+        # Carregar apenas o modelo AzMina (fine-tuned)
+        model = AutoModelForSequenceClassification.from_pretrained(MODEL_AZMINA)
+        
+        # Criar pipeline combinando modelo AzMina + tokenizer do modelo base
+        # Isso é seguro porque o AzMina foi treinado com esse tokenizer específico
         azmina = pipeline(
             "text-classification",
-            model=MODEL_AZMINA,
+            model=model,
+            tokenizer=tokenizer,
             device=-1  # CPU
         )
         print("   ✅ AzMina carregado")
     except Exception as e:
-        print(f"   ⚠️ Erro ao carregar AzMina: {e}")
-        azmina = None
+        error_msg = str(e)
+        print(f"   ⚠️ Erro ao carregar AzMina: {error_msg[:150]}")
+        print("   ℹ️ Tentando método alternativo (pipeline direto)...")
+        try:
+            # Fallback: tentar pipeline direto (provavelmente falhará, mas tentamos)
+            azmina = pipeline(
+                "text-classification",
+                model=MODEL_AZMINA,
+                device=-1
+            )
+            print("   ✅ AzMina carregado (método alternativo)")
+        except Exception as e2:
+            print(f"   ❌ AzMina não pôde ser carregado: {str(e2)[:100]}")
+            print("   ⚠️ Sistema funcionará apenas com Radar Social + Keywords + Padrões")
+            azmina = None
     
     return radar, azmina
 
@@ -190,12 +219,23 @@ def classificar_ensemble(
     
     if pesos is None:
         # Pesos ajustados: dar mais peso a keywords e padrões (mais específicos para legislação)
-        pesos = {
-            'radar': 0.20,      # Detecção de ódio (menos relevante em legislação)
-            'azmina': 0.15,     # Perspectiva feminista (proxy, não ideal) - REDUZIDO
-            'keywords': 0.35,   # Keywords específicas (MAIS IMPORTANTE - legislação tem termos claros)
-            'padroes': 0.30     # Padrões legislativos (CRÍTICO para detectar restrições) - AUMENTADO
-        }
+        # Se AzMina não estiver disponível, redistribuir seu peso proporcionalmente
+        if azmina_model is None:
+            # Sem AzMina: aumentar peso de keywords e padrões proporcionalmente
+            pesos = {
+                'radar': 0.20,      # Detecção de ódio
+                'azmina': 0.0,      # AzMina não disponível
+                'keywords': 0.40,    # Aumentado de 0.35 para 0.40 (+0.05 do AzMina)
+                'padroes': 0.40     # Aumentado de 0.30 para 0.40 (+0.10 do AzMina)
+            }
+        else:
+            # Com ambos os modelos: distribuição otimizada
+            pesos = {
+                'radar': 0.20,      # Detecção de ódio (menos relevante em legislação)
+                'azmina': 0.15,     # Perspectiva feminista (proxy, não ideal) - REDUZIDO
+                'keywords': 0.35,   # Keywords específicas (MAIS IMPORTANTE - legislação tem termos claros)
+                'padroes': 0.30     # Padrões legislativos (CRÍTICO para detectar restrições) - AUMENTADO
+            }
     
     resultados = {}