class TestAtCoderClientReal(unittest.TestCase):
def setUp(self):
self.temp_dir = tempfile.mkdtemp()
self.client = AtCoderClient()
def test_submit_source_code(self):
problem_list = self.client.download_problem_list(Contest("arc002"))
self.assertEqual(
['arc002_1',
'arc002_2',
'arc002_3',
'arc002_4'],
[p.problem_id for p in problem_list])
def test_download_problem_content(self):
content = self.client.download_problem_content(
Problem(Contest("arc002"), "C", "arc002_3"))
self.assertEqual("N\nc_{1}c_{2}...c_{N}\n", content.input_format_text)
self.assertEqual(3, len(content.samples))
def test_login_failed(self):
def fake_supplier():
return "@@@ invalid user name @@@", "@@@ password @@@"
try:
self.client.login(credential_supplier=fake_supplier,
use_local_session_cache=False)
self.fail("Unexpectedly, this test succeeded to login.")
except LoginError:
pass
def test_download_all_contests(self):
contests = self.client.download_all_contests()
# Check if the number of contests is more than the number when I wrote
# this unit test.
self.assertGreaterEqual(len(contests), 523)
# Make sure there is no duplication
self.assertEqual(
len(set([c.get_id() for c in contests])),
len(contests))
def test_check_logging_in_is_false(self):
self.assertFalse(self.client.check_logging_in())
def test_cookie_save_and_load(self):
cookie_path = os.path.join(self.temp_dir, "cookie.txt")
session = requests.Session()
loaded = load_cookie_to(session, cookie_path)
self.assertFalse(loaded)
save_cookie(session, cookie_path)
new_session = requests.Session()
loaded = load_cookie_to(new_session, cookie_path)
self.assertTrue(loaded)
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 main(lang='ja'):
alphabet = str(Path('.').absolute().name)
contest_id = str(Path('.').absolute().parent.name)
client = AtCoderClient()
client.login()
ic(client.check_logging_in())
contest = Contest(ic(contest_id))
ic(contest.get_url())
problem_list = client.download_problem_list(ic(contest))
problem = problem_list[['A', 'B', 'C', 'D', 'E', 'F'].index(ic(alphabet))]
html_doc = client.download_problem_content(problem).original_html
soup = BeautifulSoup(html_doc, 'html.parser')
title = soup.find(class_="h2").get_text()
task_statement = soup.find(id="task-statement")
if lang == 'ja':
task_statement = task_statement.find(class_='lang-ja')
def sanitize_html_for_ipynb(html_doc):
replace_dict = {
'<var>': '$',
'</var>': '$',
'<pre>': '<pre><code>',
'</pre>': '</code></pre>'
}
for old_word, new_word in replace_dict.items():
html_doc = html_doc.replace(old_word, new_word)
return ic(html_doc)
title = str(sanitize_html_for_ipynb(str(title)))
title = title.lstrip().split('\n')[0]
task_statement = Tomd(sanitize_html_for_ipynb(str(task_statement)))
with open('problem.md', 'w+') as f:
f.write(f"## {ic(title)}\n")
f.write('---\n')
f.write(task_statement.markdown)
except Exception as e:
print('ログイン/問題取得でエラー Exception = {}'.format(e))
else:
from subprocess import run
from glob import glob
run(['rm', '-r', 'tests'])
run(['mkdir', 'tests'])
for pl in pls:
k = pl.alphabet
v = pl.get_url()
try:
smp = at.download_problem_content(pl)
except Exception as e:
print('{}問題で失敗 Exception = {}'.format(k, e))
else:
for i, tx in enumerate(smp.samples):
fn = k + str(i) + '.in'
f = open('tests/' + fn, 'w')
f.write(tx.get_input())
f.close()
fn = k + str(i) + '.out'
f = open('tests/' + fn, 'w')
f.write(tx.get_output())
f.close()
print('Probiem {} END'.format(k))
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
if __name__ == "__main__":
htmls_dir = "./problem_htmls/"
mkdirs(htmls_dir)
for contest in atcoder.download_all_contests():
for problem in atcoder.download_problem_list(contest):
html_path = os.path.join(
htmls_dir, "{contest}-{problem_id}.html".format(
contest=contest.get_id(),
problem_id=problem.get_alphabet()))
if os.path.exists(html_path):
print(
"{} already exists -- skipping download".format(html_path))
continue
print("Downloading {}".format(html_path))
try:
html = atcoder.download_problem_content(problem).original_html
with open(html_path, 'w') as f:
f.write(html)
except Exception as e:
print("Failed to download {}. {}".format(html_path, e))
print("Skipping ...")
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(extension(lang)))
# 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()
def mkdirs(path):
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
if __name__ == "__main__":
htmls_dir = "./problem_htmls/"
mkdirs(htmls_dir)
for contest in atcoder.download_all_contests():
for problem in atcoder.download_problem_list(contest):
html_path = os.path.join(htmls_dir, "{contest}-{problem_id}.html".format(
contest=contest.get_id(), problem_id=problem.get_alphabet()))
if os.path.exists(html_path):
print(
"{} already exists -- skipping download".format(html_path))
continue
print("Downloading {}".format(html_path))
try:
html = atcoder.download_problem_content(problem).original_html
with open(html_path, 'w') as f:
f.write(html)
except Exception as e:
print("Failed to download {}. {}".format(html_path, e))
print("Skipping ...")
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()
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
if __name__ == "__main__":
for contest in atcoder.download_all_contests():
for problem in atcoder.download_problem_list(contest):
path = "./test_data/{contest}-{problem_id}".format(contest=contest.get_id(),
problem_id=problem.get_alphabet())
if os.path.exists(path) and len(os.listdir(path)) != 0:
print("{} already exists -- skipping download".format(path))
continue
try:
content = atcoder.download_problem_content(problem)
mkdirs(path)
with open("{}/{}".format(path, "format.txt"), "w") as f:
f.write(content.get_input_format())
for idx, sample in enumerate(content.get_samples()):
with open("{}/ex_{}.txt".format(path, idx + 1), "w") as f:
f.write(sample.get_input())
except SampleDetectionError:
print(
"failed to parse samples for {} {} -- skipping download".format(contest.get_id(),
problem.get_alphabet()))
except InputFormatDetectionError:
print(
"failed to parse input for {} {} -- skipping download".format(contest.get_id(),
