def run(self, case_name: str) -> Response:
content = self.load_problem_content(case_name)
try:
result = predict_format(content)
return Response(result, "OK")
except MultiplePredictionResultsError:
return Response(None, "Multiple results")
except NoPredictionResultError:
return Response(None, "No result")
def generate_code(atcoder_client: AtCoderClient,
problem_url: str,
config: Config,
output_file: IOBase):
problem = get_problem_from_url(problem_url)
template_code_path = config.code_style_config.template_file
lang = config.code_style_config.lang
def emit_error(text):
logging.error(with_color(text, Fore.RED))
def emit_warning(text):
logging.warning(text)
def emit_info(text):
logging.info(text)
emit_info('{} is used for template'.format(template_code_path))
# Fetch problem data from the statement
try:
content = atcoder_client.download_problem_content(problem)
except InputFormatDetectionError as e:
emit_error("Failed to download input format.")
raise e
except SampleDetectionError as e:
emit_error("Failed to download samples.")
raise e
try:
prediction_result = predict_format(content)
emit_info(
with_color("Format prediction succeeded", Fore.LIGHTGREEN_EX))
except (NoPredictionResultError, MultiplePredictionResultsError) as e:
prediction_result = FormatPredictionResult.empty_result()
if isinstance(e, NoPredictionResultError):
msg = "No prediction -- Failed to understand the input format"
else:
msg = "Too many prediction -- Failed to understand the input format"
emit_warning(with_color(msg, Fore.LIGHTRED_EX))
constants = predict_constants(content.original_html)
code_generator = config.code_style_config.code_generator
with open(template_code_path, "r") as f:
template = f.read()
output_splitter()
output_file.write(code_generator(
CodeGenArgs(
template,
prediction_result.format,
constants,
config.code_style_config
)))
def generate_code(atcoder_client: AtCoderClient, problem_url: str,
config: Config, output_file: IOBase):
problem = get_problem_from_url(problem_url)
template_code_path = config.code_style_config.template_file
lang = config.code_style_config.lang
def emit_error(text):
logging.error(with_color(text, Fore.RED))
def emit_warning(text):
logging.warning(text)
def emit_info(text):
logging.info(text)
emit_info('{} is used for template'.format(template_code_path))
# Fetch problem data from the statement
try:
content = atcoder_client.download_problem_content(problem)
except InputFormatDetectionError as e:
emit_error("Failed to download input format.")
raise e
except SampleDetectionError as e:
emit_error("Failed to download samples.")
raise e
try:
prediction_result = predict_format(content)
emit_info(with_color("Format prediction succeeded",
Fore.LIGHTGREEN_EX))
except (NoPredictionResultError, MultiplePredictionResultsError) as e:
prediction_result = FormatPredictionResult.empty_result()
if isinstance(e, NoPredictionResultError):
msg = "No prediction -- Failed to understand the input format"
else:
msg = "Too many prediction -- Failed to understand the input format"
emit_warning(with_color(msg, Fore.LIGHTRED_EX))
constants = predict_constants(content.original_html)
code_generator = config.code_style_config.code_generator
with open(template_code_path, "r") as f:
template = f.read()
output_splitter()
output_file.write(
code_generator(
CodeGenArgs(template, prediction_result.format, constants,
config.code_style_config)))
def test_default_code_generators_and_templates(self):
def _full_path(filename):
return os.path.join(RESOURCE_DIR,
"test_default_code_generators_and_templates",
filename)
input_file = _full_path("echo_test_input.txt")
expected_output_file = _full_path("echo_test_output.txt")
pred_result = predict_format(
ProblemContent(load_text_file(
_full_path("echo_test_format.txt")), [
Sample(load_text_file(_full_path("echo_test_input.txt")),
None)
]))
for lang in ALL_LANGUAGES:
expected_default_generated_code_file = _full_path(
os.path.join(
lang.name,
lang.source_code_name("expected_default_generated_code")))
# 1. Compile test with default templates
self._compile_and_run(lang, pred_result.format,
lang.default_template_path,
expected_default_generated_code_file,
input_file)
# 2. Echo test, which tests custom templates having echo output of input
exec_result = self._compile_and_run(
lang, pred_result.format,
_full_path(
os.path.join(lang.name,
lang.source_code_name("echo_template"))),
_full_path(
os.path.join(
lang.name,
lang.source_code_name(
"expected_echo_generated_code"))), input_file)
self.assertEqual(load_text_file(expected_output_file),
exec_result.output)
def test_default_code_generators_and_templates(self):
def _full_path(filename):
return os.path.join(RESOURCE_DIR, "test_default_code_generators_and_templates", filename)
input_file = _full_path("echo_test_input.txt")
expected_output_file = _full_path("echo_test_output.txt")
pred_result = predict_format(
ProblemContent(
load_text_file(_full_path("echo_test_format.txt")),
[Sample(load_text_file(_full_path("echo_test_input.txt")), None)]))
for lang in ALL_LANGUAGES:
expected_default_generated_code_file = _full_path(
os.path.join(lang.name, lang.source_code_name("expected_default_generated_code")))
# 1. Compile test with default templates
self._compile_and_run(
lang,
pred_result.format,
lang.default_template_path,
expected_default_generated_code_file,
input_file
)
# 2. Echo test, which tests custom templates having echo output of input
exec_result = self._compile_and_run(
lang,
pred_result.format,
_full_path(os.path.join(
lang.name, lang.source_code_name("echo_template"))),
_full_path(os.path.join(lang.name, lang.source_code_name(
"expected_echo_generated_code"))),
input_file
)
self.assertEqual(load_text_file(
expected_output_file), exec_result.output)
def prepare_procedure(atcoder_client: AtCoderClient, problem: Problem,
config: Config):
workspace_root_path = config.code_style_config.workspace_dir
template_code_path = config.code_style_config.template_file
lang = config.code_style_config.lang
pid = problem.get_alphabet()
problem_dir_path = os.path.join(workspace_root_path,
problem.get_contest().get_id(), pid)
def emit_error(text):
logger.error(with_color("Problem {}: {}".format(pid, text), Fore.RED))
def emit_warning(text):
logger.warning("Problem {}: {}".format(pid, text))
def emit_info(text):
logger.info("Problem {}: {}".format(pid, text))
emit_info('{} is used for template'.format(template_code_path))
original_html = atcoder_client.download_problem_content_raw_html(problem)
constants = predict_constants(original_html)
if constants.judge_method.judge_type != JudgeType.Interactive:
# Fetch problem data from the statement
try:
content = get_problem_content(original_html)
except InputFormatDetectionError as e:
emit_error("Failed to download input format.")
raise e
except SampleDetectionError as e:
emit_error("Failed to download samples.")
raise e
# Store examples to the directory path
if len(content.get_samples()) == 0:
emit_info("No samples.")
else:
os.makedirs(problem_dir_path, exist_ok=True)
create_examples(content.get_samples(), problem_dir_path,
config.etc_config.in_example_format,
config.etc_config.out_example_format)
emit_info("Created examples.")
code_file_path = os.path.join(problem_dir_path,
"main.{}".format(lang.extension))
# If there is an existing code, just create backup
if os.path.exists(code_file_path):
backup_id = 1
while True:
backup_name = "{}.{}".format(code_file_path, backup_id)
if not os.path.exists(backup_name):
new_path = backup_name
shutil.copy(code_file_path, backup_name)
break
backup_id += 1
emit_info("Backup for existing code '{}' -> '{}'".format(
code_file_path, new_path))
if constants.judge_method.judge_type != JudgeType.Interactive:
try:
prediction_result = predict_format(content)
emit_info(
with_color("Format prediction succeeded", Fore.LIGHTGREEN_EX))
except (NoPredictionResultError, MultiplePredictionResultsError) as e:
prediction_result = FormatPredictionResult.empty_result()
if isinstance(e, NoPredictionResultError):
msg = "No prediction -- Failed to understand the input format"
else:
msg = "Too many prediction -- Failed to understand the input format"
emit_warning(with_color(msg, Fore.LIGHTRED_EX))
else:
prediction_result = FormatPredictionResult.empty_result()
code_generator = config.code_style_config.code_generator
with open(template_code_path, "r") as f:
template = f.read()
create_code(
code_generator(
CodeGenArgs(template, prediction_result.format, constants,
config.code_style_config)), code_file_path)
emit_info("Saved code to {}".format(code_file_path))
# Save metadata
metadata_path = os.path.join(problem_dir_path, "metadata.json")
Metadata(
problem,
os.path.basename(code_file_path),
config.etc_config.in_example_format.replace("{}", "*"),
config.etc_config.out_example_format.replace("{}", "*"),
lang,
constants.judge_method,
).save_to(metadata_path)
emit_info("Saved metadata to {}".format(metadata_path))
if config.postprocess_config.exec_cmd_on_problem_dir is not None:
emit_info(
_message_on_execution(
problem_dir_path,
config.postprocess_config.exec_cmd_on_problem_dir))
config.postprocess_config.execute_on_problem_dir(problem_dir_path)
output_splitter()
def prepare_procedure(atcoder_client: AtCoderClient,
problem: Problem,
config: Config):
workspace_root_path = config.code_style_config.workspace_dir
template_code_path = config.code_style_config.template_file
lang = config.code_style_config.lang
pid = problem.get_alphabet()
problem_dir_path = os.path.join(
workspace_root_path,
problem.get_contest().get_id(),
pid)
def emit_error(text):
logging.error(with_color("Problem {}: {}".format(pid, text), Fore.RED))
def emit_warning(text):
logging.warning("Problem {}: {}".format(pid, text))
def emit_info(text):
logging.info("Problem {}: {}".format(pid, text))
emit_info('{} is used for template'.format(template_code_path))
# Fetch problem data from the statement
try:
content = atcoder_client.download_problem_content(problem)
except InputFormatDetectionError as e:
emit_error("Failed to download input format.")
raise e
except SampleDetectionError as e:
emit_error("Failed to download samples.")
raise e
# Store examples to the directory path
if len(content.get_samples()) == 0:
emit_info("No samples.")
else:
os.makedirs(problem_dir_path, exist_ok=True)
create_examples(content.get_samples(), problem_dir_path,
IN_EXAMPLE_FORMAT, OUT_EXAMPLE_FORMAT)
emit_info("Created examples.")
code_file_path = os.path.join(
problem_dir_path,
"main.{}".format(lang.extension))
# If there is an existing code, just create backup
if os.path.exists(code_file_path):
backup_id = 1
while True:
backup_name = "{}.{}".format(code_file_path, backup_id)
if not os.path.exists(backup_name):
new_path = backup_name
shutil.copy(code_file_path, backup_name)
break
backup_id += 1
emit_info(
"Backup for existing code '{}' -> '{}'".format(
code_file_path,
new_path))
try:
prediction_result = predict_format(content)
emit_info(
with_color("Format prediction succeeded", Fore.LIGHTGREEN_EX))
except (NoPredictionResultError, MultiplePredictionResultsError) as e:
prediction_result = FormatPredictionResult.empty_result()
if isinstance(e, NoPredictionResultError):
msg = "No prediction -- Failed to understand the input format"
else:
msg = "Too many prediction -- Failed to understand the input format"
emit_warning(with_color(msg, Fore.LIGHTRED_EX))
constants = predict_constants(content.original_html)
code_generator = config.code_style_config.code_generator
with open(template_code_path, "r") as f:
template = f.read()
create_code(code_generator(
CodeGenArgs(
template,
prediction_result.format,
constants,
config.code_style_config
)),
code_file_path)
emit_info("Saved code to {}".format(code_file_path))
# Save metadata
metadata_path = os.path.join(problem_dir_path, "metadata.json")
Metadata(problem,
os.path.basename(code_file_path),
IN_EXAMPLE_FORMAT.replace("{}", "*"),
OUT_EXAMPLE_FORMAT.replace("{}", "*"),
lang,
).save_to(metadata_path)
emit_info("Saved metadata to {}".format(metadata_path))
if config.postprocess_config.exec_cmd_on_problem_dir is not None:
emit_info(_message_on_execution(problem_dir_path,
config.postprocess_config.exec_cmd_on_problem_dir))
config.postprocess_config.execute_on_problem_dir(
problem_dir_path)
output_splitter()