def setUp(self): super(TestRedirectionToDeclaration, self).setUp() name = type(self).__name__ private_h = Header("private.h") private_h.add_type(Structure("Private")) public_h = Header("public.h") public_h.add_types([ Type["Private"].gen_forward_declaration(), Function("public_func") ]) private_c = Source("private.c") public_func_impl = Type["public_func"].gen_definition() private_c.add_type(public_func_impl) src = Source(name.lower() + ".c").add_global_variable( # It must internally re-direct pointer from type "Private" # to "Private.declaration", its forward declaration. Pointer(Type["Private"])("handler")) src.add_type(Pointer(public_func_impl, name="cb_ptr")) src_content = """\ /* %s */ #include "public.h" typedef void (*cb_ptr)(void); Private *handler __attribute__((unused)); """ % (name.lower() + ".c") self.files = [(src, src_content)]
def run(): """ Create the objects source for Sirio, Vega and Proxima as well as the corresponding scanners and the satellite object of Gaia. Then scan the sources from Gaia and print the time. :return: gaia, sirio, scanSirio, vega, scanVega, proxima, scanProxima """ start_time = time.time() sirio = Source("sirio", 101.28, -16.7161, 379.21, -546.05, -1223.14, -7.6) vega = Source("vega", 279.2333, 38.78, 128.91, 201.03, 286.23, -13.9) proxima = Source("proxima", 217.42, -62, 768.7, 3775.40, 769.33, 21.7) scanSirio = Scanner(np.radians(20), np.radians(2)) scanVega = Scanner(np.radians(20), np.radians(2)) scanProxima = Scanner(np.radians(20), np.radians(2)) gaia = Satellite() print(time.time() - start_time) scanSirio.start(gaia, sirio) scanVega.start(gaia, vega) scanProxima.start(gaia, proxima) print(time.time() - start_time) seconds = time.time() - start_time print('Total seconds:', seconds) return gaia, sirio, scanSirio, vega, scanVega, proxima, scanProxima
def test_handles_no_matches(self): p = Parser() m = Meme("all your * -base") s = [ Source("", "foo", ""), Source("", "bar", ""), Source("", "baz", "") ] self.assertEqual(p.collate_words(m, s).get_list(), [])
def test_collates_words(self): p = Parser() m = Meme("all your * -base") s = [ Source("", "all your cake", ""), Source("", "all your cake", ""), Source("", "all your data", "") ] self.assertEqual( p.collate_words(m, s).get_list(), [("cake", 2), ("data", 1)])
def main(args): #print (args) result = { 'is_success': True, 'data': None, #'foo': '中文', } if args.action == 'upload-image' and args.db_file and args.resource_id: src = Source('database', name=args.db_file) res = src.upload_image(args.resource_id) result['data'] = res elif args.action == 'update-source-description' and args.db_file and args.resource_id and args.value: src = Source('database', name=args.db_file) res = src.update_description(args.resource_id, args.value) result['result'] = { 'source_id': args.resource_id, 'value': args.value, 'text': 'update ok', 'sql': res } elif args.action == 'poll-source-status' and args.db_file and args.resource_id: src = Source('database', name=args.db_file) res = src.poll_source_status(args.resource_id) result['data'] = res elif args.action == 'batch-upload' and args.resource_id and args.ini_file and args.db_file: src = Source('database', name=args.db_file) config = Config(args.ini_file) res = src.batch_upload(config.get_config(), args.resource_id) if res: result['data'] = res else: result['is_success'] = False elif args.action == 'get-config' or \ (args.ini_file and not args.set_config_value): config = Config(args.ini_file) res = config.get_config() result['data'] = res elif args.action == 'set-config' or \ (args.ini_file and args.set_config_value): if sov := args.set_conifg_value.split(':'): # check input value if len(sov) < 3 or sov[1] == '': result['error'] = 'section:option:value syntax error' return result else: config = Config(args.ini_file) res = config.set_config(sov[0], sov[1], sov[2]) result['data'] = res
def setUp(self): super(TestOptimizeInclusions, self).setUp() name = type(self).__name__ src = Source(name.lower() + ".c") ah = Header("a.h") bh = Header("b.h") ch = Header("c.h") ah.add_type(Type("a")) bh.add_type(Type("b")).add_reference(Type["a"]) ch.add_type(Type("c")).add_reference(Type["b"]).add_inclusion(ah) src.add_type(Pointer(Type["c"], "cpointer")) # c.h includes a.h but inclusion of a.h cannot be substituted with c.h # inclusion because it creating reference loop between inclusions of # c.h and b.h. This test checks inclusions optimization correctness and # ordering of chunks. src_content = """\ /* {} */ #include "a.h" #include "b.h" #include "c.h" typedef c *cpointer; """.format(src.path) self.files = [(src, src_content)]
def sample(self): """ Method to pick the sample satisfying the likelihood constraint using uniform sampling Returns ------- new : object The evolved sample number : int Number of likelihood calculations after sampling """ new = Source() x_l, x_u = self.getPrior_X() y_l, y_u = self.getPrior_Y() r_l, r_u = self.getPrior_R() a_l, a_u = self.getPrior_A() while (True): new.X = np.random.uniform(x_l, x_u) new.Y = np.random.uniform(y_l, y_u) new.A = np.random.uniform(a_l, a_u) new.R = np.random.uniform(r_l, r_u) new.logL = self.log_likelihood(new) self.number += 1 if (new.logL > self.LC): break return new, self.number
def __get_source(self): fname = self.__get_filename() if SourceMap.sources.has_key(fname): return SourceMap.sources[fname] else: SourceMap.sources[fname] = Source(fname) return SourceMap.sources[fname]
def _recognition(self): # Colocando no banco de dados text = [] # Para cada arquivo, um reconhecimento for i in range(self.count): # Informando qual reconhecimento está sendo realizado self.label_recognition.text = f'Reconhecimento {i+1} de {self.count}' # Lendo o arquivo de aúdio audio = self.recog.read_file(f'{self.filename}-{i}.wav') # Fazendo o STT text_recognition = self.recog.recognize_speech(audio) text.append(text_recognition) sleep(0.1) self.label_recognition.text = "Reconhecimento concluído, salvando o arquivos" organizator = Source() organizator.delete() # Definindo o meu dia atual now = datetime.now() dia_atual = f'{now.day}-{now.month}-{now.year}' # Definindo nome name = self.filename.replace('tmp/', '').replace(dia_atual ,'').replace('-', '') organizator.constructor(f'{dia_atual}-{str(now.hour)}-{str(now.minute)}', name, text) self.remove_widget(self.layout) self.add_widget(Initial())
def setUp(self): super(TestSeparateCases, self).setUp() src = Source(type(self).__name__.lower() + ".c") i = Type["int"]("i") src.add_type( Function(name="func_a", body=BodyTree()(Declare(OpDeclareAssign(i, 0)), BranchSwitch(i, separate_cases=True)( SwitchCase(1), SwitchCase(2))))) src_content = """\ /* {} */ void func_a(void) {{ int i = 0; switch (i) {{ case 1: break; case 2: break; default: break; }} }} """.format(src.path) self.files = [(src, src_content)]
def setUp(self): super(TestForwardDeclaration, self).setUp() name = type(self).__name__ src = Source(name.lower() + ".c") a = Structure("A") a.append_field(Pointer(a)("next")) b = Structure("B") b.append_field(Pointer(a)("next")) src.add_types([a, b]) src_content = """\ /* {} */ typedef struct A A; struct A {{ A *next; }}; typedef struct B {{ A *next; }} B; """.format(src.path) self.files = [(src, src_content)]
def setUp(self): super(TestCrossDeclaration, self).setUp() src = Source(type(self).__name__.lower() + ".c") a = Structure("A") b = Structure("B") b.append_field(Pointer(a)("ref")) a.append_field(Pointer(b)("ref")) src.add_types([a, b]) src_content = """\ /* {} */ typedef struct B B; typedef struct A {{ B *ref; }} A; struct B {{ A *ref; }}; """.format(src.path) self.files = [(src, src_content)]
def addSource(self, x, y): self.state['sourceXIndices'].append(x) self.state['sourceYIndices'].append(y) self.state['sourcesPoints'].append((x, y)) self.state['sources'].append( Source(self.canvas, (x + 1) * (self.width / 8), (y + 1) * (self.height / 8)))
def setup_source(self, x, y, source_image, source_size, to_intersection, car_images, car_size, generative=True, spawn_delay=4.0): ''' Sets up a Source, which is an Intersection. ''' s = Sprite(source_image, source_size) s.move_to(x=x, y=self.height - y) source = Source(x, y, None, None, self, car_images, car_size, spawn_delay=spawn_delay, generative=generative) road = self.setup_road(source, to_intersection, 'road.bmp') source.road = road source.length_along_road = road.length self.source_set.add(source) self.window.add_sprite(s) return source
def __init__(self, words, source, **kwargs): super().__init__(**kwargs) self.words = words.split(' ') self.src = source # Criando os componentes self.source = Source() self.layout = BoxLayout(orientation='vertical') self.clear_widgets() results = self.search() if results != []: for result in results: title = Label(text=result['title'], font_size=30, size_hint_y=None, height=40) time = Label(text=result['time'], font_size=20, size_hint_y=None, height=40) phrarse = Label(text=result['phrarse'], font_size=15, size_hint_y=None, height=40) separator = Label(text='-----------------------------------------------', font_size=60, size_hint_y=None, height=20) self.layout.add_widget(title) self.layout.add_widget(time) self.layout.add_widget(phrarse) self.layout.add_widget(separator) self.add_widget(self.layout)
def setUp(self): super(TestLabelAndGotoGeneration, self).setUp() name = type(self).__name__ src = Source(name.lower() + ".c") lbl = Label("begin") i = Type["int"]("i") src.add_type( Function(name="main", body=BodyTree()(Declare(i), lbl, OpAssign(i, OpAdd(i, 1)), Goto(lbl)))) src_content = """\ /* {} */ void main(void) {{ int i; begin: i = i + 1; goto begin; }} """.format(src.path) self.files = [(src, src_content)]
def find_live(): # TODO refactor this mess rm = visa.ResourceManager() for res in rm.list_resources(): try: print(f'trying: {res}') inst = rm.open_resource(res) answer = inst.query('*IDN?') model = answer.split(',')[1].strip() print(model, self._generatorList) if model == 'E3648A': # if model == 'E3631A': self._source = Source(res, answer, inst) print('>>> source') # elif 'N5183A' in answer: # self._generator1 = Generator(res, answer, inst) elif model in self._generatorList: if not self._generator1: self._generator1 = Generator(res, answer, inst) print('>>> gen1') else: self._generator2 = Generator(res, answer, inst) print('>>> gen2') elif model == 'N9030A': self._analyzer = Analyzer(res, answer, inst) print('>>> analyzer') except Exception as ex: print(ex)
def __init__(self, name, directory, nic_num=0, timer_num=0, char_num=0, block_num=0, **qom_kw): super(QOMDevice, self).__init__(name, **qom_kw) self.directory = directory self.nic_num = nic_num self.timer_num = timer_num self.char_num = char_num self.block_num = block_num # Define header file header_path = join("hw", directory, self.qtn.for_header_name + ".h") try: self.header = Header.lookup(header_path) except Exception: self.header = Header(header_path) # Define source file source_path = join("hw", directory, self.qtn.for_header_name + ".c") self.source = Source(source_path)
def main(): debug = Debugger() chrono = Chrono() universe = Universe(debug) source = Source(debug).get_source() bucket_chain = BucketChain(debug, chrono, universe, source) clusters = Clusters(debug, chrono, universe) algorithm = OnlineClustering(debug, universe, bucket_chain, clusters) while True: operation_time = time.time() if bucket_chain.is_updated(): universe.compute_log_n_df() bucket_chain.compute_universal_counts() bucket_chain.compute_universal_tfidf() clusters.update_centroid_counts() clusters.update_centroid_tfidf() algorithm.pre_clustering_work() algorithm.online_clustering() clusters.remove_old_clusters() universe.prune_terms(clusters) debug.log("BUCKET FINISHED IN: " + str(time.time() - operation_time)) clusters.debug_active_clusters() clusters.save_active_clusters()
def setUp(self): super(TestPointerReferences, self).setUp() name = type(self).__name__ try: h = Header["type_a.h"] except: h = Header("type_a.h") h.add_type(Type("a", incomplete=False, base=False)) src = Source(name.lower() + ".c").add_type( Structure("s", Pointer(Type["a"])("next"))) src_content = """\ /* {} */ #include "type_a.h" typedef struct s {{ a *next; }} s; """.format(src.path) self.files = [(src, src_content)]
def setUp(self): t_init = 0 # 1/24/60 t_end = t_init + 1 / 24 / 60 # 365*5 my_dt = 1 / 24 / 60 / 10 # [days] spline_degree = 3 gaia = Satellite(ti=t_init, tf=t_end, dt=my_dt, k=spline_degree) self.gaia = gaia my_times = np.linspace(t_init, t_end, num=100, endpoint=False) real_sources = [] calc_sources = [] for t in my_times: alpha, delta = af.generate_observation_wrt_attitude( gaia.func_attitude(t)) real_src_tmp = Source(str(t), np.degrees(alpha), np.degrees(delta), 0, 0, 0, 0) calc_src_tmp = Calc_source('calc_' + str(t), [t], real_src_tmp.get_parameters()[0:5], real_src_tmp.get_parameters()[5]) real_sources.append(real_src_tmp) calc_sources.append(calc_src_tmp) # test if source and calc source are equal (as they should be) np.testing.assert_array_almost_equal( np.array(real_sources[0].get_parameters()[0:5]), calc_sources[0].s_params) # create Solver self.Solver = Agis( gaia, calc_sources, real_sources, attitude_splines=[gaia.s_w, gaia.s_x, gaia.s_y, gaia.s_z], spline_degree=spline_degree, attitude_regularisation_factor=1e-3)
def _get_sources(items, limit): return { item.name: Source(item.prob, RandomPrices(item.seed, item.initial_price, item.sigma, limit), item.seed) for item in items }
def test_reduce(self, numeric_dataset): """Test reduce""" flow = Flow().from_source(Source(fin=numeric_dataset.open())).map( lambda x: [float(_) for _ in x] ).map(lambda x: sum(x)) assert flow.reduce(lambda a, b: a + b).eval() == [145]
def run2(self): trace('start') source = Source() translator = Translator(source) sink = Sink(translator) #exit() sink.run() trace('end')
def __init__(self, source_qty, time_limits): self.create_csv_dir() self.boundaries = CityGenerator().get_general_boundaries() self.time_limits = time_limits self.init_tuples() for i in range(source_qty): util.display_loading("Création du graphe", i / source_qty) Source(self)
def buildSourceList(self, titles, verbose=True): def wikiLink(link): try: page = wiki_api.page(link) if page.exists(): return { 'page': link, 'text': page.text, 'link': page.fullurl, 'categories': list(page.categories.keys()) } except: return None for current_title in titles: if not self.checkPageAdded(current_title): wiki_api = wikipediaapi.Wikipedia( language='en', extract_format=wikipediaapi.ExtractFormat.WIKI) page_name = wiki_api.page(current_title) if not page_name.exists(): print('Page {} does not exist.'.format(page_name)) return page_links = list(page_name.links.keys()) print_description = "Links Scraped for page '{}'".format( current_title) progress = tqdm(desc=print_description, unit='', total=len(page_links)) if verbose else None current_source = Source(page_name.title, page_name.text, page_name.fullurl, list(page_name.categories.keys()), page_name) # Parallelize the scraping, to speed it up (?) with concurrent.futures.ThreadPoolExecutor( max_workers=4) as executor: future_link = { executor.submit(wikiLink, link): link for link in page_links } for future in concurrent.futures.as_completed(future_link): data = future.result() current_source.append(data) if data else None progress.update(1) if verbose else None progress.close() if verbose else None namespaces = ('Wikipedia', 'Special', 'Talk', 'LyricWiki', 'File', 'MediaWiki', 'Template', 'Help', 'User', \ 'Category talk', 'Portal talk') current_source = current_source[ (len(current_source['text']) > 20) & ~(current_source['page'].str.startswith(namespaces, na=True))] current_source['categories'] = current_source.categories.apply( lambda x: [y[9:] for y in x]) current_source['topic'] = page_name print('Wikipedia pages scraped so far:', len(current_source))
def setUp(self): super(TestHeaderInclusion, self).setUp() name = type(self).__name__ f = Function(name="test_f") f_def = f.gen_definition() hdr = Header(name.lower() + ".h").add_type(f) hdr_content = """\ /* {path} */ #ifndef INCLUDE_{fname_upper}_H #define INCLUDE_{fname_upper}_H void test_f(void); #endif /* INCLUDE_{fname_upper}_H */ """.format(path=hdr.path, fname_upper=name.upper()) src1 = Source(name.lower() + ".c").add_type(f_def) src1_content = """\ /* {} */ void test_f(void) {{}} """.format(src1.path) src2 = Source(name.lower() + "2.c").add_type( Function( name="func_a", body=BodyTree()( Call(f_def) # use function definition to Call ))) src2_content = """\ /* {} */ #include "{}" void func_a(void) {{ test_f(); }} """.format(src2.path, hdr.path) self.files = [(hdr, hdr_content), (src1, src1_content), (src2, src2_content)]
def test_filter(self, string_dataset): """Test filter registering""" flow = Flow().from_source(Source(fin=string_dataset.open())).filter( lambda x: 'line' not in x ) assert flow.chain[0].type == 'FLOW::FILTER' assert flow.batch(1)[0] == ['0', '1', '2', '3', '4']
def setUp(self): self.absoluteTolerance = 1e-5 self.relativeTolerance = 1e-4 wavelength = 0.02 theta = 60 * deg phi = 30 * deg pTEM = 1 / sqrt(2) * complexArray([1, 1j]) reflectionLayer = Layer(er=2, ur=1) self.source = Source(wavelength, theta, phi, pTEM, reflectionLayer)
def test_reload(self, numeric_dataset): """Test reloading""" flow = Flow().from_source(Source(fin=numeric_dataset.open())).map( lambda x: 1 ) assert flow.reduce(lambda a, b: a + b).eval() == [10] assert flow.reload().reduce(lambda a, b: a + b).eval() == [10]