initial commit

.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+.venv/
+venv/
+ENV/
+
+# AI Models (these will be generated)
+*.pkl
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

DEPLOYMENT.md

@@ -0,0 +1,49 @@
+# 🚀 Deploy to Hugging Face Spaces
+
+## Target URL: https://huggingface.co/spaces/rishirajpathak/task-management
+
+## Quick Deployment Steps
+
+1. **Go to**: https://huggingface.co/new-space
+2. **Space name**: `task-management` 
+3. **Owner**: `rishirajpathak`
+4. **License**: MIT
+5. **SDK**: Gradio
+6. **Hardware**: CPU (free tier)
+
+## Files to Upload (All Required)
+
+Upload these files from your D:\Task Management folder:
+
+### ✅ Core System
+- `app.py` - Main Gradio interface
+- `assignment_engine.py` - AI engine
+- `task_manager.py` - System controller
+- `requirements.txt` - Dependencies  
+
+### ✅ Data Files
+- `users.csv` - Team members
+- `tasks.csv` - Task definitions  
+- `results.csv` - Completion history
+- `task_progress.json` - Progress tracking
+
+### ✅ Documentation
+- `README.md` - Space description
+- `.gitignore` - Git ignore rules
+
+## ⚠️ DO NOT Upload
+- `.venv/` folder (virtual environment)
+- `assignment_model.pkl` (will be auto-generated)
+- Any `__pycache__/` folders
+
+## After Upload
+1. Space will auto-build from requirements.txt
+2. App will be available at: https://huggingface.co/spaces/rishirajpathak/task-management
+3. First run will create the AI model automatically
+
+## Testing the Deployed App
+1. Add users and tasks
+2. Get AI assignments  
+3. Update progress
+4. Complete tasks
+5. Retrain AI - system improves!

README.md

@@ -0,0 +1,73 @@
+---
+title: AI Task Assignment System
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🧠 AI Task Assignment System
+
+A self-learning task assignment engine that automatically optimizes team productivity by learning from real task completion results.
+
+## 🎯 What This System Does
+
+- **Enter People & Tasks**: Add team members and work items
+- **AI Decides Assignments**: Optimal matching based on learned patterns  
+- **System Learns**: From real completion results (time, quality)
+- **Gets Smarter**: Continuous improvement with each task
+
+## ✨ Key Features
+
+- **Zero-bias assignments** based on real performance data
+- **Universal application** - works for any task type (coding, design, research, etc.)
+- **Real-time progress tracking** with notes and updates
+- **Automatic skill discovery** - learns who's good at what
+- **Burnout prevention** through workload analysis
+- **Self-improving AI** that gets better with more data
+
+## 🚀 How to Use
+
+1. **Add Users**: Start with your team members
+2. **Add Tasks**: Enter work items with complexity (0-1) and deadline (hours)
+3. **Get Assignments**: AI recommends optimal person for each task
+4. **Track Progress**: Update task progress and add notes
+5. **Complete Tasks**: Enter time taken and quality score (1-5)
+6. **Retrain AI**: System learns and improves future assignments
+
+## 🧠 The Learning Process
+
+Initially assigns tasks randomly (no data), but learns from every completion:
+- User skill patterns
+- Task complexity preferences  
+- Time efficiency trends
+- Quality consistency
+- Workload capacity
+
+## 📊 Real-World Applications
+
+- **Software Teams**: Frontend, backend, testing assignments
+- **Study Groups**: Subject-based task distribution
+- **Project Management**: Optimal resource allocation
+- **Any Team Environment**: Universal skill-based matching
+
+## 🔄 Self-Learning Cycle
+
+```
+Add People & Tasks → AI Assigns → Work Completed → 
+Enter Results → AI Learns → Better Assignments
+```
+
+**Result**: Maximum efficiency, minimum burnout, automatic skill discovery.
+
+## 🛠️ Technical Details
+
+- **AI Model**: Random Forest Regressor (scikit-learn)
+- **Features**: User ID, task complexity, deadline pressure
+- **Target**: Success score (quality × efficiency)
+- **Framework**: Gradio for web interface
+- **Data**: CSV files for users, tasks, results, JSON for progress tracking

app.py

@@ -0,0 +1,241 @@
+import gradio as gr
+import pandas as pd
+from task_manager import TaskManager
+import os
+
+# Initialize the task manager
+tm = TaskManager()
+
+def show_dashboard():
+    """Display system dashboard"""
+    try:
+        # Capture dashboard information
+        stats = []
+        
+        # Basic stats
+        if len(tm.engine.results) > 0:
+            stats.append(f"📊 **SYSTEM STATISTICS**")
+            stats.append(f"- Total completed tasks: {len(tm.engine.results)}")
+            stats.append(f"- Average quality: {tm.engine.results['quality'].mean():.2f}/5")
+            stats.append(f"- Average time: {tm.engine.results['time_taken'].mean():.1f}h")
+        else:
+            stats.append("📊 No results yet - system ready for assignments")
+            
+        # User performance
+        if len(tm.engine.results) > 0:
+            user_stats = tm.engine.results.merge(tm.engine.users, on='user_id').groupby('name').agg({
+                'quality': 'mean',
+                'time_taken': 'mean',
+                'task_id': 'count'
+            }).round(2)
+            
+            stats.append("\n👥 **USER PERFORMANCE**")
+            for user, row in user_stats.iterrows():
+                stats.append(f"- {user}: {row['quality']:.1f}/5 quality, {row['time_taken']:.1f}h avg, {int(row['task_id'])} tasks")
+        
+        # Active tasks
+        if hasattr(tm.engine, 'progress_data') and tm.engine.progress_data:
+            active_tasks = [task for task in tm.engine.progress_data.values() 
+                           if task['status'] in ['assigned', 'in_progress']]
+            if active_tasks:
+                stats.append("\n📋 **ACTIVE TASKS**")
+                for task in active_tasks:
+                    status_icon = "🔄" if task['status'] == 'in_progress' else "📋"
+                    stats.append(f"{status_icon} Task {task['task_id']}: {task['user_name']} → {task['task_type']}")
+        
+        # AI status
+        ai_status = "🤖 **AI Status**: " + ("Trained ✅" if tm.engine.is_trained else "Random Assignment ⚠️")
+        stats.append(f"\n{ai_status}")
+        
+        return "\n".join(stats)
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def assign_tasks():
+    """Assign pending tasks"""
+    try:
+        assignments = []
+        
+        for _, task in tm.engine.tasks.iterrows():
+            task_id = task['task_id']
+            
+            # Check if task already completed
+            completed = tm.engine.results[tm.engine.results['task_id'] == task_id]
+            if len(completed) > 0:
+                continue
+                
+            user_id, user_name = tm.engine.assign_task(task_id)
+            if user_name:
+                assignments.append(f"✅ Task {task_id} ({task['type']}) assigned to {user_name}")
+        
+        if not assignments:
+            return "📋 No pending tasks to assign"
+            
+        return "\n".join(assignments)
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def add_user(name):
+    """Add new user"""
+    try:
+        if not name.strip():
+            return "❌ Please enter a valid name"
+            
+        tm.add_user(name.strip())
+        return f"✅ Added user: {name.strip()}"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def add_task(task_type, complexity, deadline):
+    """Add new task"""
+    try:
+        if not task_type.strip():
+            return "❌ Please enter a task type"
+        if not (0 <= complexity <= 1):
+            return "❌ Complexity must be between 0 and 1"
+        if deadline <= 0:
+            return "❌ Deadline must be positive"
+            
+        tm.add_task(task_type.strip(), complexity, deadline)
+        return f"✅ Added task: {task_type.strip()} (Complexity: {complexity}, Deadline: {deadline}h)"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def update_progress(task_id, user_id, progress, notes):
+    """Update task progress"""
+    try:
+        if not (0 <= progress <= 100):
+            return "❌ Progress must be between 0 and 100"
+            
+        tm.update_progress(int(task_id), int(user_id), int(progress), notes.strip())
+        return f"✅ Updated progress: Task {task_id} → {progress}%"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def complete_task(task_id, user_id, time_taken, quality):
+    """Complete a task"""
+    try:
+        if not (1 <= quality <= 5):
+            return "❌ Quality must be between 1 and 5"
+        if time_taken <= 0:
+            return "❌ Time taken must be positive"
+            
+        tm.enter_result(int(task_id), int(user_id), float(time_taken), int(quality))
+        return f"✅ Task {task_id} completed successfully"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def retrain_ai():
+    """Retrain the AI model"""
+    try:
+        tm.retrain_ai()
+        return "✅ AI model retrained successfully"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def get_users_list():
+    """Get list of users for dropdowns"""
+    try:
+        return [(f"{row['user_id']} - {row['name']}", row['user_id']) for _, row in tm.engine.users.iterrows()]
+    except:
+        return []
+
+def get_tasks_list():
+    """Get list of tasks for dropdowns"""
+    try:
+        return [(f"Task {row['task_id']} - {row['type']}", row['task_id']) for _, row in tm.engine.tasks.iterrows()]
+    except:
+        return []
+
+# Create Gradio interface
+with gr.Blocks(title="🧠 AI Task Assignment System") as app:
+    gr.Markdown("""
+    # 🧠 AI Task Assignment System
+    
+    **Self-learning task assignment engine that gets smarter with every completed task!**
+    
+    - 🎯 Enter people and tasks
+    - 🤖 AI decides optimal assignments  
+    - 📊 System learns from real results
+    - 📈 Continuous improvement
+    """)
+    
+    with gr.Tabs():
+        # Dashboard Tab
+        with gr.Tab("📊 Dashboard"):
+            dashboard_btn = gr.Button("🔄 Refresh Dashboard", variant="primary")
+            dashboard_output = gr.Markdown()
+            dashboard_btn.click(show_dashboard, outputs=dashboard_output)
+        
+        # Assignment Tab
+        with gr.Tab("🎯 Task Assignment"):
+            gr.Markdown("### Assign pending tasks to optimal users")
+            assign_btn = gr.Button("🎯 Assign Tasks", variant="primary") 
+            assign_output = gr.Markdown()
+            assign_btn.click(assign_tasks, outputs=assign_output)
+        
+        # Add User Tab
+        with gr.Tab("👤 Add User"):
+            gr.Markdown("### Add new team member")
+            user_name = gr.Textbox(label="User Name", placeholder="Enter name...")
+            add_user_btn = gr.Button("➕ Add User", variant="primary")
+            add_user_output = gr.Markdown()
+            add_user_btn.click(add_user, inputs=user_name, outputs=add_user_output)
+        
+        # Add Task Tab  
+        with gr.Tab("📋 Add Task"):
+            gr.Markdown("### Add new task")
+            with gr.Row():
+                task_type = gr.Textbox(label="Task Type", placeholder="e.g., coding, design, research...")
+                task_complexity = gr.Slider(0, 1, value=0.5, label="Complexity (0=Easy, 1=Hard)")
+                task_deadline = gr.Number(label="Deadline (hours)", value=24)
+            add_task_btn = gr.Button("➕ Add Task", variant="primary")
+            add_task_output = gr.Markdown()
+            add_task_btn.click(add_task, inputs=[task_type, task_complexity, task_deadline], outputs=add_task_output)
+        
+        # Progress Update Tab
+        with gr.Tab("📈 Update Progress"):
+            gr.Markdown("### Update task progress")
+            with gr.Row():
+                prog_task_id = gr.Number(label="Task ID", precision=0)
+                prog_user_id = gr.Number(label="User ID", precision=0) 
+                progress_pct = gr.Slider(0, 100, value=50, label="Progress %")
+            progress_notes = gr.Textbox(label="Notes (optional)", placeholder="Progress notes...")
+            update_prog_btn = gr.Button("📈 Update Progress", variant="primary")
+            update_prog_output = gr.Markdown()
+            update_prog_btn.click(update_progress, inputs=[prog_task_id, prog_user_id, progress_pct, progress_notes], outputs=update_prog_output)
+        
+        # Complete Task Tab
+        with gr.Tab("✅ Complete Task"):
+            gr.Markdown("### Mark task as completed")
+            with gr.Row():
+                comp_task_id = gr.Number(label="Task ID", precision=0)
+                comp_user_id = gr.Number(label="User ID", precision=0)
+                time_taken = gr.Number(label="Time Taken (hours)", value=1)
+                quality_score = gr.Slider(1, 5, value=3, label="Quality (1=Poor, 5=Excellent)", step=1)
+            complete_btn = gr.Button("✅ Complete Task", variant="primary")
+            complete_output = gr.Markdown()
+            complete_btn.click(complete_task, inputs=[comp_task_id, comp_user_id, time_taken, quality_score], outputs=complete_output)
+        
+        # AI Training Tab
+        with gr.Tab("🧠 AI Training"):
+            gr.Markdown("""
+            ### Retrain AI Model
+            After completing tasks and entering results, retrain the AI to improve future assignments.
+            """)
+            retrain_btn = gr.Button("🧠 Retrain AI", variant="primary")
+            retrain_output = gr.Markdown()
+            retrain_btn.click(retrain_ai, outputs=retrain_output)
+
+    # Auto-load dashboard on startup
+    app.load(show_dashboard, outputs=dashboard_output)
+
+if __name__ == "__main__":
+    app.launch(share=True, theme=gr.themes.Soft())

assignment_engine.py

@@ -0,0 +1,306 @@
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+import joblib
+import os
+from datetime import datetime
+import json
+
+class TaskAssignmentEngine:
+    def __init__(self):
+        self.model = None
+        self.is_trained = False
+        self.results_file = "results.csv"
+        self.progress_file = "task_progress.json"
+        
+    def load_data(self):
+        """Load users, tasks, and results"""
+        self.users = pd.read_csv("users.csv")
+        self.tasks = pd.read_csv("tasks.csv")
+        
+        # Load results if exists
+        if os.path.exists(self.results_file):
+            self.results = pd.read_csv(self.results_file)
+        else:
+            # Create empty results file
+            self.results = pd.DataFrame(columns=['task_id', 'user_id', 'time_taken', 'quality'])
+            self.results.to_csv(self.results_file, index=False)
+            
+        # Load progress tracking
+        if os.path.exists(self.progress_file):
+            with open(self.progress_file, 'r') as f:
+                self.progress_data = json.load(f)
+        else:
+            self.progress_data = {}
+            self.save_progress_data()
+            
+        print(f"✅ Loaded {len(self.users)} users, {len(self.tasks)} tasks, {len(self.results)} results")
+        
+    def prepare_training_data(self):
+        """Convert results into training data for AI"""
+        if len(self.results) == 0:
+            print("⚠️  No results data - will use random assignment")
+            return None, None
+            
+        # Merge results with task and user data
+        training_data = self.results.merge(self.tasks, on='task_id').merge(self.users, on='user_id')
+        
+        # Create features: user_id, complexity, deadline
+        X = training_data[['user_id', 'complexity', 'deadline']].values
+        
+        # Create target: success score (quality/5 * efficiency)
+        # efficiency = 1 - (time_taken / deadline) 
+        efficiency = 1 - (training_data['time_taken'] / training_data['deadline'])
+        efficiency = np.clip(efficiency, 0, 1)  # Keep between 0-1
+        
+        quality_score = training_data['quality'] / 5.0  # Normalize to 0-1
+        
+        # Success = weighted combination of quality and efficiency
+        y = (quality_score * 0.7 + efficiency * 0.3)  # 70% quality, 30% efficiency
+        
+        print(f"✅ Prepared training data: {len(X)} samples")
+        return X, y
+    
+    def train_model(self):
+        """Train the AI model"""
+        X, y = self.prepare_training_data()
+        
+        if X is None:
+            print("⚠️  No training data available")
+            return
+            
+        # Train Random Forest model
+        self.model = RandomForestRegressor(n_estimators=100, random_state=42)
+        self.model.fit(X, y)
+        self.is_trained = True
+        
+        # Save model
+        joblib.dump(self.model, 'assignment_model.pkl')
+        print("✅ Model trained and saved")
+        
+    def load_model(self):
+        """Load existing model if available"""
+        if os.path.exists('assignment_model.pkl'):
+            self.model = joblib.load('assignment_model.pkl')
+            self.is_trained = True
+            print("✅ Loaded existing model")
+        
+    def predict_success(self, user_id, task_row):
+        """Predict success probability for user-task combination"""
+        if not self.is_trained:
+            # Random assignment if no model
+            return np.random.random()
+            
+        features = [[user_id, task_row['complexity'], task_row['deadline']]]
+        prediction = self.model.predict(features)[0]
+        return max(0, min(1, prediction))  # Ensure 0-1 range
+        
+    def assign_task(self, task_id):
+        """Assign a task to the best user"""
+        task_row = self.tasks[self.tasks['task_id'] == task_id].iloc[0]
+        
+        best_user = None
+        best_score = -1
+        predictions = {}
+        
+        for _, user in self.users.iterrows():
+            user_id = user['user_id']
+            
+            # Skip if user already has this task assigned
+            existing = self.results[
+                (self.results['task_id'] == task_id) & 
+                (self.results['user_id'] == user_id)
+            ]
+            if len(existing) > 0:
+                continue
+                
+            score = self.predict_success(user_id, task_row)
+            predictions[user['name']] = score
+            
+            if score > best_score:
+                best_score = score
+                best_user = user
+                
+        print(f"\n🎯 Task {task_id} ({task_row['type']}) - Complexity: {task_row['complexity']}")
+        print("Predictions:")
+        for name, score in predictions.items():
+            print(f"  {name}: {score:.3f}")
+            
+        if best_user is not None:
+            print(f"✅ ASSIGNED to {best_user['name']} (confidence: {best_score:.3f})")
+            # Track assignment
+            self.start_task_tracking(task_id, best_user['user_id'], best_user['name'])
+            return best_user['user_id'], best_user['name']
+        else:
+            print(f"❌ No available users for this task")
+            return None, None
+            
+    def save_progress_data(self):
+        """Save progress data to JSON file"""
+        with open(self.progress_file, 'w') as f:
+            json.dump(self.progress_data, f, indent=2, default=str)
+            
+    def start_task_tracking(self, task_id, user_id, user_name):
+        """Start tracking a task"""
+        task_key = f"{task_id}_{user_id}"
+        task_info = self.tasks[self.tasks['task_id'] == task_id].iloc[0]
+        
+        self.progress_data[task_key] = {
+            'task_id': task_id,
+            'user_id': user_id,
+            'user_name': user_name,
+            'task_type': task_info['type'],
+            'complexity': task_info['complexity'],
+            'deadline': task_info['deadline'],
+            'start_time': datetime.now().isoformat(),
+            'status': 'assigned',
+            'progress_updates': [],
+            'completion_time': None
+        }
+        self.save_progress_data()
+        print(f"⏱️ Started tracking: {user_name} → {task_info['type']} (Task {task_id})")
+        
+    def update_task_progress(self, task_id, user_id, progress_percent, notes=""):
+        """Update task progress"""
+        task_key = f"{task_id}_{user_id}"
+        
+        if task_key not in self.progress_data:
+            print(f"❌ Task {task_id} for user {user_id} not found in tracking")
+            return
+            
+        update = {
+            'timestamp': datetime.now().isoformat(),
+            'progress_percent': progress_percent,
+            'notes': notes
+        }
+        
+        self.progress_data[task_key]['progress_updates'].append(update)
+        self.progress_data[task_key]['status'] = 'in_progress' if progress_percent < 100 else 'completed'
+        
+        self.save_progress_data()
+        
+        user_name = self.progress_data[task_key]['user_name']
+        task_type = self.progress_data[task_key]['task_type']
+        print(f"📈 Progress Update: {user_name} → {task_type} ({progress_percent}%)")
+        if notes:
+            print(f"   Note: {notes}")
+            
+    def add_result(self, task_id, user_id, time_taken, quality):
+        """Add task completion result"""
+        # Update progress tracking with completion
+        task_key = f"{task_id}_{user_id}"
+        completion_time = datetime.now()
+        
+        if task_key in self.progress_data:
+            self.progress_data[task_key]['completion_time'] = completion_time.isoformat()
+            self.progress_data[task_key]['status'] = 'completed'
+            self.progress_data[task_key]['actual_time_taken'] = time_taken
+            
+            # Calculate how long it actually took from start
+            start_time = datetime.fromisoformat(self.progress_data[task_key]['start_time'])
+            actual_duration = (completion_time - start_time).total_seconds() / 3600  # hours
+            self.progress_data[task_key]['actual_duration'] = round(actual_duration, 2)
+            
+            self.save_progress_data()
+        
+        new_result = {
+            'task_id': task_id,
+            'user_id': user_id,
+            'time_taken': time_taken,
+            'quality': quality
+        }
+        
+        # Add to results dataframe
+        self.results = pd.concat([self.results, pd.DataFrame([new_result])], ignore_index=True)
+        
+        # Save to CSV
+        self.results.to_csv(self.results_file, index=False)
+        
+        # Get names for display
+        task_name = self.tasks[self.tasks['task_id'] == task_id]['type'].iloc[0]
+        user_name = self.users[self.users['user_id'] == user_id]['name'].iloc[0]
+        
+        print(f"✅ Task Completed: {user_name} → {task_name} in {time_taken}h with quality {quality}/5")
+        
+        # Show completion analytics
+        if task_key in self.progress_data:
+            actual_duration = self.progress_data[task_key]['actual_duration']
+            deadline = self.progress_data[task_key]['deadline']
+            efficiency = (deadline - time_taken) / deadline * 100
+            print(f"   📊 Analytics: {actual_duration}h real time, {efficiency:+.1f}% vs deadline")
+        
+    def show_stats(self):
+        """Show system statistics"""
+        if len(self.results) == 0:
+            print("📊 No results yet - system ready for first assignments")
+            return
+            
+        print("\n📊 SYSTEM STATISTICS")
+        print(f"Total completed tasks: {len(self.results)}")
+        print(f"Average quality: {self.results['quality'].mean():.2f}/5")
+        print(f"Average time taken: {self.results['time_taken'].mean():.1f}h")
+        
+        # User performance
+        user_stats = self.results.merge(self.users, on='user_id').groupby('name').agg({
+            'quality': 'mean',
+            'time_taken': 'mean',
+            'task_id': 'count'
+        }).round(2)
+        user_stats.columns = ['Avg Quality', 'Avg Time', 'Tasks Done']
+        print("\n👥 USER PERFORMANCE")
+        print(user_stats)
+        
+    def get_user_skills(self):
+        """Discover user skills automatically"""
+        if len(self.results) == 0:
+            print("No data to analyze skills yet")
+            return
+            
+        # Merge with all data
+        full_data = self.results.merge(self.tasks, on='task_id').merge(self.users, on='user_id')
+        
+        print("\n🎯 DISCOVERED SKILLS")
+        for user_name in full_data['name'].unique():
+            user_data = full_data[full_data['name'] == user_name]
+            
+            print(f"\n{user_name}:")
+            for task_type in user_data['type'].unique():
+                type_data = user_data[user_data['type'] == task_type]
+                avg_quality = type_data['quality'].mean()
+                avg_time = type_data['time_taken'].mean()
+                skill_level = "Expert" if avg_quality >= 4 else "Good" if avg_quality >= 3 else "Learning"
+                print(f"  {task_type}: {avg_quality:.1f}/5 quality, {avg_time:.1f}h avg ({skill_level})")
+                
+    def show_active_tasks(self):
+        """Show currently active/assigned tasks"""
+        if not self.progress_data:
+            print("📋 No active tasks")
+            return
+            
+        active_tasks = [task for task in self.progress_data.values() 
+                       if task['status'] in ['assigned', 'in_progress']]
+        
+        if not active_tasks:
+            print("📋 No active tasks")
+            return
+            
+        print("\n📋 ACTIVE TASKS")
+        print("-" * 50)
+        
+        for task in active_tasks:
+            start_time = datetime.fromisoformat(task['start_time'])
+            time_elapsed = (datetime.now() - start_time).total_seconds() / 3600
+            
+            status_icon = "🔄" if task['status'] == 'in_progress' else "📋"
+            
+            print(f"{status_icon} Task {task['task_id']}: {task['user_name']} → {task['task_type']}")
+            print(f"   Complexity: {task['complexity']}, Deadline: {task['deadline']}h")
+            print(f"   Started: {time_elapsed:.1f}h ago")
+            
+            if task['progress_updates']:
+                latest = task['progress_updates'][-1]
+                print(f"   Progress: {latest['progress_percent']}%")
+                if latest['notes']:
+                    print(f"   Note: {latest['notes']}")
+                    
+        print("-" * 50)

deploy.bat

@@ -0,0 +1,23 @@
+@echo off
+echo 🚀 PREPARING FILES FOR HUGGING FACE DEPLOYMENT
+echo Target: https://huggingface.co/spaces/rishirajpathak/task-management
+echo.
+
+echo 📁 Files ready for upload:
+echo.
+dir /b app.py assignment_engine.py task_manager.py requirements.txt README.md users.csv tasks.csv results.csv task_progress.json .gitignore 2>nul
+
+echo.
+echo ✅ All files are ready!
+echo.
+echo 📋 NEXT STEPS:
+echo 1. Go to: https://huggingface.co/new-space
+echo 2. Space name: task-management
+echo 3. Owner: rishirajpathak  
+echo 4. SDK: Gradio
+echo 5. Upload the files listed above
+echo 6. Your app will be live at: https://huggingface.co/spaces/rishirajpathak/task-management
+echo.
+echo 🚫 DO NOT upload: .venv folder or any .pkl files
+echo.
+pause

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+pandas>=1.5.0
+scikit-learn>=1.0.0
+joblib>=1.0.0
+numpy>=1.20.0

results.csv

@@ -0,0 +1,7 @@
+task_id,user_id,time_taken,quality
+1,1,8,4
+2,2,3,5
+3,3,25,2
+4,1,6,5
+5,2,2,5
+6,1,15,4

task_manager.py

@@ -0,0 +1,80 @@
+from assignment_engine import TaskAssignmentEngine
+import pandas as pd
+
+class TaskManager:
+    def __init__(self):
+        self.engine = TaskAssignmentEngine()
+        self.setup()
+        
+    def setup(self):
+        """Initialize the system"""
+        print("🚀 TASK ASSIGNMENT SYSTEM STARTING...")
+        self.engine.load_data()
+        self.engine.load_model()  # Load existing model if available
+        
+    def assign_tasks(self):
+        """Assign all pending tasks"""
+        print("\n🎯 ASSIGNING TASKS...")
+        
+        for _, task in self.engine.tasks.iterrows():
+            task_id = task['task_id']
+            
+            # Check if task already completed
+            completed = self.engine.results[self.engine.results['task_id'] == task_id]
+            if len(completed) > 0:
+                print(f"Task {task_id} already completed")
+                continue
+                
+            user_id, user_name = self.engine.assign_task(task_id)
+            
+    def enter_result(self, task_id, user_id, time_taken, quality):
+        """Enter task completion result"""
+        self.engine.add_result(task_id, user_id, time_taken, quality)
+        
+    def update_progress(self, task_id, user_id, progress_percent, notes=""):
+        """Update task progress"""
+        self.engine.update_task_progress(task_id, user_id, progress_percent, notes)
+        
+    def retrain_ai(self):
+        """Retrain the AI with new data"""
+        print("\n🧠 RETRAINING AI...")
+        self.engine.train_model()
+        
+    def show_dashboard(self):
+        """Show system dashboard"""
+        print("\n" + "="*50)
+        print("📋 TASK ASSIGNMENT DASHBOARD")
+        print("="*50)
+        
+        self.engine.show_stats()
+        self.engine.get_user_skills()
+        self.engine.show_active_tasks()
+        
+        print(f"\n🤖 AI Status: {'Trained' if self.engine.is_trained else 'Random Assignment'}")
+        
+    def add_user(self, name):
+        """Add new user"""
+        new_id = self.engine.users['user_id'].max() + 1
+        new_user = pd.DataFrame({'user_id': [new_id], 'name': [name]})
+        self.engine.users = pd.concat([self.engine.users, new_user], ignore_index=True)
+        self.engine.users.to_csv("users.csv", index=False)
+        print(f"✅ Added user: {name} (ID: {new_id})")
+        
+    def add_task(self, task_type, complexity, deadline):
+        """Add new task"""
+        new_id = self.engine.tasks['task_id'].max() + 1
+        new_task = pd.DataFrame({
+            'task_id': [new_id], 
+            'type': [task_type], 
+            'complexity': [complexity], 
+            'deadline': [deadline]
+        })
+        self.engine.tasks = pd.concat([self.engine.tasks, new_task], ignore_index=True)
+        self.engine.tasks.to_csv("tasks.csv", index=False)
+        print(f"✅ Added task: {task_type} (ID: {new_id}, Complexity: {complexity}, Deadline: {deadline}h)")
+
+if __name__ == "__main__":
+    # Example usage
+    tm = TaskManager()
+    tm.show_dashboard()
+    tm.assign_tasks()

task_progress.json

@@ -0,0 +1,26 @@
+{
+  "7_2": {
+    "task_id": 7,
+    "user_id": 2,
+    "user_name": "Amit",
+    "task_type": "design",
+    "complexity": 0.5,
+    "deadline": 30.0,
+    "start_time": "2026-01-11T13:40:39.520692",
+    "status": "assigned",
+    "progress_updates": [],
+    "completion_time": null
+  },
+  "8_2": {
+    "task_id": 8,
+    "user_id": 2,
+    "user_name": "Amit",
+    "task_type": "add login page",
+    "complexity": 1.0,
+    "deadline": 6.0,
+    "start_time": "2026-01-11T13:40:39.545921",
+    "status": "assigned",
+    "progress_updates": [],
+    "completion_time": null
+  }
+}

tasks.csv

@@ -0,0 +1,10 @@
+task_id,type,complexity,deadline
+1,study,0.6,48.0
+2,fitness,0.4,24.0
+3,project,0.9,72.0
+4,study,0.7,36.0
+5,fitness,0.3,12.0
+6,project,0.8,48.0
+7,design,0.5,30.0
+8,add login page,1.0,6.0
+9,login page,0.5,6.0

users.csv

@@ -0,0 +1,6 @@
+user_id,name
+1,Rishiraj
+2,Amit
+3,Rahul
+4,Priya
+5,Utkarsh