ezyml 2__py3-none-any.whl

ezyml/__init__.py

@@ -0,0 +1,9 @@
+# ezyml/__init__.py
+
+# This file makes the 'ezyml' directory a Python package.
+
+# Import the main class to make it directly accessible to users
+from .core import EZTrainer
+
+__version__ = "2.0"
+__author__ = "Raktim Kalita"

ezyml/cli.py

@@ -0,0 +1,102 @@
+# ezyml/cli.py
+
+import argparse
+import pandas as pd
+
+from ezyml.core import EZTrainer
+from ezyml.compiler.compile import compile_project
+from ezyml.eda.auto_eda import auto_eda
+from ezyml.monitoring.fingerprint import dataset_fingerprint
+
+
+def compile_cli(args):
+    print("\n--- EZYML :: COMPILE ---")
+
+    df = pd.read_csv(args.data)
+
+    if not args.no_eda:
+        auto_eda(df, target=args.target)
+        print("[EDA] Completed")
+
+    # --------------------------------------------------
+    # PIPELINE (OPTIONAL) OR FALLBACK TRAINER
+    # --------------------------------------------------
+    if args.pipeline:
+        try:
+            from ezyml.pipeline.loader import load_pipeline
+        except ImportError:
+            raise RuntimeError(
+                "Pipeline support is not available in this installation.\n"
+                "Either install ezyml with pipeline support or run without --pipeline."
+            )
+
+        pipeline = load_pipeline(args.pipeline)
+        trainer = pipeline.run(df, target=args.target)
+
+    else:
+        print("[INFO] No pipeline provided. Using implicit EZTrainer.")
+        trainer = EZTrainer(
+            data=df,
+            target=args.target,
+            model=args.model,
+            task="classification"
+        )
+        trainer.train()
+
+    fingerprint = dataset_fingerprint(df)
+    print(f"[FINGERPRINT] {fingerprint}")
+
+    schema = {c: "number" for c in df.drop(columns=[args.target]).columns}
+
+    # --all overrides everything
+    api = args.api or args.all
+    demo = args.demo or args.all
+    docker = args.docker or args.all
+    k8s = args.k8s or args.all
+
+    compile_project(
+        trainer=trainer,
+        schema=schema,
+        api=api,
+        demo=demo,
+        docker=docker,
+        k8s=k8s
+    )
+
+    print("\n[SUCCESS] Compilation complete.")
+    print("Generated:")
+    print("  model.pkl")
+    print("  metrics.json")
+    if api: print("  app.py + openapi.json")
+    if demo: print("  demo_app.py")
+    if docker: print("  Dockerfile")
+    if k8s: print("  k8s.yaml")
+
+
+def main():
+    parser = argparse.ArgumentParser("ezyml")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    compile_cmd = sub.add_parser("compile")
+    compile_cmd.add_argument("--data", required=True)
+    compile_cmd.add_argument("--target", required=True)
+
+    # OPTIONAL
+    compile_cmd.add_argument("--pipeline", required=False)
+    compile_cmd.add_argument("--model", default="random_forest")
+
+    compile_cmd.add_argument("--api", action="store_true")
+    compile_cmd.add_argument("--demo", action="store_true")
+    compile_cmd.add_argument("--docker", action="store_true")
+    compile_cmd.add_argument("--k8s", action="store_true")
+    compile_cmd.add_argument("--all", action="store_true")
+
+    compile_cmd.add_argument("--no-eda", action="store_true")
+    compile_cmd.set_defaults(func=compile_cli)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

ezyml/compiler/__init__.py

@@ -0,0 +1 @@
+

ezyml/compiler/compile.py

@@ -0,0 +1,137 @@
+# from pathlib import Path
+# from ezyml.deploy import (
+#     generate_fastapi_app,
+#     generate_dockerfile,
+#     generate_openapi_spec,
+#     generate_streamlit_app,
+#     generate_k8s_manifests
+# )
+
+# def compile_project(
+#     model,
+#     pipeline,
+#     schema,
+#     image_name="ezyml-model",
+#     replicas=1,
+#     with_demo=True,
+#     with_k8s=True,
+#     build_dir="build"
+# ):
+#     """
+#     One-command ML system compiler.
+#     """
+
+#     build_dir = Path(build_dir)
+#     build_dir.mkdir(exist_ok=True)
+
+#     # ---- Core artifacts ----
+#     model_path = build_dir / "model.pkl"
+#     pipeline_path = build_dir / "pipeline.pkl"
+
+#     import pickle
+#     pickle.dump(model, open(model_path, "wb"))
+#     pickle.dump(pipeline, open(pipeline_path, "wb"))
+
+#     # ---- API & Docs ----
+#     generate_fastapi_app(model_path, schema, output_path=build_dir / "app.py")
+#     generate_openapi_spec(schema, output_path=build_dir / "openapi.json")
+
+#     # ---- Demo ----
+#     if with_demo:
+#         generate_streamlit_app(model_path, schema, output_path=build_dir / "demo_app.py")
+
+#     # ---- Docker ----
+#     generate_dockerfile(output_path=build_dir / "Dockerfile")
+
+#     # ---- Kubernetes ----
+#     if with_k8s:
+#         generate_k8s_manifests(
+#             app_name=image_name,
+#             image=f"{image_name}:latest",
+#             replicas=replicas,
+#             output_prefix=build_dir / "k8s"
+#         )
+
+#     return {
+#         "model": model_path,
+#         "pipeline": pipeline_path,
+#         "api": build_dir / "app.py",
+#         "dockerfile": build_dir / "Dockerfile",
+#         "openapi": build_dir / "openapi.json",
+#         "k8s": build_dir / "k8s.yaml" if with_k8s else None
+#     }
+# ezyml/compiler/compile.py
+
+from pathlib import Path
+import pickle
+import json
+
+from ezyml.deploy import (
+    generate_fastapi_app,
+    generate_dockerfile,
+    generate_openapi_spec,
+    generate_streamlit_app,
+    generate_k8s_manifests
+)
+
+def compile_project(
+    trainer,
+    schema,
+    build_dir="build",
+    api=False,
+    demo=False,
+    docker=False,
+    k8s=False,
+    plots=False
+):
+    build_dir = Path(build_dir)
+    build_dir.mkdir(exist_ok=True)
+
+    # --------------------------------------------------
+    # ALWAYS GENERATED (MINIMUM CONTRACT)
+    # --------------------------------------------------
+    model_path = build_dir / "model.pkl"
+    metrics_path = build_dir / "metrics.json"
+
+    with open(model_path, "wb") as f:
+        pickle.dump(trainer.pipeline, f)
+
+    with open(metrics_path, "w") as f:
+        json.dump(trainer.report, f, indent=2)
+
+    # --------------------------------------------------
+    # OPTIONAL OUTPUTS
+    # --------------------------------------------------
+    if api:
+        generate_fastapi_app(
+            model_path=model_path,
+            schema=schema,
+            output_path=build_dir / "app.py"
+        )
+        generate_openapi_spec(schema, output_path=build_dir / "openapi.json")
+
+    if demo:
+        generate_streamlit_app(
+            model_path=model_path,
+            schema=schema,
+            output_path=build_dir / "demo_app.py"
+        )
+
+    if docker:
+        generate_dockerfile(output_path=build_dir / "Dockerfile")
+
+    if k8s:
+        generate_k8s_manifests(
+            app_name="ezyml-model",
+            image="ezyml-model:latest",
+            output_prefix=build_dir / "k8s"
+        )
+
+    return {
+        "model": model_path,
+        "metrics": metrics_path,
+        "api": api,
+        "demo": demo,
+        "docker": docker,
+        "k8s": k8s
+    }