1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

class SecurityBudgetManagement:
    def __init__(self):
        self.budget_categories = {
            'personnel': {
                'name': 'Security Personnel',
                'subcategories': ['salaries', 'benefits', 'training', 'recruitment']
            },
            'technology': {
                'name': 'Security Technology',
                'subcategories': ['software', 'hardware', 'licenses', 'maintenance']
            },
            'services': {
                'name': 'Security Services',
                'subcategories': ['consulting', 'outsourcing', 'cloud_services', 'support']
            },
            'infrastructure': {
                'name': 'Infrastructure',
                'subcategories': ['data_center', 'network', 'storage', 'backup']
            },
            'compliance': {
                'name': 'Compliance',
                'subcategories': ['audits', 'certifications', 'legal', 'regulatory']
            }
        }
        
        self.budget_data = {}
        self.allocations = {}
        self.expenditures = {}
        self.forecasts = {}
    
    def create_budget(self, budget_id, fiscal_year, total_budget):
        """Create security budget"""
        self.budget_data[budget_id] = {
            'budget_id': budget_id,
            'fiscal_year': fiscal_year,
            'total_budget': total_budget,
            'allocated_budget': 0,
            'spent_budget': 0,
            'remaining_budget': total_budget,
            'created_date': datetime.now(),
            'status': 'active'
        }
    
    def allocate_budget(self, budget_id, category, subcategory, amount, justification):
        """Allocate budget by category"""
        if budget_id not in self.budget_data:
            return False
        
        allocation_key = f"{budget_id}_{category}_{subcategory}"
        
        self.allocations[allocation_key] = {
            'budget_id': budget_id,
            'category': category,
            'subcategory': subcategory,
            'amount': amount,
            'justification': justification,
            'allocated_date': datetime.now(),
            'status': 'allocated'
        }
        
        # Update allocated budget
        self.budget_data[budget_id]['allocated_budget'] += amount
        self.budget_data[budget_id]['remaining_budget'] -= amount
        
        return True
    
    def record_expenditure(self, budget_id, category, subcategory, amount, description, vendor):
        """Record expense"""
        if budget_id not in self.budget_data:
            return False
        
        expenditure_id = f"EXP-{len(self.expenditures) + 1}"
        
        self.expenditures[expenditure_id] = {
            'expenditure_id': expenditure_id,
            'budget_id': budget_id,
            'category': category,
            'subcategory': subcategory,
            'amount': amount,
            'description': description,
            'vendor': vendor,
            'expenditure_date': datetime.now(),
            'status': 'approved'
        }
        
        # Update spent budget
        self.budget_data[budget_id]['spent_budget'] += amount
        
        return True
    
    def calculate_budget_utilization(self, budget_id):
        """Calculate budget utilization"""
        if budget_id not in self.budget_data:
            return None
        
        budget = self.budget_data[budget_id]
        
        utilization = {
            'total_budget': budget['total_budget'],
            'allocated_budget': budget['allocated_budget'],
            'spent_budget': budget['spent_budget'],
            'remaining_budget': budget['remaining_budget'],
            'allocation_rate': (budget['allocated_budget'] / budget['total_budget'] * 100) if budget['total_budget'] > 0 else 0,
            'spending_rate': (budget['spent_budget'] / budget['total_budget'] * 100) if budget['total_budget'] > 0 else 0,
            'utilization_rate': (budget['spent_budget'] / budget['allocated_budget'] * 100) if budget['allocated_budget'] > 0 else 0
        }
        
        return utilization
    
    def generate_budget_report(self, budget_id):
        """Generate budget report"""
        if budget_id not in self.budget_data:
            return None
        
        budget = self.budget_data[budget_id]
        utilization = self.calculate_budget_utilization(budget_id)
        
        # Group allocations by category
        category_allocations = {}
        for allocation in self.allocations.values():
            if allocation['budget_id'] == budget_id:
                category = allocation['category']
                if category not in category_allocations:
                    category_allocations[category] = 0
                category_allocations[category] += allocation['amount']
        
        # Group expenses by category
        category_expenditures = {}
        for expenditure in self.expenditures.values():
            if expenditure['budget_id'] == budget_id:
                category = expenditure['category']
                if category not in category_expenditures:
                    category_expenditures[category] = 0
                category_expenditures[category] += expenditure['amount']
        
        report = {
            'budget_id': budget_id,
            'fiscal_year': budget['fiscal_year'],
            'utilization': utilization,
            'category_allocations': category_allocations,
            'category_expenditures': category_expenditures,
            'recommendations': self.generate_budget_recommendations(budget_id)
        }
        
        return report
    
    def generate_budget_recommendations(self, budget_id):
        """Generate budget recommendations"""
        recommendations = []
        
        utilization = self.calculate_budget_utilization(budget_id)
        if not utilization:
            return recommendations
        
        # Recommendations based on utilization
        if utilization['allocation_rate'] < 80:
            recommendations.append("Consider increasing budget allocation to maximize usage")
        
        if utilization['spending_rate'] > 90:
            recommendations.append("Budget almost exhausted, consider requesting additional funds")
        
        if utilization['utilization_rate'] < 50:
            recommendations.append("Low utilization of allocated budget, review projects")
        
        # Recommendations based on categories
        category_allocations = {}
        for allocation in self.allocations.values():
            if allocation['budget_id'] == budget_id:
                category = allocation['category']
                if category not in category_allocations:
                    category_allocations[category] = 0
                category_allocations[category] += allocation['amount']
        
        total_allocated = sum(category_allocations.values())
        if total_allocated > 0:
            for category, amount in category_allocations.items():
                percentage = (amount / total_allocated) * 100
                if percentage > 40:
                    recommendations.append(f"Review {category} allocation ({percentage:.1f}% of total)")
        
        return recommendations

# Usage example
budget_mgmt = SecurityBudgetManagement()

# Create budget
budget_mgmt.create_budget('BUDGET-2025', 2025, 1000000)

# Allocate budget by categories
budget_mgmt.allocate_budget('BUDGET-2025', 'personnel', 'salaries', 400000, 'Security team salaries')
budget_mgmt.allocate_budget('BUDGET-2025', 'technology', 'software', 200000, 'Security software licenses')
budget_mgmt.allocate_budget('BUDGET-2025', 'services', 'consulting', 150000, 'Consulting services')
budget_mgmt.allocate_budget('BUDGET-2025', 'infrastructure', 'data_center', 150000, 'Data center infrastructure')
budget_mgmt.allocate_budget('BUDGET-2025', 'compliance', 'audits', 100000, 'Compliance audits')

# Record expenses
budget_mgmt.record_expenditure('BUDGET-2025', 'personnel', 'salaries', 50000, 'Q1 Salaries', 'N/A')
budget_mgmt.record_expenditure('BUDGET-2025', 'technology', 'software', 25000, 'SIEM License', 'Splunk')

# Generate report
report = budget_mgmt.generate_budget_report('BUDGET-2025')
print(f"Budget report: {report['utilization']['allocation_rate']:.1f}% allocated")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

class SecurityROIAnalysis:
    def __init__(self):
        self.investments = {}
        self.benefits = {}
        self.costs = {}
        self.roi_calculations = {}
    
    def add_investment(self, investment_id, investment_data):
        """Add security investment"""
        self.investments[investment_id] = {
            'investment_id': investment_id,
            'name': investment_data['name'],
            'category': investment_data['category'],
            'initial_cost': investment_data['initial_cost'],
            'annual_cost': investment_data.get('annual_cost', 0),
            'expected_lifespan': investment_data.get('expected_lifespan', 5),
            'implementation_date': investment_data.get('implementation_date', datetime.now()),
            'description': investment_data.get('description', '')
        }
    
    def add_benefit(self, benefit_id, benefit_data):
        """Add security benefit"""
        self.benefits[benefit_id] = {
            'benefit_id': benefit_id,
            'investment_id': benefit_data['investment_id'],
            'type': benefit_data['type'],
            'description': benefit_data['description'],
            'annual_value': benefit_data['annual_value'],
            'probability': benefit_data.get('probability', 1.0),
            'start_date': benefit_data.get('start_date', datetime.now())
        }
    
    def add_cost(self, cost_id, cost_data):
        """Add security cost"""
        self.costs[cost_id] = {
            'cost_id': cost_id,
            'investment_id': cost_data['investment_id'],
            'type': cost_data['type'],
            'description': cost_data['description'],
            'annual_cost': cost_data['annual_cost'],
            'start_date': cost_data.get('start_date', datetime.now())
        }
    
    def calculate_roi(self, investment_id, years=5):
        """Calculate investment ROI"""
        if investment_id not in self.investments:
            return None
        
        investment = self.investments[investment_id]
        
        # Get related benefits and costs
        related_benefits = [b for b in self.benefits.values() if b['investment_id'] == investment_id]
        related_costs = [c for c in self.costs.values() if c['investment_id'] == investment_id]
        
        # Calculate annual cash flow
        cash_flows = []
        
        for year in range(years):
            year_benefits = sum(b['annual_value'] * b['probability'] for b in related_benefits)
            year_costs = sum(c['annual_cost'] for c in related_costs)
            
            if year == 0:
                # Year 0 includes initial cost
                year_costs += investment['initial_cost']
            
            net_cash_flow = year_benefits - year_costs
            cash_flows.append(net_cash_flow)
        
        # Calculate ROI metrics
        total_investment = investment['initial_cost'] + sum(c['annual_cost'] for c in related_costs) * years
        total_benefits = sum(cash_flows)
        roi_percentage = (total_benefits / total_investment * 100) if total_investment > 0 else 0
        
        # Calculate payback period
        cumulative_cash_flow = 0
        payback_period = None
        
        for year, cash_flow in enumerate(cash_flows):
            cumulative_cash_flow += cash_flow
            if cumulative_cash_flow >= 0 and payback_period is None:
                payback_period = year
        
        # Calculate NPV (Net Present Value) with 10% discount rate
        discount_rate = 0.10
        npv = sum(cf / (1 + discount_rate) ** year for year, cf in enumerate(cash_flows))
        
        roi_calculation = {
            'investment_id': investment_id,
            'investment_name': investment['name'],
            'total_investment': total_investment,
            'total_benefits': total_benefits,
            'roi_percentage': roi_percentage,
            'payback_period': payback_period,
            'npv': npv,
            'cash_flows': cash_flows,
            'years_analyzed': years
        }
        
        self.roi_calculations[investment_id] = roi_calculation
        return roi_calculation
    
    def compare_investments(self, investment_ids):
        """Compare investments"""
        comparison = []
        
        for investment_id in investment_ids:
            if investment_id in self.roi_calculations:
                roi = self.roi_calculations[investment_id]
                comparison.append({
                    'investment_id': investment_id,
                    'investment_name': roi['investment_name'],
                    'roi_percentage': roi['roi_percentage'],
                    'payback_period': roi['payback_period'],
                    'npv': roi['npv'],
                    'total_investment': roi['total_investment']
                })
        
        # Sort by ROI
        comparison.sort(key=lambda x: x['roi_percentage'], reverse=True)
        
        return comparison
    
    def generate_investment_recommendations(self):
        """Generate investment recommendations"""
        recommendations = []
        
        if not self.roi_calculations:
            return recommendations
        
        # Recommendations based on ROI
        high_roi_investments = [roi for roi in self.roi_calculations.values() if roi['roi_percentage'] > 100]
        if high_roi_investments:
            recommendations.append({
                'type': 'high_roi',
                'message': f"Consider prioritizing {len(high_roi_investments)} investments with ROI > 100%",
                'investments': [roi['investment_name'] for roi in high_roi_investments]
            })
        
        # Recommendations based on payback period
        quick_payback = [roi for roi in self.roi_calculations.values() if roi['payback_period'] is not None and roi['payback_period'] <= 2]
        if quick_payback:
            recommendations.append({
                'type': 'quick_payback',
                'message': f"Consider {len(quick_payback)} investments with quick payback (≤2 years)",
                'investments': [roi['investment_name'] for roi in quick_payback]
            })
        
        # Recommendations based on NPV
        positive_npv = [roi for roi in self.roi_calculations.values() if roi['npv'] > 0]
        if positive_npv:
            recommendations.append({
                'type': 'positive_npv',
                'message': f"Consider {len(positive_npv)} investments with positive NPV",
                'investments': [roi['investment_name'] for roi in positive_npv]
            })
        
        return recommendations

# Usage example
roi_analysis = SecurityROIAnalysis()

# Add investment
roi_analysis.add_investment('INV-001', {
    'name': 'SIEM Implementation',
    'category': 'technology',
    'initial_cost': 100000,
    'annual_cost': 25000,
    'expected_lifespan': 5,
    'description': 'SIEM implementation for security monitoring'
})

# Add benefits
roi_analysis.add_benefit('BEN-001', {
    'investment_id': 'INV-001',
    'type': 'risk_reduction',
    'description': 'Reduced incident detection time',
    'annual_value': 50000,
    'probability': 0.8
})

roi_analysis.add_benefit('BEN-002', {
    'investment_id': 'INV-001',
    'type': 'compliance',
    'description': 'Regulatory compliance',
    'annual_value': 30000,
    'probability': 0.9
})

# Add costs
roi_analysis.add_cost('COST-001', {
    'investment_id': 'INV-001',
    'type': 'maintenance',
    'description': 'Maintenance and support',
    'annual_cost': 15000
})

# Calculate ROI
roi_result = roi_analysis.calculate_roi('INV-001')
print(f"SIEM ROI: {roi_result['roi_percentage']:.1f}%")
print(f"Payback period: {roi_result['payback_period']} years")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

class HumanResourceManagement:
    def __init__(self):
        self.team_members = {}
        self.skills_matrix = {}
        self.training_programs = {}
        self.performance_metrics = {}
    
    def add_team_member(self, member_id, member_data):
        """Add team member"""
        self.team_members[member_id] = {
            'member_id': member_id,
            'name': member_data['name'],
            'role': member_data['role'],
            'level': member_data.get('level', 'junior'),
            'skills': member_data.get('skills', []),
            'certifications': member_data.get('certifications', []),
            'experience_years': member_data.get('experience_years', 0),
            'salary': member_data.get('salary', 0),
            'availability': member_data.get('availability', 1.0),
            'performance_score': member_data.get('performance_score', 0.0)
        }
    
    def assess_skills_gap(self, required_skills):
        """Assess skills gap"""
        skills_gap = {}
        
        for skill in required_skills:
            skill_name = skill['name']
            required_level = skill['level']
            
            team_skill_levels = []
            for member in self.team_members.values():
                for member_skill in member['skills']:
                    if member_skill['name'] == skill_name:
                        team_skill_levels.append(member_skill['level'])
            
            if team_skill_levels:
                max_team_level = max(team_skill_levels)
                gap = max(0, required_level - max_team_level)
            else:
                gap = required_level
                max_team_level = 0
            
            skills_gap[skill_name] = {
                'required_level': required_level,
                'max_team_level': max_team_level,
                'gap': gap,
                'team_members_with_skill': len([level for level in team_skill_levels if level > 0])
            }
        
        return skills_gap
    
    def create_training_plan(self, member_id, target_skills):
        """Create training plan"""
        if member_id not in self.team_members:
            return None
        
        member = self.team_members[member_id]
        current_skills = {skill['name']: skill['level'] for skill in member['skills']}
        
        training_plan = {
            'member_id': member_id,
            'member_name': member['name'],
            'target_skills': target_skills,
            'training_modules': [],
            'estimated_duration': 0,
            'estimated_cost': 0,
            'priority': 'medium'
        }
        
        for skill in target_skills:
            skill_name = skill['name']
            target_level = skill['level']
            current_level = current_skills.get(skill_name, 0)
            
            if current_level < target_level:
                gap = target_level - current_level
                
                # Determine required training modules
                modules = self.get_training_modules(skill_name, current_level, target_level)
                
                for module in modules:
                    training_plan['training_modules'].append({
                        'skill': skill_name,
                        'module_name': module['name'],
                        'duration_hours': module['duration_hours'],
                        'cost': module['cost'],
                        'provider': module['provider']
                    })
                    
                    training_plan['estimated_duration'] += module['duration_hours']
                    training_plan['estimated_cost'] += module['cost']
        
        # Determine priority based on gap
        total_gap = sum(skill['gap'] for skill in target_skills)
        if total_gap > 10:
            training_plan['priority'] = 'high'
        elif total_gap > 5:
            training_plan['priority'] = 'medium'
        else:
            training_plan['priority'] = 'low'
        
        return training_plan
    
    def get_training_modules(self, skill_name, current_level, target_level):
        """Get training modules"""
        # Training modules database
        training_modules = {
            'network_security': [
                {'name': 'Network Security Fundamentals', 'duration_hours': 40, 'cost': 2000, 'provider': 'Cisco'},
                {'name': 'Advanced Network Security', 'duration_hours': 60, 'cost': 3000, 'provider': 'SANS'},
                {'name': 'Network Penetration Testing', 'duration_hours': 80, 'cost': 4000, 'provider': 'Offensive Security'}
            ],
            'incident_response': [
                {'name': 'Incident Response Fundamentals', 'duration_hours': 32, 'cost': 1500, 'provider': 'SANS'},
                {'name': 'Advanced Incident Response', 'duration_hours': 48, 'cost': 2500, 'provider': 'SANS'},
                {'name': 'Digital Forensics', 'duration_hours': 64, 'cost': 3500, 'provider': 'SANS'}
            ],
            'cloud_security': [
                {'name': 'Cloud Security Fundamentals', 'duration_hours': 24, 'cost': 1200, 'provider': 'AWS'},
                {'name': 'Advanced Cloud Security', 'duration_hours': 40, 'cost': 2000, 'provider': 'Microsoft'},
                {'name': 'Cloud Security Architecture', 'duration_hours': 56, 'cost': 2800, 'provider': 'Google'}
            ]
        }
        
        modules = training_modules.get(skill_name, [])
        
        # Filter modules based on current and target level
        relevant_modules = []
        for module in modules:
            if current_level < 3 and 'Fundamentals' in module['name']:
                relevant_modules.append(module)
            elif current_level >= 3 and current_level < 5 and 'Advanced' in module['name']:
                relevant_modules.append(module)
            elif current_level >= 5 and 'Architecture' in module['name']:
                relevant_modules.append(module)
        
        return relevant_modules
    
    def calculate_team_capacity(self):
        """Calculate team capacity"""
        total_capacity = 0
        available_capacity = 0
        
        for member in self.team_members.values():
            member_capacity = member['availability'] * 40  # 40 hours per week
            total_capacity += member_capacity
            available_capacity += member_capacity
        
        return {
            'total_capacity': total_capacity,
            'available_capacity': available_capacity,
            'utilization_rate': (total_capacity - available_capacity) / total_capacity * 100 if total_capacity > 0 else 0,
            'team_size': len(self.team_members)
        }
    
    def generate_team_report(self):
        """Generate team report"""
        capacity = self.calculate_team_capacity()
        
        # Skills analysis
        all_skills = set()
        for member in self.team_members.values():
            for skill in member['skills']:
                all_skills.add(skill['name'])
        
        skills_analysis = {}
        for skill in all_skills:
            members_with_skill = [m for m in self.team_members.values() 
                                if any(s['name'] == skill for s in m['skills'])]
            skills_analysis[skill] = {
                'team_members': len(members_with_skill),
                'average_level': sum(s['level'] for m in members_with_skill 
                                   for s in m['skills'] if s['name'] == skill) / len(members_with_skill) if members_with_skill else 0
            }
        
        # Performance analysis
        performance_scores = [m['performance_score'] for m in self.team_members.values() if m['performance_score'] > 0]
        average_performance = sum(performance_scores) / len(performance_scores) if performance_scores else 0
        
        report = {
            'team_capacity': capacity,
            'skills_analysis': skills_analysis,
            'average_performance': average_performance,
            'team_members': len(self.team_members),
            'recommendations': self.generate_team_recommendations()
        }
        
        return report
    
    def generate_team_recommendations(self):
        """Generate team recommendations"""
        recommendations = []
        
        capacity = self.calculate_team_capacity()
        
        if capacity['utilization_rate'] > 90:
            recommendations.append("Consider hiring additional staff - high team utilization")
        
        if capacity['utilization_rate'] < 50:
            recommendations.append("Review task allocation - low team utilization")
        
        # Recommendations based on skills
        all_skills = set()
        for member in self.team_members.values():
            for skill in member['skills']:
                all_skills.add(skill['name'])
        
        for skill in all_skills:
            members_with_skill = [m for m in self.team_members.values() 
                                if any(s['name'] == skill for s in m['skills'])]
            
            if len(members_with_skill) < 2:
                recommendations.append(f"Develop {skill} skills - only {len(members_with_skill)} team member(s)")
        
        return recommendations

# Usage example
hr_mgmt = HumanResourceManagement()

# Add team members
hr_mgmt.add_team_member('TM-001', {
    'name': 'Ana García',
    'role': 'Security Analyst',
    'level': 'senior',
    'skills': [
        {'name': 'network_security', 'level': 4},
        {'name': 'incident_response', 'level': 3}
    ],
    'certifications': ['CISSP', 'GCIH'],
    'experience_years': 5,
    'salary': 80000,
    'performance_score': 4.2
})

# Assess skills gap
required_skills = [
    {'name': 'network_security', 'level': 5},
    {'name': 'cloud_security', 'level': 3},
    {'name': 'incident_response', 'level': 4}
]

skills_gap = hr_mgmt.assess_skills_gap(required_skills)
print(f"Skills gap: {skills_gap}")

# Generate team report
team_report = hr_mgmt.generate_team_report()
print(f"Team report: {team_report['team_members']} members")