Resource Allocation Algorithms - Minimize cost given Time

Question

I want assign tasks to workers in a way that cost is minimized given a time constraint.

Suppose:

Labor Cost: $20/hr and handles 10Kg
Machine Cost: $30/hr and handles 20Kg and requires a Machine Operator
Machine Operator Cost: 15$/hr

Constraints:
Total Available Labor = 10 
Total Available Machines = 5
Total Available Machine Operator = 3
Total Required Load to Handle = 1000Kg
Total Available Hours to complete Task = 8

How can I solve this problem using Python? Are there any libraries to solve such problems?

Edit: Objective:

Minimize:

Cost = 20 * ith_labor_time + 30 * jth_Machine_time + 15 * kth_Machine_Operator_time

Now the constraints:

1) 0 <= i(total_labor) <= 10
2) 0 <= j(total_machine) <= 5 (Not 5 because only 3 operators available and machine is dependent on operator)
3) 0 <= k(total_machine_operator_time) <= 3
4) sum(ith_labor_time <= 80)
5) sum(ith_machine_time <= 40)
5) sum(ith_Operator_time) - sum(ith_Machine_time) = 0
6) constraint that total weight handled is 1000kg (unable to make this constraint)
7) machine_time and operator_time are dependent on each other as 1 machine requires 1 operator (I believe this is handled in constraint 5)

Practical Example:

Suppose we have total_labor = 3, total_machines = 3 and total_operators = 3

Cost per labor/hr = $20
Cost per machinery/hr = $30 
Cost per operator/hr = $15 
Labor process rate/hr = 10 Kg
Machine process rate/hr = 20 Kg

Next each labor can work for 8 hours similarly each machinery can work for 8 hours and same for the machine operator they can work for 8 hours.

Task needs to be completed in 8 hours and 1000kg load needs to be processed.

My formulation:

    Min:
    Cost = 20*L1 + 20*L2 + 20*L3 + 30*M1 + 30*M2 + 30*M3 + 15*O1 + 15*O2 + 15*O3
    
    Constraints:
    
    L1 + L2 + L3 <= 24 (if each labor work simultaneously they can total up to 24hrs) 
    L1 <= 8
    L2 <= 8
    L3 <= 8
    M1 + M2 + M3 <= 24 (if each machinery works simultaneously they can total up to 24hrs)
    M1 <= 8
    M2 <= 8
    M3 <= 8  
    M1 + M2 + M3 - O1 - O2 - O3 = 0 (Each machinery requires an operator)
    10*L1 + 10*L2 + 10*L3 + 20*M1 + 20*M2 + 20*M3 = 1000 (Total load to be processed = 1000 Kg)

Code

from scipy.optimize import linprog

c = [20, 20, 20, 30, 30, 30, 15, 15, 15]

A = [[1, 1, 1, 0, 0, 0, 0, 0, 0],
     [0, 0, 0, 1, 1, 1, 0, 0, 0],
     [1, 0, 0, 0, 0, 0, 0, 0, 0],
     [0, 1, 0, 0, 0, 0, 0, 0, 0],
     [0, 0, 1, 0, 0, 0, 0, 0, 0],
     [0, 0, 0, 1, 0, 0, 0, 0, 0],
     [0, 0, 0, 0, 1, 0, 0, 0, 0],
     [0, 0, 0, 0, 0, 1, 0, 0, 0],
     [0, 0, 0, 1, 1, 1, -1, -1, -1]]

A1 = [[10, 10, 10, 20, 20, 20, 0, 0, 0]]

b = [24, 24, 8, 8, 8, 8, 8, 8, 0]
b2 = [1000]
res = linprog(c, A_ub=A, A_eq=A1, b_ub=b, b_eq=b2, method='revised simplex')