# Preventive Maintenance Scheduling System

Show Full Code

# Facility Layout Optimization System
import numpy as np
from scipy.optimize import minimize

class FacilityLayoutOptimizer:
    def __init__(self, facility_width, facility_length):
        self.facility_width = facility_width
        self.facility_length = facility_length
        self.departments = {}
        self.material_flow_matrix = {}
    
    def add_department(self, dept_id, name, width, length, x, y):
        """Add department to facility layout"""
        self.departments[dept_id] = {
            'name': name,
            'width': width,
            'length': length,
            'x': x,
            'y': y,
            'area': width * length
        }
    
    def set_material_flow(self, from_dept, to_dept, flow_volume):
        """Set material flow between departments"""
        key = f"{from_dept}-{to_dept}"
        self.material_flow_matrix[key] = flow_volume
    
    def calculate_total_distance(self, layout):
        """Calculate total material handling distance"""
        total_distance = 0
        
        for flow_key, volume in self.material_flow_matrix.items():
            from_dept, to_dept = flow_key.split('-')
            
            # Calculate distance between department centers
            from_center_x = layout[from_dept]['x'] + layout[from_dept]['width'] / 2
            from_center_y = layout[from_dept]['y'] + layout[from_dept]['length'] / 2
            to_center_x = layout[to_dept]['x'] + layout[to_dept]['width'] / 2
            to_center_y = layout[to_dept]['y'] + layout[to_dept]['length'] / 2
            
            distance = np.sqrt((to_center_x - from_center_x)**2 + (to_center_y - from_center_y)**2)
            total_distance += distance * volume
        
        return total_distance
    
    def optimize_layout(self):
        """Optimize facility layout to minimize material handling distance"""
        # Initial layout
        initial_layout = self.departments.copy()
        
        # Objective function: minimize total distance
        def objective(layout_params):
            # Convert parameters back to layout format
            layout = {}
            param_index = 0
            for dept_id in self.departments:
                layout[dept_id] = {
                    'x': layout_params[param_index],
                    'y': layout_params[param_index + 1],
                    'width': self.departments[dept_id]['width'],
                    'length': self.departments[dept_id]['length']
                }
                param_index += 2
            return self.calculate_total_distance(layout)
        
        # Initial parameters (x, y coordinates for each department)
        initial_params = []
        for dept_id in self.departments:
            initial_params.extend([self.departments[dept_id]['x'], self.departments[dept_id]['y']])
        
        # Constraints: departments must stay within facility bounds
        bounds = []
        for dept_id in self.departments:
            max_x = self.facility_width - self.departments[dept_id]['width']
            max_y = self.facility_length - self.departments[dept_id]['length']
            bounds.extend([(0, max_x), (0, max_y)])
        
        # Optimize
        result = minimize(objective, initial_params, bounds=bounds, method='L-BFGS-B')
        
        # Convert result back to layout
        optimized_layout = {}
        param_index = 0
        for dept_id in self.departments:
            optimized_layout[dept_id] = {
                'name': self.departments[dept_id]['name'],
                'x': result.x[param_index],
                'y': result.x[param_index + 1],
                'width': self.departments[dept_id]['width'],
                'length': self.departments[dept_id]['length']
            }
            param_index += 2
        
        return optimized_layout, result.fun

# Usage
optimizer = FacilityLayoutOptimizer(100, 80)  # 100x80 facility

# Add departments
optimizer.add_department('RECEIVING', 'Receiving', 20, 15, 0, 0)
optimizer.add_department('STORAGE', 'Storage', 30, 20, 25, 0)
optimizer.add_department('ASSEMBLY', 'Assembly', 25, 25, 60, 0)
optimizer.add_department('SHIPPING', 'Shipping', 20, 15, 0, 60)

# Set material flows (volume per day)
optimizer.set_material_flow('RECEIVING', 'STORAGE', 50)
optimizer.set_material_flow('STORAGE', 'ASSEMBLY', 30)
optimizer.set_material_flow('ASSEMBLY', 'SHIPPING', 25)

# Optimize layout
optimized_layout, total_distance = optimizer.optimize_layout()

print(f"Optimized total distance: {total_distance:.2f} units")
for dept_id, layout in optimized_layout.items():
         print(f"{layout['name']}: ({layout['x']:.1f}, {layout['y']:.1f})")

Show Full Code

# Process Simplification Analysis Tool
import pandas as pd
import matplotlib.pyplot as plt

class ProcessSimplificationAnalyzer:
    def __init__(self):
        self.process_steps = []
        self.value_analysis = {}
    
    def add_process_step(self, step_id, description, duration, value_added, complexity_score):
        """Add a process step for analysis"""
        self.process_steps.append({
            'step_id': step_id,
            'description': description,
            'duration': duration,
            'value_added': value_added,
            'complexity_score': complexity_score,
            'elimination_potential': self.calculate_elimination_potential(duration, value_added, complexity_score)
        })
    
    def calculate_elimination_potential(self, duration, value_added, complexity):
        """Calculate potential for step elimination"""
        # Formula: (duration * complexity) / value_added
        # Higher score = higher elimination potential
        if value_added == 0:
            return 100  # Non-value-added step
        return (duration * complexity) / value_added
    
    def identify_elimination_candidates(self, threshold=50):
        """Identify steps with high elimination potential"""
        candidates = []
        for step in self.process_steps:
            if step['elimination_potential'] > threshold:
                candidates.append({
                    'step_id': step['step_id'],
                    'description': step['description'],
                    'elimination_potential': step['elimination_potential'],
                    'savings_hours': step['duration'],
                    'recommendation': self.generate_recommendation(step)
                })
        return sorted(candidates, key=lambda x: x['elimination_potential'], reverse=True)
    
    def generate_recommendation(self, step):
        """Generate specific recommendation for step elimination"""
        if step['value_added'] == 0:
            return "Eliminate - No value added"
        elif step['complexity_score'] > 8:
            return "Simplify - High complexity"
        elif step['duration'] > 60:
            return "Optimize - Long duration"
        else:
            return "Review - Moderate improvement potential"
    
    def calculate_process_efficiency(self):
        """Calculate overall process efficiency"""
        total_duration = sum(step['duration'] for step in self.process_steps)
        value_added_duration = sum(step['duration'] for step in self.process_steps if step['value_added'] > 0)
        
        efficiency = (value_added_duration / total_duration) * 100 if total_duration > 0 else 0
        
        return {
            'total_duration': total_duration,
            'value_added_duration': value_added_duration,
            'efficiency_percentage': efficiency,
            'waste_percentage': 100 - efficiency
        }
    
    def generate_improvement_report(self):
        """Generate comprehensive improvement report"""
        candidates = self.identify_elimination_candidates()
        efficiency = self.calculate_process_efficiency()
        
        report = {
            'current_efficiency': efficiency['efficiency_percentage'],
            'potential_savings_hours': sum(candidate['savings_hours'] for candidate in candidates),
            'elimination_candidates': candidates,
            'recommendations': self.generate_overall_recommendations()
        }
        
        return report
    
    def generate_overall_recommendations(self):
        """Generate overall process improvement recommendations"""
        recommendations = [
            "Implement electronic approvals to reduce manual processing",
            "Standardize work procedures to reduce complexity",
            "Use automation for repetitive, low-value tasks",
            "Implement mistake-proofing devices to prevent errors",
            "Create visual work instructions to reduce training time",
            "Establish clear decision-making authority to reduce approval delays"
        ]
        return recommendations

# Usage
analyzer = ProcessSimplificationAnalyzer()

# Add process steps (duration in minutes, value_added 0-10, complexity 1-10)
analyzer.add_process_step('STEP1', 'Manual data entry', 30, 2, 8)
analyzer.add_process_step('STEP2', 'Quality inspection', 15, 8, 6)
analyzer.add_process_step('STEP3', 'Manager approval', 45, 3, 7)
analyzer.add_process_step('STEP4', 'Document filing', 10, 1, 4)
analyzer.add_process_step('STEP5', 'Final assembly', 60, 10, 5)

# Generate improvement report
report = analyzer.generate_improvement_report()

print(f"Current Process Efficiency: {report['current_efficiency']:.1f}%")
print(f"Potential Time Savings: {report['potential_savings_hours']} minutes")
print(f"Elimination Candidates: {len(report['elimination_candidates'])} steps")

for candidate in report['elimination_candidates'][:3]:
         print(f"- {candidate['description']}: {candidate['recommendation']}")

Show Full Code

# Inventory Optimization and Kanban System
import numpy as np
from datetime import datetime, timedelta

class InventoryOptimizer:
    def __init__(self):
        self.inventory_items = {}
        self.kanban_cards = {}
        self.demand_history = {}
    
    def add_inventory_item(self, item_id, description, current_stock, safety_stock, 
                          lead_time_days, daily_demand, container_size):
        """Add inventory item for optimization"""
        self.inventory_items[item_id] = {
            'description': description,
            'current_stock': current_stock,
            'safety_stock': safety_stock,
            'lead_time_days': lead_time_days,
            'daily_demand': daily_demand,
            'container_size': container_size,
            'reorder_point': self.calculate_reorder_point(safety_stock, lead_time_days, daily_demand),
            'kanban_quantity': self.calculate_kanban_quantity(lead_time_days, daily_demand, container_size)
        }
    
    def calculate_reorder_point(self, safety_stock, lead_time, daily_demand):
        """Calculate reorder point using formula: Safety Stock + (Lead Time × Daily Demand)"""
        return safety_stock + (lead_time * daily_demand)
    
    def calculate_kanban_quantity(self, lead_time, daily_demand, container_size):
        """Calculate optimal kanban quantity"""
        # Kanban quantity = Lead time demand + Safety factor
        lead_time_demand = lead_time * daily_demand
        safety_factor = daily_demand * 0.5  # 50% safety factor
        total_quantity = lead_time_demand + safety_factor
        
        # Round up to nearest container size
        kanban_quantity = np.ceil(total_quantity / container_size) * container_size
        return int(kanban_quantity)
    
    def create_kanban_card(self, item_id, card_type='production'):
        """Create kanban card for pull system"""
        if item_id in self.inventory_items:
            item = self.inventory_items[item_id]
            card_id = f"KANBAN-{item_id}-{card_type.upper()}"
            
            self.kanban_cards[card_id] = {
                'item_id': item_id,
                'description': item['description'],
                'type': card_type,
                'quantity': item['kanban_quantity'],
                'container_size': item['container_size'],
                'status': 'active',
                'created_date': datetime.now(),
                'last_used': None
            }
            return card_id
        return None
    
    def check_inventory_status(self, item_id):
        """Check current inventory status and generate recommendations"""
        if item_id in self.inventory_items:
            item = self.inventory_items[item_id]
            current_stock = item['current_stock']
            reorder_point = item['reorder_point']
            
            status = {
                'item_id': item_id,
                'current_stock': current_stock,
                'reorder_point': reorder_point,
                'safety_stock': item['safety_stock'],
                'status': 'OK' if current_stock > reorder_point else 'REORDER',
                'days_until_stockout': self.calculate_days_until_stockout(current_stock, item['daily_demand']),
                'recommendations': self.generate_inventory_recommendations(item)
            }
            return status
        return None
    
    def calculate_days_until_stockout(self, current_stock, daily_demand):
        """Calculate days until stockout"""
        return int(current_stock / daily_demand) if daily_demand > 0 else float('inf')
    
    def generate_inventory_recommendations(self, item):
        """Generate specific inventory improvement recommendations"""
        recommendations = []
        
        if item['current_stock'] <= item['reorder_point']:
            recommendations.append(f"Place order for {item['kanban_quantity']} units")
        
        if item['current_stock'] > item['reorder_point'] * 2:
            recommendations.append("Consider reducing order quantity - excess inventory")
        
        if item['lead_time_days'] > 7:
            recommendations.append("Work with suppliers to reduce lead time")
        
        if item['daily_demand'] * item['lead_time_days'] < item['safety_stock']:
            recommendations.append("Review safety stock levels - may be too high")
        
        return recommendations
    
    def calculate_inventory_turnover(self, item_id, period_days=30):
        """Calculate inventory turnover rate"""
        if item_id in self.inventory_items:
            item = self.inventory_items[item_id]
            average_inventory = (item['current_stock'] + item['safety_stock']) / 2
            period_demand = item['daily_demand'] * period_days
            
            turnover_rate = period_demand / average_inventory if average_inventory > 0 else 0
            days_of_inventory = 365 / turnover_rate if turnover_rate > 0 else float('inf')
            
            return {
                'turnover_rate': turnover_rate,
                'days_of_inventory': days_of_inventory,
                'target_turnover': 12,  # Industry standard
                'improvement_potential': max(0, 12 - turnover_rate)
            }
        return None

# Usage
optimizer = InventoryOptimizer()

# Add inventory items
optimizer.add_inventory_item('PART001', 'Steel Bracket', 150, 50, 5, 20, 25)
optimizer.add_inventory_item('PART002', 'Circuit Board', 80, 30, 3, 15, 20)

# Create kanban cards
kanban1 = optimizer.create_kanban_card('PART001', 'production')
kanban2 = optimizer.create_kanban_card('PART002', 'supplier')

# Check inventory status
status1 = optimizer.check_inventory_status('PART001')
turnover1 = optimizer.calculate_inventory_turnover('PART001')

print(f"Item: {status1['item_id']}")
print(f"Status: {status1['status']}")
print(f"Days until stockout: {status1['days_until_stockout']}")
print(f"Turnover rate: {turnover1['turnover_rate']:.1f} per year")
 print(f"Recommendations: {len(status1['recommendations'])} items")

Show Full Code

# Ergonomic Assessment Checklist
class ErgonomicAssessment:
    def __init__(self):
        self.assessment_data = {}
    
    def assess_workstation(self, workstation_id):
        """Complete ergonomic assessment of workstation"""
        assessment = {
            'workstation_id': workstation_id,
            'date': datetime.now(),
            'assessor': 'Ergonomic Specialist',
            'risk_factors': {
                'posture': self.assess_posture(),
                'repetition': self.assess_repetition(),
                'force': self.assess_force_requirements(),
                'duration': self.assess_task_duration(),
                'recovery': self.assess_recovery_time()
            },
            'recommendations': self.generate_recommendations()
        }
        return assessment
    
    def assess_posture(self):
        """Assess worker posture using RULA methodology"""
        # RULA scoring system
        posture_score = {
            'upper_arm': 0,  # 1-4 scale
            'lower_arm': 0,  # 1-3 scale
            'wrist': 0,      # 1-4 scale
            'neck': 0,       # 1-4 scale
            'trunk': 0,      # 1-4 scale
            'legs': 0        # 1-3 scale
        }
        return posture_score
    
    def generate_recommendations(self):
        """Generate specific ergonomic recommendations"""
        recommendations = [
            'Adjust chair height to maintain 90-degree knee angle',
            'Position monitor at arm's length, top at eye level',
            'Use footrest if feet don't reach floor',
            'Implement adjustable work surface',
            'Provide anti-fatigue mats for standing work',
            'Install proper lighting (500-1000 lux)',
            'Use ergonomic tools and equipment'
        ]
        return recommendations

# Usage
ergo_assessor = ErgonomicAssessment()
assessment = ergo_assessor.assess_workstation('WS-001')
print(f"Risk Level: {assessment['risk_factors']['posture']}")
 print(f"Recommendations: {len(assessment['recommendations'])} items")

Show Full Code

# Employee Engagement and Development Management System
from datetime import datetime, timedelta
import json

class EmployeeEngagementSystem:
    def __init__(self):
        self.employees = {}
        self.suggestions = {}
        self.training_programs = {}
        self.performance_metrics = {}
    
    def add_employee(self, employee_id, name, department, skills, experience_years):
        """Add employee to the system"""
        self.employees[employee_id] = {
            'name': name,
            'department': department,
            'skills': skills,
            'experience_years': experience_years,
            'suggestions_submitted': 0,
            'suggestions_implemented': 0,
            'training_hours': 0,
            'performance_rating': 0,
            'engagement_score': 0,
            'last_assessment': None
        }
    
    def submit_suggestion(self, employee_id, suggestion_text, category, expected_impact):
        """Submit improvement suggestion from employee"""
        if employee_id in self.employees:
            suggestion_id = f"SUGG-{len(self.suggestions) + 1:04d}"
            
            self.suggestions[suggestion_id] = {
                'employee_id': employee_id,
                'suggestion_text': suggestion_text,
                'category': category,
                'expected_impact': expected_impact,
                'submission_date': datetime.now(),
                'status': 'Submitted',
                'review_date': None,
                'implementation_date': None,
                'actual_impact': None
            }
            
            # Update employee metrics
            self.employees[employee_id]['suggestions_submitted'] += 1
            
            return suggestion_id
        return None
    
    def review_suggestion(self, suggestion_id, status, reviewer_notes):
        """Review and approve/reject suggestion"""
        if suggestion_id in self.suggestions:
            self.suggestions[suggestion_id]['status'] = status
            self.suggestions[suggestion_id]['review_date'] = datetime.now()
            self.suggestions[suggestion_id]['reviewer_notes'] = reviewer_notes
            
            if status == 'Approved':
                self.suggestions[suggestion_id]['implementation_date'] = datetime.now()
                employee_id = self.suggestions[suggestion_id]['employee_id']
                self.employees[employee_id]['suggestions_implemented'] += 1
    
    def create_training_program(self, program_id, title, description, duration_hours, 
                               target_skills, difficulty_level):
        """Create training program for skill development"""
        self.training_programs[program_id] = {
            'title': title,
            'description': description,
            'duration_hours': duration_hours,
            'target_skills': target_skills,
            'difficulty_level': difficulty_level,
            'enrolled_employees': [],
            'completion_rate': 0
        }
    
    def enroll_employee_training(self, employee_id, program_id):
        """Enroll employee in training program"""
        if employee_id in self.employees and program_id in self.training_programs:
            if employee_id not in self.training_programs[program_id]['enrolled_employees']:
                self.training_programs[program_id]['enrolled_employees'].append(employee_id)
                return True
        return False
    
    def complete_training(self, employee_id, program_id):
        """Mark training as completed"""
        if (employee_id in self.employees and program_id in self.training_programs and
            employee_id in self.training_programs[program_id]['enrolled_employees']):
            
            # Update employee training hours
            self.employees[employee_id]['training_hours'] += self.training_programs[program_id]['duration_hours']
            
            # Update program completion rate
            total_enrolled = len(self.training_programs[program_id]['enrolled_employees'])
            completed = sum(1 for emp in self.training_programs[program_id]['enrolled_employees'] 
                          if self.employees[emp]['training_hours'] > 0)
            self.training_programs[program_id]['completion_rate'] = (completed / total_enrolled) * 100 if total_enrolled > 0 else 0
    
    def assess_employee_engagement(self, employee_id):
        """Assess employee engagement level"""
        if employee_id in self.employees:
            employee = self.employees[employee_id]
            
            # Calculate engagement score based on multiple factors
            suggestion_score = min(employee['suggestions_submitted'] * 10, 30)  # Max 30 points
            implementation_score = min(employee['suggestions_implemented'] * 20, 40)  # Max 40 points
            training_score = min(employee['training_hours'] / 10, 20)  # Max 20 points
            performance_score = min(employee['performance_rating'] * 2, 10)  # Max 10 points
            
            total_score = suggestion_score + implementation_score + training_score + performance_score
            employee['engagement_score'] = total_score
            employee['last_assessment'] = datetime.now()
            
            return {
                'employee_id': employee_id,
                'name': employee['name'],
                'engagement_score': total_score,
                'level': self.get_engagement_level(total_score),
                'recommendations': self.generate_engagement_recommendations(employee)
            }
        return None
    
    def get_engagement_level(self, score):
        """Determine engagement level based on score"""
        if score >= 80:
            return "Highly Engaged"
        elif score >= 60:
            return "Engaged"
        elif score >= 40:
            return "Moderately Engaged"
        else:
            return "Needs Improvement"
    
    def generate_engagement_recommendations(self, employee):
        """Generate recommendations to improve employee engagement"""
        recommendations = []
        
        if employee['suggestions_submitted'] == 0:
            recommendations.append("Encourage participation in improvement suggestions")
        
        if employee['training_hours'] < 20:
            recommendations.append("Provide more training and development opportunities")
        
        if employee['performance_rating'] < 4:
            recommendations.append("Set clear performance goals and provide feedback")
        
        if employee['suggestions_implemented'] == 0 and employee['suggestions_submitted'] > 0:
            recommendations.append("Review and implement employee suggestions promptly")
        
        return recommendations
    
    def generate_engagement_report(self):
        """Generate comprehensive engagement report"""
        total_employees = len(self.employees)
        if total_employees == 0:
            return None
        
        engagement_levels = {'Highly Engaged': 0, 'Engaged': 0, 'Moderately Engaged': 0, 'Needs Improvement': 0}
        total_suggestions = len(self.suggestions)
        implemented_suggestions = sum(1 for s in self.suggestions.values() if s['status'] == 'Approved')
        
        for employee in self.employees.values():
            level = self.get_engagement_level(employee['engagement_score'])
            engagement_levels[level] += 1
        
        return {
            'total_employees': total_employees,
            'engagement_distribution': engagement_levels,
            'average_engagement_score': sum(emp['engagement_score'] for emp in self.employees.values()) / total_employees,
            'total_suggestions': total_suggestions,
            'suggestion_implementation_rate': (implemented_suggestions / total_suggestions * 100) if total_suggestions > 0 else 0,
            'average_training_hours': sum(emp['training_hours'] for emp in self.employees.values()) / total_employees
        }

# Usage
engagement_system = EmployeeEngagementSystem()

# Add employees
engagement_system.add_employee('EMP001', 'John Smith', 'Production', ['Assembly', 'Quality Control'], 3)
engagement_system.add_employee('EMP002', 'Sarah Johnson', 'Engineering', ['CAD', 'Lean Methods'], 5)

# Submit suggestions
sugg1 = engagement_system.submit_suggestion('EMP001', 'Install tool holders at workstations', 'Ergonomics', 'Medium')
sugg2 = engagement_system.submit_suggestion('EMP002', 'Implement visual management system', 'Process Improvement', 'High')

# Review suggestions
engagement_system.review_suggestion(sugg1, 'Approved', 'Good ergonomic improvement')
engagement_system.review_suggestion(sugg2, 'Under Review', 'Requires budget approval')

# Create and enroll in training
engagement_system.create_training_program('TRAIN001', 'Lean Fundamentals', 'Basic lean principles', 16, ['Lean Methods'], 'Beginner')
engagement_system.enroll_employee_training('EMP001', 'TRAIN001')
engagement_system.complete_training('EMP001', 'TRAIN001')

# Assess engagement
assessment = engagement_system.assess_employee_engagement('EMP001')
report = engagement_system.generate_engagement_report()

print(f"Employee: {assessment['name']}")
print(f"Engagement Level: {assessment['level']}")
print(f"Score: {assessment['engagement_score']:.1f}/100")
print(f"Recommendations: {len(assessment['recommendations'])} items")
 print(f"Overall Implementation Rate: {report['suggestion_implementation_rate']:.1f}%")

Show Full Code

# Enhanced Employee Engagement System with CSV Import
import pandas as pd
from datetime import datetime, timedelta
import json

class EmployeeEngagementSystem:
    def __init__(self):
        self.employees = {}
        self.suggestions = {}
        self.training_programs = {}
        self.performance_metrics = {}
    
    def import_employees_from_csv(self, csv_file):
        """Import employee data from CSV file"""
        try:
            df = pd.read_csv(csv_file)
            for _, row in df.iterrows():
                skills = row['skills'].split(',') if pd.notna(row['skills']) else []
                self.add_employee(
                    row['employee_id'],
                    row['name'],
                    row['department'],
                    skills,
                    row['experience_years'],
                    row.get('performance_rating', 0)
                )
            print(f"Imported {len(df)} employees from {csv_file}")
        except Exception as e:
            print(f"Error importing employees: {e}")
    
    def import_training_programs_from_csv(self, csv_file):
        """Import training programs from CSV file"""
        try:
            df = pd.read_csv(csv_file)
            for _, row in df.iterrows():
                target_skills = row['target_skills'].split(',') if pd.notna(row['target_skills']) else []
                self.create_training_program(
                    row['program_id'],
                    row['title'],
                    row['description'],
                    row['duration_hours'],
                    target_skills,
                    row['difficulty_level']
                )
            print(f"Imported {len(df)} training programs from {csv_file}")
        except Exception as e:
            print(f"Error importing training programs: {e}")
    
    def import_suggestions_from_csv(self, csv_file):
        """Import employee suggestions from CSV file"""
        try:
            df = pd.read_csv(csv_file)
            for _, row in df.iterrows():
                submission_date = datetime.strptime(row['submission_date'], '%Y-%m-%d')
                self.suggestions[row['suggestion_id']] = {
                    'employee_id': row['employee_id'],
                    'suggestion_text': row['suggestion_text'],
                    'category': row['category'],
                    'expected_impact': row['expected_impact'],
                    'submission_date': submission_date,
                    'status': row['status'],
                    'review_date': None,
                    'implementation_date': None
                }
                # Update employee suggestion count
                if row['employee_id'] in self.employees:
                    self.employees[row['employee_id']]['suggestions_submitted'] += 1
                    if row['status'] == 'Approved':
                        self.employees[row['employee_id']]['suggestions_implemented'] += 1
            print(f"Imported {len(df)} suggestions from {csv_file}")
        except Exception as e:
            print(f"Error importing suggestions: {e}")
    
    def import_training_enrollments_from_csv(self, csv_file):
        """Import training enrollments from CSV file"""
        try:
            df = pd.read_csv(csv_file)
            for _, row in df.iterrows():
                if row['status'] == 'Completed' and pd.notna(row['completion_date']):
                    completion_date = datetime.strptime(row['completion_date'], '%Y-%m-%d')
                    # Update employee training hours
                    if (row['employee_id'] in self.employees and 
                        row['program_id'] in self.training_programs):
                        program_hours = self.training_programs[row['program_id']]['duration_hours']
                        self.employees[row['employee_id']]['training_hours'] += program_hours
            print(f"Imported {len(df)} training enrollments from {csv_file}")
        except Exception as e:
            print(f"Error importing training enrollments: {e}")
    
    # ... (rest of the existing methods remain the same)

# Usage with CSV Import
engagement_system = EmployeeEngagementSystem()

# Import data from CSV files
engagement_system.import_employees_from_csv('employees.csv')
engagement_system.import_training_programs_from_csv('training_programs.csv')
engagement_system.import_suggestions_from_csv('suggestions.csv')
engagement_system.import_training_enrollments_from_csv('training_enrollments.csv')

# Generate comprehensive report
report = engagement_system.generate_engagement_report()
print(f"Total Employees: {report['total_employees']}")
print(f"Average Engagement Score: {report['average_engagement_score']:.1f}")
print(f"Suggestion Implementation Rate: {report['suggestion_implementation_rate']:.1f}%")
 print(f"Average Training Hours: {report['average_training_hours']:.1f}")

Show Full Code