fertpy 0.2.1__py3-none-any.whl

fertpy/__init__.py

@@ -0,0 +1,15 @@
+from .nutrientes import (
+    Fosforo,
+    Nitrogenio,
+    Potassio,
+)
+
+from .correcao_solo import Calagem
+
+
+__all__ = [
+    "Fosforo",
+    "Nitrogenio",
+    "Potassio",
+    "Calagem",
+]

fertpy/cli/parametros_cli.py

@@ -0,0 +1,33 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from fertpy.utils.parametros import extrair_parametros
+
+
+def imprimir_parametros(estrutura: dict[str, dict[str, list[str]]]) -> None:
+    linhas = []
+
+    for boletim, culturas in estrutura.items():
+        linhas.append(f"\nboletim: {boletim}")
+
+        for cultura, nutrientes in culturas.items():
+            linhas.append(f"  Cultura: {cultura}")
+        
+            for nutriente in nutrientes:
+                linhas.append(f"    - {nutriente}")
+
+    return "\n".join(linhas)
+
+def imprimir_parametros_cli():
+    dados = extrair_parametros()
+    print(imprimir_parametros(dados))

fertpy/core/domain/classe.py

@@ -0,0 +1,21 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Classe:
+    nome: str
+    tipo: str = "faixa" 
+    descricao: str | None = None

fertpy/core/domain/criterio.py

@@ -0,0 +1,47 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from dataclasses import dataclass
+from typing import Any
+
+from fertpy.core.domain.intervalo import Intervalo
+from fertpy.core.domain.classe import Classe
+
+
+@dataclass(frozen=True)
+class Criterio:
+
+    condicoes: dict[str, Intervalo | str]
+    classe: Classe | None
+    recomendacao: Any
+
+    observacoes: str | None = None
+
+    def __post_init__(self):
+
+        if not isinstance(self.condicoes, dict):
+            raise TypeError("Condições deve ser um dict")
+
+        if not self.condicoes:
+            raise ValueError("Criterio precisa de pelo menos uma condição")
+
+        for nome, condicao in self.condicoes.items():
+
+            if not isinstance(nome, str) or not nome.strip():
+                raise TypeError("Nome de condição inválido")
+
+            if not isinstance(condicao, (Intervalo, str)):
+                raise TypeError(f"Condição inválida para {nome}")
+
+        if self.classe is not None and not isinstance(self.classe, Classe):
+            raise TypeError("Classe deve ser Classe ou None")

fertpy/core/domain/exceptions.py

@@ -0,0 +1,25 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+class ParametroInvalidoError(ValueError):
+    
+    def __init__(self, parametro: str, valor: str, validos: list[str]):
+        mensagem = (
+            f"{parametro} inválido: '{valor}', "
+            f"Valores válidos: {', '.join(validos)}"
+        )
+        super().__init__(mensagem)
+        self.parametro = parametro
+        self.valor = valor
+        self.validos = validos
+        

fertpy/core/domain/intervalo.py

@@ -0,0 +1,41 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Intervalo:
+    minimo: float | None
+    maximo: float | None
+    inclui_min: bool = True
+    inclui_max: bool = False
+
+    def __post_init__(self):
+        if self.minimo is not None and self.maximo is not None:
+            if self.minimo > self.maximo:
+                raise ValueError("Minimo não pode ser maior que o maximo")
+        
+    def contem(self, valor:float) -> bool:
+        if self.minimo is not None:
+            if self.inclui_min and valor < self.minimo:
+                return False
+            if not self.inclui_min and valor <= self.minimo:    
+                return False
+        
+        if self.maximo is not None:
+            if self.inclui_max and valor > self.maximo:
+                return False
+            if not self.inclui_max and valor >= self.maximo:
+                return False
+        
+        return True

fertpy/core/domain/modelo_agronomico.py

@@ -0,0 +1,112 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from dataclasses import dataclass
+from collections import defaultdict
+
+from fertpy.core.domain.criterio import Criterio
+from fertpy.core.domain.exceptions import ParametroInvalidoError
+
+
+@dataclass(frozen=True)
+class ModeloAgronomico:
+    nutriente: str
+    unidade_saida: str
+
+    criterios: list[Criterio]
+
+    nutriente_recomendado: str | None = None
+    unidade_entrada: str | None = None
+    metodo_analitico: str | None = None
+    fonte_referencia: dict | None = None
+
+    def __post_init__(self):
+
+        if not self.nutriente:
+            raise ValueError("O modelo não possui nutriente declarado")
+        
+        if not self.unidade_saida:
+            raise ValueError("O modelo não possui unidade de saida declarado") 
+
+        if not self.criterios:
+            raise ValueError("Modelo precisa de critérios")
+
+        for c in self.criterios:
+            if not isinstance(c, Criterio):
+                raise TypeError("Todos os critérios devem ser instâncias de criterio")
+
+    @property
+    def variaveis_esperadas(self) -> set[str]:
+        variaveis = set()
+
+        for criterio in self.criterios:
+            variaveis.update(criterio.condicoes.keys())
+
+        return variaveis
+    
+    def valores_discretos_por_variavel(self) -> dict[str, set]:
+
+        valores = defaultdict(set)
+
+        for criterio in self.criterios:
+            for var, cond in criterio.condicoes.items():
+                if isinstance(cond, str):
+                    valores[var].add(cond)
+        
+        return valores
+    
+    def validar_contexto(self, contexto: dict):
+        faltando = self.variaveis_esperadas - contexto.keys()
+        if faltando:
+            raise ValueError(
+                f"Variáveis obrigatórias ausentes: {sorted(faltando)}"
+            )
+        
+        extras = contexto.keys() - self.variaveis_esperadas
+        if extras:
+            raise ValueError(
+                f"Variáveis inesperadas: {sorted(extras)}"
+            )
+        
+        for var, valor in contexto.items():
+
+            exemplos = [
+                criterio.condicoes[var]
+                for criterio in self.criterios
+                if var in criterio.condicoes
+            ]
+
+            if not exemplos:
+                continue
+
+            exemplo = exemplos[0]
+
+            if isinstance(exemplo, str):
+                valores_validos = {
+                    c.condicoes[var]
+                    for c in self.criterios
+                    if isinstance(c.condicoes[var], str)
+                }
+
+                if valor not in valores_validos:
+                    raise ParametroInvalidoError(
+                        var,
+                        valor,
+                        sorted(valores_validos)
+                    )
+            
+            else:
+                if not isinstance(valor, (int, float)):
+                    raise TypeError(
+                        f"Variável '{var}' deve ser numérica"
+                    )

fertpy/core/domain/recomendacao.py

@@ -0,0 +1,38 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from dataclasses import dataclass
+
+from fertpy.core.domain.intervalo import Intervalo
+from fertpy.core.domain.classe import Classe
+
+
+@dataclass(frozen=True)
+class Recomendacao:
+    nutriente: str
+    
+    dose: float | Intervalo | str
+    unidade: str
+
+    classe: Classe
+
+    observacoes: list[str] | None = None
+    fonte: dict | None = None
+
+    def __post_init__(self):
+
+        if not self.nutriente:
+            raise ValueError("Recomendação precisa do parâmetro nutriente")
+        
+        if not self.unidade:
+            raise ValueError("Recomendação precisa do parâmetro unidade")

fertpy/core/engine/avaliador.py

@@ -0,0 +1,73 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from fertpy.core.domain.classe import Classe
+from fertpy.core.domain.criterio import Criterio
+from fertpy.core.domain.intervalo import Intervalo
+from fertpy.core.domain.recomendacao import Recomendacao
+
+
+class Avaliador:
+
+    @staticmethod
+    def avaliar(
+        criterios: list[Criterio],
+        contexto: dict[str, float],
+        nutriente: str,
+        unidade: str,
+        observacoes: list[str] | None = None,
+        fonte: dict | None = None
+    ) -> Recomendacao:
+
+        for criterio in criterios:
+            for variavel, intervalo in criterio.condicoes.items():
+                
+                if variavel not in contexto:
+                    break
+
+                valor = contexto[variavel]
+
+                if isinstance(intervalo, Intervalo):
+                    
+                    if not isinstance(valor, (int, float)):
+                        break
+
+                    if not intervalo.contem(valor):
+                        break
+                else:
+                    if valor != intervalo:
+                        break
+
+            else:
+                classe_final = criterio.classe or Classe(nome="dose")
+
+                obs_final = []
+
+                if observacoes:
+                    obs_final.extend(observacoes)
+                
+                if criterio.observacoes:
+                    obs_final.append(criterio.observacoes)
+                
+                obs_final = obs_final or None
+
+                return Recomendacao(
+                    nutriente=nutriente,
+                    dose=criterio.recomendacao,
+                    unidade=unidade,
+                    classe=classe_final,
+                    observacoes=obs_final,
+                    fonte=fonte
+                ) 
+            
+        raise ValueError("Nenhum critério compatível encontrado.")

fertpy/core/engine/calculo_calagem.py

@@ -0,0 +1,37 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+class CalagemEngine:
+
+    @staticmethod
+    def calcular(
+        v1: float,
+        ctc: float,
+        v2: float,
+        prnt: float,
+        dose_maxima: float | None = None,
+        dose_minima: float | None = None
+    ) -> float:
+
+        nc = (ctc * (v2 - v1)) / (10 * prnt)
+
+        if nc <= 0:
+            return 0.0
+
+        if dose_maxima is not None and nc > dose_maxima:
+            nc = dose_maxima
+
+        if dose_minima is not None and nc < dose_minima:
+            nc = dose_minima
+
+        return round(nc, 2)

fertpy/correcao_solo/__init__.py

@@ -0,0 +1,3 @@
+from .calagem import Calagem
+
+__all__ = ["Calagem"]

fertpy/correcao_solo/calagem.py

@@ -0,0 +1,46 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from fertpy.infra.loaders.correcao_loader import carregar_modelo_correcao
+from fertpy.core.engine.calculo_calagem import CalagemEngine
+
+
+class Calagem:
+
+    def __init__(self, cultura: str):
+
+        yaml = carregar_modelo_correcao(
+            "boletim_100",
+            cultura
+        )["calagem"]
+
+        self.modelo = yaml
+
+    def calcular(
+        self,
+        v_atual: float,
+        ctc: float,
+        prnt: float | None = None
+    ) -> float:
+
+        parametros = self.modelo["parametros"]
+        limites = self.modelo.get("limites", {})
+
+        return CalagemEngine.calcular(
+            v1=v_atual,
+            ctc=ctc,
+            v2=parametros["v2_desejado"],
+            prnt=prnt or parametros["prnt_padrao"],
+            dose_maxima=limites.get("dose_maxima"),
+            dose_minima=limites.get("dose_minima")
+        )

fertpy/infra/loaders/adubacao_loader.py

@@ -0,0 +1,36 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from importlib import resources
+import yaml
+
+
+def carregar_modelo_adubacao(
+        boletim: str,
+        cultura: str,
+        finalidade: str,
+        nutriente: str
+):
+
+    pacote_base = (
+        f"fertpy.knowledge."
+        f"{boletim}.adubacao."
+        f"{cultura}.{finalidade}"
+    )
+
+    nome_arquivo = f"{nutriente}.yaml"
+
+    with resources.files(pacote_base).joinpath(nome_arquivo).open(
+        "r", encoding="utf-8"
+    ) as f:
+        return yaml.safe_load(f)

fertpy/infra/loaders/correcao_loader.py

@@ -0,0 +1,29 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from importlib import resources
+import yaml
+
+
+def carregar_modelo_correcao(
+        boletim: str,
+        cultura: str
+):
+    
+    pacote_base = f"fertpy.knowledge.{boletim}.calagem"
+    nome_arquivo = f"{cultura}.yaml"
+
+    with resources.files(pacote_base).joinpath(nome_arquivo).open(
+        "r", encoding="utf-8"
+    ) as f:
+        return yaml.safe_load(f)

fertpy/infra/parsing/condicao.py

@@ -0,0 +1,27 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+from fertpy.infra.parsing.intervalo import parse_intervalo
+
+
+def parse_condicao(valor):
+    if isinstance(valor, (int, float)):
+        return parse_intervalo(str(valor))
+    
+    if isinstance(valor, str):
+        try:
+            return parse_intervalo(valor)
+        except ValueError:
+            return valor.strip()
+    
+    return valor

fertpy/infra/parsing/intervalo.py

@@ -0,0 +1,72 @@
+# Copyright 2026 Luiz Henrique de Lima Peguin
+# and Pedro Henrique Escaranaro Brasil
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
+import re
+
+from fertpy.core.domain.intervalo import Intervalo
+
+
+def parse_intervalo(texto: str) -> Intervalo:
+    texto = texto.strip()
+
+    #===============================================
+    # Forma matematica: x <= a <= y, x < a < y, etc
+    #===============================================
+
+    padrao_duplo = re.compile(
+        r"^\s*(-?\d+\.?\d*)\s*(<=|<)\s*[a-zA-Z_]+\s*(<=|<)\s*(-?\d+\.?\d*)\s*$"
+    )
+
+    m = padrao_duplo.match(texto)
+
+    if m:
+        a = float(m.group(1))
+        limite_inferior = m.group(2)
+        limite_superior = m.group(3)
+        b = float(m.group(4))
+
+        if a >= b:
+            raise ValueError(f"intervalo inválido (a >= b): {texto}")
+
+        inc_min = limite_inferior == "<="
+        inc_max = limite_superior == "<="
+
+        return Intervalo(a, b, inc_min, inc_max)
+    
+    #============================
+    # Intervalos abertos simples
+    #============================
+
+    if texto.startswith(">="):
+        return Intervalo(float(texto[2:].strip()), None, True, False)
+    
+    if texto.startswith("<="):
+        return Intervalo(None, float(texto[2:].strip()), False, True)
+    
+    if texto.startswith(">"):
+        return Intervalo(float(texto[1:].strip()), None, False, False)
+    
+    if texto.startswith("<"):
+        return Intervalo(None, float(texto[1:].strip()), False, False)
+    
+    #=============
+    # Valor exato
+    #=============
+
+    try:
+        v = float(texto)
+        return Intervalo(v, v, True, True)
+    except ValueError:
+        pass
+
+    raise ValueError(f"Intervalo inválido: {texto}")