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))