deploy: updated backend structure and ignored frontend

.gitignore

@@ -1,18 +1,61 @@
-# --- SENSITIVE KEYS (Never Push) ---
+# --- Python Specific ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# --- ML Models (Ignored because they are on the HF Hub) ---
+# We ignore the local folder to prevent 1.5GB pushes
+ml_models/
+*.joblib
+*.pkl
+*.pth
+*.onnx
+
+# --- Environment & Secrets ---
+# Never push your API keys or email passwords
 .env
-backend/.env
-frontend/.env
-*.env
+.flaskenv
+secrets.json
+
+# --- OS Specific ---
+.DS_Store
+.DS_Store?
+._*
+Thumbs.db
+desktop.ini
 
-# --- HEAVY FOLDERS (Never Push) ---
+# --- Frontend (Excluding local frontend code if in same repo) ---
+# Since you'll deploy the frontend separately to Vercel
+frontend/
 node_modules/
-frontend/node_modules/
-backend/env/
-env/
-__pycache__/
-backend/__pycache__/
 dist/
 build/
 
-# --- ML MODELS (Ignore entire folder over 100MB) ---
-backend/ml_models/
+# --- Logs & Reports ---
+*.log
+backend/reporting/*.pdf
+backend/reporting/*.csv
+
+# --- Docker ---
+.dockerignore
+
+# Fonts and Media
+backend/reporting/*.ttf
+frontend/public/*.mp3
+frontend/src/assests/*.png

backend/app.py → app.py

@@ -97,5 +97,6 @@ def home():
 
 if __name__ == "__main__":
     print("🚀 Starting Adaptive AI NIDS Backend...")
-    socketio.run(app, host="0.0.0.0", port=5000, debug=False)
+    # 7860 is the magic number for Hugging Face
+    socketio.run(app, host="0.0.0.0", port=7860, debug=False)
 

backend/utils/model_selector.py

@@ -1,116 +0,0 @@
-import os
-import joblib
-import threading
-import traceback
-
-# Global active model (default = bcc so your current flow remains unchanged)
-ACTIVE_MODEL = "bcc"
-_ACTIVE_LOCK = threading.Lock()
-
-# Cache loaded models to avoid repeated disk loads
-_MODEL_CACHE = {}
-ML_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "ml_models"))
-print("[model_selector] ML_DIR =", ML_DIR)
-try:
-    print("[model_selector] ML_DIR files:", os.listdir(ML_DIR))
-except Exception as e:
-    print("[model_selector] Could not list ML_DIR:", e)
-
-
-def _try_load(path):
-    """Try to joblib.load(path). On failure return None but print full traceback."""
-    if not os.path.exists(path):
-        print(f"[model_selector] SKIP (not found): {path}")
-        return None
-    try:
-        print(f"[model_selector] Attempting to load: {path}")
-        obj = joblib.load(path)
-        print(f"[model_selector] Successfully loaded: {os.path.basename(path)}")
-        return obj
-    except Exception as e:
-        print(f"[model_selector] FAILED to load {path}: {e}")
-        traceback.print_exc()
-        return None
-
-def load_model(model_key):
-    """Return a dict with keys depending on model. Caches result."""
-    if model_key in _MODEL_CACHE:
-        return _MODEL_CACHE[model_key]
-
-    if model_key == "bcc":
-        # original BCC artifact names (your working files)
-        model_path = os.path.join(ML_DIR, "realtime_model.pkl")
-        scaler_path = os.path.join(ML_DIR, "realtime_scaler.pkl")
-        encoder_path = os.path.join(ML_DIR, "realtime_encoder.pkl")
-
-        model = _try_load(model_path)
-        scaler = _try_load(scaler_path)
-        encoder = _try_load(encoder_path)
-
-        if model is None:
-            print(f"[model_selector] WARNING: bcc model not found at {model_path}")
-        _MODEL_CACHE["bcc"] = {"model": model, "scaler": scaler, "encoder": encoder}
-        return _MODEL_CACHE["bcc"]
-
-    if model_key == "cicids":
-        # Prefer the RF pipeline you requested; try common names in preferred order
-        candidate_models = [
-            "rf_pipeline.joblib",        # preferred - your RF pipeline
-            "cicids_rf.joblib",
-            "rf_pipeline.pkl",
-            "cicids_model.joblib",
-            "lgb_pipeline.joblib",
-            "cicids_rf.pkl",
-        ]
-        # prefer 'training_artifacts' or 'cicids_artifacts'
-        candidate_artifacts = [
-            "training_artifacts.joblib",
-            "training_artifacts.pkl",
-            "cicids_artifacts.joblib",
-            "cicids_artifacts.pkl",
-            "artifacts.joblib",
-            "artifacts.pkl"
-        ]
-
-        model = None
-        artifacts = None
-        for fn in candidate_models:
-            p = os.path.join(ML_DIR, fn)
-            model = _try_load(p)
-            if model is not None:
-                print(f"[model_selector] Loaded cicids model from {p}")
-                break
-
-        for fn in candidate_artifacts:
-            p = os.path.join(ML_DIR, fn)
-            artifacts = _try_load(p)
-            if artifacts is not None:
-                print(f"[model_selector] Loaded cicids artifacts from {p}")
-                break
-
-        if model is None:
-            print("[model_selector] WARNING: No cicids model found in ml_models.")
-        if artifacts is None:
-            print("[model_selector] WARNING: No cicids artifacts found in ml_models.")
-
-        # artifacts expected to include: 'scaler' and 'features' at minimum
-        _MODEL_CACHE["cicids"] = {
-            "model": model,
-            "artifacts": artifacts
-        }
-        return _MODEL_CACHE["cicids"]
-
-    raise ValueError("Unknown model_key")
-
-def set_active_model(key: str):
-    global ACTIVE_MODEL
-    if key not in ("bcc", "cicids"):
-        raise ValueError("Active model must be 'bcc' or 'cicids'")
-    with _ACTIVE_LOCK:
-        ACTIVE_MODEL = key
-    print(f"[model_selector] ACTIVE_MODEL set to: {ACTIVE_MODEL}")
-
-def get_active_model():
-    return ACTIVE_MODEL
-
-

utils/model_selector.py

@@ -0,0 +1,95 @@
+import os
+import joblib
+import threading
+import traceback
+from huggingface_hub import hf_hub_download
+
+# --- CONFIGURATION ---
+HF_REPO_ID = "CodebaseAi/netraids-ml-models"  # Replace with your actual public repo ID
+# ---------------------
+
+ACTIVE_MODEL = "bcc"
+_ACTIVE_LOCK = threading.Lock()
+_MODEL_CACHE = {}
+
+# 1. FIXED PATH LOGIC:
+# __file__ is /app/utils/model_selector.py
+# dirname(__file__) is /app/utils
+# dirname(dirname(...)) is /app (the ROOT)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ML_DIR = os.path.join(BASE_DIR, "ml_models")
+
+# Ensure the local ml_models directory exists for caching
+if not os.path.exists(ML_DIR):
+    os.makedirs(ML_DIR, exist_ok=True)
+
+print(f"[model_selector] ROOT BASE_DIR: {BASE_DIR}")
+print(f"[model_selector] ML_DIR: {ML_DIR}")
+
+def _get_model_path(filename):
+    """
+    First looks in the local 'ml_models' folder. 
+    If not found, downloads from the public Hugging Face Hub.
+    """
+    local_path = os.path.join(ML_DIR, filename)
+    
+    # 1. Check if the file is already there
+    if os.path.exists(local_path):
+        return local_path
+    
+    # 2. Download from Hub if missing
+    try:
+        print(f"[model_selector] {filename} not found locally. Downloading from Hub...")
+        # We specify local_dir to force it into our ml_models folder
+        downloaded_path = hf_hub_download(
+            repo_id=HF_REPO_ID, 
+            filename=filename,
+            local_dir=ML_DIR
+        )
+        return downloaded_path
+    except Exception as e:
+        print(f"[model_selector] ERROR: Could not find/download {filename}: {e}")
+        return None
+
+def _try_load(filename):
+    path = _get_model_path(filename)
+    if not path or not os.path.exists(path):
+        print(f"[model_selector] SKIP: {filename} path invalid.")
+        return None
+    try:
+        return joblib.load(path)
+    except Exception as e:
+        print(f"[model_selector] FAILED to load {filename}: {e}")
+        return None
+
+def load_model(model_key):
+    if model_key in _MODEL_CACHE:
+        return _MODEL_CACHE[model_key]
+
+    if model_key == "bcc":
+        _MODEL_CACHE["bcc"] = {
+            "model": _try_load("realtime_model.pkl"),
+            "scaler": _try_load("realtime_scaler.pkl"),
+            "encoder": _try_load("realtime_encoder.pkl")
+        }
+        return _MODEL_CACHE["bcc"]
+
+    if model_key == "cicids":
+        # It will look for your RF files in the Hub
+        _MODEL_CACHE["cicids"] = {
+            "model": _try_load("rf_pipeline.joblib"),
+            "artifacts": _try_load("training_artifacts.joblib")
+        }
+        return _MODEL_CACHE["cicids"]
+
+    raise ValueError(f"Unknown model_key: {model_key}")
+
+def set_active_model(key: str):
+    global ACTIVE_MODEL
+    with _ACTIVE_LOCK:
+        ACTIVE_MODEL = key
+    print(f"[model_selector] ACTIVE_MODEL set to: {ACTIVE_MODEL}")
+
+def get_active_model():
+    return ACTIVE_MODEL
+