async def get_problems(self,
partial=None,
group=None,
_type=None,
organization=None,
search=None,
cached=False) -> List[Problem_DB]:
q = session.query(Problem_DB).\
filter(self.parse(Problem_DB.partial, partial)).\
filter(self.parse(Problem_DB.group, group)).\
filter(self.parse(Problem_DB.types, _type)).\
filter(self.parse(Problem_DB.organizations, organization))
if cached:
return q.all()
a = API()
if search is not None:
# Can't bother to implement something with db
# maybe future me can do this
await a.get_problems(partial=partial,
group=group,
_type=_type,
organization=organization,
search=search)
return list(map(Problem_DB, a.data.objects))
page = 1
await a.get_problems(partial=partial,
group=group,
_type=_type,
organization=organization,
search=search,
page=page)
if a.data.total_objects == q.count():
return q.all()
for problem in a.data.objects:
qq = session.query(Problem_DB).\
filter(Problem_DB.code == problem.code)
if qq.count() == 0:
session.add(Problem_DB(problem))
while a.data.has_more:
page += 1
await a.get_problems(partial=partial,
group=group,
_type=_type,
organization=organization,
search=search,
page=page)
for problem in a.data.objects:
qq = session.query(Problem_DB).\
filter(Problem_DB.code == problem.code)
if qq.count() == 0:
session.add(Problem_DB(problem))
session.commit()
return q.all()
async def async_old(self):
problem_q = session.query(Problem_DB).\
filter(Problem_DB.code == self._problem)
if problem_q.count() == 0:
api = API()
await api.get_problem(self._problem)
session.add(Problem_DB(api.data.object))
session.commit()
self.problem = [problem_q.first()]
user_q = session.query(User_DB).\
filter(User_DB.username == self._user)
if user_q.count() == 0:
api = API()
await api.get_user(self._user)
session.add(User_DB(api.data.object))
session.commit()
self.user = [user_q.first()]
language_q = session.query(Language_DB).\
filter(Language_DB.key == self._language)
if language_q.count() == 0:
api = API()
await api.get_languages()
for language in api.data.objects:
if language.key == self._language:
session.add(Language_DB(language))
session.commit()
break
self.language = [language_q.first()]
async def async_init(self, problem_q, user_q, language_q, lock_table):
if self._problem not in problem_q and self._problem not in lock_table:
lock_table[self._problem] = asyncio.Lock()
async with lock_table[self._problem]:
api = API()
await api.get_problem(self._problem)
problem = Problem_DB(api.data.object)
session.add(problem)
problem_q[self._problem] = problem
if self._problem in problem_q:
self.problem = [problem_q[self._problem]]
if self._user not in user_q:
api = API()
await api.get_user(self._user)
user = User_DB(api.data.object)
session.add()
user_q[self._user] = user
self.user = [user_q[self._user]]
if self._language not in language_q:
api = API()
await api.get_languages()
for language in api.data.objects:
if language.key == self._language:
lang = Language_DB(language)
session.add(lang)
language_q[self._language] = lang
break
self.language = [language_q[self._language]]
if self.problem is None:
async with lock_table[self._problem]:
self.problem = [problem_q[self._problem]]
async def async_init(self):
organization_qq = session.query(Organization_DB).filter(
Organization_DB.id.in_(self._organizations))
organization_q = session.query(Organization_DB.id).filter(
Organization_DB.id.in_(self._organizations)).all()
organization_q = list(map(itemgetter(0), organization_q))
for organization_id in self._organizations:
if organization_id not in organization_q:
api = API()
await api.get_organizations()
for organization in api.data.objects:
if organization.id not in organization_q and organization.id in self._organizations:
session.add(Organization_DB(organization))
session.commit()
break
self.organizations = organization_qq.all()
# perhaps I should check if it's the general or detailed version
self._problem_codes = list(map(itemgetter("code"), self._problems))
problem_qq = session.query(Problem_DB).filter(
Problem_DB.code.in_(self._problem_codes))
problem_q = session.query(Problem_DB.code).filter(
Problem_DB.code.in_(self._problem_codes)).all()
problem_q = list(map(itemgetter(0), problem_q))
for problem_dict in self._problems:
problem_code = problem_dict["code"]
try:
if problem_code not in problem_q:
api = API()
await api.get_problem(problem_code)
session.add(Problem_DB(api.data.object))
session.commit()
except ObjectNotFound:
pass
self.problems = problem_qq.all()
async def async_init(self):
problem_qq = session.query(Problem_DB).filter(
Problem_DB.code.in_(self._solved_problems))
problem_q = session.query(Problem_DB.code).filter(
Problem_DB.code.in_(self._solved_problems)).all()
problem_q = list(map(itemgetter(0), problem_q))
for problem_code in self._solved_problems:
try:
if problem_code not in problem_q:
api = API()
await api.get_problem(problem_code)
session.add(Problem_DB(api.data.object))
session.commit()
except ObjectNotFound:
pass
self.solved_problems = problem_qq.all()
organization_qq = session.query(Organization_DB).filter(
Organization_DB.id.in_(self._organizations))
organization_q = session.query(Organization_DB.id).filter(
Organization_DB.id.in_(self._organizations)).all()
organization_q = list(map(itemgetter(0), organization_q))
for organization_id in self._organizations:
if organization_id not in organization_q:
api = API()
await api.get_organizations()
for organization in api.data.objects:
if organization.id not in organization_q and organization.id in self._organizations:
session.add(Organization_DB(organization))
session.commit()
break
self.organizations = organization_qq.all()
for contest in self._contests:
if contest["rating"]:
self.max_rating = max(self.max_rating or 0, contest["rating"])
self._contest_keys = list(map(itemgetter("key"), self._contests))
contest_qq = session.query(Contest_DB).filter(
Contest_DB.key.in_(self._contest_keys))
contest_q = session.query(Contest_DB.key).filter(
Contest_DB.key.in_(self._contest_keys)).all()
contest_q = list(map(itemgetter(0), contest_q))
for contest_key in self._contest_keys:
try:
if contest_key not in contest_q:
api = API()
await api.get_contest(contest_key)
# This causes db errors, and in the case the above doesn't catch it.
# This will be a last ditch effort
if session.query(Contest_DB).filter(
Contest_DB.key == contest_key).count():
continue
session.add(Contest_DB(api.data.object))
session.commit()
except ObjectNotFound:
pass
self.contests = contest_qq.all()
async def async_init(self):
problem_qq = session.query(Problem_DB).\
filter(Problem_DB.code.in_(self._solved_problems))
problem_q = session.query(Problem_DB.code).\
filter(Problem_DB.code.in_(self._solved_problems)).all()
problem_q = list(map(itemgetter(0), problem_q))
for problem_code in self._solved_problems:
try:
if problem_code not in problem_q:
api = API()
await api.get_problem(problem_code)
session.add(Problem_DB(api.data.object))
session.commit()
except ObjectNotFound:
pass
self.solved_problems = problem_qq.all()
organization_qq = session.query(Organization_DB).\
filter(Organization_DB.id.in_(self._organizations))
organization_q = session.query(Organization_DB.id).\
filter(Organization_DB.id.in_(self._organizations)).all()
organization_q = list(map(itemgetter(0), organization_q))
for organization_id in self._organizations:
if organization_id not in organization_q:
api = API()
await api.get_organizations()
for organization in api.data.objects:
if (organization.id not in organization_q
and organization.id in self._organizations):
session.add(Organization_DB(organization))
session.commit()
break
self.organizations = organization_qq.all()
def get_key(contest):
return contest["key"]
self._contest_keys = list(map(get_key, self._contests))
contest_qq = session.query(Contest_DB).\
filter(Contest_DB.key.in_(self._contest_keys))
contest_q = session.query(Contest_DB.key).\
filter(Contest_DB.key.in_(self._contest_keys)).all()
contest_q = list(map(itemgetter(0), contest_q))
for contest_key in self._contest_keys:
try:
if contest_key not in contest_q:
api = API()
await api.get_contest(contest_key)
session.add(Contest_DB(api.data.object))
session.commit()
except ObjectNotFound:
pass
self.contests = contest_qq.all()
async def get_problem(self, code) -> Problem_DB:
q = session.query(Problem_DB).\
filter(Problem_DB.code == code)
if q.count():
# has_rating check if it has a detailed row
if q.first().short_circuit is not None:
return q.first()
a = API()
await a.get_problem(code)
if q.count():
q.delete()
session.add(Problem_DB(a.data.object))
session.commit()
return q.first()
