agroplan-ai-cli 1.0.15 → 1.0.17

package/backend-template/providers/zarc_provider.py

@@ -16,6 +16,11 @@ ZARC_CACHE_DIR = os.path.join(os.path.dirname(__file__), '..', 'data', 'zarc')
 ZARC_CACHE_TTL = int(os.getenv("ZARC_CACHE_TTL", "86400"))  # 24 horas
 ZARC_SOURCE = os.getenv("ZARC_SOURCE", "official")  # official, fallback
 ZARC_SAFRA_DEFAULT = os.getenv("ZARC_SAFRA", "2025/2026")
+ZARC_FAST_INDEX_ENABLED = os.getenv("ZARC_FAST_INDEX_ENABLED", "true").lower() == "true"
+ZARC_ALLOW_FULL_SCAN = os.getenv("ZARC_ALLOW_FULL_SCAN", "false").lower() == "true"
+
+# Cache do índice em memória (pequeno, pode ficar em RAM)
+_zarc_index_cache = {}
 
 # URLs oficiais do Portal de Dados Abertos do Ministério da Agricultura
 ZARC_URLS = {
@@ -314,7 +319,242 @@ def is_cache_valid(cache_path: str) -> bool:
     file_age = datetime.now() - datetime.fromtimestamp(os.path.getmtime(cache_path))
     return file_age.total_seconds() < ZARC_CACHE_TTL
 
-def download_zarc_dataset(safra: str) -> Optional[str]:
+def get_zarc_status(safra: str = ZARC_SAFRA_DEFAULT) -> Dict[str, Any]:
+    """
+    Retorna status do ZARC sem carregar dados
+    
+    MEMORY SAFE: Não carrega CSV, apenas verifica arquivos
+    
+    Returns:
+        Status do ZARC (configuração, cache, etc)
+    """
+    cache_path = get_cache_path(safra)
+    
+    # Verificar índice
+    safra_filename = safra.replace("/", "-")
+    index_path = os.path.join(ZARC_CACHE_DIR, f"zarc_index_{safra_filename}.json")
+    
+    status = {
+        "status": "configured",
+        "safra": safra,
+        "source": ZARC_SOURCE,
+        "fast_index": ZARC_FAST_INDEX_ENABLED,
+        "full_scan": ZARC_ALLOW_FULL_SCAN,
+        "index_exists": os.path.exists(index_path),
+        "cache_exists": os.path.exists(cache_path),
+        "cache_valid": False,
+        "cache_size_mb": 0
+    }
+    
+    if os.path.exists(cache_path):
+        try:
+            # Tamanho do arquivo em MB
+            size_bytes = os.path.getsize(cache_path)
+            status["cache_size_mb"] = round(size_bytes / (1024 * 1024), 2)
+            
+            # Verificar se cache é válido
+            status["cache_valid"] = is_cache_valid(cache_path)
+        except Exception:
+            pass
+    
+    return status
+
+def load_zarc_index(safra: str = ZARC_SAFRA_DEFAULT) -> Optional[Dict[str, Any]]:
+    """
+    Carrega índice ZARC compacto em memória
+    
+    MEMORY SAFE: Índice é pequeno (~35KB), pode ficar em RAM
+    
+    Returns:
+        Índice ZARC ou None se não existir
+    """
+    global _zarc_index_cache
+    
+    # Verificar cache em memória
+    if safra in _zarc_index_cache:
+        return _zarc_index_cache[safra]
+    
+    # Carregar do arquivo
+    safra_filename = safra.replace("/", "-")
+    index_path = os.path.join(ZARC_CACHE_DIR, f"zarc_index_{safra_filename}.json")
+    
+    if not os.path.exists(index_path):
+        return None
+    
+    try:
+        with open(index_path, 'r', encoding='utf-8') as f:
+            index = json.load(f)
+        
+        # Cachear em memória
+        _zarc_index_cache[safra] = index
+        
+        return index
+    except Exception as e:
+        print(f"Erro ao carregar índice ZARC: {e}")
+        return None
+
+def buscar_zarc_indexado(
+    cultura: str,
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    solo: Optional[str] = None,
+    safra: str = ZARC_SAFRA_DEFAULT
+) -> Optional[Dict[str, Any]]:
+    """
+    Busca ZARC no índice compacto (rápido)
+    
+    PERFORMANCE: Lookup O(1) em vez de O(n) no CSV
+    
+    Returns:
+        Dados ZARC ou None se não encontrar no índice
+    """
+    if not ZARC_FAST_INDEX_ENABLED:
+        return None
+    
+    index = load_zarc_index(safra)
+    if not index:
+        return None
+    
+    # Normalizar parâmetros
+    cultura_norm = normalizar_cultura(cultura)
+    
+    if not uf or not municipio:
+        return None
+    
+    uf_norm = normalizar_uf(uf)
+    municipio_norm = normalizar_municipio(municipio)
+    
+    # Tentar diferentes combinações de solo
+    solos_tentar = []
+    if solo:
+        solo_norm = normalizar_solo(solo)
+        # Tentar o solo especificado primeiro, depois outros como fallback
+        solos_tentar = [solo_norm, "medio", "arenoso", "argiloso", "misto"]
+        # Remover duplicatas mantendo ordem
+        seen = set()
+        solos_tentar = [s for s in solos_tentar if not (s in seen or seen.add(s))]
+    else:
+        # Se não especificou solo, tentar todos (preferir medio/argiloso)
+        solos_tentar = ["medio", "argiloso", "arenoso", "misto"]
+    
+    # Buscar no índice
+    for solo_test in solos_tentar:
+        # Chave: UF|municipio|cultura|solo
+        chave = f"{uf_norm}|{municipio_norm}|{cultura_norm}|{solo_test}"
+        
+        if chave in index["records"]:
+            return index["records"][chave]
+    
+    return None
+
+def iter_zarc_records(file_path: str):
+    """
+    Itera sobre registros ZARC em streaming
+    
+    MEMORY SAFE: Usa yield para processar linha por linha
+    
+    Args:
+        file_path: Caminho do arquivo CSV
+    
+    Yields:
+        Dicionário com dados de cada linha
+    """
+    with open(file_path, 'r', encoding='utf-8-sig', newline='') as f:
+        # Detectar delimitador
+        primeira_linha = f.readline()
+        f.seek(0)
+        
+        delimiter = ';' if ';' in primeira_linha else ','
+        
+        reader = csv.DictReader(f, delimiter=delimiter)
+        
+        for row in reader:
+            yield row
+
+def ensure_zarc_file(safra: str = ZARC_SAFRA_DEFAULT) -> Optional[Dict[str, Any]]:
+    """
+    Garante que arquivo ZARC existe, baixando se necessário
+    
+    MEMORY SAFE: Não carrega registros, apenas gerencia arquivo
+    
+    Returns:
+        Metadata do arquivo ou None se não disponível
+    """
+    cache_path = get_cache_path(safra)
+    
+    # Verificar cache válido
+    if is_cache_valid(cache_path):
+        return {
+            "file_path": cache_path,
+            "source": "zarc-cache",
+            "fallback": False,
+            "error": None
+        }
+    
+    # Tentar download se source for official
+    if ZARC_SOURCE == "official":
+        url = ZARC_URLS.get(safra)
+        if url:
+            try:
+                # Criar request com User-Agent
+                req = urllib.request.Request(
+                    url,
+                    headers={
+                        'User-Agent': 'AgroPlan-AI/1.0 (https://github.com/Kuuhaku-Allan/agroplan-ai)'
+                    }
+                )
+                
+                # Download
+                with urllib.request.urlopen(req, timeout=30) as response:
+                    content = response.read().decode('utf-8')
+                
+                # Salvar
+                with open(cache_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                
+                return {
+                    "file_path": cache_path,
+                    "source": "zarc-oficial",
+                    "fallback": False,
+                    "error": None
+                }
+            except Exception as e:
+                # Se download falhar, tentar usar cache antigo
+                if os.path.exists(cache_path):
+                    return {
+                        "file_path": cache_path,
+                        "source": "zarc-cache",
+                        "fallback": False,
+                        "error": f"Download falhou, usando cache antigo: {str(e)}"
+                    }
+    
+    # Usar cache antigo se existir (mesmo expirado)
+    if os.path.exists(cache_path):
+        return {
+            "file_path": cache_path,
+            "source": "zarc-cache",
+            "fallback": False,
+            "error": "Cache expirado mas usado"
+        }
+    
+    # Nenhum arquivo disponível
+    return None
+
+# OBSOLETO: Funções antigas que carregavam CSV inteiro em memória
+# Mantidas apenas para referência, não devem ser usadas
+# Use: ensure_zarc_file() + iter_zarc_records() + buscar_zarc()
+
+# def download_zarc_dataset(safra: str) -> Optional[str]:
+#     """OBSOLETO - Não usar, causa problemas de memória"""
+#     pass
+
+# def get_zarc_dataset(safra: str = ZARC_SAFRA_DEFAULT) -> Dict[str, Any]:
+#     """OBSOLETO - Não usar, carrega 1M+ registros em memória"""
+#     pass
+
+# def load_zarc_from_file(file_path: str) -> List[Dict[str, Any]]:
+#     """OBSOLETO - Não usar, carrega CSV inteiro em lista"""
+#     pass
     """
     Baixa dataset ZARC oficial
     
@@ -576,6 +816,8 @@ def buscar_zarc(
     """
     Busca dados ZARC para cultura/região específica
     
+    PERFORMANCE: Tenta índice primeiro (rápido), depois streaming (lento)
+    
     Args:
         cultura: Nome da cultura
         uf: Unidade Federativa (opcional)
@@ -586,27 +828,51 @@ def buscar_zarc(
     Returns:
         Dicionário com dados ZARC ou None se não encontrar
     """
-    dataset_info = get_zarc_dataset(safra)
-    if not dataset_info or not dataset_info.get("records"):
-        return None
-    
-    dataset = dataset_info["records"]
-    source = dataset_info["source"]
-    is_fallback = dataset_info["fallback"]
+    # FAST PATH: Tentar índice primeiro (O(1) lookup)
+    if ZARC_FAST_INDEX_ENABLED:
+        resultado_indexado = buscar_zarc_indexado(cultura, uf, municipio, solo, safra)
+        if resultado_indexado:
+            return resultado_indexado
+    
+    # SLOW PATH: Full scan no CSV (apenas se permitido)
+    if not ZARC_ALLOW_FULL_SCAN:
+        # Não encontrou no índice e full scan não é permitido
+        # Tentar fallback
+        return buscar_zarc_fallback(cultura, uf, municipio, solo, safra)
+    
+    # Full scan permitido (desenvolvimento local)
+    return buscar_zarc_streaming(cultura, uf, municipio, solo, safra)
+
+def buscar_zarc_streaming(
+    cultura: str,
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    solo: Optional[str] = None,
+    safra: str = ZARC_SAFRA_DEFAULT
+) -> Optional[Dict[str, Any]]:
+    """
+    Busca ZARC usando streaming no CSV (LENTO mas memory-safe)
     
+    PERFORMANCE: O(n) - varre todo o CSV
+    Usar apenas em desenvolvimento ou quando índice não disponível
+    """
     # Normalizar parâmetros de busca
     cultura_norm = normalizar_cultura(cultura)
     uf_norm = normalizar_uf(uf) if uf else None
     municipio_norm = normalizar_municipio(municipio) if municipio else None
     solo_norm = normalizar_solo(solo) if solo else None
     
-    # Se estiver usando dados oficiais, processar decêndios
-    if not is_fallback:
-        # Buscar no CSV oficial
+    # Tentar obter arquivo ZARC
+    file_info = ensure_zarc_file(safra)
+    
+    if file_info:
+        # Usar arquivo oficial/cache com streaming
+        source = file_info["source"]
         melhor_match = None
         melhor_score = 0
         
-        for registro in dataset:
+        # Processar CSV em streaming (linha por linha)
+        for registro in iter_zarc_records(file_info["file_path"]):
             score = 0
             
             # Cultura deve bater
@@ -628,9 +894,10 @@ def buscar_zarc(
                 if normalizar_solo(solo_registro) == solo_norm:
                     score += 2
             
+            # Manter apenas o melhor match (não acumula lista)
             if score > melhor_score:
                 melhor_score = score
-                melhor_match = registro
+                melhor_match = registro.copy()  # Copia apenas este registro
         
         if melhor_match:
             # Extrair janelas de plantio dos decêndios
@@ -684,11 +951,31 @@ def buscar_zarc(
                 "message": "Nenhuma recomendação ZARC encontrada para os parâmetros informados."
             }
     
-    # Fallback: usar dados simplificados
+    # Arquivo não disponível, usar fallback
+    return buscar_zarc_fallback(cultura, uf, municipio, solo, safra)
+
+def buscar_zarc_fallback(
+    cultura: str,
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    solo: Optional[str] = None,
+    safra: str = ZARC_SAFRA_DEFAULT
+) -> Optional[Dict[str, Any]]:
+    """
+    Busca ZARC em dados simplificados (fallback)
+    """
+    # Normalizar parâmetros
+    cultura_norm = normalizar_cultura(cultura)
+    uf_norm = normalizar_uf(uf) if uf else None
+    municipio_norm = normalizar_municipio(municipio) if municipio else None
+    solo_norm = normalizar_solo(solo) if solo else None
+    
+    # Fallback: usar dados simplificados (lista pequena em memória)
+    fallback_data = get_zarc_fallback()
     melhor_match = None
     melhor_score = 0
     
-    for registro in dataset:
+    for registro in fallback_data:
         score = 0
         
         # Cultura deve bater

package/backend-template/scripts/build_zarc_index.py

@@ -0,0 +1,256 @@
+"""
+Script para construir índice ZARC compacto
+
+Processa o CSV oficial ZARC e gera um índice JSON pequeno
+contendo apenas as regiões e culturas de interesse do AgroPlan.
+
+Uso:
+    python scripts/build_zarc_index.py
+"""
+import sys
+import os
+import json
+from datetime import datetime
+
+# Adicionar diretório pai ao path para importar providers
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from providers.zarc_provider import (
+    ensure_zarc_file,
+    iter_zarc_records,
+    normalizar_cultura,
+    normalizar_municipio,
+    normalizar_uf,
+    normalizar_solo,
+    mapear_codigo_solo,
+    extrair_janelas_plantio,
+    escolher_melhor_janela,
+    ZARC_CACHE_DIR
+)
+
+# Regiões de interesse
+REGIOES_INTERESSE = [
+    {"uf": "SP", "municipio": "Clementina"},
+    {"uf": "SP", "municipio": "São Paulo"},
+    {"uf": "SP", "municipio": "Ribeirão Preto"},
+    {"uf": "MS", "municipio": "Campo Grande"},
+    {"uf": "PR", "municipio": "Londrina"},
+    {"uf": "DF", "municipio": "Brasília"},
+]
+
+# Culturas de interesse
+CULTURAS_INTERESSE = [
+    "soja",
+    "milho",
+    "feijao",
+    "trigo",
+    "algodao",
+    "cafe",
+    "cana",
+    "arroz",
+    "sorgo",
+    "mandioca"
+]
+
+# Solos de interesse
+SOLOS_INTERESSE = ["arenoso", "medio", "argiloso", "misto"]
+
+def build_zarc_index(safra: str = "2025/2026"):
+    """
+    Constrói índice ZARC compacto
+    
+    Args:
+        safra: Safra para processar
+    """
+    print(f"🌾 Construindo índice ZARC para safra {safra}...")
+    print()
+    
+    # Garantir que arquivo ZARC existe
+    file_info = ensure_zarc_file(safra)
+    
+    if not file_info:
+        print("❌ Erro: Arquivo ZARC não disponível")
+        return False
+    
+    print(f"✅ Arquivo ZARC: {file_info['file_path']}")
+    print(f"   Fonte: {file_info['source']}")
+    print()
+    
+    # Normalizar regiões de interesse
+    regioes_norm = []
+    for regiao in REGIOES_INTERESSE:
+        regioes_norm.append({
+            "uf": normalizar_uf(regiao["uf"]),
+            "municipio": normalizar_municipio(regiao["municipio"]),
+            "municipio_original": regiao["municipio"]
+        })
+    
+    # Normalizar culturas de interesse
+    culturas_norm = [normalizar_cultura(c) for c in CULTURAS_INTERESSE]
+    
+    print("📍 Regiões de interesse:")
+    for r in regioes_norm:
+        print(f"   - {r['municipio_original']}/{r['uf']}")
+    print()
+    
+    print("🌱 Culturas de interesse:")
+    for c in CULTURAS_INTERESSE:
+        print(f"   - {c}")
+    print()
+    
+    # Processar CSV em streaming
+    print("🔄 Processando CSV oficial...")
+    
+    index_records = {}
+    registros_processados = 0
+    registros_incluidos = 0
+    
+    for registro in iter_zarc_records(file_info['file_path']):
+        registros_processados += 1
+        
+        # Mostrar progresso a cada 100k registros
+        if registros_processados % 100000 == 0:
+            print(f"   Processados: {registros_processados:,} registros...")
+        
+        # Verificar se é cultura de interesse
+        cultura_csv = normalizar_cultura(registro.get("Nome_cultura", ""))
+        if cultura_csv not in culturas_norm:
+            continue
+        
+        # Verificar se é região de interesse
+        uf_csv = normalizar_uf(registro.get("UF", ""))
+        municipio_csv = normalizar_municipio(registro.get("municipio", ""))
+        
+        regiao_match = None
+        for regiao in regioes_norm:
+            if uf_csv == regiao["uf"] and municipio_csv == regiao["municipio"]:
+                regiao_match = regiao
+                break
+        
+        if not regiao_match:
+            continue
+        
+        # Solo
+        solo_codigo = registro.get("Cod_Solo", "")
+        solo_nome = mapear_codigo_solo(solo_codigo)
+        solo_norm = normalizar_solo(solo_nome)
+        
+        if solo_norm not in SOLOS_INTERESSE and solo_norm != "desconhecido":
+            continue
+        
+        # Extrair janelas de plantio
+        janelas = extrair_janelas_plantio(registro)
+        melhor_janela = escolher_melhor_janela(janelas)
+        
+        if not melhor_janela:
+            # Sem janelas válidas, pular
+            continue
+        
+        # Criar chave: UF|municipio|cultura|solo
+        chave = f"{uf_csv}|{municipio_csv}|{cultura_csv}|{solo_norm}"
+        
+        # Se já existe, manter o de menor risco
+        if chave in index_records:
+            risco_atual = index_records[chave]["risco"]
+            risco_novo = melhor_janela["risco_predominante"]
+            
+            ordem_risco = {"baixo": 1, "medio": 2, "alto": 3}
+            
+            if ordem_risco.get(risco_novo, 999) < ordem_risco.get(risco_atual, 999):
+                # Novo tem risco menor, substituir
+                pass
+            else:
+                # Manter o atual
+                continue
+        
+        # Adicionar ao índice
+        index_records[chave] = {
+            "source": "zarc-oficial-derived",
+            "fallback": False,
+            "cultura": registro.get("Nome_cultura"),
+            "uf": uf_csv.upper(),
+            "municipio": regiao_match["municipio_original"],
+            "solo": solo_nome,
+            "safra": safra,
+            "janela_plantio": {
+                "inicio": melhor_janela["inicio"],
+                "fim": melhor_janela["fim"]
+            },
+            "risco": melhor_janela["risco_predominante"],
+            "decendios_recomendados": melhor_janela["decendios"],
+            "geocodigo": registro.get("geocodigo", ""),
+            "encontrado": True,
+            "observacao": "Dados derivados da Tábua de Risco oficial do ZARC."
+        }
+        
+        registros_incluidos += 1
+    
+    print(f"✅ Processamento concluído!")
+    print(f"   Total processado: {registros_processados:,} registros")
+    print(f"   Incluídos no índice: {registros_incluidos} registros")
+    print()
+    
+    # Criar estrutura do índice
+    index = {
+        "metadata": {
+            "source": "zarc-oficial-derived",
+            "safra": safra,
+            "generated_at": datetime.now().isoformat(),
+            "generated_from": file_info["source"],
+            "regions": [f"{r['municipio_original']}/{r['uf']}" for r in regioes_norm],
+            "cultures": CULTURAS_INTERESSE,
+            "soils": SOLOS_INTERESSE,
+            "total_records": registros_incluidos
+        },
+        "records": index_records
+    }
+    
+    # Salvar índice
+    safra_filename = safra.replace("/", "-")
+    index_path = os.path.join(ZARC_CACHE_DIR, f"zarc_index_{safra_filename}.json")
+    
+    with open(index_path, 'w', encoding='utf-8') as f:
+        json.dump(index, f, ensure_ascii=False, indent=2)
+    
+    # Calcular tamanho
+    size_bytes = os.path.getsize(index_path)
+    size_kb = size_bytes / 1024
+    
+    print(f"💾 Índice salvo em: {index_path}")
+    print(f"   Tamanho: {size_kb:.2f} KB")
+    print()
+    
+    # Estatísticas por região
+    print("📊 Estatísticas por região:")
+    for regiao in regioes_norm:
+        count = sum(1 for k in index_records.keys() 
+                   if k.startswith(f"{regiao['uf']}|{regiao['municipio']}|"))
+        print(f"   {regiao['municipio_original']}/{regiao['uf']}: {count} registros")
+    print()
+    
+    # Estatísticas por cultura
+    print("📊 Estatísticas por cultura:")
+    for cultura in culturas_norm:
+        count = sum(1 for k in index_records.keys() 
+                   if f"|{cultura}|" in k)
+        print(f"   {cultura}: {count} registros")
+    print()
+    
+    print("✅ Índice ZARC construído com sucesso!")
+    return True
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Construir índice ZARC compacto")
+    parser.add_argument(
+        "--safra",
+        default="2025/2026",
+        help="Safra para processar (padrão: 2025/2026)"
+    )
+    
+    args = parser.parse_args()
+    
+    success = build_zarc_index(args.safra)
+    
+    sys.exit(0 if success else 1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agroplan-ai-cli",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {