def match(a, b):
# On Windows, a temp file is not created if we use "with" statement,
user_output = tempfile.NamedTemporaryFile(delete=False)
judge_result = False
try:
if rstrip:
user_output.write(a.rstrip(rstrip_targets).encode())
else:
user_output.write(a.encode())
user_output.close()
arg0 = judge
arg1 = str(test_input_path.resolve())
arg2 = user_output.name
arg3 = str((str(test_output_path.resolve()) if test_output_path is not None else ''))
actual_command = '{} {} {} {}'.format(arg0, arg1, arg2, arg3) # TODO: quote arguments for paths including spaces; see https://github.com/kmyk/online-judge-tools/pull/584
log.status('$ %s', actual_command)
info, proc = utils.exec_command(actual_command)
if not silent:
log.emit('judge\'s output:\n%s', utils.make_pretty_large_file_content(info['answer'] or b'', limit=40, head=20, tail=10, bold=True))
judge_result = (proc.returncode == 0)
finally:
os.unlink(user_output.name)
return judge_result
def format_code(code: bytes, dos2unix: bool = False, rstrip: bool = False) -> bytes:
if dos2unix:
log.status('dos2unix...')
code = code.replace(b'\r\n', b'\n')
if rstrip:
log.status('rstrip...')
code = code.rstrip()
return code
def _flush(self) -> None:
# halve the size if it is more than 1MiB
if self.path.stat().st_size >= 1024 * 1024:
with open(str(self.path)) as fh:
history_lines = fh.readlines()
with open(str(self.path), 'w') as fh:
fh.write(''.join(history_lines[:-len(history_lines) // 2]))
log.status('halve history at: %s', self.path)
def remove(self, *, directory: pathlib.Path) -> None:
if not self.path.exists():
return
log.status('clear the downloading history for this directory: %s',
self.path)
with open(str(self.path)) as fh:
history_lines = fh.readlines()
with open(str(self.path), 'w') as fh:
pred = lambda line: pathlib.Path(json.loads(line)['directory']
) != directory
fh.write(''.join(filter(pred, history_lines)))
def add(self, problem: Problem, *, directory: pathlib.Path) -> None:
log.status('append the downloading history: %s', self.path)
self.path.parent.mkdir(parents=True, exist_ok=True)
with open(str(self.path), 'a') as fh:
fh.write(
json.dumps({
'timestamp': int(
time.time()
), # this should not be int, but Python's strptime is too weak and datetime.fromisoformat is from 3.7
'directory': str(directory),
'url': problem.get_url(),
}) + '\n')
self._flush()
def get(self, *, directory: pathlib.Path) -> List[str]:
if not self.path.exists():
return []
log.status('read history from: %s', self.path)
found = set()
with open(str(self.path)) as fh:
for line in fh:
try:
data = json.loads(line)
except json.decoder.JSONDecodeError as e:
log.warning('corrupted line found in: %s', self.path)
log.debug('%s', traceback.format_exc())
continue
if pathlib.Path(data['directory']) == directory:
found.add(data['url'])
log.status('found urls in history:\n%s', '\n'.join(found))
return list(found)
def test_single_case(test_name: str, test_input_path: pathlib.Path, test_output_path: Optional[pathlib.Path], *, lock: Optional[threading.Lock] = None, args: 'argparse.Namespace') -> Dict[str, Any]:
# print the header earlier if not in parallel
if lock is None:
log.emit('')
log.info('%s', test_name)
# run the binary
with test_input_path.open() as inf:
info, proc = utils.exec_command(args.command, stdin=inf, timeout=args.tle, gnu_time=args.gnu_time)
# TODO: the `answer` should be bytes, not str
answer = (info['answer'] or b'').decode(errors='replace') # type: str
elapsed = info['elapsed'] # type: float
memory = info['memory'] # type: Optional[float]
# lock is require to avoid mixing logs if in parallel
nullcontext = contextlib.ExitStack() # TODO: use contextlib.nullcontext() after updating Python to 3.7
with lock or nullcontext:
if lock is not None:
log.emit('')
log.info('%s', test_name)
log.status('time: %f sec', elapsed)
if memory:
if memory < MEMORY_PRINT:
if args.print_memory:
log.status('memory: %f MB', memory)
elif memory < MEMORY_WARNING:
log.status('memory: %f MB', memory)
else:
log.warning('memory: %f MB', memory)
status = compare_and_report(proc, answer, memory, test_input_path, test_output_path, mle=args.mle, mode=args.display_mode, error=args.error, does_print_input=args.print_input, silent=args.silent, rstrip=args.rstrip, judge=args.judge)
# return the result
testcase = {
'name': test_name,
'input': str(test_input_path.resolve()),
}
if test_output_path:
testcase['output'] = str(test_output_path.resolve())
return {
'status': status,
'testcase': testcase,
'output': answer,
'exitcode': proc.returncode,
'elapsed': elapsed,
'memory': memory,
}
def request(method: str,
url: str,
session: requests.Session,
raise_for_status: bool = True,
**kwargs) -> requests.Response:
assert method in ['GET', 'POST']
kwargs.setdefault('allow_redirects', True)
log.status('%s: %s', method, url)
if 'data' in kwargs:
log.debug('data: %s', repr(kwargs['data']))
resp = session.request(method, url, **kwargs)
if resp.url != url:
log.status('redirected: %s', resp.url)
log.status(describe_status_code(resp.status_code))
if raise_for_status:
resp.raise_for_status()
return resp
def guess_lang_ids_of_file(filename: pathlib.Path, code: bytes, language_dict, cxx_latest: bool = False, cxx_compiler: str = 'all', python_version: str = 'all', python_interpreter: str = 'all') -> List[str]:
assert cxx_compiler in ('gcc', 'clang', 'all')
assert python_version in ('2', '3', 'auto', 'all')
assert python_interpreter in ('cpython', 'pypy', 'all')
ext = filename.suffix
lang_ids = language_dict.keys()
log.debug('file extension: %s', ext)
ext = ext.lstrip('.')
if ext in ('cpp', 'cxx', 'cc', 'C'):
log.debug('language guessing: C++')
# memo: https://stackoverflow.com/questions/1545080/c-code-file-extension-cc-vs-cpp
lang_ids = list(filter(lambda lang_id: is_cplusplus_description(language_dict[lang_id]), lang_ids))
if not lang_ids:
return []
log.debug('all lang ids for C++: %s', lang_ids)
# compiler
found_gcc = False
found_clang = False
for lang_id in lang_ids:
compiler = parse_cplusplus_compiler(language_dict[lang_id])
if compiler == 'gcc':
found_gcc = True
elif compiler == 'clang':
found_clang = True
if found_gcc and found_clang:
log.status('both GCC and Clang are available for C++ compiler')
if cxx_compiler == 'gcc':
log.status('use: GCC')
lang_ids = list(filter(lambda lang_id: parse_cplusplus_compiler(language_dict[lang_id]) in ('gcc', None), lang_ids))
elif cxx_compiler == 'clang':
log.status('use: Clang')
lang_ids = list(filter(lambda lang_id: parse_cplusplus_compiler(language_dict[lang_id]) in ('clang', None), lang_ids))
else:
assert cxx_compiler == 'all'
log.debug('lang ids after compiler filter: %s', lang_ids)
# version
if cxx_latest:
saved_lang_ids = lang_ids
lang_ids = []
for compiler in ('gcc', 'clang'): # use the latest for each compiler
ids = list(filter(lambda lang_id: parse_cplusplus_compiler(language_dict[lang_id]) in (compiler, None), saved_lang_ids))
if not ids:
continue
ids.sort(key=lambda lang_id: (parse_cplusplus_version(language_dict[lang_id]) or '', language_dict[lang_id]))
lang_ids += [ids[-1]] # since C++11 < C++1y < ... as strings
log.debug('lang ids after version filter: %s', lang_ids)
assert lang_ids
lang_ids = sorted(set(lang_ids))
return lang_ids
elif ext == 'py':
log.debug('language guessing: Python')
# interpreter
lang_ids = list(filter(lambda lang_id: is_python_description(language_dict[lang_id]), lang_ids))
if any([parse_python_interpreter(language_dict[lang_id]) == 'pypy' for lang_id in lang_ids]):
log.status('PyPy is available for Python interpreter')
if python_interpreter != 'all':
lang_ids = list(filter(lambda lang_id: parse_python_interpreter(language_dict[lang_id]) == python_interpreter, lang_ids))
# version
three_found = False
two_found = False
for lang_id in lang_ids:
version = parse_python_version(language_dict[lang_id])
log.debug('%s (%s) is recognized as Python %s', lang_id, language_dict[lang_id], str(version or 'unknown'))
if version == 3:
three_found = True
if version == 2:
two_found = True
if two_found and three_found:
log.status('both Python2 and Python3 are available for version of Python')
if python_version in ('2', '3'):
versions = [int(python_version)] # type: List[Optional[int]]
elif python_version == 'all':
versions = [2, 3]
else:
assert python_version == 'auto'
lines = code.splitlines()
if code.startswith(b'#!'):
s = lines[0] # use shebang
else:
s = b'\n'.join(lines[:10] + lines[-5:]) # use modelines
versions = []
for version in (2, 3):
if re.search(r'python *(version:? *)?%d'.encode() % version, s.lower()):
versions += [version]
if not versions:
log.status('no version info in code')
versions = [3]
log.status('use: %s', ', '.join(map(str, versions)))
lang_ids = list(filter(lambda lang_id: parse_python_version(language_dict[lang_id]) in versions + [None], lang_ids))
lang_ids = sorted(set(lang_ids))
return lang_ids
else:
log.debug('language guessing: others')
table = [
{ 'names': [ 'awk' ], 'exts': [ 'awk' ] },
{ 'names': [ 'bash' ], 'exts': [ 'sh' ] },
{ 'names': [ 'brainfuck' ], 'exts': [ 'bf' ] },
{ 'names': [ 'c#' ], 'exts': [ 'cs' ] },
{ 'names': [ 'c' ], 'exts': [ 'c' ], 'split': True },
{ 'names': [ 'ceylon' ], 'exts': [ 'ceylon' ] },
{ 'names': [ 'clojure' ], 'exts': [ 'clj' ] },
{ 'names': [ 'common lisp' ], 'exts': [ 'lisp', 'lsp', 'cl' ] },
{ 'names': [ 'crystal' ], 'exts': [ 'cr' ] },
{ 'names': [ 'd' ], 'exts': [ 'd' ], 'split': True },
{ 'names': [ 'f#' ], 'exts': [ 'fs' ] },
{ 'names': [ 'fortran' ], 'exts': [ 'for', 'f', 'f90', 'f95', 'f03' ] },
{ 'names': [ 'go' ], 'exts': [ 'go' ], 'split': True },
{ 'names': [ 'haskell' ], 'exts': [ 'hs' ] },
{ 'names': [ 'java' ], 'exts': [ 'java' ] },
{ 'names': [ 'javascript' ], 'exts': [ 'js' ] },
{ 'names': [ 'julia' ], 'exts': [ 'jl' ] },
{ 'names': [ 'kotlin' ], 'exts': [ 'kt', 'kts' ] },
{ 'names': [ 'lua' ], 'exts': [ 'lua' ] },
{ 'names': [ 'nim' ], 'exts': [ 'nim' ] },
{ 'names': [ 'moonscript' ], 'exts': [ 'moon' ] },
{ 'names': [ 'objective-c' ], 'exts': [ 'm' ] },
{ 'names': [ 'ocaml' ], 'exts': [ 'ml' ] },
{ 'names': [ 'octave' ], 'exts': [ 'm' ] },
{ 'names': [ 'pascal' ], 'exts': [ 'pas' ] },
{ 'names': [ 'perl6' ], 'exts': [ 'p6', 'pl6', 'pm6' ] },
{ 'names': [ 'perl' ], 'exts': [ 'pl', 'pm' ], 'split': True },
{ 'names': [ 'php' ], 'exts': [ 'php' ] },
{ 'names': [ 'ruby' ], 'exts': [ 'rb' ] },
{ 'names': [ 'rust' ], 'exts': [ 'rs' ] },
{ 'names': [ 'scala' ], 'exts': [ 'scala' ] },
{ 'names': [ 'scheme' ], 'exts': [ 'scm' ] },
{ 'names': [ 'sed' ], 'exts': [ 'sed' ] },
{ 'names': [ 'standard ml' ], 'exts': [ 'sml' ] },
{ 'names': [ 'swift' ], 'exts': [ 'swift' ] },
{ 'names': [ 'text' ], 'exts': [ 'txt' ] },
{ 'names': [ 'typescript' ], 'exts': [ 'ts' ] },
{ 'names': [ 'unlambda' ], 'exts': [ 'unl' ] },
{ 'names': [ 'vim script' ], 'exts': [ 'vim' ] },
{ 'names': [ 'visual basic' ], 'exts': [ 'vb' ] },
] # type: List[Dict[str, Any]] # yapf: disable
lang_ids = []
for data in table:
if ext in data['exts']:
for name in data['names']:
lang_ids += select_ids_of_matched_languages([name], language_dict.keys(), language_dict=language_dict, split=data.get('split', False))
return sorted(set(lang_ids))
def submit(args: 'argparse.Namespace') -> None:
# guess url
history = onlinejudge_command.download_history.DownloadHistory()
if args.file.parent.resolve() == pathlib.Path.cwd():
guessed_urls = history.get(directory=pathlib.Path.cwd())
else:
log.warning('cannot guess URL since the given file is not in the current directory')
guessed_urls = []
if args.url is None:
if len(guessed_urls) == 1:
args.url = guessed_urls[0]
log.info('guessed problem: %s', args.url)
else:
log.error('failed to guess the URL to submit')
log.info('please manually specify URL as: $ oj submit URL FILE')
sys.exit(1)
# parse url
problem = dispatch.problem_from_url(args.url)
if problem is None:
sys.exit(1)
# read code
with args.file.open('rb') as fh:
code = fh.read() # type: bytes
format_config = {
'dos2unix': args.format_dos2unix or args.golf,
'rstrip': args.format_dos2unix or args.golf,
}
code = format_code(code, **format_config)
# report code
log.info('code (%d byte):', len(code))
log.emit(utils.make_pretty_large_file_content(code, limit=30, head=10, tail=10, bold=True))
with utils.new_session_with_our_user_agent(path=args.cookie) as sess:
# guess or select language ids
language_dict = {language.id: language.name for language in problem.get_available_languages(session=sess)} # type: Dict[LanguageId, str]
matched_lang_ids = None # type: Optional[List[str]]
if args.language in language_dict:
matched_lang_ids = [args.language]
else:
if args.guess:
kwargs = {
'language_dict': language_dict,
'cxx_latest': args.guess_cxx_latest,
'cxx_compiler': args.guess_cxx_compiler,
'python_version': args.guess_python_version,
'python_interpreter': args.guess_python_interpreter,
}
matched_lang_ids = guess_lang_ids_of_file(args.file, code, **kwargs)
if not matched_lang_ids:
log.info('failed to guess languages from the file name')
matched_lang_ids = list(language_dict.keys())
if args.language is not None:
log.info('you can use `--no-guess` option if you want to do an unusual submission')
matched_lang_ids = select_ids_of_matched_languages(args.language.split(), matched_lang_ids, language_dict=language_dict)
else:
if args.language is None:
matched_lang_ids = None
else:
matched_lang_ids = select_ids_of_matched_languages(args.language.split(), list(language_dict.keys()), language_dict=language_dict)
# report selected language ids
if matched_lang_ids is not None and len(matched_lang_ids) == 1:
args.language = matched_lang_ids[0]
log.info('chosen language: %s (%s)', args.language, language_dict[LanguageId(args.language)])
else:
if matched_lang_ids is None:
log.error('language is unknown')
log.info('supported languages are:')
elif len(matched_lang_ids) == 0:
log.error('no languages are matched')
log.info('supported languages are:')
else:
log.error('Matched languages were not narrowed down to one.')
log.info('You have to choose:')
for lang_id in sorted(matched_lang_ids or language_dict.keys()):
log.emit('%s (%s)', lang_id, language_dict[LanguageId(lang_id)])
sys.exit(1)
# confirm
guessed_unmatch = ([problem.get_url()] != guessed_urls)
if guessed_unmatch:
samples_text = ('samples of "{}'.format('", "'.join(guessed_urls)) if guessed_urls else 'no samples')
log.warning('the problem "%s" is specified to submit, but %s were downloaded in this directory. this may be mis-operation', problem.get_url(), samples_text)
if args.wait:
log.status('sleep(%.2f)', args.wait)
time.sleep(args.wait)
if not args.yes:
if guessed_unmatch:
problem_id = problem.get_url().rstrip('/').split('/')[-1].split('?')[-1] # this is too ad-hoc
key = problem_id[:3] + (problem_id[-1] if len(problem_id) >= 4 else '')
sys.stdout.write('Are you sure? Please type "{}" '.format(key))
sys.stdout.flush()
c = sys.stdin.readline().rstrip()
if c != key:
log.info('terminated.')
return
else:
sys.stdout.write('Are you sure? [y/N] ')
sys.stdout.flush()
c = sys.stdin.read(1)
if c.lower() != 'y':
log.info('terminated.')
return
# submit
try:
submission = problem.submit_code(code, language_id=LanguageId(args.language), session=sess)
except NotLoggedInError:
log.failure('login required')
sys.exit(1)
except SubmissionError:
log.failure('submission failed')
sys.exit(1)
# show result
if args.open:
browser = webbrowser.get()
log.status('open the submission page with browser')
opened = browser.open_new_tab(submission.get_url())
if not opened:
log.failure('failed to open the url. please set the $BROWSER envvar')
def test(args: 'argparse.Namespace') -> None:
# list tests
if not args.test:
args.test = fmtutils.glob_with_format(args.directory, args.format) # by default
if args.ignore_backup:
args.test = fmtutils.drop_backup_or_hidden_files(args.test)
tests = fmtutils.construct_relationship_of_files(args.test, args.directory, args.format)
# check wheather GNU time is available
if not check_gnu_time(args.gnu_time):
log.warning('GNU time is not available: %s', args.gnu_time)
args.gnu_time = None
if args.mle is not None and args.gnu_time is None:
raise RuntimeError('--mle is used but GNU time does not exist')
# run tests
history = [] # type: List[Dict[str, Any]]
if args.jobs is None:
for name, paths in sorted(tests.items()):
history += [test_single_case(name, paths['in'], paths.get('out'), args=args)]
else:
if os.name == 'nt':
log.warning("-j/--jobs opiton is unstable on Windows environmet")
with concurrent.futures.ThreadPoolExecutor(max_workers=args.jobs) as executor:
lock = threading.Lock()
futures = [] # type: List[concurrent.futures.Future]
for name, paths in sorted(tests.items()):
futures += [executor.submit(test_single_case, name, paths['in'], paths.get('out'), lock=lock, args=args)]
for future in futures:
history += [future.result()]
# summarize
slowest = -1.0 # type: float
slowest_name = ''
heaviest = -1.0 # type: float
heaviest_name = ''
ac_count = 0
for result in history:
if result['status'] == 'AC':
ac_count += 1
if slowest < result['elapsed']:
slowest = result['elapsed']
slowest_name = result['testcase']['name']
if result['memory'] is not None and heaviest < result['memory']:
heaviest = result['memory']
heaviest_name = result['testcase']['name']
# print the summary
log.emit('')
log.status('slowest: %f sec (for %s)', slowest, slowest_name)
if heaviest >= 0:
if heaviest < MEMORY_WARNING:
log.status('max memory: %f MB (for %s)', heaviest, heaviest_name)
else:
log.warning('max memory: %f MB (for %s)', heaviest, heaviest_name)
if ac_count == len(tests):
log.success('test ' + log.green('success') + ': %d cases', len(tests))
else:
log.failure('test ' + log.red('failed') + ': %d AC / %d cases', ac_count, len(tests))
if args.json:
print(json.dumps(history))
if ac_count != len(tests):
sys.exit(1)
def generate_output_single_case(test_name: str,
test_input_path: pathlib.Path,
*,
lock: Optional[threading.Lock] = None,
args: 'argparse.Namespace') -> None:
# print the header
if lock is None:
log.emit('')
log.info('%s', test_name)
# run the command
with test_input_path.open() as inf:
info, proc = utils.exec_command(args.command,
stdin=inf,
timeout=args.tle)
answer = info['answer'] # type: Optional[bytes]
elapsed = info['elapsed'] # type: float
# acquire lock to print logs properly, if in parallel
nullcontext = contextlib.ExitStack()
with lock or nullcontext:
if lock is not None:
log.emit('')
log.info('%s', test_name)
# check the result
log.status('time: %f sec', elapsed)
if proc.returncode is None:
log.failure(log.red('TLE'))
log.info('skipped.')
return
elif proc.returncode != 0:
log.failure(log.red('RE') + ': return code %d', proc.returncode)
log.info('skipped.')
return
assert answer is not None
log.emit(
utils.make_pretty_large_file_content(answer,
limit=40,
head=20,
tail=10,
bold=True))
# find the destination path
match_result = fmtutils.match_with_format(
args.directory, args.format,
test_input_path) # type: Optional[Match[Any]]
if match_result is not None:
matched_name = match_result.groupdict()['name'] # type: str
else:
assert False
test_output_path = fmtutils.path_from_format(args.directory,
args.format,
name=matched_name,
ext='out')
# write the result to the file
if not test_output_path.parent.is_dir():
os.makedirs(str(test_output_path.parent), exist_ok=True)
with test_output_path.open('wb') as fh:
fh.write(answer)
log.success('saved to: %s', test_output_path)
def download(args: 'argparse.Namespace') -> None:
# prepare values
problem = dispatch.problem_from_url(args.url)
if problem is None:
raise requests.exceptions.InvalidURL(
'The contest "%s" is not supported' % args.url)
is_default_format = args.format is None and args.directory is None # must be here since args.directory and args.format are overwritten
if args.directory is None:
args.directory = pathlib.Path('test')
if args.format is None:
args.format = '%b.%e'
# get samples from the server
with utils.new_session_with_our_user_agent(path=args.cookie) as sess:
if args.yukicoder_token and isinstance(problem, YukicoderProblem):
sess.headers['Authorization'] = 'Bearer {}'.format(
args.yukicoder_token)
if args.system:
samples = problem.download_system_cases(session=sess)
else:
samples = problem.download_sample_cases(session=sess)
if not samples:
raise SampleParseError("Sample not found")
# append the history for submit subcommand
if not args.dry_run and is_default_format:
history = onlinejudge_command.download_history.DownloadHistory()
if not list(args.directory.glob('*')):
# reset the history to help users who use only one directory for many problems
history.remove(directory=pathlib.Path.cwd())
history.add(problem, directory=pathlib.Path.cwd())
# prepare files to write
def iterate_files_to_write(
sample: TestCase, *,
i: int) -> Iterator[Tuple[str, pathlib.Path, bytes]]:
for ext in ['in', 'out']:
data = getattr(sample, ext + 'put_data')
if data is None:
continue
name = sample.name
table = {}
table['i'] = str(i + 1)
table['e'] = ext
table['n'] = name
table['b'] = os.path.basename(name)
table['d'] = os.path.dirname(name)
path = args.directory / format_utils.percentformat(
args.format, table) # type: pathlib.Path
yield ext, path, data
for i, sample in enumerate(samples):
for _, path, _ in iterate_files_to_write(sample, i=i):
if path.exists():
raise FileExistsError(
'Failed to download since file already exists: ' +
str(path))
# write samples to files
for i, sample in enumerate(samples):
log.emit('')
log.info('sample %d', i)
for ext, path, data in iterate_files_to_write(sample, i=i):
log.status('%sput: %s', ext, sample.name)
if not args.silent:
log.emit(
utils.make_pretty_large_file_content(data,
limit=40,
head=20,
tail=10,
bold=True))
if not args.dry_run:
path.parent.mkdir(parents=True, exist_ok=True)
with path.open('wb') as fh:
fh.write(data)
log.success('saved to: %s', path)
# print json
if args.json:
print(json.dumps(list(map(convert_sample_to_dict, samples))))