coremlflow 0.0.2__tar.gz

coremlflow-0.0.2/LICENCE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Willian Marchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

coremlflow-0.0.2/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: coremlflow
+Version: 0.0.2
+Summary: Coreflow - Abstração de Funções para MLFlow não oficial.
+Author: Willian Marchi
+Author-email: willian.m.marchi@gmail.com
+License: MIT License
+Keywords: coremlflow mlflow core
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: mlflow
+Provides-Extra: sklearn
+Requires-Dist: scikit-learn; extra == "sklearn"
+Provides-Extra: prophet
+Requires-Dist: prophet; extra == "prophet"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# Guia de Desenvolvimento: Modelos e Inferência no coremlflow
+
+Este guia explica como criar scripts de **Treinamento (`train.py`)** e **Predição/Inferência (`predict.py`)** utilizando o framework base da biblioteca `coremlflow`.
+
+A arquitetura orientada a objetos obriga a implementação de métodos específicos para padronizar o ciclo de vida do modelo e a integração automática com o MLflow.
+
+---
+
+## 🚀 1. Criando um Modelo de Treinamento (`train.py`)
+
+Com o `coremlflow`, você tem a opção de herdar da classe base genérica ou utilizar as **abstrações específicas** construídas para os principais frameworks de Data Science.
+
+### A. Utilizando as Classes Especializadas (Recomendado)
+
+O pacote `coremlflow.models` provê classes preparadas que já implementam automaticamente a melhor forma de salvar o seu modelo (ex: usando `mlflow.sklearn` ou `mlflow.prophet`).
+
+#### Exemplo: Random Forest
+Para Random Forest ou Isolation Forest, herde das classes em `coremlflow.models.sklearn`:
+
+```python
+import pandas as pd
+from typing import Dict, Any
+from sklearn.ensemble import RandomForestClassifier
+from coremlflow.models.sklearn import RandomForestMLFlowModel
+
+class MeuModeloRF(RandomForestMLFlowModel):
+    def __init__(self, experiment_name: str, data_path: str, tracking_uri: str = None):
+        super().__init__(experiment_name, tracking_uri)
+        self.data_path = data_path 
+    
+    def load_data(self) -> Dict[str, Any]:
+        # Exemplo carregando dados de Treino/Teste
+        return {"X_train": [...], "y_train": [...], "X_test": [...], "y_test": [...]}
+
+    def train(self, data: Dict[str, Any], params: Dict[str, Any]) -> Any:
+        model = RandomForestClassifier(**params)
+        model.fit(data["X_train"], data["y_train"])
+        return model
+
+    def evaluate(self, model: Any, data: Dict[str, Any]) -> Dict[str, float]:
+        # Calcule e retorne suas métricas
+        score = model.score(data["X_test"], data["y_test"])
+        return {"accuracy": score}
+
+    def get_signature_data(self, model: Any, data: Dict[str, Any]) -> tuple:
+        return (data["X_train"], data["y_train"])
+```
+*Note que não foi necessário implementar o método `save_model()`, pois ele já foi abstraído pela classe mãe `RandomForestMLFlowModel`.*
+
+#### Outros modelos suportados nativamente:
+- `IsolationForestMLFlowModel` (em `coremlflow.models.sklearn`)
+- `ProphetMLFlowModel` (em `coremlflow.models.prophet`)
+
+### B. Utilizando a Classe Base Genérica
+
+Se você estiver treinando um modelo Keras, PyTorch, ou outro ainda não mapeado nas classes filhas nativas, basta herdar nativamente da `MLFlowModelBase` e definir seu `.save_model()`.
+
+```python
+from coremlflow.base import MLFlowModelBase
+import mlflow.keras
+
+class MeuModeloGenerico(MLFlowModelBase):
+    # ... defina load(), train(), evaluate(), get_signature_data() ...
+    
+    def save_model(self, model, signature) -> None:
+        # [Obrigatório na Base]
+        mlflow.keras.log_model(model, artifact_path="model", signature=signature)
+```
+
+### Executando o Treinamento
+
+Para rodar, instancie a sua classe e chame o método genérico `run(params)`. Ele vai orquestrar todas as chamadas garantindo o log correto no MLflow.
+
+```python
+if __name__ == "__main__":
+    predictor = MeuModeloRF(experiment_name="Projeto_Churn", data_path="dados.csv")
+    params = {"n_estimators": 100, "max_depth": 5}
+    
+    modelo = predictor.run(params=params)
+```
+
+---
+
+## 🔮 2. Consumindo um Modelo em Produção (`predict.py`)
+
+Ao fazer a inferência, importe o `MLFlowPredictorBase`.
+
+Essa classe cuida internamente do carregamento do modelo a partir do Registry do MLflow. Se o Tracking Server do MLflow estiver fora do ar, você ainda pode fornecer um `local_model_path` como *fallback*.
+
+### Estrutura da Classe de Predição
+
+Opcionalmente, você pode sobrescrever o método `predict`, mas por base, a classe já traz o comportamento chamando recursivamente o modelo baixado no formato `pyfunc`.
+
+```python
+from coremlflow.predictor import MLFlowPredictorBase
+
+# Você pode usar a classe base diretamente:
+servico_ia = MLFlowPredictorBase(
+    internal_alias="CHURN_PROD",
+    internal_alias_map_path="./mlflow_aliases.json",
+    local_model_path="./modelos_backup/rf_model_v1" # Fallback opcional offline
+)
+
+# Os resultados dependerão da natureza do modelo treinado.
+resultados = servico_ia.predict(dados_de_entrada)
+```
+
+Ou, caso você precise criar um fluxo complexo de tratamento de dados de entrada antes / depois de passar pelo `.predict()`:
+
+```python
+class SeuPredictorService(MLFlowPredictorBase):
+    def predict(self, input_data):
+        # 1. Trata input_data (ex: limpeza, feature engineering)
+        dados_tratados = limpar(input_data)
+        
+        # 2. Chama a predição da classe base
+        resultado = super().predict(dados_tratados)
+        
+        # 3. Pós Processa
+        return formatar(resultado)
+```
+
+Exemplo de arquivo `./mlflow_aliases.json` (apelido interno -> run_id):
+
+```json
+{
+  "CHURN_PROD": "a1b2c3d4e5f6g7h8i9j0",
+  "FORECAST_PROD": { "run_id": "ffffeeee111122223333444455556666", "artifact_path": "model" }
+}
+```

coremlflow-0.0.2/README.md

@@ -0,0 +1,130 @@
+# Guia de Desenvolvimento: Modelos e Inferência no coremlflow
+
+Este guia explica como criar scripts de **Treinamento (`train.py`)** e **Predição/Inferência (`predict.py`)** utilizando o framework base da biblioteca `coremlflow`.
+
+A arquitetura orientada a objetos obriga a implementação de métodos específicos para padronizar o ciclo de vida do modelo e a integração automática com o MLflow.
+
+---
+
+## 🚀 1. Criando um Modelo de Treinamento (`train.py`)
+
+Com o `coremlflow`, você tem a opção de herdar da classe base genérica ou utilizar as **abstrações específicas** construídas para os principais frameworks de Data Science.
+
+### A. Utilizando as Classes Especializadas (Recomendado)
+
+O pacote `coremlflow.models` provê classes preparadas que já implementam automaticamente a melhor forma de salvar o seu modelo (ex: usando `mlflow.sklearn` ou `mlflow.prophet`).
+
+#### Exemplo: Random Forest
+Para Random Forest ou Isolation Forest, herde das classes em `coremlflow.models.sklearn`:
+
+```python
+import pandas as pd
+from typing import Dict, Any
+from sklearn.ensemble import RandomForestClassifier
+from coremlflow.models.sklearn import RandomForestMLFlowModel
+
+class MeuModeloRF(RandomForestMLFlowModel):
+    def __init__(self, experiment_name: str, data_path: str, tracking_uri: str = None):
+        super().__init__(experiment_name, tracking_uri)
+        self.data_path = data_path 
+    
+    def load_data(self) -> Dict[str, Any]:
+        # Exemplo carregando dados de Treino/Teste
+        return {"X_train": [...], "y_train": [...], "X_test": [...], "y_test": [...]}
+
+    def train(self, data: Dict[str, Any], params: Dict[str, Any]) -> Any:
+        model = RandomForestClassifier(**params)
+        model.fit(data["X_train"], data["y_train"])
+        return model
+
+    def evaluate(self, model: Any, data: Dict[str, Any]) -> Dict[str, float]:
+        # Calcule e retorne suas métricas
+        score = model.score(data["X_test"], data["y_test"])
+        return {"accuracy": score}
+
+    def get_signature_data(self, model: Any, data: Dict[str, Any]) -> tuple:
+        return (data["X_train"], data["y_train"])
+```
+*Note que não foi necessário implementar o método `save_model()`, pois ele já foi abstraído pela classe mãe `RandomForestMLFlowModel`.*
+
+#### Outros modelos suportados nativamente:
+- `IsolationForestMLFlowModel` (em `coremlflow.models.sklearn`)
+- `ProphetMLFlowModel` (em `coremlflow.models.prophet`)
+
+### B. Utilizando a Classe Base Genérica
+
+Se você estiver treinando um modelo Keras, PyTorch, ou outro ainda não mapeado nas classes filhas nativas, basta herdar nativamente da `MLFlowModelBase` e definir seu `.save_model()`.
+
+```python
+from coremlflow.base import MLFlowModelBase
+import mlflow.keras
+
+class MeuModeloGenerico(MLFlowModelBase):
+    # ... defina load(), train(), evaluate(), get_signature_data() ...
+    
+    def save_model(self, model, signature) -> None:
+        # [Obrigatório na Base]
+        mlflow.keras.log_model(model, artifact_path="model", signature=signature)
+```
+
+### Executando o Treinamento
+
+Para rodar, instancie a sua classe e chame o método genérico `run(params)`. Ele vai orquestrar todas as chamadas garantindo o log correto no MLflow.
+
+```python
+if __name__ == "__main__":
+    predictor = MeuModeloRF(experiment_name="Projeto_Churn", data_path="dados.csv")
+    params = {"n_estimators": 100, "max_depth": 5}
+    
+    modelo = predictor.run(params=params)
+```
+
+---
+
+## 🔮 2. Consumindo um Modelo em Produção (`predict.py`)
+
+Ao fazer a inferência, importe o `MLFlowPredictorBase`.
+
+Essa classe cuida internamente do carregamento do modelo a partir do Registry do MLflow. Se o Tracking Server do MLflow estiver fora do ar, você ainda pode fornecer um `local_model_path` como *fallback*.
+
+### Estrutura da Classe de Predição
+
+Opcionalmente, você pode sobrescrever o método `predict`, mas por base, a classe já traz o comportamento chamando recursivamente o modelo baixado no formato `pyfunc`.
+
+```python
+from coremlflow.predictor import MLFlowPredictorBase
+
+# Você pode usar a classe base diretamente:
+servico_ia = MLFlowPredictorBase(
+    internal_alias="CHURN_PROD",
+    internal_alias_map_path="./mlflow_aliases.json",
+    local_model_path="./modelos_backup/rf_model_v1" # Fallback opcional offline
+)
+
+# Os resultados dependerão da natureza do modelo treinado.
+resultados = servico_ia.predict(dados_de_entrada)
+```
+
+Ou, caso você precise criar um fluxo complexo de tratamento de dados de entrada antes / depois de passar pelo `.predict()`:
+
+```python
+class SeuPredictorService(MLFlowPredictorBase):
+    def predict(self, input_data):
+        # 1. Trata input_data (ex: limpeza, feature engineering)
+        dados_tratados = limpar(input_data)
+        
+        # 2. Chama a predição da classe base
+        resultado = super().predict(dados_tratados)
+        
+        # 3. Pós Processa
+        return formatar(resultado)
+```
+
+Exemplo de arquivo `./mlflow_aliases.json` (apelido interno -> run_id):
+
+```json
+{
+  "CHURN_PROD": "a1b2c3d4e5f6g7h8i9j0",
+  "FORECAST_PROD": { "run_id": "ffffeeee111122223333444455556666", "artifact_path": "model" }
+}
+```

coremlflow-0.0.2/coremlflow/__init__.py

@@ -0,0 +1,9 @@
+from .base import MLFlowModelBase
+from .predictor import MLFlowPredictorBase
+from .decorators import mlflow_standard_run
+
+__all__ = [
+    "MLFlowModelBase",
+    "MLFlowPredictorBase",
+    "mlflow_standard_run",
+]

coremlflow-0.0.2/coremlflow/base.py

@@ -0,0 +1,75 @@
+from abc import ABC, abstractmethod
+import mlflow
+import os
+import logging
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+class MLFlowModelBase(ABC):
+    def __init__(self, experiment_name: str, tracking_uri: Optional[str] = None):
+        self.experiment_name = experiment_name
+        
+        # Usa env var se não for passado via parâmetro
+        uri = tracking_uri or os.getenv("MLFLOW_TRACKING_URI", "http://localhost:5000")
+        mlflow.set_tracking_uri(uri)
+        mlflow.set_experiment(experiment_name)
+        
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(self.__class__.__name__)
+
+    @abstractmethod
+    def load_data(self) -> Any:
+        """Obrigatório: Lógica para carregar os dados."""
+        pass
+
+    @abstractmethod
+    def train(self, data: Any, params: Dict[str, Any]) -> Any:
+        """Obrigatório: Lógica de treinamento do modelo."""
+        pass
+
+    @abstractmethod
+    def evaluate(self, model: Any, data: Any) -> Dict[str, float]:
+        """Obrigatório: Retornar dicionário de métricas (ex: {'acc': 0.9})."""
+        pass
+
+    @abstractmethod
+    def get_signature_data(self, model: Any, data: Any) -> tuple[Any, Any]:
+        """Obrigatório: Retornar (sample_input, sample_output) para infer_signature.
+        Caso não queira gerar signature, retorne (None, None).
+        """
+        pass
+
+    @abstractmethod
+    def save_model(self, model: Any, signature: Any) -> None:
+        """Obrigatório: Salvar o modelo no MLflow.
+        Use mlflow.sklearn.log_model, mlflow.pytorch.log_model, etc.
+        """
+        pass
+
+    def run(self, params: dict):
+        with mlflow.start_run(run_name=f"Run_{self.__class__.__name__}_{datetime.now().strftime('%H%M%S')}") as run:
+            # 1. Ciclo de vida padrão
+            data = self.load_data()
+            model = self.train(data, params)
+            metrics = self.evaluate(model, data)
+
+            # 2. Log Automático de Parâmetros e Métricas
+            mlflow.log_params(params)
+            mlflow.log_metrics(metrics)
+
+            # 3. Inteligência de Registro
+            sample_input, sample_output = self.get_signature_data(model, data)
+            signature = None
+            if sample_input is not None and sample_output is not None:
+                from mlflow.models import infer_signature
+                try:
+                    signature = infer_signature(sample_input, sample_output)
+                    self.logger.info("Signature inferred successfully.")
+                except Exception as e:
+                    self.logger.warning(f"Failed to infer signature: {e}")
+
+            # 4. Salvar o modelo confiando na implementação da classe filha
+            self.save_model(model, signature)
+
+            self.logger.info(f"Modelo registrado com sucesso no Run ID: {run.info.run_id}")
+            return model

coremlflow-0.0.2/coremlflow/decorators.py

@@ -0,0 +1,35 @@
+import functools
+import time
+import mlflow
+import logging
+
+logger = logging.getLogger(__name__)
+
+def mlflow_standard_run(func):
+    """
+    Decorator para registrar a duração de execução e status em uma Active Run do MLflow.
+    Presume-se que seja executado dentro de um context manager ou que tenha uma run ativa.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        logger.info(f"--- Iniciando execução de ML: {func.__name__} ---")
+        
+        try:
+            result = func(*args, **kwargs)
+            
+            duration = time.time() - start_time
+            # Só loga métricas se houver uma run ativa para não criar runs soltas indesejadas
+            if mlflow.active_run():
+                mlflow.log_metric(f"{func.__name__}_duration_seconds", duration)
+                mlflow.set_tag(f"{func.__name__}_status", "success")
+            
+            return result
+        except Exception as e:
+            if mlflow.active_run():
+                mlflow.set_tag(f"{func.__name__}_status", "failed")
+                mlflow.log_param(f"{func.__name__}_error_message", str(e))
+            logger.error(f"Erro na execução de {func.__name__}: {e}")
+            raise e
+            
+    return wrapper

coremlflow-0.0.2/coremlflow/models/prophet.py

@@ -0,0 +1,33 @@
+from typing import Any, Dict
+from abc import abstractmethod
+import mlflow
+import mlflow.prophet
+from coremlflow.base import MLFlowModelBase
+
+class ProphetMLFlowModel(MLFlowModelBase):
+    """
+    Classe base para modelos da biblioteca Prophet.
+    O Prophet tem um modo de treino e de salvar modelo específico.
+    """
+    def save_model(self, model: Any, signature: Any) -> None:
+        """Salva o modelo usando mlflow.prophet.log_model."""
+        self.logger.info("Salvando modelo Prophet...")
+        mlflow.prophet.log_model(
+            pr_model=model,
+            artifact_path="model",
+            signature=signature
+        )
+
+    @abstractmethod
+    def train(self, data: Any, params: Dict[str, Any]) -> Any:
+        # Exemplo:
+        # from prophet import Prophet
+        # model = Prophet(**params)
+        # dataframe precisa ter 'ds' (data) e 'y' (valor)
+        # return model.fit(data)
+        pass
+
+    @abstractmethod
+    def evaluate(self, model: Any, data: Any) -> Dict[str, float]:
+        # Avaliação de séries temporais: MAPE, MAE, RMSE...
+        pass

coremlflow-0.0.2/coremlflow/models/sklearn.py

@@ -0,0 +1,64 @@
+from typing import Any, Dict
+from abc import abstractmethod
+import mlflow
+import mlflow.sklearn
+from coremlflow.base import MLFlowModelBase
+
+class MLFlowSklearnModel(MLFlowModelBase):
+    """
+    Classe base intermediária para qualquer modelo que use o flavor do scikit-learn.
+    Ela auto-implementa a forma correta de salvar o modelo.
+    """
+    def save_model(self, model: Any, signature: Any) -> None:
+        """Salva o modelo usando mlflow.sklearn.log_model."""
+        self.logger.info("Salvando modelo Scikit-Learn...")
+        # Usa infer_signature se a signature for passada, senão salva sem
+        mlflow.sklearn.log_model(
+            sk_model=model,
+            artifact_path="model",
+            signature=signature
+        )
+
+class RandomForestMLFlowModel(MLFlowSklearnModel):
+    """
+    Abstração específica para Random Forest.
+    Sugerimos implementar o train() com RandomForestClassifier ou RandomForestRegressor.
+    """
+    
+    @abstractmethod
+    def train(self, data: Any, params: Dict[str, Any]) -> Any:
+        # Exemplo: 
+        # from sklearn.ensemble import RandomForestClassifier
+        # model = RandomForestClassifier(**params)
+        # return model.fit(data['X'], data['y'])
+        pass
+
+    @abstractmethod
+    def evaluate(self, model: Any, data: Any) -> Dict[str, float]:
+        # Exemplo:
+        # from sklearn.metrics import accuracy_score
+        # preds = model.predict(data['X_test'])
+        # return {"accuracy": accuracy_score(data['y_test'], preds)}
+        pass
+
+
+class IsolationForestMLFlowModel(MLFlowSklearnModel):
+    """
+    Abstração específica para Isolation Forest (Detecção de Anomalias).
+    Sugerimos implementar o train() abstraindo o uso não-supervisionado do Isolation Forest.
+    """
+    
+    @abstractmethod
+    def train(self, data: Any, params: Dict[str, Any]) -> Any:
+        # Exemplo:
+        # from sklearn.ensemble import IsolationForest
+        # model = IsolationForest(**params)
+        # return model.fit(data['X'])
+        pass
+
+    @abstractmethod
+    def evaluate(self, model: Any, data: Any) -> Dict[str, float]:
+        # O IsolationForest retorna -1 para anomalias e 1 para inliers.
+        # Exemplo: usar F1-score caso tenha os rótulos verdadeiros de anomalias (data['y_true'])
+        # ou outras métricas não supervisionadas (Silhouette Score se aplicável).
+        pass

coremlflow-0.0.2/coremlflow/predictor.py

@@ -0,0 +1,116 @@
+from abc import ABC, abstractmethod
+import mlflow
+import os
+import logging
+from typing import Optional, Any
+import json
+
+class MLFlowPredictorBase(ABC):
+    def __init__(
+        self,
+        model_name: Optional[str] = None,
+        alias: str = "Production",
+        tracking_uri: Optional[str] = None,
+        local_model_path: Optional[str] = None,
+        *,
+        model_uri: Optional[str] = None,
+        internal_alias: Optional[str] = None,
+        internal_alias_map_path: Optional[str] = None,
+        artifact_path: str = "model",
+    ):
+        """
+        Estratégias suportadas para carregar modelo (ordem):
+        - model_uri: URI direta do MLflow (ex: runs:/<run_id>/model, models:/<name>@<alias>, file:/...).
+        - model_name + alias: via Model Registry (quando existir) usando models:/{model_name}@{alias}
+        - internal_alias + internal_alias_map_path: apelido interno resolvido para runs:/<run_id>/{artifact_path}
+        - local_model_path: fallback local
+        """
+        self.model_name = model_name
+        self.alias = alias
+        self.local_model_path = local_model_path
+        self.model_uri = model_uri
+        self.internal_alias = internal_alias
+        self.internal_alias_map_path = internal_alias_map_path or os.getenv("COREMLFLOW_ALIAS_MAP_PATH")
+        self.artifact_path = artifact_path
+        
+        uri = tracking_uri or os.getenv("MLFLOW_TRACKING_URI", "http://localhost:5000")
+        mlflow.set_tracking_uri(uri)
+        
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.model = self._load_model()
+
+    def _resolve_internal_alias_to_model_uri(self) -> Optional[str]:
+        if not self.internal_alias:
+            return None
+        if not self.internal_alias_map_path:
+            raise ValueError(
+                "internal_alias foi informado, mas internal_alias_map_path não foi fornecido "
+                "e COREMLFLOW_ALIAS_MAP_PATH não está definido."
+            )
+        if not os.path.exists(self.internal_alias_map_path):
+            raise FileNotFoundError(f"Arquivo de aliases não encontrado: {self.internal_alias_map_path}")
+
+        with open(self.internal_alias_map_path, "r", encoding="utf-8") as f:
+            mapping = json.load(f)
+
+        entry = mapping.get(self.internal_alias)
+        if entry is None:
+            raise KeyError(f"Alias interno não encontrado no mapa: {self.internal_alias}")
+
+        # Aceita dois formatos:
+        # 1) "CHURN_PROD": "<run_id>"
+        # 2) "CHURN_PROD": {"run_id": "...", "artifact_path": "model"}
+        if isinstance(entry, str):
+            run_id = entry
+            artifact_path = self.artifact_path
+        elif isinstance(entry, dict):
+            run_id = entry.get("run_id")
+            artifact_path = entry.get("artifact_path") or self.artifact_path
+        else:
+            raise TypeError("Entrada de alias deve ser str (run_id) ou dict {run_id, artifact_path}.")
+
+        if not run_id:
+            raise ValueError(f"Alias interno '{self.internal_alias}' não possui run_id válido.")
+
+        return f"runs:/{run_id}/{artifact_path}"
+
+    def _load_model(self):
+        """Carrega o modelo do MLflow por URI, registry (se existir) ou alias interno."""
+        try:
+            resolved_uri = None
+
+            if self.model_uri:
+                resolved_uri = self.model_uri
+                self.logger.info(f"Carregando modelo via model_uri: {resolved_uri}")
+            elif self.model_name:
+                # Sintaxe moderna para aliases do MLflow: models:/{model_name}@{alias}
+                resolved_uri = f"models:/{self.model_name}@{self.alias}"
+                self.logger.info(f"Carregando modelo do registry: {resolved_uri}")
+            elif self.internal_alias:
+                resolved_uri = self._resolve_internal_alias_to_model_uri()
+                self.logger.info(f"Carregando modelo via alias interno '{self.internal_alias}': {resolved_uri}")
+            else:
+                raise ValueError("Informe model_uri, model_name, ou internal_alias para carregar o modelo.")
+
+            return mlflow.pyfunc.load_model(resolved_uri)
+        except Exception as e:
+            self.logger.warning(f"Erro ao carregar do tracking server: {e}")
+            if self.local_model_path and os.path.exists(self.local_model_path):
+                self.logger.info(f"Carregando modelo via fallback local: {self.local_model_path}")
+                return mlflow.pyfunc.load_model(self.local_model_path)
+            else:
+                self.logger.error("Falha no fallback local: Caminho não fornecido ou inexistente.")
+                raise e
+
+    def predict(self, data: Any) -> Any:
+        """
+        Prediz baseado nos dados.
+        Retornos variam por tipo de modelo (ex: Prophet retorna DataFrame com 'yhat', scikit-learn retorna array).
+        Pode ser sobrescrita para tratar pré/pós processamento se desejado.
+        """
+        if self.model is None:
+            raise ValueError("Modelo não foi carregado.")
+        
+        self.logger.info("Realizando predição com base nos dados fornecidos.")
+        return self.model.predict(data)

coremlflow-0.0.2/coremlflow.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: coremlflow
+Version: 0.0.2
+Summary: Coreflow - Abstração de Funções para MLFlow não oficial.
+Author: Willian Marchi
+Author-email: willian.m.marchi@gmail.com
+License: MIT License
+Keywords: coremlflow mlflow core
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: mlflow
+Provides-Extra: sklearn
+Requires-Dist: scikit-learn; extra == "sklearn"
+Provides-Extra: prophet
+Requires-Dist: prophet; extra == "prophet"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# Guia de Desenvolvimento: Modelos e Inferência no coremlflow
+
+Este guia explica como criar scripts de **Treinamento (`train.py`)** e **Predição/Inferência (`predict.py`)** utilizando o framework base da biblioteca `coremlflow`.
+
+A arquitetura orientada a objetos obriga a implementação de métodos específicos para padronizar o ciclo de vida do modelo e a integração automática com o MLflow.
+
+---
+
+## 🚀 1. Criando um Modelo de Treinamento (`train.py`)
+
+Com o `coremlflow`, você tem a opção de herdar da classe base genérica ou utilizar as **abstrações específicas** construídas para os principais frameworks de Data Science.
+
+### A. Utilizando as Classes Especializadas (Recomendado)
+
+O pacote `coremlflow.models` provê classes preparadas que já implementam automaticamente a melhor forma de salvar o seu modelo (ex: usando `mlflow.sklearn` ou `mlflow.prophet`).
+
+#### Exemplo: Random Forest
+Para Random Forest ou Isolation Forest, herde das classes em `coremlflow.models.sklearn`:
+
+```python
+import pandas as pd
+from typing import Dict, Any
+from sklearn.ensemble import RandomForestClassifier
+from coremlflow.models.sklearn import RandomForestMLFlowModel
+
+class MeuModeloRF(RandomForestMLFlowModel):
+    def __init__(self, experiment_name: str, data_path: str, tracking_uri: str = None):
+        super().__init__(experiment_name, tracking_uri)
+        self.data_path = data_path 
+    
+    def load_data(self) -> Dict[str, Any]:
+        # Exemplo carregando dados de Treino/Teste
+        return {"X_train": [...], "y_train": [...], "X_test": [...], "y_test": [...]}
+
+    def train(self, data: Dict[str, Any], params: Dict[str, Any]) -> Any:
+        model = RandomForestClassifier(**params)
+        model.fit(data["X_train"], data["y_train"])
+        return model
+
+    def evaluate(self, model: Any, data: Dict[str, Any]) -> Dict[str, float]:
+        # Calcule e retorne suas métricas
+        score = model.score(data["X_test"], data["y_test"])
+        return {"accuracy": score}
+
+    def get_signature_data(self, model: Any, data: Dict[str, Any]) -> tuple:
+        return (data["X_train"], data["y_train"])
+```
+*Note que não foi necessário implementar o método `save_model()`, pois ele já foi abstraído pela classe mãe `RandomForestMLFlowModel`.*
+
+#### Outros modelos suportados nativamente:
+- `IsolationForestMLFlowModel` (em `coremlflow.models.sklearn`)
+- `ProphetMLFlowModel` (em `coremlflow.models.prophet`)
+
+### B. Utilizando a Classe Base Genérica
+
+Se você estiver treinando um modelo Keras, PyTorch, ou outro ainda não mapeado nas classes filhas nativas, basta herdar nativamente da `MLFlowModelBase` e definir seu `.save_model()`.
+
+```python
+from coremlflow.base import MLFlowModelBase
+import mlflow.keras
+
+class MeuModeloGenerico(MLFlowModelBase):
+    # ... defina load(), train(), evaluate(), get_signature_data() ...
+    
+    def save_model(self, model, signature) -> None:
+        # [Obrigatório na Base]
+        mlflow.keras.log_model(model, artifact_path="model", signature=signature)
+```
+
+### Executando o Treinamento
+
+Para rodar, instancie a sua classe e chame o método genérico `run(params)`. Ele vai orquestrar todas as chamadas garantindo o log correto no MLflow.
+
+```python
+if __name__ == "__main__":
+    predictor = MeuModeloRF(experiment_name="Projeto_Churn", data_path="dados.csv")
+    params = {"n_estimators": 100, "max_depth": 5}
+    
+    modelo = predictor.run(params=params)
+```
+
+---
+
+## 🔮 2. Consumindo um Modelo em Produção (`predict.py`)
+
+Ao fazer a inferência, importe o `MLFlowPredictorBase`.
+
+Essa classe cuida internamente do carregamento do modelo a partir do Registry do MLflow. Se o Tracking Server do MLflow estiver fora do ar, você ainda pode fornecer um `local_model_path` como *fallback*.
+
+### Estrutura da Classe de Predição
+
+Opcionalmente, você pode sobrescrever o método `predict`, mas por base, a classe já traz o comportamento chamando recursivamente o modelo baixado no formato `pyfunc`.
+
+```python
+from coremlflow.predictor import MLFlowPredictorBase
+
+# Você pode usar a classe base diretamente:
+servico_ia = MLFlowPredictorBase(
+    internal_alias="CHURN_PROD",
+    internal_alias_map_path="./mlflow_aliases.json",
+    local_model_path="./modelos_backup/rf_model_v1" # Fallback opcional offline
+)
+
+# Os resultados dependerão da natureza do modelo treinado.
+resultados = servico_ia.predict(dados_de_entrada)
+```
+
+Ou, caso você precise criar um fluxo complexo de tratamento de dados de entrada antes / depois de passar pelo `.predict()`:
+
+```python
+class SeuPredictorService(MLFlowPredictorBase):
+    def predict(self, input_data):
+        # 1. Trata input_data (ex: limpeza, feature engineering)
+        dados_tratados = limpar(input_data)
+        
+        # 2. Chama a predição da classe base
+        resultado = super().predict(dados_tratados)
+        
+        # 3. Pós Processa
+        return formatar(resultado)
+```
+
+Exemplo de arquivo `./mlflow_aliases.json` (apelido interno -> run_id):
+
+```json
+{
+  "CHURN_PROD": "a1b2c3d4e5f6g7h8i9j0",
+  "FORECAST_PROD": { "run_id": "ffffeeee111122223333444455556666", "artifact_path": "model" }
+}
+```

coremlflow-0.0.2/coremlflow.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENCE
+README.md
+setup.py
+coremlflow/__init__.py
+coremlflow/base.py
+coremlflow/decorators.py
+coremlflow/predictor.py
+coremlflow.egg-info/PKG-INFO
+coremlflow.egg-info/SOURCES.txt
+coremlflow.egg-info/dependency_links.txt
+coremlflow.egg-info/requires.txt
+coremlflow.egg-info/top_level.txt
+coremlflow/models/__init__.py
+coremlflow/models/prophet.py
+coremlflow/models/sklearn.py
+tests/test_models.py

coremlflow-0.0.2/coremlflow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

coremlflow-0.0.2/coremlflow.egg-info/requires.txt

@@ -0,0 +1,7 @@
+mlflow
+
+[prophet]
+prophet
+
+[sklearn]
+scikit-learn

coremlflow-0.0.2/coremlflow.egg-info/top_level.txt

@@ -0,0 +1 @@
+coremlflow

coremlflow-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

coremlflow-0.0.2/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as arq:
+    readme = arq.read()
+
+setup(name='coremlflow',
+    version='0.0.2',
+    license='MIT License',
+    author='Willian Marchi',
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    author_email='willian.m.marchi@gmail.com',
+    keywords='coremlflow mlflow core',
+    description=u'Coreflow - Abstração de Funções para MLFlow não oficial.',
+    packages=find_packages(exclude=("tests",)),
+    install_requires=['mlflow'],
+    extras_require={
+        "sklearn": ["scikit-learn"],
+        "prophet": ["prophet"],
+    },
+)

coremlflow-0.0.2/tests/test_models.py

@@ -0,0 +1,59 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from coreflow.models.sklearn import RandomForestMLFlowModel, IsolationForestMLFlowModel
+from coreflow.models.prophet import ProphetMLFlowModel
+
+class DummyRFModel(RandomForestMLFlowModel):
+    def load_data(self):
+        return {"X": [[1, 2], [3, 4]], "y": [0, 1]}
+    def train(self, data, params):
+        return "mock_rf_model"
+    def evaluate(self, model, data):
+        return {"accuracy": 0.95}
+    def get_signature_data(self, model, data):
+        return (data["X"], data["y"])
+
+class DummyProphetModel(ProphetMLFlowModel):
+    def load_data(self):
+        return {"ds": ["2020-01-01", "2020-01-02"], "y": [1.0, 2.0]}
+    def train(self, data, params):
+        return "mock_prophet_model"
+    def evaluate(self, model, data):
+        return {"mape": 0.05}
+    def get_signature_data(self, model, data):
+        return (data, [1.5, 2.5])
+
+class TestModels(unittest.TestCase):
+    
+    @patch("coreflow.base.mlflow")
+    @patch("coreflow.models.sklearn.mlflow.sklearn")
+    def test_random_forest_model_run(self, mock_mlflow_sklearn, mock_mlflow_base):
+        # Mocking signature Inference
+        with patch("mlflow.models.infer_signature", return_value="mock_signature"):
+            model_instance = DummyRFModel(experiment_name="test_rf")
+            result = model_instance.run(params={"n_estimators": 100})
+            
+            # Verificar se salvou corretamente
+            mock_mlflow_sklearn.log_model.assert_called_once_with(
+                sk_model="mock_rf_model",
+                artifact_path="model",
+                signature="mock_signature"
+            )
+            self.assertEqual(result, "mock_rf_model")
+
+    @patch("coreflow.base.mlflow")
+    @patch("coreflow.models.prophet.mlflow.prophet")
+    def test_prophet_model_run(self, mock_mlflow_prophet, mock_mlflow_base):
+        with patch("mlflow.models.infer_signature", return_value="mock_signature"):
+            model_instance = DummyProphetModel(experiment_name="test_prophet")
+            result = model_instance.run(params={"changepoint_prior_scale": 0.05})
+            
+            mock_mlflow_prophet.log_model.assert_called_once_with(
+                pr_model="mock_prophet_model",
+                artifact_path="model",
+                signature="mock_signature"
+            )
+            self.assertEqual(result, "mock_prophet_model")
+
+if __name__ == "__main__":
+    unittest.main()