def main():
if len(sys.argv) > 1:
args = load_config(sys.argv[1])
if args == None:
exit(1)
out_dir_path = Path(args['COVERAGE']['OUT_DIR'])
if not out_dir_path.exists():
print('Out dir doesnt exist. Creating new!')
out_dir_path.mkdir(parents=True, exist_ok=True)
tasks = queue.Queue()
for worker_id in range(args['COVERAGE']['WORKERS']):
worker = threading.Thread(target=run_drrun,
args=(tasks, worker_id, args))
worker.setDaemon(True)
worker.start()
for f_path in Path(args['COVERAGE']['INP_DIR']).iterdir():
tasks.put({'input': f_path.as_posix()})
tasks.join()
else:
print(f'Usage: {sys.argv[0]} <config_file>')
def main():
# TODO: find a cleaner way of shutting down
signal.signal(signal.SIGINT, signal.SIG_DFL)
config = load_config()
debounce_sec = config['debounce']
display_name = config['display_name']
script_working_dir = config['_script_working_dir']
dbus_interface_name = config['_dbus']['interface_name']
dbus_path = config['_dbus']['path']
dbus_signal_name = config['_dbus']['signal_name']
connect_scripts = config['on_connect']
disconnect_scripts = config['on_disconnect']
app = QCoreApplication(sys.argv)
loop = DBusQtMainLoop(set_as_default=True)
bus = dbus.SessionBus()
signal_runner = SignalRunner(debounce_sec,
display_name,
cwd=script_working_dir)
for script in connect_scripts:
signal_runner.add_connect_script(script)
for script in disconnect_scripts:
signal_runner.add_disconnect_script(script)
bus.add_signal_receiver(handler_function=signal_runner.run,
dbus_interface=dbus_interface_name,
path=dbus_path,
signal_name=dbus_signal_name)
sys.exit(app.exec_())
def __init__(self, img_path=None, silent=False):
self.config = load_config()
if (img_path != None):
self.img = cv2.imread(img_path)
else:
self.img = cv2.imread(self.config['img_filename'])
self.silent = silent
bgr_props = self.config['bgr_properties']
bgr_mean = (bgr_props['b_mean'], bgr_props['g_mean'],
bgr_props['r_mean'])
bgr_stdev = (bgr_props['b_stdev'], bgr_props['g_stdev'],
bgr_props['r_stdev'])
self.seg_img = self._segment_bgr(
self.img,
self._calc_lowerb(bgr_mean, bgr_stdev,
bgr_props['lowerb_stdev_scalar']),
self._calc_upperb(bgr_mean, bgr_stdev,
bgr_props['upperb_stdev_scalar']))
self.filtered_img = cv2.medianBlur(self.seg_img,
self.config['filter_ksize'])
self.contours = self._get_contours(self.filtered_img)
def main(argv):
inputfile = ''
outputdir = ''
arch = ''
lib = ''
try:
opts, args = getopt.getopt(argv, "i:o:a:l:",
["file=", "output_dir=", "arch=", "lib="])
except:
getopt.GetoptError
print("generator.py -i <inputfile> -o <outputdir> -a <arch> -l <lib>")
sys.exit(2)
for opt, arg in opts:
if opt == "-h":
print("generator.py -i <inputfile>")
sys.exit()
elif opt in ("-i", "--file"):
inputfile = arg
elif opt in ("-o", "--output_dir"):
outputdir = arg
elif opt in ("-a", "--arch"):
arch = arg
elif opt in ("-l", "--lib"):
lib = arg
print("Generate code from: ", inputfile)
print("Files will be written to: ", outputdir)
generator = select_generator(arch, lib)
config = load_config(inputfile)
generator.set_config(config)
generator.set_output_dir(os.path.abspath(outputdir))
generator.generate()
def main():
config = config_loader.load_config()
fifoname = config['clonner_fifo']
if not os.path.exists(fifoname):
os.mkfifo(fifoname)
while True:
pipein = open(fifoname, 'r')
instr = pipein.readline()[:-1]
pipein.close()
print("Instruction readed: ", instr)
if (instr == 'clone'):
clone(config_loader.load_config())
else:
pid = os.fork()
if (pid == 0):
os.system(instr)
return
def __init__(self, orthomosaic_path=None, silent=False):
self.silent = silent
self.config = load_config()
if (orthomosaic_path == None):
self.orthomosaic_path = self.config['orthomosaic_filename']
else:
self.orthomosaic_path = orthomosaic_path
class LogConfig:
"""Logging related configuration
Attributes:
log_level (str): python logging level
log_location (str): log file output location
"""
_lcfg: Dict[Any, Any] = load_config('logging')
log_level: str = _lcfg['log_level']
log_location: str = _lcfg['log_location']
def main():
if len(sys.argv) > 1:
args = load_config(sys.argv[1])
if args == None:
exit(1)
run_dbg(args)
else:
print(f'Usage: {sys.argv[0]} <config_file>')
def swtich_windows():
"""
Switch all the windows
"""
config = config_loader.load_config("config.json")
original_window = xdotool.get_window_active()
windows = xdotool.search_window_class(config['browser'])
for window in windows:
window_name = xdotool.get_window_name(window)
xdotool.activate_window(window)
swtich_tabs(window, max_tab=30)
xdotool.activate_window(original_window)
def detect_wrong_format(input_file, pattern):
"""Delete entries in ldap older than limit_days_ago before today
:param input_file: Ldap dumb file to parse
:param pattern: Pattern to be detected, it must be defined in config.yml!
"""
cfg = load_config()
try:
cfg[pattern]
except KeyError:
LOGGER.error("Pattern not found in the config.yml file!")
sys.exit(1)
else:
detect_ldap_problems.detect_wrong_format(cfg[pattern], input_file)
def get_logger():
logger = logging.getLogger('Basic model (coordinates) train')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
config = load_config()
file_handler = logging.FileHandler(config["PATH_TO_DEBUG_LOG"])
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
class DBConfig:
"""Database related configuration
Attributes:
mongo_server (str): server host
mongo_database (str): mongo database name
mongo_collection (str): mongo collection name
"""
_lcfg: Dict[Any, Any] = load_config('mongo_db')
mongo_server: str = _lcfg['mongo_server']
mongo_database: str = _lcfg['mongo_database']
mongo_collection: str = _lcfg['mongo_collection']
def main():
"""Entry point of the program"""
config, input_spec, coords, dm = config_loader.load_config()
# Create the data.
data = create_data(input_spec)
addresses = data['addresses']
API_key = data['API_key']
distance_matrix = create_distance_matrix(data)
print(distance_matrix)
with open(config["matrix_file"], "w") as f:
for row in distance_matrix:
f.write(",".join([str(e) for e in row]) + "\n")
def main():
"""Entry point of the program"""
input_file = None
config = None
config, input_data, coords, dm = config_loader.load_config()
# Create the data.
data = create_data(input_data)
coords_vect = create_distance_matrix(data)
# coords_vect = [[44.4352806, 26.0490164], [44.448984, 26.0561547], [44.4421364, 26.0666876], [44.4386435, 26.0458386], [44.4430103, 26.05114], [44.4447228, 26.0548487], [44.4482361, 26.0429976], [44.4492548, 26.0530481], [44.4384469, 26.038602], [44.4430707, 26.0627016], [44.4468016, 26.0660459], [44.4404178, 26.0629714], [44.4335841, 26.0560158]]
print(coords_vect)
with open(config["coords_file"], "w") as f:
for row in coords_vect:
f.write(",".join([str(e) for e in row]) + "\n")
def main():
config = config_loader.load_config()
if not os.path.exists(config['menu_fifo']):
os.mkfifo(config['menu_fifo'])
pipeout = os.open(config['menu_fifo'], os.O_WRONLY)
instr = ""
while instr != "n":
instr = input(
"Select action:\n1 - block\n2 - run\n3 - kill\n4 - emulate\n")
os.write(pipeout, bytearray(instr + '\n', 'utf-8'))
if (instr == '2' or instr == '3'):
name = input("Enter process name\n")
os.write(pipeout, bytearray(name + '\n', 'utf-8'))
instr = input("Add instruction(Y/n)\n")
os.write(pipeout, b'stop\n')
return 0
def main():
if len(sys.argv) > 1:
args = load_config(sys.argv[1])
if args == None:
exit(1)
crashes_dir = pathlib.Path(args['CRASH_ANALYZER']['INP_DIR'])
reports_dir = pathlib.Path(args['CRASH_ANALYZER']['REPORTS_DIR'])
if not crashes_dir.exists():
print(
'Crashes directory doesnt exist! Check if file path is correct!'
)
exit(1)
if not reports_dir.exists():
print('Out directory doesnt exist! Creating new one.')
reports_dir.mkdir(parents=True, exist_ok=True)
tasks = queue.Queue()
for worker_id in range(args['CRASH_ANALYZER']['WORKERS']):
worker = threading.Thread(target=run_bugid,
args=(tasks, worker_id, args))
worker.setDaemon(True)
worker.start()
crash_samples = list(crashes_dir.iterdir())
current = 0
total = len(crash_samples)
for crash_path in crash_samples:
tasks.put({
'crash_path': crash_path.absolute().as_posix(),
'reports_dir': reports_dir.absolute().as_posix(),
'current': current,
'total': total,
'delete': args['CRASH_ANALYZER']['DELETE_NON_CRASHING']
})
current += 1
tasks.join()
else:
print(f'Usage: {sys.argv[0]} <config_file>')
def create_data_model():
global config, input_data
"""Stores the data for the problem."""
data = {}
config, input_data, coords, dm = config_loader.load_config()
depots = input_data["depots"]
issues = input_data["issues"]
vehicles = input_data["vehicles"]
data['distance_matrix'] = dm
data['demands'] = [
int(d) * input_data["options"]["demand_factor"]
for d in input_data["demands"]
]
data['num_vehicles'] = len(vehicles)
data['vehicle_capacities'] = [int(v["capacity"]) for v in vehicles]
data['vehicle_fuel'] = [int(v["fuel"]) for v in vehicles]
sum_demands = sum(data['demands'])
sum_capacities = sum(data['vehicle_capacities'])
# ratio = sum_demands / sum_capacities
# if ratio > 1:
# data["vehicle_capacities"] = [int(d*ratio) for d in data["vehicle_capacities"]]
data['depot'] = 0
# So far, we have assumed that all vehicles start and end at a single location, the depot.
# You can also set possibly different start and end locations for each vehicle in the problem.
# To do so, pass two vectors, containing the indices of the start and end locations,
# as inputs to the RoutingModel method in the main function.
# Here's how to create the start and end vectors in the data section of the program:
data['starts'] = [i for i in range(len(depots))]
data['ends'] = [i for i in range(len(depots))]
print(data)
print("sum demands: " + str(sum_demands))
print("sum capacities: " + str(sum_capacities))
# quit()
return data
def simplemodel_train(logger, use_backup=False, debug=False):
config = load_config()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
if not torch.cuda.is_available():
logger.error("Cuda is unavailable")
seq, angles = data_utils.get_embedded_data_angles(config)
train_data, test_data = data_utils.get_dataset_angles(seq, angles)
train_dataloader, val_dataloader = data_utils.get_dataloaders(
train_data, test_data, BATCH_SIZE)
model = SimpleRNN(MODEL_INPUT_SIZE, MODEL_OUTPUT_SIZE, MODEL_HIDDEN_DIM,
N_LAYERS)
start_epoch, model = train_utils.try_load_model_backup(
model, MODEL_NAME, use_backup, logger, config)
model.to(device)
train_utils.initialize_wandb(model, config, N_LAYERS, BATCH_SIZE,
'simple-model-angles', MODEL_HIDDEN_DIM)
loss = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
train_utils.train_model(
train_dataloader,
val_dataloader,
model,
MODEL_NAME,
loss,
optimizer,
NUM_EPOCHS,
logger,
device,
config,
metrics_logger=train_utils.angles_metrics_logger,
start_epoch=start_epoch,
model_backup_path=config["PATH_TO_SIMPLEMODEL_BACKUP"],
num_epoch_before_backup=config["NUM_EPOCH_BEFORE_BACKUP"],
debug=debug)
train_utils.write_training_epoch(config, 0, MODEL_NAME, logger)
torch.save(model.state_dict(), os.path.join(wandb.run.dir, 'model.pt'))
def simplemodel_coord_train(logger, args, use_backup=False, debug=False):
params = parse_parameters(args)
save_prefix = args['save_prefix']
config = load_config()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
if not torch.cuda.is_available():
logger.error("Cuda is unavailable")
seq, coord = data_utils.get_embedded_data_coordinates(config)
train_data, test_data = data_utils.get_dataset_coordinates(seq, coord, config)
train_dataloader, val_dataloader = data_utils.get_dataloaders(train_data, test_data, params['batch_size'])
model = SimpleCharRNN(params['input_size'], params['output_size'], params['hidden_dim'], params['n_layers'], device)
start_epoch, model = train_utils.try_load_model_backup(model, MODEL_NAME, use_backup, logger, config)
model.to(device)
if not debug:
train_utils.initialize_wandb(model, config, params['n_layers'], params['batch_size'],
'simple-model-coordinates', params['hidden_dim'])
loss = ComplexLoss(on_cpu=debug)
optimizer = torch.optim.Adam(model.parameters(), lr=params['learning_rate'])
scheduler = None
# scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.5)
# scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.0001, max_lr=0.002, step_size_up=100,
# cycle_momentum=False)
train_utils.train_model(train_dataloader, val_dataloader, model, MODEL_NAME, loss, optimizer, params['epochs'],
logger,
device,
config,
train_utils.coordinates_metrics_logger,
scheduler=scheduler,
start_epoch=start_epoch, model_backup_path=config["PATH_TO_SIMPLEMODEL_COORD_BACKUP"],
num_epoch_before_backup=config["NUM_EPOCH_BEFORE_BACKUP"],
debug=debug)
train_utils.write_training_epoch(config, 0, MODEL_NAME, logger)
if save_prefix is not None:
model_path = '../results/' + save_prefix + '.sav'
torch.save(model.cpu(), model_path)
def main():
global user_stats
global ip_stats
if len(sys.argv) < 2:
config_path = "./config.py"
elif len(sys.argv) == 2:
config_path = sys.argv[1]
else:
print("Usage: mtprotoproxy [path/to/config.py]")
if not load_config(globals(), config_path):
return
try:
setup_uvloop()
except:
pass
try:
setup_fd_limit()
except Exception as exc:
print_err("Failed to increase file limit:", exc)
try:
setup_debug()
except:
pass
init_ip_info()
print_tg_info()
user_stats = {}
ip_stats = {}
if sys.platform == "win32":
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
loop = asyncio.get_event_loop()
loop.set_exception_handler(loop_exception_handler)
loop.run_until_complete(INIT_HOOK(HookAPI(USERS, user_stats, ip_stats)))
stats_printer_task = asyncio.Task(stats_printer())
asyncio.ensure_future(stats_printer_task)
if USE_MIDDLE_PROXY:
middle_proxy_updater_task = asyncio.Task(update_middle_proxy_info())
asyncio.ensure_future(middle_proxy_updater_task)
reuse_port = hasattr(socket, "SO_REUSEPORT")
task_v4 = asyncio.start_server(handle_client_wrapper,
'0.0.0.0',
PORT,
limit=TO_TG_BUFSIZE,
reuse_port=reuse_port,
loop=loop)
server_v4 = loop.run_until_complete(task_v4)
if socket.has_ipv6:
task_v6 = asyncio.start_server(handle_client_wrapper,
'::',
PORT,
limit=TO_TG_BUFSIZE,
reuse_port=reuse_port,
loop=loop)
server_v6 = loop.run_until_complete(task_v6)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
stats_printer_task.cancel()
server_v4.close()
loop.run_until_complete(server_v4.wait_closed())
if socket.has_ipv6:
server_v6.close()
loop.run_until_complete(server_v6.wait_closed())
loop.close()
def main():
if len(sys.argv) > 1:
args = load_config(sys.argv[1])
if args == None:
exit(1)
sync_path = pathlib.Path(args['COLLECT']['FUZZER_SYNC_DIR'])
out_dir_path = pathlib.Path(args['COLLECT']['OUT_DIR'])
crashes_dir = out_dir_path / 'crashes'
hangs_dir = out_dir_path / 'hangs'
if not crashes_dir.exists() or not hangs_dir.exists():
print('Out directory doesnt exist! Creating new one.')
crashes_dir.mkdir(parents=True, exist_ok=True)
hangs_dir.mkdir(parents=True, exist_ok=True)
crashes = 0
hangs = 0
per_fuzzer_stats = {} # {'fuzzer0':(crashes, hangs)}
for fuzzer_path in sync_path.iterdir():
if fuzzer_path.is_dir():
for fuzzer_data in fuzzer_path.iterdir():
if 'crashes' in fuzzer_data.name and fuzzer_data.is_dir():
for crash_path in fuzzer_data.iterdir():
if not 'README' in crash_path.name:
copy_from = crash_path.as_posix()
copy_to = (crashes_dir).as_posix() + '/' + crash_path.name + '_' + str(crashes)
if args['COLLECT']['VERBOSITY']:
print('Crash path: ' + copy_from)
print('Copy to path: ' + copy_to)
if not args['COLLECT']['JUST_GET_STATS']:
shutil.copy(copy_from, copy_to)
crashes += 1
if not fuzzer_path.name in per_fuzzer_stats.keys():
per_fuzzer_stats[fuzzer_path.name] = [0, 0]
else:
per_fuzzer_stats[fuzzer_path.name][0] += 1
if 'hangs' in fuzzer_data.name and fuzzer_data.is_dir():
for hangs_path in fuzzer_data.iterdir():
if not 'README' in hangs_path.name:
copy_from = hangs_path.as_posix()
copy_to = (hangs_dir).as_posix() + '/' + hangs_path.name + '_' + str(hangs)
if args['COLLECT']['VERBOSITY']:
print('Crash path: ' + copy_from)
print('Copy to path: ' + copy_to)
if not args['COLLECT']['JUST_GET_STATS']:
shutil.copy(copy_from, copy_to)
hangs += 1
if not fuzzer_path.name in per_fuzzer_stats.keys():
per_fuzzer_stats[fuzzer_path.name] = [0, 0]
else:
per_fuzzer_stats[fuzzer_path.name][1] += 1
print(f'Total collected:')
print(f'\tCrashes: {crashes}')
print(f'\tHangs: {hangs}')
print(f'Per-fuzzer stats:')
for k, v in per_fuzzer_stats.items():
print(f'\tFuzzer: {k}. Crashes: {v[0]}. Hangs: {v[1]}.')
else:
print(f'Usage: {sys.argv[0]} <config_file>')
def main():
# Instantiate the data problem.
config, input_data, coords, dm = config_loader.load_config()
depots = input_data["depots"]
places = input_data["places"]
vehicles = input_data["vehicles"]
n_vehicles = len(vehicles)
options = input_data["options"]
# just for initial check
demands = [
int(d) * options["demand_factor"] for d in input_data["demands"]
]
vehicle_capacities = [int(v["capacity"]) for v in vehicles]
vehicle_fuel = [int(v["fuel"]) for v in vehicles]
items = options["items"]
if options["fixed_vehicles"]:
n_vehicles = options["n_vehicles"]
vehicles = [{"id": i + 1} for i in range(n_vehicles)]
print(items)
if options["sort_order_msb"]:
items.sort(key=lambda x: x["weight"], reverse=True)
print(items)
sum_demands = sum(demands)
sum_capacities = sum(vehicle_capacities)
depot = 0
# So far, we have assumed that all vehicles start and end at a single location, the depot.
# You can also set possibly different start and end locations for each vehicle in the problem.
# To do so, pass two vectors, containing the indices of the start and end locations,
# as inputs to the RoutingModel method in the main function.
# Here's how to create the start and end vectors in the data section of the program:
start_points = [i for i in range(len(depots))]
end_points = [i for i in range(len(depots))]
print("sum demands: " + str(sum_demands))
print("sum capacities: " + str(sum_capacities))
# compute_geometry.load_config()
n_iter = options["n_iter"]
n_epochs = options["n_epochs"]
if use_external_input:
df = pd.read_csv('coords_nearby_filtered.csv')
place_ids = []
coords = []
place_ids = df["google_id"]
coords_lat = [lat for lat in df["lat"]]
coords_lng = [lng for lng in df["lng"]]
for i in range(len(coords_lat)):
coords.append([coords_lat[i], coords_lng[i]])
place_ids = ["place_id:" + pid for pid in place_ids]
print(place_ids[0])
print(coords[0])
places = place_ids[n_vehicles:]
if options["fixed_demands"]:
# only use demand factor
input_data["demands"] = [1 for p in place_ids]
place_coords = coords[n_vehicles:]
compute_geometry.set_coords(coords)
# quit()
if options["use_range"]:
# use demand factor range
demand_factor_range = options["demand_factor_range"]
demand_factor_range = range(demand_factor_range[0],
demand_factor_range[1] + 1)
print("using demand factor range: ", list(demand_factor_range))
else:
# use specified demand factor
demand_factor_range = [options["demand_factor"]]
print("using default demand factor: ", list(demand_factor_range))
geometry.init_random(False)
epoch_results_vect = []
for epoch in range(n_epochs):
for i_df, df in enumerate(demand_factor_range):
demands = [int(d) * df for d in input_data["demands"]]
demands = demands[n_vehicles:]
fill_dict = {}
for i, place in enumerate(places):
fill_dict[place] = {
"place": place,
"coords": place_coords[i],
"items": [],
"item_coords": [],
"found": False,
"filled": False,
"finder": None,
"find_index": -1,
"total_revisits": 0,
"demand": demands[i]
}
print(len([k for k in fill_dict]))
find_index = 0
compute_geometry.init_random_walk(vehicles, None)
for i in range(n_iter):
if i == 0 and use_initial_depots:
distance_matrix = compute_geometry.compute_distance_matrix_wrapper(
)
else:
distance_matrix = compute_geometry.get_distance_matrix_with_random_walk(
)
print("epoch: " + str(epoch) + ", iteration: " + str(i) +
" with demand factor: " + str(df) + " [" + str(
int((i_df * n_iter + i) /
(len(demand_factor_range) * n_iter) * 100)) +
"%]")
# each agent covers a given range (treasure scan)
for i_vehicle, v in enumerate(vehicles):
if disp_view:
print("vehicle: ", i_vehicle)
# check nearby places within range
found_places = []
for j, d in enumerate(distance_matrix[i_vehicle]):
if j >= n_vehicles:
# print(j,d)
if d <= options["scan_radius"]:
if disp_view:
print("found: ", d)
place = places[j - n_vehicles]
dict_place = fill_dict[place]
# check if place was already found by another agent
if not dict_place["found"]:
dict_place["found"] = True
dict_place["finder"] = vehicles[i_vehicle][
"id"]
dict_place["find_index"] = find_index
found_places.append(dict_place)
find_index += 1
else:
dict_place["total_revisits"] += 1
if disp_view:
print("already found: ", d)
# assign random items for each agent and found places
n_slots = 0
for fps in found_places:
# check filled items, get number of free slots
if not fps["filled"]:
n_slots += fps["demand"]
if disp_view:
print("n_slots: ", n_slots)
# generate free slots
slots = [None] * n_slots
n_items = []
# compute number of slots for each item type
for item in items:
n_items.append(int(n_slots * item["weight"]))
# assign items for free slots
slots_index = 0
for k, n_item in enumerate(n_items):
for n in range(n_item):
slots[slots_index] = items[k]["item"]
slots_index += 1
if disp_view:
print("n_items: ", n_items)
print("filled: ", slots_index)
# check unfilled slots, fill with last item type
n_unfilled = n_slots - slots_index
if slots_index < n_slots:
for n in range(n_unfilled):
slots[slots_index + n] = items[len(items) -
1]["item"]
# shuffle items/slots
slots = shuffle.fisher_yates_shuffle_improved(slots)
if disp_view:
print(len(slots))
slots_index = 0
# assign items to actual places
for fps in found_places:
for d in range(fps["demand"]):
if not fps["filled"]:
fps["items"].append(slots[slots_index])
fps["item_coords"].append(
geometry.get_random_point_in_radius(
fps["coords"],
options["item_coords"]["min_radius"],
options["item_coords"]["max_radius"]))
slots_index += 1
else:
if disp_view:
print("already filled")
if check_results(items, places, demands, fill_dict, i, epoch,
False, True)[0]:
break
_, epoch_results, map_geometry = check_results(
items, places, demands, fill_dict, i, epoch, True, False)
epoch_results_vect.append(epoch_results)
fig = compute_geometry.plot_random_walk_record()
output_str = "epoch,places,demand,T,C,S,A,revisits,iterations\n"
for epoch_results in epoch_results_vect:
output_str += epoch_results + "\n"
print(output_str)
with open("./data/dms_results.csv", "w") as f:
f.write(output_str)
map_geometry_str = json.dumps(map_geometry, indent=2)
with open("./data/dms_map.json", "w") as f:
f.write(map_geometry_str)
fig.savefig("./data/random_walk.png", dpi=300)
from config_loader import load_config
def projects_from_file(fname):
with open(fname) as f:
doc = yaml.load(f)
commercial = doc['Projects']['Commercial']
for project in commercial.keys():
yield ('commercial', project, commercial[project])
private = doc['Projects']['Private']
for project in private.keys():
yield ('private', project, private[project])
if __name__ == '__main__':
fname = "life_tasks.yml"
elastic_hosts = load_config('elastic-config.yml')
es = Elasticsearch(hosts=elastic_hosts, verify_certs=False)
for project_tuple in projects_from_file(fname):
commercial_or_private = project_tuple[0]
project_name = project_tuple[1]
project_details = project_tuple[2]
project_details['title'] = project_name
project_details['type'] = commercial_or_private
es.index(index="searchmybio_luke",
doc_type='project',
id=project_name,
body=project_details)
import pandas as pd
from transmission_rpc import Client
from telegram import Update, ParseMode
from telegram.ext import CallbackContext
from scraper import search_piratebay
from config_loader import load_config
# Load config file
token, username, password, host, port, chatid = load_config()
def help_command(update: Update, context: CallbackContext) -> None:
"""Send a message when the command /help is issued."""
help_text = """/piratesearch (n) query - Show first n results for query on Piratebay
/more - Show 5 more results for Query
/download idx - Download torrent with idx from previous piratesearch
/listtorrents - List all torrents in Transmission
/deletealltorrents - Delete all torrents in Transmission
/deletetorrent idx - Delete torrent with idx from previous listtorrent
"""
update.message.reply_text(help_text.replace(' ', ''))
def pirate_search(update, context):
"""Usage /piratesearch n query
Show first n results for query on Piratebay. Note that n is limited to 30, as only the first page is scraped.
If no n is provided 10 rows are shown by default.
"""
if update.effective_chat.id != chatid:
import redis
import time
from config_loader import load_config
from bot import WallEBot
from handlers.tags import TagsHandler
from handlers.repeat import RepeatHandler
from handlers.morse import MorseCodeHandler
from handlers.mud_emote import MudEmoteHandler
cfg = load_config()
rds = redis.StrictRedis(host=cfg.REDIS_HOST, db=cfg.REDIS_DB)
bot = WallEBot(cfg.TELEGRAM_TOKEN)
bot.add_handlers(
TagsHandler(bot),
MorseCodeHandler(bot),
MudEmoteHandler(bot),
RepeatHandler(bot)
)
def run():
bot.message_loop()
print('Listening...')
while True:
time.sleep(10)
return (mean[0] - interval_scalar * stdev[0],
mean[1] - interval_scalar * stdev[1],
mean[2] - interval_scalar * stdev[2])
def calc_upperb(mean, stdev, interval_scalar):
return (mean[0] + interval_scalar * stdev[0],
mean[1] + interval_scalar * stdev[1],
mean[2] + interval_scalar * stdev[2])
###############################################################
# Main
if __name__ == "__main__":
config = load_config()
img = cv2.imread("../input/DJI_0240.JPG")
bgr_props = config['bgr_properties']
bgr_mean = (bgr_props['b_mean'], bgr_props['g_mean'], bgr_props['r_mean'])
bgr_stdev = (bgr_props['b_stdev'], bgr_props['g_stdev'],
bgr_props['r_stdev'])
# # BGR segmentation
img_seg_bgr = segment_bgr(
img, calc_lowerb(bgr_mean, bgr_stdev,
bgr_props['lowerb_stdev_scalar']),
calc_upperb(bgr_mean, bgr_stdev, bgr_props['upperb_stdev_scalar']))
_, cnts, _ = cv2.findContours(img_seg_bgr, cv2.RETR_TREE,
from blessings import Terminal
# self
import config_loader
# parse docopt
arguments = docopt.docopt(__doc__, options_first=True)
if arguments['--debug']:
log_level = logging.DEBUG
else:
log_level = logging.INFO
# Set configuration and logging up first
config_location = "~/.nbssh"
config = config_loader.load_config(config_location)
if config == 0:
sample_config = """Sample configuration:
[main]
API_ADDRESS = https://netbox.yourdomain.com
LOG_LOCATION = /var/log/nbssh.log
API_TOKEN = Token abc123
NO_OF_RESULTS = 10
"""
print(sample_config)
sys.exit()
logging.basicConfig(level=log_level,
format='[%(asctime)s][%(levelname)s][%(name)s] \
%(message)s',
#!/usr/bin/env python
from config_loader import load_config
from google.cloud import pubsub_v1
config = load_config("../config.yml")
project_id = config["project_id"]
subscription = config["subscription"]
subscription_name = f"projects/{project_id}/subscriptions/{subscription}"
print(f"Subscription name: {subscription_name}")
subscriber = pubsub_v1.SubscriberClient()
print("Listening for messages on {}".format(subscription_name))
while True:
response = subscriber.pull(subscription_name, max_messages=5)
for msg in response.received_messages:
print("Received message:", msg.message.data)
ack_ids = [msg.ack_id for msg in response.received_messages]
subscriber.acknowledge(subscription_name, ack_ids)
#!/usr/bin/env python
from tweepy import API
from authenticate import authenticate
from config_loader import load_config
from unfollow import unfollow_stale_friends
auth_config: dict = load_config('auth_config.yml')
config: dict = load_config('config.yml')
api: API = authenticate(consumer_key=auth_config['consumer_key'],
consumer_secret=auth_config['consumer_secret'],
access_key=auth_config['access_key'],
access_secret=auth_config['access_secret'])
unfollow_stale_friends(days=config['days'], api=api)
import yaml
import csv
from modules import geometry
import config_loader
config, input_spec, coords, dm = config_loader.load_config()
def compute_distance_matrix(coords):
"""build distance matrix from coords"""
d_mat = []
for c1 in coords:
# get distance between current point and all other points
d_vect = []
for c2 in coords:
d = int(geometry.get_distance_from_deg(c1, c2))
d_vect.append(d)
d_mat.append(d_vect)
return d_mat
def compute_distance_matrix_wrapper():
return compute_distance_matrix(coords)
def compute_random_points(coords):
"""set origin as coords centroid. compute distances relative to origin. update depot coords with random points."""
new_coords = []
app.config['TEMPLATES_AUTO_RELOAD'] = True
app.debug = True
LOG_FILENAME = 'app_access_logs.log'
app.logger.setLevel(logging.INFO) # use the native logger of flask
handler = handlers.RotatingFileHandler(
LOG_FILENAME,
maxBytes=1024 * 1024 * 100,
backupCount=20
)
app.logger.addHandler(handler)
elastic_config = load_config('elastic-config.yml')
dao = ElasticDao(elastic_config)
@app.route("/")
def hello():
message = "This is front page"
return render_template("index.html", message = message)
@app.route("/cv")
def cv():
response = dao.docs_sorted_by_date(innertype='commercial')
commercial_projects = response['hits']['hits']
response = dao.docs_sorted_by_date(innertype='private')
private_projects = response['hits']['hits']
