Use 'problem' instead of 'question', 'solution' instead of 'answer', and...

# Project-specific files

/conf.json

/questions/*

!/questions/.gitkeep

/answers/*

!/answers/.gitkeep

/problems/*

!/problems/.gitkeep

/solutions/*

!/solutions/.gitkeep

# Byte-compiled / optimized / DLL files

    # return adc2019system.role.role

    return render_template('index.html')

@webui.route('/template/questions')

def webui_template_questions():

@webui.route('/part/problems')

def webui_part_problems():

    if (adc2019system.role is not None) and (adc2019system.role.type == 'host'):

        questions = adc2019system.role.get_questions()

        return render_template('part_questions.html', questions=questions)

        problems = adc2019system.role.get_problems()

        return render_template('part_problems.html', problems=problems)

    else:

        return abort(404)

@webui.route('/template/system-summary')

def webui_template_workers():

@webui.route('/part/system-summary')

def webui_parte_workers():

    if (adc2019system.role is not None) and (adc2019system.role.type == 'host'):

        workers = adc2019system.role.get_workers()

        return render_template('part_system_summary.html', workers=workers)

    else:

        return abort(404)

@webui.route('/template/question/<name>')

def webui_template_question_status(name=None):

@webui.route('/part/problem/<name>')

def webui_partem_status(name=None):

    if name is None:

        return abort(404)

    if (adc2019system.role is not None) and (adc2019system.role.type == 'host'):

        question = adc2019system.role.get_question(name)

        if question is None:

        problem = adc2019system.role.get_problem(name)

        if problem is None:

            return abort(404)

        else:

            return render_template('part_question_status.html', question=question)

            return render_template('part_problem_status.html', problem=problem)

    else:

        return abort(404)

import time

import requests

from utils import Question

from utils import Problem

class Host(object):

        self.type = 'host'

        self.config = config

        self.questions = dict()

        self.problems = dict()

        self.worker_manager = None

        self.request = dict()

        self.processing_request = None

        self._load_questions(config['question_path'])

        self._load_problems(config['problem_path'])

        self._setup_workers()

    def __repr__(self):

        return "Host"

    def _load_questions(self, path):

    def _load_problems(self, path):

        questions_path = glob.glob(path)

        problems_path = glob.glob(path)

        questions_path = sorted(questions_path)

        problems_path = sorted(problems_path)

        for v in questions_path:

        for v in problems_path:

            question = Question(v)

            _key = question.name

            problem = Problem(v)

            _key = problem.name

            self.questions[_key] = question

            self.problems[_key] = problem

    def _setup_workers(self):

    def get_workers(self):

        return self.worker_manager.get_workers()

    def distribute_question(self, question_key):

    def distribute_problem(self, problem_key):

        question = self.get_question(question_key)

        if question is None:

        problem = self.get_problem(problem_key)

        if problem is None:

            return {'status': 'key error'}

        else:

            request = Request(self.worker_manager, question.get_dict())

            request = Request(self.worker_manager, problem.get_dict())

            request_id = request.get_id()

            self.request[request_id] = request

                'timeout': request.timeout

                }

    def get_questions(self):

        return self.questions

    def get_problems(self):

        return self.problems

    def get_question(self, _key):

        if _key in self.questions:

            return self.questions[_key]

    def get_problem(self, _key):

        if _key in self.problems:

            return self.problems[_key]

        else:

            return None

        else:

            print(f'W: Unknown request_id: {request_id}')

        question_key = solution['question']

        problem_key = solution['problem']

        if question_key in self.questions:

            self.questions[question_key].put_solution(solution)

        if problem_key in self.problems:

            self.problems[problem_key].put_solution(solution)

            return {'status': 'registered'}

        else:

            return {'status': 'error'}

        if cmd == 'role':

            # サーバの役割確認

            return {'role': self.type}

        elif cmd == 'question/solve':

            # params['question']に指定された問題をworkerに配信

            question_key = params['question']

            return self.distribute_question(question_key)

        elif cmd == 'question/solution':

        elif cmd == 'problem/solve':

            # params['problem']に指定された問題をworkerに配信

            problem_key = params['problem']

            return self.distribute_problem(problem_key)

        elif cmd == 'problem/solution':

            self.store_solution(params)

            return {'status': 'received'}

        elif cmd == 'request/status':

        if self.broadcast_time is None:

            progress = 0,

        else:

            progress_question =  response_count / worker_count * 100

            progress_problem =  response_count / worker_count * 100

            progress_time = (time.time() - self.broadcast_time) / self.timeout * 100

            progress = min(100, max(progress_question, progress_time))

            progress = min(100, max(progress_problem, progress_time))

        worker_list = self.worker_manager.get_workers().keys()

        worker_status = dict()

    def submit_solution(self, params, solution):

        data = {

            'request_id': params['request_id'],

            'question': params['name'],

            'problem': params['name'],

            'worker': self.address

        }

        data.update(solution)

        self.post('question/solution', data)

        self.post('problem/solution', data)

    def start_solver(self, params):