def requestAvatarId(self, cred): # pylint: disable=no-self-use
"""get user id from database"""
cred.username = cred.username.decode('utf-8')
args = cred.username.split(SERVERMARK)
if len(args) > 1:
if args[0] == 'adduser':
cred.username = args[1]
password = args[2]
query = Query(
'insert or ignore into player(name,password) values(?,?)',
(cred.username, password))
elif args[1] == 'deluser':
pass
query = Query('select id, password from player where name=?',
(cred.username, ))
if not len(query.records):
template = 'Wrong username: %1'
if Debug.connections:
logDebug(i18n(template, cred.username))
return fail(
credError.UnauthorizedLogin(srvMessage(template,
cred.username)))
userid, password = query.records[0]
defer1 = maybeDeferred(cred.checkPassword, password.encode('utf-8'))
defer1.addCallback(DBPasswordChecker._checkedPassword, userid)
return defer1
def community(url, cookie):
response = requests.get(url, cookie, verify=False)
soup = BeautifulSoup(response.text, 'html.parser')
# tables name
community_data = []
for table in soup.findAll("table"):
titles_thead = table.find('thead')
title = titles_thead.text.strip()
communities = re.findall(re.compile(
r'<td class=\"trow[1-2]\">\s*<strong><a href=\"forumdisplay\.php\?fid=[0-9]{1,}\">(.*)</a></strong>')
, str(table))
sub_communities = re.findall(re.compile(r'<a href=\"forumdisplay\.php\?fid=[0-9]{1,}" title=\"\">([^</a>]*)')
, str(table))
query = Query(table)
query.tables()
for com in communities:
u = re.findall(f"<a href=\"(.*)\">{com}</a>", str(table))
community_url = url + u[0]
community_data.append((com, community_url))
query = Query(community_data)
c_id = query.community()
if re.findall(f'<div class="smalltext">', str(table)):
sub_community_url = (url + re.findall(f"<a href=\"([^<]*)\" title=\"\">{sub}</a>", str(table))[0]
for sub in sub_communities)
for url_sub in sub_community_url:
sub_community(url_sub, cookie)
return "communities and title tables"
def __init__(self):
"""self.servers is a list of tuples containing server and last playername"""
QDialog.__init__(self, None)
decorateWindow(self, i18nc('kajongg', 'Login'))
self.setupUi()
localName = i18nc('kajongg name for local game server',
Query.localServerName)
self.servers = Query(
'select url,lastname from server order by lasttime desc').records
servers = list(x[0] for x in self.servers
if x[0] != Query.localServerName)
# the first server combobox item should be default: either the last used server
# or localName for autoPlay
if localName not in servers:
servers.append(localName)
if 'kajongg.org' not in servers:
servers.append('kajongg.org')
if Internal.autoPlay:
demoHost = Options.host or localName
if demoHost in servers:
servers.remove(
demoHost
) # we want a unique list, it will be re-used for all following games
servers.insert(0, demoHost)
# in this process but they will not be autoPlay
self.cbServer.addItems(servers)
self.passwords = Query(
'select url, p.name, passwords.password from passwords, player p '
'where passwords.player=p.id').records
Players.load()
self.cbServer.editTextChanged.connect(self.serverChanged)
self.cbUser.editTextChanged.connect(self.userChanged)
self.serverChanged()
StateSaver(self)
def createDatabase(self):
# create database
self.cursor.execute(
Query(self.connection).createDatabase(self.db_name))
# use database
self.cursor.execute(Query(self.connection).useDatabase(self.db_name))
print('Database', self.db_name, 'succesfully created')
def query_register(self, cmd, session):
device_requesting = session.query(Device).filter_by(
pubkey=cmd.token).first()
if device_requesting:
if device_requesting.is_enabled:
self.parent.devices[cmd.token] = self
self.other = cmd.token
self.type = 'device'
device_requesting.is_online = True
self.logger.info('Registered new device %s.' %
device_requesting.name)
else:
query = Query()
query.create_deactivated_device(config.server_token, cmd.token)
self.connection.sendall(query.to_command())
self.logger.info(
'Disabled device %s tried to register and was rejected.' %
device_requesting.name)
return self.shutdown()
else:
query = Query()
query.create_unknown_token(config.server_token, cmd.token)
self.connection.sendall(query.to_command())
self.logger.info(
'Unknown token %s tried to register and was rejected.' %
cmd.token)
return self.shutdown()
def _get_rel_data_restricted(self, sql):
saved = self._restricted_table_call
table_name, relation, pk, pk_value = saved['table_name'], saved['relation'], saved['pk'], saved['pk_value']
relation_fk = Structure.get_foreign_key_for_table(relation, table_name)
if not self._cache.relation_exists(table_name, relation):
if sql._select_args:
sql.add_select_arg(Column(relation, relation_fk))
if sql._limit:
union_sql = []
union_parameters = []
union_dict = {}
for id in self._cache.get_all_keys(table_name, pk):
limiting_sql = copy.deepcopy(sql)
limiting_sql.add_where_literal(Column(relation, relation_fk) == id)
union_dict = limiting_sql.build_select()
union_sql.append('(%s)' % union_dict['sql'])
union_parameters.extend(union_dict['parameters'])
union_dict['sql'], union_dict['parameters'] = ' UNION '.join(union_sql), union_parameters
data = Query().execute_and_fetch(**union_dict)
self._cache.save_relation(table_name, relation, data)
else:
sql.add_where_literal(Column(relation, relation_fk).in_(self._cache.get_all_keys(table_name, pk)))
data = Query().execute_and_fetch(**sql.build_select())
self._cache.save_relation(table_name, relation, data)
return ResultSet(self._cache.get_relation_set(relation, relation_fk, pk_value), relation, self._cache)
def answered(result, games):
"""question answered, result is True or False"""
if result:
for game in games:
Query("DELETE FROM score WHERE game = ?", (game, ))
Query("DELETE FROM game WHERE id = ?", (game, ))
self.setQuery() # just reload entire table
def selectableRulesets(server=None):
"""returns all selectable rulesets for a new game.
server is used to find the last ruleset used by us on that server, this
ruleset will returned first in the list."""
result = Ruleset.availableRulesets()
# if we have a selectable ruleset with the same name as the last used ruleset
# put that ruleset in front of the list. We do not want to use the exact same last used
# ruleset because we might have made some fixes to the ruleset meanwhile
if server is None: # scoring game
# the exists clause is only needed for inconsistent data bases
qData = Query(
"select ruleset from game where seed is null "
" and exists(select id from ruleset where game.ruleset=ruleset.id)"
"order by starttime desc limit 1").records
else:
qData = Query(
'select lastruleset from server where lastruleset is not null and url=?',
list([server])).records
if not qData:
# we never played on that server
qData = Query(
'select lastruleset from server where lastruleset is not null '
'order by lasttime desc limit 1').records
if qData:
lastUsedId = qData[0][0]
qData = Query("select name from ruleset where id=%d" %
lastUsedId).records
if qData:
lastUsed = qData[0][0]
for idx, ruleset in enumerate(result):
if ruleset.name == lastUsed:
del result[idx]
return [ruleset] + result
return result
def save(self, minus=False, forced=False):
"""save the ruleset to the database.
If it does not yet exist in database, give it a new id
If the name already exists in the database, also give it a new name
If the hash already exists in the database, only save if forced=True"""
if not forced:
if minus:
# if we save a template, only check for existing templates. Otherwise this could happen:
# clear kajongg.db, play game with DMJL, start ruleset editor, copy DMJL.
# since play Game saved the used ruleset with id 1, id 1 is found here and no new
# template is generated. Next the ruleset editor shows the original ruleset in italics
# and the copy with normal font but identical name, and the
# copy is never saved.
qData = Query("select id from ruleset where hash=? and id<0",
(self.hash, )).records
else:
qData = Query("select id from ruleset where hash=?",
(self.hash, )).records
if qData:
# is already in database
self.rulesetId = qData[0][0]
return
with Internal.db:
self.rulesetId, self.name = self._newKey(minus)
Query(
'INSERT INTO ruleset(id,name,hash,description) VALUES(?,?,?,?)',
(self.rulesetId, english(
self.name), self.hash, self.description),
failSilent=True)
cmd = 'INSERT INTO rule(ruleset, list, position, name, definition, ' \
'points, doubles, limits, parameter) VALUES(?,?,?,?,?,?,?,?,?)'
args = list(self.ruleRecord(x) for x in self.allRules)
Query(cmd, args)
def sub_community(url, cookie):
response = requests.get(url, cookie, verify=False)
soup = BeautifulSoup(response.text, 'html.parser')
sub_communities_data = []
community_title = re.findall(re.compile(r'<span class=\"active\">(.*)</span>'), response)
for table in soup.find("table").findAll("tr"):
sub_community_title = re.findall(re.compile(
r'<td class=\"trow[1-2]\">\s*<strong><a href=\"forumdisplay\.php\?fid=[0-9]{1,}\">(.*)</a></strong>')
, str(table))
# Author
sub_community_author = re.findall(re.compile(
r'<br/>\s*توسط\s*<a href=\"https://forum\.dataak\.com/member\.php\?action=profile&uid=[1-9]'
r'{1,}\">(.*)</a></span>'), str(table))
author_url = [re.findall(f"<a href=\"(.*)\">{i}</a>", str(table)) for i in sub_community_author]
# Post
post_text = re.findall(re.compile(
r'<a href=\"showthread\.php\?tid=[1-9]&action=lastpost\" title=\"(.*)\"><strong>'),
str(table))
post_url = (re.findall(f"<<a href=\"(.*)\" title=\"{p}\"><strong>", str(table)) for p in post_text)
query = Query(author_url)
query.user()
sub_communities_data.append((community_title, sub_community_title, url, post_url))
query = Query(sub_communities_data)
query.sub_community()
return "sub_communities"
def updateRule(self, rule):
"""update rule in database"""
self.__hash = None # invalidate, will be recomputed when needed
with Transaction():
Query("DELETE FROM rule WHERE ruleset=? and name=?",
list([self.rulesetId, english(rule.name)]))
self.saveRule(rule)
Query("UPDATE ruleset SET hash=? WHERE id=?",
list([self.hash, self.rulesetId]))
def test_result_selected_fields(self, db_):
query = Query(db_, "SELECT name FROM people WHERE id = 1")
assert query.result == [{"name": "Jake"}]
query = Query(db_, "SELECT id FROM people WHERE id = 1")
assert query.result == [{"id": 1}]
query = Query(db_, "SELECT id, name FROM people WHERE id = 1")
assert query.result == [{"id": 1, "name": "Jake"}]
query = Query(db_, "SELECT * FROM people WHERE id = 1")
assert query.result == [{"id": 1, "name": "Jake"}]
def saveStartTime(self):
"""write a new entry in the game table with the selected players"""
Game.saveStartTime(self)
# for PlayingGame, this one is already done in
# Connection.__updateServerInfoInDatabase
known = Query('update server set lastruleset=? where url=?',
(self.ruleset.rulesetId, Query.localServerName))
if not known:
Query('insert into server(url,lastruleset) values(?,?)',
(self.ruleset.rulesetId, Query.localServerName))
def updateRule(self, rule):
"""update rule in database"""
self.__hash = None # invalidate, will be recomputed when needed
with Internal.db:
record = self.ruleRecord(rule)
Query(
"UPDATE rule SET name=?, definition=?, points=?, doubles=?, limits=?, parameter=? "
"WHERE ruleset=? AND list=? AND position=?",
tuple(record[3:] + record[:3]))
Query("UPDATE ruleset SET hash=? WHERE id=?",
(self.hash, self.rulesetId))
def confirm_formulaire(self):
msg = Query().add_bus(self.ligne.get(), self.bus.get())
if msg == "le bus existe deja":
result = messagebox.askquestion("Start a new game",
"Le bus existe deja le modifier ?",
icon='warning')
if result == 'yes':
Query().update_bus(self.bus.get(), "AA", 20, self.ligne.get())
print(self.ligne.get())
else:
messagebox.showinfo("Bas", msg)
def setUp(self):
super(ParticipantSummaryDaoTest, self).setUp(use_mysql=True)
self.dao = ParticipantSummaryDao()
self.order_dao = BiobankOrderDao()
self.measurement_dao = PhysicalMeasurementsDao()
self.participant_dao = ParticipantDao()
self.no_filter_query = Query([], None, 2, None)
self.one_filter_query = Query(
[FieldFilter("participantId", Operator.EQUALS, 1)], None, 2, None)
self.two_filter_query = Query([
FieldFilter("participantId", Operator.EQUALS, 1),
FieldFilter("hpoId", Operator.EQUALS, PITT_HPO_ID)
], None, 2, None)
self.ascending_biobank_id_query = Query([], OrderBy("biobankId", True),
2, None)
self.descending_biobank_id_query = Query([],
OrderBy("biobankId",
False), 2, None)
self.enrollment_status_order_query = Query([],
OrderBy(
"enrollmentStatus",
True), 2, None)
self.hpo_id_order_query = Query([], OrderBy("hpoId", True), 2, None)
self.first_name_order_query = Query([], OrderBy("firstName", True), 2,
None)
def test_as_url(self):
""" Test url conversion. """
query = Query(self.config)
self.assertEqual(
query.as_url('/'),
'/?dc=default&index=application-%2A&from=now-15m&to=now&interval=auto'
)
query = Query(self.config, level='WARN')
self.assertEqual(
query.as_url('/'),
'/?dc=default&index=application-%2A&from=now-15m&to=now&interval=auto&level=WARN'
)
def main():
parser = argparse.ArgumentParser(
description='CLI for the pldb application.')
parser.add_argument(
'--update',
action='store_true',
help='Download season data and update the JSON file and the database.')
parser.add_argument(
'--table',
action='store_true',
help=
'Display the current standings table (calculated from data in the database).'
)
parser.add_argument(
'--club',
type=str,
default=None,
help=
'Display info for all the matches for the given club in the season.')
args = parser.parse_args()
if args.update:
print("Updating season data...")
etl = ETL()
etl.run()
print("done.")
elif args.table:
query = Query()
table_data = query.table()
print("#\tClub\tPlayed\tWon\tDrawn\tLost\tGD\tPoints")
for rank in range(len(table_data)):
row = table_data[rank]
print(
f"{rank + 1}\t{row['club']}\t{row['matches_played']}\t"
f"{row['wins']}\t{row['draws']}\t{row['losses']}\t{row['goal_diff']}\t"
f"{row['points']}")
elif args.club:
query = Query()
for match in query.club(args.club):
kick_time = match['kickoff'] / 1000
kick_time = datetime.datetime.fromtimestamp(kick_time).strftime(
"%a %d %b %H:%M")
if match['status'] == 'C':
score = f"{match['away_goals']} {match['home_goals']}"
else:
score = ' @ '
print(
f"{kick_time} {match['away_club']['abbr']} "
f"{score} {match['home_club']['abbr']} {match['ground']['name']}"
)
def test_query_only_statement(self):
dummy = self.dummyQuery(
statement='list',
ast=(
'match_and',
('match_tag_exists', 'target_type'),
('match_tag_exists', 'unit')
),
patterns=['target_type=', 'unit='],
target_modifiers=[Query.derive_counters],
)
query = Query("list")
self.assertQueryMatches(query, dummy)
query = Query("list ")
self.assertQueryMatches(query, dummy)
def get_query(table, limit=None):
from query import Query
from clause import Table
if isinstance(table, basestring):
return Query(table=table, limit=limit)
if isinstance(table, Query):
table.set_limit(limit)
return table
if isinstance(table, Table):
return Query(table=table.json(), limit=limit)
if table['type'] == 'table':
return Query(table=table, limit=limit)
query = Query.load(table)
query.set_limit(limit)
return query
def send(self, event=None):
# Get the msg input from the user and return the answer depends on the query option
relative_position_of_scrollbar = self.scroll_bar.get()[1]
msg = self.user_msg.get()
# display the user msg
self.display_user_text(msg)
# get query option from user
# -KB: query from the KB
# -Feeds: feed text to Edison and get return
if self.query_option.get() == "KB":
query = Query()
j = query.match_question(msg)
print("matched q: %s real q: %s" % (query.get_question(j), msg))
ans = query.get_query(j)
else:
ans = edison.get_response_kibana(msg)
# display the bot msg
self.display_bot_text(ans)
self.msg_txtbox.delete("0", tk.END)
# move the scroll bar to bottom
if relative_position_of_scrollbar == 1:
self._textarea.yview_moveto(1)
def main():
# initialize
os.chdir(os.path.dirname(os.path.realpath(__file__)))
path, amount, query_terms = parse_args()
# load random docs in memory
rand_docs = get_random_docs(path, amount)
# preprocess these docs
docs = [preprocess(doc) for doc in rand_docs]
inv_idx = InvertedIdx()
inv_idx.build_idx_from_docs(docs)
print('Inverted index')
print(inv_idx)
print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
#global_unigram = build_global_unigram(inv_idx)
#print('global unigramm model')
#pprint(global_unigram)
print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
q = Query(query_terms.split(' '), docs, inv_idx)
print(q)
relevant_docs = q.prefiltered_docs
print('Relevant docs by idx lookup: ' +
', '.join([str(id) for id in relevant_docs]))
ranked = q.doc_likelihood()
print('\n'.join([str(r) for r in ranked[:10]]))
def _saveScores(self):
"""save computed values to database,
update score table and balance in status line"""
scoretime = datetime.datetime.now().replace(microsecond=0).isoformat()
logMessage = ''
for player in self.players:
if player.hand:
manualrules = '||'.join(x.rule.name
for x in player.hand.usedRules)
else:
manualrules = i18n('Score computed manually')
Query(
"INSERT INTO SCORE "
"(game,hand,data,manualrules,player,scoretime,won,prevailing,"
"wind,points,payments, balance,rotated,notrotated) "
"VALUES(%d,%d,?,?,%d,'%s',%d,'%s','%s',%d,%d,%d,%d,%d)" %
(self.gameid, self.handctr, player.nameid, scoretime,
int(player == self.__winner), self.roundWind.char,
player.wind, player.handTotal, player.payment, player.balance,
self.rotated, self.notRotated),
(player.hand.string, manualrules))
logMessage += '{player:<12} {hand:>4} {total:>5} {won} | '.format(
player=str(player)[:12],
hand=player.handTotal,
total=player.balance,
won='WON' if player == self.winner else ' ')
for usedRule in player.hand.usedRules:
rule = usedRule.rule
if rule.score.limits:
self.addCsvTag(rule.name.replace(' ', ''))
if Debug.scores:
self.debug(logMessage)
def hashIsKnown(value):
"""returns False or True"""
result = any(x.hash == value for x in PredefinedRuleset.rulesets())
if not result:
query = Query("select id from ruleset where hash=?", list([value]))
result = bool(query.records)
return result
def complex_metric(self, panel, metric, entity):
"""
Complex metrics involve multiple metrics.
An example is one metric as a percentage of another metrics.
The idea is to temporarily store each individual target by a name
that can then be used when creating the final complex target.
@param panel - Dictionary representation of the panel
@param metric - Dictionary representation of the metric
@param entity - Entity model instance.
"""
# Template the named targets
named_targets = {}
for name, m in metric['named-metrics'].iteritems():
query = Query(m['query'])
result = query.query(entity)
if not result:
return
for entity, check, metric_obj in result:
self.ctx.update(entity=entity, check=check, metric=metric_obj)
if name not in named_targets:
named_targets[name] = []
named_targets[name] \
.append(self.substitute(m['target'], self.ctx))
for name, targets in named_targets.iteritems():
named_targets[name] = ','.join(targets)
# Apply named targets to the final target
target = self.substitute(metric['target'], named_targets)
# Apply the context to the final target
self.add_metric(panel, metric, target=target)
def run(self):
print("~Transaction # " + str(self.transaction_id))
for query, args in self.queries:
key = args[0]
#print(key)
exclusive = False
if query.__name__ == "increment":
exclusive = True
elif key in self.reads:
result = self.reads[key]
continue
if self.secure_lock(key, exclusive) == False:
print("Aborting transaciton #" + str(self.transaction_id))
return self.abort()
result = query(*args)
if exclusive:
self.updates.append(key)
query = Query(self.table)
self.reads[key] = query.select(key, self.table.key,
[1] * self.table.num_columns)
else:
self.reads[key] = result
return self.commit()
def list(self,
ids: typing.List[str] = [],
show_id: bool = None,
unwatched: bool = None,
tags: typing.List[str] = None,
fields: typing.Optional[typing.Sequence[str]] = None):
args: typing.List[str] = ids or []
q = Query(table='subs')
q.add_order('subs.id')
fields = Subscriptions._parse_fields(fields, DEFAULT_SUB_FIELDS,
VALID_SUB_FIELDS)
q.add_fields(*('0' if x == 'url' else 'subs.' + x for x in fields))
if unwatched:
q.add_joins(
'join videos on subs.id == videos.sub and videos.watched == 0')
if ids:
q.add_filter('name in ({})'.format(Query.make_args(len(ids))))
if unwatched:
q.add_group('subs.id')
if tags:
q.add_joins(
'join (tags, subs_tags)'
' on (subs.id == subs_tags.sub and tags.id == subs_tags.tag)')
q.add_filter('(tags.name in ({}))'.format(
Query.make_args(len(tags))))
args.extend(tags)
c = self._conn.cursor().execute(q.query(distinct=bool(tags)), args)
for _ in map(print, map(' '.join, c)):
pass
def read_queries(filename):
in_ = open(filename, 'r')
queries = in_.read()
queries = queries.split("\n")
ir = IR()
for query in queries:
target_doc_id = int(query[0:query.index(' ')])
q = Query(query[query.index(' ') + 1:len(query)])
rank = -1
documents = ir.search(q)
for i in range(0, len(documents)):
if documents[i].id == target_doc_id:
rank = i
break
documents = documents[0:15]
divider = '\n==============================================================================\n'
out_ = open('../tests/' + query + '.txt', 'w')
result = (
'target document is rank ' + str(rank + 1) + divider +
divider.join([
'DOC ID:\n\t' + str(doc.id) + '\n' + doc.fancy_str()
for (doc, r) in zip(documents, range(1,
len(documents) + 1))
]))
result += '\n\n\n'
out_.write(result)
out_.close()
in_.close()
def update_queues(session, self, data):
try:
cmd = Query()
if cmd.create_valid_query_from_string(data):
try:
if cmd.method == 'REGISTER':
self.query_register(cmd, session)
elif cmd.method == 'REGISTER WEBUI':
self.query_register_webui(cmd)
elif cmd.method == 'UNREGISTER':
self.query_unregister(cmd, session)
elif cmd.method == 'PONG':
self.query_pong(cmd)
else:
self.parent.queries.put(cmd, block=False)
except queue.Empty:
pass
except Exception as e:
self.logger.exception(
'Caught exception whilst processing command:')
self.logger.exception(cmd.query)
self.logger.exception(e)
else:
self.logger.info('Discarded command:')
self.logger.info(data)
except:
self.logger.info('Discarded command:')
self.logger.info(data)
def run_demo_only(self, target, patID, evidence):
#-- Make query and analyze
query = Query(evidence=evidence[1],
targets=[],
meta_evidence=evidence[0],
meta_targets=[target],
type='updating')
probs = list()
if True: #self.drug != evidence[0][0][2]:
query = self.reasoner.analyze_query(
copy.deepcopy(query),
save_dir=None,
target_strategy=self.target_strategy,
interpolation=self.interpolation)
query.result.summary()
query.getReport()
for comp_name, state_dict in query.independ_result.items():
for state_name, prob in state_dict.items():
probs.append((comp_name, state_name, prob))
else:
query = self.reasoner.analyze_query(
copy.deepcopy(query),
preprocessed_bkb=self.processed_bkb,
target_strategy=self.target_strategy,
interpolation=self.interpolation)
query.result.summary()
query.getReport()
for comp_name, state_dict in query.independ_result.items():
for state_name, prob in state_dict.items():
probs.append((comp_name, state_name, prob))
