def test_loading(self): """ Tests if the file dataset is loaded correctly. It uses the pandas' library's dataframe testing method assert_frame_equal which compares two dataframes which when equal returns OK. """ # Create our class objects f = fm.FileManager(self.path_10) df_from_method = f.parse_json_dataframe() # Load dataframe using read_json and remove some of it's columns and change datatypes. dtypes = { "visitor_uuid": 'category', "visitor_useragent": "category", "visitor_country": 'category', "subject_doc_id": "category", "event_type": "category", "event_readtime": "float32" } df_from_test = pd.read_json( "C:/Users/amogh/PycharmProjects/dataAnalysis/data/issuu_cw2.json", lines=True).loc[:, [ "visitor_uuid", "visitor_useragent", "visitor_country", "subject_doc_id", "event_readtime", "event_type" ]] df_from_test["event_readtime"] = df_from_test["event_readtime"].fillna( 0) df_from_test = df_from_test.astype(dtypes) # Compare left and right dataframes pdt.assert_frame_equal(left=df_from_method, right=df_from_test)
def create_dot(gen_data,pdf=False,seperate_colors=False,trait=0): global genealogy_data, dot_file genealogy_data = gen_data directory = "outputs/dot/" # first couple of lines dot_file = file_manager.FileManager(directory,get_genealogy_name()+".dot") dot_file.write("graph \"" + get_genealogy_name() + "\"{") # create the dot stuff config_graph() # seperate or not if seperate_colors: create_colors_labels(traits) create_colors(traits) else: create_labels() create_generations() create_member_attributes() create_relations() finish() if pdf: os.system("sudo dot " + directory + get_genealogy_name() + ".dot -Tpdf -o " + directory + get_genealogy_name() + ".pdf") os.system("sudo rm " + directory + get_genealogy_name() + ".dot")
def test_filelines(self): """ Tests if the number of lines in the file are outputted correctly. """ # Create our class objects f = fm.FileManager(self.path_10) self.assertEqual(f.get_file_lines, "10003", "Should be 10003")
def test_graph_600k(self): """ Displays the graph for the 600k dataset's task 6 test parameters. """ f = fm.FileManager(self.path_600) df = f.parse_json_dataframe() p = prc.DataProcessing(df) p.run_task_6(self.doc_id_600, self.user_id_600)
def test_filename(self): """ Tests if the file name is returned correctly """ # Create our class objects f = fm.FileManager(self.path_10) self.assertEqual(f.get_file_name, "issuu_cw2.json", "Should be issuu_cw2.json")
def test_fileformat(self): """ Tests if the file format is returned correctly """ # Create our class objects f = fm.FileManager(self.path_10) self.assertEqual(f.check_file_format(), True, "Should be True for JSON")
def articles_list(generator): pelican_settings = generator.settings parser = parser_factory(html_parser.TYPE_HTML, pelican_settings) articles_total_count = len(generator.articles) s = settings.ArticlesListSettings() articles_list_settings = s.get(pelican_settings, articles_total_count) articles_list_settings['articles_total_count'] = articles_total_count al = creator.Creator(file_manager.FileManager()) al.run(generator.articles, articles_list_settings, parser)
def __init__(self, host, port, identifier="main-", syncServer=[]): self.server = Server(host, port, identifier) self.fileManager = file_manager.FileManager(identifier) self.lockSync = consistency.Sync() self.syncServer = list() for server in syncServer: url = "PYRONAME:%s@%s:%d" % (server, host, port) self.syncServer.append(Pyro4.Proxy(url)) self.Sync()
def test_format_time(self): """Tests if the time is formatted correctly We test the seconds converted by this tool. test data: 1234567800 source tool: https://www.convert-me.com/en/convert/time/millisecond/millisecond-to-dhms.html?u=millisecond&v=1%2C234%2C567%2C800 """ f = fm.FileManager(file_path=self.path_100) df = f.parse_json_dataframe() p = prc.DataProcessing(df) actual = p._format_time( 1234567800) # 1234567800ms is 14 days 6 hours 56 minutes 7 seconds expected = "14d : 6h : 56m : 7s" self.assertEqual(actual, expected, "Should be %s" % expected)
def __init__(self, n_devices, logger, server=True): """ :param n_devices: numero di device della rete :param logger: elabora il file di log :param server: booleano, indica la presenza di un server centrale (False = P2P) """ self.env = simpy.Environment() self.logger = logger self.file_manager = fm.FileManager(self.logger) self.devices = {} self.shared_folders = {} self.server = server self.stats = cs.StatsManager(n_devices, self.devices, self.env, server) self.generate_network(n_devices)
def test_also_likes_readers_100k(self): """ Test to see if the readers is as expected for a document and visitor in the 100k dataset. """ f = fm.FileManager(file_path=self.path_100) df = f.parse_json_dataframe() p = prc.DataProcessing(df) # get relevant readers gets a set of readers for a document and user id set_readers = p.get_relevant_readers(self.doc_id_100, self.user_id_100) set_expected = { '4108dc09bfe11a0c' } # We expect only 1 reader based on the given test data self.assertEqual(set_readers, set_expected, "Should be %s" % set_expected)
def test_also_likes_readers_600k(self): """ Test to see if the readers is as expected for a document and visitor in the 600k dataset. """ f = fm.FileManager(self.path_600) df = f.parse_json_dataframe() p = prc.DataProcessing(df) # get relevant readers gets a set of readers for a document and user id set_readers = p.get_relevant_readers(self.doc_id_600, self.user_id_600) # We expect the following 4 readers based on the given test data. set_expected = { '383508ea93fd2fd1', '3f64bccfd160557e', '1f891eb0b573e42c', '7134a88f8b201d31' } self.assertEqual(set_readers, set_expected, "Should be %s" % set_expected)
def run(torrent): try: # create FileManager and check hashes if file already exists file_wrapper = file_manager.FileWrapper(torrent=torrent) existing_hashes = file_wrapper.create_file_or_return_hashes() if existing_hashes: for index, h in enumerate(existing_hashes): piece_info = torrent.piece_info(index) if piece_info.sha1hash == h: torrent._complete[ index] = True # TODO remove private property access s_complete_pieces, r_complete_pieces = trio.open_memory_channel( config.INTERNAL_QUEUE_SIZE) s_write_confirmations, r_write_confirmations = trio.open_memory_channel( config.INTERNAL_QUEUE_SIZE) s_blocks_to_read, r_blocks_to_read = trio.open_memory_channel( config.INTERNAL_QUEUE_SIZE) s_blocks_for_peers, r_blocks_for_peers = trio.open_memory_channel( config.INTERNAL_QUEUE_SIZE) file_engine = file_manager.FileManager( file_wrapper=file_wrapper, pieces_to_write=r_complete_pieces, write_confirmations=s_write_confirmations, blocks_to_read=r_blocks_to_read, blocks_for_peers=s_blocks_for_peers, ) engine = Engine( torrent=torrent, complete_pieces_to_write=s_complete_pieces, write_confirmations=r_write_confirmations, blocks_to_read=s_blocks_to_read, blocks_for_peers=r_blocks_for_peers, ) async def run(): async with trio.open_nursery() as nursery: nursery.start_soon(file_engine.run) nursery.start_soon(engine.run) trio.run(run) except KeyboardInterrupt: print() print("Shutting down without cleanup...")
def create_dot(self): # first couple of lines self.dot_file = file_manager.FileManager("outputs", self.name + ".dot") self.dot_file.write("graph " + self.name + "{") self.generations_labels = [] # setup the dot parameters (to do lots of things) self.dot_params = dot_parameters.DOTParameters(self, self.geneology) # create the dot stuff self.dot_params.config_graph() self.create_generations_labels() self.create_generations() self.create_member_attributes() self.create_relations() self.finish()
def select_file(): """Lets the user select a file and checks if it is valid""" file_frame.filename = filedialog.askopenfilename(initialdir="/dataAnalysis/data", title="Select Dataset", filetypes=FILE_TYPES) if file_frame.filename: f = fm.FileManager(file_frame.filename) if f.check_file_format(): # Check if file selected is of JSON format global df # Try loading the dataframe, else return messagebox with relevant errors. df = f.parse_json_dataframe() if not df.empty: global dataset dataset = pr.DataProcessing(df) display_file_info(f) else: messagebox.showerror("Value Error", "The JSON file you are trying to load didn't contain valid dictionaries. Please try again") else: # Display message box in case file is incorrect format messagebox.showerror(title="Bad file format", message="Please load JSON file only.")
def test_also_likes_documents_100k(self): """ Test to see if the documents is as expected for a document and visitor in the 100k dataset. """ f = fm.FileManager(file_path=self.path_100) df = f.parse_json_dataframe() p = prc.DataProcessing(df) # get relevant readers gets a set of readers for a document and user id set_readers = p.get_relevant_readers(self.doc_id_100, self.user_id_100) # get the documents that these readers like set_docs = p.get_documents(set_readers) # We expect only 4 documents based on the given test data set_expected = { '4108dc09bfe11a0c': { '100405170355-00000000ee4bfd24d2ff703b9147dd59', '100806162735-00000000115598650cb8b514246272b5', '100806172045-0000000081705fbea3553bd0d745b92f', '101122221951-00000000a695c340822e61891c8f14cf' } } self.assertEqual(set_docs, set_expected, "Should be %s" % set_expected)
import file_manager plik = file_manager.FileManager("tekst") print(plik.read_file()) plik.update_file(" - update test") print(plik.read_file())
def main(): """ Start point of app """ # Driver path driverPath = os.path.dirname( os.path.abspath(__file__)) + '/chromedriver_win32/chromedriver.exe' # Objects objFileManager = fm.FileManager() objScrapper = ps.PolyScrapper(driverPath) # Get words to search from file (words.txt) searchTexts = objFileManager.read_all_words() for i in range(len(searchTexts)): searchTexts[i] = searchTexts[i].rstrip() # Count of max download per searched text. maxDownloadCountPerItem = 50 for searchText in searchTexts: print("--------------------> Searching:" + searchText) # Create sub folder in destinationPath objFileManager.create_folder(searchText) # Search objScrapper.search(searchText) time.sleep(4) # Filter founded items objScrapper.filter() time.sleep(2) # Get founded total item count itemCount = int(objScrapper.get_item_count()) maxItemCount = maxDownloadCountPerItem if itemCount < maxDownloadCountPerItem: maxItemCount = itemCount print("--------------------> ItemCount:" + str(itemCount)) # Scroll a couple times to load enough item to screen. objScrapper.scroll_down() time.sleep(1) objScrapper.scroll_down() time.sleep(1) objScrapper.scroll_down() time.sleep(1) objScrapper.scroll_down() time.sleep(1) # Download all founded items one by one for index in range(maxItemCount): realIndex = index + 1 print("Index:" + str(realIndex) + " at " + str(datetime.datetime.now())) # Click Item isClickSuccess = objScrapper.click_element(realIndex) if isClickSuccess: time.sleep(2) isPageExist = objScrapper.is_page_exist() if isPageExist: # Remove non-ascii characters from name name = objScrapper.get_name() name = replace_non_ascii(name) # Is item already downloaded? isFileExist = objFileManager.has_file(name, searchText) # if isFileExist == False: isSuccess = objScrapper.download() if isSuccess: # Wait until download finish while True: if objFileManager.is_download_finished( ) == True: break time.sleep(0.25) # Move downloaded file to correct folder objFileManager.create_folder(searchText) objFileManager.cut_and_paste_last_file( searchText, name) else: print("Download failed") objScrapper.return_to_first_tab() else: print("File already exist") objScrapper.return_to_first_tab() else: print("File already exist") objScrapper.return_to_first_tab() # time.sleep(0.5) objScrapper.quit() print("ALL DONE!")
class Entity: name = "" health = 0 attack = 0 defence = 0 money = 0 alive = True file_stuff = file_manager.FileManager() def attack_target(self, thing_being_attacked): roll = self.dice_roll(20) print("{} rolled a {}".format(self.name, roll)) if roll >= 15: damage = self.attack * 2 - thing_being_attacked.defence thing_being_attacked.set_health(thing_being_attacked.health - damage) print("{} hit doing critical damage of {}".format( self.name, damage)) elif roll < 15 and roll >= 10: damage = self.attack - thing_being_attacked.defence thing_being_attacked.set_health(thing_being_attacked.health - damage) print("{} hit doing damage of {}".format(self.name, damage)) if roll >= 5 and roll < 10: print("{} missed!".format(self.name)) if roll < 5: damage = self.attack * 2 - thing_being_attacked.defence self.set_health(self.health - damage) print("{} missed and hit themselves dealing {} damage".format( self.name, damage)) def run_from(self, thing_attacking): roll = self.dice_roll(20) if roll >= 15: print("{} got away from {} safely".format(self.name, thing_attacking.name)) return True else: damage = thing_attacking.attack * 2 self.set_health(self.health - damage) print("{} failed to get away and got hit doing {} damage".format( self.name, damage)) return False def get_health(self): return self.health def set_health(self, number): self.health = number def dice_roll(self, sides): return random.randrange(1, sides) def check_if_alive(self): if self.health <= 0: print("{} DIED!".format(self.name)) self.alive = False return False else: print("{} health is {}".format(self.name, self.health)) return True
def add(self, a, b): print(a + b) def difference(self, s, b): print(a - b) def multiply(self, a, b): print(a * b) def divide(self, a, b): print(a / b) class ScienceCalculator(Calculator): def potega(self, a, b): print(a ^ b) def tyl(tekst): print(tekst[::-1]) plik = file_manager.FileManager("pliczek.txt") print("Przed edycja:\n") plik.read_file() plik.update_file() plik.zamknij() krowa = file_manager.FileManager("pliczek.txt") print("Po edycji:\n") krowa.read_file()
def __init__(self, host, port, identifier="main-"): self.server = Server(host, port, identifier) self.fileManager = file_manager.FileManager()
import screen import file_manager import store import entity import time import json file_stuff = file_manager.FileManager() game_is_running = True filer = file_manager.FileManager() screen_stuff = screen.Screen() def opening_screen(): print("Welcome") print() print( "what do you want to do?\nfor new game type new\nto load game type load\nTo quit type quit" ) running = True while running: user_input = input() if user_input == "new": return character_creator() elif user_input == "load": while True: character_name = input("what is your characters name: ") file_exists = filer.check_if_file_exists( "json/{}.json".format(character_name)) if file_exists == True:
def main(): ''' Main que simula o dispatcher, administra todos os modulos e le os Arquivos de entrada ''' #Inicializa modulos manager = pm.ProcessManager() memory = mm.MemoryManager() io = iom.IOManager() filesystem = fm.FileManager() logger = log.Logger() # Se tiver dois argumentos de linha, utiliza-os, senao usa os padroes if len(sys.argv) > 2: procFile = sys.argv[1] arqFile = sys.argv[2] else: procFile = 'processes.txt' arqFile = 'files.txt' #Abre e le o arquivo de processos with open(procFile, 'r') as f: procs = [[int(x) for x in line.split(',')] for line in f] processes = [pm.Process(x).__dict__ for x in procs] #Abre e le o arquivo do sistema de arquivos with open(arqFile, 'r') as f: temp = f.read().splitlines() filesystem.qtd_blocos = int(temp[0]) filesystem.qtd_segmentos = int(temp[1]) filesystem.arquivos = [ fm.File(temp[i].replace(' ', '').split(',')).__dict__ for i in range(2, filesystem.qtd_segmentos + 2) ] # import ipdb; ipdb.set_trace() filesystem.operacoes = [ fm.FileOperation(temp[i].replace(' ', '').split(',')).__dict__ for i in range(filesystem.qtd_segmentos + 2, len(temp)) ] filesystem.inicia_disco() #Ordena os processos por ordem de chegada manager.fila_principal = list( sorted(processes, key=operator.itemgetter('tempo_init'))) # Como o quantum e um, o tratamento e apenas um iterador t t = 0 while (True): #Se tiver processo ainda nao processado while (manager.fila_principal): #Escalona processos do tempo de chegada = t if (manager.fila_principal[0]['tempo_init'] == t): manager.escalona_processo_geral() else: break #Escalona processos da fila de usuario para as filas de prioridade while (manager.escalona_processo_usuario()): pass #SE NAO TEM NADA EXECUTANDO(SE TIVER VAI SER TEMPO REAL) if (not (manager.em_execucao)): #Executa tempo real se tiver for novo_processo in manager.fila_tempo_real: #Tenta salvar na memoria, se tiver espaco novo_processo['PID'] = manager.gera_pid() offset = memory.salva(novo_processo) #Coloca em execucao if (offset is not None): manager.em_execucao = manager.fila_tempo_real.pop( manager.fila_tempo_real.index(novo_processo)) manager.em_execucao['offset'] = offset logger.dispatch(manager.em_execucao) break #Nao atribui PID se n conseguir salvar na memoria else: novo_processo['PID'] = None manager.ultimoPID -= 1 #Se nao tiver tempo real, vai ser despachado processos de usuario else: # Procura algum processo de prioridade 1 que possa ser executado for novo_processo in manager.prioridade_1: #Se processo ainda nao esta na memoria(nunca foi executado) if novo_processo['offset'] is None: #Ve se pode ser alocado em IO novo_processo['PID'] = manager.gera_pid() if (io.aloca(novo_processo)): offset = memory.salva(novo_processo) novo_processo['offset'] = offset if offset is not None: logger.dispatch(novo_processo) offset = novo_processo['offset'] #Se o processo puder ser executado, carrega para a CPU if (offset is not None): manager.em_execucao = manager.prioridade_1.pop( manager.prioridade_1.index(novo_processo)) break else: novo_processo['PID'] = None manager.ultimoPID -= 1 # Se nao pode atribuir processos de prioridade 1(falta de processos ou recursos(memoria e io)) else: for novo_processo in manager.prioridade_2: #Se processo ainda nao esta na memoria if novo_processo['offset'] is None: #Ve se pode ser alocado em IO novo_processo['PID'] = manager.gera_pid() if (io.aloca(novo_processo)): offset = memory.salva(novo_processo) novo_processo['offset'] = offset if offset is not None: logger.dispatch(novo_processo) offset = novo_processo['offset'] #Se o processo puder ser executado, carrega para a CPU if (offset is not None): manager.em_execucao = manager.prioridade_2.pop( manager.prioridade_2.index(novo_processo)) break else: novo_processo['PID'] = None manager.ultimoPID -= 1 # Se nao pode atribuir processos de prioridade 1 ou 2(falta de processos ou recursos(memoria e io)) else: for novo_processo in manager.prioridade_3: #Se processo ainda nao esta na memoria if novo_processo['offset'] is None: #Ve se pode ser alocado em IO novo_processo['PID'] = manager.gera_pid() if (io.aloca(novo_processo)): offset = memory.salva(novo_processo) novo_processo['offset'] = offset if offset is not None: logger.dispatch(novo_processo) offset = novo_processo['offset'] #Se o processo puder ser executado, carrega para a CPU if (offset is not None): manager.em_execucao = manager.prioridade_3.pop( manager.prioridade_3.index(novo_processo)) break else: novo_processo['PID'] = None manager.ultimoPID -= 1 if (manager.acabou()): #Condicao de saida do programa => Nao tem nenhum processo em nenhuma fila #E todos os processos ja chegaram break # Executa Processo if (manager.em_execucao): #Decrementa tempo restante e aumenta o numero de instrucoes rodadas manager.em_execucao['tempo_processador'] -= 1 manager.em_execucao['execucoes'] += 1 #Mostra Saida logger.executa(manager.em_execucao) #APOS EXECUCAO #Remove o processo da memoria e libera recursos SE TIVER ACABADO O TEMPO if manager.em_execucao['tempo_processador'] == 0: filesystem.opera_processo(manager.em_execucao) io.libera(manager.em_execucao) memory.mata(manager.em_execucao) manager.em_execucao = {} #COmo o quantum eh um, processos de usuario sao retirados da CPU em toda iteracao elif manager.em_execucao['prioridade'] > 0: if manager.em_execucao['prioridade'] == 1: manager.prioridade_1.append(manager.em_execucao) elif manager.em_execucao['prioridade'] == 2: manager.prioridade_2.append(manager.em_execucao) elif manager.em_execucao['prioridade'] == 3: manager.prioridade_3.append(manager.em_execucao) manager.em_execucao = {} #Avanca uma unidade de tempo t += 1 #Mostra saida do sistema de arquivos logger.disco(filesystem)
def run(args): print("") # Leave a gap print("Starting task %s" % args.task) # If the task value is 2a, then run if args.task == "2a": # Create file object f = fm.FileManager(args.file) # Create the dataframe df = f.parse_json_dataframe() # If the df was not empty, then run this if not df.empty: # Send it to dataprocessing, dataset = pr.DataProcessing(df) # Run the task for 2a. dataset.histogram_country(args.docid) # If the task value is 2b, then run elif args.task == "2b": f = fm.FileManager(args.file) df = f.parse_json_dataframe() if not df.empty: dataset = pr.DataProcessing(df) dataset.histogram_continent(args.docid) elif args.task == "3a": f = fm.FileManager(args.file) df = f.parse_json_dataframe() if not df.empty: dataset = pr.DataProcessing(df) dataset.histogram_browsers_a() elif args.task == "3b": f = fm.FileManager(args.file) df = f.parse_json_dataframe() if not df.empty: dataset = pr.DataProcessing(df) dataset.histogram_browsers_b() elif args.task == "4": f = fm.FileManager(args.file) df = f.parse_json_dataframe() if not df.empty: dataset = pr.DataProcessing(df) output = dataset.visitor_readtimes() print("Reader(s): | Total readtime(s): ") print("------------------------------------------------") for k, v in output.items(): print('%s | %s' % (k, v)) elif args.task == "5": f = fm.FileManager(args.file) df = f.parse_json_dataframe() if not df.empty: dataset = pr.DataProcessing(df) readers, output = dataset.run_task_5(args.docid, args.userid) print("Relevant readers for the document:") print("Reader(s) ") print("-----------") for reader in readers: print("%s |" % reader[-4:]) print("") print("Top 10 most read (also-like) documents: ") print("Document(s) | Times Read") print("----------------------------") for documents, count in output.items(): if documents[-4:] == args.docid[-4:]: print("%s (*) | %s" % (documents[-4:], count)) else: print("%s | %s" % (documents[-4:], count)) print("Where (*) is the input document.") elif args.task == "6": f = fm.FileManager(args.file) dataset = pr.DataProcessing(f.parse_json_dataframe()) dataset.run_task_6(args.docid, args.userid) else: return "No conditions set"
import config_parser import file_manager if __name__ == "__main__": p = config_parser.ConfigParser() f = file_manager.FileManager() dest = p.get_destination() f.archive_desktop_files(dest)
def run(self): self.logger_function('Server started') while self.main.server_running: try: connection, address = self.socket.accept() except: continue self.logger_function('Received connection from ' + str(address)) connection.settimeout(1) data = connection.recv(65535) configuration_password_hash = self.configuration_menu.get_parameter( 'password_hash') if data.startswith(b'GET_MEME'): self.logger_function('Meme was requested') password_hash, offset = ServerThread.parse_length_value_string( data, len('GET_MEME')) if not password_hash == configuration_password_hash.encode(): connection.send(b'WRONG_PASSWORD') self.logger_function('Wrong password') else: file_mngr = file_manager.FileManager() folder_list = json.loads( self.configuration_menu.get_parameter('folders')) extension_list = json.loads( self.configuration_menu.get_parameter('extensions')) try: file_mngr.open_random_file(folder_list, extension_list) path = file_mngr.get_file_path().encode() path_length = len(path) connection.send(path_length.to_bytes(2, 'big') + path) data = file_mngr.read() while data: connection.send(data) data = file_mngr.read() file_mngr.close_file() self.logger_function('Sent meme') except: self.logger_function('Didn\'t find any memes to send') elif data.startswith(b'MOVE_FILE'): self.logger_function('File moving was requested') password_hash, offset = ServerThread.parse_length_value_string( data, len('MOVE_FILE')) if not password_hash == configuration_password_hash.encode(): connection.send('WRONG_PASSWORD') self.logger_function('Wrong password') else: source, offset = ServerThread.parse_length_value_string( data, offset) destination, offset = ServerThread.parse_length_value_string( data, offset) new_path = file_manager.FileManager.move_file( source.decode("utf-8"), destination.decode("utf-8")) if new_path: connection.send(new_path.encode()) self.logger_function('Moved successfully') else: connection.send(b'NOK') self.logger_function('Moving failed') connection.close() self.socket.close() self.logger_function('Server stopped')
def run(): fm = file_manager.FileManager("best_examples") best_score = fm.get_or_create_file(k, l, choose_mode) scores = [] moves = [] cascade_repartition = np.zeros(int(np.log2(k))) for i in range(trial_number): tmp_cascade_repartition = np.zeros(int(np.log2(k))) t0 = time.time() p = random_phase.RandomPhase(k, l, choose_mode) p.start_phase() # TO COMPUTE THE MAX COST OF A PHASE if best_score < sum(p.cascade_costs): best_score = sum(p.cascade_costs) fm.redo_file(best_score, p.history) scores.clear() scores.append(p.cascade_costs) moves.clear() moves.append(p.g.get_moves()) elif best_score == sum(p.cascade_costs): fm.update_file(p.history) scores.append(p.cascade_costs) moves.append(p.g.get_moves()) # TO CHECK THE PROPERTY: after each cascade, cost <= l*s*log(s), where s is the number of revealed edges for j in range(0, len(p.cascade_costs)): if sum(p.cascade_costs[:j]) > l * (j + 1) * np.log2(j + 1): fm.store_counter_example("best_examples", "false lslog(s) property ", p.history, p.cascade_costs, j) print("counter example!! false lslog(s) property") break # TO CHECK THE PROPERTY: after each cascade, cost <= max(2, l*s*log(s)), where s is the number of revealed edges for j in range(0, len(p.cascade_costs)): if sum(p.cascade_costs[:j + 1]) > max(2, l * (j + 1) * np.log2(j + 1)): fm.store_counter_example("best_examples", "false max(2, lslog(s) property) ", p.history, p.cascade_costs, j) print("counter example!! false max(2, lslog(s) property") break # TO SEE THE REPARTITION OF CASCADES, DEPENDING ON THEIR COST for c in p.cascade_costs: index = int(np.log2(int(c / l))) tmp_cascade_repartition[index] += 1 for j in range(len(tmp_cascade_repartition)): if tmp_cascade_repartition[j] > cascade_repartition[j]: cascade_repartition[j] = tmp_cascade_repartition[j] duration = time.time() - t0 remaining_time = (trial_number - i) * duration hours = remaining_time // 3600 minutes = (remaining_time - hours * 3600) // 60 print(i * 100 / trial_number, "% rem. time:", int(hours), "h", int(minutes), "m score:", sum(p.cascade_costs), "best :", best_score) print("cas. repart.: ", cascade_repartition) print("best score : ", best_score)
def getCreator(self): fm = file_manager.FileManager() fm.save_file = MagicMock(return_value=True) return creator.Creator(fm)
elif command == b'\x0D': # RS422: Begin to use the rover line for extended period of time files_transferring = True files_transfer_thread = threading.Thread( target=rover.transfer_sample) files_transfer_thread.start() elif command == b'\x0E': rover.clock_sync(packet) elif command == b'\xF0': debug.pi_tune() if __name__ == "__main__": if DEBUG_MODE: fm = file_manager.FileManager(DEBUG_SD_PATH, DEBUG_FLASH_PATH) else: fm = file_manager.FileManager(SD_PATH, FLASH_PATH) # Set up our serial connection to the rover rover_serial = oasis_serial.OasisSerial("/dev/ttyS1", debug_mode=DEBUG_MODE, debug_tx_port=ROVER_TX_PORT, debug_rx_port=ROVER_RX_PORT, rx_print_prefix="BBB RX] ") # Set up a packet manager to process the OSPP packets we send and recieve packet_manager = ospp.PacketManager(rover_serial) tlc_serial = oasis_serial.OasisSerial("/dev/ttyS2", debug_mode=DEBUG_MODE, debug_tx_port=TLC_TX_PORT,
list2 = [1, 2, 3, 4, 5, 6, 7] lists(list1, list2) # 2 print(info("WIELKIE niewielkie")) # 3 print(delete("Ala ma kota", "a")) # 4 print(convert("K", 33)) print(convert("F", 43)) print(convert("R", 43)) # 5 calc1 = Calculator() print(calc1.add(3, 4)) # 6 calc2 = ScienceCalculator() print(calc2.square(4, 2)) # 7 reverse("to kajak") # 8 manager1 = file_manager.FileManager("zad8.txt") manager1.read_file() manager1.update_file("\nAdded text") manager1.read_file()