..

ARCHITECTURE_DIAGRAM.md

@@ -1,294 +0,0 @@
-# HuggingFace + Cloud MLOps - Complete Workflow
-
-## Visual Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    DEVELOPER MACHINE                             │
-│                                                                  │
-│  1. Get Prefect API Key                                         │
-│     https://app.prefect.cloud/ → Profile → API Keys             │
-│                                                                  │
-│  2. Run Deployment Script                                       │
-│     python prepare_hf_deployment.py                             │
-│     ├─ Adds files to git                                        │
-│     ├─ Commits changes                                          │
-│     └─ Shows secret configuration steps                         │
-│                                                                  │
-│  3. Configure HuggingFace Secrets                               │
-│     https://huggingface.co/spaces/kshitijk20/nss/settings       │
-│     Add: PREFECT_API_KEY = pnu_xxxxx                            │
-│                                                                  │
-│  4. Push to HuggingFace                                         │
-│     git push hf main                                            │
-└─────────────────────────────────────────────────────────────────┘
-                            ↓
-┌─────────────────────────────────────────────────────────────────┐
-│                  HUGGINGFACE SPACES (Build)                      │
-│                                                                  │
-│  Docker Build Process:                                          │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │ 1. FROM python:3.13-slim                                   │ │
-│  │ 2. COPY requirements.txt → pip install                     │ │
-│  │    • prefect>=2.14.0                                       │ │
-│  │    • evidently>=0.4.0                                      │ │
-│  │    • fastapi, uvicorn, scikit-learn                        │ │
-│  │ 3. COPY application code                                   │ │
-│  │    • app.py, startup.sh, cloud_config.py                   │ │
-│  │    • prefect_flows/, monitoring/                           │ │
-│  │    • final_model/model.pkl, preprocessor.pkl               │ │
-│  │ 4. RUN chmod +x startup.sh                                 │ │
-│  │ 5. RUN python load_data_to_sqlite.py                       │ │
-│  │ 6. RUN python cloud_config.py (check config)               │ │
-│  │ 7. ENTRYPOINT ["./startup.sh"]                             │ │
-│  │ 8. CMD ["uvicorn", "app:app", ...]                         │ │
-│  └────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-                            ↓
-┌─────────────────────────────────────────────────────────────────┐
-│               CONTAINER STARTUP (startup.sh)                     │
-│                                                                  │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │ 🔍 Check Environment Variables                             │ │
-│  │                                                            │ │
-│  │ if [ -n "$PREFECT_API_KEY" ]; then                         │ │
-│  │   ✅ Prefect Cloud API Key detected                        │ │
-│  │   🔧 Configuring Prefect Cloud...                          │ │
-│  │   prefect config set PREFECT_API_KEY="$PREFECT_API_KEY"   │ │
-│  │   prefect cloud workspace ls  # Verify connection          │ │
-│  │   ✅ Successfully connected to Prefect Cloud               │ │
-│  │                                                            │ │
-│  │   if [ "$AUTO_DEPLOY_FLOWS" = "true" ]; then               │ │
-│  │     📦 Auto-deploying Prefect flows...                     │ │
-│  │     cd prefect_flows && python deploy_schedule.py          │ │
-│  │   fi                                                       │ │
-│  │ else                                                       │ │
-│  │   ℹ️  No PREFECT_API_KEY - Cloud features disabled         │ │
-│  │ fi                                                         │ │
-│  │                                                            │ │
-│  │ if [ -n "$EVIDENTLY_CLOUD_TOKEN" ]; then                   │ │
-│  │   ✅ Evidently Cloud enabled                               │ │
-│  │ else                                                       │ │
-│  │   ℹ️  Using open-source Evidently                          │ │
-│  │ fi                                                         │ │
-│  │                                                            │ │
-│  │ 📁 mkdir -p monitoring/reports final_model logs            │ │
-│  │ ✅ Initialization complete!                                │ │
-│  │ 🌐 Starting FastAPI application...                         │ │
-│  └────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-                            ↓
-┌─────────────────────────────────────────────────────────────────┐
-│                FASTAPI APPLICATION (app.py)                      │
-│                                                                  │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │ from cloud_config import initialize_monitoring             │ │
-│  │ cloud_status = initialize_monitoring()                     │ │
-│  │                                                            │ │
-│  │ app = FastAPI()                                            │ │
-│  │                                                            │ │
-│  │ @app.get("/")                                              │ │
-│  │ def root():                                                │ │
-│  │     return {                                               │ │
-│  │         "status": "running",                               │ │
-│  │         "cloud_mlops": {                                   │ │
-│  │             "prefect_cloud": "enabled" ✅                  │ │
-│  │             "evidently": "open-source"                     │ │
-│  │         }                                                  │ │
-│  │     }                                                      │ │
-│  │                                                            │ │
-│  │ @app.get("/train")                                         │ │
-│  │ def training_route():                                      │ │
-│  │     if ENABLE_PREFECT:                                     │ │
-│  │         # Option 1: Trigger via Prefect Cloud              │ │
-│  │         training_flow()  # Logged to Prefect dashboard     │ │
-│  │     else:                                                  │ │
-│  │         # Option 2: Direct training                        │ │
-│  │         training_pipeline.run_pipeline()                   │ │
-│  │                                                            │ │
-│  │ @app.post("/predict")                                      │ │
-│  │ def predict_route(file):                                   │ │
-│  │     # Make predictions                                     │ │
-│  │     # Optionally log to Evidently                          │ │
-│  └────────────────────────────────────────────────────────────┘ │
-│                                                                  │
-│  🌐 Running at: https://kshitijk20-nss.hf.space                │
-└─────────────────────────────────────────────────────────────────┘
-                            ↕
-��─────────────────────────────────────────────────────────────────┐
-│               PREFECT CLOUD (External Service)                   │
-│                                                                  │
-│  Dashboard: https://app.prefect.cloud/                          │
-│                                                                  │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │ 📊 Flow Runs                                               │ │
-│  │ ├─ training-flow-2026-01-17-14:30:00 ✅ Success           │ │
-│  │ ├─ training-flow-2026-01-10-14:30:00 ✅ Success           │ │
-│  │ └─ drift-monitoring-2026-01-17-03:00:00 ✅ Success        │ │
-│  │                                                            │ │
-│  │ 📅 Deployments                                             │ │
-│  │ ├─ weekly-training (Every Sunday 2 AM)                     │ │
-│  │ └─ daily-drift-check (Every day 3 AM)                      │ │
-│  │                                                            │ │
-│  │ 🔔 Automations                                             │ │
-│  │ └─ Notify on training failure → Slack/Email                │ │
-│  │                                                            │ │
-│  │ 📈 Metrics                                                 │ │
-│  │ • Total runs: 45                                           │ │
-│  │ • Success rate: 97.8%                                      │ │
-│  │ • Avg duration: 2.3 min                                    │ │
-│  └────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-                            ↕
-┌─────────────────────────────────────────────────────────────────┐
-│            EVIDENTLY (Open Source - Local Reports)               │
-│                                                                  │
-│  Reports stored in: /app/monitoring/reports/                    │
-│                                                                  │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │ drift_report_20260117_143000.html                          │ │
-│  │ ├─ Data Drift: 12% of features drifted                     │ │
-│  │ ├─ Data Quality: 98.5% complete                            │ │
-│  │ └─ Recommendation: No retraining needed                    │ │
-│  │                                                            │ │
-│  │ performance_report_20260117_143000.html                    │ │
-│  │ ├─ Accuracy: 94.2%                                         │ │
-│  │ ├─ Precision: 93.8%                                        │ │
-│  │ └─ Recall: 95.1%                                           │ │
-│  └────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Data Flow Diagram
-
-```
-┌──────────┐       ┌─────────────┐       ┌──────────────┐
-│          │       │             │       │              │
-│  User    │──────>│ HuggingFace │──────>│   FastAPI    │
-│          │ POST  │   Space     │       │   app.py     │
-│          │ /pred │             │       │              │
-└──────────┘       └─────────────┘       └──────┬───────┘
-                                                 │
-                   ┌─────────────────────────────┼─────────────────┐
-                   │                             │                 │
-                   ↓                             ↓                 ↓
-          ┌────────────────┐          ┌─────────────────┐  ┌──────────────┐
-          │  Model Files   │          │ Prefect Cloud   │  │  Evidently   │
-          │  • model.pkl   │          │ • Log training  │  │  • Reports   │
-          │  • preproc.pkl │          │ • Schedule jobs │  │  • Drift det │
-          └────────────────┘          └─────────────────┘  └──────────────┘
-```
-
-## Secrets Flow
-
-```
-Developer → Get API Key from Prefect Cloud
-              ↓
-           Add to HuggingFace Space Secrets
-              ↓
-           Push code: git push hf main
-              ↓
-           HuggingFace builds Docker container
-              ↓
-           Injects secrets as environment variables
-              ↓
-           startup.sh reads $PREFECT_API_KEY
-              ↓
-           Configures Prefect Cloud connection
-              ↓
-           app.py uses cloud features
-              ↓
-           All operations visible in Prefect dashboard
-```
-
-## File Interaction Map
-
-```
-prepare_hf_deployment.py
-    ├─ Adds to git:
-    │   ├─ startup.sh
-    │   ├─ cloud_config.py
-    │   ├─ app.py (updated)
-    │   ├─ Dockerfile (updated)
-    │   └─ prefect_flows/
-    └─ Shows: Secret configuration instructions
-
-Dockerfile
-    ├─ Copies: startup.sh, cloud_config.py
-    ├─ RUN: chmod +x startup.sh
-    ├─ RUN: python cloud_config.py
-    └─ ENTRYPOINT: ./startup.sh
-
-startup.sh
-    ├─ Reads: $PREFECT_API_KEY, $EVIDENTLY_CLOUD_TOKEN
-    ├─ Configures: Prefect Cloud connection
-    ├─ Creates: monitoring/reports, final_model
-    └─ Starts: uvicorn app:app
-
-cloud_config.py
-    ├─ Reads: All environment variables
-    ├─ Exports: Configuration status
-    └─ Used by: app.py, startup.sh
-
-app.py
-    ├─ Imports: cloud_config
-    ├─ GET /: Shows cloud status
-    ├─ GET /train: Can use Prefect Cloud
-    └─ POST /predict: Normal predictions
-```
-
----
-
-## Success Flow (Happy Path)
-
-```
-1. Developer runs: python prepare_hf_deployment.py
-   ✅ Files added to git
-   ✅ Commit created
-
-2. Developer adds PREFECT_API_KEY to HF Space
-   ✅ Secret configured
-
-3. Developer pushes: git push hf main
-   ✅ Code pushed to HuggingFace
-
-4. HuggingFace builds container
-   ✅ Docker image built
-   ✅ Dependencies installed
-
-5. Container starts (startup.sh runs)
-   ✅ Prefect Cloud API Key detected
-   ✅ Successfully connected to Prefect Cloud
-   ✅ Initialization complete!
-
-6. FastAPI starts
-   ✅ Server running on port 7860
-   ✅ Cloud features enabled
-
-7. User calls GET /
-   ✅ Returns: "prefect_cloud": "enabled"
-
-8. User calls GET /train
-   ✅ Training executes
-   ✅ Logged to Prefect Cloud dashboard
-
-9. Developer checks Prefect dashboard
-   ✅ Sees flow run from HF Space
-   ✅ Views logs and execution graph
-```
-
----
-
-## Cost-Free Production MLOps! 🎉
-
-```
-┌───────────────────────────────────────────┐
-│ Component          │ Tier      │ Cost    │
-├───────────────────────────────────────────┤
-│ HuggingFace Spaces │ Community │ FREE ✅ │
-│ Prefect Cloud      │ Hobby     │ FREE ✅ │
-│ Evidently          │ Open Src  │ FREE ✅ │
-├───────────────────────────────────────────┤
-│ TOTAL MONTHLY COST                │ $0  │
-└───────────────────────────────────────────┘
-```

CLOUD_INTEGRATION_SUMMARY.md

@@ -1,152 +0,0 @@
-# ☁️ Cloud MLOps Integration - Summary
-
-## What Was Added
-
-Your HuggingFace Space now automatically sets up **Prefect Cloud** and **Evidently** during Docker build!
-
----
-
-## 📋 Quick Checklist
-
-### Before Deploying:
-- [ ] Create Prefect Cloud account: https://app.prefect.cloud/
-- [ ] Get API key (Profile → API Keys → Create)
-- [ ] Run: `python prepare_hf_deployment.py`
-
-### Add to HuggingFace Secrets:
-- [ ] Go to: https://huggingface.co/spaces/kshitijk20/nss/settings
-- [ ] Add secret: `PREFECT_API_KEY` = `<your-key>`
-- [ ] (Optional) Add: `AUTO_DEPLOY_FLOWS` = `true`
-
-### Deploy:
-- [ ] Run: `git push hf main`
-- [ ] Monitor build logs
-- [ ] Check for: "✅ Successfully connected to Prefect Cloud"
-
----
-
-## 🔧 What Happens Automatically
-
-### During Docker Build:
-1. ✅ Installs Prefect and Evidently
-2. ✅ Copies startup.sh and cloud_config.py
-3. ✅ Creates monitoring directories
-4. ✅ Makes scripts executable
-
-### During Container Startup:
-1. ✅ Reads PREFECT_API_KEY from HF secrets
-2. ✅ Configures Prefect Cloud connection
-3. ✅ Verifies workspace access
-4. ✅ (Optional) Auto-deploys flows
-5. ✅ Sets up Evidently monitoring
-6. ✅ Starts FastAPI app
-
-### When You Access the API:
-- ✅ `GET /` shows cloud MLOps status
-- ✅ `GET /train` can use Prefect Cloud
-- ✅ `POST /predict` works normally
-- ✅ All operations logged to Prefect dashboard
-
----
-
-## 📁 New Files
-
-| File | Purpose |
-|------|---------|
-| `startup.sh` | Container initialization script |
-| `cloud_config.py` | Cloud services configuration |
-| `HF_SECRETS_SETUP.md` | Secrets reference guide |
-| `CLOUD_MLOPS_SETUP.md` | Complete cloud setup guide |
-| `DEPLOY_TO_HF.md` | Deployment instructions |
-| `prepare_hf_deployment.py` | Deployment helper script |
-
----
-
-## 🎯 Required Secrets
-
-### Minimum (for cloud features):
-```
-Name:  PREFECT_API_KEY
-Value: pnu_... (from app.prefect.cloud)
-```
-
-### Optional (advanced):
-```
-AUTO_DEPLOY_FLOWS=true
-USE_PREFECT_FOR_TRAINING=true
-EVIDENTLY_CLOUD_TOKEN=<paid-service>
-```
-
----
-
-## 🚀 Deploy Commands
-
-```bash
-# 1. Prepare
-python prepare_hf_deployment.py
-
-# 2. Add secrets to HF Space UI
-# https://huggingface.co/spaces/kshitijk20/nss/settings
-
-# 3. Push
-git push hf main
-
-# 4. Monitor
-# https://huggingface.co/spaces/kshitijk20/nss
-```
-
----
-
-## ✅ Success Indicators
-
-After deployment, check:
-
-1. **Build Logs:**
-   ```
-   ✅ Successfully connected to Prefect Cloud
-   ✅ Initialization complete!
-   ```
-
-2. **Root Endpoint:**
-   ```bash
-   curl https://kshitijk20-nss.hf.space/
-   # Should show: "prefect_cloud": "enabled"
-   ```
-
-3. **Prefect Dashboard:**
-   - Go to: https://app.prefect.cloud/
-   - See flow runs from HF Space
-
----
-
-## 💰 Cost
-
-- HuggingFace Spaces: **FREE**
-- Prefect Cloud: **FREE** (Hobby tier)
-- Evidently Open Source: **FREE**
-
-**Total: $0** ✨
-
----
-
-## 📚 Documentation
-
-- **Quick Deploy:** [DEPLOY_TO_HF.md](DEPLOY_TO_HF.md)
-- **Secrets Setup:** [HF_SECRETS_SETUP.md](HF_SECRETS_SETUP.md)
-- **Full Cloud Guide:** [CLOUD_MLOPS_SETUP.md](CLOUD_MLOPS_SETUP.md)
-
----
-
-## 🆘 Need Help?
-
-1. Check build logs in HuggingFace Space
-2. Review [DEPLOY_TO_HF.md](DEPLOY_TO_HF.md) troubleshooting section
-3. Test Prefect key locally first:
-   ```bash
-   export PREFECT_API_KEY="your-key"
-   prefect cloud workspace ls
-   ```
-
----
-
-**Ready to deploy?** Run: `python prepare_hf_deployment.py` 🚀

CLOUD_MLOPS_SETUP.md

@@ -1,457 +0,0 @@
-# ☁️ Cloud MLOps Setup: Prefect Cloud + Evidently AI
-
-Complete guide to setting up production-grade MLOps using **Prefect Cloud** and **Evidently AI Cloud** platforms.
-
----
-
-## 🌟 Why Cloud Platforms?
-
-### Prefect Cloud
-- ✅ **Zero Infrastructure**: No server to manage
-- ✅ **Hybrid Execution**: Control plane in cloud, workers in your infrastructure
-- ✅ **Free Tier**: 2 users, 5 workflows, unlimited runs
-- ✅ **SOC 2 Type II Certified**: Enterprise security
-- ✅ **Real-time Monitoring**: Live dashboard at app.prefect.cloud
-
-### Evidently AI Cloud
-- ✅ **LLM & ML Monitoring**: 100+ built-in metrics
-- ✅ **Synthetic Data Generation**: For testing edge cases
-- ✅ **Automated Evaluation**: Continuous testing dashboards
-- ✅ **No-Code Interface**: Domain experts can collaborate
-- ✅ **Open Source Based**: Built on trusted Evidently library
-
----
-
-## 1️⃣ Prefect Cloud Setup
-
-### Step 1: Create Free Account
-1. Go to: https://app.prefect.cloud/
-2. Click **"Start Free"**
-3. Sign up with GitHub, Google, or email
-4. Create your first workspace (e.g., "phishing-detection")
-
-### Step 2: Get API Key
-```bash
-# In Prefect Cloud dashboard:
-# 1. Click on your profile (bottom left)
-# 2. Go to "API Keys"
-# 3. Click "Create API Key"
-# 4. Name it "NSS-Project" and copy the key
-```
-
-### Step 3: Configure Local Environment
-```bash
-# Activate your venv
-.\.venv\Scripts\activate
-
-# Login to Prefect Cloud
-prefect cloud login
-
-# Paste your API key when prompted
-# Or set it directly:
-prefect config set PREFECT_API_KEY="your-api-key-here"
-
-# Verify connection
-prefect cloud workspace ls
-```
-
-### Step 4: Update Training Flow for Cloud
-```python
-# prefect_flows/training_flow.py already configured!
-# Just run it and it will sync with Prefect Cloud
-cd prefect_flows
-python training_flow.py
-```
-
-### Step 5: Deploy to Prefect Cloud
-```bash
-# Create deployment with schedule
-cd prefect_flows
-python deploy_schedule.py
-
-# This creates a deployment visible in Prefect Cloud dashboard
-```
-
-### Step 6: Run Worker (Local or Cloud)
-
-**Option A: Run Worker Locally (Hybrid Model - Recommended)**
-```bash
-# Start worker on your machine (keeps data secure)
-prefect agent start -q training
-
-# Worker polls Prefect Cloud but executes in your environment
-# Your data never leaves your infrastructure!
-```
-
-**Option B: Use Prefect Managed Execution (Fully Cloud)**
-```python
-# Update deploy_schedule.py to use managed pool:
-deployment = Deployment.build_from_flow(
-    flow=training_flow,
-    name="weekly-training",
-    work_pool_name="prefect-managed-pool",  # Use managed pool
-    schedule=CronSchedule(cron="0 2 * * 0", timezone="UTC"),
-)
-```
-
-### Step 7: Monitor in Dashboard
-- Go to: https://app.prefect.cloud/
-- View flow runs in real-time
-- Check logs, states, and execution graphs
-- Set up alerts and automations
-
----
-
-## 2️⃣ Evidently AI Cloud Setup
-
-### Understanding Evidently Cloud vs Open Source
-
-**Open Source (What we have now):**
-- Generate HTML reports locally
-- Manual drift analysis
-- No centralized dashboard
-
-**Evidently Cloud (Upgrade):**
-- Centralized monitoring dashboard
-- Automated continuous testing
-- Alerting and notifications
-- Team collaboration
-- Synthetic data generation
-
-### Step 1: Get Access to Evidently Cloud
-```bash
-# Option A: Request Demo (Recommended for production)
-# Go to: https://www.evidentlyai.com/get-demo
-# Book a 1:1 demo to get:
-# - Private cloud deployment
-# - Custom risk assessment
-# - Enterprise features
-
-# Option B: Try Open Source First (What we currently have)
-# Already installed! Just use local HTML reports
-```
-
-### Step 2: Current Setup (Open Source - Already Working)
-```bash
-# Test current Evidently monitoring
-python test_evidently.py
-
-# This generates reports in monitoring/reports/
-# Open HTML files in browser
-```
-
-### Step 3: Integrate with Prefect Cloud
-
-#### Update Drift Monitoring Flow:
-```python
-# prefect_flows/drift_monitoring_flow.py
-# This flow already integrates both:
-# 1. Evidently for drift detection
-# 2. Prefect Cloud for orchestration
-
-# Run it:
-python prefect_flows/drift_monitoring_flow.py
-```
-
-#### Schedule Automated Drift Checks:
-```python
-# Create new file: prefect_flows/schedule_drift_monitoring.py
-from prefect.deployments import Deployment
-from prefect.server.schemas.schedules import CronSchedule
-from drift_monitoring_flow import drift_monitoring_flow
-
-deployment = Deployment.build_from_flow(
-    flow=drift_monitoring_flow,
-    name="daily-drift-check",
-    schedule=CronSchedule(cron="0 3 * * *", timezone="UTC"),  # Daily 3 AM
-    work_queue_name="training",
-    tags=["monitoring", "drift-detection"],
-)
-
-if __name__ == "__main__":
-    deployment.apply()
-    print("✅ Daily drift monitoring scheduled!")
-```
-
----
-
-## 3️⃣ Complete Cloud MLOps Workflow
-
-### Architecture Overview
-```
-┌───────────────────────────────────────��─────────────┐
-│              PREFECT CLOUD (Control Plane)          │
-│  - Flow orchestration                               │
-│  - Scheduling (Weekly training, Daily drift check)  │
-│  - Real-time monitoring dashboard                   │
-│  - Event-driven automations                         │
-└─────────────────────────────────────────────────────┘
-                         ↓
-┌─────────────────────────────────────────────────────┐
-│          YOUR INFRASTRUCTURE (Workers)              │
-│  - Prefect Worker (polls cloud API)                 │
-│  - Training pipeline execution                      │
-│  - Model files (final_model/)                       │
-│  - Evidently drift reports                          │
-└─────────────────────────────────────────────────────┘
-                         ↓
-┌─────────────────────────────────────────────────────┐
-│            EVIDENTLY (Open Source)                  │
-│  - Data drift detection                             │
-│  - Quality reports                                  │
-│  - HTML dashboards (local)                          │
-└─────────────────────────────────────────────────────┘
-                         ↓
-┌─────────────────────────────────────────────────────┐
-│         HUGGINGFACE SPACES (Deployment)             │
-│  - FastAPI app serving predictions                  │
-│  - Model inference endpoint                         │
-│  - Public access: kshitijk20-nss.hf.space          │
-└─────────────────────────────────────────────────────┘
-```
-
-### Daily Operations
-
-#### Morning: Check Dashboard
-```
-1. Open Prefect Cloud: https://app.prefect.cloud/
-2. Review overnight flow runs
-3. Check for any failures or warnings
-4. View execution graphs and logs
-```
-
-#### Weekly: Automated Training
-```
-Every Sunday 2 AM UTC:
-→ Prefect Cloud triggers training flow
-→ Worker executes pipeline in your environment
-→ New model saved to final_model/
-→ Logs visible in Prefect dashboard
-```
-
-#### Daily: Drift Monitoring
-```
-Every day 3 AM UTC:
-→ Drift monitoring flow runs
-→ Evidently checks for data drift
-→ If drift > 30%, triggers retraining
-→ Report saved to monitoring/reports/
-→ Notification sent (if configured)
-```
-
----
-
-## 4️⃣ Setup Commands (Step-by-Step)
-
-### One-Time Setup
-```bash
-# 1. Activate environment
-.\.venv\Scripts\activate
-
-# 2. Login to Prefect Cloud
-prefect cloud login
-# Paste your API key
-
-# 3. Create deployments
-cd prefect_flows
-python deploy_schedule.py  # Weekly training
-
-# 4. Start worker (keep running in background)
-# Terminal 1:
-prefect agent start -q training
-
-# 5. Test flows manually
-# Terminal 2:
-python training_flow.py
-python drift_monitoring_flow.py
-```
-
-### Verify Everything Works
-```bash
-# Check Prefect Cloud connection
-prefect cloud workspace ls
-
-# Check deployments
-prefect deployment ls
-
-# Run training manually
-cd prefect_flows
-python training_flow.py
-
-# Check Prefect Cloud dashboard
-# Go to: https://app.prefect.cloud/
-# You should see your flow run!
-
-# Generate Evidently report
-python test_evidently.py
-# Check monitoring/reports/ for HTML files
-```
-
----
-
-## 5️⃣ Cost Breakdown
-
-### Prefect Cloud
-| Tier | Price | Features |
-|------|-------|----------|
-| **Hobby (Free)** | $0 | 2 users, 5 workflows, unlimited runs |
-| **Pro** | Pay per user | Unlimited workflows, SSO, RBAC |
-| **Enterprise** | Custom | Private deployment, dedicated support |
-
-**Recommendation**: Start with Free tier (sufficient for this project)
-
-### Evidently AI
-| Option | Price | Features |
-|--------|-------|----------|
-| **Open Source** | FREE | Local reports, 100+ metrics |
-| **Cloud** | Contact sales | Centralized dashboard, alerting, team collaboration |
-
-**Recommendation**: Use Open Source (what we have now), upgrade to Cloud for production
-
----
-
-## 6️⃣ Monitoring & Alerts
-
-### Prefect Cloud Automations
-Set up alerts in Prefect Cloud UI:
-
-1. Go to **Automations** tab
-2. Create automation:
-   - **Trigger**: Flow run fails
-   - **Action**: Send email/Slack notification
-3. Example triggers:
-   - Training fails
-   - Drift threshold exceeded
-   - Worker goes offline
-
-### Evidently Alerts (Open Source)
-```python
-# In drift_monitoring_flow.py (already configured):
-if monitor.check_drift_threshold():
-    # Send notification (add your logic here)
-    send_alert("⚠️ Model drift detected! Retraining triggered.")
-```
-
----
-
-## 7️⃣ Advantages Over Local Setup
-
-| Feature | Local | Prefect Cloud | Benefit |
-|---------|-------|---------------|---------|
-| Server Management | You maintain | Managed | No DevOps overhead |
-| Availability | Your machine | 99.9% SLA | Production-ready |
-| Collaboration | Single user | Team access | Multi-user support |
-| Monitoring | Terminal logs | Rich dashboard | Better visibility |
-| Scheduling | Cron jobs | Cloud scheduler | More reliable |
-| Security | DIY | SOC 2 certified | Enterprise-grade |
-| Scaling | Manual | Auto-scale | Handle more workflows |
-
----
-
-## 8️⃣ Next Steps
-
-### Immediate (Today)
-- [x] Create Prefect Cloud account
-- [x] Get API key and login
-- [x] Deploy training flow
-- [x] Start worker and test
-
-### Short-term (This Week)
-- [ ] Set up automations for failure alerts
-- [ ] Schedule daily drift monitoring
-- [ ] Configure Slack/email notifications
-- [ ] Document team access procedures
-
-### Long-term (Next Month)
-- [ ] Evaluate Evidently Cloud (if needed)
-- [ ] Set up CI/CD with GitHub Actions
-- [ ] Implement A/B testing for models
-- [ ] Add more monitoring metrics
-
----
-
-## 9️⃣ Troubleshooting
-
-### Prefect Cloud Connection Issues
-```bash
-# Reset API key
-prefect cloud logout
-prefect cloud login
-
-# Check connection
-prefect cloud workspace ls
-
-# View logs
-prefect config view --show-sources
-```
-
-### Worker Not Picking Up Jobs
-```bash
-# Check worker status
-prefect work-queue ls
-
-# Restart worker
-prefect agent start -q training
-
-# Check deployment
-prefect deployment ls
-```
-
-### Evidently Reports Not Generating
-```bash
-# Verify data exists
-python test_evidently.py
-
-# Check reports directory
-dir monitoring\reports
-
-# Re-run with debug
-python -v test_evidently.py
-```
-
----
-
-## 📚 Resources
-
-### Prefect Cloud
-- Dashboard: https://app.prefect.cloud/
-- Documentation: https://docs.prefect.io/latest/cloud/
-- Community: https://prefect.io/slack
-- Status: https://prefect.status.io/
-
-### Evidently AI
-- Website: https://www.evidentlyai.com/
-- Documentation: https://docs.evidentlyai.com/
-- GitHub: https://github.com/evidentlyai/evidently
-- Discord: https://discord.com/invite/PyAJuUD5mB
-
-### Your Project
-- HuggingFace Space: https://kshitijk20-nss.hf.space
-- Prefect Dashboard: Check after login
-- Evidently Reports: `monitoring/reports/`
-
----
-
-## ✅ Success Checklist
-
-- [ ] Prefect Cloud account created
-- [ ] API key configured locally
-- [ ] Training flow deployed to cloud
-- [ ] Worker running and picking up jobs
-- [ ] Weekly schedule active (visible in dashboard)
-- [ ] Drift monitoring flow tested
-- [ ] Evidently reports generating correctly
-- [ ] Automations configured (optional)
-- [ ] Team members invited (if applicable)
-
----
-
-**🎉 Congratulations!** You now have a production-grade MLOps stack with:
-- Automated orchestration (Prefect Cloud)
-- Data drift monitoring (Evidently)
-- Scheduled retraining (Weekly)
-- Real-time dashboards
-- Enterprise security
-- Zero infrastructure management
-
-All while keeping your data secure in your own environment! 🔒

DEPLOY_TO_HF.md

@@ -1,352 +0,0 @@
-# 🚀 Deploying to HuggingFace with Cloud MLOps
-
-## Quick Deploy (5 Steps)
-
-### 1️⃣ Get Prefect Cloud API Key (Free)
-```bash
-# Visit: https://app.prefect.cloud/
-# Sign up (free) → Profile → API Keys → Create API Key
-# Copy the key (you'll need it in step 3)
-```
-
-### 2️⃣ Prepare Deployment
-```bash
-# Activate venv
-.\.venv\Scripts\activate
-
-# Run preparation script
-python prepare_hf_deployment.py
-
-# This will:
-# - Add all necessary files to git
-# - Commit changes
-# - Show HuggingFace secrets configuration
-```
-
-### 3️⃣ Add Secrets to HuggingFace Space
-```
-Go to: https://huggingface.co/spaces/kshitijk20/nss/settings
-
-Add Repository Secret:
-┌────────────────────────────────┐
-│ Name:  PREFECT_API_KEY         │
-│ Value: <paste your API key>    │
-└────────────────────────────────┘
-
-Click "Add secret"
-```
-
-### 4️⃣ Push to HuggingFace
-```bash
-git push hf main
-```
-
-### 5️⃣ Monitor Build
-```
-Watch logs at: https://huggingface.co/spaces/kshitijk20/nss
-
-Look for:
-✅ Prefect Cloud configured successfully
-✅ Initialization complete!
-✅ Starting FastAPI application...
-```
-
----
-
-## What Happens During Docker Build
-
-When you push to HuggingFace, Docker will:
-
-### Build Phase (Dockerfile)
-```dockerfile
-1. Install Python 3.13 slim
-2. Copy requirements.txt → Install packages
-   - fastapi, uvicorn
-   - prefect>=2.14.0
-   - evidently>=0.4.0
-   - scikit-learn, pandas, numpy
-3. Copy application code
-4. Create directories (monitoring/reports, final_model)
-5. Initialize SQLite database
-6. Run cloud_config.py (check for secrets)
-```
-
-### Startup Phase (startup.sh)
-```bash
-1. Check for PREFECT_API_KEY environment variable
-   ├─ If found: Configure Prefect Cloud connection
-   │  ├─ Set PREFECT_API_KEY
-   │  ├─ Set PREFECT_API_URL
-   │  └─ Verify connection: prefect cloud workspace ls
-   └─ If not found: Skip Prefect features
-
-2. Check for EVIDENTLY_CLOUD_TOKEN (optional)
-   ├─ If found: Enable Evidently Cloud
-   └─ If not found: Use open-source Evidently
-
-3. Create monitoring directories
-4. Start FastAPI application
-```
-
-### Runtime (app.py)
-```python
-1. Initialize cloud_config.py
-   - Load environment variables
-   - Configure Prefect/Evidently
-   
-2. Start FastAPI with endpoints:
-   GET  / → System status (shows cloud MLOps status)
-   GET  /train → Trigger training (can use Prefect)
-   POST /predict → Make predictions
-```
-
----
-
-## Secrets Configuration
-
-### Required (for Cloud MLOps)
-
-**PREFECT_API_KEY**
-- **What:** API key from Prefect Cloud
-- **Get it:** https://app.prefect.cloud/ → Profile → API Keys
-- **Purpose:** Connect HF Space to Prefect Cloud for orchestration
-- **Free:** Yes (Hobby tier: 2 users, 5 workflows, unlimited runs)
-
-### Optional (Advanced)
-
-**PREFECT_WORKSPACE**
-- **What:** Your Prefect workspace name
-- **Example:** `my-org/phishing-detection`
-- **Purpose:** Specify exact workspace (if you have multiple)
-
-**AUTO_DEPLOY_FLOWS**
-- **What:** `true` or `false`
-- **Purpose:** Auto-deploy Prefect flows on container start
-- **Default:** `false`
-
-**USE_PREFECT_FOR_TRAINING**
-- **What:** `true` or `false`
-- **Purpose:** Use Prefect Cloud when /train endpoint is called
-- **Default:** `false` (direct training)
-
-**EVIDENTLY_CLOUD_TOKEN**
-- **What:** Evidently Cloud API token (paid service)
-- **Get it:** https://www.evidentlyai.com/get-demo
-- **Purpose:** Centralized monitoring dashboard
-- **Note:** Open-source Evidently works without this
-
-**MONITORING_ENABLED**
-- **What:** `true` or `false`
-- **Purpose:** Enable/disable monitoring features
-- **Default:** `true`
-
-**DRIFT_CHECK_ENABLED**
-- **What:** `true` or `false`
-- **Purpose:** Automated drift detection on predictions
-- **Default:** `false`
-
----
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────┐
-│          HuggingFace Space (Container)              │
-│                                                     │
-│  ┌───────────────────────────────────────────────┐ │
-│  │ Environment Variables (Secrets from HF UI)    │ │
-│  │ • PREFECT_API_KEY=pnu_xxx                     │ │
-│  │ • AUTO_DEPLOY_FLOWS=true                      │ │
-│  └───────────────────────────────────────────────┘ │
-│                       ↓                             │
-│  ┌───────────────────────────────────────────────┐ │
-│  │ startup.sh (Container Initialization)         │ │
-│  │ • Configures Prefect Cloud                    │ │
-│  │ • Sets up Evidently                           │ │
-│  │ • Creates directories                         │ │
-│  └───────────────────────────────────────────────┘ │
-│                       ↓                             │
-│  ┌───────────────────────────────────────────────┐ │
-│  │ cloud_config.py (Python Configuration)        │ │
-│  │ • Reads env vars                              │ │
-│  │ • Initializes monitoring                      │ │
-│  └───────────────────────────────────────────────┘ │
-│                       ↓                             │
-│  ┌───────────────────────────────────────────────┐ │
-│  │ app.py (FastAPI Application)                  │ │
-│  │ • Serves predictions                          │ │
-│  │ • Training endpoint                           │ │
-│  │ • Reports status                              │ │
-│  └───────────────────────────────────────────────┘ │
-│                                                     │
-│  https://kshitijk20-nss.hf.space                   │
-└─────────────────────────────────────────────────────┘
-                        ↕
-┌─────────────────────────────────────────────────────┐
-│         Prefect Cloud (External Service)            │
-│  • Flow orchestration                               │
-│  • Scheduling (weekly training)                     │
-│  • Monitoring dashboard                             │
-│  • Execution logs                                   │
-│                                                     │
-│  https://app.prefect.cloud/                         │
-└─────────────────────────────────────────────────────┘
-```
-
----
-
-## Testing After Deployment
-
-### 1. Check System Status
-```bash
-curl https://kshitijk20-nss.hf.space/
-
-# Response should show:
-{
-  "status": "running",
-  "cloud_mlops": {
-    "prefect_cloud": "enabled",  # ✅ If API key configured
-    "evidently": "open-source",
-    "monitoring": "enabled"
-  }
-}
-```
-
-### 2. Test Training Endpoint
-```bash
-curl -X GET "https://kshitijk20-nss.hf.space/train"
-
-# With Prefect: "Training triggered via Prefect Cloud!"
-# Without: "Training successfull !!"
-```
-
-### 3. Check Prefect Cloud Dashboard
-```
-1. Go to: https://app.prefect.cloud/
-2. Navigate to "Flow Runs"
-3. You should see training executions from HF Space
-4. Click on a run to see logs and details
-```
-
-### 4. Test Prediction
-```bash
-curl -X POST "https://kshitijk20-nss.hf.space/predict" \
-  -F "file=@data/phisingData.csv"
-
-# Should return HTML table with predictions
-```
-
----
-
-## Build Logs Examples
-
-### ✅ Successful Build with Prefect Cloud
-```
-Building Docker image...
-Step 1/15 : FROM python:3.13-slim
-Step 2/15 : COPY requirements.txt
-Step 3/15 : RUN pip install -r requirements.txt
-...
-🚀 Starting Network Security System...
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ Prefect Cloud API Key detected
-🔧 Configuring Prefect Cloud connection...
-✅ Successfully connected to Prefect Cloud
-✅ Initialization complete!
-🌐 Starting FastAPI application...
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-INFO: Started server process
-INFO: Uvicorn running on http://0.0.0.0:7860
-```
-
-### ⚠️ Build without Secrets (Still Works)
-```
-🚀 Starting Network Security System...
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-ℹ️  No PREFECT_API_KEY found - Prefect Cloud features disabled
-   Set PREFECT_API_KEY in HuggingFace Space secrets to enable
-ℹ️  No EVIDENTLY_CLOUD_TOKEN - Using open-source Evidently
-✅ Initialization complete!
-🌐 Starting FastAPI application...
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-INFO: Started server process
-```
-
----
-
-## Troubleshooting
-
-### Secret not recognized
-**Symptom:** Logs show "No PREFECT_API_KEY found"
-**Fix:**
-1. Verify secret name is exactly `PREFECT_API_KEY` (case-sensitive)
-2. Check secret value has no extra spaces
-3. Rebuild Space: Settings → Factory reboot
-
-### Prefect connection fails
-**Symptom:** "Could not connect to Prefect Cloud"
-**Fix:**
-1. Test API key locally first:
-   ```bash
-   export PREFECT_API_KEY="your-key"
-   prefect cloud workspace ls
-   ```
-2. Regenerate key if expired
-3. Check HF Space has internet access (should be fine)
-
-### Builds but features don't work
-**Symptom:** App runs but cloud features inactive
-**Fix:**
-1. Check `/` endpoint response for cloud status
-2. Review build logs for initialization messages
-3. Ensure secrets were added BEFORE rebuild
-
----
-
-## Cost Summary
-
-| Service | Cost | What You Get |
-|---------|------|-------------|
-| **HuggingFace Spaces** | FREE | Docker hosting, public URL |
-| **Prefect Cloud** | FREE | 2 users, 5 workflows, unlimited runs |
-| **Evidently (Open Source)** | FREE | Local HTML reports, 100+ metrics |
-| **Evidently Cloud** | Paid | Centralized dashboard (optional) |
-
-**Total Cost: $0** for complete MLOps stack! 🎉
-
----
-
-## Next Steps
-
-After successful deployment:
-
-1. **Monitor Prefect Dashboard:** https://app.prefect.cloud/
-2. **Test API:** https://kshitijk20-nss.hf.space/docs
-3. **Review Documentation:** 
-   - [CLOUD_MLOPS_SETUP.md](CLOUD_MLOPS_SETUP.md) - Complete cloud setup
-   - [HF_SECRETS_SETUP.md](HF_SECRETS_SETUP.md) - Secrets reference
-4. **Set up Automations:** Configure failure alerts in Prefect
-5. **Schedule Training:** Deploy weekly training flow
-
----
-
-## Support Resources
-
-- **Prefect Cloud:** https://docs.prefect.io/latest/cloud/
-- **HuggingFace Spaces:** https://huggingface.co/docs/hub/spaces
-- **Evidently:** https://docs.evidentlyai.com/
-- **FastAPI:** https://fastapi.tiangolo.com/
-
----
-
-## Files Created for Cloud MLOps
-
-- ✅ **startup.sh** - Container initialization script
-- ✅ **cloud_config.py** - Cloud services configuration
-- ✅ **HF_SECRETS_SETUP.md** - Secrets documentation
-- ✅ **CLOUD_MLOPS_SETUP.md** - Complete cloud guide
-- ✅ **prepare_hf_deployment.py** - Deployment helper
-- ✅ **Dockerfile** - Updated with cloud setup
-- ✅ **app.py** - Integrated cloud features
-
-All ready for `git push hf main`! 🚀

Dockerfile

@@ -22,20 +22,13 @@ RUN pip install --no-cache-dir --upgrade -r requirements.txt
 COPY --chown=user . /app
 
 # Create necessary directories
-RUN mkdir -p /app/data /app/final_model /app/templates /app/monitoring/reports /app/prefect_flows
-
-# Make startup script executable
-RUN chmod +x /app/startup.sh
+RUN mkdir -p /app/data /app/final_model /app/templates
 
 # run the load_data_to_sqlite.py script to initialize the database
 RUN python load_data_to_sqlite.py
 
-# Run cloud configuration check (non-blocking)
-RUN python cloud_config.py || echo "Cloud config check completed"
-
 # Expose port 7860 (HF Space requirement)
 EXPOSE 7860
 
-# Use startup script to initialize cloud services, then start app
-ENTRYPOINT ["/app/startup.sh"]
+# Run the application
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

HF_SECRETS_SETUP.md

@@ -1,238 +0,0 @@
-# 🔐 HuggingFace Space Secrets Configuration
-
-To enable cloud MLOps features in your HuggingFace Space, add these secrets:
-
-## Required Secrets
-
-### 1. Prefect Cloud (Recommended)
-Add these to HuggingFace Space Settings → Repository secrets:
-
-```
-Name: PREFECT_API_KEY
-Value: <Your Prefect Cloud API Key>
-```
-
-**How to get:**
-1. Go to https://app.prefect.cloud/
-2. Click your profile (bottom left) → API Keys
-3. Click "Create API Key"
-4. Name it "HuggingFace-NSS"
-5. Copy the key and paste as secret
-
-### 2. Prefect Workspace (Optional)
-```
-Name: PREFECT_WORKSPACE
-Value: <Your workspace ID or name>
-```
-
-**How to get:**
-- In Prefect Cloud, go to workspace settings
-- Copy the workspace name (e.g., "my-workspace/phishing-detection")
-
-### 3. Auto-Deploy Flows (Optional)
-```
-Name: AUTO_DEPLOY_FLOWS
-Value: true
-```
-Set to `true` if you want flows automatically deployed on container start.
-
----
-
-## Optional Secrets
-
-### Evidently Cloud (For Enterprise Users)
-```
-Name: EVIDENTLY_CLOUD_TOKEN
-Value: <Your Evidently Cloud Token>
-```
-
-```
-Name: EVIDENTLY_PROJECT_ID
-Value: <Your Project ID>
-```
-
-**How to get:**
-- Contact Evidently AI for cloud access: https://www.evidentlyai.com/get-demo
-- They will provide token and project ID
-
-### Additional Configuration
-```
-Name: MONITORING_ENABLED
-Value: true (default)
-```
-
-```
-Name: DRIFT_CHECK_ENABLED
-Value: false (set to true for automated drift checks)
-```
-
----
-
-## How to Add Secrets to HuggingFace Space
-
-### Method 1: Web UI (Recommended)
-1. Go to your HuggingFace Space: https://huggingface.co/spaces/kshitijk20/nss
-2. Click **"Settings"** tab
-3. Scroll to **"Repository secrets"**
-4. Click **"Add a secret"**
-5. Enter **Name** and **Value**
-6. Click **"Add secret"**
-7. Rebuild your Space (Settings → Factory reboot)
-
-### Method 2: CLI
-```bash
-# Install HuggingFace CLI
-pip install huggingface_hub
-
-# Login
-huggingface-cli login
-
-# Add secret
-huggingface-cli space add-secret kshitijk20/nss PREFECT_API_KEY "your-api-key-here"
-```
-
----
-
-## Testing Configuration
-
-After adding secrets and rebuilding:
-
-1. **Check Logs:**
-   - Go to your Space → Logs tab
-   - Look for: "✅ Prefect Cloud configured successfully"
-
-2. **Verify Prefect Connection:**
-   - In Prefect Cloud dashboard: https://app.prefect.cloud/
-   - Check if deployments appear
-
-3. **Test Endpoints:**
-   ```bash
-   # Training endpoint
-   curl -X GET "https://kshitijk20-nss.hf.space/train"
-   
-   # Prediction endpoint  
-   curl -X POST "https://kshitijk20-nss.hf.space/predict" \
-     -F "file=@data/phisingData.csv"
-   ```
-
----
-
-## Environment Variables Summary
-
-| Variable | Required | Default | Purpose |
-|----------|----------|---------|---------|
-| `PREFECT_API_KEY` | ✅ Recommended | None | Connect to Prefect Cloud |
-| `PREFECT_API_URL` | ❌ | https://api.prefect.cloud/api | Prefect API endpoint |
-| `PREFECT_WORKSPACE` | ❌ | None | Specific workspace |
-| `AUTO_DEPLOY_FLOWS` | ❌ | false | Auto-deploy on startup |
-| `EVIDENTLY_CLOUD_TOKEN` | ❌ | None | Evidently Cloud (paid) |
-| `EVIDENTLY_PROJECT_ID` | ❌ | None | Evidently project |
-| `MONITORING_ENABLED` | ❌ | true | Enable monitoring |
-| `DRIFT_CHECK_ENABLED` | ❌ | false | Auto drift checks |
-
----
-
-## Architecture with Secrets
-
-```
-┌─────────────────────────────────────────────┐
-│     HuggingFace Space (Docker Container)    │
-│  ┌────────────────────────────────────────┐ │
-│  │  Environment Variables (Secrets)       │ │
-│  │  - PREFECT_API_KEY                     │ │
-│  │  - EVIDENTLY_CLOUD_TOKEN (optional)    │ │
-│  └────────────────────────────────────────┘ │
-│                    ↓                         │
-│  ┌────────────────────────────────────────┐ │
-│  │  startup.sh (Initialization)           │ │
-│  │  - Configures Prefect Cloud            │ │
-│  │  - Sets up Evidently                   │ │
-│  │  - Creates directories                 │ │
-│  └────────────────────────────────────────┘ │
-│                    ↓                         │
-│  ┌────────────────────────────────────────┐ │
-│  │  FastAPI App (app.py)                  │ │
-│  │  - Serves predictions                  │ │
-│  │  - Training endpoint                   │ │
-│  │  - Reports to Prefect Cloud            │ │
-│  └────────────────────────────────���───────┘ │
-└─────────────────────────────────────────────┘
-                    ↓
-┌─────────────────────────────────────────────┐
-│         Prefect Cloud (Monitoring)          │
-│  - Flow execution logs                      │
-│  - Training history                         │
-│  - Automated scheduling                     │
-└─────────────────────────────────────────────┘
-```
-
----
-
-## Troubleshooting
-
-### Secret not recognized
-**Problem:** Container doesn't see secret
-**Solution:** 
-- Verify secret name matches exactly (case-sensitive)
-- Rebuild Space (Settings → Factory reboot)
-- Check logs for initialization messages
-
-### Prefect connection fails
-**Problem:** "Could not connect to Prefect Cloud"
-**Solution:**
-- Verify API key is valid (test locally first)
-- Check PREFECT_API_URL is correct
-- Ensure network access from HF Spaces
-
-### Auto-deploy fails
-**Problem:** Flows not deploying automatically
-**Solution:**
-- Set `AUTO_DEPLOY_FLOWS=true`
-- Check prefect_flows/ directory exists
-- Review logs for deployment errors
-
----
-
-## Security Best Practices
-
-1. **Never commit secrets to git**
-   - Use `.gitignore` for local `.env` files
-   - Only use HF Space secrets feature
-
-2. **Rotate keys regularly**
-   - Update Prefect API key monthly
-   - Delete old unused keys
-
-3. **Use minimal permissions**
-   - Create separate API keys for different environments
-   - Limit key scope to required operations
-
-4. **Monitor access**
-   - Check Prefect Cloud audit logs
-   - Review Space access logs
-
----
-
-## Next Steps
-
-After configuration:
-
-1. **Test locally first:**
-   ```bash
-   export PREFECT_API_KEY="your-key"
-   python cloud_config.py
-   ```
-
-2. **Add to HuggingFace Space**
-3. **Rebuild and monitor logs**
-4. **Verify Prefect Cloud shows deployments**
-5. **Run training to test end-to-end**
-
----
-
-## Support
-
-- **Prefect Cloud:** https://docs.prefect.io/latest/cloud/
-- **HuggingFace Spaces:** https://huggingface.co/docs/hub/spaces
-- **Evidently:** https://docs.evidentlyai.com/
-- **Project Issues:** Report bugs in your GitHub repository

app.py

@@ -12,16 +12,6 @@ from starlette.responses import RedirectResponse
 import pandas as pd
 from src.utils.ml_utils.model.estimator import NetworkSecurityModel
 
-# Initialize cloud configuration
-try:
-    from cloud_config import initialize_monitoring, ENABLE_PREFECT
-    cloud_status = initialize_monitoring()
-    logging.info(f"Cloud MLOps initialized: {cloud_status}")
-except Exception as e:
-    logging.warning(f"Cloud config initialization failed: {e}")
-    ENABLE_PREFECT = False
-    cloud_status = {"prefect": False, "evidently": False}
-
 ca = certifi.where()
 load_dotenv()
 mongo_db_uri = os.getenv("MONGO_DB_URI")
@@ -58,11 +48,6 @@ async def root():
     return {
         "status": "running",
         "service": "Network Security System - Phishing Detection",
-        "cloud_mlops": {
-            "prefect_cloud": "enabled" if cloud_status.get("prefect") else "disabled",
-            "evidently": "cloud" if cloud_status.get("evidently") else "open-source",
-            "monitoring": "enabled" if cloud_status.get("monitoring") else "disabled"
-        },
         "endpoints": {
             "docs": "/docs",
             "train": "/train",
@@ -74,18 +59,9 @@ async def root():
 async def training_route():
     try: 
         logging.info("Starting training pipeline...")
-        
-        # Run training directly - Prefect Cloud monitoring happens in prefect_flows if needed
         training_pipeline = Trainingpipeline()
         training_pipeline.run_pipeline()
-        
-        status_msg = "✅ Training completed successfully!"
-        if ENABLE_PREFECT:
-            status_msg += "\n\n📊 Prefect Cloud connected - Run flows via prefect_flows/ directory"
-            status_msg += "\n   Dashboard: https://app.prefect.cloud/"
-        
-        return Response(status_msg)
-        return Response("Training completed successfully (direct mode)")
+        return Response("Training completed successfully!")
     except Exception as e:
         raise NetworkSecurityException(e, sys)
 

cloud_config.py

@@ -1,102 +0,0 @@
-"""
-Cloud MLOps Configuration for HuggingFace Spaces
-Handles Prefect Cloud and Evidently integration via environment variables
-"""
-import os
-import sys
-from pathlib import Path
-
-# Prefect Cloud Configuration
-PREFECT_API_KEY = os.getenv("PREFECT_API_KEY")
-PREFECT_API_URL = os.getenv("PREFECT_API_URL", "https://api.prefect.cloud/api")
-PREFECT_WORKSPACE = os.getenv("PREFECT_WORKSPACE")
-AUTO_DEPLOY_FLOWS = os.getenv("AUTO_DEPLOY_FLOWS", "false").lower() == "true"
-
-# Evidently Cloud Configuration (Optional)
-EVIDENTLY_CLOUD_TOKEN = os.getenv("EVIDENTLY_CLOUD_TOKEN") or os.getenv("EVIDENTLY_API_KEY")
-EVIDENTLY_PROJECT_ID = os.getenv("EVIDENTLY_PROJECT_ID")
-
-# Feature Flags
-ENABLE_PREFECT = PREFECT_API_KEY is not None
-ENABLE_EVIDENTLY_CLOUD = EVIDENTLY_CLOUD_TOKEN is not None
-
-# Monitoring Configuration
-MONITORING_ENABLED = os.getenv("MONITORING_ENABLED", "true").lower() == "true"
-DRIFT_CHECK_ENABLED = os.getenv("DRIFT_CHECK_ENABLED", "false").lower() == "true"
-
-def setup_prefect_cloud():
-    """Configure Prefect Cloud connection"""
-    if not ENABLE_PREFECT:
-        print("ℹ️  Prefect Cloud disabled - No API key provided")
-        return False
-    
-    try:
-        from prefect import settings
-        
-        print("🔧 Configuring Prefect Cloud...")
-        os.environ["PREFECT_API_KEY"] = PREFECT_API_KEY
-        os.environ["PREFECT_API_URL"] = PREFECT_API_URL
-        
-        if PREFECT_WORKSPACE:
-            os.environ["PREFECT_WORKSPACE"] = PREFECT_WORKSPACE
-        
-        print("✅ Prefect Cloud configured successfully")
-        return True
-    except Exception as e:
-        print(f"⚠️  Failed to configure Prefect Cloud: {e}")
-        return False
-
-def setup_evidently_cloud():
-    """Configure Evidently Cloud connection"""
-    if not ENABLE_EVIDENTLY_CLOUD:
-        print("ℹ️  Evidently Cloud disabled - Using open source version")
-        return False
-    
-    try:
-        os.environ["EVIDENTLY_CLOUD_TOKEN"] = EVIDENTLY_CLOUD_TOKEN
-        if EVIDENTLY_PROJECT_ID:
-            os.environ["EVIDENTLY_PROJECT_ID"] = EVIDENTLY_PROJECT_ID
-        
-        print("✅ Evidently Cloud configured successfully")
-        return True
-    except Exception as e:
-        print(f"⚠️  Failed to configure Evidently Cloud: {e}")
-        return False
-
-def initialize_monitoring():
-    """Initialize monitoring systems"""
-    print("\n" + "="*60)
-    print("🔧 Cloud MLOps Configuration")
-    print("="*60)
-    
-    # Setup Prefect
-    prefect_ok = setup_prefect_cloud()
-    
-    # Setup Evidently
-    evidently_ok = setup_evidently_cloud()
-    
-    # Create monitoring directories
-    Path("monitoring/reports").mkdir(parents=True, exist_ok=True)
-    Path("final_model").mkdir(parents=True, exist_ok=True)
-    
-    print("\n" + "="*60)
-    print("✅ Monitoring Configuration Summary")
-    print("="*60)
-    print(f"Prefect Cloud:     {'✅ Enabled' if prefect_ok else '❌ Disabled'}")
-    print(f"Evidently Cloud:   {'✅ Enabled' if evidently_ok else '❌ Open Source'}")
-    print(f"Drift Monitoring:  {'✅ Enabled' if DRIFT_CHECK_ENABLED else '❌ Disabled'}")
-    print("="*60 + "\n")
-    
-    return {
-        "prefect": prefect_ok,
-        "evidently": evidently_ok,
-        "monitoring": MONITORING_ENABLED
-    }
-
-if __name__ == "__main__":
-    # Run initialization
-    config = initialize_monitoring()
-    
-    # Print configuration for debugging
-    import json
-    print("Configuration:", json.dumps(config, indent=2))

monitoring/evidently_monitor.py

@@ -1,242 +0,0 @@
-"""
-Evidently Monitoring Module
-Tracks data drift, model performance, and data quality
-"""
-import pandas as pd
-from evidently.report import Report
-from evidently.metric_preset import DataDriftPreset, DataQualityPreset, TargetDriftPreset
-from evidently.metrics import *
-from datetime import datetime
-import json
-import os
-
-class PhishingModelMonitor:
-    """Monitor phishing detection model for drift and performance"""
-    
-    def __init__(self, reference_data_path="data/phisingData.csv"):
-        """
-        Initialize monitor with reference dataset
-        
-        Args:
-            reference_data_path: Path to the original training data
-        """
-        self.reference_data = pd.read_csv(reference_data_path)
-        self.reports_dir = "monitoring/reports"
-        os.makedirs(self.reports_dir, exist_ok=True)
-        
-        # Check for Evidently Cloud integration
-        self.evidently_cloud_token = os.getenv("EVIDENTLY_CLOUD_TOKEN") or os.getenv("EVIDENTLY_API_KEY")
-        self.evidently_project_id = os.getenv("EVIDENTLY_PROJECT_ID") or "nss"  # Default to "nss"
-        self.use_evidently_cloud = self.evidently_cloud_token is not None
-        
-        if self.use_evidently_cloud:
-            print(f"✅ Evidently Cloud integration enabled (Project: {self.evidently_project_id})")
-            try:
-                from evidently.ui.workspace.cloud import CloudWorkspace
-                # Initialize Evidently Cloud workspace
-                self.workspace = CloudWorkspace(
-                    token=self.evidently_cloud_token,
-                    url="https://app.evidently.cloud"
-                )
-                # Get or create project
-                try:
-                    self.project = self.workspace.get_project(self.evidently_project_id)
-                    print(f"✅ Connected to Evidently Cloud project: {self.evidently_project_id}")
-                except:
-                    # Project might be referenced by name, try to find it
-                    print(f"📦 Looking for project: {self.evidently_project_id}")
-                    self.project = None  # Will create reports without project reference
-                
-            except Exception as e:
-                print(f"⚠️  Evidently Cloud setup warning: {e}")
-                self.use_evidently_cloud = False
-        else:
-            print("ℹ️  Using Evidently open-source (local reports only)")
-    
-    def generate_data_drift_report(self, current_data: pd.DataFrame):
-        """
-        Generate data drift report comparing current data with reference
-        Saves locally AND pushes to Evidently Cloud if enabled
-        
-        Args:
-            current_data: Recent prediction data
-            
-        Returns:
-            Report object and saves HTML report
-        """
-        # Create drift report
-        report = Report(metrics=[
-            DataDriftPreset(),
-            DataQualityPreset(),
-        ])
-        
-        report.run(
-            reference_data=self.reference_data,
-            current_data=current_data
-        )
-        
-        # Save local HTML report
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        report_path = f"{self.reports_dir}/drift_report_{timestamp}.html"
-        report.save_html(report_path)
-        
-        # Push to Evidently Cloud if enabled
-        if self.use_evidently_cloud and self.project:
-            try:
-                self.workspace.add_report(self.project.id, report)
-                print(f"✅ Report pushed to Evidently Cloud: {self.evidently_project_id}")
-            except Exception as e:
-                print(f"⚠️  Failed to push to Evidently Cloud: {e}")
-        
-        # Extract metrics
-        report_json = report.as_dict()
-        
-        return {
-            "report_path": report_path,
-            "metrics": self._extract_drift_metrics(report_json),
-            "timestamp": timestamp
-        }
-    
-    def generate_model_performance_report(self, current_data: pd.DataFrame, 
-                                         predictions: pd.Series, 
-                                         actuals: pd.Series = None):
-        """
-        Generate model performance report
-        
-        Args:
-            current_data: Feature data
-            predictions: Model predictions
-            actuals: Actual labels (if available)
-        """
-        current_data = current_data.copy()
-        current_data['prediction'] = predictions
-        
-        if actuals is not None:
-            current_data['target'] = actuals
-            reference_data = self.reference_data.copy()
-            
-            # Create performance report
-            report = Report(metrics=[
-                ClassificationQualityMetric(),
-                ClassificationClassBalance(),
-                ClassificationConfusionMatrix(),
-                ClassificationQualityByClass()
-            ])
-            
-            report.run(
-                reference_data=reference_data,
-                current_data=current_data,
-                column_mapping={
-                    'target': 'Result',
-                    'prediction': 'prediction'
-                }
-            )
-        else:
-            # Only prediction drift if no actuals
-            report = Report(metrics=[
-                TargetDriftPreset(),
-            ])
-            
-            report.run(
-                reference_data=self.reference_data,
-                current_data=current_data,
-                column_mapping={'prediction': 'prediction'}
-            )
-        
-        # Save report
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        report_path = f"{self.reports_dir}/performance_report_{timestamp}.html"
-        report.save_html(report_path)
-        
-        return {
-            "report_path": report_path,
-            "timestamp": timestamp
-        }
-    
-    def _extract_drift_metrics(self, report_json):
-        """Extract key metrics from drift report"""
-        try:
-            metrics = report_json.get('metrics', [])
-            drift_summary = {
-                'dataset_drift': False,
-                'number_of_drifted_columns': 0,
-                'share_of_drifted_columns': 0.0,
-                'drifted_features': []
-            }
-            
-            for metric in metrics:
-                if metric.get('metric') == 'DatasetDriftMetric':
-                    result = metric.get('result', {})
-                    drift_summary['dataset_drift'] = result.get('dataset_drift', False)
-                    drift_summary['number_of_drifted_columns'] = result.get('number_of_drifted_columns', 0)
-                    drift_summary['share_of_drifted_columns'] = result.get('share_of_drifted_columns', 0.0)
-                    
-                    # Extract drifted features
-                    drift_by_columns = result.get('drift_by_columns', {})
-                    drift_summary['drifted_features'] = [
-                        col for col, info in drift_by_columns.items() 
-                        if info.get('drift_detected', False)
-                    ]
-                    break
-            
-            return drift_summary
-        except Exception as e:
-            return {"error": str(e)}
-    
-    def check_drift_threshold(self, drift_metrics, threshold=0.3):
-        """
-        Check if drift exceeds threshold
-        
-        Args:
-            drift_metrics: Output from generate_data_drift_report
-            threshold: Maximum acceptable share of drifted columns
-            
-        Returns:
-            bool: True if retraining is recommended
-        """
-        share_drifted = drift_metrics['metrics'].get('share_of_drifted_columns', 0)
-        return share_drifted > threshold
-    
-    def save_monitoring_state(self, metrics, filepath="monitoring/monitoring_state.json"):
-        """Save monitoring metrics to file"""
-        os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        
-        state = {
-            "last_check": datetime.now().isoformat(),
-            "metrics": metrics
-        }
-        
-        with open(filepath, 'w') as f:
-            json.dump(state, f, indent=2)
-
-
-# Utility function to monitor predictions
-def monitor_predictions(data_csv_path: str, reference_csv_path: str = "data/phisingData.csv"):
-    """
-    Quick function to monitor predictions from CSV
-    
-    Args:
-        data_csv_path: Path to CSV with recent predictions
-        reference_csv_path: Path to reference training data
-    """
-    monitor = PhishingModelMonitor(reference_csv_path)
-    current_data = pd.read_csv(data_csv_path)
-    
-    # Generate drift report
-    drift_result = monitor.generate_data_drift_report(current_data)
-    
-    print(f"📊 Drift Report Generated: {drift_result['report_path']}")
-    print(f"📈 Metrics: {drift_result['metrics']}")
-    
-    # Check if retraining needed
-    if monitor.check_drift_threshold(drift_result):
-        print("⚠️  WARNING: Significant drift detected! Retraining recommended.")
-    else:
-        print("✅ Drift within acceptable limits.")
-    
-    return drift_result
-
-
-if __name__ == "__main__":
-    # Example: Monitor predictions
-    monitor_predictions("final_model/predicted.csv")

prefect_flows/deploy_schedule.py

@@ -1,26 +0,0 @@
-"""
-Deploy Prefect flow with scheduling
-Run this script to create a scheduled deployment for automated training
-"""
-from prefect.deployments import Deployment
-from prefect.server.schemas.schedules import CronSchedule
-from training_flow import training_flow
-
-# Create deployment with weekly schedule (every Sunday at 2 AM)
-deployment = Deployment.build_from_flow(
-    flow=training_flow,
-    name="weekly-training",
-    schedule=CronSchedule(cron="0 2 * * 0", timezone="UTC"),  # Every Sunday at 2 AM UTC
-    work_queue_name="training",
-    tags=["production", "ml-training", "phishing-detection"],
-    description="Weekly automated retraining of phishing detection model",
-    version="1.0.0"
-)
-
-if __name__ == "__main__":
-    # Deploy the flow
-    deployment.apply()
-    print("✅ Deployment created successfully!")
-    print("📅 Schedule: Every Sunday at 2:00 AM UTC")
-    print("\nTo start the worker, run:")
-    print("  prefect agent start -q training")

prefect_flows/drift_monitoring_flow.py

@@ -1,96 +0,0 @@
-"""
-Example: Run Evidently monitoring on scheduled basis
-Can be integrated with Prefect for automated monitoring
-"""
-import sys
-sys.path.append('..')
-
-from monitoring.evidently_monitor import PhishingModelMonitor
-from prefect import flow, task
-from prefect.task_runners import ConcurrentTaskRunner
-import pandas as pd
-from src.logging.logger import logging
-
-@task(name="check_data_drift")
-def check_drift():
-    """Check for data drift in recent predictions"""
-    try:
-        logging.info("Checking for data drift...")
-        monitor = PhishingModelMonitor()
-        
-        # Load recent predictions
-        current_data = pd.read_csv("final_model/predicted.csv")
-        
-        # Generate drift report
-        drift_result = monitor.generate_data_drift_report(current_data)
-        
-        logging.info(f"Drift metrics: {drift_result['metrics']}")
-        
-        # Check if retraining needed
-        needs_retraining = monitor.check_drift_threshold(drift_result)
-        
-        if needs_retraining:
-            logging.warning("⚠️ Significant drift detected! Retraining recommended.")
-        else:
-            logging.info("✅ Drift within acceptable limits.")
-        
-        return {
-            "needs_retraining": needs_retraining,
-            "drift_metrics": drift_result['metrics'],
-            "report_path": drift_result['report_path']
-        }
-    except Exception as e:
-        logging.error(f"Drift monitoring failed: {str(e)}")
-        raise
-
-@task(name="trigger_retraining")
-def trigger_retraining():
-    """Trigger retraining pipeline if drift detected"""
-    try:
-        from training_flow import training_flow
-        logging.info("Triggering retraining due to drift...")
-        
-        # Run training flow
-        result = training_flow()
-        
-        logging.info(f"Retraining completed: {result}")
-        return result
-    except Exception as e:
-        logging.error(f"Retraining failed: {str(e)}")
-        raise
-
-@flow(
-    name="drift-monitoring-flow",
-    description="Monitor data drift and trigger retraining if needed",
-    task_runner=ConcurrentTaskRunner()
-)
-def drift_monitoring_flow():
-    """
-    Main flow for drift monitoring
-    Checks drift and triggers retraining if threshold exceeded
-    """
-    logging.info("="*50)
-    logging.info("Starting Drift Monitoring Flow")
-    logging.info("="*50)
-    
-    # Check drift
-    drift_result = check_drift()
-    
-    # Trigger retraining if needed
-    if drift_result["needs_retraining"]:
-        training_result = trigger_retraining()
-        return {
-            "status": "retraining_triggered",
-            "drift": drift_result,
-            "training": training_result
-        }
-    else:
-        return {
-            "status": "no_action_needed",
-            "drift": drift_result
-        }
-
-if __name__ == "__main__":
-    # Run monitoring flow
-    result = drift_monitoring_flow()
-    print(f"\n📊 Monitoring Result: {result}")

prefect_flows/training_flow.py

@@ -1,85 +0,0 @@
-"""
-Prefect Flow for Automated Model Training
-Orchestrates the complete training pipeline with scheduling
-"""
-import sys
-from prefect import flow, task
-from prefect.task_runners import ConcurrentTaskRunner
-from datetime import timedelta
-import logging
-
-# Add project root to path
-sys.path.append('..')
-from src.pipeline.training_pipeline import Trainingpipeline
-from src.exception.exception import NetworkSecurityException
-from src.logging.logger import logging as app_logger
-
-@task(name="run_training_pipeline", retries=2, retry_delay_seconds=60)
-def train_model():
-    """
-    Task to run the complete training pipeline
-    """
-    try:
-        app_logger.info("Starting training pipeline via Prefect")
-        training_pipeline = Trainingpipeline()
-        training_pipeline.run_pipeline()
-        app_logger.info("Training pipeline completed successfully")
-        return {"status": "success", "message": "Model trained successfully"}
-    except Exception as e:
-        app_logger.error(f"Training pipeline failed: {str(e)}")
-        raise NetworkSecurityException(e, sys)
-
-@task(name="validate_model")
-def validate_model():
-    """
-    Task to validate the trained model
-    """
-    try:
-        from src.utils.main_utils.utils import load_object
-        
-        app_logger.info("Validating trained model")
-        model = load_object("final_model/model.pkl")
-        preprocessor = load_object("final_model/preprocessor.pkl")
-        
-        if model is None or preprocessor is None:
-            raise ValueError("Model or preprocessor not found")
-        
-        app_logger.info("Model validation successful")
-        return {"status": "success", "message": "Model validated"}
-    except Exception as e:
-        app_logger.error(f"Model validation failed: {str(e)}")
-        raise
-
-@flow(
-    name="phishing-detection-training",
-    description="Automated training pipeline for phishing detection model",
-    task_runner=ConcurrentTaskRunner()
-)
-def training_flow():
-    """
-    Main Prefect flow for training orchestration
-    """
-    logging.info("="*50)
-    logging.info("Starting Phishing Detection Training Flow")
-    logging.info("="*50)
-    
-    # Step 1: Train model
-    train_result = train_model()
-    logging.info(f"Training result: {train_result}")
-    
-    # Step 2: Validate model
-    validation_result = validate_model()
-    logging.info(f"Validation result: {validation_result}")
-    
-    logging.info("="*50)
-    logging.info("Training flow completed successfully!")
-    logging.info("="*50)
-    
-    return {
-        "training": train_result,
-        "validation": validation_result
-    }
-
-if __name__ == "__main__":
-    # Run the flow locally
-    training_flow()

requirements.txt

@@ -11,8 +11,4 @@ dagshub
 fastapi 
 uvicorn 
 python-multipart
-# Orchestration
-prefect>=2.14.0
-# Monitoring
-evidently>=0.4.0
 # -e .

setup_cloud_mlops.py

@@ -1,151 +0,0 @@
-"""
-Quick Setup Script for Prefect Cloud + Evidently
-Run this after getting your Prefect Cloud API key
-"""
-import subprocess
-import sys
-
-def run_command(command, description):
-    """Run a command and print result"""
-    print(f"\n{'='*60}")
-    print(f"🔧 {description}")
-    print(f"{'='*60}")
-    try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
-        print(result.stdout)
-        if result.returncode != 0:
-            print(f"❌ Error: {result.stderr}")
-            return False
-        return True
-    except Exception as e:
-        print(f"❌ Exception: {e}")
-        return False
-
-def main():
-    print("""
-    ╔══════════════════════════════════════════════════════════╗
-    ║   Prefect Cloud + Evidently Setup for NSS Project       ║
-    ╚══════════════════════════════════════════════════════════╝
-    
-    Prerequisites:
-    1. Created Prefect Cloud account at https://app.prefect.cloud/
-    2. Generated API key from dashboard
-    3. Virtual environment activated (.venv)
-    
-    """)
-    
-    input("Press Enter to continue...")
-    
-    # Step 1: Check Prefect installation
-    if not run_command("prefect --version", "Checking Prefect installation"):
-        print("\n❌ Prefect not installed. Run: pip install prefect>=2.14.0")
-        return
-    
-    # Step 2: Check Evidently installation
-    if not run_command("python -c \"import evidently; print(f'Evidently {evidently.__version__}')\"", 
-                      "Checking Evidently installation"):
-        print("\n❌ Evidently not installed. Run: pip install evidently>=0.4.0")
-        return
-    
-    # Step 3: Login to Prefect Cloud
-    print("\n" + "="*60)
-    print("🔑 Prefect Cloud Login")
-    print("="*60)
-    print("Please paste your Prefect Cloud API key when prompted...")
-    print("(Get it from: https://app.prefect.cloud/ → Profile → API Keys)")
-    
-    if not run_command("prefect cloud login", "Logging into Prefect Cloud"):
-        print("\n❌ Login failed. Please check your API key.")
-        return
-    
-    # Step 4: Verify connection
-    if not run_command("prefect cloud workspace ls", "Verifying Prefect Cloud connection"):
-        print("\n❌ Could not connect to Prefect Cloud.")
-        return
-    
-    # Step 5: Create deployments
-    print("\n" + "="*60)
-    print("📦 Creating Prefect Deployments")
-    print("="*60)
-    
-    deploy_result = subprocess.run(
-        "cd prefect_flows && python deploy_schedule.py",
-        shell=True,
-        capture_output=True,
-        text=True
-    )
-    
-    if deploy_result.returncode == 0:
-        print("✅ Weekly training deployment created!")
-        print(deploy_result.stdout)
-    else:
-        print(f"⚠️  Deployment creation skipped or failed: {deploy_result.stderr}")
-    
-    # Step 6: Test Evidently
-    print("\n" + "="*60)
-    print("📊 Testing Evidently Monitoring")
-    print("="*60)
-    
-    test_result = subprocess.run(
-        "python test_evidently.py",
-        shell=True,
-        capture_output=True,
-        text=True
-    )
-    
-    if test_result.returncode == 0:
-        print("✅ Evidently reports generated successfully!")
-        print("Check monitoring/reports/ for HTML files")
-    else:
-        print(f"⚠️  Evidently test failed: {test_result.stderr}")
-    
-    # Final Instructions
-    print("""
-    
-    ╔══════════════════════════════════════════════════════════╗
-    ║                  Setup Complete! 🎉                      ║
-    ╚══════════════════════════════════════════════════════════╝
-    
-    📋 NEXT STEPS:
-    
-    1. Start Prefect Worker (keep running):
-       Command: prefect agent start -q training
-    
-    2. View Dashboard:
-       URL: https://app.prefect.cloud/
-    
-    3. Run Training Flow (test):
-       Command: cd prefect_flows && python training_flow.py
-    
-    4. Run Drift Monitoring (test):
-       Command: cd prefect_flows && python drift_monitoring_flow.py
-    
-    5. Check Evidently Reports:
-       Location: monitoring/reports/*.html
-    
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    
-    📚 DOCUMENTATION:
-    - Full guide: CLOUD_MLOPS_SETUP.md
-    - Prefect Cloud: https://docs.prefect.io/latest/cloud/
-    - Evidently: https://docs.evidentlyai.com/
-    
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━��━━━━━━━━━━━━━━━━━━━━━━━
-    
-    ⚡ QUICK TEST:
-    Open a new terminal and run:
-    
-    Terminal 1 (Worker):
-    > prefect agent start -q training
-    
-    Terminal 2 (Test Flow):
-    > cd prefect_flows
-    > python training_flow.py
-    
-    Then check: https://app.prefect.cloud/ to see your flow run!
-    
-    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    """)
-
-if __name__ == "__main__":
-    main()

startup.sh

@@ -1,66 +0,0 @@
-#!/bin/bash
-# Startup script for HuggingFace Space
-# Initializes Prefect Cloud and Evidently monitoring
-
-set -e
-
-echo "🚀 Starting Network Security System..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Check if Prefect Cloud API key is provided
-if [ -n "$PREFECT_API_KEY" ]; then
-    echo "✅ Prefect Cloud API Key detected"
-    echo "🔧 Configuring Prefect Cloud connection..."
-    
-    # Set Prefect Cloud API URL (default to cloud)
-    export PREFECT_API_URL="${PREFECT_API_URL:-https://api.prefect.cloud/api}"
-    
-    # Configure Prefect
-    prefect config set PREFECT_API_KEY="$PREFECT_API_KEY"
-    prefect config set PREFECT_API_URL="$PREFECT_API_URL"
-    
-    # Verify connection
-    if prefect cloud workspace ls 2>/dev/null; then
-        echo "✅ Successfully connected to Prefect Cloud"
-        
-        # Optional: Auto-deploy flows if enabled
-        if [ "$AUTO_DEPLOY_FLOWS" = "true" ]; then
-            echo "📦 Auto-deploying Prefect flows..."
-            cd /app/prefect_flows
-            python deploy_schedule.py || echo "⚠️  Flow deployment skipped"
-            cd /app
-        fi
-    else
-        echo "⚠️  Warning: Could not connect to Prefect Cloud"
-        echo "   Prefect features will be limited"
-    fi
-else
-    echo "ℹ️  No PREFECT_API_KEY found - Prefect Cloud features disabled"
-    echo "   Set PREFECT_API_KEY in HuggingFace Space secrets to enable"
-fi
-
-# Check if Evidently Cloud token is provided (optional)
-if [ -n "$EVIDENTLY_API_KEY" ]; then
-    echo "✅ Evidently Cloud Token detected"
-    export EVIDENTLY_API_KEY="$EVIDENTLY_API_KEY"
-    echo "🔧 Evidently Cloud integration enabled"
-else
-    echo "ℹ️  No EVIDENTLY_API_KEY - Using open-source Evidently"
-fi
-
-# Create necessary directories
-echo "📁 Creating directories..."
-mkdir -p /app/monitoring/reports
-mkdir -p /app/final_model
-mkdir -p /app/logs
-
-# Set permissions
-chmod +x /app/app.py 2>/dev/null || true
-
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "✅ Initialization complete!"
-echo "🌐 Starting FastAPI application..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Start the application
-exec "$@"

trigger_prefect_training.py

@@ -1,14 +0,0 @@
-"""
-Trigger Prefect training flow manually
-Use this to run training through Prefect Cloud from command line
-"""
-import sys
-sys.path.append('.')
-
-from prefect_flows.training_flow import training_flow
-
-if __name__ == "__main__":
-    print("🚀 Starting training via Prefect Cloud...")
-    result = training_flow()
-    print(f"✅ Training completed: {result}")
-    print("📊 Check Prefect Cloud dashboard: https://app.prefect.cloud/")