76 lines
3.6 KiB
Python
76 lines
3.6 KiB
Python
from itertools import combinations
|
|
from pulp import lpSum, LpProblem
|
|
from random import randint, sample
|
|
|
|
from models.bundle import Bundle
|
|
from models.item import Item
|
|
from models.solver_run import SolverRun
|
|
|
|
import logging
|
|
|
|
from lib.errors.item_generation_error import ItemGenerationError
|
|
|
|
def build_constraints(solver_run: SolverRun, problem: LpProblem, items: list[Item], bundles: list[Bundle] or None) -> LpProblem:
|
|
try:
|
|
total_form_items = solver_run.total_form_items
|
|
constraints = solver_run.constraints
|
|
|
|
for constraint in constraints:
|
|
attribute = constraint.reference_attribute
|
|
min = constraint.minimum
|
|
max = constraint.maximum
|
|
|
|
if attribute.type == 'metadata':
|
|
con = dict(zip([item.id for item in solver_run.items],
|
|
[item.attribute_exists(attribute)
|
|
for item in solver_run.items]))
|
|
problem += lpSum([con[item.id]
|
|
* items[item.id]
|
|
for item in solver_run.items]) >= round(total_form_items * (min / 100)), f'{attribute.id} - {attribute.value} - min'
|
|
problem += lpSum([con[item.id]
|
|
* items[item.id]
|
|
for item in solver_run.items]) <= round(total_form_items * (max / 100)), f'{attribute.id} - {attribute.value} - max'
|
|
elif attribute.type == 'bundle' and bundles:
|
|
total_bundle_items = sum(bundle.count for bundle in bundles)
|
|
|
|
for bundle in bundles:
|
|
con = dict(zip([item.id for item in solver_run.items],
|
|
[(getattr(item, bundle.type, False) == bundle.id)
|
|
for item in solver_run.items]))
|
|
problem += lpSum([con[item.id]
|
|
* items[item.id]
|
|
for item in solver_run.items]) == bundle.count, f'Bundle constraint for {bundle.type} ({bundle.id})'
|
|
|
|
# make sure all other items added to the form
|
|
# are not a part of any bundle
|
|
# currently only supports single bundle constraints, will need refactoring for multiple bundle constraints
|
|
con = dict(zip([item.id for item in solver_run.items],
|
|
[(getattr(item, attribute.id, None) == None)
|
|
for item in solver_run.items]))
|
|
problem += lpSum([con[item.id]
|
|
* items[item.id]
|
|
for item in solver_run.items]) == solver_run.total_form_items - total_bundle_items, f'Remaining items are not of a bundle type'
|
|
|
|
return problem
|
|
except ValueError as error:
|
|
logging.error(error)
|
|
raise ItemGenerationError("Bundle min and/or max larger than bundle amount provided", error.args[0])
|
|
|
|
def valid_bundle_combinations(total_form_items: int, total_bundles: int, min_bundles: int, bundles: list[Bundle], selected_bundle_combinations: list[list[Bundle]] = []) -> list[list[Bundle]]:
|
|
if total_bundles < min_bundles:
|
|
return selected_bundle_combinations
|
|
else:
|
|
# generate all bundle combinations
|
|
bundle_combinations = [list(combination) for combination in combinations(bundles, total_bundles)]
|
|
|
|
# iterate through all the combinations
|
|
# if the combination item count is less than or equal to
|
|
# the total items on a form, add it to selected bundles
|
|
for bundle_combination in bundle_combinations:
|
|
total_bundle_items = sum(bundle.count for bundle in bundle_combination)
|
|
if total_bundle_items <= total_form_items:
|
|
selected_bundle_combinations.append(bundle_combination)
|
|
|
|
# recurse to continue generating combinations
|
|
# all the way to the minimum amount of bundles allowed
|
|
return valid_bundle_combinations(total_form_items, total_bundles - 1, min_bundles, bundles, selected_bundle_combinations) |