def testWithEncryptedVolumes(self, get_state_mock, gui_oauth_mock, _): argv = [ 'main_test', '--login_type', 'oauth2', '--server_url', 'https://cvest.appspot.com', '--username', 'user' ] app.run(main.main, argv=argv) get_state_mock.assert_called_once() gui_oauth_mock.assert_called_once_with('https://cvest.appspot.com', 'user') gui_oauth_mock.return_value.EncryptedVolumePrompt.assert_called_once()
def run_main(): """Initializes flags and calls main().""" program.setup_environment() tensorboard = program.TensorBoard(default.get_plugins(), default.get_assets_zip_provider()) try: from absl import app # Import this to check that app.run() will accept the flags_parser argument. from absl.flags import argparse_flags app.run(tensorboard.main, flags_parser=tensorboard.configure) raise AssertionError("absl.app.run() shouldn't return") except ImportError: pass tensorboard.configure(sys.argv) sys.exit(tensorboard.main())
def MaybeRunScriptInstead(): if "SCRIPT_NAME" in os.environ: # Append current path to import path and execute `SCRIPT_NAME` main. sys.path.extend([os.path.dirname(__file__)]) module_name = os.environ["SCRIPT_NAME"] retval = app.run(importlib.import_module(module_name).main) sys.exit(retval)
) as env: for i in range(100000): agent.setup(env.observation_spec(), env.action_spec()) timesteps = env.reset() agent.reset() while True: action, pi, last_logp_pi = agent.step(timesteps[0]) step_actions = [action] old_timesteps = timesteps timesteps = env.step(step_actions) if(isTraining): agent.trainAgent(timesteps[0], old_timesteps[0], pi, timesteps[0].reward, last_logp_pi) if timesteps[0].last(): break except KeyboardInterrupt: pass if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--model', type=str, help='Name of the model') parser.add_argument('--replay', type=bool, help="Save a replay of the experiment") parser.add_argument('--training', type=bool, help="if is training") args, unknown_flags = parser.parse_known_args() flags.FLAGS(sys.argv[:1] + unknown_flags) app.run(main, argv=sys.argv[:1] + unknown_flags)
def GRRFuse(): from grr_response_server.bin import fuse_mount app.run(fuse_mount.main)
def GrrFrontend(): from grr_response_server.bin import frontend app.run(frontend.main)
def ApiShellRawAccess(): from grr_response_server.bin import api_shell_raw_access app.run(api_shell_raw_access.main)
def test_main(): with pytest.raises(SystemExit): app.run(benchmark_xmon_simulator.main, argv=( 'main', 'from dev_tools.profiling.benchmark_xmon_simulator import simulate' ))
flags.register_validator( 'generated_x_dir', lambda x: False if (FLAGS.image_set_y_glob and not x) else True, 'Must provide `generated_x_dir`.') flags.register_validator( 'generated_y_dir', lambda x: False if (FLAGS.image_set_x_glob and not x) else True, 'Must provide `generated_y_dir`.') def main(_): _validate_flags() images_x_hwc_pl, generated_y = make_inference_graph('ModelX2Y', FLAGS.patch_dim) images_y_hwc_pl, generated_x = make_inference_graph('ModelY2X', FLAGS.patch_dim) # Restore all the variables that were saved in the checkpoint. saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, FLAGS.checkpoint_path) export(sess, images_x_hwc_pl, generated_y, FLAGS.image_set_x_glob, FLAGS.generated_y_dir) export(sess, images_y_hwc_pl, generated_x, FLAGS.image_set_y_glob, FLAGS.generated_x_dir) if __name__ == '__main__': app.run()
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Utility to create a single py_binary that can call multiple py_binaries. This simulates executing a python script by importing a module name by the environment 'SCRIPT_NAME' and executing its main via `app.run`. """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import importlib import os import sys from absl import app if __name__ == '__main__': # Append current path to import path and execute `SCRIPT_NAME` main. sys.path.extend([os.path.dirname(__file__)]) module_name = os.environ['SCRIPT_NAME'] app.run(importlib.import_module(module_name).main)
FLAGS = flags.FLAGS flags.DEFINE_string('name', None, 'model name') def _main(name): starter = get_starter(name) print(name) if starter.url is not None: if starter.clean_archive(): print('Cleaned') else: print('No archive present') else: print('No url') print('---------------------------------------') def main(_): name = FLAGS.name if name is None: for name in get_names(): _main(name) else: _main(name) if __name__ == '__main__': app.run(main)
resnet_size='32', train_epochs=250, epochs_between_evals=10, batch_size=128) def run_cifar(flags_obj): """Run ResNet CIFAR-10 training and eval loop. Args: flags_obj: An object containing parsed flag values. """ input_function = (flags_obj.use_synthetic_data and get_synth_input_fn() or input_fn) ##### INPUT ##### Specifically the "shape" that is passed in with the values being at the top of the file resnet_run_loop.resnet_main( flags_obj, cifar10_model_fn, input_function, DATASET_NAME, shape=[_HEIGHT, _WIDTH, _NUM_CHANNELS]) def main(_): with logger.benchmark_context(flags.FLAGS): run_cifar(flags.FLAGS) if __name__ == '__main__': tf.logging.set_verbosity(tf.logging.INFO) define_cifar_flags() absl_app.run(main)
def multi_process_run(main: Callable[[Any], None]) -> None: """Same as `absl.app.run` but with special multiprocess flags.""" app.run(main)
"version", default=False, allow_override=True, help="Print the GRR worker version number and exit immediately.") def main(argv): """Main.""" del argv # Unused. if flags.FLAGS.version: print("GRR worker {}".format(config_server.VERSION["packageversion"])) return config.CONFIG.AddContext(contexts.WORKER_CONTEXT, "Context applied when running a worker.") # Initialise flows and config_lib server_startup.Init() fleetspeak_connector.Init() token = access_control.ACLToken(username="******").SetUID() worker_obj = worker_lib.GRRWorker(token=token) worker_obj.Run() if __name__ == "__main__": app.run(main)
return (self.train_loss_metric.result().numpy(), self.test_loss_metric.result().numpy()) def run_main(argv): del argv kwargs = utils.flags_dict() main(**kwargs) def main(epochs, enable_function, buffer_size, batch_size, download_path, num_examples=70000, embedding_dim=256, enc_units=1024, dec_units=1024): file_path = utils.download(download_path) train_ds, test_ds, inp_lang, targ_lang = utils.create_dataset( file_path, num_examples, buffer_size, batch_size) vocab_inp_size = len(inp_lang.word_index) + 1 vocab_tar_size = len(targ_lang.word_index) + 1 encoder = nmt.Encoder(vocab_inp_size, embedding_dim, enc_units, batch_size) decoder = nmt.Decoder(vocab_tar_size, embedding_dim, dec_units) train_obj = Train(epochs, enable_function, encoder, decoder, inp_lang, targ_lang, batch_size, batch_size) print ('Training ...') return train_obj.training_loop(train_ds, test_ds) if __name__ == '__main__': utils.nmt_flags() app.run(run_main)
[0, 1], GetProcessIteratorPids( cmdline_regex_string=r"svchost.exe -k (abc|def)")) self.assertCountEqual( [0, 1, 2], GetProcessIteratorPids(cmdline_regex_string=r"svchost.exe.*")) self.assertCountEqual( [2], GetProcessIteratorPids(cmdline_regex_string=r"^svchost.exe$")) def testCmdlineRegex(self): scan_request = rdf_memory.YaraProcessScanRequest( signature_shard=rdf_memory.YaraSignatureShard(index=0, payload=b"123"), num_signature_shards=1, cmdline_regex="svchost.exe -k def") with mock.patch.object(memory.YaraProcessScan, "_GetMatches", return_value=[rdf_memory.YaraMatch()]): results = self.ExecuteAction(memory.YaraProcessScan, arg=scan_request) self.assertLen(results, 2) self.assertLen(results[0].matches, 1) self.assertEqual(results[0].matches[0].process.pid, 1) if __name__ == "__main__": app.run(test_lib.main)
decompress_cmd.set_defaults( f=decompress, a=["input_file", "output_file", "url_prefix", "metagraph_cache"]) # Arguments for both 'compress' and 'decompress'. for cmd, ext in ((compress_cmd, ".tfci"), (decompress_cmd, ".png")): cmd.add_argument( "input_file", help="Input filename.") cmd.add_argument( "output_file", nargs="?", help="Output filename (optional). If not provided, appends '{}' to " "the input filename.".format(ext)) # 'models' subcommand. models_cmd = subparsers.add_parser( "models", description="Lists available trained models. Requires an internet " "connection.") models_cmd.set_defaults(f=list_models, a=["url_prefix"]) # Parse arguments. return parser.parse_args(argv[1:]) if __name__ == "__main__": # Parse arguments and run function determined by subcommand. app.run( lambda args: args.f(**{k: getattr(args, k) for k in args.a}), flags_parser=parse_args)
def Run(): app.run(main, flags_parser=lambda argv: parser.parse_args(argv[1:]))
def EndToEndTests(): from grr_response_test import run_end_to_end_tests app.run(run_end_to_end_tests.main)
summary_writer = tf.summary.FileWriter(LOG) for i in range(PARALLEL): agents[i].setup(sess, summary_writer) agent.initialize() if not FLAGS.training or FLAGS.continuation: global COUNTER COUNTER = agent.load_model(SNAPSHOT) # Run threads threads = [] for i in range(PARALLEL - 1): t = threading.Thread(target=run_thread, args=(agents[i], FLAGS.map, False)) threads.append(t) t.daemon = True t.start() time.sleep(5) run_thread(agents[-1], FLAGS.map, FLAGS.render) for t in threads: t.join() if FLAGS.profile: print(stopwatch.sw) if __name__ == "__main__": app.run(_main)
def ApiRegressionTestsGenerate(): from grr_response_test import api_regression_test_generate app.run(api_regression_test_generate.main)
def Console(): from grr_response_server.bin import console app.run(console.main)
def DumpMySQLSchema(): from grr_response_test import dump_mysql_schema app.run(dump_mysql_schema.main)
def GrrServer(): from grr_response_server.bin import grr_server app.run(grr_server.main)
def DistEntry(): """The main entry point for packages.""" app.run(main)
def Worker(): from grr_response_server.bin import worker app.run(worker.main)
def Client(): from grr_response_client import client app.run(client.main)
def AdminUI(): from grr_response_server.gui import admin_ui app.run(admin_ui.main)
def FleetspeakClient(): from grr_response_client import grr_fs_client app.run(grr_fs_client.main)
flags.DEFINE_integer( name="train_start", default=0, help=help_wrap("Start index of train examples within the data.")) flags.DEFINE_integer( name="train_count", default=1000000, help=help_wrap("Number of train examples within the data.")) flags.DEFINE_integer( name="eval_start", default=10000000, help=help_wrap("Start index of eval examples within the data.")) flags.DEFINE_integer( name="eval_count", default=1000000, help=help_wrap("Number of eval examples within the data.")) flags.DEFINE_integer( "n_trees", default=100, help=help_wrap("Number of trees to build.")) flags.DEFINE_integer( "max_depth", default=6, help=help_wrap("Maximum depths of each tree.")) flags.DEFINE_float( "learning_rate", default=0.1, help=help_wrap("The learning rate.")) flags_core.set_defaults(data_dir="/tmp/higgs_data", model_dir="/tmp/higgs_model") if __name__ == "__main__": # Training progress and eval results are shown as logging.INFO; so enables it. tf.logging.set_verbosity(tf.logging.INFO) define_train_higgs_flags() absl_app.run(main)
def PoolClient(): from grr_response_client import poolclient app.run(poolclient.main)
#!/usr/bin/env python from __future__ import absolute_import from __future__ import division from __future__ import unicode_literals from absl import app from absl.testing import absltest from grr_response_server.databases import db_client_reports_test from grr_response_server.databases import mem_test_base from grr.test_lib import test_lib class MemoryDBClientReportsTest( db_client_reports_test.DatabaseTestClientReportsMixin, mem_test_base.MemoryDBTestBase, absltest.TestCase): pass if __name__ == "__main__": app.run(test_lib.main)
cv2.imshow('HawkEye', img) if FLAGS.output: out.write(img) frame_index = frame_index + 1 list_file.write(str(frame_index) + ' ') if len(converted_boxes) != 0: for i in range(0, len(converted_boxes)): list_file.write( str(converted_boxes[i][0]) + ' ' + str(converted_boxes[i][1]) + ' ' + str(converted_boxes[i][2]) + ' ' + str(converted_boxes[i][3]) + ' ') list_file.write('\n') # press q to quit if cv2.waitKey(1) == ord('q'): break vid.release() if FLAGS.output: out.release() list_file.close() cv2.destroyAllWindows() if __name__ == '__main__': try: hawkEye = HawkEye() app.run(hawkEye.main) except SystemExit: pass