def main(): vt_mysqlbinlog = os.environ.get('VT_MYSQL_ROOT') + '/bin/vt_mysqlbinlog' if not os.path.isfile(vt_mysqlbinlog): sys.exit("%s is not present, please install it and then re-run the test" % vt_mysqlbinlog) print "Note: This is a slow test, has a couple of sleeps in it to simulate proper state changes" utils.main()
def load(): import base base.main(dp) import text_parse text_parse.main(dp) import utils utils.main(dp) import vortaro vortaro.main(dp) import xkcd xkcd.main(dp)
def main(argv): load_all = True dump_all = True curr_frame = dict(start_day=1, start_hour=0,end_day=1,end_hour=1,year = 2009, month = 7) from config import update_time_frame try: opts, args = getopt.getopt(argv,"h",["sd=","sh=","ed=","eh="]) except getopt.GetoptError: print 'driver-analysis --sd --sh --ed --eh ' sys.exit(2) for opt, arg in opts: if opt == 'h': print 'driver-analysis --sd --sh --ed --eh ' sys.exit() elif opt=="--sd": curr_frame["start_day"] = int(arg) elif opt=="--sh": curr_frame["start_hour"] = int(arg) elif opt=="--ed": curr_frame["end_day"] = int(arg) elif opt=="--eh": curr_frame["end_hour"] = int(arg) print curr_frame # time_frame_list = [dict(start_day=1, start_hour=0,end_day=1,end_hour=1,year = 2009, month = 7), # dict(start_day=10, start_hour=0,end_day=11,end_hour=0,year = 2012, month = 4), # dict(start_day=11, start_hour=0,end_day=12,end_hour=0,year = 2012, month = 4), # dict(start_day=12, start_hour=0,end_day=13,end_hour=0,year = 2012, month = 4), # dict(start_day=13, start_hour=0,end_day=14,end_hour=0,year = 2012, month = 4), # dict(start_day=15, start_hour=0,end_day=16,end_hour=0,year = 2012, month = 4), # ] update_time_frame(curr_frame) import utils utils.main() import grid grid.main(reload=load_all, dump=dump_all) import input_data # cProfile.run('input_data.main(reload_trip=load_all, reload_log=load_all, dump_trip=dump_all, dump_log=dump_all)') input_data.main(reload_trip=load_all, reload_log=load_all, dump_trip=dump_all, dump_log=dump_all) import driver_income driver_income.main(reload=load_all, dump=dump_all) import driver_state_stats driver_state_stats.main(reload=load_all, dump=dump_all) import relative_demand_grid relative_demand_grid.main(reload=load_all, dump= dump_all, dump_csv = dump_all) import zone_driver zone_driver.main(reload=load_all, dump= dump_all) print "job done!"
def main(): parser = optparse.OptionParser(usage='usage: %prog [options] [test_names]') parser.add_option('-e', '--environment_type', help='Environment type', default=None) parser.add_option('-n', '--name', help='Environment name', default=None) parser.add_option('-p', '--environment_params', help='Environment parameters if creating an environment ' 'for the test', default=None) parser.add_option('-t', '--test_params', help='Test parameters', default=None) utils.add_options(parser) global _options _options, _ = parser.parse_args() del sys.argv[1:] utils.main()
def setUp(): """Sets up VtGate for integration tests in Java client""" create_table = '''create table vtgate_test ( id bigint auto_increment, name varchar(64), age SMALLINT, percent DECIMAL(5,2), keyspace_id bigint(20) unsigned NOT NULL, primary key (id) ) Engine=InnoDB''' vtgatev2_test.create_tables.append(create_table) utils.main(vtgatev2_test) # this is read in Java test to set up connection params sys.stdout.write(json.dumps({ "port": vtgatev2_test.vtgate_port, "keyspace_name": vtgatev2_test.KEYSPACE_NAME, "shard_kid_map": vtgatev2_test.shard_kid_map, })) sys.stdout.flush()
def get(self, anno_id): # they can request a certain format by ending with .gobe whatever. self.response.headers['Content-type'] = 'text/plain'; if anno_id == "": a = Annotation.all().order("-date").get() elif anno_id != "all": a = Annotation.all().filter('anno_id = ', anno_id).get() if a is None: a = Annotation() content = a.content if a.format and a.format != "gobe": content = [x.strip() for x in content.split("\n")] content = utils.main(content, a.format, force_tabs=True) self.response.out.write(content or "")
#!/usr/bin/env python # # Copyright 2014, Google Inc. All rights reserved. # Use of this source code is governed by a BSD-style license that can # be found in the LICENSE file. import utils import resharding from vtdb import keyrange_constants # this test is the same as resharding_bytes.py, but it uses vtworker to # do the clone. if __name__ == '__main__': resharding.keyspace_id_type = keyrange_constants.KIT_BYTES resharding.use_clone_worker = True utils.main(resharding)
doctest.testmod() from optparse import OptionParser parser = OptionParser(__doc__) supported_fmts = ("bed", "gff", "blast") parser.add_option("--format", dest="format", default="bed", choices=supported_fmts, help="choose one of %s" % (supported_fmts,) + " [default: %default]") parser.add_option("--feature-types", dest="feature_types", default=None, help= "include list of feature types (separated by comma); types not " "in the list are excluded (e.g. --feature-types CDS,exon,gene ") parser.add_option("--qadjust", dest="qadjust", type='int', default=0, help="adjust local query blast coordinates to chromosomal coords") parser.add_option("--sadjust", dest="sadjust", type='int', default=0, help="adjust local subject blast coordinates to chromosomal coords") parser.add_option("--title", dest="title", help="optional descriptor for" " this dataset. if specified, the data will be uploaded to" " try-gobe.appspot.com and a url will be printed where you" " can view your data") opts, args = parser.parse_args() if len(args) != 1: sys.exit(parser.print_help()) bed_file = args[0] print utils.main(bed_file, opts.format, opts.feature_types, title=opts.title, qadjust=opts.qadjust, sadjust=opts.sadjust)
def main(): utils.main(parse_func, exec_func)
def main(): utils.main(InTheEnd.InTheEndGame)
except urllib2.HTTPError as e: self.assertEqual(e.code, 307) # Verify that the command logged something and its available at /status. status = urllib2.urlopen(worker_base_url + '/status').read() self.assertIn( "Ping command was called with message: 'pong'", status, 'Command did not log output to /status') # Reset the job. urllib2.urlopen(worker_base_url + '/reset').read() status_after_reset = urllib2.urlopen(worker_base_url + '/status').read() self.assertIn( 'This worker is idle.', status_after_reset, '/status does not indicate that the reset was successful') def add_test_options(parser): parser.add_option( '--num_insert_rows', type='int', default=100, help='The number of rows, per shard, that we should insert before ' 'resharding for this test.') parser.add_option( '--num_insert_rows_before_reparent_test', type='int', default=3000, help='The number of rows, per shard, that we should insert before ' 'running TestReparentDuringWorkerCopy (supersedes --num_insert_rows in ' 'that test). There must be enough rows such that SplitClone takes ' 'several seconds to run while we run a planned reparent.') if __name__ == '__main__': utils.main(test_options=add_test_options)
#!/usr/bin/env python # # Copyright 2013, Google Inc. All rights reserved. # Use of this source code is governed by a BSD-style license that can # be found in the LICENSE file. """Re-runs merge_sharding.py with a varbinary keyspace_id.""" from vtdb import keyrange_constants import base_sharding import merge_sharding import utils if __name__ == '__main__': base_sharding.keyspace_id_type = keyrange_constants.KIT_BYTES utils.main(merge_sharding)
def Completo(): funciones.LimpiaDirectorio(ruta) speedtest.main() utils.main() ProcesosComunes()
#!/usr/bin/env python # # Copyright 2014, Google Inc. All rights reserved. # Use of this source code is governed by a BSD-style license that can # be found in the LICENSE file. import utils import initial_sharding from vtdb import keyrange_constants # this test is the same as initial_sharding_bytes.py, but it uses vtworker to # do the clone. if __name__ == '__main__': initial_sharding.use_clone_worker = True initial_sharding.keyspace_id_type = keyrange_constants.KIT_BYTES utils.main(initial_sharding)
logging.info('Fetching main vtctl page: %s', self.vtctl_addr) self.driver.get(self.vtctl_addr) self._check_shard_overview('test_keyspace', '-80', { 'master': 1, 'replica': 1, 'rdonly': 0 }) self._check_shard_overview('test_keyspace', '80-', { 'master': 1, 'replica': 1, 'rdonly': 0 }) self._check_shard_overview('test_keyspace2', '0', { 'master': 1, 'replica': 1, 'rdonly': 1 }) def add_test_options(parser): parser.add_option('--no-xvfb', action='store_false', dest='xvfb', default=True, help='Use local DISPLAY instead of headless Xvfb mode.') if __name__ == '__main__': utils.main(test_options=add_test_options)
cursor.execute(query, {'id': 1, 'message': 'hello world 1'}) cursor.execute(query, {'id': 4, 'message': 'hello world 4'}) cursor.commit() (it, fields) = vtgate_conn.message_stream(keyspace, name) self.assertEqual(fields, [('id', query_pb2.INT64), ('message', query_pb2.VARCHAR)]) # We should get both messages. result = {} for _ in xrange(2): row = it.next() result[row[0]] = row[1] self.assertEqual(result, {1: 'hello world 1', 4: 'hello world 4'}) # After ack, we should get only one message. count = vtgate_conn.message_ack(name, [4]) self.assertEqual(count, 1) result = {} for _ in xrange(2): row = it.next() result[row[0]] = row[1] self.assertEqual(result, {1: 'hello world 1'}) # Only one should be acked. count = vtgate_conn.message_ack(name, [1, 4]) self.assertEqual(count, 1) if __name__ == '__main__': utils.main()
#!/usr/bin/env python # # Copyright 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Re-runs resharding.py with a varbinary keyspace_id.""" from vtdb import keyrange_constants import base_sharding import resharding import utils # this test is just re-running an entire resharding.py with a # varbinary keyspace_id if __name__ == '__main__': base_sharding.keyspace_id_type = keyrange_constants.KIT_BYTES utils.main(resharding)
keyspace = 'test_keyspace' source_shard_list = "0" dest_shard_list = "-80,80-" _protocol, endpoint = utils.vtctld.rpc_endpoint() utils.run( environment.binary_argstr('automation_client') + ' --server localhost:' + str(automation_server_port) + ' --task HorizontalReshardingTask' + ' --param keyspace=' + keyspace + ' --param source_shard_list=' + source_shard_list + ' --param dest_shard_list=' + dest_shard_list + ' --param source_shard_rdonly_list=' + worker.shard_rdonly1.tablet_alias + ' --param dest_shard_rdonly_list=' + worker.shard_0_rdonly1.tablet_alias + ',' + worker.shard_1_rdonly1.tablet_alias + ' --param vtctld_endpoint=' + endpoint + ' --param vtworker_endpoint=localhost:' + str(worker_rpc_port)) self.assert_shard_data_equal(0, worker.shard_master, worker.shard_0_tablets.replica) self.assert_shard_data_equal(1, worker.shard_master, worker.shard_1_tablets.replica) utils.kill_sub_process(automation_server_proc, soft=True) utils.kill_sub_process(worker_proc, soft=True) if __name__ == '__main__': utils.main(test_options=worker.add_test_options)
#!/usr/bin/env python # # Copyright 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Re-runs update_stream.py with RBR.""" import update_stream import utils if __name__ == '__main__': update_stream.use_rbr = True utils.main(update_stream)
#!/usr/bin/env python # Copyright 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Re-runs backup.py with use_mysqlctld=True.""" import backup import utils if __name__ == '__main__': backup.use_mysqlctld = True utils.main(backup)
#!/usr/bin/env python # # Copyright 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Re-runs resharding.py with RBR on.""" import base_sharding import vertical_split import utils if __name__ == '__main__': base_sharding.use_rbr = True utils.main(vertical_split)
def main(): print "Note: This is a slow test, has a couple of sleeps in it to simulate proper state changes" utils.main()
# course: Kickstart Coding # date: 11/19/19 # name: Victor Sanchez # description: Templating for a static-site generator from utils import main import sys from slugify import slugify if len(sys.argv) < 3 and len(sys.argv) > 1: command = sys.argv[1] if command == "build": print("Build was specified") main() elif command == "new": print("New page was specified") new_name = slugify(input("New file name: ")) print('New file created:', (new_name + '.html')) new_filename = ('content/' + new_name + '.html') new_content = open('templates/new_content_temp.html').read() open(new_filename, "w+").write(new_content) else: print("\nPlease specify 'build' or 'new'\n" 'Usage:\n' ' Rebuild site: python manage.py build\n' ' Create new page: python manage.py new')
def Diagnostico(): funciones.LimpiaDirectorio(ruta) utils.main() ProcesosComunes()
self.game_data[item.name] = item def remove_possession(self, name): item = self.game_data[name] item.count -= 1 if not item.count: del self.game_data[name] self.possessions.remove(item) def make_opt_epilog(self): return "" def add_quiz_answer(self, q, a): self.game_data[q] = a self.quiz_answers.append([q, a]) def first_situation(self): return OpeningCredits(self) def _jump_to_situation(self): if self.jump_to.endswith(".csv"): self.jump_to = "MainSituation_%s" % self.jump_to.split(".csv")[0] sit = globals()[self.jump_to](self) utils._log("JUMPING TO SITUATION: %s (%s)" % (self.jump_to, sit.__class__.__name__)) return sit if __name__ == "__main__": utils.main(InTheEndGame)
#!/usr/bin/env python # # Copyright 2013, Google Inc. All rights reserved. # Use of this source code is governed by a BSD-style license that can # be found in the LICENSE file. import initial_sharding import utils from vtdb import keyrange_constants # this test is just re-running an entire initial_sharding.py with a # varbinary keyspace_id if __name__ == '__main__': initial_sharding.keyspace_id_type = keyrange_constants.KIT_BYTES utils.main(initial_sharding)
return model def generate_main(args): """ generates text from trained model specified in args. main method for generate subcommand. """ # load learning model for config and weights model = load_model(args.checkpoint_path) # build inference model and transfer weights inference_model = build_inference_model(model) inference_model.set_weights(model.get_weights()) logger.info("model loaded: %s.", args.checkpoint_path) # create seed if not specified if args.seed is None: with open(args.text_path) as f: text = f.read() seed = generate_seed(text) logger.info("seed sequence generated from %s.", args.text_path) else: seed = args.seed return generate_text(inference_model, seed, args.length, args.top_n) if __name__ == "__main__": logger = get_logger(__name__, console=True) main("Keras", train_main, generate_main)
# # We must run an explicit healthcheck or we can see one of the two states: # - NOT_SERVING, DisableQueryService=false, tablet type 'spare' # (immediately after SplitDiff returned) # - SERVING, DisableQueryService=false, tablet type 'rdonly' # (during healthcheck before post-action callback is called) utils.run_vtctl(["RunHealthCheck", worker.shard_rdonly1.tablet_alias], auto_log=True) # source shard: query service must be disabled after MigrateServedTypes. utils.check_tablet_query_service(self, worker.shard_rdonly1, serving=False, tablet_control_disabled=True) utils.check_tablet_query_service(self, worker.shard_replica, serving=False, tablet_control_disabled=True) utils.check_tablet_query_service(self, worker.shard_master, serving=False, tablet_control_disabled=True) # dest shard -80: query service must be disabled after MigrateServedTypes. # Run explicit healthcheck because 'rdonly' tablet may still be 'spare'. utils.run_vtctl(["RunHealthCheck", worker.shard_0_rdonly1.tablet_alias], auto_log=True) utils.check_tablet_query_service(self, worker.shard_0_rdonly1, serving=True, tablet_control_disabled=False) utils.check_tablet_query_service(self, worker.shard_0_replica, serving=True, tablet_control_disabled=False) utils.check_tablet_query_service(self, worker.shard_0_master, serving=True, tablet_control_disabled=False) # dest shard 80-: query service must be disabled after MigrateServedTypes. # Run explicit healthcheck because 'rdonly' tablet is still 'spare'. utils.run_vtctl(["RunHealthCheck", worker.shard_1_rdonly1.tablet_alias], auto_log=True) utils.check_tablet_query_service(self, worker.shard_1_rdonly1, serving=True, tablet_control_disabled=False) utils.check_tablet_query_service(self, worker.shard_1_replica, serving=True, tablet_control_disabled=False) utils.check_tablet_query_service(self, worker.shard_1_master, serving=True, tablet_control_disabled=False) if __name__ == "__main__": utils.main(test_options=worker.add_test_options)
#!/usr/bin/env python # # Copyright 2017 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Re-runs vtgatev2_test.py with a l2vtgate process.""" import utils import vtgatev2_test # This test is just re-running an entire vtgatev2_test.py with a # l2vtgate process in the middle. if __name__ == '__main__': vtgatev2_test.use_l2vtgate = True utils.main(vtgatev2_test)
with self.assertRaises(dbexceptions.OperationalError): vtgate_conn = get_connection(user="******", password="******") def test_incorrect_credentials(self): with self.assertRaises(dbexceptions.OperationalError): vtgate_conn = get_connection(user=self.user, password="******") def test_challenge_is_used(self): vtgate_conn = get_connection(user=self.user, password=self.password) challenge = "" proof = "%s %s" %(self.user, hmac.HMAC(self.password, challenge).hexdigest()) self.assertRaises(gorpc.AppError, vtgate_conn.client.call, 'AuthenticatorCRAMMD5.Authenticate', {"Proof": proof}) def test_only_few_requests_are_allowed(self): vtgate_conn = get_connection(user=self.user, password=self.password) for i in range(4): try: vtgate_conn.client.call('AuthenticatorCRAMMD5.GetNewChallenge', "") except gorpc.GoRpcError: break else: self.fail("Too many requests were allowed (%s)." % (i + 1)) if __name__ == '__main__': utils.main()
import argparse from utils import execute, main, get_abspath parser = argparse.ArgumentParser(description='Restore MongoDBs') parser.add_argument('-u', '--url', type=str, required=False, default='mongodb://127.0.0.1:27017/', help='Mongo DB URL for Backup') parser.add_argument('-i', '--input_dir', type=str, required=True, help='Input directory for the Restore.') parser.add_argument('-d', '--db', type=str, required=False, default='test_results_collection', help='database name after the restore.') def restore(args): input_dir = get_abspath(args.input_dir) cmd = ['mongorestore', '%s' % input_dir] execute(cmd, args) if __name__ == '__main__': main(restore, parser)