def server_initialize(self, status, port, host_backup, port_backup): if (status == 'active'): self.server_tag = "A" self.active = True self.db = DBHandler(connection_string_1, "register-share-system-1") self.start_timer_thread() else: self.server_tag = "B" self.db = DBHandler(connection_string_2, "register-share-system-2") self.port = port self.host_backup = host_backup self.port_backup = port_backup
def index(): db_handler = DBHandler() all_providers = db_handler.get_all_providers() providers_selected = np.random.choice(all_providers, size=CINEMA_TO_SHOW, replace=False) is_auth = current_user.is_authenticated negative_item = None similar_user = None if is_auth: user_id = current_user.id negative_item = find_negative_item(user_id) similar_user = find_similar_user(user_id) feedback = LikeForm() if feedback.validate_on_submit(): db_handler.add_interaction(user_id=user_id, item_id=negative_item.id) flash(flash_messages["got_feedback"]) redirect(url_for("index")) return render_template( "index.html", providers=providers_selected, negative_item=negative_item, similar_user=similar_user, is_auth=is_auth, form=feedback, )
def run(self): while True: time.sleep(1) print(app.engineThread.waterLevel) db_handler = DBHandler() db_handler.save_to_db(app.engineThread.waterLevel, app.engineThread.aim)
def cinema(): db_handler = DBHandler() id = request.args.get("id") provider = db_handler.get_provider_by_id(id=id) movies_in = db_handler.get_items_in_provider(provider_id=provider.id) movies_id = [movie.id for movie in movies_in] movies_obj = db_handler.get_items_by_ids(movies_id) auth = current_user.is_authenticated """ We are going to sort movies for user """ if auth: model = ALSRecommender() model.load() scores = model.score(id, movies_id) movies_obj = list(np.array(movies_obj)[np.argsort(scores)[::-1]]) movies_obj = movies_obj[:MOVIES_TO_SHOW] return render_template( "cinema.html", provider=provider, movies=movies_obj, auth=auth, len_movies=len(movies_obj), )
def __init__(self): self.db = DBHandler() self.file_handler = FileHandler() self.db.create_database() self.db.create_tables() self.db.create_room_birthday_idx() self.db.create_sex_index() self.insert_data()
def main(): handler = DBHandler(DB_NAME, DB_USER, DB_PASSWORD) with handler: handler.insert_values('Teams', ('Team 2', True, 't2_password')) print(handler.query_list('SELECT * FROM Teams;')) handler.insert_values('Bids', ('bid_1', 4.56, False)) handler.insert_values('Bids', ('bid_2', 7.89, False)) print(handler.query_list('SELECT * FROM Bids;')) handler.update_values('Bids', "bid_id = 'bid_2'", ("price", ), ('1.23', )) print(handler.query_list('SELECT * FROM Bids;'))
def main(): handler = DBHandler(k.DB_NAME, k.DB_USER, k.DB_PASSWORD) with handler: handler.query_one('DELETE From Drone_States_History;') handler.query_one('DELETE From Requests;') handler.query_one('DELETE From Request_States;') handler.query_one('DELETE From Drones;') handler.query_one('DELETE From Teams;') handler.query_one('DELETE From Ports;') _loadRequestStates(handler) _loadTeams(handler) _loadPorts(handler)
def count_predictions( config: dict, db_name: str, dark_terms: List[str] ) -> Tuple[List[WordWindow], DefaultDict[str, Counter]]: hdlr = DBHandler(config['data']['db_dir'], db_name) model = WordPredictModel(config['mask']['model_name']) word_windows = _fetch_word_windows(dark_terms, hdlr, config['mask']['window_size']) counters = _predict_masked_words(word_windows, model, config['mask']['top_k']) return word_windows, counters
def main(): # give functionality for creating table, inserting into table, deleting from table, retrieving data from table conn = create_connection("test_amaris.db") while True: db_handler = DBHandler(conn) print_help("init") curr = cmd_handler(db_handler) if curr == False: break finish(conn)
def register(): db_handler = DBHandler() if current_user.is_authenticated: return redirect(url_for("index")) form = RegistrationForm() if form.validate_on_submit(): db_handler.add_user(name=form.name.data, password=form.password.data) flash(flash_messages["new_user"]) return redirect(url_for("login")) return render_template("register.html", title="Register", form=form)
def download_log_files(self): jobs = self.service.jobs blocking_search = {"exec_mode": "blocking"} query = "search | head 5" job = jobs.create(query, **blocking_search) job_results = results.ResultsReader(job.results(count=5)) i = 0 mydb = DBHandler() for result in job_results: if True: mydb.create_log_entry(i, result['_raw'], result['_indextime'], result['host'], result['source'], result['sourcetype']) i += 1
def main(): running = True message_queue = queue.Queue() print("Creating mqtt class..") mqtt_thread = MqttConnector() mqtt_thread.start() ## Start sensors temp_sensor = TemperatureSensor(message_queue) #ir_temp_sensor = IRTemperatureSensor(message_queue) #ir2_temp_sensor = IR2TemperatureSensor(message_queue) #gps_sensor = GpsSensor(message_queue) humidity_sensor = HumiditySensor(message_queue) pressure_sensor = PressureSensor(message_queue) orientation_sensor = OrientationSensor(message_queue) acceleration_sensor = AccelerationSensor(message_queue) imu_sensor = UDPReceiver(cfg.ip_imu, cfg.port_imu, message_queue, "IMU") seanav_sensor = UDPReceiver(cfg.ip_seanav, cfg.port_seanav, message_queue, "SEANAV") temp_sensor.start() #ir_temp_sensor.start() #ir2_temp_sensor.start() #gps_sensor.start() humidity_sensor.start() pressure_sensor.start() orientation_sensor.start() acceleration_sensor.start() imu_sensor.start() seanav_sensor.start() ## Connect to databases db_handler = DBHandler(local=True, cloud=True) ## Wait for connected to server while not mqtt_thread.connected: continue print("Connected...") print("Start message sender") sender = MessageSender(message_queue, mqtt_thread, db_handler) sender.start() ## Keep from stopping program while (running): continue print("Program end")
def find_similar_user(user_id): db_handler = DBHandler() user_factors = np.load(CURRENT_USER_FACTORS_PATH, allow_pickle=True) if user_id > user_factors.shape[0]: most_similar_user_id = np.random.choice(user_factors.shape[0]) else: user_factor = user_factors[user_id - 1] dot_product = (user_factor * user_factors).sum(1) indexes = np.argsort(dot_product)[::-1] most_similar_user_id = int(indexes[-2]) print(most_similar_user_id, type(most_similar_user_id)) most_similar_user = db_handler.get_user_by_id(user_id=most_similar_user_id) return most_similar_user
def find_negative_item(user_id): db_handler = DBHandler() all_items = db_handler.get_all_items() items_ids = [item.id for item in all_items] interacted_items = db_handler.get_interactions_by_id(user_id=user_id) interacted_items_id = [item.item_id for item in interacted_items] not_interacted_items_id = list(set(items_ids) - set(interacted_items_id)) not_interacted_items = db_handler.get_items_by_ids(not_interacted_items_id) if not_interacted_items is None: return None else: not_interacted_item = np.random.choice(not_interacted_items) return not_interacted_item
def main(): try: data_handler: DataHandler = DBHandler() checker: Checker = Checker(data_handler) # Create the parser input_path = get_csv_path() print("Welcome to Vulnerability Checker") if input_path is None: print("Scanning the all packages on machine for vulnerabilities...\n") checker.scan_machine() else: print("Scanning the given packages for vulnerabilities...\n") checker.scan_user_list(input_path) except User_Exit_Interrupt: print("\n\nUser stopped the scan. Exiting program...") sys.exit(0) except KeyboardInterrupt: print("\n\nUser stopped the scan. Exiting program...") sys.exit(0)
def extract_timestamps(config: dict, dark_terms: Sequence[str]): timestamps = {} db_names = config['data']['db_names'][:3] for db_name in db_names: db_handler = DBHandler(config['data']['db_dir'], db_name) table_name = db_handler.table_name timestamps[table_name] = extract_timestamps_for_db( db_handler, dark_terms) total = timestamps.get('total', {}) for dark_term in dark_terms: if dark_term not in total: series = timestamps[table_name][dark_term] else: series1 = timestamps['total'][dark_term] series2 = timestamps[table_name][dark_term] series = (series1 + series2).fillna(series2).fillna(series1) total[dark_term] = series timestamps['total'] = total print('writing timestamps for {}'.format(db_name)) pkl.dump(timestamps, open(dict_out, 'wb'))
def login(): db_handler = DBHandler() if current_user.is_authenticated: return redirect(url_for("index")) form = LoginForm() if form.validate_on_submit(): user = db_handler.get_user_by_name(name=form.username.data) if user is None or not user.check_password(form.password.data): flash(flash_messages["invalid_login"]) return redirect(url_for("login")) login_user(user, remember=form.remember_me.data) next_page = request.args.get("next") flash(flash_messages["login_ok"]) if not next_page or url_parse(next_page).netloc != "": next_page = url_for("index") return redirect(next_page) return render_template("login.html", title="Sign In", form=form)
load_config, COUNTRIES, SCORE_THRESHOLD, RUMOR_THRESHOLD, USEFUL_THRESHOLD, SENTIMENT_THRESHOLD, ITOPICS, ECOUNTRY_ICOUNTRIES_MAP, ) logger = logging.getLogger(__file__) cfg = load_config() meta_data_handler = MetaDataHandler() db_handler = DBHandler(**cfg["db_handler"]) log_handler = LogHandler(**cfg["log_handler"]) twitter_handler = TwitterHandler(**cfg["twitter_handler"]) def update_database(do_tweet: bool = False): logger.debug("Add automatically categorized pages.") data_path = cfg["data"]["article_list"] cache_file = f'{cfg["log_handler"]["log_dir"]}/offset.txt' if os.path.exists(cache_file): with open(cache_file) as f: offset = int(f.read().strip()) else: offset = 0 logger.debug(f"Skip the first {offset} lines.") maybe_tweeted_ds = []
# Revolet # Force override doesnt work. must delete model and associated files. cf = CFHandler('109jikL9APOQLYLWVbh0BPzsKh4Fj1E5y', '1d4uAconWl18s629ZUMaZlXkopD2Vfzh3', '1-JiAeAJ_0XWXxkRteRP1my84x57cpVmg', force_download=False) # Sum # Take paper2data (authors, citing authors) from CF (Revolet) if use_semantic: from inference.semantic import SemanticHandler semantic = SemanticHandler('1-n-GephieNUHJ-pXeHIoX-rjMWRtssKj', '11rB0mV9o5Uk78d8bIjzDR4obnHtn2bwc', '1-H_P6t33LNMfaAuD7qtj7b9hD-RviLvQ') db_handler = DBHandler(cf, mock=not use_db) def get_best_authors(title, author_ids, top=10): if len(author_ids) > 0: cf_recommended_authors = cf.get_recommended_authors(author_ids, top) else: cf_recommended_authors = [] # TODO: We dont care about the weight but we should cf_recommended_authors = [ author_score_tuple[0] for author_score_tuple in cf_recommended_authors ] if title is not None and use_semantic: semantic_recommended_authors = semantic.get_recommended_authors(
def __init__(self): self.db_handler = DBHandler() self.current_user = None self.semester = None self.curr_offering = None self.create_instances()
def findChecksecinDB(package, rowlist): query = f"SELECT {CHECKSEC} from {VULNERABILITY_TABLE_NAME} where {PACKAGE} = '{package}' and {CHECKSEC} != 'NULL'" db = DBHandler() result = db._execute_select(query) rowlist.extend(result)
app = Flask(__name__) # === Application settings ============================================================================================= SERVER_PORT = 5000 API_PREFIX = '/api/v1' # === CORS setting ===================================================================================================== cors = CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' # === database handling ================================================================================================ dbhandler = DBHandler(database_file='test.db') # === Routes definition ================================================================================================ @app.route('/') def home(): # code to automatically send origin urls if not request.script_root: # print "########## not request.script_root:" # this assumes that the 'home' view function handles the path '/' request.origin = {} request.origin['baseUrl'] = url_for('home', _external=True) request.origin[ 'apiBaseUrl'] = request.origin['baseUrl'] + API_PREFIX[1:] print request.origin
from db_handler import DBHandler from goodreadapi import get_book_data app = Flask(__name__) # Check for environment variable if not os.getenv("DATABASE_URL"): raise RuntimeError("DATABASE_URL is not set") # Configure session to use filesystem app.config["SESSION_PERMANENT"] = False app.config["SESSION_TYPE"] = "filesystem" Session(app) # Set up database dbh = DBHandler(os.getenv("DATABASE_URL")) @app.route("/api/<string:isbn>") def book_api(isbn): """Return details in json format about single book""" book, message = dbh.get_book_by_isbn(isbn) if message: return jsonify({"error": "Invalid isbn"}), 404 goodreads = get_book_data(isbn) return jsonify({ "title": book.title, "author": book.author, "year": book.year, "isbn": isbn,
def handle_message(self, message_dict, address): message_type = message_dict["TYPE"] self.write_to_log('MESSAGE RECEIVED\t [' + str(address) + ']:\t ' + str(message_dict)) if (message_type == "INITIALIZATION"): self.client_list.append(address) self.semaphore.acquire() try: if self.active == True: # Notify the client about which server is the active one ("A" or "B") msg = { "TYPE": "INITIALIZATION-SUCCESS", "SERVER-TAG": self.server_tag } msg_serialized = utils.serialize(msg) self.sock.sendto(msg_serialized, address) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) finally: self.semaphore.release() elif (message_type == "REGISTER"): success = self.db.add_user(message_dict["NAME"], message_dict["IP"], message_dict["PORT"]) if (success == 0): msg = {"TYPE": "REGISTER-SUCCESS", "RQ#": message_dict["RQ#"]} self.semaphore.acquire() try: if self.active == True: self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) finally: self.semaphore.release() else: if (success == 1): msg = { "TYPE": "REGISTER-DENIED", "RQ#": message_dict["RQ#"], "REASON": "USERNAME ALREADY EXISTS" } elif (success == 2): msg = { "TYPE": "REGISTER-DENIED", "RQ#": message_dict["RQ#"], "REASON": "NOT A VALID USERNAME" } elif (success == 3): msg = { "TYPE": "REGISTER-DENIED", "RQ#": message_dict["RQ#"], "REASON": "DATABASE CONNECTION ERROR" } self.semaphore.acquire() try: if self.active == True: self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) finally: self.semaphore.release() elif (message_type == "DE-REGISTER"): success = self.db.remove_user(message_dict["NAME"]) if (success): msg_client = { "TYPE": "DE-REGISTER-SUCCESS", "RQ#": message_dict["RQ#"] } msg_server = { "TYPE": "DE-REGISTER-SUCCESS", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"] } self.sock.sendto(utils.serialize(msg_client), address) self.sock.sendto(utils.serialize(msg_server), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg_client)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg_server)) else: msg_client = { "TYPE": "DE-REGISTER-DENIED", "RQ#": message_dict["RQ#"] } msg_server = { "TYPE": "DE-REGISTER-DENIED", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"] } self.sock.sendto(utils.serialize(msg_client), address) self.sock.sendto(utils.serialize(msg_server), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg_client)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg_server)) elif (message_type == "UPDATE-SOCKET"): success = self.db.update_socket(message_dict["NAME"], message_dict["IP"], message_dict["PORT"]) if (success): msg = { "TYPE": "UPDATE-SOCKET-SUCCESS", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "IP": message_dict["IP"], "PORT": message_dict["PORT"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) else: msg = { "TYPE": "UPDATE-SOCKET-DENIED", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "IP": message_dict["IP"], "PORT": message_dict["PORT"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) elif (message_type == "SUBJECTS"): subjects_list = message_dict["SUBJECT-LIST"].split(",") print(subjects_list) success = self.db.update_subjects(message_dict["NAME"], subjects_list) if (success): msg = { "TYPE": "UPDATE-SUBJECTS-SUCCESS", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "SUBJECT-LIST": message_dict["SUBJECT-LIST"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) else: msg = { "TYPE": "UPDATE-SUBJECTS-DENIED", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "SUBJECT-LIST": message_dict["SUBJECT-LIST"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) elif (message_type == "PUBLISH"): success = self.db.publish_message(message_dict["NAME"], message_dict["SUBJECT"], message_dict["TEXT"]) if (success): msg = { "TYPE": "PUBLISH-SUCCESS", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "SUBJECT": message_dict["SUBJECT"], "TEXT": message_dict["TEXT"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) else: msg = { "TYPE": "PUBLISH-DENIED", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "SUBJECT": message_dict["SUBJECT"], "TEXT": message_dict["TEXT"] } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) elif (message_type == "RETRIEVE-TEXTS"): msg_list = self.db.retrieve_texts(message_dict["NAME"]) if (msg_list != None): msg = { "TYPE": "RETRIEVE-SUCCESS", "RQ#": message_dict["RQ#"], "NAME": message_dict["NAME"], "POSTS": msg_list } self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) else: msg = {"TYPE": "RETRIEVE-DENIED", "RQ#": message_dict["RQ#"]} self.sock.sendto(utils.serialize(msg), address) self.sock.sendto(utils.serialize(msg), (self.host_backup, self.port_backup)) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg)) self.write_to_log('MESSAGE SENT\t\t [' + str((self.host_backup, self.port_backup)) + ']:\t ' + str(msg)) elif (message_type == "CHANGE-SERVER"): # If the server receives this message, it gains control self.gain_control() self.start_timer_thread() elif (message_type == "UPDATE-SERVER"): self.semaphore.acquire() try: if self.active == True: # If a server receives this message, it means it the inactive server has # changed its IP and PORT. Thus, we should update these values self.host_backup = message_dict["IP"] self.port_backup = message_dict["PORT"] # We should now reply to the new server that we have taken note of its IP and PORT # We also send it our IP and PORT number so it knows which one is the active server msg_reply = { "TYPE": "UPDATE-SERVER-SUCCESS", "IP": self.host, "PORT": self.port, "SERVER-TAG": self.server_tag, "CLIENT-LIST": self.client_list } msg_reply_serialized = utils.serialize(msg_reply) self.sock.sendto(msg_reply_serialized, address) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg_reply)) # else if the inactive server receives this message, it should send a message # to all the connected clients so they know where the new inactive server is else: new_host = message_dict["IP"] new_port = message_dict["PORT"] msg_client = { "TYPE": "UPDATE-SERVER", "IP": new_host, "PORT": new_port, "SERVER-TAG": self.server_tag } msg_client_serialized = utils.serialize(msg_client) for i in self.client_list: self.sock.sendto(msg_client_serialized, i) self.write_to_log('MESSAGE SENT\t\t [' + str(i) + ']:\t ' + str(msg_client)) self.write_to_log("SERVER-CLOSED") print("SERVER-CLOSED") except: print("ERROR SENDING UPDATE-SERVER MESSAGE") msg_error = {"TYPE": "UPDATE-SERVER-DENIED"} msg_error_serialized = utils.serialize(msg_error) self.sock.sendto(msg_error_serialized, address) self.write_to_log('MESSAGE SENT\t\t [' + str(address) + ']:\t ' + str(msg_error)) finally: self.semaphore.release() elif (message_type == "END-CONNECTION"): try: self.client_list.remove(address) except: pass elif ((message_type == "REGISTER-SUCCESS") or (message_type == "REGISTER-DENIED")): pass elif ((message_type == "DE-REGISTER-SUCCESS") or (message_type == "DE-REGISTER-DENIED")): try: if (message_type == "DE-REGISTER-SUCCESS"): success = self.db.remove_user(message_dict["NAME"]) except Exception as msg: print(str(msg)) elif ((message_type == "UPDATE-SOCKET-SUCCESS") or (message_type == "UPDATE-SOCKET-DENIED")): try: if (message_type == "UPDATE-SOCKET-SUCCESS"): self.db.update_socket(message_dict["NAME"], message_dict["IP"], message_dict["PORT"]) except: pass elif ((message_type == "UPDATE-SUBJECTS-SUCCESS") or (message_type == "UPDATE-SUBJECTS-DENIED")): subjects_list = message_dict["SUBJECT-LIST"].split(",") try: if (message_type == "UPDATE-SUBJECTS-SUCCESS"): self.db.update_subjects(message_dict["NAME"], subjects_list) except: pass elif ((message_type == "PUBLISH-SUCCESS") or (message_type == "PUBLISH-DENIED")): try: if (message_type == "PUBLISH-SUCCESS"): self.db.publish_message(message_dict["NAME"], message_dict["SUBJECT"], message_dict["TEXT"]) except: pass elif ((message_type == "RETRIEVE-SUCCESS") or (message_type == "RETRIEVE-DENIED")): try: if (message_type == "RETRIEVE-SUCCESS"): self.db.retrieve_texts(message_dict["NAME"]) except: pass elif ((message_type == "UPDATE-SERVER-SUCCESS") or (message_type == "UPDATE-SERVER-DENIED")): try: if (message_type == "UPDATE-SERVER-SUCCESS"): if message_dict["SERVER-TAG"] == "A": self.server_tag = "B" self.db = DBHandler(connection_string_2, "register-share-system-2") else: self.server_tag = 'A' self.db = DBHandler(connection_string_1, "register-share-system-1") self.host_backup = message_dict["IP"] self.port_backup = message_dict["PORT"] self.client_list = utils.convert( message_dict["CLIENT-LIST"]) except: pass else: pass
roads_download = args["roads_download"] simplify = args["simplify"] dsn = args["dsn"] assign_address = args["assign_address"] check_address = args["check_address"] check_building = args["check_building"] check_road_rail = args["check_road_rail"] vacuum = args["vacuum"] report = args["report"] index = args["index_data"] bbox = args["bbox"] add_fields = args["add_fields"] dedupe = args["dedupe_address"] convert_poly = args["convert_poly"] db = DBHandler(dsn) osm = OSMHandler(bbox) if setup: print 'Setting up the database.' db.setup_db() if building_download: print 'Querying OverpassAPI for buildings.' buildings = osm.query_buildings() print 'Uploading OSM buildings to Postgres...' db.insert_osm(buildings, 'osm_buildings') if address_download: print 'Querying OverpassAPI for addresses.' addresses = osm.query_address()
#!/usr/bin/env python # -*- coding: utf-8 -*- import telegram from datetime import datetime import logging from telegram.ext import Updater, CommandHandler, CallbackQueryHandler from telegram import InlineKeyboardButton, InlineKeyboardMarkup from getToken import getToken from db_handler import DBHandler from getChatId import getId CHAT_ID = getId() startTime = datetime.now() db = DBHandler() def error(bot, update, error): #change the logging level between INFO - normal mode or DEBUG - verbose mode logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG) logger = logging.getLogger(__name__) logger.warning('Update "%s" caused error "%s"' % (update, error)) #checkUser checks is the user is already registered for d2-bot, #verify that only users from a certain chat have access def checkUser(bot, update):
def main(): # INIT db = DBHandler() # id name lvl curr_exp base_health base_damage curr_location inventory hero_res = start_menu(db) while hero_res == -1: hero_res = start_menu(db) # INVENTORY t = pypika.Table('inventories') q = pypika.Query.from_(t).select('*').where(t.id == hero_res[7]).get_sql() # id capacity size inv_res = db.select(q)[0] heros_inv = Inventory(inv_res[0], inv_res[1], inv_res[2], db) # LOCATIONS init_locations(db) for l in LOCATIONS: if l.id == hero_res[6]: global CUR_LOCATION CUR_LOCATION = l # PYGAME pygame.init() pygame.key.set_repeat(100, 300) clock = pygame.time.Clock() screen = pygame.display.set_mode([DISPLAY_W, DISPLAY_H], pygame.DOUBLEBUF) mapp = Map(MAP_W, MAP_H) mapp.random_fill(create_monsters_list(db)) hero = Character(hero_res[0], hero_res[1], hero_res[2], hero_res[3], hero_res[4], hero_res[5], heros_inv, round(mapp.w / 2), round(mapp.h / 2), CUR_LOCATION, make_pygame_image("assets/new_hero.png"), hero_res[-1], hero_res[-2]) set_skills_to_hero(hero, db) constants.BACKGROUND_COLOR = hero.curr_location.rgb inventory_surf = pygame.Surface((DISPLAY_W - MAP_W, DISPLAY_H / 2)) inventory_surf.fill(INVENTORY_COLOR) skills_surf = pygame.Surface((DISPLAY_W - MAP_W, DISPLAY_H / 2)) skills_surf.fill(SKILLS_COLOR) in_inventory_mode = False in_skills_mode = False in_skill_direction_choosing_mode = False target_is_found = False target = None screen.fill(constants.BACKGROUND_COLOR) for i, it in mapp: if it != 0: screen.blit(it.img, (it.x * TILE_SIZE, it.y * TILE_SIZE)) if isinstance(it, Monster): health_bar = pygame.Surface( (TILE_SIZE * (it.health / it.base_health), int(TILE_SIZE / 10))) health_bar.fill(hex_to_rgb('#00FF00')) screen.blit(health_bar, (it.x * TILE_SIZE, (it.y * TILE_SIZE))) health_bar = pygame.Surface( (TILE_SIZE * (hero.curr_health / hero.get_total_health()), int(TILE_SIZE / 10))) health_bar.fill(hex_to_rgb('#00FF00')) screen.blit(health_bar, (hero.x * TILE_SIZE, (hero.y * TILE_SIZE) - 15)) mana_bar = pygame.Surface( (TILE_SIZE * (hero.curr_mana / hero.total_mana), int(TILE_SIZE / 10))) mana_bar.fill(hex_to_rgb('#0000FF')) screen.blit(mana_bar, (hero.x * TILE_SIZE, (hero.y * TILE_SIZE) - 10)) screen.blit(hero.img, (hero.x * TILE_SIZE, hero.y * TILE_SIZE)) screen.blit(inventory_surf, (MAP_W, 0)) screen.blit(skills_surf, (MAP_W, DISPLAY_H / 2)) draw_UI(screen, hero, in_inventory_mode, in_skills_mode, in_skill_direction_choosing_mode) pygame.display.update() running = True while running and hero.curr_health > 0: clock.tick(FPS) for e in pygame.event.get(): if e.type == pygame.QUIT: running = False if e.type == pygame.KEYDOWN: global CUR_ITEM global CUR_SKILL if e.key == pygame.K_ESCAPE: running = False break if e.key == pygame.K_i: if not in_inventory_mode: in_skills_mode = False in_inventory_mode = not in_inventory_mode CUR_ITEM = 0 if e.key == pygame.K_s: if not in_skills_mode: in_inventory_mode = False in_skills_mode = not in_skills_mode CUR_SKILL = 0 if in_inventory_mode: if e.key == pygame.K_UP: if CUR_ITEM != 0: CUR_ITEM -= 1 if e.key == pygame.K_DOWN: if CUR_ITEM < hero.inventory.size - 1: CUR_ITEM += 1 if e.key == pygame.K_g: index = hero.x + hero.y * mapp.w mmmap = mapp.cells[index] if isinstance(mmmap, Item): if hero.take_item(mmmap): mapp.cells[index] = 0 if e.key == pygame.K_d: hero.drop_item(hero.inventory.items[CUR_ITEM]) elif in_skills_mode: if e.key == pygame.K_UP: if CUR_SKILL != 0: CUR_SKILL -= 1 if e.key == pygame.K_DOWN: if CUR_SKILL < len(hero.skills) - 1: CUR_SKILL += 1 if e.key == pygame.K_RETURN: skill = hero.skills[CUR_SKILL] if skill.cost > hero.curr_mana: break if skill.type == 'heal': skill.use_on_target(hero) skill_animation(hero, hero.x, hero.y, screen) hero.curr_mana -= skill.cost in_skills_mode = False if skill.type == 'dmg': in_skill_direction_choosing_mode = True in_skills_mode = False elif in_skill_direction_choosing_mode: if e.key == pygame.K_UP: ind = hero.x + hero.y * mapp.w while ind >= 0: if isinstance(mapp.cells[ind], Monster): target_is_found = True target = mapp.cells[ind] break ind -= mapp.w elif e.key == pygame.K_DOWN: ind = hero.x + hero.y * mapp.w while ind <= mapp.h * mapp.w: if isinstance(mapp.cells[ind], Monster): target_is_found = True target = mapp.cells[ind] break ind += mapp.w elif e.key == pygame.K_LEFT: ind = hero.x + hero.y * mapp.w while ind >= hero.y * mapp.w: if isinstance(mapp.cells[ind], Monster): target_is_found = True target = mapp.cells[ind] break ind -= 1 elif e.key == pygame.K_RIGHT: ind = hero.x + hero.y * mapp.w while ind <= hero.y * mapp.w + mapp.w: if isinstance(mapp.cells[ind], Monster): target_is_found = True target = mapp.cells[ind] break ind += 1 else: target_is_found = False target = None in_skill_direction_choosing_mode = False if target_is_found: hero.curr_mana -= skill.cost skill_animation(hero, target.x, target.y, screen) hero.skills[CUR_SKILL].use_on_target(target) if target.health <= 0: mapp.cells[target.x + target.y * mapp.w] = target.item target.item.x = target.x target.item.y = target.y leveling(hero, target.exp, db) target_is_found = False target = None in_skill_direction_choosing_mode = False else: if e.key == pygame.K_UP: move(hero, mapp, 0, -1, db) if e.key == pygame.K_DOWN: move(hero, mapp, 0, 1, db) if e.key == pygame.K_LEFT: move(hero, mapp, -1, 0, db) if e.key == pygame.K_RIGHT: move(hero, mapp, 1, 0, db) if hero.curr_health <= 0: break hero.regenerate() screen.fill(constants.BACKGROUND_COLOR) for i, it in mapp: if it != 0: screen.blit(it.img, (it.x * TILE_SIZE, it.y * TILE_SIZE)) if isinstance(it, Monster): health_bar = pygame.Surface( (TILE_SIZE * (it.health / it.base_health), int(TILE_SIZE / 10))) health_bar.fill(hex_to_rgb('#00FF00')) screen.blit(health_bar, (it.x * TILE_SIZE, (it.y * TILE_SIZE))) health_bar = pygame.Surface( (TILE_SIZE * (hero.curr_health / hero.get_total_health()), int(TILE_SIZE / 10))) health_bar.fill(hex_to_rgb('#00FF00')) screen.blit(health_bar, (hero.x * TILE_SIZE, (hero.y * TILE_SIZE) - 15)) mana_bar = pygame.Surface( (TILE_SIZE * (hero.curr_mana / hero.total_mana), int(TILE_SIZE / 10))) mana_bar.fill(hex_to_rgb('#0000FF')) screen.blit(mana_bar, (hero.x * TILE_SIZE, (hero.y * TILE_SIZE) - 10)) screen.blit(hero.img, (hero.x * TILE_SIZE, hero.y * TILE_SIZE)) screen.blit(inventory_surf, (MAP_W, 0)) screen.blit(skills_surf, (MAP_W, DISPLAY_H / 2)) draw_UI(screen, hero, in_inventory_mode, in_skills_mode, in_skill_direction_choosing_mode) pygame.display.update() if hero.curr_health <= 0: print('Your character is totally dead :(') print('Make another one and good luck!')
def __init__(self): super(MainWindow, self).__init__() loadUi('../ui/MainWindow.ui', self) self.myDb = DBHandler() self.updateTableFlag = True self.FilterConfigButton = self.findChild(QPushButton, 'filterButton') self.FilterConfigButton.clicked.connect(self.openFilterConfig) self.settingsConfig = self.findChild(QAction, 'actionSettings') self.settingsConfig.triggered.connect(self.openSettings) #Search button functionality ##need to add keyword search still self.searchSearchButton = self.findChild(QPushButton, 'searchSearchButton') self.searchSearchButton.clicked.connect(self.openFilterConfig) # Enter press on qlineedit search tab triggers the search button self.searchLineEdit = self.findChild(QLineEdit, 'lineEdit_2') self.searchLineEdit.returnPressed.connect( self.searchSearchButton.click) # Enter press on qlineedit graph tab triggers search button self.graphSearchEdit = self.findChild(QLineEdit, 'graphLineEdit') #Exit menu option functionality self.CloseMenuSelect = self.findChild(QAction, 'actionClose_Exit') self.CloseMenuSelect.setShortcut('Ctrl+Q') self.CloseMenuSelect.triggered.connect(qApp.quit) #Export menu option functionality self.exportConfig = self.findChild(QAction, 'actionExport') self.exportConfig.setShortcut('Ctrl+E') self.exportConfig.triggered.connect(self.openExportConfig) #VectorDBConfig linked to menu option self.versionControl = self.findChild(QAction, 'actionVersion_Control') self.versionControl.setShortcut('Ctrl+S') self.versionControl.triggered.connect(self.openVectDBConfig) self.GraphTable = self.findChild(QTableWidget, 'tableWidget') self.graphArea = self.findChild(QWidget, 'graphArea') self.graphArea.setLayout(QVBoxLayout()) self.graphSearchButton = self.findChild(QPushButton, 'graphSearchButton_2') # self.graphSearchButton.clicked.connect() self.currentVectorMenu = self.findChild(QComboBox, 'VectorMenu') self.currentVectorLabel = self.findChild(QLabel, 'CurrentVector') self.currentVectorMenu.addItems(self.myDb.get_vector_names()) self.currentVectorLabel.setText(self.currentVectorMenu.currentText()) self.currentVectorMenu.activated.connect(self.vectorSelected) self.GraphTable.cellClicked.connect(self.entryFieldSelected) self.GraphTable.cellChanged.connect(self.updateEntryFromTable) # Events def node_selected(node): if self.qgv.manipulation_mode == QGraphVizManipulationMode.Node_remove_Mode: print("Node {} removed".format(node)) self.saveGraph() # self.updateTableFromGraph() else: print("Node selected {}".format(node)) def edge_selected(edge): if self.qgv.manipulation_mode == QGraphVizManipulationMode.Edge_remove_Mode: print("Edge {} removed".format(edge)) else: print("Edge selected {}".format(edge)) def node_invoked(node): print("Node double clicked") def edge_invoked(node): print("Edge double clicked") def node_removed(node): print("Node removed") def edge_removed(node): print("Edge removed") # Create QGraphViz widget show_subgraphs = True self.qgv = QGraphViz(show_subgraphs=show_subgraphs, node_selected_callback=node_selected, edge_selected_callback=edge_selected, node_invoked_callback=node_invoked, edge_invoked_callback=edge_invoked, node_removed_callback=node_removed, edge_removed_callback=edge_removed, hilight_Nodes=True, hilight_Edges=True) self.qgv.setStyleSheet("background-color:white;") # Create A new Graph using Dot layout engine self.qgv.new(Dot(Graph("Main_Graph"), show_subgraphs=show_subgraphs)) # Adding nodes with an image as its shape icon_path = os.path.dirname(os.path.abspath(__file__)) + r"\dbicon.png" # Build the graph (the layout engine organizes where the nodes and connections are) self.qgv.build() # Save it to a file to be loaded by Graphviz if needed self.qgv.save("test.gv") # Add the QGraphViz object to the layout self.graphArea.layout().addWidget(self.qgv) # Add a horizontal layout (a pannel to select what to do) self.hpanel = QHBoxLayout() self.graphArea.layout().addLayout(self.hpanel) # Add buttons to the panel def save(): fname = QFileDialog.getSaveFileName(self.qgv, "Save", "", "*.json") if (fname[0] != ""): self.qgv.saveAsJson(fname[0]) def new(): self.qgv.engine.graph = Graph("MainGraph") self.qgv.build() self.qgv.repaint() def load(): fname = QFileDialog.getOpenFileName(self.qgv, "Open", "", "*.json") if (fname[0] != ""): self.qgv.loadAJson(fname[0]) def add_node(): dlg = QDialog() dlg.ok = False dlg.node_name = "" dlg.node_label = "" dlg.node_color = "" dlg.node_type = "None" # Layouts main_layout = QVBoxLayout() l = QFormLayout() buttons_layout = QHBoxLayout() main_layout.addLayout(l) main_layout.addLayout(buttons_layout) dlg.setLayout(main_layout) leNodeName = QLineEdit() leNodeLabel = QLineEdit() cbxNodeType = QComboBox() leImagePath = QLineEdit() leNodeColor = QLineEdit() pbOK = QPushButton() pbCancel = QPushButton() cbxNodeType.addItems(["None", "circle", "box"]) pbOK.setText("&OK") pbCancel.setText("&Cancel") l.setWidget(0, QFormLayout.LabelRole, QLabel("Node Name")) l.setWidget(0, QFormLayout.FieldRole, leNodeName) l.setWidget(1, QFormLayout.LabelRole, QLabel("Node Label")) l.setWidget(1, QFormLayout.FieldRole, leNodeLabel) l.setWidget(2, QFormLayout.LabelRole, QLabel("Node Type")) l.setWidget(2, QFormLayout.FieldRole, cbxNodeType) l.setWidget(3, QFormLayout.LabelRole, QLabel("Node Image")) l.setWidget(3, QFormLayout.FieldRole, leImagePath) l.setWidget(4, QFormLayout.LabelRole, QLabel("Node Color")) l.setWidget(4, QFormLayout.FieldRole, leNodeColor) def ok(): dlg.OK = True dlg.node_name = leNodeName.text() dlg.node_label = leNodeLabel.text() if (leImagePath.text()): dlg.node_type = leImagePath.text() else: dlg.node_type = cbxNodeType.currentText() dlg.node_color = leNodeColor.text() dlg.close() def cancel(): dlg.OK = False dlg.close() pbOK.clicked.connect(ok) pbCancel.clicked.connect(cancel) buttons_layout.addWidget(pbOK) buttons_layout.addWidget(pbCancel) dlg.exec_() # node_name, okPressed = QInputDialog.getText(wi, "Node name","Node name:", QLineEdit.Normal, "") if dlg.OK and dlg.node_name != '': self.qgv.addNode(self.qgv.engine.graph, dlg.node_name, label=dlg.node_label, shape=dlg.node_type, color=dlg.node_color) self.qgv.build() def remove_node(): self.qgv.manipulation_mode = QGraphVizManipulationMode.Node_remove_Mode for btn in self.buttons_list: btn.setChecked(False) self.btnRemoveNode.setChecked(True) def remove_edge(): self.qgv.manipulation_mode = QGraphVizManipulationMode.Edge_remove_Mode for btn in self.buttons_list: btn.setChecked(False) self.btnRemoveEdge.setChecked(True) def add_edge(): self.qgv.manipulation_mode = QGraphVizManipulationMode.Edges_Connect_Mode for btn in self.buttons_list: btn.setChecked(False) self.btnAddEdge.setChecked(True) # Add buttons self.btnNew = QPushButton("New") self.btnNew.clicked.connect(new) self.btnOpen = QPushButton("Open") self.btnOpen.clicked.connect(load) self.btnSave = QPushButton("Save") self.btnSave.clicked.connect(save) self.hpanel.addWidget(self.btnNew) self.hpanel.addWidget(self.btnOpen) self.hpanel.addWidget(self.btnSave) self.buttons_list = [] self.btnAddNode = QPushButton("Add Node") self.btnAddNode.clicked.connect(add_node) self.hpanel.addWidget(self.btnAddNode) self.buttons_list.append(self.btnAddNode) self.btnRemoveNode = QPushButton("Remove Node") self.btnRemoveNode.setCheckable(True) self.btnRemoveNode.clicked.connect(remove_node) self.hpanel.addWidget(self.btnRemoveNode) self.buttons_list.append(self.btnRemoveNode) self.btnAddEdge = QPushButton("Add Edge") self.btnAddEdge.setCheckable(True) self.btnAddEdge.clicked.connect(add_edge) self.hpanel.addWidget(self.btnAddEdge) self.buttons_list.append(self.btnAddEdge) self.btnRemoveEdge = QPushButton("Remove Edge") self.btnRemoveEdge.setCheckable(True) self.btnRemoveEdge.clicked.connect(remove_edge) self.hpanel.addWidget(self.btnRemoveEdge) self.buttons_list.append(self.btnRemoveEdge) #icon_path = os.path.dirname(os.path.abspath(__file__)) + r"\Resouces\IconDir,100,100" # n9 = qgv.addNode(qgv.engine.graph, "Node9", label="N9", shape=icon_path) #drop down menus vector collumn search table self.SearchTable = self.findChild(QTableWidget, 'tableWidget_2') self.showMaximized() # DBHandler.create_vector_entry('../Resources/LocalGraphs/VECTOR_3.json') self.updateViews()