def test_service_from_url(self):
service1 = dispatch.service_from_url('https://codeforces.com/')
self.assertEqual(service1.get_name(), 'Codeforces')
self.assertTrue(
isinstance(service1, service.codeforces.CodeforcesService))
self.assertEqual(service1.get_url_of_login_page(),
'https://codeforces.com/enter')
def handleCookieAdded(self, cookie: QNetworkCookie):
url = self.browser.url().toString()
if service_from_url(url):
py_cookie = toPyCookie(cookie)
with with_cookiejar(new_session_with_our_user_agent(),
path=default_cookie_path) as sess:
sess.cookies.set_cookie(py_cookie)
def test_service_from_url(self):
service1 = dispatch.service_from_url('https://atcoder.jp/')
self.assertIsInstance(service1, service.atcoder.AtCoderService)
self.assertEqual(service1.get_name(), 'AtCoder')
self.assertEqual(service1.get_url_of_login_page(),
'https://atcoder.jp/login')
self.assertEqual(service1.get_user_history_url(22),
'https://atcoder.jp/users/22/history/json')
def is_logged_in(url: str, *, memo={}) -> bool:
# functools.lru_cache is unusable since Service are unhashable, so we need to use `memo={}`.
service = dispatch.service_from_url(url)
assert service is not None
url = service.get_url() # normalize url
if url not in memo:
# We need to use main instead of `service.is_logged_in()` to use cookies.
result = main(['login-service', '--check', url], debug=True)
memo[url] = bool((result.get('result') or {}).get('loggedIn'))
return memo[url]
def login(args: 'argparse.Namespace') -> None:
service = dispatch.service_from_url(args.url)
if service is None:
sys.exit(1)
with utils.new_session_with_our_user_agent(path=args.cookie) as session:
if is_logged_in_with_message(service, session=session):
return
else:
if args.check:
sys.exit(1)
if args.use_browser in ('always', 'auto'):
try:
login_with_browser(service, session=session)
except ImportError:
logger.error(
'Selenium is not installed. Please run $ pip3 install selenium'
)
except WebDriverException as e:
logger.debug(e)
else:
if is_logged_in_with_message(service, session=session):
return
else:
sys.exit(1)
if args.use_browser in ('never', 'auto'):
if args.use_browser == 'auto':
logger.warning(
'Switch to use CUI-based login instead of Selenium')
try:
login_with_password(service,
username=args.username,
password=args.password,
session=session)
except NotImplementedError as e:
logger.exception(e)
except LoginError as e:
logger.debug(e)
except Exception as e:
logger.exception(e)
else:
if is_logged_in_with_message(service, session=session):
return
else:
sys.exit(1)
sys.exit(1)
def main(args: Optional[List[str]] = None,
*,
debug: bool = False) -> Dict[str, Any]:
parser = get_parser()
parsed = parser.parse_args(args=args)
if parsed.verbose:
basicConfig(level=DEBUG)
else:
basicConfig(level=INFO)
# do sleep to prevent impolite scraping
logger.info('sleep %f sec', parsed.wait)
time.sleep(parsed.wait)
# parse the URL
problem = dispatch.problem_from_url(getattr(parsed, 'url', ''))
contest = dispatch.contest_from_url(getattr(parsed, 'url', ''))
service = dispatch.service_from_url(getattr(parsed, 'url', ''))
# prepare a session
session = requests.Session()
session.headers['User-Agent'] = parsed.user_agent
# set yukicoder's token
if parsed.yukicoder_token is not None:
parser.error("don't use --yukicoder-token. use $YUKICODER_TOKEN")
else:
parsed.yukicoder_token = os.environ.get('YUKICODER_TOKEN')
is_yukicoder = isinstance(problem, YukicoderProblem) or isinstance(
service, YukicoderService)
if parsed.yukicoder_token and is_yukicoder:
session.headers['Authorization'] = 'Bearer {}'.format(
parsed.yukicoder_token)
# set password to login from the environment variable
if parsed.subcommand == 'login-service':
if parsed.password is not None:
parser.error("don't use --password. use $PASSWORD")
else:
parsed.password = os.environ.get('PASSWORD')
try:
with utils.with_cookiejar(session, path=parsed.cookie) as session:
result = None # type: Optional[Dict[str, Any]]
schema = {} # type: Dict[str, Any]
if parsed.subcommand == 'get-problem':
if problem is None:
raise ValueError("unsupported URL: {}".format(
repr(parsed.url)))
result = get_problem.main(
problem,
is_system=parsed.system,
is_full=parsed.full,
is_compatibility=parsed.compatibility,
session=session)
if parsed.compatibility:
schema = get_problem.schema_compatibility
else:
schema = get_problem.schema
elif parsed.subcommand == 'get-contest':
if contest is None:
raise ValueError("unsupported URL: {}".format(
repr(parsed.url)))
result = get_contest.main(contest,
is_full=parsed.full,
session=session)
schema = get_contest.schema
elif parsed.subcommand == 'get-service':
if service is None:
raise ValueError("unsupported URL: {}".format(
repr(parsed.url)))
result = get_service.main(
service,
does_list_contests=parsed.list_contests,
session=session)
schema = get_service.schema
elif parsed.subcommand == 'login-service':
if service is None:
raise ValueError("unsupported URL: {}".format(
repr(parsed.url)))
result = login_service.main(service,
username=parsed.username,
password=parsed.password,
check_only=parsed.check,
session=session)
schema = login_service.schema
elif parsed.subcommand == 'submit-code':
if problem is None:
raise ValueError("unsupported URL: {}".format(
repr(parsed.url)))
result = submit_code.main(problem,
file=parsed.file,
language_id=parsed.language,
session=session)
schema = submit_code.schema
elif parsed.subcommand is None:
parser.print_help()
result = None
else:
assert False
except:
etype, evalue, _ = sys.exc_info()
logger.exception('%s', evalue)
wrapped = {
"status":
"error",
"messages": [
*map(lambda line: line.strip(),
traceback.format_exception_only(etype, evalue))
],
"result":
None,
} # type: Dict[str, Any]
if debug:
return wrapped
else:
print(json.dumps(wrapped))
raise SystemExit(1)
else:
if result is None:
# no subcommand given
if debug:
return {
"status": "ok",
"messages": [],
"result": None,
}
else:
raise SystemExit(0)
wrapped = {
"status": "ok",
"messages": [],
"result": result,
}
if not debug:
print(json.dumps(wrapped))
try:
jsonschema.validate(result, schema)
except jsonschema.exceptions.ValidationError as e:
logger.debug('%s', e)
if debug:
return wrapped
else:
raise SystemExit(0)
def test_service_from_url(self):
self.assertIsNone(
dispatch.service_from_url('https://www.yahoo.co.jp/'))
def test_service_eq(self):
self.assertEqual(service_from_url('https://atcoder.jp/'), service_from_url('https://atcoder.jp/contests/agc030'))
self.assertNotEqual(service_from_url('https://atcoder.jp/'), service_from_url('https://codeforces.com/'))