def view(self, noteid=""): notetext = {} dbmgr = DatabaseManager("scribler.db") for row in dbmgr.query("select * from notes where _id = '" + noteid + "'"): notetext["title"] = row[1] notetext["body"] = row[2] return notetext
def concept_as_rdf(self, REQUEST, cp, ns="1"): """ Return a concept in RDF format """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: return None
def delete(self, noteid="", allnotes="one"): dbmgr = DatabaseManager("scribler.db") if allnotes == "one": status = dbmgr.query( "delete from notes where _id = '" + noteid + "'") else: status = dbmgr.query("delete from notes") return status.rowcount
def getDefinitionSources(self): """ return definition sources """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: # write log return ({}, 1)
def GetAllRelations(self): """ return all relations """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: # write log return ((), 1)
def GetBackbone(self): """ return data for backbone.rdf """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: #write log return ((), 1)
def GetConceptName(self, concept_ns, concept_id, langcode): """ return a concepts name in requested language """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: #write log return (0, 1)
def getAlphabet(self, lang, theme, case, theme_ns=""): """ return the alphabet (default small letters) for a given language """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: # write log conn.closeConnection() return ((), [], 1, "")
def GetLanguageDirection(self, lang): """ get a language by its code """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: # write log return ({}, 1)
def GetConceptsName(self, langcode, start=0, letter=0, ns=1): """ return the concepts name for a given language """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: #write log return ((), [], 1)
def GetLanguages(self, concept_ns=None, concept_id=None): """ get languages """ conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: # write log return None
def GetGroupsAndThemes(self, langcode): """ return all the groups and all the themes for a given language """ errors = 0 conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, err: # write log errors = 1 return ((), (), (), err)
def GetGroupConcepts(self, params, langcode=None, REQUEST=None): """ return all the narrower concepts beloging to a group """ relations = [] top_cp = [] conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: self.error_log.raising(sys.exc_info()) return ((), 1)
def main(argv): opts = get_command_args(argv) dm = DatabaseManager() if (opts['data']): pprint(dm.get_data(opts['redcap'])) if (opts['match']): pprint(dm.get_matches(opts['redcap'],opts['bool'],opts['value'])) if (opts['search']): pprint(dm.get_searches(opts['redcap'],opts['bool'],opts['value'])) if (opts['mach']): pprint(dm.get_ml_data(opts['redcap']))
def main(): print "Reading minID" fp = open('ids.txt', 'r') for line in fp: ids = line.strip().split(",") minID = ids[0] maxID = ids[1] fp.close() print "minID: ", minID print "maxID: ", maxID dbm = DatabaseManager() print "running query..." places = dbm.runQuery("SELECT id, bounding_box FROM Places \ WHERE lat_1 IS NULL AND id >= {0} AND id < {1}".format(minID, maxID)) print "query done!" cont = 0.0; for row in places: try: idPlace = row[0] bounding_box = row[1] tmp = re.sub(r'u\'','\'', bounding_box) tmp = re.sub(r'\'','"', tmp) obj = json.loads(tmp) box_coords = obj['coordinates'][0] lat_1 = box_coords[0][1] long_1 = box_coords[0][0] lat_2 = box_coords[1][1] long_2 = box_coords[1][0] lat_3 = box_coords[2][1] long_3 = box_coords[2][0] lat_4 = box_coords[3][1] long_4 = box_coords[3][0] query = u"""UPDATE Places SET lat_1={0}, long_1={1}, lat_2={2}, long_2={3},lat_3={4}, long_3={5}, lat_4={6}, long_4={7} WHERE id = {8}""".format(lat_1, long_1, lat_2, long_2, lat_3, long_3, lat_4, long_4, idPlace) print cont dbm.runCommit(query) except Exception as e: print "error with id=", row[0] print e cont += 1
def GetGroups(self, langcode=None, REQUEST=None): """ return all the super_groups with all their childrens """ results = {} #{(id_super, def_super):[{id:id_group, def:def_group},...]} if langcode is None: return ((), 1) conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, err: self.error_log.raising(sys.exc_info()) return ((), 1)
def GetThemeConcepts(self, theme, langcode, start=0, letter=0, namespace=4): """ return all the concepts for a given theme tagged with their language """ def wrap_concept(concept): return concept th_name = '' conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: #write log return ((), [], 1, '')
def GetThemes(self, lang=None, REQUEST=None, namespace=4): """ return all the themes for a given langcode """ flag = 0 if lang is None: return ((), 1) conn = DatabaseManager() conn.openConnection(self) try: res = self._get_themes(namespace, lang, conn) except OperationalError, err: print err flag = 1
def __init__(self, subreddit, username, db_name, debug=False): ''' initializer for the ReputationManager pre: the subreddit it's going to manage in, and the name of the database and if debug mode is turned on or not, default is False post: the ReputationManager class is initialized ''' user_agent = 'Reputation-Manager v1.2.1 /u/cutety' self.r = praw.Reddit(user_agent=user_agent,log_requests=0) self.o = OAuth2Util.OAuth2Util(self.r, print_log=False) self.subreddit = subreddit self.username = username print('Initializing database...') self.db = DatabaseManager(db_name) # the functions are associated with the identifiers position in this list # this is done so identifier can be changed at anytime and the same function # will be done without having to change any other code self.identifiers = ['!offer', '!accept', '!success', '!scam', '!report', '!cancel', '!retract'] # configure logging logging.basicConfig(filename='REPMLog.log', level=logging.DEBUG, format='%(asctime)s %(message)s') self.debug = debug
def db_setup(db_name: str) -> None: try: # access db with DatabaseManager(db_name) as db: # create a table for input files archives db.execute("""CREATE TABLE IF NOT EXISTS input_reports( date TEXT, hours_worked REAL, employee_id INTEGER, job_group TEXT, PRIMARY KEY (date, employee_id, job_group))""") # create a table for storing unique report ids db.execute("""CREATE TABLE IF NOT EXISTS report_ids( id INTEGER, PRIMARY KEY (id))""") # create a table for job groups db.execute("""CREATE TABLE IF NOT EXISTS job_group( job_group TEXT, rate REAL, PRIMARY KEY (job_group))""") # insert data for job group table db.execute( """INSERT OR IGNORE INTO job_group VALUES('A', 20), ('B', 30)""" ) except sqlite3.Error as e: print("db_setup Error: %s" % e.args[0]) db.__exit__() print("------ Finish Database Setup -------")
def run(self): self._running = True while self._running: try: restQuery = self._socket.recv(1024) print restQuery except Exception as exc: print self._socket.getsockname(), exc break # Database connection db = DatabaseManager(DatabaseConfig.host) # Get SQL Query from REST sqlQuery = DatabaseManager.getSQLqueryFromREST(restQuery) # Get the result from SQL Server carObjects = db.SelectFromDatabase(sqlQuery) # Build a JSON String from the result jsonString = JSONBuilder.getJSON(carObjects) #Send to the server the result self._socket.send(jsonString) self._socket.close()
def get_soil_humidity(self): ir = InputReader() res = ir.read_analogic_sensor(analog_pin["soil_humidity"]) db = DatabaseManager() if (res <= 200): valDB = db.store_moisture(0) return 0 elif (res >= 510): valDB = db.store_moisture(100) return 100 else: temp = (10 * res - 2000) / 31 valDB = db.store_moisture(int(temp)) return int(temp)
class UpdateALayout(tkinter.Frame): def __init__(self, tkinter, row=0, column=0): super().__init__(tkinter) self.databaseM = DatabaseManager() self.parent = tkinter self.row = row self.column = column self.create_layout() def create_layout(self): label = tkinter.Label(self.parent, text="Aktualizovat vybrané anime", font=Font(size=40)) label.grid(row=self.row, column=self.column, columnspan=self.column + 2) label = tkinter.Label(self.parent, text="Vyber anime, které chceš aktualizovat") label.grid(row=self.row + 1, column=self.column) self.select_anime = ttk.Combobox( self.parent, value=self.databaseM.return_database()) self.select_anime.grid(row=self.row + 1, column=self.column + 1) def update_data(self): self.create_layout()
def handle_jawbone_login(self, data): c = Client(token_endpoint='https://jawbone.com/auth/oauth2/token', client_id='nEXyCKO3F3s', client_secret='c9a66fc619ccb0e7c2c4e90e59200dfba8aea5de', token_transport=transport_headers) c.request_token(grant_type='authorization_code', code=data['code']) #createInfo(c.access_token,c.token_expires) query = DatabaseManager('key.db') #maybe check if table doesn't exist and create it in DBMR__init__) query.updateInfo("UPDATE userinfo SET key = ?, expires = ?", c.access_token, c.token_expires) del query self.dump_client(c) return
def get_report_id_from_db(db_name: str) -> list: with DatabaseManager(db_name) as db: db.execute("SELECT * FROM report_ids") tup = db.fetchall() # convert tuples to a list result = list(sum(tup, ())) return result
def GetConceptDetails(self, concept_id, langcode, concept_ns=1): """ return all the information available for a given concept """ nt_list = [] bt_list = [] rt_list = [] ct_name = {} ct_trans = [] ct_definition = '' ct_note = '' errors = 0 conn = DatabaseManager() try: conn.openConnection(self) except OperationalError, error: #write log return ({}, [], [], [], [], '', '', '', (), (), (), (), 1)
def __init__(self, parent): super().__init__(parent) self.parent = parent self.dManager = DatabaseManager() self.parent.title("Moje anime") self.parent.minsize(900, 600) self.parent.resizable(True, True) self.create_widgets()
def __init__(self, filename: str): super().__init__() self.setupUi(self) self.setWindowModality(qtc.Qt.ApplicationModal) # block input to all other windows self.setWindowFlag(qtc.Qt.Window) # dialog box without min or max buttons self.setWindowFlag(qtc.Qt.FramelessWindowHint) # borderless window that cannot be resized self.__filename = filename self.__db_manager = DatabaseManager(self.__filename) self.__timer = qtc.QTimer() # a timer to display messages for a designated amount of time self.__timer.setSingleShot(True) # Set up the model-view structure for the 'Checked In' list. # As the data in the model changes, the view is updated automatically. # The QStringListModel is the easiest to implement since it does not require a customized model. checked_in_list = self.get_checked_in_list() self.__checked_in_model = qtc.QStringListModel(checked_in_list) self.checkedInList.setModel(self.__checked_in_model) self.checkedInList.setFocusPolicy(qtc.Qt.NoFocus) self.checkedInList.setVerticalScrollBarPolicy(qtc.Qt.ScrollBarAlwaysOn) self.checkedInList.setHorizontalScrollBarPolicy(qtc.Qt.ScrollBarAlwaysOff) self.checkedInList.setAutoScroll(False) self.checkedInList.setAutoScrollMargin(400) self.checkedInList.setEditTriggers(qtw.QAbstractItemView.NoEditTriggers) self.checkedInList.setSelectionMode(qtw.QAbstractItemView.NoSelection) self.barcode.setEchoMode(qtw.QLineEdit.Password) # hide the barcode number that was scanned, like a password # When a barcode is scanned, the 'returnPressed' signal emits which calls the 'barcode_scanned' slot. self.barcode.returnPressed.connect(lambda: self.barcode_scanned(self.barcode.text())) # Use the timer to clear the message. The self.refresh_window() method will start the timer. # The static method qtc.QTimer.singleShot() will perform a similar operation, however # if two students check in within the allotted time (3 seconds in this case) # then the first message will be cut short (as it should be) but # the second message will only display for the remaining time from the first message. self.__timer.timeout.connect(self.message.clear) if platform.system() == 'Windows': self.show() else: self.showFullScreen() self.check_database() # check if the database file exists after the main window displays
def getDataFromGitHubIntoDB(repositoryName): manager = GitConnectionManager() collaboratorData = GitCollaboratorData( manager.getConnection()).getCollaboratorData(repositoryName) print("Got Collaborator Data !") commitData = GitCommitData( manager.getConnection()).getCommitData(repositoryName) print("Got Commit Data !") (pullRequestData, pullReviewData) = GitPullRequestData( manager.getConnection()).getPullRequestData(repositoryName) print("Got Pull Request Data !") DatabaseManager.populateRepository(repositoryName, collaboratorData, commitData, pullRequestData, pullReviewData) print("Data Inserted !")
class Server(): def __init__(self): self.initQueues() print('[ SERVER ] Making a connection to Database...') self.dbConncetion = DatabaseManager() print('[ SERVER ] Initialising Gateway...') self.gatewayConnection = Gateway(self.dbConncetion, self.requestQueue, self.responseQueue) def initQueues(self): self.requestQueue = multiprocessing.Queue(1000) self.responseQueue = multiprocessing.Queue(1000) def waitForExit(self): print('[ SERVER ] Exiting...') self.gatewayConnection.processExit() self.dbConncetion.closeConnection() print('[ SERVER ] Closed.')
def setUp(self): sqlite_file = 'test.db' self.db = DatabaseManager(sqlite_file, '__ADMIN__') filename = "Test_Files/DatabaseManagerTest_15.csv" self.ingestor = Ingestor(filename) self.ingestor.readCSV() tempHeaders = self.ingestor.getCSVHeaders() self.searchCritera = [ tempHeaders[0], tempHeaders[1], tempHeaders[2], tempHeaders[4], tempHeaders[5], tempHeaders[6] ] searchCriteraTwoD = self.ingestor.getHeaderIndex( self.searchCritera, tempHeaders) self.ingestor.searchRows(searchCriteraTwoD, self.ingestor.getRows()) self.searchCritera = self.db.remove_spaces(self.searchCritera) self.new_table = 'Test_15'
def __init__(self, redcap, directory, articles, searchwords=[]): self.articles = articles self.directory = directory ml_data = DatabaseManager().get_ml_data(redcap) if (not searchwords): self.allwords = self.get_allwords() else: self.allwords = searchwords self.train(redcap, ml_data)
def run(self): print("Comment Stream Thread Started") if self.sub is None: return while True: metaList = RedditManager.fetchCommentMetaRecent(self.sub) DatabaseManager.updateCommentList(metaList) for post_meta in metaList: DatabaseManager.ensure_user_exists(post_meta.username, post_meta.subreddit) time.sleep(10) pass
def __init__(self, parent): super().__init__(parent) self.parent = parent self.dManager = DatabaseManager() self.parent.title("Anime page") self.parent.minsize(900, 600) self.parent.resizable(True, True) self.addAnimeL = None self.selectL = None self.create_widgets()
def __init__(self, window_title, db_file_loc, tables, protected_table_prefix): super().__init__() #Creating the window self.title = window_title self.setWindowTitle(self.title) self.protected_table_prefix = protected_table_prefix self.tablesInDB = tables #Database manager stuff self.db = DatabaseManager(db_file_loc, protected_table_prefix) #Create array with tables already in the database to be #put in the common files radio button box self.default_lists = [] for table in tables: tempList = [] for columnName in self.db.get_headers(table): tempList.append(columnName) self.default_lists.append(tempList) self.layout = QGridLayout()
def viewallskip(self, limit=1, offset=1): listtext = [] dbmgr = DatabaseManager("scribler.db") if limit == 1: for row in dbmgr.query("select * from notes"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) elif limit > 1: for row in dbmgr.query("select * from notes limit '" + str(limit) + "' OFFSET '" + str(offset) + "'"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) return listtext
def searchskip(self, query="", limit=1, offset=1): listtext = [] dbmgr = DatabaseManager("scribler.db") if limit == 1: for row in dbmgr.query("select * from notes where title LIKE '%" + query + "%' or content LIKE '%" + query + "%'"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) elif limit > 1: for row in dbmgr.query("select * from notes where title LIKE '%" + query + "%' or content LIKE '%" + query + "%' limit '" + str(limit) + "' OFFSET '" + str(offset) + "'"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) return listtext
class CrudOperations(object): dbmgr = None def __init__(self): # constructor initiates database connection instance self.dbmgr = DatabaseManager("cmapp.db") """Performs insert in db to save a notetext """ def save(self, **content): # content contains the name and mobile number of contacts contactname = "" contactnumber = "" if len(content) == 2: # Both name and mobile number exist contactname = content['contactname'] contactnumber = content['contactnumber'] elif len(content) == 1: # only title exists return "Cannot save to db only one argument provided , two are expected" # save to db self.dbmgr.query( "insert into contactsDB(Contactname,Content,sent,datecreated) VALUES('" + contactname + "','" + contactnumber + "','NO','" + self.gettime() + "')")
def run(self): print("Post Maintenance Thread Started") DAY_HALF_SECONDS = 60 * 60 * 24 * 1.5 while True: try: current_time = datetime.datetime.utcnow().timestamp() post_list = DatabaseManager.get_all_posts( dateLimit=current_time - DAY_HALF_SECONDS) post_sub_list = [] count = 0 while count < len(post_list): cur_post = post_list[count] cur_post.fetch() if count % 10 == 0: DatabaseManager.updatePostList(post_sub_list) post_sub_list = [] post_sub_list.append(post_list[count]) count += 1 except: print("Post Main Thread Exception: " + str(sys.exc_info()[0])) pass
def save_video_list_by_playlist(playlist): pytplaylist = pyTubePlaylist(playlist.url) pytplaylist.populate_video_urls() videos = [] for videoUrl in pytplaylist.video_urls: try: CurrentVideo = YouTube(videoUrl) except: print "Error parsing videoUrl:- {0}", videoUrl try: url = videoUrl title = CurrentVideo.title duration = CurrentVideo.length views = CurrentVideo.views thumbnailUrl = CurrentVideo.thumbnail_url fullimageUrl = thumbnailUrl playlistUrl = playlist.url video = Video(url, title, duration, views, thumbnailUrl, fullimageUrl, playlistUrl) videos.append(video) except: print "Error occured Extracting Data videoUrl :- {0}", videoUrl db = DatabaseManager() for vid in videos: try: db.insert_video(vid) except: print "Error occurred inserting video to db , VideoUrl :-{0}", videoUrl db.insert_playlist(playlist)
def run(self): print("User Stream Thread Started") while True: try: post_list = DatabaseManager.get_all_posts() for cur_post in post_list: DatabaseManager.ensure_user_exists(cur_post.username, cur_post.subreddit) comment_list = DatabaseManager.get_all_comments() for cur_comment in comment_list: DatabaseManager.ensure_user_exists(cur_comment.username, cur_comment.subreddit) except: print("User Stream Thread Exception: " + str(sys.exc_info()[0])) pass
def searchThesaurus(self, term, langcode='en', ns=1): """ """ if not term: return [] conn = DatabaseManager() conn.openConnection(self) collation = self._get_language_collation(langcode, conn) err, res, msg = conn.query(sql_find_concept(term, langcode, collation)) if err: # log error return [] conn.closeConnection() results = [] for i in res: if i['scope_name'] is None: i['scope_name'] = '' if i['concept_alt_name'] is None: i['concept_alt_name'] = '' results.append(ConceptLink(ns, i['concept_id'], i['concept_name'], i['scope_name'], i['concept_alt_name'])) return results
def main(): DatabaseManager.init_connection('test.sqlite') DatabaseManager.create_tables() RedditManager.login_threads_from_file("config.yml") ThreadedServices.setup_threads("BotParty") # RedditManager.get_bans("BotParty") # RedditManager.get_messages() # ThreadedServices.setup_threads(SUBREDDIT) # ThreadedServices.setup_threads("OnionHate") # ThreadedServices.setup_threads("OnionHate") while True: time.sleep(0)
class DatabaseManagerTest: def __init__(self): self.manager = DatabaseManager() self.cmanager = CSVManager() #manager.exportReplayDatabase() def createDatabase(self): pass def importDatabase(self, databasePath): return self.manager.read(databasePath) def exportDatabase(self, data, header, filePath, createBackup): self.cmanager.write(data, header, filePath, createBackup) def dropTest(self, colName, database): return self.manager.delCol(colName, database) def swapTest(self, cols, database): return self.manager.swapCols(cols, database) def delDuplicatesTest(self, database): return self.manager.delDupes(database) def databaseTester(self): testReplay = '87B11D4743F1EAE859CAC9B48DAA8E89.replay' # testDB = pd.read_csv(defaultDatabasePath) # print(testDB) dbm = DatabaseManager() dbm.read() #print(dbm.database) row = dbm.getRow(testReplay) print(row) value = row.iloc[0]['GUID'] print(value)
def viewall(self, limit=1): listtext = [] dbmgr = DatabaseManager("scribler.db") if limit == 1: for row in dbmgr.query("select * from notes"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) elif limit > 1: for row in dbmgr.query("select * from notes limit '" + str(limit) + "'"): notetext = {} notetext["_id"] = row[0] notetext["title"] = row[1] notetext["body"] = row[2] notetext["datecreated"] = row[4] listtext.append(notetext) return listtext # list containing dictionary entries of notes
def SetTpUpdateNSlUpdateOrder_DOWN(task, childOrder): tpFound = False slFound = False tpOfPosition = 0 tpOrderID = 0 slOfPosition = 0 slOrderID = 0 for order in childOrder: if order['order_type'] == 'LIMIT': tpFound = True tpOrderID = order['order_id'] tpOfPosition = order['price'] elif order['order_type'] == 'SL': slFound = True slOrderID = order['order_id'] dbInstance = DatabaseManager.GetInstance() # This level is already 1 down of current tp, so we need to get next level type then set tpupdate n slupdate task levelType = task[2] tmpNxtLevel = dbInstance.GetNextLevel(task[0], levelType) if tmpNxtLevel.__len__() == 0: return #levelType = tmpNxtLevel[0][0] if tpFound: levelPrice = tpOfPosition * (1 + 0.0005) nxtLevel = dbInstance.GetNextLevel(task[0], levelType) if nxtLevel.__len__() > 0: nextTP = nxtLevel[0][1] nextLevelType = nxtLevel[0][0] dbInstance.CreateNewTask(task[0], task[1], nextLevelType, levelPrice, nextTP, 0.0, TASK_TYPE_ENUM[2], LEVEL_CROSS_TYPE_ENUM[1], tpOrderID) if slFound: levelPrice = tpOfPosition(1 + 0.0003) # Only first time we need prev level, for other time, we need next level prevLevel = dbInstance.GetPrevLevel(task[0], levelType) if prevLevel.__len__() > 0: nextSL = prevLevel[0][1] nxtLevel = dbInstance.GetNextLevel(task[0], levelType) if nxtLevel.__len__() > 0: nextLevelType = nxtLevel[0][0] dbInstance.CreateNewTask(task[0], task[1], nextLevelType, levelPrice, 0.0, nextSL, TASK_TYPE_ENUM[3], LEVEL_CROSS_TYPE_ENUM[1], slOrderID)
def main(self): self.__dbManager = DatabaseManager() print('') print( 'Welcome to our library! What would you like to do? Please enter the number of option.' ) print('1. Sign up a new account') print('2. Log in with Password') print('3. Log in with Facial Recognition') print('4. Exit') option = TakeInput.inputInteger(1, 4) if option == 1: self.register() elif option == 2: self.loginWithPassword() elif option == 3: self.loginWithFacial() else: self.logout()
def __init__(self): """Init""" if not hasattr(ServerManager, 'instance'): ServerManager.instance = self else: self.log("Error: singleton already defined") sys.exit(-1) self.__running = True self.__db = DatabaseManager(DatabaseType.CSV, cfg.db_addr) # Instantiate the port manager for all games + admin messages self.__port_manager = PortManager(cfg.lower_bound, cfg.upper_bound) # Instantiate the message manager exclusively for admin messages self.__message_manager = WebsocketMessageManager(cfg.admin) self.__pid = os.getpid() self.__public_requests = ThreadsafeQueue() self.__game_pids = ThreadsafeQueue() self.__logger = Logger(cfg.log_addr) self.__http_proc = threading.Thread(target=self.serveHTTP) self.__pub_polling = threading.Thread(target=self.pollPublic) self.log("Server Initialized") self.__http_proc.start() self.__pub_polling.start()
def SetTpUpdateOrder_DOWN(task): # Now before setting another order, check whether this order is still open or not if OrderClosed(task[8]): return levelType = task[2] levelPrice = task[4] * (1 + 0.0005) dbInstance = DatabaseManager.GetInstance() nxtLevel = dbInstance.GetNextLevel(task[0], levelType) if nxtLevel.__len__() > 0: nextTP = nxtLevel[0][1] nextLevelType = nxtLevel[0][0] dbInstance.CreateNewTask(task[0], task[1], nextLevelType, levelPrice, nextTP, 0.0, TASK_TYPE_ENUM[2], LEVEL_CROSS_TYPE_ENUM[1], task[8])
class Model(): instance = None def __init__(self): Model.instance = self self.db = DatabaseManager("periodic.sqlite") self.computer = ConcentrationComputer() self.balance = Balance() def getElements(self): """ Retourne les elements chimiques depuis la base de données """ elements = self.db.fetchElements() return elements
def salvaDados(): id_aluno = listaAlunos.get() id_prof = listaProf.get() id_disciplina = listaD.get() nota1 = fldnota1.get() nota2 = fldnota2.get() if id_aluno == "": messagebox.showinfo("Erro", "Informe um aluno!") elif id_prof == "": messagebox.showinfo("Erro", "Informe um professor!") elif id_disciplina == "": messagebox.showinfo("Erro", "Informe uma disciplina!") elif nota1 == "" or nota2 == "": messagebox.showinfo("Erro", "Informe os valores das notas!") else: DatabaseManager.insert( "notes", [contaID, id_aluno, id_prof, id_disciplina, nota1, nota2]) messagebox.showinfo("Aviso", "Dados inseridos no banco!")
def _get_concept_relatives(self, concept_ns, concept_id, target_ns=None, relation_uri=None): """ get all concepts related to a given concept """ conn = DatabaseManager() conn.openConnection(self) err, res, msg = conn.query(sql_get_concept_relatives(concept_ns, concept_id, target_ns, relation_uri)) conn.closeConnection() return res
def fetch_namespaces(self): conn = DatabaseManager() conn.openConnection(self) err, res, msg = conn.query(sql_get_namespaces()) if err: print err, msg conn.closeConnection() return res
def fetch_concept_property_translations(self, concept_ns, concept_id, prop_name): conn = DatabaseManager() conn.openConnection(self) err, res, msg = conn.query(sql_get_concept_property(concept_ns, concept_id, prop_name)) if err: print err, msg conn.closeConnection() return res
def __init__(self, parent=None): """ Face Detection Init. Instantiate all the classes required by face detection module. """ super().__init__(parent) self.constants = Constants() self.db_manager = DatabaseManager() self._red = (0, 0, 255) self._width = 2 self.image = QtGui.QImage() self.process_this_frame = True self.foundNewFace = False self.foundFace = False
def SetSlUpdateOrder_DOWN(task): # Now before setting another order, check whether this order is still open or not if OrderClosed(task[8]): return levelType = task[2] nextSL = task[3] # current level(old tp) will be new sl dbInstance = DatabaseManager.GetInstance() currentLevel = dbInstance.GetCurrentLevel(task[0], levelType) if currentLevel.__len__() > 0: nxtLevel = dbInstance.GetNextLevel(task[0], levelType) if nxtLevel.__len__() > 0: nextLevelType = nxtLevel[0][0] nextLevelPrice = currentLevel[0][1] * (1 + 0.0003) dbInstance.CreateNewTask(task[0], task[1], nextLevelType, nextLevelPrice, 0.0, nextSL, TASK_TYPE_ENUM[3], LEVEL_CROSS_TYPE_ENUM[1], task[8])
def main(argv): opts = get_command_args(argv) dm = DatabaseManager() if (opts['data']): pprint(dm.get_data(opts['redcap'])) if (opts['match']): pprint(dm.get_matches(opts['redcap'], opts['bool'], opts['value'])) if (opts['search']): pprint(dm.get_searches(opts['redcap'], opts['bool'], opts['value'])) if (opts['mach']): pprint(dm.get_ml_data(opts['redcap']))
def Handle_LogIn(self): print("button pressed") db = DatabaseManager(self.db_file_loc, self.protected_table_prefix) username = self.user_name_tf.text() password = self.password_tf.text() try: if db.is_valid_string(username) and db.is_valid_string(password): #Both user name and password have to be valid strings to continue if not db.doesTableExist(self.account_info_table_name): print("Must create account before") #Gets the account from the databse with the same password #If the isn't a match then it returns none row_with_entered_pass = db.get_row_at( self.account_info_table_name, column_name=account_columns[0], column_value=password) # print(row_with_entered_pass) if not row_with_entered_pass == None: #If the there is a password match then save the info password_db = row_with_entered_pass[0] user_name_db = row_with_entered_pass[1] if password_db == password and user_name_db == username: #If the user name and password entered match the #user name and password in the db then it's a valid login self.valid_login() else: ErrorBox = QtWidgets.QMessageBox() ErrorBox.warning( self, 'No Account Found', "No account found for the combination of user name and password", ErrorBox.Ok) else: ErrorBox = QtWidgets.QMessageBox() ErrorBox.warning( self, 'No Account Found', "No account found for the combination of user name and password", ErrorBox.Ok) else: raise Exception() except: ErrorBox = QtWidgets.QMessageBox() ErrorBox.critical( self, 'Text Entry Error', "Text entries can only have letters numbers, and underscores", ErrorBox.Ok)
def get_light(self): ir = InputReader() res = ir.read_analogic_sensor(analog_pin["light"]) db = DatabaseManager() if (res <= 200): valDB = db.store_light(0) return 0, "Dark" elif (res > 200 and res <= 400): valDB = db.store_light(1) return 1, "Dim" #shadow elif (res > 400 and res <= 700): valDB = db.store_light(2) return 2, "Light" elif (res > 700 and res <= 900): valDB = db.store_light(3) return 3, "Bright" else: valDB = db.store_light(4) return 4, "Very Bright"
def generate_output_report(db: str) -> list: try: with DatabaseManager(db) as db: db.execute(""" SELECT employee_id, pay_period, amount_paid FROM ( SELECT r.employee_id , SUM(r.amount_paid) as amount_paid, CASE WHEN strftime('%d',r.date) < '16' THEN strftime('%m-%Y', Date(r.date,'start of month')) || ' - ' || strftime('%m-%Y', Date(r.date,'start of month','+14 day')) ELSE strftime('%m-%Y', Date(r.date,'start of month','+15 day')) || ' - ' || strftime('%m-%Y', Date(r.date,'start of month','+1 month','-1 day')) END month_year_key, CASE WHEN strftime('%d',r.date) < '16' THEN strftime('%d/%m/%Y', Date(r.date,'start of month')) || ' - ' || strftime('%d/%m/%Y', Date(r.date,'start of month','+14 day')) ELSE strftime('%d/%m/%Y', Date(r.date,'start of month','+15 day')) || ' - ' || strftime('%d/%m/%Y', Date(r.date,'start of month','+1 month','-1 day')) END pay_period FROM ( SELECT i.date, i.employee_id, i.hours_worked*j.rate AS amount_paid FROM input_reports i JOIN job_group j ON i.job_group = j.job_group ORDER BY i.employee_id, i.date ASC) r GROUP BY pay_period, employee_id ORDER BY employee_id, month_year_key, pay_period ASC)""" ) output_report = db.fetchall() return output_report except sqlite3.Error as e: print("db_setup Error: %s" % e.args[0]) db.__exit__()