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)
