method call help

[Yoriz]

Google translation

---

Good morning,
I get a result not which I expect, and I don't know why?
when I call the pricing_mac(self): method of class HardwareGeek(EmployeeHardware): the price does not change, :

When :
kim.pricing_intel() # switch to "PC" pricing
project_o.perform(kim, "PC hardware purchase", 0.5)
kim.pricing_mac() # switch to "MAC" pricing
project_o.perform(kim, "MAC hardware purchase", 1.5)
project_o.perform(ali, "hardware configuration", 2)
project_o.perform(ali, "customer installation", 3)

it displays :

Kim PC hardware purchase 65.00€/h 0.50h 32€
Kim purchase of MAC equipment 75.00€/h 1.50h 112€
Ali hardware configuration 0.00€/h 2.00h 0€
Ali installation at customer 0.00€/h 3.00h 0€

I want this poster:
Kim PC hardware purchase 65.00€/h 0.50h 32€
Kim purchase of MAC equipment 75.00€/h 1.50h 112€
Ali hardware configuration 50.00€/h 2.00h 100€
Ali installation at customer 50.00€/h 3.00h 150€

This is my code:

from abc import ABC, abstractmethod
  
  
class InvoiceCalc:
     """
     Calculation of amounts to be invoiced
     """
     __vat_rate = 0.21
     __instance = None
  
     @classmethod
     def singleton(vat_rate):
         if not InvoiceCalc.__instance:
             InvoiceCalc.__instance = InvoiceCalc()
             InvoiceCalc.__instance.__vat_rate = InvoiceCalc(vat_rate)
  
     def __init__(self):
      pass
  
     def compute_perform(self, price, hard):
         """ calculates the amount to be invoiced (htva, vat, ttc)
             for this employee "emp" and
             for this duration of "hard" performance
             with the hourly rate "price" = emp.price
         """
         amount = hard * price
         return self.compute_expense(amount)
  
     def compute_expense(self, exp):
         """ calculates and returns the amount to be invoiced (htva, vat, ttc)
             for this expense "exp"
         """
         amount = exp
         vat = amount * self.__tax_tva
         amount_ttc = amount + vat
         return ( amount, vat, amount_ttc )
  
class Project:
     """
     Managing an employee's time records
     on a project for a client.
     Do not modify!
     """
     def __init__(self, project="", client=""):
         self.__customer = ""
         self.__project = project
         self.__perform_l = []
         self.__expense_l = []
         self.__customer = customer
  
     def perform(self, emp, det, hard):
         if isinstance(emp, Employee):
             self.__perform_l.append({
                 "name": emp.name,
                 "detail": det,
                 "duration": float(duration),
                 "price": emp.price
             })
  
     def expense(self, emp, subject, amount):
         self.__expense_l.append({
             "name": emp.name,
             "detail": subject,
             "amount": float(amount)
         })
  
     def __iter__(self):
         self.index = 0
         self.inv_calc = InvoiceCalc()
         return self
  
     def __next__(self):
         if self.index >= len(self.__expense_l):
             raise StopIteration
         data = self.__expense_l[self.index]
         self.index += 1
         amount = data['amount']
         excl. vat, vat, ttc = self.inv_calc.compute_expense(amount)
         return f'{data["detail"]},{htva},{tva},{ttc}'
         #return data
  
     def __str__(self):
         # templates
         header_s=\
     """
     Customer: {1}
     Project: {2}
  
     """
         header_perform_s=\
     """
     Detail of services (h, €)
     """
         header_expense_s=\
     """
     Details of expenses (€)
     """
         perform_str = "{2:8} {0:26} {5:>6.2f}€/h {1:>6.2f}h {4:>6.0f}€\n"
         expense_str = "{2:8} {0:26} {4:>6.0f}€\n"
         title_str = "{2:^8} {0:^26} {5:^8} {1:^9} {4:^7}\n"
         t_p = 0 # total service
         t_i = 0 # total billing
         t_e = 0 # total expense
         final_fs = ""
  
         # header
         final_fs += header_s.format("", self.__client, self.__project)
  
         # body "perform"
         final_fs += header_perform_s
         final_fs += title_str.format("TASK", "HARD", "PERSON", "DEPT", "INV", "PRICE")
         for data in self.__perform_l:
             inv_c = InvoiceCalc()
             to_invoice_tuple = inv_c.compute_perform(data["price"], data["duration"])
             final_fs += perform_str.format(
                 data["detail"],
                 data["duration"],
                 data["name"],
                 "",
                 to_invoice_tuple[0],
                 data["price"]
             )
             t_p += data["duration"]
             t_i += to_invoice_tuple[0]
         final_fs += "\n" + perform_str.format("Total perform", t_p, "", "", t_i, 0) + "\n"
  
         # body "expense"
         final_fs += header_expense_s
         final_fs += title_str.format("EXPENSE", "", "PERSON", "DEPT", "INV", "")
         for data in self.__expense_l:
             inv_c = InvoiceCalc()
             to_invoice_tuple = inv_c.compute_expense(data["amount"])
             final_fs += expense_str.format(
                 data["detail"],
                 0,
                 data["name"],
                 "",
                 to_invoice_tuple[0]
             )
             t_e += to_invoice_tuple[0]
         final_fs += "\n" + expense_str.format("Total expense", 0, "", "", t_e) + "\n"
  
         # footer
         final_fs += "\n" + expense_str.format("Grand total", 0, "******", "***********", t_e + t_i) + "\n "
  
         return final_fs

class Employee(ABC):
     def __init__(self, name):
         self.name = name
   
     @property
     @abstractmethod
     def price(self):
         return self.price
         #pass
   
     @property
     @abstractmethod
     def department(self):
         return self.department
         #pass
   
     @classmethod
     deffactory(self, name, function):
         if function == "Geek":
             return Geek(name)
         elif function == "hardware":
             return HardwareGeek(name)
         elif function == "technical manager":
             return TechnicalManager(name)
         elif function == "account manager":
             return AccountManager(name)
         else:
             raise ValueError("Unknown employee type")
         #return EmployeeFake(name)
   
   
class EmployeeFake(Employee):
     department = "circus"
     price = 15
   
   
class EmployeeHardware(Employee):
     department = "hardware"
     project_o = Project("installation of two PCs", "Lehman Brothers Bank")
     emp = "kim"
     det = {"MAC hardware purchase", "hardware configuration", "customer installation"}#"detail"
     hard = 0
     project_o.perform(emp, det, hard)
     detail = detail
   
class Geek(EmployeeHardware):
     price = 60
   
   
class HardwareGeek(EmployeeHardware):
     price = 0
   
     # function to move to the correct class
   
     def pricing_intel(self):
         self.price = 65
         return self.price
         # pass
   
     def pricing_mac(self):
   
         detail = {"MAC hardware purchase", "hardware configuration", "customer installation"}
         if detail == "MAC hardware purchase":
             self.price = 75
         if detail == "hardware configuration":
             self.price = 50
         elif detail == "customer installation":
             self.price = 50
         else:self.price = 75
    
class TechnicalManager(EmployeeHardware):
     price = 90
   
   
class AccountManager(Employee):
     department = "account"
     price = 100
   
   
   
if __name__ == '__main__':
     #
   
     #1)
     kim = Employee.factory("Kim", "hardware") # return HardwareGeek object
     ali = Employee.factory("Ali", "hardware") # return HardwareGeek object
     albert = Employee.factory("Albert", "technical manager") # return TechnicalManager object
     sophie = Employee.factory("Sophie", "account manager") # return AccountManager object
   
     #2)
     project_o = Project("installation of two PCs", "Lehman Brothers Bank")
   
     #3)
     project_o.perform(albert, "meeting with client", 1)
     kim.pricing_intel() # switch to "PC" pricing
     project_o.perform(kim, "PC hardware purchase", 0.5)
     kim.pricing_mac() # switch to "MAC" pricing
     project_o.perform(kim, "MAC hardware purchase", 1.5)
     project_o.perform(ali, "hardware configuration", 2)
     project_o.perform(ali, "customer installation", 3)
     project_o.perform(albert, "key delivery", 0.5)
     project_o.perform(sophie, "agreement with the client", 0.5)
   
     # we add expenses
     project_o.expense(kim, "two PCs and accessories", 1500)
     project_o.expense(kim, "three MACs and accessories", 4500)
   
     print(project_o)
   
     #4)
     print("CSV")
   
     project_it = iter(project_o)
     whileTrue:
         try:
             #iterate
             csv = next(project_it)
             print(csv)
         except StopIteration:
             # when all records have been received
             break

*thanks for the help*