161 lines
6.5 KiB
Python
161 lines
6.5 KiB
Python
import json, random, io, logging
|
|
|
|
from pulp import LpProblem, LpMinimize, LpMaximize, LpStatus
|
|
|
|
from lib.application_configs import ApplicationConfigs
|
|
from helpers import aws_helper, tar_helper, csv_helper, service_helper
|
|
from lib.errors.item_generation_error import ItemGenerationError
|
|
|
|
from models.solver_run import SolverRun
|
|
from models.solution import Solution
|
|
from models.problem import Problem
|
|
from models.form import Form
|
|
from models.targets.target import Target
|
|
|
|
from services.base import Base
|
|
|
|
class FormGenerationService(Base):
|
|
ACTION = 'formGeneration'
|
|
|
|
def process(self):
|
|
try:
|
|
self.solver_run = self.create_solver_run_from_attributes()
|
|
self.solver_run.generate_bundles()
|
|
self.solver_run.generate_constraints()
|
|
self.solution = self.generate_solution()
|
|
self.result = self.stream_to_s3_bucket()
|
|
except ItemGenerationError as error:
|
|
self.result = self.stream_to_s3_bucket(error)
|
|
except TypeError as error:
|
|
logging.error(error)
|
|
self.result = self.stream_to_s3_bucket(
|
|
ItemGenerationError(
|
|
"Provided params causing error in calculation results"))
|
|
|
|
def create_solver_run_from_attributes(self) -> SolverRun:
|
|
logging.info('Retrieving attributes from message...')
|
|
# get s3 object
|
|
self.key = aws_helper.get_key_from_message(self.source)
|
|
s3_object = aws_helper.get_object(
|
|
self.key, aws_helper.get_bucket_from_message(self.source))
|
|
|
|
# convert to tar
|
|
self.tar = tar_helper.raw_to_tar(s3_object)
|
|
|
|
# get attributes file and convert to dict
|
|
attributes = json.loads(
|
|
tar_helper.extract_file_from_tar(
|
|
self.tar, 'solver_run_attributes.json').read())
|
|
|
|
# create solver run
|
|
solver_run = SolverRun.parse_obj(attributes)
|
|
|
|
# get items file and convert to dict
|
|
items_csv = tar_helper.extract_file_from_tar(self.tar, 'items.csv')
|
|
items_csv_reader = csv_helper.file_stream_reader(items_csv)
|
|
|
|
# add items to solver run
|
|
solver_run.items = service_helper.csv_to_item(items_csv_reader,
|
|
solver_run)
|
|
|
|
logging.info('Processed Attributes...')
|
|
|
|
return solver_run
|
|
|
|
def generate_solution(self) -> Solution:
|
|
logging.info('Generating Solution...')
|
|
|
|
solution = Solution(response_id=random.randint(100, 5000),
|
|
forms=[]) # unsolved solution
|
|
|
|
# iterate for number of forms that require creation
|
|
for form_count in range(self.solver_run.total_forms):
|
|
form_number = form_count + 1
|
|
drift_increment = self.solver_run.max_drift / (self.solver_run.max_attempts - 1)
|
|
current_drift = 0 # FF Tokyo Drift
|
|
current_attempt = 0
|
|
|
|
logging.info(f'Generating Solution for Form {form_number} using the {self.solver_run.irt_model.model} IRT model')
|
|
|
|
# respect max attempts
|
|
# this will likely be more built out when we add increment rate & drif limit
|
|
while current_attempt <= self.solver_run.max_attempts:
|
|
drift_percent = current_drift / 100
|
|
self.solver_run.objective_function.update_targets_drift(
|
|
drift_percent)
|
|
|
|
# create problem
|
|
problem = LpProblem('ata-form-generate', self.solver_run.objective_function.objective)
|
|
problem_handler = Problem(items = self.solver_run.unbundled_items(), bundles = self.solver_run.bundles, problem = problem)
|
|
problem_handler.generate(solution, self.solver_run)
|
|
problem = problem_handler.solve(self.solver_run)
|
|
|
|
if LpStatus[problem.status] == 'Infeasible':
|
|
logging.info(
|
|
f'attempt infeasible for drift of {current_drift}%')
|
|
|
|
if current_drift >= Target.max_drift(
|
|
) or current_attempt >= self.solver_run.max_attempts: # this is the last attempt, so lets finalize the solution
|
|
if ApplicationConfigs.local_dev_env:
|
|
service_helper.print_problem_variables(problem)
|
|
|
|
logging.info(
|
|
f'No feasible solution found for Form {form_number}!'
|
|
)
|
|
logging.error(problem)
|
|
|
|
self.add_form_to_solution(problem, solution)
|
|
|
|
break
|
|
|
|
current_drift += drift_increment
|
|
current_attempt += 1
|
|
else:
|
|
if ApplicationConfigs.local_dev_env:
|
|
service_helper.print_problem_variables(problem)
|
|
|
|
logging.info(
|
|
f'Optimal solution found with drift of {current_drift}%!'
|
|
)
|
|
|
|
self.add_form_to_solution(problem, solution)
|
|
|
|
break
|
|
|
|
logging.info('Solution Generated.')
|
|
|
|
return solution
|
|
|
|
def add_form_to_solution(self, problem: LpProblem, solution: Solution):
|
|
# add return items and create as a form
|
|
form_items, solver_variables = service_helper.solution_items(
|
|
problem.variables(), self.solver_run)
|
|
form = Form.create(form_items, self.solver_run,
|
|
LpStatus[problem.status], solver_variables)
|
|
|
|
solution.forms.append(form)
|
|
|
|
logging.info('Form generated and added to solution...')
|
|
|
|
def stream_to_s3_bucket(self, error=None):
|
|
self.file_name = f'{service_helper.key_to_uuid(self.key)}.csv'
|
|
solution_file = None
|
|
# setup writer buffer and write processed forms to file
|
|
buffer = io.StringIO()
|
|
|
|
if error:
|
|
logging.info('Streaming %s error response to s3 bucket - %s',
|
|
self.file_name,
|
|
ApplicationConfigs.s3_processed_bucket)
|
|
solution_file = service_helper.error_to_file(buffer, error)
|
|
else:
|
|
logging.info('Streaming %s to s3 bucket - %s', self.file_name,
|
|
ApplicationConfigs.s3_processed_bucket)
|
|
solution_file = service_helper.solution_to_file(
|
|
buffer, self.solver_run.total_form_items, self.solution.forms)
|
|
|
|
# upload generated file to s3 and return result
|
|
return aws_helper.file_stream_upload(
|
|
solution_file, self.file_name,
|
|
ApplicationConfigs.s3_processed_bucket, self.ACTION)
|