def main(): print "[+] " + g_module.PROGRAM_NAME + " Initiated." center_frame.main() leftBottom_frame.main() database.load_database() # events.main() g_module.root.mainloop()
def main(): print "[+] "+g_module.PROGRAM_NAME+" Initiated." center_frame.main() leftBottom_frame.main() database.load_database() #events.main() g_module.root.mainloop()
def test_model(): """Test the model""" # 1. Get Testing Options cfg = TestOptions() # 2. Load train and val Dataset test_loader = load_database(cfg) # 3. Create a Model model = BaseModel(cfg) # 4, Create multi class metrics metrics = MultiClassMetrics(cfg.class_name) # 5. Outer loop for one batch test sample for per_step, (images, labels, images_names) in enumerate(test_loader): results = [] model.input(images=images, labels=labels) model.test() if cfg.opts.test_label != 'None': metrics.eval(labels, model.out.cpu(), indicators="ACC, F1, FPR", step=len(test_loader)) else: predict = model.out.cpu().argmax(1) for i in range(len(predict)): results.append([images_names[i], predict[i].item()]) wrote_csv_file(model.result_path, results, mode='a', show=False) print_test_info(cfg, [per_step, len(test_loader)], metrics.metrics)
def train_model(): """Train the model""" # 1. Get Training Options cfg = TrainOptions() # 2. Load train and val Dataset train_loader, val_loader = load_database(cfg) # 3. Create a Model model = BaseModel(cfg) # 4. Training for per_epoch in range(model.start_epoch + 1, cfg.opts.epoch + 1): val_flag = False save_metrics = {"LOSS": 0.0, "ACC": 0.0} # inner loop for one batch for per_step, (images, labels, _) in enumerate(train_loader.flow()): model.train(images=images, labels=labels) save_metrics["LOSS"] += model.loss save_metrics["ACC"] += model.metric val_flag = print_train_info( val_flag, cfg, [model.start_epoch + 1, per_epoch, cfg.opts.epoch], [per_step + 1, len(train_loader)], model.lr, model.loss, model.metric) if cfg.opts.is_val: val_model(cfg, model, val_loader, val_flag, per_epoch) if per_epoch % cfg.opts.save_list == 0: model.save_model(per_epoch, [ "train" + cfg.opts.save_metric, save_metrics[cfg.opts.save_metric] / len(train_loader) ]) model.update_lr(per_epoch + 1)
def test_model(): """Test the model""" # 1. Get Testing Options cfg = TestOptions() # 2. Load train and val Dataset test_loader = load_database(cfg) # 3. Create a Model model = BaseModel(cfg) # 4. Outer loop for one batch test sample loss = acc = 0.0 for per_step, (images, labels, images_names) in enumerate(test_loader.flow()): results = [] model.test(images=images, labels=labels, mode='test') loss += model.loss acc += model.metric if cfg.opts.test_label == 'None': predict = model.out.argmax(1) for i in range(len(predict)): results.append([images_names[i], predict[i].item()]) wrote_csv_file(model.result_path, results, mode='a', show=False) print_test_info(cfg, [per_step, len(test_loader)], loss, acc)
def run(): list_database = database.load_database("list") image, descriptors = ConvertToDescriptor.camera_to_descriptors(upscale=0) detections = ConvertToDescriptor.image_to_detections(image) fig, ax = plt.subplots() ax.imshow(image) unknown_desc = [] for face, d in zip(descriptors, detections): # Recognize the person name = Match.recognizeImage(list_database, face, 0.10) if name is 'Unknown': name = f'Unknown {len(unknown_desc) + 1}' unknown_desc.append(face) # Print a rectangle around their face rect = Rectangle((d.left(), d.bottom()), d.right() - d.left(), d.top() - d.bottom(), linewidth=1, edgecolor='r', facecolor='none') ax.add_patch(rect) # Print their name (or 'Unknown') plt.text(d.left(), d.bottom(), f"{name}", color='#42f545') plt.show() for idx, desc in enumerate(unknown_desc): text = input(f"We don't know Unknown {idx + 1}, what is their name? ") name = text data = database.load_database("dict") if name in data: data[name].add_descriptor(desc, data) else: database.add_person(person.Person(name, (desc, )), data)
def run(self): if self.init: database.init_database(self.sound_lib_dir, self.sound_lib_database, progress=self.update.emit, message=self.message_func) if self.message_func: self.message_func("Loading Database...") self.database = database.load_database(self.sound_lib_database, progress=self.update.emit) time.sleep(1) if self.close_prog_func: self.close_prog_func() if self.close_log_func: self.close_log_func()
def run(): response = menu() if response == 0: events = database.load_csv_data() database.create_database() database.load_database(events) elif response == 1: database.display_presenters() elif response == 2: database.display_events() elif response == 3: print("Please enter event id") event_id = int(input()) database.display_presenters_for_event(event_id) elif response == 4: print("Please enter presenter id") presenter_id = int(input()) database.display_events_for_presenter(presenter_id) else: print("Invalid selection")
def products_details(product_id): final_product = None data = database.load_database() for product in data: if product['ProductId'] == product_id: final_product = product # print (final_product['ProductId']) template_file = open('templates/products_details.html', 'r').read() return render_template_string(template_file, product=final_product)
def main(): """CLI Main Function and Argument Handler""" start_time = time.time() parser = create_parser() args = parser.parse_args() if not validate_path(args.path): print("[-] Error: Path \"" + args.path + "\" does not exist") sys.exit(1) filename = db.load_database(args.nsrl_db) print("\n[+] -- Hashing Files --\n") scan_list = misc.generate_file_list(args.path) hashes = [] for item in tqdm(scan_list): hashes.append(hashylib.HashedPath(item)) print("\n[+] -- Scanning Database --\n") unmatched_list = sorted(hashylib.scan_database(hashes, filename), key=lambda x: x.get_path()) print("[+] Files Not in Database: \n") for item in unmatched_list: print(item.get_path()) run_time = time.time() - start_time no_access= len(filter(lambda x: x.get_hash() == None, hashes)) actually_scanned = len(scan_list) - no_access verified = actually_scanned - len(unmatched_list) print("\n[+] -- Statistics --\n") print("Execution Time: " + "{0:.1f}".format(run_time) + " seconds") print("Targeted Files: " + str(len(scan_list)) + "\n") print("Scanned Files: " + str(actually_scanned)) print("Inaccessable Files: " + str(no_access) + "\n") print("Verified Files: " + str(verified)) print("Unverified Files: " + str(len(unmatched_list)))
def products_page(): data = database.load_database() return render_template('products.html', products=data)
bind_to = '127.0.0.1' logger.info("Could not read bind address. Using default {}".format(bind_to)) try: bind_port = int(config['UI_SETTINGS']['bind_port']) except KeyError: bind_port = 5001 logger.info("Could not read bind port. Using default {}".format(bind_port)) try: sub_directory = config['UI_SETTINGS']['sub_directory'] except KeyError: sub_directory = "" # Load database, needs to be done before accessing db_get function #config = config_management.load_config('traceroute_history.conf') db_load_result = load_database(config) # Prepare FastAPI app = FastAPI() templates_path = os.path.join(config['TRACEROUTE_HISTORY']['install_dir'], 'www', 'templates') assets_path = os.path.join(config['TRACEROUTE_HISTORY']['install_dir'], 'www', 'assets') templates = Jinja2Templates(directory=templates_path) app.mount('/assets', StaticFiles(directory=assets_path), name='assets') def get_system_data(): try: cpu = psutil.cpu_percent() except NameError:
import selectors import json # Importing from parent directory sys.path.append('..') import database as db import hashing_algorithms as ha HOST = '127.0.0.1' PORT = 60001 sel = selectors.DefaultSelector() print('Starting AS server at ' + HOST + ' port ' + str(PORT)) AS_db = db.load_database('AS_db') # Adds a new client via CLI params (add [name] [password]) try: if sys.argv[1] == 'add': name = str(sys.argv[2]) password = ha.hash(str(sys.argv[3])).decode('utf-8') print('Adding client - name: ' + name + ' password: '******'***' + password[len(password) - 4:]) db.insert(AS_db, name, password) db.save_database('AS_db', AS_db) except IndexError: print('No new clients added.') def accept(sock, mask):
class ExistingComment: """Info about an existing comment with class info.""" def __init__(self, comment_id_, mentions_): self.comment_id = comment_id_ self.mentions_list = mentions_ def __str__(self): return "\"{}\"->\"{}\"".format(self.comment_id, self.mentions_list) print(_get_mentions_in_string('HAVC40')) exit() # print('Started {}.'.format(datetime.now())) posts_with_comments = load_posts_with_comments() db = database.load_database() reddit = auth_reddit() print('id{_}author{_}title{_}action{_}current mentions{_}previous mentions'.format(_ = '\t')) # post_comment(reddit.get_submission(submission_id = '3yw5sz')) # on /r/bottesting subreddit = reddit.get_subreddit('ucsc') for submission in subreddit.get_new(): # print(submission) post_comment(submission) save_posts_with_comments()
class ExistingComment: """Info about an existing comment with class info.""" def __init__(self, comment_id_, mentions_): self.comment_id = comment_id_ self.mentions_list = mentions_ def __str__(self): return '"{}"->"{}"'.format(self.comment_id, self.mentions_list) print(_get_mentions_in_string("HAVC40")) exit() # print('Started {}.'.format(datetime.now())) posts_with_comments = load_posts_with_comments() db = database.load_database() reddit = auth_reddit() print("id{_}author{_}title{_}action{_}current mentions{_}previous mentions".format(_="\t")) # post_comment(reddit.get_submission(submission_id = '3yw5sz')) # on /r/bottesting subreddit = reddit.get_subreddit("ucsc") for submission in subreddit.get_new(): # print(submission) post_comment(submission) save_posts_with_comments()
import json from datetime import datetime, timedelta # Importing from parent directory sys.path.append('..') import database as db import hashing_algorithms as ha HOST = '127.0.0.1' PORT = 60002 sel = selectors.DefaultSelector() print('Starting TGS server at ' + HOST + ' port ' + str(PORT)) TGS_db = db.load_database('TGS_db') # Adds a new service via CLI params (add [service_name] [key]) try: if sys.argv[1] == 'add': service_name = str(sys.argv[2]) key = ha.hash(str(sys.argv[3])).decode('utf-8') print('Adding service - name: ' + service_name + ' key: ' + key[:4] + '***' + key[len(key) - 4:]) db.insert(TGS_db, service_name, key) db.save_database('TGS_db', TGS_db) except IndexError: print('No new service added.') def accept(sock, mask):
#!/usr/bin/env python3 import sys import json from datetime import datetime # Importing from parent directory sys.path.append('..') import database as db import hashing_algorithms as ha try: K_s = ha.hash('service_master_password').decode('utf-8') ticket = db.load_database('service_ticket') T_c_s = ticket['T_c_s'] message = ticket['message'] decrypted_T_c_s = ha.aes_decrypt(T_c_s['encrypted_message'], K_s, T_c_s['nonce'], T_c_s['tag']) decrypted_T_c_s = json.loads(decrypted_T_c_s) decrypted_message = ha.aes_decrypt(message['encrypted_message'], decrypted_T_c_s['K_c_s'], message['nonce'], message['tag']) decrypted_message = json.loads(decrypted_message) T_c_s_ID_C = decrypted_T_c_s['ID_C'] message_ID_C = decrypted_message['ID_C'] T_a = decrypted_T_c_s['T_A'] T_a = datetime.strptime(T_a, '%Y-%m-%d %H:%M:%S.%f') except:
def main(argv): global CONFIG_FILE global logger try: opts, _ = getopt.getopt(argv, "h?", [ 'config=', 'get-traceroutes-for=', 'list-targets', 'remove-target=', 'daemon', 'update-now', 'init-db', 'help' ]) except getopt.GetoptError: help_() sys.exit(9) config_file_set = False for opt, arg in opts: if opt == '--config': CONFIG_FILE = arg config_file_set = True # Reload config before executing anything elsee config = config_management.load_config(CONFIG_FILE) try: log_file = config['TRACEROUTE_HISTORY']['log_file'] logger = ofunctions.logger_get_logger(log_file=log_file) except KeyError: pass if not config_file_set: logger.info('No config file set. trying default one: {0}.'.format( os.path.abspath(CONFIG_FILE))) if os.name != 'nt': if os.getuid() != 0: logger.warn( 'This program should probably be run as root so traceroute can work.' ) initialize = False for opt, arg in opts: if opt == '--init-db': initialize = True load_database(config, initialize=initialize) opt_found = False for opt, arg in opts: if opt == '--get-traceroutes-for': try: target, limit = arg.split(',') limit = int(limit) except (ValueError, TypeError): target = arg limit = None print(get_last_traceroutes_formatted(target, limit)) sys.exit(0) if opt == '--list-targets': print( 'List of current targets in database (not necessary in the config file:' ) print( json.dumps(list_targets(), indent=2, sort_keys=True, default=str)) sys.exit(0) if opt == '--remove-target': res = remove_target(arg) sys.exit(res) if opt == '--daemon': opt_found = True execute(daemon=True) if opt == '--update-now': opt_found = True execute() if opt == '--help' or opt == 'h' or opt == '?': opt_found = True help_() if not opt_found: help_()
parser = argparse.ArgumentParser() parser.add_argument("--subreddit", help="which subreddit to use", default="colorize_bw_photos") parser.add_argument('--usednn', dest="useDNN", action='store_true') parser.add_argument('--no-dnn', dest="useDNN", action='store_false') parser.add_argument('--replicate', dest="replicate", action='store_true') parser.set_defaults(useDNN=True,replicate=False) args = parser.parse_args() upload_queue = [] upload_timer = time.time() upload_timeout = 60*10 #every 10 minutes to send what wasn't sent database.load_database() MAX_IMAGE_WIDTH = 1920 MAX_IMAGE_HEIGHT = 1080 print args useDNN = args.useDNN subreddit = args.subreddit if useDNN: import colorize colorize.loadDNN(False) def check_condition(c): text = c.body tokens = text.lower().split() if len(tokens) == 1 and (("colorizebot" in tokens) or ('colourizebot' in tokens)):
def product_details(product_id): products = database.load_database() return render_template("product_details.html", product=products[product_id])
import sys from datetime import datetime import hashing_algorithms as ha import database as db DATABASE = 'server_data.json' args = sys.argv[1:] if len(args) < 1 or len(args) > 2: print('Para cadastrar novo usuario: [user] [senha semente]') print('Para validar tokens: [user]') sys.exit() print('Abrindo base...') database = db.load_database(DATABASE) print('Base aberta com sucesso.') if len(args) == 2: username = args[0] seed_password = args[1] if username not in database: print('Cadastrando novo usuario...') salt = ha.salt_generator() hashed_seed = ha.hash_password(seed_password) content = { 'senha_semente': ha.hash_password(hashed_seed + salt), 'salt': salt } db.insert(database, username, content) print('Usuario cadastrado com sucesso.')
def product_page(): products = database.load_database() return render_template("product_page.html", products=products)