def main(): parser = utils.build_parser("List offers") args = parser.parse_args() subnet = args.subnet_tag sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n" ) enable_default_logger() try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag=subnet, ), timeout=4, )) except TimeoutError: pass
def main(): import pathlib import sys parent_directory = pathlib.Path(__file__).resolve().parent.parent sys.stderr.write(f"Adding {parent_directory} to sys.path.\n") sys.path.append(str(parent_directory)) import utils parser = utils.build_parser("List offers") args = parser.parse_args() subnet = args.subnet_tag sys.stderr.write(f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n") enable_default_logger() try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for(list_offers(Configuration(), subnet_tag=subnet,), timeout=4,) ) except TimeoutError: pass
if 'pc' in loaded[ref_out_layer]: ref_pc = loaded[ref_out_layer]['pc'] performance_metrics(pc=pc, ref_pc=ref_pc) blob_counters(out_blob=out_blob, ref_out_blob=ref_out_blob) global_accuracy = update_global_accuracy_matrics(global_accuracy=global_accuracy, current_accuracy=a_m) print_all_over_the_net_metrics(global_accuracy=global_accuracy) def main(args): log.info('Inference Engine:\n API version ............ {}'.format(ie.__version__), extra={'no_lvl': True}) set_verbosity(args.verbosity) mode = find_out_cct_mode(args) if mode == 1: log.info('Cross check with one IR was enabled') one_ir_mode(args) elif mode == 2: log.info('Cross check with two IRs was enabled') two_ir_mode(args) elif mode == 3: log.info('Dump mode was enabled') dump_mode(args) elif mode == 4: log.info('Load mode was enabled') load_mode(args) log.info("Execution successful") if __name__ == '__main__': set_logger(log.DEBUG) main(validate_args(build_parser().parse_args()))
timeout=timedelta(minutes=25), subnet_tag=args.subnet_tag, event_emitter=log_summary(log_event_repr), ) as engine: inputs = range(2) async for task in engine.map( worker, [Task(data=graphInput) for graphInput in inputs]): print(f"{utils.TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.output}" f"{utils.TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = utils.build_parser("script") parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=2) args = parser.parse_args() enable_default_logger(log_file=args.log_file) sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n" ) loop = asyncio.get_event_loop() task = loop.create_task(main(args)) try: # Generate a new set of images on the Golem network
max_workers=3, budget=10.0, timeout=init_overhead + timedelta(minutes=len(frames) * 2), subnet_tag=subnet_tag, event_emitter=log_summary(log_event_repr), ) as engine: async for task in engine.map(worker, [Task(data=frame) for frame in frames]): print(f"{utils.TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.output}" f"{utils.TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = utils.build_parser("Render blender scene") parser.set_defaults(log_file="blender-yapapi.log") args = parser.parse_args() enable_default_logger(log_file=args.log_file) loop = asyncio.get_event_loop() subnet = args.subnet_tag sys.stderr.write( f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n" ) sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n" ) task = loop.create_task(main(subnet_tag=args.subnet_tag)) try: asyncio.get_event_loop().run_until_complete(task)
async for task in engine.map(worker, [Task(data=date) for date in days]): print( f'\033[36;1mTask computed: {task}, result: {task.output}\033[0m' ) gif_name = './covid.gif' generate_gif(gif_name) print(f'{utils.TEXT_COLOR_GREEN}' f'gif generated: {gif_name}' f'{utils.TEXT_COLOR_DEFAULT}') if __name__ == '__main__': parser = utils.build_parser('covid') parser.add_argument('--workers', type=int, default=2) parser.add_argument('--parameter', type=str, default='new_deaths') parser.add_argument('--start', type=str, default='2020-10-01') parser.add_argument('--end', type=str, default='2020-10-20') args = parser.parse_args() enable_default_logger(log_file=args.log_file) sys.stderr.write( f'Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n' ) Path('outputs').mkdir(parents=True, exist_ok=True)
) async for task in completed_tasks: num_tasks += 1 print( f"{TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.result}, time: {task.running_time}" f"{TEXT_COLOR_DEFAULT}") print( f"{TEXT_COLOR_CYAN}" f"{num_tasks} tasks computed, total time: {datetime.now() - start_time}" f"{TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = build_parser("Send a drone task") now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S") parser.set_defaults(log_file=f"drone-yapapi-{now}.log") args = parser.parse_args() # This is only required when running on Windows with Python prior to 3.8: windows_event_loop_fix() enable_default_logger( log_file=args.log_file, debug_activity_api=True, debug_market_api=True, debug_payment_api=True, ) loop = asyncio.get_event_loop()
TEXT_COLOR_RED, TEXT_COLOR_YELLOW, print_env_info, run_golem_example, ) HASHCAT_ATTACK_MODE = 3 # stands for mask attack, hashcat -a option KEYSPACE_OUTPUT_PATH = Path("/golem/output/keyspace") # Ideally, this value should depend on the chunk size MASK_ATTACK_TIMEOUT: timedelta = timedelta(minutes=30) KEYSPACE_TIMEOUT: timedelta = timedelta(minutes=10) # Enough timeout for two attempts KEYSPACE_TIMEOUT_ALL_TASKS: timedelta = KEYSPACE_TIMEOUT * 2.1 arg_parser = build_parser("Run a hashcat attack (mask mode) on Golem network.") arg_parser.set_defaults( log_file=f"hashcat-yapapi-{datetime.now().strftime('%Y-%m-%d_%H.%M.%S')}.log" ) arg_parser.epilog = ( "Example invocation: ./yacat.py --mask '?a?a?a' --hash '$P$5ZDzPE45CLLhEx/72qt3NehVzwN2Ry/'" ) arg_parser.add_argument("--hash", type=str, help="Target hash to be cracked", required=True) arg_parser.add_argument( "--mask", type=str, help="Hashcat mask to be used for the attack. Example: a value of '?a?a?a' will " "try all 3-character combinations, where each character is mixalpha-numeric " "(lower and upper-case letters + digits) or a special character", required=True, )
num_tasks += 1 print( f"{TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.result}, time: {task.running_time}" f"{TEXT_COLOR_DEFAULT}" ) print( f"{TEXT_COLOR_CYAN}" f"{num_tasks} tasks computed, total time: {datetime.now() - start_time}" f"{TEXT_COLOR_DEFAULT}" ) if __name__ == "__main__": parser = build_parser("Render a Blender scene") parser.set_defaults(log_file="blender-yapapi.log") args = parser.parse_args() # This is only required when running on Windows with Python prior to 3.8: windows_event_loop_fix() enable_default_logger( log_file=args.log_file, debug_activity_api=True, debug_market_api=True, debug_payment_api=True, ) loop = asyncio.get_event_loop() task = loop.create_task(
else: distance = (count - numSteps / 2) / (numSteps / 2) secondFrequency = interpolate(16, 10, distance) smoothness = interpolate(3, 10, distance) inputs.append((filename, step, secondFrequency, smoothness)) async for task in engine.map(worker, [Task(data=graphInput) for graphInput in inputs]): print( f"{utils.TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.output}" f"{utils.TEXT_COLOR_DEFAULT}" ) if __name__ == "__main__": parser = utils.build_parser("golemGraph") parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=4) args = parser.parse_args() enable_default_logger(log_file=args.log_file) sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n" ) loop = asyncio.get_event_loop() task = loop.create_task(main(args)) try: # Generate a new set of images on the Golem network loop.run_until_complete(task) # Combine them locally renderAnimation()
max_workers=8, budget=100.0, timeout=timedelta(minutes=3) + timedelta(minutes=10), subnet_tag=subnet_tag, event_emitter=log_summary(log_event_repr), ) as engine: async for task in engine.map(worker, [Task(data=feed) for feed in feeds]): print(f"{utils.TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.output}" f"{utils.TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = utils.build_parser("Simulate a strong gravitational lensing") parser.set_defaults() args = parser.parse_args() enable_default_logger(log_file=args.log_file) loop = asyncio.get_event_loop() subnet = args.subnet_tag sys.stderr.write( f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n" ) sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n" ) task = loop.create_task(main(subnet_tag=args.subnet_tag)) try: asyncio.get_event_loop().run_until_complete(task)
await proxy.stop() print(f"{TEXT_COLOR_CYAN}HTTP server stopped{TEXT_COLOR_DEFAULT}") cluster.stop() cnt = 0 while cnt < 3 and any(s.is_available for s in instances): print(instances) await asyncio.sleep(5) cnt += 1 await network.remove() if __name__ == "__main__": parser = build_parser("An extremely simple http proxy") parser.add_argument( "--num-instances", type=int, default=2, help="The number of instances of the http service to spawn", ) parser.add_argument( "--port", type=int, default=8080, help="The local port to listen on", ) parser.add_argument( "--running-time", default=600,
payment_driver=payment_driver, payment_network=payment_network, ) as golem: print_env_info(golem) print( f"{TEXT_COLOR_YELLOW}Scanning {pluralize(scan_size, 'node')}, " f"using {pluralize(max_workers, 'concurrent worker')}.{TEXT_COLOR_DEFAULT}" ) tasks: List[Task] = [Task(i) for i in range(scan_size)] async for task in golem.execute_tasks(worker, tasks, payload, max_workers=max_workers): print(f"{TEXT_COLOR_MAGENTA}{task.result}{TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = build_parser("Scan providers") parser.add_argument("--scan-size", help="Number of nodes to scan", type=int, default=5) parser.add_argument( "--max-workers", help="Number of scans at the same time", type=int, default=3 ) now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S") parser.set_defaults(log_file=f"scan-yapapi-{now}.log") args = parser.parse_args() run_golem_example( main( scan_size=args.scan_size, max_workers=args.max_workers, subnet_tag=args.subnet_tag, payment_driver=args.payment_driver, payment_network=args.payment_network,
print(f"{TEXT_COLOR_CYAN}HTTP server stopped{TEXT_COLOR_DEFAULT}") web_cluster.stop() db_cluster.stop() cnt = 0 while cnt < 3 and any( s.is_available for s in web_cluster.instances + db_cluster.instances): print(web_cluster.instances + db_cluster.instances) await asyncio.sleep(5) cnt += 1 if __name__ == "__main__": parser = build_parser("Golem simple Web app example") parser.add_argument( "--port", type=int, default=8080, help="The local port to listen on", ) now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S") parser.set_defaults(log_file=f"webapp-yapapi-{now}.log") args = parser.parse_args() run_golem_example( main( subnet_tag=args.subnet_tag, payment_driver=args.payment_driver, payment_network=args.payment_network,
print(f"{TEXT_COLOR_YELLOW}Stopping {cluster}...{TEXT_COLOR_DEFAULT}") cluster.stop() # wait for instances to stop cnt = 0 while cnt < 10 and any(s.is_available for s in cluster.instances): print_instances() await asyncio.sleep(5) print_instances() if __name__ == "__main__": parser = build_parser( "A very simple / POC example of a service running on Golem, utilizing the VM runtime" ) parser.add_argument( "--running-time", default=120, type=int, help=( "How long should the instance run before the cluster is stopped " "(in seconds, default: %(default)s)" ), ) parser.add_argument( "--num-instances", type=int, default=1, help="The number of instances of the service to spawn",
f"{utils.TEXT_COLOR_DEFAULT}") password = read_password(ranges) if password is None: print( f"{utils.TEXT_COLOR_RED}No password found{utils.TEXT_COLOR_DEFAULT}" ) else: print(f"{utils.TEXT_COLOR_GREEN}" f"Password found: {password}" f"{utils.TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = utils.build_parser("yacat") parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=3) parser.add_argument("mask") parser.add_argument("hash") args = parser.parse_args() # This is only required when running on Windows with Python prior to 3.8: windows_event_loop_fix() enable_default_logger(log_file=args.log_file)
password = read_password(task.data) if password: break if password is None: print(f"{utils.TEXT_COLOR_RED}No password found{utils.TEXT_COLOR_DEFAULT}") else: print( f"{utils.TEXT_COLOR_GREEN}" f"Password found: {password}" f"{utils.TEXT_COLOR_DEFAULT}" ) if __name__ == "__main__": parser = utils.build_parser("john") parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=3) parser.add_argument("hash") args = parser.parse_args() enable_default_logger(log_file=args.log_file) sys.stderr.write( f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n" ) Path('logs').mkdir(parents=True, exist_ok=True) Path('logs').mkdir(parents=True, exist_ok=True)
print('Document created successfully') print('You can access your document here:', url) pid_path = config[MAIN_SECTION][utils.Section.PID_PATH] sleep_time = int(config[MAIN_SECTION][utils.Section.SLEEP_TIME]) with daemon.DaemonContext( working_directory='./', umask=0o002, files_preserve=[handler.stream], stderr=handler.stream, pidfile=pidfile.PIDLockFile(pid_path), ): logger.info('Starting daemon') while True: logger.info('Running gdoc process.') _run() time.sleep(sleep_time) if __name__ == '__main__': args = utils.build_parser() if args.mode == 'start': start_daemon_process() elif args.mode == 'stop': stop() elif args.mode == 'restart': stop() start_daemon_process() else: raise ValueError('Invalid mode.')
max_workers=10, budget=20.0, timeout=init_overhead, subnet_tag=subnet_tag, event_emitter=log_summary(log_event_repr), ) as engine: async for task in engine.map( worker, [Task(data=preset) for preset in preset_list]): print(f"{utils.TEXT_COLOR_CYAN}" f"Task computed: {task}, result: {task.output}" f"{utils.TEXT_COLOR_DEFAULT}") if __name__ == "__main__": parser = utils.build_parser("Video Transcoder") parser.add_argument( "--presets", default="Fast 480p30", help= "HandBrakeCLI transcode preset; can pass multiple separated by comma; default: %(default)s" ) parser.add_argument("--job", default="0", help="An optional job ID; default: %(default)s") parser.add_argument("input_file") args = parser.parse_args() enable_default_logger(log_file=args.log_file) loop = asyncio.get_event_loop() subnet = args.subnet_tag
for i in range(node_count): output_file = f"out_{str(i+1)}.txt" with open(output_file) as f: lines = f.readlines() echoer_message = f"Ripper {i+1} did not find the password" for line in lines: if "?" in line: echoer_message = f"{utils.TEXT_COLOR_GREEN}Worker {i+1} found the password: {line[2:].strip()}{utils.TEXT_COLOR_DEFAULT}" break print(echoer_message) if __name__ == "__main__": parser = utils.build_parser("John the Ripper") parser.add_argument("node_count") parser.add_argument("timeout_seconds") parser.add_argument("password") parser.set_defaults(log_file="john.log", node_count="4", timeout_seconds="5", password="******") args = parser.parse_args() enable_default_logger(log_file=args.log_file) loop = asyncio.get_event_loop() subnet = args.subnet_tag sys.stderr.write( f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n" )
password = read_password(ranges) if password is None: print(f"{TEXT_COLOR_RED}No password found{TEXT_COLOR_DEFAULT}") else: print( f"{TEXT_COLOR_GREEN}Password found: {password}{TEXT_COLOR_DEFAULT}" ) print( f"{TEXT_COLOR_CYAN}Total time: {datetime.now() - start_time}{TEXT_COLOR_DEFAULT}" ) if __name__ == "__main__": parser = build_parser("yacat") parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=3) parser.add_argument("mask") parser.add_argument("hash") args = parser.parse_args() # This is only required when running on Windows with Python prior to 3.8: windows_event_loop_fix() enable_default_logger(log_file=args.log_file)
try: await asyncio.sleep(5) except (KeyboardInterrupt, asyncio.CancelledError): break cluster.stop() cnt = 0 while cnt < 3 and any(s.is_available for s in instances): print(instances) await asyncio.sleep(5) cnt += 1 if __name__ == "__main__": parser = build_parser("Golem VPN SSH example") parser.add_argument( "--num-instances", type=int, default=2, help="Number of instances to spawn", ) now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S") parser.set_defaults(log_file=f"ssh-yapapi-{now}.log") args = parser.parse_args() run_golem_example( main( subnet_tag=args.subnet_tag, payment_driver=args.payment_driver, payment_network=args.payment_network,
if was_running and all([ s.state == ServiceState.terminated for s in cluster.instances ]): print_instances() print("All services were successfully terminated") break if len(cluster.instances) > 0: print_instances() was_running = True if __name__ == "__main__": parser = build_parser("Custom Usage Counter Example") parser.add_argument( "--running-time", default=30, type=int, help= "How long should the the service run (in seconds, default: %(default)s)", ) args = parser.parse_args() enable_default_logger( log_file=args.log_file, debug_activity_api=True, debug_market_api=True, debug_payment_api=True, ) asyncio.run(