agroplan-ai-cli 1.0.0

package/backend-template/core/scenario_simulator.py

@@ -0,0 +1,286 @@
+"""
+Simulador de cenários para comparar diferentes estratégias de planejamento agrícola
+"""
+
+from core.terrain_analyzer import analisar_todos_talhoes
+
+
+def calcular_metricas_plano(plano):
+    """Calcula métricas agregadas de um plano"""
+    lucro_total = sum(p['lucro_estimado'] for p in plano)
+    area_total = sum(p['area'] for p in plano)
+    risco_ponderado = sum(p['risco'] * p['area'] for p in plano)
+    risco_medio = risco_ponderado / area_total if area_total > 0 else 0
+    
+    return {
+        'lucro_total': lucro_total,
+        'area_total': area_total,
+        'risco_medio': risco_medio
+    }
+
+
+def gerar_cenario_equilibrado(analises):
+    """
+    Cenário Equilibrado: Escolhe a cultura com maior nota_final
+    Melhor equilíbrio entre lucro, compatibilidade e risco
+    """
+    plano = []
+    
+    for analise in analises:
+        talhao = analise['talhao']
+        melhor = analise['melhor_cultura']  # Já é a de maior nota
+        
+        if melhor:
+            plano.append({
+                'talhao': talhao['id'],
+                'area': talhao['area'],
+                'cultura': melhor['cultura'],
+                'lucro_estimado': melhor['lucro_total'],
+                'risco': melhor['risco'],
+                'nota': melhor['nota']
+            })
+    
+    metricas = calcular_metricas_plano(plano)
+    
+    return {
+        'nome': 'Equilibrado',
+        'descricao': 'Melhor equilíbrio entre lucro, compatibilidade e risco.',
+        'plano': plano,
+        **metricas
+    }
+
+
+def gerar_cenario_maximo_lucro(analises):
+    """
+    Cenário Máximo Lucro: Prioriza lucro_estimado
+    O risco pode ser maior, mas ainda aparece no relatório
+    """
+    plano = []
+    
+    for analise in analises:
+        talhao = analise['talhao']
+        ranking = analise['ranking']
+        
+        # Escolhe a cultura com maior lucro
+        melhor_lucro = max(ranking, key=lambda x: x['lucro_total'])
+        
+        plano.append({
+            'talhao': talhao['id'],
+            'area': talhao['area'],
+            'cultura': melhor_lucro['cultura'],
+            'lucro_estimado': melhor_lucro['lucro_total'],
+            'risco': melhor_lucro['risco'],
+            'nota': melhor_lucro['nota']
+        })
+    
+    metricas = calcular_metricas_plano(plano)
+    
+    return {
+        'nome': 'Máximo Lucro',
+        'descricao': 'Prioriza o maior retorno financeiro estimado.',
+        'plano': plano,
+        **metricas
+    }
+
+
+def gerar_cenario_baixo_risco(analises):
+    """
+    Cenário Baixo Risco: Prioriza culturas com menor risco
+    Em caso de empate, escolhe maior nota_final
+    """
+    plano = []
+    
+    for analise in analises:
+        talhao = analise['talhao']
+        ranking = analise['ranking']
+        
+        # Ordena por risco (crescente) e depois por nota (decrescente)
+        ranking_ordenado = sorted(ranking, key=lambda x: (x['risco'], -x['nota']))
+        melhor_baixo_risco = ranking_ordenado[0]
+        
+        plano.append({
+            'talhao': talhao['id'],
+            'area': talhao['area'],
+            'cultura': melhor_baixo_risco['cultura'],
+            'lucro_estimado': melhor_baixo_risco['lucro_total'],
+            'risco': melhor_baixo_risco['risco'],
+            'nota': melhor_baixo_risco['nota']
+        })
+    
+    metricas = calcular_metricas_plano(plano)
+    
+    return {
+        'nome': 'Baixo Risco',
+        'descricao': 'Prioriza segurança e menor exposição a perdas.',
+        'plano': plano,
+        **metricas
+    }
+
+
+def gerar_cenario_sustentavel(analises):
+    """
+    Cenário Sustentável: Prioriza boa compatibilidade com solo, água e risco menor
+    Não escolhe apenas pelo lucro
+    """
+    plano = []
+    
+    for analise in analises:
+        talhao = analise['talhao']
+        ranking = analise['ranking']
+        
+        # Calcula score de sustentabilidade
+        # Prioriza compatibilidades altas e risco baixo
+        def score_sustentavel(cultura):
+            compatibilidade = (
+                cultura['compatibilidade_solo'] +
+                cultura['compatibilidade_clima'] +
+                cultura['compatibilidade_agua']
+            )
+            # Penaliza risco mais fortemente
+            return compatibilidade - (cultura['risco'] / 5)
+        
+        melhor_sustentavel = max(ranking, key=score_sustentavel)
+        
+        plano.append({
+            'talhao': talhao['id'],
+            'area': talhao['area'],
+            'cultura': melhor_sustentavel['cultura'],
+            'lucro_estimado': melhor_sustentavel['lucro_total'],
+            'risco': melhor_sustentavel['risco'],
+            'nota': melhor_sustentavel['nota']
+        })
+    
+    metricas = calcular_metricas_plano(plano)
+    
+    return {
+        'nome': 'Sustentável',
+        'descricao': 'Prioriza compatibilidade ambiental e uso eficiente de recursos.',
+        'plano': plano,
+        **metricas
+    }
+
+
+def gerar_cenario_conservador(analises):
+    """
+    Cenário Conservador: Evita culturas com risco alto
+    Escolhe opções com boa nota e risco controlado
+    """
+    plano = []
+    
+    for analise in analises:
+        talhao = analise['talhao']
+        ranking = analise['ranking']
+        
+        # Filtra culturas com risco <= 30%, se possível
+        ranking_baixo_risco = [c for c in ranking if c['risco'] <= 30]
+        
+        # Se não houver opções de baixo risco, usa todas
+        if not ranking_baixo_risco:
+            ranking_baixo_risco = ranking
+        
+        # Entre as de baixo risco, escolhe a de maior nota
+        melhor_conservador = max(ranking_baixo_risco, key=lambda x: x['nota'])
+        
+        plano.append({
+            'talhao': talhao['id'],
+            'area': talhao['area'],
+            'cultura': melhor_conservador['cultura'],
+            'lucro_estimado': melhor_conservador['lucro_total'],
+            'risco': melhor_conservador['risco'],
+            'nota': melhor_conservador['nota']
+        })
+    
+    metricas = calcular_metricas_plano(plano)
+    
+    return {
+        'nome': 'Conservador',
+        'descricao': 'Evita riscos altos, priorizando segurança e estabilidade.',
+        'plano': plano,
+        **metricas
+    }
+
+
+def simular_cenarios(culturas, talhoes, regras):
+    """
+    Simula diferentes cenários de planejamento agrícola
+    
+    Retorna um dicionário com todos os cenários e suas métricas
+    """
+    # Analisa todos os talhões uma única vez
+    analises = analisar_todos_talhoes(talhoes, culturas, regras)
+    
+    # Gera todos os cenários
+    cenarios = {
+        'equilibrado': gerar_cenario_equilibrado(analises),
+        'maximo_lucro': gerar_cenario_maximo_lucro(analises),
+        'baixo_risco': gerar_cenario_baixo_risco(analises),
+        'sustentavel': gerar_cenario_sustentavel(analises),
+        'conservador': gerar_cenario_conservador(analises)
+    }
+    
+    return cenarios
+
+
+def recomendar_melhor_cenario(cenarios):
+    """
+    Recomenda o melhor cenário baseado em critérios balanceados
+    
+    Considera:
+    - Lucro razoável (não necessariamente o máximo)
+    - Risco controlado
+    - Equilíbrio geral
+    """
+    # Por padrão, recomenda o equilibrado
+    melhor = 'equilibrado'
+    
+    # Mas verifica se há cenários melhores
+    equilibrado = cenarios['equilibrado']
+    baixo_risco = cenarios['baixo_risco']
+    
+    # Se o baixo risco tem lucro muito próximo (>90%) e risco menor, prefere ele
+    if baixo_risco['lucro_total'] >= equilibrado['lucro_total'] * 0.9:
+        if baixo_risco['risco_medio'] < equilibrado['risco_medio']:
+            melhor = 'baixo_risco'
+    
+    justificativa = gerar_justificativa_recomendacao(cenarios, melhor)
+    
+    return {
+        'cenario': melhor,
+        'justificativa': justificativa
+    }
+
+
+def gerar_justificativa_recomendacao(cenarios, cenario_escolhido):
+    """Gera justificativa para a recomendação do cenário"""
+    cenario = cenarios[cenario_escolhido]
+    
+    justificativas = {
+        'equilibrado': (
+            f"O cenário {cenario['nome']} foi recomendado porque apresenta "
+            f"bom lucro estimado (R$ {cenario['lucro_total']:,.2f}), "
+            f"risco controlado ({cenario['risco_medio']:.1f}%) e "
+            f"alta compatibilidade entre culturas e características dos talhões."
+        ),
+        'baixo_risco': (
+            f"O cenário {cenario['nome']} foi recomendado porque oferece "
+            f"excelente segurança com risco médio de apenas {cenario['risco_medio']:.1f}%, "
+            f"mantendo lucro razoável de R$ {cenario['lucro_total']:,.2f}."
+        ),
+        'maximo_lucro': (
+            f"O cenário {cenario['nome']} foi recomendado porque maximiza "
+            f"o retorno financeiro (R$ {cenario['lucro_total']:,.2f}), "
+            f"com risco aceitável de {cenario['risco_medio']:.1f}%."
+        ),
+        'sustentavel': (
+            f"O cenário {cenario['nome']} foi recomendado porque prioriza "
+            f"compatibilidade ambiental e uso eficiente de recursos, "
+            f"com lucro de R$ {cenario['lucro_total']:,.2f} e risco de {cenario['risco_medio']:.1f}%."
+        ),
+        'conservador': (
+            f"O cenário {cenario['nome']} foi recomendado porque evita "
+            f"riscos altos, mantendo risco médio de {cenario['risco_medio']:.1f}% "
+            f"e lucro de R$ {cenario['lucro_total']:,.2f}."
+        )
+    }
+    
+    return justificativas.get(cenario_escolhido, "Cenário recomendado pelo sistema.")

package/backend-template/core/scorer.py

@@ -0,0 +1,101 @@
+"""
+Sistema de pontuação para avaliar compatibilidade entre culturas e talhões
+"""
+
+def calcular_compatibilidade_solo(solo_talhao, solos_ideais):
+    """Calcula compatibilidade do solo (0-25 pontos)"""
+    solos = [s.strip() for s in solos_ideais.split(';')]
+    return 25 if solo_talhao in solos else 0
+
+
+def calcular_compatibilidade_clima(clima_talhao, climas_ideais):
+    """Calcula compatibilidade do clima (0-25 pontos)"""
+    climas = [c.strip() for c in climas_ideais.split(';')]
+    return 25 if clima_talhao in climas else 0
+
+
+def calcular_compatibilidade_relevo(relevo_talhao, relevos_ideais):
+    """Calcula compatibilidade do relevo (0-15 pontos)"""
+    relevos = [r.strip() for r in relevos_ideais.split(';')]
+    return 15 if relevo_talhao in relevos else 0
+
+
+def calcular_compatibilidade_agua(agua_talhao, agua_necessaria):
+    """Calcula compatibilidade da disponibilidade de água (0-15 pontos)"""
+    # Mapeamento de níveis
+    niveis = {'baixa': 1, 'media': 2, 'alta': 3}
+    
+    nivel_talhao = niveis.get(agua_talhao, 0)
+    nivel_necessario = niveis.get(agua_necessaria, 0)
+    
+    # Pontuação máxima se atende ou excede a necessidade
+    if nivel_talhao >= nivel_necessario:
+        return 15
+    # Penalidade se não atende
+    elif nivel_talhao == nivel_necessario - 1:
+        return 8
+    else:
+        return 0
+
+
+def calcular_lucro_por_hectare(cultura):
+    """Calcula lucro estimado por hectare"""
+    return (cultura['preco'] * cultura['produtividade']) - cultura['custo']
+
+
+def normalizar_lucro(lucro, lucro_min, lucro_max):
+    """Normaliza lucro para escala 0-10"""
+    if lucro_max == lucro_min:
+        return 5
+    return 10 * (lucro - lucro_min) / (lucro_max - lucro_min)
+
+
+def calcular_nota_final(talhao, cultura, regra, lucro_normalizado):
+    """
+    Calcula nota final da cultura para o talhão
+    
+    Componentes:
+    - Solo: 0-25 pontos
+    - Clima: 0-25 pontos
+    - Relevo: 0-15 pontos
+    - Água: 0-15 pontos
+    - Lucro: 0-10 pontos
+    - Risco: -risco_base pontos
+    
+    Total máximo: 90 pontos (antes do risco)
+    """
+    nota = 0
+    
+    # Compatibilidades
+    nota += calcular_compatibilidade_solo(talhao['solo'], regra['solos_ideais'])
+    nota += calcular_compatibilidade_clima(talhao['clima'], regra['climas_ideais'])
+    nota += calcular_compatibilidade_relevo(talhao['relevo'], regra['relevo_ideal'])
+    nota += calcular_compatibilidade_agua(talhao['agua'], regra['agua_necessaria'])
+    
+    # Lucro normalizado
+    nota += lucro_normalizado
+    
+    # Penalidade por risco
+    nota -= (regra['risco_base'] / 10)
+    
+    return round(nota, 2)
+
+
+def avaliar_cultura_para_talhao(talhao, cultura, regra, lucro_normalizado):
+    """Avalia uma cultura específica para um talhão e retorna detalhes completos"""
+    lucro_por_ha = calcular_lucro_por_hectare(cultura)
+    lucro_total = lucro_por_ha * talhao['area']
+    nota = calcular_nota_final(talhao, cultura, regra, lucro_normalizado)
+    
+    return {
+        'cultura': cultura['nome'],
+        'nota': nota,
+        'lucro_por_ha': lucro_por_ha,
+        'lucro_total': lucro_total,
+        'risco': regra['risco_base'],
+        'tempo': cultura['tempo'],
+        'compatibilidade_solo': calcular_compatibilidade_solo(talhao['solo'], regra['solos_ideais']),
+        'compatibilidade_clima': calcular_compatibilidade_clima(talhao['clima'], regra['climas_ideais']),
+        'compatibilidade_relevo': calcular_compatibilidade_relevo(talhao['relevo'], regra['relevo_ideal']),
+        'compatibilidade_agua': calcular_compatibilidade_agua(talhao['agua'], regra['agua_necessaria'])
+    }

package/backend-template/core/terrain_analyzer.py

@@ -0,0 +1,123 @@
+"""
+Analisador de terreno que avalia e recomenda culturas para cada talhão
+"""
+
+from core.scorer import calcular_lucro_por_hectare, normalizar_lucro, avaliar_cultura_para_talhao
+
+
+def analisar_talhao(talhao, culturas, regras):
+    """
+    Analisa um talhão e retorna ranking de culturas recomendadas
+    
+    Retorna:
+    - ranking: lista de culturas ordenadas por nota
+    - melhor_cultura: cultura com maior nota
+    - justificativa: texto explicando a recomendação
+    """
+    avaliacoes = []
+    
+    # Calcula lucro de todas as culturas para normalização
+    lucros = []
+    for _, cultura in culturas.iterrows():
+        lucro = calcular_lucro_por_hectare(cultura)
+        lucros.append(lucro)
+    
+    lucro_min = min(lucros)
+    lucro_max = max(lucros)
+    
+    # Avalia cada cultura para este talhão
+    for _, cultura in culturas.iterrows():
+        # Busca regras da cultura
+        regra = regras[regras['cultura'] == cultura['nome']]
+        
+        if regra.empty:
+            continue
+        
+        regra = regra.iloc[0]
+        
+        # Calcula lucro normalizado
+        lucro = calcular_lucro_por_hectare(cultura)
+        lucro_normalizado = normalizar_lucro(lucro, lucro_min, lucro_max)
+        
+        # Avalia cultura
+        avaliacao = avaliar_cultura_para_talhao(talhao, cultura, regra, lucro_normalizado)
+        avaliacoes.append(avaliacao)
+    
+    # Ordena por nota (decrescente)
+    ranking = sorted(avaliacoes, key=lambda x: x['nota'], reverse=True)
+    
+    # Melhor cultura
+    melhor = ranking[0] if ranking else None
+    
+    # Gera justificativa
+    justificativa = gerar_justificativa(talhao, melhor)
+    
+    return {
+        'ranking': ranking,
+        'melhor_cultura': melhor,
+        'justificativa': justificativa
+    }
+
+
+def gerar_justificativa(talhao, avaliacao):
+    """Gera texto explicando por que a cultura foi recomendada"""
+    if not avaliacao:
+        return "Nenhuma cultura compatível encontrada."
+    
+    cultura = avaliacao['cultura']
+    pontos_fortes = []
+    pontos_fracos = []
+    
+    # Analisa compatibilidades
+    if avaliacao['compatibilidade_solo'] == 25:
+        pontos_fortes.append(f"solo {talhao['solo']}")
+    elif avaliacao['compatibilidade_solo'] == 0:
+        pontos_fracos.append(f"solo {talhao['solo']} não é ideal")
+    
+    if avaliacao['compatibilidade_clima'] == 25:
+        pontos_fortes.append(f"clima {talhao['clima']}")
+    elif avaliacao['compatibilidade_clima'] == 0:
+        pontos_fracos.append(f"clima {talhao['clima']} não é ideal")
+    
+    if avaliacao['compatibilidade_relevo'] == 15:
+        pontos_fortes.append(f"relevo {talhao['relevo']}")
+    elif avaliacao['compatibilidade_relevo'] == 0:
+        pontos_fracos.append(f"relevo {talhao['relevo']} não é ideal")
+    
+    if avaliacao['compatibilidade_agua'] == 15:
+        pontos_fortes.append(f"disponibilidade {talhao['agua']} de água")
+    elif avaliacao['compatibilidade_agua'] < 15:
+        if avaliacao['compatibilidade_agua'] == 0:
+            pontos_fracos.append("disponibilidade de água insuficiente")
+        else:
+            pontos_fracos.append("disponibilidade de água abaixo do ideal")
+    
+    # Monta justificativa
+    texto = f"A cultura {cultura} foi recomendada porque "
+    
+    if pontos_fortes:
+        texto += f"apresenta alta compatibilidade com {', '.join(pontos_fortes)}"
+    
+    if pontos_fracos:
+        if pontos_fortes:
+            texto += f", apesar de {', '.join(pontos_fracos)}"
+        else:
+            texto += f"é a melhor opção disponível, embora {', '.join(pontos_fracos)}"
+    
+    # Adiciona informação sobre lucro e risco
+    texto += f". Oferece lucro estimado de R$ {avaliacao['lucro_total']:,.2f} "
+    texto += f"com risco de {avaliacao['risco']}% e ciclo de {avaliacao['tempo']} dias."
+    
+    return texto
+
+
+def analisar_todos_talhoes(talhoes, culturas, regras):
+    """Analisa todos os talhões e retorna recomendações completas"""
+    analises = []
+    
+    for _, talhao in talhoes.iterrows():
+        analise = analisar_talhao(talhao, culturas, regras)
+        analise['talhao'] = talhao
+        analises.append(analise)
+    
+    return analises

package/backend-template/data/culturas.csv

@@ -0,0 +1,11 @@
+nome,custo,preco,produtividade,tempo
+soja,1500,3000,3.2,120
+milho,1200,2500,4.5,100
+feijao,1000,2200,2.8,90
+trigo,1300,2400,3.5,110
+algodao,1800,3500,2.5,140
+cafe,2200,4500,2.0,180
+cana,1400,2800,5.5,150
+sorgo,900,1800,3.8,85
+mandioca,800,1600,4.2,240
+arroz,1100,2300,3.6,130

package/backend-template/data/regras_culturas.csv

@@ -0,0 +1,11 @@
+cultura,solos_ideais,climas_ideais,relevo_ideal,agua_necessaria,risco_base
+soja,argiloso;misto,quente;ameno,plano;leve,media,30
+milho,argiloso;misto;arenoso,quente;ameno,plano;leve,alta,35
+feijao,misto;arenoso,ameno;quente,plano,media,25
+trigo,argiloso;misto,frio;ameno,plano;leve,media,40
+algodao,argiloso;arenoso,quente,plano;leve,alta,45
+cafe,argiloso;siltoso,ameno;quente,leve;moderado,alta,50
+cana,argiloso;misto,quente,plano,alta,38
+sorgo,arenoso;siltoso,quente;ameno,plano;leve,baixa,20
+mandioca,arenoso;misto,quente;ameno,plano;leve,baixa,18
+arroz,argiloso;siltoso,ameno;frio,plano,alta,42

package/backend-template/data/talhoes.csv

@@ -0,0 +1,11 @@
+id,area,solo,clima,relevo,agua
+1,10,argiloso,quente,plano,media
+2,15,arenoso,quente,leve,baixa
+3,8,misto,ameno,plano,alta
+4,12,siltoso,ameno,leve,media
+5,18,argiloso,frio,plano,alta
+6,9,arenoso,quente,moderado,baixa
+7,14,misto,ameno,plano,media
+8,11,argiloso,quente,leve,alta
+9,7,siltoso,frio,moderado,media
+10,13,misto,ameno,ingreme,baixa