def run_for_package(*, package_name: str, current_version: str) -> bool:
is_updated = not is_update_available_on_pypi(package_name, current_version)
if not is_updated:
log.warning('update available for %s: %s -> %s',
package_name, current_version,
get_latest_version_from_pypi(package_name))
log.info('run: $ pip3 install -U %s', package_name)
return is_updated
def main(args: Optional[List[str]] = None) -> None:
log.addHandler(log.logging.StreamHandler(sys.stderr))
log.setLevel(log.logging.INFO)
is_updated = update_checking.run()
parser = get_parser()
namespace = parser.parse_args(args=args)
try:
run_program(namespace, parser=parser)
except NotImplementedError as e:
log.debug('\n' + traceback.format_exc())
log.error('NotImplementedError')
log.info(
'The operation you specified is not supported yet. Pull requests are welcome.'
)
log.info(
'see: https://github.com/kmyk/online-judge-tools/blob/master/CONTRIBUTING.md'
)
if not is_updated:
log.info('hint: try updating the version of online-judge-tools')
sys.exit(1)
except Exception as e:
log.debug('\n' + traceback.format_exc())
log.error(str(e))
if not is_updated:
log.info('hint: try updating the version of online-judge-tools')
sys.exit(1)
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 construct_relationship_of_files(paths: List[pathlib.Path], directory: pathlib.Path, format: str) -> Dict[str, Dict[str, pathlib.Path]]:
tests = collections.defaultdict(dict) # type: Dict[str, Dict[str, pathlib.Path]]
for path in paths:
m = match_with_format(directory, format, path.resolve())
if not m:
log.error('unrecognizable file found: %s', path)
sys.exit(1)
name = m.groupdict()['name']
ext = m.groupdict()['ext']
assert ext not in tests[name]
tests[name][ext] = path
for name in tests:
if 'in' not in tests[name]:
assert 'out' in tests[name]
log.error('dangling output case: %s', tests[name]['out'])
sys.exit(1)
if not tests:
log.error('no cases found')
sys.exit(1)
log.info('%d cases found', len(tests))
return tests
def generate_output_single_case_exists_ok(
test_name: str,
test_input_path: pathlib.Path,
test_output_path: Optional[pathlib.Path],
*,
lock: Optional[threading.Lock] = None,
args: 'argparse.Namespace') -> None:
if test_output_path is not None:
nullcontext = contextlib.ExitStack()
with lock or nullcontext:
log.emit('')
log.info('%s', test_name)
log.info('output file already exists.')
log.info('skipped.')
else:
generate_output_single_case(test_name,
test_input_path,
lock=lock,
args=args)
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 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))))