def file_write(members, member_elements): if not os.path.exists('ttl/common'): common.main() # os.mkdir('ttl/common') # with open('ttl/common.ttl', 'w') as fhandle: # fhandle.write(ttlhead) # fhandle.write('<common> a reg:Register ;\n') # fhandle.write('\trdfs:label "WMO No. 306 Vol I.2 common concepts" ;\n') # fhandle.write('\tdc:description "Register of concepts common across WMO No. 306 Vol I.2 formats"@en ;\n') # fhandle.write('\treg:owner <http://codes.wmo.int/system/organization/wmo> ;\n') # fhandle.write('\tdct:publisher <http://codes.wmo.int/system/organization/wmo> ;\n') # fhandle.write('\treg:manager <http://codes.wmo.int/system/organization/www-dm> ;\n') # fhandle.write('\t.\n') with open('ttl/common/bulk_c6.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write('<unit> a skos:Collection ;\n') fhandle.write('\trdfs:label "Code Table C-6: List of units for TDCFs"@en ;\n') fhandle.write('\tdct:description "WMO No. 306 Vol I.2 Common Code-table C-6 List of units for TDCFs."@en ;\n') fhandle.write('\tskos:notation "C-6" ;\n') fhandle.write('\treg:manager <http://codes.wmo.int/system/organization/www-dm> ;\n') fhandle.write('\treg:owner <http://codes.wmo.int/system/organization/wmo> ;\n') fhandle.write('\tskos:member ') fhandle.write(', '.join(members)) fhandle.write('\t.\n\n') fhandle.write('\n'.join(member_elements))
def main(): args = get_arguments() if args is None: print('No arguments') return if args.print_memory: common.print_memory(args.print_memory) if args.initialize: common.main() xb.get_network_info() if args.initialize_gsm_module: if retry_count == 0: lockscript.get_lock('gateway gsm') gsmio.init_gsm() if args.get_phonebook: dbio.get_phonebook_numbers() if args.write_custom_sms: custom_sms_routine() if args.send_outbox_messages: lockscript.get_lock('gateway gsm') send_unsent_msg_outbox() if args.delete_outbox_messages: dbio.delete_smsoutbox() if args.delete_all_outbox_messages: dbio.delete_all_smsoutbox() if args.debug_gsm: lockscript.get_lock('gateway gsm') gsmio.gsm_debug() if args.reset_gsm: lockscript.get_lock('gateway gsm') gsmio.reset_gsm() if args.reset_rain_value: rd.reset_rain_value() if args.rain_detect: rd.check_rain_value() if args.send_smsoutbox_memory: lockscript.get_lock('gateway gsm') send_smsoutbox_memory() send_unsent_msg_outbox() if args.purge_memory: lockscript.get_lock('gateway gsm') common.purge_memory(args.purge_memory) if args.set_system_time: set_system_time() if args.create_startup_message: create_startup_message() if args.sample_routers: lockscript.get_lock('xbeegate') xb.routine()
def file_write(members, member_elements): if not os.path.exists('ttl/common'): common.main() with open('ttl/common/bulk_quantitykind.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write('<quantity-kind> a skos:Collection ;\n') fhandle.write('\trdfs:label "Code Table D-2: Physical quantity kinds"@en ;\n') fhandle.write('\tskos:notation "D-2" ;\n') fhandle.write('\tdct:description "WMO No. 306 Vol I.3 Common Code-table D-2, Physical quantity kinds."@en ;\n') fhandle.write('\treg:manager <http://codes.wmo.int/system/organization/www-dm> ;\n') fhandle.write('\treg:owner <http://codes.wmo.int/system/organization/wmo> ;\n') fhandle.write('\tskos:member ') fhandle.write(', '.join(members)) fhandle.write('\t.\n\n') fhandle.write('\n'.join(member_elements))
def main( intensity, # Whether to include intensity or not device='cuda', max_epochs=200, pos_weight=10, *, # training parameters model_name, hidden_channels, hidden_hidden_channels, num_hidden_layers, # model parameters dry_run=False, **kwargs): # kwargs passed on to cdeint batch_size = 1024 lr = 0.0001 * (batch_size / 32) static_intensity = intensity # these models use the intensity for their evolution. They won't explicitly use it as an input unless we include it # via the use_intensity parameter, though. time_intensity = intensity or (model_name in ('odernn', 'dt', 'decay')) times, train_dataloader, val_dataloader, test_dataloader = datasets.sepsis.get_data( static_intensity, time_intensity, batch_size) input_channels = 1 + (1 + time_intensity) * 34 make_model = common.make_model(model_name, input_channels, 1, hidden_channels, hidden_hidden_channels, num_hidden_layers, use_intensity=intensity, initial=False) def new_make_model(): model, regularise = make_model() model.linear.weight.register_hook(lambda grad: 100 * grad) model.linear.bias.register_hook(lambda grad: 100 * grad) return InitialValueNetwork(intensity, hidden_channels, model), regularise if dry_run: name = None else: intensity_str = '_intensity' if intensity else '_nointensity' name = 'sepsis' + intensity_str num_classes = 2 return common.main(name, times, train_dataloader, val_dataloader, test_dataloader, device, new_make_model, num_classes, max_epochs, lr, kwargs, pos_weight=torch.tensor(pos_weight), step_mode=True)
def main( result_folder=None, # saving parameters result_subfolder=None, # epochs=1000, # training parameters num_shapelets_per_class=4, # model parameters num_shapelet_samples=None, # discrepancy_fn='L2', # max_shapelet_length_proportion=0.3, # num_continuous_samples=None, # initialization_proportion=None, ablation_pseudometric=True, # For ablation studies ablation_learntlengths=True, # ablation_similarreg=True, # old_shapelets=False, # Whether to toggle off all of our innovations and use old-style shapelets save_top_logreg_shapelets=False, save_on_uniform_grid=True): times, train_dataloader, val_dataloader, test_dataloader = get_data() input_channels = 40 num_classes = 10 return common.main(times, train_dataloader, val_dataloader, test_dataloader, num_classes, input_channels, result_folder, result_subfolder, epochs, num_shapelets_per_class, num_shapelet_samples, discrepancy_fn, max_shapelet_length_proportion, initialization_proportion, num_continuous_samples, ablation_pseudometric, ablation_learntlengths, ablation_similarreg, old_shapelets, save_top_logreg_shapelets, save_on_uniform_grid)
def main( dataset_name, # dataset parameters missing_rate=0., # noise_channels=0, # result_folder=None, # saving parameters result_subfolder='', # dataset_detail='', # epochs=250, # training parameters num_shapelets_per_class=3, # model parameters num_shapelet_samples=None, # discrepancy_fn='L2', # max_shapelet_length_proportion=1.0, # initialization_proportion=None, # Set to initialise shaplets at a desired fraction of length num_continuous_samples=None, # ablation_pseudometric=True, # For ablation studies ablation_learntlengths=True, # ablation_similarreg=True, # old_shapelets=False, # Whether to toggle off all of our innovations and use old-style shapelets save_top_logreg_shapelets=False, # True will save shapelets of the top logreg coefficients save_on_uniform_grid=False ): # Active if save_top_logreg_shapelets, will first sample onto a uniform grid times, train_dataloader, val_dataloader, test_dataloader, num_classes, input_channels = get_data( dataset_name, missing_rate, noise_channels) return common.main( times, train_dataloader, val_dataloader, test_dataloader, num_classes, input_channels, result_folder, _subfolder(dataset_name, dataset_detail, result_subfolder), epochs, num_shapelets_per_class, num_shapelet_samples, discrepancy_fn, max_shapelet_length_proportion, initialization_proportion, num_continuous_samples, ablation_pseudometric, ablation_learntlengths, ablation_similarreg, old_shapelets, save_top_logreg_shapelets, save_on_uniform_grid)
def make_regs(): if not os.path.exists('ttl/common'): common.main() if not os.path.exists('ttl/common/c-15'): os.mkdir('ttl/common/c-15') if not os.path.exists('ttl/common/c-15/ae'): os.mkdir('ttl/common/c-15/ae') if not os.path.exists('ttl/common/c-15/me'): os.mkdir('ttl/common/c-15/me') if not os.path.exists('ttl/common/c-15/oc'): os.mkdir('ttl/common/c-15/oc') with open('ttl/common/deprec_c-15.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write("""<c-15> a reg:Register , ldp:Container ; rdfs:label "Physical quantities"@en ; dct:description "WMO No. 306 Vol I.2 Common Code-table C-15 'Physical quantities'."@en ; reg:owner <http://codes.wmo.int/system/organization/wmo> ; reg:manager <http://codes.wmo.int/system/organization/www-dm> ; . """) with open('ttl/common/c-15/deprec_ae.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write("""<ae> a reg:Register , ldp:Container ; rdfs:label "Physical quantities - aeronautical meteorology discipline"@en ; dct:description "WMO No. 306 Vol I.2 Common Code-table C-15 'Physical quantities - aeronautical meteorology discipline'."@en ; reg:owner <http://codes.wmo.int/system/organization/wmo> ; reg:manager <http://codes.wmo.int/system/organization/www-dm> ; . """) with open('ttl/common/c-15/deprec_me.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write("""<me> a reg:Register , ldp:Container ; rdfs:label "Physical quantities - meteorology discipline"@en ; dct:description "WMO No. 306 Vol I.2 Common Code-table C-15 'Physical quantities - meteorology discipline'."@en ; reg:owner <http://codes.wmo.int/system/organization/wmo> ; reg:manager <http://codes.wmo.int/system/organization/www-dm> ; . """) with open('ttl/common/c-15/deprec_oc.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write("""<oc> a reg:Register , ldp:Container ; rdfs:label "Physical quantities - oceanography discipline"@en ; dct:description "WMO No. 306 Vol I.2 Common Code-table C-15 'Physical quantities - oceanography discipline'."@en ; reg:owner <http://codes.wmo.int/system/organization/wmo> ; reg:manager <http://codes.wmo.int/system/organization/www-dm> ; . """)
def main( dataset_name, missing_rate=0.3, # dataset parameters device='cuda', max_epochs=1000, *, # training parameters model_name, hidden_channels, hidden_hidden_channels, num_hidden_layers, # model parameters dry_run=False, **kwargs): # kwargs passed on to cdeint batch_size = 32 lr = 0.001 * (batch_size / 32) # Need the intensity data to know how long to evolve for in between observations, but the model doesn't otherwise # use it because of use_intensity=False below. intensity_data = True if model_name in ('odernn', 'dt', 'decay') else False (times, train_dataloader, val_dataloader, test_dataloader, num_classes, input_channels) = datasets.uea.get_data(dataset_name, missing_rate, device, intensity=intensity_data, batch_size=batch_size) if num_classes == 2: output_channels = 1 else: output_channels = num_classes make_model = common.make_model(model_name, input_channels, output_channels, hidden_channels, hidden_hidden_channels, num_hidden_layers, use_intensity=False, initial=True) if dry_run: name = None else: name = dataset_name + str(int(missing_rate * 100)) return common.main(name, times, train_dataloader, val_dataloader, test_dataloader, device, make_model, num_classes, max_epochs, lr, kwargs, step_mode=False)
def main(): prs = argparse.ArgumentParser(description='Train/test DNS rec. server model: Decision Tree') prs.add_argument('--viz', help='store Graphviz representation in given path') args, cls, names = common.main(prs, train, common.load, common.test) if args.viz: tree.export_graphviz(cls, args.viz, feature_names=names, class_names=["ok", "hijack"], filled=True, impurity=False)
def file_write(members, member_elements): if not os.path.exists('ttl/common'): common.main() # os.mkdir('ttl/common') # with open('ttl/common.ttl', 'w') as fhandle: # fhandle.write(ttlhead) # fhandle.write('<common> a reg:Register ;\n') # fhandle.write('\trdfs:label "WMO No. 306 Vol I.2 common concepts" ;\n') # fhandle.write('\tdc:description "Register of concepts common across WMO No. 306 Vol I.2 formats"@en ;\n') # fhandle.write('\treg:owner <http://codes.wmo.int/system/organization/wmo> ;\n') # fhandle.write('\tdct:publisher <http://codes.wmo.int/system/organization/wmo> ;\n') # fhandle.write('\treg:manager <http://codes.wmo.int/system/organization/www-dm> ;\n') # fhandle.write('\t.\n') with open('ttl/common/bulk_c6.ttl', 'w') as fhandle: fhandle.write(ttlhead) fhandle.write('<unit> a skos:Collection ;\n') fhandle.write( '\trdfs:label "Code Table C-6: List of units for TDCFs"@en ;\n' ) fhandle.write( '\tdct:description "WMO No. 306 Vol I.2 Common Code-table C-6 List of units for TDCFs."@en ;\n' ) fhandle.write('\tskos:notation "C-6" ;\n') fhandle.write( '\treg:manager <http://codes.wmo.int/system/organization/www-dm> ;\n' ) fhandle.write( '\treg:owner <http://codes.wmo.int/system/organization/wmo> ;\n' ) fhandle.write('\tskos:member ') fhandle.write(', '.join(members)) fhandle.write('\t.\n\n') fhandle.write('\n'.join(member_elements))
def main( device='cuda', max_epochs=200, *, # training parameters model_name, hidden_channels, hidden_hidden_channels, num_hidden_layers, # model parameters dry_run=False, **kwargs): # kwargs passed on to cdeint batch_size = 1024 lr = 0.00005 * (batch_size / 32) intensity_data = True if model_name in ('odernn', 'dt', 'decay') else False times, train_dataloader, val_dataloader, test_dataloader = datasets.speech_commands.get_data( intensity_data, batch_size) input_channels = 1 + (1 + intensity_data) * 20 make_model = common.make_model(model_name, input_channels, 10, hidden_channels, hidden_hidden_channels, num_hidden_layers, use_intensity=False, initial=True) def new_make_model(): model, regularise = make_model() model.linear.weight.register_hook(lambda grad: 100 * grad) model.linear.bias.register_hook(lambda grad: 100 * grad) return model, regularise name = None if dry_run else 'speech_commands' num_classes = 10 return common.main(name, times, train_dataloader, val_dataloader, test_dataloader, device, new_make_model, num_classes, max_epochs, lr, kwargs, step_mode=True)
#!/usr/bin/env pypy import common if __name__ == "__main__": common.main(common.uct, common.SearchTree())
#!/usr/bin/python # returns number of songs for each artist import common import json import re # input: file name # output: artist_id artist_name def map(line): line_split=re.split("\t",line) track_id=line_split[0] track_data=json.loads(line_split[1]) tempo=track_data["tempo"] artist_id=track_data["artist_id"] artist_name=track_data["artist_name"] yield(artist_id,artist_name) def reduce(word, counts): count=0 for artist in counts: count=count+1 yield(counts[0],str(count)) if __name__ == "__main__": common.main(map, reduce)
def main(): common.main( run=run_vm, plot=plot_vm, )
#!/usr/bin/python import numpy as np from common import main def fft(x): N = len(x) if N <= 1: return x even = fft(x[0::2]) odd = fft(x[1::2]) M = N / 2 rhs = np.exp(-2j*np.pi/N * np.arange(M)) * odd l = even + rhs r = even - rhs return np.concatenate([l, r]) def setup(N): return np.arange(N, dtype='complex'), if __name__ == "__main__": main(fft, setup)
treble_pattern = Staff() chords = Staff(context_name='ChordNames') for key in sideman.keys_in_order(): jazz_scale = sideman.JazzScale(key) treble_pattern.append( get_pattern_n19(jazz_scale) ) chords.append( get_pattern_n19_chord_measure(jazz_scale) ) score = Score([chords, treble_pattern]) tempo = Tempo(Duration(1, 4), (80, 132)) attach(tempo, treble_pattern) return score def title(): return "Jazz Pattern 19" def composer(): return "Jerry Greene et al, Thiruvathukal" def pdf(): return "jazz019.pdf" def midi(): return "jazz019.midi" if __name__ == '__main__': score = get_score() common.main( score, title(), composer(), pdf()) common.main( score, title(), composer(), midi())
def get_score(): treble_pattern = Staff() chords = Staff(context_name='ChordNames') for key in sideman.keys_in_order(): jazz_scale = sideman.JazzScale(key) treble_pattern.append( get_pattern3(jazz_scale) ) chords.append( get_pattern3_chord_measure(jazz_scale) ) score = Score([chords, treble_pattern]) tempo = Tempo(Duration(1, 4), (80, 132)) attach(tempo, treble_pattern) return score def title(): return "Jazz Pattern 3" def composer(): return "Jerry Greene et al, Thiruvathukal" def pdf(): return "jazz003.pdf" def midi(): return "jazz003.midi" if __name__ == '__main__': score = get_score() common.main( score, title(), composer(), pdf()) common.main( score, title(), composer(), midi())
threads = [] for i in range(common.PARALLEL_COUNT): threads.append( SearchThread(root_state, iter_max / common.PARALLEL_COUNT, search_tree)) for t in threads: t.start() for t in threads: t.join() root_node = SearchNode(tree_node=search_tree.get_node(root_state)) selected_node = root_node.uct_select_child(0.0) print "Nodes generated:", str(search_tree.size() - node_count) print print root_node.children2string() root_node.clean_sub_tree(selected_node, search_tree) print "Nodes remainning:", str(search_tree.size()) print return selected_node.move if __name__ == "__main__": common.main(uct, SearchTree())
# The browser to use BROWSER = "Chrome" # Get list of useragents to use useragents = getUseragents() def setUpWebdriver(browser, agent): """Set up the webdriver that will be used for the automation.""" if (browser == "Firefox"): profile = webdriver.FirefoxProfile() profile.set_preference("general.useragent.override", agent) driver = webdriver.Firefox(firefox_profile=profile) elif (browser == "Chrome"): options = webdriver.ChromeOptions() options.add_argument("--user-agent='" + agent + "'") driver = webdriver.Chrome(chrome_options=options) else: print() raise TypeError("ERROR - unknown browser:", browser) return driver if __name__ == '__main__': for useragent in useragents: driver = setUpWebdriver(BROWSER, useragent[0]) main(driver, BROWSER, useragent)
import sys import common if __name__ == '__main__': try: backend = common.choose_backend(sys.argv[1]) filename = sys.argv[2] except (KeyError, IndexError) as e: print(e) print("Usage: python %s <numba|numbapro|numpy> <recorded_file>" % sys.argv[0]) else: print("Click on the screen to plunk the string.") print("Y-axis: top -- lighter; bottom -- heavier") print("X-axis: position") common.main(backend.physics, filename)
senttokens = list() for tok in sent.split("\n"): token, tag = tok.split("\t") stts = rftag2stts(tag) senttokens.append( Token(word=token, xpos=stts, feats=str(Morph.from_rftag(tag)))) self.data.append(Sentence(senttokens)) class UDPipe(TestSystem): pass # TODO if __name__ == "__main__": main( # "tokens", "pos", [ StanfordNLP, RFTagger, TreeTagger, RNNTagger, SoMeWeTa, CoreNLP, Clevertagger, Spacy, ], )
#!/usr/bin/env pypy import common if __name__ == "__main__": common.main(common.uct)
workers = [] for i in range(common.PARALLEL_COUNT): w = SearchWorker(root_state, iter_max / common.PARALLEL_COUNT, multiprocessing.Queue()); workers.append(w); for w in workers: w.start() for w in workers: w.join() results = [w.get_result() for w in workers] values = collections.defaultdict(float) for r in results: for (move, value) in r[0].items(): values[move] += value print "Nodes generated:", sum([r[1] for r in results]) print for (k, v) in values.items(): print "%s: %.3f" % (str(k), v / common.PARALLEL_COUNT) print return max(values.items(), key=lambda (k, v): v)[0] if __name__ == "__main__": common.main(uct, None)
import common if __name__ == '__main__': common.main(common.args, model_type='s_ibp_bbvi')
(os.path.join(self.build_dir, 'regression.xml')), '' if not toolset_to_test else 'toolset=%s' % (toolset_to_test), '' if not self.address_model else 'address-model=%s' % (self.address_model), 'variant=%s' % (self.variant), '--test-type=%s' % (self.target), '--verbose-test') # Generate a readable test report. import build_log log_main = build_log.Main([ '--output=console', os.path.join(self.build_dir, 'regression.xml') ]) # And exit with an error if the report contains failures. # This lets the CI notice the error and report a failed build. # And hence trigger the failure machinery, like sending emails. if log_main.failed: self.ci.finish(-1) def command_before_cache(self): script_common.command_before_cache(self) os.chdir(self.boost_root) utils.check_call("git", "clean", "-dfqx") utils.check_call("git", "submodule", "--quiet", "foreach", "git", "clean", "-dfqx") utils.check_call("git", "status", "-bs") utils.check_call("git", "submodule", "foreach", "git", "status", "-bs") main(script)
def euler(cls, drs): """ Return the result of Euler algorithm for `drs`. The arguments `drs` is a list of 2-tuples, each being a divisor and the required reminder. The method returns the smallest number that when divided by each divisor gives its corresponding reminder. The method is based on Euler's article that can be found [here](http://eulerarchive.maa.org/docs/translations/E036en.pdf). The algorithm can be generalised for more than 2 numbers, but it is quite fast this way, so I leave the optimisation to the reader. O:-) :param drs: An iterable of 2-tuples, each being a divisor and its required reminder. :return: The smallest nonnegative integer that divided by each of the divisors in `drs` gives their respective reminders. """ while len(drs) > 1: drs = drs[:-2] + [cls._euler2(*drs[-1], *drs[-2])] return drs[0][1] def part2(self): return self.euler([(bus, -idx % bus) for idx, bus in enumerate(self.buses) if bus]) if __name__ == "__main__": main(Day13)
steps, elevator, state = agenda[curmin].pop() if all(b == 3 for b in state): return steps onfloor = [a for a, b in enumerate(state) if b == elevator] for comb in itertools.chain( ((a, ) for a in onfloor), itertools.combinations(onfloor, 2)): for dir in (1, -1): if 0 <= elevator + dir <= 3: newstate = [b + dir * (a in comb) for a, b in enumerate(state)] if legal(newstate) and srepr( elevator + dir, newstate) not in seen: seen.add(srepr(elevator + dir, newstate)) est = estimate(elevator, newstate) + steps + 1 agenda[est].append(( steps + 1, elevator + dir, newstate)) if curmin > est: curmin = est def day11b(s): lines = s.splitlines() lines[0] += ' elerium generator elerium-compatible microchip' lines[0] += ' dilithium generator dilithium-compatible microchip' return day11a('\n'.join(lines)) if __name__ == '__main__': main(globals())
def construct(args): network = NetworkMelody(args) with network.session.graph.as_default(): spectrogram_function, spectrogram_thumb, spectrogram_info = common.spectrograms(args) # save spectrogram_thumb to hyperparams args.spectrogram_thumb = spectrogram_thumb hop_samples = args.frame_width*args.samplerate/44100 print("hop_samples", hop_samples) def preload_fn(aa): aa.annotation = datasets.Annotation.from_time_series(*aa.annotation, hop_samples=hop_samples) aa.audio.load_resampled_audio(args.samplerate).load_spectrogram(spectrogram_function, spectrogram_thumb, spectrogram_info[2]) def dataset_transform(tf_dataset, dataset): return tf_dataset.map(dataset.prepare_example, num_parallel_calls=args.threads).batch(args.batch_size_evaluation).prefetch(10) def dataset_transform_train(tf_dataset, dataset): return tf_dataset.shuffle(10**5).map(dataset.prepare_example, num_parallel_calls=args.threads).batch(args.batch_size).prefetch(10) valid_hooks = [MetricsHook(), VisualOutputHook(False, False, True, True), SaveBestModelHook(args.logdir), CSVOutputWriterHook(), AdjustVoicingHook()] train_dataset, test_datasets, validation_datasets = common.prepare_datasets(args.datasets, args, preload_fn, dataset_transform, dataset_transform_train, valid_hooks=valid_hooks) network.construct(args, create_model, train_dataset.dataset.output_types, train_dataset.dataset.output_shapes, spectrogram_info=spectrogram_info) return network, train_dataset, validation_datasets, test_datasets if __name__ == "__main__": common.main(sys.argv[1:], construct, parse_args)
review_changes.append(change) if not review_changes: error("No files selected") return review_changes = merge_changes(review_changes) self.start_busy() try: self.upload_changes(review_changes) finally: self.end_busy() def OnSelectAll(self, evt): for i in range(self._files.GetCount()): self._files.Check(i, 1) def OnUnselectAll(self, evt): for i in range(self._files.GetCount()): self._files.Check(i, 0) def OnInvertSelection(self, evt): for i in range(self._files.GetCount()): self._files.Check(i, not self._files.IsChecked(i)) if __name__ == "__main__": main(UCMCC)
('Alternate email', user.alternate_email) if user.alternate_email else None, ('Alternate phone', user.alternate_phone) if user.alternate_phone else None, ('Created', "%s by %s" % (common.last_modified_date(user.created_date), user.created_by)), ('Last modified', "%s by %s using %s" % (common.last_modified_date(user.lastmod_datetime), user.lastmod_by, user.lastmod_with)), ) def show_ownerships(): """Handle 'mruser ownerships'.""" user = User(client, args.user) ownership.show_ownerships(client, args, user) def setup_subcommands(argparser): """Sets up all the subcommands.""" subparsers = argparser.add_subparsers() parser_info = subparsers.add_parser('info', help = 'Provide the information about the user') parser_info.add_argument('user', help = 'The user to inspect') parser_ownerships = subparsers.add_parser('ownerships', help = 'Show items which this user owns') parser_ownerships.add_argument('user', help = 'The name of the user to show information about') parser_ownerships.add_argument('-r', '--recursive', action = 'store_true', help = 'Show items which this user own through being in lists') parser_info.set_defaults(handler = show_info) parser_ownerships.set_defaults(handler = show_ownerships) if __name__ == '__main__': client, args = common.init('mruser', 'Inspect Moira users', setup_subcommands) common.main()
def gateway_initialize(): common.main()
example=1.5), 'strlen': fields.String(required=True, description='length limited str', max_length=4, min_length=2, example="exs"), 'listlen': fields.List(fields.String, required=True, description='length limited list', max_length=4, min_length=2, example=["some", "strings", "here"]), }) @example_ns.route('/<int:exint>') class ExampleResource(Resource): @api.expect(ExampleObj) @api.response(204, 'App successfully updated.') def put(self, exint): """Takes in data""" log.debug("Got parameter: %r", exint) log.debug("Got body: %r", request.data) return None, 204 if __name__ == '__main__': main(os.path.splitext(os.path.basename(__file__))[0] + '.json')
#!/usr/bin/python from cmath import exp, pi from common import main def fft(x): N = len(x) if N <= 1: return x even = fft(x[0::2]) odd = fft(x[1::2]) M = N / 2 expBase = -2j*pi/N l = [even[k] + exp(expBase*k) * odd[k] for k in xrange(M)] r = [even[k] - exp(expBase*k) * odd[k] for k in xrange(M)] return l + r if __name__ == "__main__": main(fft)
xpos, feats, head, deprel, deps, misc, ) = tok.split("\t") mytokens.append( Token( id=index, word=word, lemma=lemma, # don't write out gold pos # upos=upos, xpos=xpos, feats=str(Morph.from_parzu(xpos + "|" + feats)), head=head, deprel=deprel, deps=deps, misc=misc, )) self.data.append(Sentence(mytokens)) class UDPipe(TestSystem): # maybe pass if __name__ == "__main__": main("depparse", [CoreNLP, ParZu, Spacy, StanfordNLP])
'--dump-tests', '--verbose-test', '--build-dir=%s'%(self.build_dir), '--out-xml=%s'%(os.path.join(self.build_dir,'regression.xml')), '' if not toolset_to_test else 'toolset=%s'%(toolset_to_test), '' if not self.address_model else 'address-model=%s'%(self.address_model), 'variant=%s'%(self.variant), self.target ) # Generate a readable test report. import build_log log_main = build_log.Main([ '--output=console', os.path.join(self.build_dir,'regression.xml')]) # And exit with an error if the report contains failures. # This lets the CI notice the error and report a failed build. # And hence trigger the failure machinery, like sending emails. if log_main.failed: self.ci.finish(-1) def command_before_cache(self): script_common.command_before_cache(self) os.chdir(self.b2_dir) utils.check_call("git","clean","-dfqx") utils.check_call("git","status","-bs") # utils.check_call("git","submodule","--quiet","foreach","git","clean","-dfqx") # utils.check_call("git","submodule","foreach","git","status","-bs") main(script)
import common import os import cPickle as pickle class SearchTree(common.SearchTree): file_name = "search_tree.pkl" def __init__(self): common.SearchTree.__init__(self) if os.path.exists(self.file_name): try: with open(self.file_name, "r") as f: self.__pool = pickle.load(f) except pickle.PickleError: self.__pool = {} else: self.__pool = {} def dump(self): with open(self.file_name, "w") as f: pickle.dump(self.__pool, f) def clean_sub_tree(self, root_node, ignore_node): pass if __name__ == "__main__": tree = SearchTree() common.main(common.uct, tree) tree.dump()
scale = sideman.get_scale(key, 'major') pattern_measure = get_pattern_n77(scale) chord_measure = get_pattern_n77_chords(scale) treble_pattern.append(pattern_measure) chords.append(chord_measure) tempo = Tempo(Duration(1, 4), (100, 138)) attach(tempo, treble_pattern) score = Score([chords, treble_pattern]) return score def title(): return "Jazz Pattern 77" def composer(): return "Jerry Greene et al, Thiruvathukal" def pdf(): return "jazz77.pdf" def midi(): return "jazz77.midi" if __name__ == '__main__': common.main(get_score(), title(), composer(), pdf()) common.main(get_score(), title(), composer(), midi())
if not baseline: return view = self._view.GetStringSelection() baseline = baseline.replace("(", "") baseline = baseline.replace(")", "") name, owner, date = baseline.split() activities = get_baseline_activities_progress(view, name) activitires_str = "\t" + "\n\t".join(activities) messageDialog( self, BASELINE_TEMPLATE % (name, owner, date, activitires_str), "Baseline Information for %s" % name, wx.OK) def add_text(self, sizer, caption): text = wx.StaticText(self, -1, "%s:" % caption) sizer.Add(text, 0, wx.ALIGN_CENTER_VERTICAL) def add_combo(self, sizer, choices=None): if choices is None: choices = [] combo = wx.ComboBox(self, -1, choices=choices, style=wx.CB_READONLY, size=(500, -1)) sizer.Add(combo, 0, wx.EXPAND) return combo if __name__ == "__main__": main(UCMCCBaseline)
def main(): common.main(widget=StatusWidget, window_name='Item/Widget')
def myprocessor(myinput): mydoc = string2doc(myinput) for sent in mydoc: for tok in sent: try: matching_lemmas = self.lemmatizer.lemmatize( tok.word, conv_table.get(tok.xpos)) if matching_lemmas is None: tok.lemma = "_" # elif len(matching_lemmas) > 1: # print("lots o lemmas!", matching_lemmas) else: # unclear how to select best alternative # just use first item in list tok.lemma = matching_lemmas[0] except ValueError: tok.lemma = "_" # don't repeat gold pos in output tok.hide_fields(HIDDEN_FIELDS) return mydoc self.processor = myprocessor def postprocess(self): self.data = doc2string(self.output_data) if __name__ == "__main__": main("lemmas", [GermaLemma, CustomLemmatizer, IWNLP])
def main(): common.main(widget=StatusView, window_name='Model/View')
return measure def get_score(): treble_pattern = Staff() chords = Staff(context_name='ChordNames') for key in sideman.keys_in_fifths(): jazz_scale = sideman.JazzScale(key) treble_pattern.append( get_pattern2(jazz_scale) ) chords.append( get_pattern2_chord_measure(jazz_scale) ) score = Score([chords, treble_pattern]) tempo = Tempo(Duration(1, 4), (80, 132)) attach(tempo, treble_pattern) return score def title(): return "Jazz Pattern 2" def composer(): return "Jerry Greene et al, Thiruvathukal" def pdf(): return "jazz002.pdf" def midi(): return "jazz002.midi" if __name__ == '__main__': common.main( get_score(), title(), composer(), pdf()) common.main( get_score(), title(), composer(), midi())
#!/usr/bin/python # find song with highest variance in loudness import common import json import re # input: file name # output: artist_id artist_name def map(line): line_split = re.split("\t", line) track_id = line_split[0] track_data = json.loads(line_split[1]) loudness_variance = track_data["segment_loudness_variance"] variance_string = "%010.6f" % loudness_variance track_name = track_data["title"] artist_name = track_data["artist_name"] yield (variance_string, artist_name + " -- " + track_name) def reduce(word, counts): pass if __name__ == "__main__": common.main(map, reduce)
) # Instanciate glanceclient and retrieve the list of images glanceclient = client_manager.image marker = None kwargs = {} image_list = [] while True: page = glanceclient.api.image_list(marker=marker, **kwargs) if not page: break image_list.extend(page) # Set the marker to the id of the last item we received marker = page[-1]['id'] LOG.info("Found {0} image(s).".format(str(len(image_list)))) for image in image_list: migrate_image(glanceclient, image['id']) if __name__ == "__main__": parser = argparse.ArgumentParser( description='Glance image backend migration' ) opts = common.base_parser( clientmanager.build_plugin_option_parser(parser), ).parse_args() common.configure_logging(opts) sys.exit(common.main(opts, main))
test = common.Test() test.show() box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) test.pack_start(box, True, True, 0) box.show() toolbar_box = ToolbarBox() box.pack_start(toolbar_box, False, False, 0) toolbar_box.show() separator = Gtk.SeparatorToolItem() toolbar_box.toolbar.insert(separator, -1) separator.show() def color_changed_cb(button, pspec): print button.get_color() color_button = ColorToolButton() color_button.connect("notify::color", color_changed_cb) toolbar_box.toolbar.insert(color_button, -1) color_button.show() if __name__ == '__main__': common.main(test)
Assumes 2 alternating players (player 1 starts), with game results in the range [0.0, 1.0].""" node_count = search_tree.size() threads = [] for i in range(common.PARALLEL_COUNT): threads.append(SearchThread(root_state, iter_max / common.PARALLEL_COUNT, search_tree)) for t in threads: t.start() for t in threads: t.join() root_node = SearchNode(tree_node=search_tree.get_node(root_state)) selected_node = root_node.uct_select_child(0.0) print "Nodes generated:", str(search_tree.size() - node_count) print print root_node.children2string() root_node.clean_sub_tree(selected_node, search_tree) print "Nodes remainning:", str(search_tree.size()) print return selected_node.move if __name__ == "__main__": common.main(uct, SearchTree())
# Do useful things with it # Look in the object store c_list = client_manager.object_store.container_list() print("Name\tCount\tBytes") for c in c_list: print("%s\t%d\t%d" % (c['name'], c['count'], c['bytes'])) if len(c_list) > 0: # See what is in the first container o_list = client_manager.object_store.object_list(c_list[0]['name']) print("\nObject") for o in o_list: print("%s" % o) # Look at the compute flavors flavor_list = client_manager.compute.flavors.list() print("\nFlavors:") for f in flavor_list: print("%s" % f) if __name__ == "__main__": parser = argparse.ArgumentParser(description='ClientManager Example') opts = common.base_parser( clientmanager.build_plugin_option_parser(parser), ).parse_args() common.configure_logging(opts) sys.exit(common.main(opts, run))
score = Score([chords, voicing, bass_pattern]) return score def title(key_name): return "II-V-I Progression (starting in %s), Piano" % key_name def composer(): return "Not Specified" def pdf(key_name): return "progression001-%s.pdf" % key_name.lower() def midi(key_name): return "progression001-%s.midi" % key_name.lower() if __name__ == '__main__': parser = argparse.ArgumentParser(description="compute the II-V-I progression exercise in C or F") group = parser.add_mutually_exclusive_group() group.add_argument("-c", "--key_of_c", action="store_true") group.add_argument("-f", "--key_of_f", action="store_true") args = parser.parse_args() key_name = 'f' if args.key_of_f else 'c' key_name = key_name.upper() print("Creating II-V-I in key of %s" % key_name) score = get_score(key_name) common.main( score, title(key_name), composer(), pdf(key_name)) common.main( score, title(key_name), composer(), midi(key_name))