# -*- coding: utf-8 -*-
# @author:

POSITIVE_WORDS = {"excellent", "good", "dependable"}
NEGATIVE_WORDS = {"poor", "error", "unreliable", "late"}

class EmployeePerformances:
"""
A class that implements analysis of annual employee performance for ABC Consulting professional staff
"""

def __init__(self, init_data_path="emp_beg_yr.txt", sales_path="sales.txt"):
   # initialize a main dictionary that will contain employee performance
   self.employee_performances = dict()

   # initial data for all employees
   with open(init_data_path) as file:
         file_lines = file.readlines()

   # generate initial dictionary,
   # use an employee ID as a key and dictionary that contains employee information as a value
   for line in file_lines[1:]:
         Id, last_name, first_name, job_code, base_pay = line.strip().split(",")
         self.employee_performances[Id] = dict(
            last_name=last_name, first_name=first_name, job_code=job_code, base_pay=int(base_pay)
         )

   # load new sales (only for Directors)
   sales = dict()
   with open(sales_path) as file:
         file_lines = file.readlines()
   for line in file_lines:
         Id, sale = line.split(",")
         sales[Id] = int(sale)

   # add sales to the main dictionary
   for Id, item in self.employee_performances.items():
         if item["job_code"] == "D":
            if Id not in sales:
               # if new sale is not provided for a Director, set a sale to zero
               self.employee_performances[Id]["sale"] = 0
            else:
               self.employee_performances[Id]["sale"] = sales[Id]

   self.employees_Ids = set(self.employee_performances.keys())

def hours_worked(self, path="timesheet.txt"):
   # a method that calculates utilization rate
   hours_worked_per_employee = dict()

   # load the data from the file
   with open(path, "r") as file:
         file_lines = file.readlines()

   # iterate over all records and calculate total hours worked annually for each emplolyee
   for line in file_lines:
         Id, hours_worked_per_project = line.split(",")
         if Id not in hours_worked_per_employee:
            hours_worked_per_employee[Id] = 0
         hours_worked_per_employee[Id] += int(hours_worked_per_project)

   # calculate utilization rate and add it to the main dictionary
   # if employee not have had any engagement in the year, set utilization rate to zero
   for Id in self.employee_performances.keys():
         if Id in hours_worked_per_employee:
            hours = hours_worked_per_employee[Id]
            score = int(round(100 * hours / 2250))
            self.employee_performances[Id]["utilization"] = score
         else:
            self.employee_performances[Id]["utilization"] = 0

   hours_worked_per_employee_Ids = set(hours_worked_per_employee.keys())

   error_Ids = hours_worked_per_employee_Ids.difference(self.employees_Ids)
   with open("error.txt", "a") as file:
         for Id in error_Ids:
            file.write(f"{Id} in timesheet.txt\n")

def textual_evaluation(self, path="evaluation.txt"):
   # a method that evaluation score from comments
   employee_textual_evaluation = dict()

   # load comments from the file
   with open(path, "r") as file:
         file_lines = file.readlines()

   for line in file_lines:
         Id, text_eval = line.split("#")
         # count the number of negative and possutive words in each comment
         neg_words_count = sum([text_eval.lower().count(word) for word in NEGATIVE_WORDS])
         pos_words_count = sum([text_eval.lower().count(word) for word in POSITIVE_WORDS])
         if pos_words_count + neg_words_count > 0:
            # calculate the score
            score = 100 * (pos_words_count - neg_words_count) / (pos_words_count + neg_words_count)
            score = int(round(score))
         else:
            score = 0
         employee_textual_evaluation[Id] = score

Part 1: Poker Odds In this part of the lab, we'll be estimating th...