ezyml 2__py3-none-any.whl

ezyml/deploy/__init__.py

@@ -0,0 +1,5 @@
+from .fastapi import generate_fastapi_app
+from .docker import generate_dockerfile
+from .openapi import generate_openapi_spec
+from .streamlit import generate_streamlit_app
+from .k8s import generate_k8s_manifests

ezyml/deploy/docker.py

@@ -0,0 +1,21 @@
+def generate_dockerfile(output_path="Dockerfile"):
+    """
+    Generates a minimal Dockerfile for FastAPI deployment.
+    """
+    dockerfile = """
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir fastapi uvicorn scikit-learn numpy
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
+"""
+    with open(output_path, "w") as f:
+        f.write(dockerfile)
+
+    return output_path

ezyml/deploy/fastapi.py

@@ -0,0 +1,30 @@
+def generate_fastapi_app(model_path, schema, output_path="app.py"):
+    """
+    Generates a FastAPI inference server.
+    Assumes sklearn-compatible model.
+    """
+    code = f'''
+from fastapi import FastAPI
+import pickle
+import numpy as np
+
+app = FastAPI()
+
+with open("{model_path}", "rb") as f:
+    model = pickle.load(f)
+
+FEATURES = {list(schema.keys())}
+
+@app.post("/predict")
+def predict(payload: dict):
+    try:
+        X = np.array([[payload[f] for f in FEATURES]])
+        pred = model.predict(X)[0]
+        return {{"prediction": int(pred)}}
+    except Exception as e:
+        return {{"error": str(e)}}
+'''
+    with open(output_path, "w") as f:
+        f.write(code)
+
+    return output_path

ezyml/deploy/k8s.py

@@ -0,0 +1,125 @@
+import yaml
+
+def generate_k8s_manifests(
+    app_name,
+    image,
+    port=8000,
+    replicas=1,
+    namespace="default",
+    output_prefix="k8s",
+    with_ingress=False,
+    ingress_host=None
+):
+    """
+    Generates Kubernetes YAML manifests for ezyml models.
+    """
+
+    deployment = {
+        "apiVersion": "apps/v1",
+        "kind": "Deployment",
+        "metadata": {
+            "name": app_name,
+            "namespace": namespace
+        },
+        "spec": {
+            "replicas": replicas,
+            "selector": {
+                "matchLabels": {"app": app_name}
+            },
+            "template": {
+                "metadata": {
+                    "labels": {"app": app_name}
+                },
+                "spec": {
+                    "containers": [{
+                        "name": app_name,
+                        "image": image,
+                        "ports": [{"containerPort": port}],
+                        "resources": {
+                            "requests": {
+                                "cpu": "250m",
+                                "memory": "256Mi"
+                            },
+                            "limits": {
+                                "cpu": "500m",
+                                "memory": "512Mi"
+                            }
+                        }
+                    }]
+                }
+            }
+        }
+    }
+
+    service = {
+        "apiVersion": "v1",
+        "kind": "Service",
+        "metadata": {
+            "name": f"{app_name}-svc",
+            "namespace": namespace
+        },
+        "spec": {
+            "selector": {"app": app_name},
+            "ports": [{
+                "protocol": "TCP",
+                "port": 80,
+                "targetPort": port
+            }],
+            "type": "ClusterIP"
+        }
+    }
+
+    manifests = [deployment, service]
+
+    if with_ingress:
+        if not ingress_host:
+            raise ValueError("ingress_host must be provided if with_ingress=True")
+
+        ingress = {
+            "apiVersion": "networking.k8s.io/v1",
+            "kind": "Ingress",
+            "metadata": {
+                "name": f"{app_name}-ingress",
+                "namespace": namespace
+            },
+            "spec": {
+                "rules": [{
+                    "host": ingress_host,
+                    "http": {
+                        "paths": [{
+                            "path": "/",
+                            "pathType": "Prefix",
+                            "backend": {
+                                "service": {
+                                    "name": f"{app_name}-svc",
+                                    "port": {"number": 80}
+                                }
+                            }
+                        }]
+                    }
+                }]
+            }
+        }
+        manifests.append(ingress)
+
+    # Write individual files
+    with open(f"{output_prefix}_deployment.yaml", "w") as f:
+        yaml.safe_dump(deployment, f)
+
+    with open(f"{output_prefix}_service.yaml", "w") as f:
+        yaml.safe_dump(service, f)
+
+    # Write combined file
+    with open(f"{output_prefix}.yaml", "w") as f:
+        yaml.safe_dump_all(manifests, f)
+
+    if with_ingress:
+        with open(f"{output_prefix}_ingress.yaml", "w") as f:
+            yaml.safe_dump(ingress, f)
+
+    return {
+        "deployment": f"{output_prefix}_deployment.yaml",
+        "service": f"{output_prefix}_service.yaml",
+        "combined": f"{output_prefix}.yaml",
+        "ingress": f"{output_prefix}_ingress.yaml" if with_ingress else None
+    }

ezyml/deploy/openapi.py

@@ -0,0 +1,19 @@
+import json
+
+def generate_openapi_spec(schema, output_path="openapi.json"):
+    """
+    Generates a minimal OpenAPI-style input schema.
+    """
+    spec = {
+        "title": "ezyml-model-api",
+        "type": "object",
+        "properties": {
+            k: {"type": "number"} for k in schema.keys()
+        },
+        "required": list(schema.keys())
+    }
+
+    with open(output_path, "w") as f:
+        json.dump(spec, f, indent=2)
+
+    return output_path

ezyml/deploy/streamlit.py

@@ -0,0 +1,205 @@
+def generate_streamlit_app(model_path, schema, output_path="demo_app.py"):
+    """
+    Generates a professional Streamlit app that automatically adapts to
+    Light or Dark mode (fixing the 'invisible text' issue).
+    """
+    
+    code = f'''
+import streamlit as st
+import pickle
+import pandas as pd
+import numpy as np
+import time
+
+# --------------------------------------------------
+# 1. PAGE CONFIGURATION
+# --------------------------------------------------
+st.set_page_config(
+    page_title="ezyml Enterprise Demo",
+    page_icon="⚡",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# --------------------------------------------------
+# 2. CUSTOM CSS STYLING (THEME SAFE)
+# --------------------------------------------------
+# We removed the forced background colors to ensure text remains visible
+# regardless of whether the user is in Light or Dark mode.
+st.markdown("""
+    <style>
+    /* Style the tabs to look pill-shaped but keep default colors */
+    .stTabs [data-baseweb="tab-list"] {{
+        gap: 8px;
+    }}
+    .stTabs [data-baseweb="tab"] {{
+        height: 50px;
+        white-space: pre-wrap;
+        border-radius: 4px;
+        padding-top: 10px;
+        padding-bottom: 10px;
+    }}
+    
+    /* Custom button styling - stands out in both modes */
+    div.stButton > button {{
+        width: 100%;
+        font-weight: bold;
+        padding: 0.5rem 1rem;
+        border-radius: 8px;
+    }}
+    
+    /* Remove default top padding for a cleaner look */
+    .block-container {{
+        padding-top: 2rem;
+    footer {{visibility: hidden;}}
+    </style>
+""", unsafe_allow_html=True)
+
+# --------------------------------------------------
+# 3. LOAD MODEL
+# --------------------------------------------------
+@st.cache_resource
+def load_model():
+    try:
+        with open("{model_path}"=model.pkl, "rb") as f:
+            return pickle.load(f)
+    except FileNotFoundError:
+        st.error("Model file not found. Please check path.")
+        return None
+
+model = load_model()
+
+# --------------------------------------------------
+# 4. SIDEBAR
+# --------------------------------------------------
+with st.sidebar:
+    st.title("🎛️ ezyml Control")
+    st.divider()
+    
+    st.subheader("Model Status")
+    if model:
+        st.success("🟢 Model Active")
+    else:
+        st.error("🔴 Model Offline")
+        
+    st.info("""
+    **Mode Selection:**
+    1. **Single Predict**: Test one sample.
+    2. **Batch Predict**: Upload CSV.
+    """)
+    
+    st.divider()
+    st.caption("Generated by ezyml v2.0")
+
+# --------------------------------------------------
+# 5. MAIN CONTENT
+# --------------------------------------------------
+
+st.title("⚡ Model Inference Dashboard")
+st.markdown("Enter values below to generate predictions.")
+
+tab1, tab2 = st.tabs(["🎯 Single Prediction", "📂 Batch Processing"])
+
+# --- TAB 1: SINGLE PREDICTION ---
+with tab1:
+    st.write("") # Spacer
+    
+    # Create a container with a border for better visual separation
+    with st.container(border=True):
+        st.subheader("Configure Inputs")
+        
+        with st.form("prediction_form"):
+            inputs = {{}}
+            
+            # Use 3 columns for better layout
+            cols = st.columns(3)
+            schema_keys = {list(schema.keys())}
+            
+            for i, feature in enumerate(schema_keys):
+                col = cols[i % 3]
+                with col:
+                    inputs[feature] = st.number_input(
+                        label=feature,
+                        value=0.0,
+                        format="%.2f"
+                    )
+            
+            st.markdown("---")
+            
+            # Using type="primary" makes the button colorful automatically
+            submitted = st.form_submit_button("Run Prediction 🚀", type="primary")
+
+    if submitted and model:
+        # Spinner instead of manual progress bar for cleaner UI
+        with st.spinner("Calculating..."):
+            time.sleep(0.5) # clear visual cue
+            
+            X = pd.DataFrame([inputs])
+            try:
+                prediction = model.predict(X)[0]
+                
+                # Result Container
+                st.write("")
+                st.subheader("Results")
+                
+                res_col1, res_col2 = st.columns([1, 1])
+                
+                with res_col1:
+                    # Using a container with border makes it pop
+                    with st.container(border=True):
+                        st.metric(
+                            label="Predicted Value", 
+                            value=str(prediction), 
+                            delta="Success"
+                        )
+                
+                # Confidence (Optional)
+                if hasattr(model, "predict_proba"):
+                    with res_col2:
+                        try:
+                            probs = model.predict_proba(X)[0]
+                            confidence = np.max(probs) * 100
+                            with st.container(border=True):
+                                st.metric(label="Confidence", value=f"{{confidence:.1f}}%")
+                                st.progress(int(confidence))
+                        except:
+                            pass
+                
+            except Exception as e:
+                st.error(f"Prediction Error: {{e}}")
+
+# --- TAB 2: BATCH PREDICTION ---
+with tab2:
+    st.write("")
+    with st.container(border=True):
+        st.subheader("Bulk Inference")
+        
+        uploaded_file = st.file_uploader("Upload CSV", type=["csv"])
+        
+        if uploaded_file:
+            df = pd.read_csv(uploaded_file)
+            st.dataframe(df.head(), use_container_width=True)
+            
+            if st.button("Process Batch", type="primary"):
+                with st.spinner("Processing..."):
+                    try:
+                        preds = model.predict(df)
+                        df['Prediction'] = preds
+                        
+                        st.success("Done!")
+                        st.dataframe(df, use_container_width=True)
+                        
+                        csv = df.to_csv(index=False).encode('utf-8')
+                        st.download_button(
+                            "⬇️ Download CSV",
+                            csv,
+                            "predictions.csv",
+                            "text/csv"
+                        )
+                    except Exception as e:
+                        st.error(f"Batch failed: {{e}}")
+'''
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(code)
+
+    return output_path

ezyml/devx/__init___.py

@@ -0,0 +1 @@
+

ezyml/devx/doctor.py

@@ -0,0 +1,7 @@
+import sys
+
+def doctor():
+    issues=[]
+    if sys.version_info < (3,9):
+        issues.append("Python < 3.9 detected")
+    return issues or ["Environment OK"]

ezyml/devx/init.py

@@ -0,0 +1,6 @@
+import os
+
+def init_project(name):
+    os.makedirs(name, exist_ok=True)
+    for d in ["data","pipelines","models","artifacts"]:
+        os.makedirs(f"{name}/{d}", exist_ok=True)

ezyml/eda/auto_eda.py

@@ -0,0 +1,22 @@
+import numpy as np
+from scipy.stats import skew
+
+def auto_eda(df, target=None):
+    report = {}
+    report["shape"] = df.shape
+    report["missing"] = df.isnull().mean().to_dict()
+    report["outliers"] = outliers_iqr(df)
+    report["skewness"] = {c: float(skew(df[c].dropna()))
+                          for c in df.select_dtypes(include=np.number)}
+    if target:
+        report["target_distribution"] = df[target].value_counts(normalize=True).to_dict()
+    return report
+
+def outliers_iqr(df):
+    out = {}
+    for c in df.select_dtypes(include=np.number):
+        q1, q3 = df[c].quantile([0.25,0.75])
+        iqr = q3-q1
+        mask = (df[c]<q1-1.5*iqr)|(df[c]>q3+1.5*iqr)
+        out[c] = float(mask.mean())
+    return out

ezyml/evaluation/evaluator.py

@@ -0,0 +1,43 @@
+import os, json
+from .metrics import METRIC_REGISTRY
+from .plots import *
+
+class Evaluator:
+    DEFAULT_METRICS = {
+        "classification": ["accuracy", "precision", "recall", "f1", "roc_auc"],
+        "regression": ["rmse", "mae", "r2"]
+    }
+
+    DEFAULT_PLOTS = {
+        "classification": ["confusion_matrix", "roc_curve", "pr_curve"],
+        "regression": ["pred_vs_actual"]
+    }
+
+    def __init__(self, task, extra_metrics=None, extra_plots=None):
+        self.task = task
+        self.metrics = self.DEFAULT_METRICS[task] + (extra_metrics or [])
+        self.plots = self.DEFAULT_PLOTS[task] + (extra_plots or [])
+
+    def evaluate(self, y_true, y_pred, y_prob=None):
+        results = {}
+        for m in self.metrics:
+            fn = METRIC_REGISTRY[m]
+            results[m] = fn(y_true, y_prob if m=="roc_auc" else y_pred)
+        return results
+
+    def save(self, results, out_dir):
+        os.makedirs(out_dir, exist_ok=True)
+        with open(f"{out_dir}/metrics.json","w") as f:
+            json.dump(results, f, indent=2)
+
+    def visualize(self, y_true, y_pred, y_prob, out_dir):
+        os.makedirs(out_dir, exist_ok=True)
+        for p in self.plots:
+            if p=="confusion_matrix":
+                plot_confusion_matrix(y_true,y_pred,f"{out_dir}/confusion.png")
+            elif p=="roc_curve":
+                plot_roc_curve(y_true,y_prob,f"{out_dir}/roc.png")
+            elif p=="pr_curve":
+                plot_pr_curve(y_true,y_prob,f"{out_dir}/pr.png")
+            elif p=="pred_vs_actual":
+                plot_pred_vs_actual(y_true,y_pred,f"{out_dir}/pred_vs_actual.png")

ezyml/evaluation/metrics.py

@@ -0,0 +1,25 @@
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    roc_auc_score, mean_squared_error, mean_absolute_error, r2_score
+)
+
+def accuracy(y_true, y_pred): return accuracy_score(y_true, y_pred)
+def precision(y_true, y_pred): return precision_score(y_true, y_pred, zero_division=0)
+def recall(y_true, y_pred): return recall_score(y_true, y_pred, zero_division=0)
+def f1(y_true, y_pred): return f1_score(y_true, y_pred, zero_division=0)
+def roc_auc(y_true, y_prob): return roc_auc_score(y_true, y_prob)
+
+def rmse(y_true, y_pred): return mean_squared_error(y_true, y_pred, squared=False)
+def mae(y_true, y_pred): return mean_absolute_error(y_true, y_pred)
+def r2(y_true, y_pred): return r2_score(y_true, y_pred)
+
+METRIC_REGISTRY = {
+    "accuracy": accuracy,
+    "precision": precision,
+    "recall": recall,
+    "f1": f1,
+    "roc_auc": roc_auc,
+    "rmse": rmse,
+    "mae": mae,
+    "r2": r2
+}

ezyml/evaluation/plots.py

@@ -0,0 +1,23 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, roc_curve, precision_recall_curve
+
+def plot_confusion_matrix(y_true, y_pred, path):
+    cm = confusion_matrix(y_true, y_pred)
+    sns.heatmap(cm, annot=True, fmt="d")
+    plt.savefig(path); plt.close()
+
+def plot_roc_curve(y_true, y_prob, path):
+    fpr, tpr, _ = roc_curve(y_true, y_prob)
+    plt.plot(fpr, tpr); plt.xlabel("FPR"); plt.ylabel("TPR")
+    plt.savefig(path); plt.close()
+
+def plot_pr_curve(y_true, y_prob, path):
+    p, r, _ = precision_recall_curve(y_true, y_prob)
+    plt.plot(r, p); plt.xlabel("Recall"); plt.ylabel("Precision")
+    plt.savefig(path); plt.close()
+
+def plot_pred_vs_actual(y_true, y_pred, path):
+    plt.scatter(y_true, y_pred)
+    plt.xlabel("Actual"); plt.ylabel("Predicted")
+    plt.savefig(path); plt.close()

ezyml/explain/learner.py

@@ -0,0 +1,12 @@
+def explain_model_choice(model_name, profile):
+    if profile["rows"] < 1000:
+        return f"{model_name} chosen due to small dataset robustness."
+    return f"{model_name} chosen for general performance."
+
+def explain_metric(metric):
+    explanations = {
+        "accuracy":"Overall correctness of predictions.",
+        "f1":"Balance between precision and recall.",
+        "roc_auc":"Ability to separate classes."
+    }
+    return explanations.get(metric,"Standard evaluation metric.")

ezyml/monitoring/drift.py

@@ -0,0 +1,9 @@
+def detect_data_drift(base_df, new_df):
+    drift = {}
+    for c in base_df.columns:
+        drift[c] = abs(base_df[c].mean() - new_df[c].mean())
+    return drift
+
+def detect_concept_drift(y_true, y_pred, threshold=0.7):
+    acc = (y_true==y_pred).mean()
+    return acc < threshold

ezyml/monitoring/fingerprint.py

@@ -0,0 +1,8 @@
+import hashlib, json
+
+def dataset_fingerprint(df):
+    payload = json.dumps(df.describe().to_dict(), sort_keys=True)
+    return hashlib.sha256(payload.encode()).hexdigest()
+
+def compare_fingerprints(fp1, fp2):
+    return fp1 == fp2

ezyml/pipeline/loader.py

@@ -0,0 +1,84 @@
+# # ezyml/pipeline/loader.py
+
+# import yaml
+# from ezyml.core import EZTrainer
+# from ezyml.pipeline.visualize import render_ascii_dag
+
+
+# class Pipeline:
+#     def __init__(self, steps, edges):
+#         self.steps = steps
+#         self.edges = edges
+#         self.trainer = None
+
+#     def run(self, data, target=None):
+#         """
+#         Execute the pipeline.
+#         v1 assumption: last step is always EZTrainer.
+#         """
+#         if "trainer" not in self.steps:
+#             raise ValueError("Pipeline must contain a 'trainer' step")
+
+#         cfg = self.steps["trainer"]
+#         params = cfg.get("params", {})
+
+#         self.trainer = EZTrainer(
+#             data=data,
+#             target=target,
+#             model=params.get("model"),
+#             task="classification"
+#         )
+
+#         self.trainer.train()
+#         return self.trainer
+
+
+# def load_pipeline(path: str) -> Pipeline:
+#     with open(path, "r") as f:
+#         cfg = yaml.safe_load(f)
+
+#     steps = cfg.get("steps", {})
+#     edges = cfg.get("edges", [])
+
+#     render_ascii_dag(steps.keys(), _edges_to_map(edges))
+#     return Pipeline(steps=steps, edges=edges)
+
+
+# def _edges_to_map(edges):
+#     graph = {}
+#     for src, dst in edges:
+#         graph.setdefault(src, []).append(dst)
+#     return graph
+
+# ezyml/pipeline/loader.py
+
+import yaml
+from ezyml.core import EZTrainer
+from ezyml.pipeline.visualize import render_ascii_dag
+
+
+class Pipeline:
+    def __init__(self, steps):
+        self.steps = steps
+
+    def run(self, data, target):
+        cfg = self.steps["trainer"]
+        params = cfg.get("params", {})
+
+        trainer = EZTrainer(
+            data=data,
+            target=target,
+            model=params.get("model", "random_forest"),
+            task="classification"
+        )
+        trainer.train()
+        return trainer
+
+
+def load_pipeline(path):
+    with open(path) as f:
+        cfg = yaml.safe_load(f)
+
+    steps = cfg.get("steps", {})
+    render_ascii_dag(steps.keys(), {})
+    return Pipeline(steps)