A lot of starter code just need to implement 2 methods all instructions and sample tests are provided (Should not take long) (USING PYTHON 3.9) 1) Implement Employee.total_pay. Read the header and docstring for the new method. Decide if it should be implemented in the base class, or made abstract and implemented in the subclasses. (Even though the doctest for this method is in the base class, we can still make it an abstract method.) You may add new instance attribute(s) to implement the required functionality; just make sure to document them in the class docstring, add type annotations for them, and initialize them properly. You may assume as a precondition that the pay method is not called on the same employee twice in the same month. (Remember: "precondition" means here that your implementation can assume that it's true, and does not need to check for it.) 2) Implement Company.total_payroll. Read the header docstring for this method carefully. To implement this method, you should not need to add any additional attributes in the Company class. (DO NOT MAKE CHANGES TO OTHER METHODS + DO NOT IMPORT ANYTHING) (Methods that need to be implemented have #TODO) Sample Tests: def test_total_pay_basic() -> None: e = SalariedEmployee (14, 'Gilbert the cat', 1200.0) e.pay(date (2018, 6, 28)) e.pay(date(2018, 7, 28)) e.pay(date (2018, 8, 28)) assert e.total_pay() == 300.0 def test total_payroll_mixed () -> None: my_corp = Company ( [Salaried Employee (24, Gilbert the cat', 1200.0), Hourly Employee (25, 'Chairman Meow', 500.25, 1)]) (2018, 6, 28)) my_corp.pay_all(date assert my_corp.total_payroll() == 600.25 For the given code implement the methods Employee.total_pay and Company.total_payroll : === Module Description === This module contains an illustration of *inheritance* through an abstract Employee class that defines a common interface for all of its subclasses. from datetime import date class Employee: """An employee of a company. This is an abstract class. Only child classes should be instantiated. ===Public attributes === id_: This employee's ID number. name: This employee's name. id: int name: str def _init_(self, id: int, name: str) -> None: """Initialize this employee. Note: This initializer is meant for internal use only; Employee is an abstract class and should not be instantiated directly. self.id_ = id_ self.name = name def get_monthly payment (self) -> float: ***"Return the amount that this Employee should be paid in one month. Round the amount to the nearest cent. MILIT raise NotImplemented Error def pay(self, pay_date: date) -> None: """Pay this Employee on the given date and record the payment. (Assume this is called once per month.) HIGH payment = self.get_monthly payment () print (f'An employee was paid (payment) on {pay_date}.') def total pay (self) -> float: """Return the total amount of pay this Employee has received. >>> e = Salaried Employee (14, 'Gilbert the cat', 1200.0) >>> e.pay (date (2018, 6, 28)) An employee was paid 100.0 on 2018-06-28. >>> e.pay (date (2018, 7, 28)) An employee was paid 100.0 on 2018-07-28. >>> e.pay (date (2018, 8, 28)) An employee was paid 100.0 on 2018-08-28. >>> e.total_pay() 300.0 MILI #TODO: implement this method! pass class Salaried Employee (Employee): """An employee whose pay is computed based on an annual salary. ===Public attributes === salary: This employee's annual salary === Representation invariants === salary >= 0 - id: int name: str salary: float definit_(self, id int, name: str, salary: float) -> None: """Initialize this salaried Employee. >>> e = salaried Employee (14, 'Fred Flintstone', 5200.0) >>> e.salary 5200.0 # Note that to call the superclass' initializer, we need to use the # full name '_init_'. This is the only time we write '__init__* # explicitly. Employee. _init__(self, id, name) self.salary salary def get_monthly payment (self) -> float: ***Return the amount that this Employee should be paid in one month. = Round the amount to the nearest cent. >>> e = Salaried Employee (99, 'Mr slate', 120000.0) >>> e.get_monthly_payment() 10000.0 It return round(self.salary 12, 2) class HourlyEmployee (Employee): """An employee whose pay is computed based on an hourly rate. === Public attributes== hourly_wage: This employee's hourly rate of pay. hours_per_month: The number of hours this employee works each month. === Representation invariants === - hourly_wage >= 0 hours_per_month >= 0 FEST id_: int name: str hourly wage: float hours_per_month: float def_init_(self, id: int, name: str, hourly wage: float, hours_per_month: float) -> None: """Initialize this Hourly Employee. >>> barney = HourlyEmployee (23, 'Barney Rubble', 1.25, 50.0) >>> barney.hourly_wage 1.25 >>> barney.hours_per_month 50.0 Employee._init_(self, id, name) self.hourly wage = hourly wage self.hours_per_month= hours_per_month def get_monthly payment (self) -> float: ***"Return the amount that this Employee should be paid in one month. Round the amount to the nearest cent. >>> e = Hourly Employee (23, Barney Rubble', 1.25, 50.0) >>> e.get_monthly_payment() 62.5 HIU monthly_total = self.hours_per_month *self.hourly_wage return round(monthly_total, 2) class Company: """A company with employees. We use this class mainly as a client for the various Employee classes we defined in employee. === Attributes === employees: the employees in the company. employees: list [Employee] def _init_(self, employees: list[Employee]) -> None: self. employees = employees def pay_all(self, pay_date: date) -> None: """Pay all employees at this company. for employee in self.employees: employee.pay (pay_date) www def total_payroll(self) -> float: ***"Return the total of all payments ever made to all employees. >>> my_corp = Company ([\ SalariedEmployee (24, "Gilbert the cat', 1200.0), \ HourlyEmployee (25, 'Chairman Meow', 500.25, 1.0)]) >>> my_corp.pay_all(date (2022, 6, 28)) An employee was paid 100.0 on 2022-06-28. An employee was paid 500.25 on 2022-06-28. >>> my_corp.total_payroll() 600.25 # TODO: implement this method! pass