def rotate_wrt_atom(self, atom_number, axis, angle): if atom_number < 1 and atom_number > len(self.rows): return #Do nothing #Get the coordinates of the given atom. Minus 1 because we #start atom counting at 1 instead of 0. center_coord = Struct() center_coord.x = self.rows[atom_number-1][1] center_coord.y = self.rows[atom_number-1][2] center_coord.z = self.rows[atom_number-1][3] return self.rotate(center_coord, axis, angle)
def rotate_wrt_atom(self, atom_number, axis, angle): if atom_number < 1 and atom_number > len(self.rows): return #Do nothing #Get the coordinates of the given atom. Minus 1 because we #start atom counting at 1 instead of 0. center_coord = Struct() center_coord.x = self.rows[atom_number - 1][1] center_coord.y = self.rows[atom_number - 1][2] center_coord.z = self.rows[atom_number - 1][3] return self.rotate(center_coord, axis, angle)
def __init__(self): layout = [[ sg.Button('Lista'), sg.Button('Fila'), sg.Button('Pilha'), sg.Button('Árvore'), sg.Button('Grafo') ], [sg.Button('Fechar')]] win = sg.Window('Projeto de ED', layout) event, value = win.read() random.shuffle(aux) global estrutura if (event == sg.WIN_CLOSED or event == 'Fechar'): win.close() elif (event == "Lista"): estrutura = ListaDinamica.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1() elif (event == "Fila"): estrutura = Fila.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1() elif (event == "Pilha"): estrutura = Pilha.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1() elif (event == "Árvore"): estrutura = Arvore.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1()
def getProductReview(url): L = [] options = Options() options.add_argument('--headless') # options.add_argument('--disable-gpu') options.add_argument('user-agent=Mozilla/5.0') driver = webdriver.Chrome(options=options, executable_path='./chromedriver') driver.get(url) driver.execute_script( "window.scrollBy(0, (document.body.scrollHeight*0.6));") comment = {} soup = BeautifulSoup(driver.page_source, 'html.parser') for review in soup.find_all('div', class_='BVRRContentReview'): author = review.find('span', class_='BVRRNickname').text date = review.find('span', class_='BVRRReviewDate').text title = review.find('span', class_='BVRRReviewTitle').text content = review.find('span', class_='BVRRReviewText').text score = review.find('span', class_='BVRRRatingNumber').text # print ("---") # print (author) # print (date) # print (title) # print (content) # print (score) comment = Struct.Comment(content, score, date, title) L.append(comment) driver.close() return L
def product_merge(L, result, source): for product in L: check = False for mp in result: if product.brand.upper() == mp.brand.upper() and name_check( product.name, mp.name): # print (product.name); mp.price = min(mp.price, product.price) mp.original_price.append(product.price) mp.review_score = int( (mp.review_score * len(mp.product_URL) + product.review_score) / (len(mp.product_URL) + 1)) mp.product_URL.append(product.product_URL) mp.figure_URL.append(product.figure_URL) mp.source.append(source) check = True break if (not check): mp = Struct.Merge_Product() mp.name = product.name mp.price = product.price mp.original_price.append(product.price) mp.product_URL.append(product.product_URL) mp.figure_URL.append(product.figure_URL) mp.review_score = int(product.review_score) mp.brand = product.brand mp.source.append(source) result.append(mp)
def merge(L1, L2, L3): result = [] if (L1): for product in L1: mp = Struct.Merge_Product() mp.name = product.name mp.price = product.price mp.product_URL.append(product.product_URL) mp.figure_URL.append(product.figure_URL) mp.review_score = int(product.review_score) mp.brand = product.brand mp.source.append("Sephora") mp.original_price.append(product.price) result.append(mp) if (L2): if (len(result) == 0): for product in L2: mp = Struct.Merge_Product() mp.name = product.name mp.price = product.price mp.product_URL.append(product.product_URL) mp.figure_URL.append(product.figure_URL) mp.review_score = int(product.review_score) mp.brand = product.brand mp.source.append("Bloomindale") mp.original_price.append(product.price) result.append(mp) else: product_merge(L2, result, "Bloomindale") if (L3): if (len(result) == 0): for product in L3: mp = Struct.Merge_Product() mp.name = product.name mp.price = product.price mp.product_URL.append(product.product_URL) mp.figure_URL.append(product.figure_URL) mp.review_score = int(product.review_score) mp.brand = product.brand mp.source.append("UTLA") mp.original_price.append(product.price) result.append(mp) else: product_merge(L3, result, "UTLA") return result
def getProductReview(searchUrl): L = [] # Init driver # headless chrome_options = Options() chrome_options.add_argument('--headless') chrome_options.add_argument('--disable-extensions') chrome_options.add_argument('--window-size=1920,1080') # certificate capabilities = DesiredCapabilities.CHROME.copy() capabilities['acceptSslCerts'] = True capabilities['acceptInsecureCerts'] = True driver = webdriver.Chrome(executable_path='./chromedriver', chrome_options=chrome_options, desired_capabilities=capabilities) # driver = webdriver.Chrome(executable_path='/Users/Leon/Desktop/capstone_test/chromedriver') # baseUrl = 'https://www.sephora.com'; driver.get(searchUrl) time.sleep(0.5) # Delays for 0.5 seconds. # Move ten times can scroll to the end (the height of the website is 4284px) for i in range(10): driver.execute_script("window.scrollBy(0,500)") time.sleep(0.2) html = driver.page_source soup = BeautifulSoup(html.encode('utf-8'), 'html.parser') reviewTitleClass = 'css-1fsuw0x' reviewContentClass = 'css-eq4i08' reviewDateClass = 'css-12z5fyi' reviewTitles = soup.findAll("div", {"class": reviewTitleClass}) reviewContents = soup.findAll("div", {"class": reviewContentClass}) reviewDates = soup.findAll("span", {"class": reviewDateClass}) reviewRatings = getReviewRatings(soup) for i in range(len(reviewTitles)): title = reviewTitles[i].contents content = reviewContents[i].contents date = reviewDates[i].contents rating = reviewRatings[i] # print(content[0]); # print(rating); # print(date[0]); # print(title[0]); # print("--------") # print content comment = Struct.Comment(content[0], rating, date[0], title[0]) L.append(comment) driver.close() return L
def find_min_value(self): min = Struct() min.x = self.rows[0][1] #Set to some initial value min.y = self.rows[0][2] min.z = self.rows[0][3] for row in self.rows: if row[1] < min.x: min.x = row[1] if row[2] < min.y: min.y = row[2] if row[3] < min.z: min.z = row[3] return min
def find_max_value(self): max = Struct() max.x = self.rows[0][1] #Set to some initial value max.y = self.rows[0][2] max.z = self.rows[0][3] for row in self.rows: if row[1] > max.x: max.x = row[1] if row[2] > max.y: max.y = row[2] if row[3] > max.z: max.z = row[3] return max
def getProductInfo(keyword): products = [] url = 'https://shop.nordstrom.com/sr?keyword=%s' % keyword response = requests.get(url, headers={'User-Agent': "Mozilla/5.0"}) print('url: ' + str(url)) print('status code: ' + str(response.status_code)) print('encoding: ' + str(response.encoding)) soup = BeautifulSoup(response.content, 'html.parser') for product in soup.find_all('article', class_='productModule_Z1pWESH'): name = product.find( 'span', class_='light_Z1MOMXL navigationLink_Z1yc2MG').span.text.strip( ' \t\n') product_url = 'https://shop.nordstrom.com' + product.find( 'a', class_='linkWrapper_F71fC')['href'] picture_url = product.find('img', class_='image_Z272g5Q')['src'] prices = product.find_all( 'span', attrs={'data-element': 'product-module-price-line-price'}) normal_price = prices[0].text sales_price = -1 if len(prices) > 1: sales_price = prices[1].text print('---') print(name) print(product_url) print(picture_url) print(normal_price) print(sales_price) p = Struct.Product("", name, normal_price, product_url, picture_url, "0") if (sales_price != -1): p = Struct.Product("", name, sales_price, product_url, picture_url, "0") products.append(p) return products
def initialize(self): self.number_of_target_atoms = Struct() self.number_of_target_atoms.x = len(self.molecule_placement[0]) self.number_of_target_atoms.y = len(self.molecule_placement) self.spacing_of_target_atoms = Struct() self.spacing_of_target_atoms.x = abs(self.upper_left_surface_atom.x- \ self.lower_right_surface_atom.x)/(self.number_of_target_atoms.x-1) #-1 because counting atom connections self.spacing_of_target_atoms.y = abs(self.upper_left_surface_atom.y- \ self.lower_right_surface_atom.y)/(self.number_of_target_atoms.y-1) #-1 because counting atom connections #Load our surface and molecule placing position self.surface = XYZ() self.surface.load(self.surface_xyz_file) self.place_molecule = XYZ() self.place_molecule.load(self.place_xyz_file) self.place_molecule.normalize_coordinates( ) #Make the molecule start from (0,0,0) #Make the molecule start from the upper left position self.place_molecule.translate(self.upper_left_surface_atom.x, self.upper_left_surface_atom.y, \ self.upper_left_surface_atom.z)
def create_register(option, type): if not (exists(option[1])): for elem in option[2:]: if (not [atomic for atomic in atomics if atomic.name == elem]): print("Ha introducido un tipo que no existe") return elements = [] for elem in option[2:]: elements.append(search_element(elem, 'atomic')) if (type == "struct"): structs.append(Struct(option[1], elements)) else: unions.append(Union(option[1], elements))
def main(): #Arguments surface_xyz_file = '0etoh.xyz' place_xyz_file = 'placed_eto_orientation.xyz' #The molecule we want to place on the surface output_xyz_file = 'placed.xyz' #Define the longer axis as the axis where more molecules can be placed #(see the molecule placement array). We also define the upper left atom as the one #closer to (0, 0): upper_left_surface_atom = Struct(x=1.69501, y=0.71964, z=31.50097) #In Angstroms lower_right_surface_atom = Struct(x=14.68505, y=15.51403, z=31.51654) placement_z_distance_from_surface = 1.8141 #The distance of our 'to place' molecule from the surface. #Molecule placement: Use 1 to indicate placement of the molecule, 0 is vacant spot. If you want to # rotate the molecule, enter a list that takes the arguments: # [1, (int) atom to rotate wrt, (str) axis, (float) degrees] # ie. To rotate EtOH molecule about its O molecule along the z axis 180 degrees: # [1, 5, 'z', 180] molecule_placement = [[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]] ethanol_place = Surface_place() ethanol_place.set_filenames(surface_xyz_file, place_xyz_file, output_xyz_file) ethanol_place.define_surface_sites(upper_left_surface_atom, lower_right_surface_atom, placement_z_distance_from_surface) ethanol_place.define_molecule_placement(molecule_placement) ethanol_place.initialize() ethanol_place.place() #Now save the surface and any placed molecules ethanol_place.surface.export(output_xyz_file) print 'Surface placed file created: ' + output_xyz_file
def __init__(self, opcao): dado = [] layout = [ [sg.Text('Por favor, informe aqui os dados:')], [sg.Text('Chave', size=(30, 1)), sg.InputText()], [sg.Text('Data de Observação', size=(30, 1)), sg.InputText()], [ sg.Text('Estado da Província (Se for na China)', size=(30, 1)), sg.InputText() ], [sg.Text('Região do País', size=(30, 1)), sg.InputText()], [sg.Text('Última Atualização', size=(30, 1)), sg.InputText()], [sg.Text('Casos confirmados', size=(30, 1)), sg.InputText()], [sg.Text('Número de mortos', size=(30, 1)), sg.InputText()], [sg.Text('Números de recuperados', size=(30, 1)), sg.InputText()], [sg.Submit(), sg.Cancel()] ] window_ins = sg.Window('Dados', layout) event, values = window_ins.read() print(event) if (event == 'Cancel'): window_ins.close() else: for i in values: dado.append(values[i]) dado[0] = int(dado[0]) aux2 = Struct.CovidLine(*dado) if (opcao == 1): estrutura.inserir(aux2) elif (opcao == 2): estrutura2.inserir(aux2) elif (opcao == 3): estrutura3.inserir(aux2) window_ins.close()
def getProductInfo(keyword): L = [] url = 'https://www.bloomingdales.com/shop/search?keyword=%s' % keyword response = requests.get(url, headers={'User-Agent': "Mozilla/5.0"}) soup = BeautifulSoup(response.content, 'html.parser') # print ('url: ' + str(url)) # print ('status code: ' + str(response.status_code)) # print ('encoding: ' + str(response.encoding)) for product in soup.find_all('div', class_='productThumbnail'): # print ("---") product_url = 'https://www.bloomingdales.com' + product.find( 'a', class_='productDescLink')['href'] # picture_url = product.find('img', class_ = 'thumbnailImage')['src'] source = product.find('source', class_='thumbnailImage') if source.get('srcset') == None: picture_url = source['data-srcset'] else: picture_url = source['srcset'] if product.find('span', class_='regular') == None: continue price = product.find('span', class_='regular').text.strip(' \t\n') # score = product.find('div', class_ = 'b-pdp-rating').find('div')['style'] span_lis = product.find('div', class_='productDescription').find_all('span') span_num = len(span_lis) if span_num == 1: brand = span_lis[0].string name = span_lis[0].next_sibling.string.strip(' \t\n') else: brand = span_lis[0].text name = span_lis[1].text + ' ' + span_lis[2].text product = Struct.Product(brand, name, float(price[1:]), product_url, picture_url, 4.0) L.append(product) #print (product_url) #print (picture_url) #print (price) # print (score) #print (brand) #print (name) return L
def main(): stop_api_update = False number_of_api_updates = 4 alarm = False user = get_user("ID_VALUE") # "sign in" as user pprint.pprint(user['events'][0]) next_event = Struct.Struct(**user['events'] [0]) # convert dict returned to Struct object next_event.travel_time = TrafficAPI.get_travel_time( next_event, False) # call api to determine the average travel time (not delay) api_call_time = calculate_api_call( next_event) # get time at which the api needs to be called print(f"api_call_time: {api_call_time}") usual_travel_delay = next_event.travel_time + next_event.buffer alarm_time = update_time( next_event.time, usual_travel_delay) # calculate the regular alarm time (no delay) print(f"Alarm time : {alarm_time}") while alarm == False: current_time = datetime.datetime.now() if (current_time >= api_call_time) and not stop_api_update: travel_time_delay = TrafficAPI.get_travel_time( next_event, True) # gets the travel time with live traffic (seconds) departure_time_delay = travel_time_delay + next_event.buffer alarm_time = update_time(next_event.time, departure_time_delay + next_event.buffer) # update alarm time print(f"Alarm time updated to: {alarm_time}") # update the api call time so it is not continuatlly called api_call_time = calculate_api_call(next_event, api_call_time, number_of_api_updates) print(f"API call time updated to: {api_call_time}") number_of_api_updates -= 1 if (number_of_api_updates == 1): stop_api_update = True if current_time >= alarm_time: print("Sound the Alarm") alarm = True
def load_struct(self): print("info: loading file:" + self.path) # check exist file if not os.path.exists(self.path): try: raise ValueError("Error: fine not exist") except ValueError as e: traceback.print_exc() # check file type root, ext = os.path.splitext(self.path) if not ext == '.yml' or ext == '.yaml': try: raise ValueError("Error: file is not yaml file") except ValueError as e: traceback.print_exc() # get info try: with open(self.path) as file: # PyYaml Setting yaml.add_constructor( yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, lambda loader, node: OrderedDict( loader.construct_pairs(node))) obj = yaml.load(file) print(obj) # detect struct_name key for key in obj.keys(): if key == 'msg_id': self.msg_id = obj[key] else: self.struct_name = key # create instance self.struct = st.Struct(self.struct_name, self.msg_id) # add variables for key in obj[self.struct_name].keys(): variable_name = key variable_type = obj[self.struct_name][key] # add self.struct.add_variable(variable_name, variable_type) except Exception as e: traceback.print_exc()
def __init__(self, parent, controller): tk.Frame.__init__(self, parent) self.controller = controller label = tk.Label(self, text="Lista") label.grid(row=0, column=1, padx=5, pady=5) estrutura = ListaDinamica.CoviList() data = pd.read_csv("./covid_19_data.csv", header=1, na_filter=True, na_values='nan', keep_default_na=False) aux = list(range(len(data))) random.shuffle(aux) x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 button1 = tk.Button(self, text="Voltar", command=lambda: controller.show_frame(Main)) button1.grid(row=3, column=1, padx=5, pady=5) button2 = tk.Button( self, text="Imprimir na tela", command=lambda: controller.show_frame(P1).estrutura.visualizar()) button2.grid(row=1, column=1, padx=5, pady=5) button3 = tk.Button(self, text="Exportar para arquivo de texto", command=lambda: controller.show_frame()) button3.grid(row=2, column=1, padx=5, pady=5)
class PEFile(BinaryAccessor): class SectionInfo: def __init__(self): self.virtual_size = None self.virtual_address = None self.size_of_raw_data = None self.pointer_to_raw_data = None self.characteristics = None def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_pe(): return try: self.tree = Struct(self.data) self.mz = self.tree.struct("MZ header", "mz") self.mz.uint16("magic") self.mz.uint16("lastsize") self.mz.uint16("nblocks") self.mz.uint16("nreloc") self.mz.uint16("hdrsize") self.mz.uint16("minalloc") self.mz.uint16("maxalloc") self.mz.uint16("ss") self.mz.uint16("sp") self.mz.uint16("checksum") self.mz.uint16("ip") self.mz.uint16("cs") self.mz.uint16("relocpos") self.mz.uint16("noverlay") self.mz.bytes(8, "reserved1") self.mz.uint16("oem_id") self.mz.uint16("oem_info") self.mz.bytes(20, "reserved2") self.mz.uint32("pe_offset") self.header = self.tree.struct("PE header", "header") self.header.seek(self.mz.pe_offset) self.header.uint32("magic") self.header.uint16("machine") self.header.uint16("section_count") self.header.uint32("timestamp") self.header.uint32("coff_symbol_table") self.header.uint32("coff_symbol_count") self.header.uint16("optional_header_size") self.header.uint16("characteristics") self.header.struct("Optional header", "opt") self.header.opt.uint16("magic") self.header.opt.uint8("major_linker_version") self.header.opt.uint8("minor_linker_version") self.header.opt.uint32("size_of_code") self.header.opt.uint32("size_of_init_data") self.header.opt.uint32("size_of_uninit_data") self.header.opt.uint32("address_of_entry") self.header.opt.uint32("base_of_code") if self.header.opt.magic == 0x10b: # 32-bit self.bits = 32 self.header.opt.uint32("base_of_data") self.header.opt.uint32("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint32("size_of_stack_reserve") self.header.opt.uint32("size_of_stack_commit") self.header.opt.uint32("size_of_heap_reserve") self.header.opt.uint32("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") elif self.header.opt.magic == 0x20b: # 64-bit self.bits = 64 self.header.opt.uint64("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint64("size_of_stack_reserve") self.header.opt.uint64("size_of_stack_commit") self.header.opt.uint64("size_of_heap_reserve") self.header.opt.uint64("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") else: self.valid = False return self.image_base = self.header.opt.image_base self.data_dirs = self.header.array(self.header.opt.data_dir_count, "data_dirs") for i in xrange(0, self.header.opt.data_dir_count): self.data_dirs[i].uint32("virtual_address") self.data_dirs[i].uint32("size") self.sections = [] header_section_obj = PEFile.SectionInfo() header_section_obj.virtual_size = self.header.opt.size_of_headers header_section_obj.virtual_address = 0 header_section_obj.size_of_raw_data = self.header.opt.size_of_headers header_section_obj.pointer_to_raw_data = 0 header_section_obj.characteristics = 0 self.sections.append(header_section_obj) self.tree.array(self.header.section_count, "sections") for i in xrange(0, self.header.section_count): section = self.tree.sections[i] section.seek(self.mz.pe_offset + self.header.optional_header_size + 24 + (i * 40)) section.bytes(8, "name") section.uint32("virtual_size") section.uint32("virtual_address") section.uint32("size_of_raw_data") section.uint32("pointer_to_raw_data") section.uint32("pointer_to_relocs") section.uint32("pointer_to_line_numbers") section.uint16("reloc_count") section.uint16("line_number_count") section.uint32("characteristics") section_obj = PEFile.SectionInfo() section_obj.virtual_size = section.virtual_size section_obj.virtual_address = section.virtual_address & ~( self.header.opt.section_align - 1) section_obj.size_of_raw_data = section.size_of_raw_data section_obj.pointer_to_raw_data = section.pointer_to_raw_data & ~( self.header.opt.file_align - 1) section_obj.characteristics = section.characteristics self.sections.append(section_obj) self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" if self.header.opt.data_dir_count >= 2: self.imports = self.tree.array(0, "imports") for i in xrange(0, self.data_dirs[1].size / 20): if self.read( self.image_base + self.data_dirs[1].virtual_address + (i * 20), 4) == "\0\0\0\0": break if self.read( self.image_base + self.data_dirs[1].virtual_address + (i * 20) + 16, 4) == "\0\0\0\0": break self.imports.append() dll = self.imports[i] dll.seek( self.virtual_address_to_file_offset( self.image_base + self.data_dirs[1].virtual_address) + (i * 20)) dll.uint32("lookup") dll.uint32("timestamp") dll.uint32("forward_chain") dll.uint32("name") dll.uint32("iat") for dll in self.imports: name = self.read_string(self.image_base + dll.name).split('.') if len(name) > 1: name = '.'.join(name[0:-1]) else: name = name[0] entry_ofs = self.image_base + dll.lookup iat_ofs = self.image_base + dll.iat while True: if self.bits == 32: entry = self.read_uint32(entry_ofs) is_ordinal = (entry & 0x80000000) != 0 entry &= 0x7fffffff else: entry = self.read_uint64(entry_ofs) is_ordinal = (entry & 0x8000000000000000) != 0 entry &= 0x7fffffffffffffff if (not is_ordinal) and (entry == 0): break if is_ordinal: func = name + "!Ordinal%d" % (entry & 0xffff) else: func = name + "!" + self.read_string( self.image_base + entry + 2) self.symbols_by_name[func] = iat_ofs self.symbols_by_addr[iat_ofs] = func entry_ofs += self.bits / 8 iat_ofs += self.bits / 8 if (self.header.opt.data_dir_count >= 1) and (self.data_dirs[0].size >= 40): self.exports = self.tree.struct("Export directory", "exports") self.exports.seek( self.virtual_address_to_file_offset( self.image_base + self.data_dirs[0].virtual_address)) self.exports.uint32("characteristics") self.exports.uint32("timestamp") self.exports.uint16("major_version") self.exports.uint16("minor_version") self.exports.uint32("dll_name") self.exports.uint32("base") self.exports.uint32("function_count") self.exports.uint32("name_count") self.exports.uint32("address_of_functions") self.exports.uint32("address_of_names") self.exports.uint32("address_of_name_ordinals") self.exports.array(self.exports.function_count, "functions") for i in xrange(0, self.exports.function_count): self.exports.functions[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_functions) + (i * 4)) self.exports.functions[i].uint32("address") self.exports.array(self.exports.name_count, "names") for i in xrange(0, self.exports.name_count): self.exports.names[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_names) + (i * 4)) self.exports.names[i].uint32("address_of_name") self.exports.array(self.exports.name_count, "name_ordinals") for i in xrange(0, self.exports.name_count): self.exports.name_ordinals[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_name_ordinals) + (i * 2)) self.exports.name_ordinals[i].uint16("ordinal") for i in xrange(0, self.exports.name_count): function_index = self.exports.name_ordinals[ i].ordinal - self.exports.base address = self.image_base + self.exports.functions[ function_index].address name = self.read_string( self.image_base + self.exports.names[i].address_of_name) self.symbols_by_addr[address] = name self.symbols_by_name[name] = address self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self) def read_string(self, addr): result = "" while True: ch = self.read(addr, 1) addr += 1 if (len(ch) == 0) or (ch == '\0'): break result += ch return result def virtual_address_to_file_offset(self, addr): for i in self.sections: if ((addr >= (self.image_base + i.virtual_address)) and (addr < (self.image_base + i.virtual_address + i.virtual_size))) and ( i.virtual_size != 0): cur = i if cur == None: return None ofs = addr - (self.image_base + cur.virtual_address) return cur.pointer_to_raw_data + ofs def read(self, ofs, len): result = "" while len > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size)) ) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += "\x00" * mem_len len -= mem_len ofs += mem_len continue result += self.data.read(cur.pointer_to_raw_data + prog_ofs, file_len) len -= file_len ofs += file_len return result def next_valid_addr(self, ofs): result = -1 for i in self.sections: if ((self.image_base + i.virtual_address) >= ofs) and (i.virtual_size != 0) and ((result == -1) or ( (self.image_base + i.virtual_address) < result)): result = self.image_base + i.virtual_address return result def get_modification(self, ofs, len): result = [] while len > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size)) ) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += [DATA_ORIGINAL] * mem_len len -= mem_len ofs += mem_len continue result += self.data.get_modification( cur.pointer_to_raw_data + prog_ofs, file_len) len -= file_len ofs += file_len return result def write(self, ofs, data): result = 0 while len(data) > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size)) ) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: break result += self.data.write(cur.pointer_to_raw_data + prog_ofs, data[0:file_len]) data = data[file_len:] ofs += file_len return result def insert(self, ofs, data): return 0 def remove(self, ofs, size): return 0 def notify_data_write(self, data, ofs, contents): # Find sections that hold data backed by updated regions of the file for i in self.sections: if ((ofs + len(contents)) > i.pointer_to_raw_data) and ( ofs < (i.pointer_to_raw_data + i.size_of_raw_data)) and ( i.virtual_size != 0): # This section has been updated, compute which region has been changed from_start = ofs - i.pointer_to_raw_data data_ofs = 0 length = len(contents) if from_start < 0: length += from_start data_ofs -= from_start from_start = 0 if (from_start + length) > i.size_of_raw_data: length = i.size_of_raw_data - from_start # Notify callbacks if length > 0: for cb in self.callbacks: if hasattr(cb, "notify_data_write"): cb.notify_data_write( self, self.image_base + i.virtual_address + from_start, contents[data_ofs:(data_ofs + length)]) def save(self, filename): self.data.save(filename) def start(self): return self.image_base def entry(self): return self.image_base + self.header.opt.address_of_entry def __len__(self): max = None for i in self.sections: if ((max == None) or ((self.image_base + i.virtual_address + i.virtual_size) > max)) and (i.virtual_size != 0): max = self.image_base + i.virtual_address + i.virtual_size return max - self.start() def is_pe(self): if self.data.read(0, 2) != "MZ": return False ofs = self.data.read(0x3c, 4) if len(ofs) != 4: return False ofs = struct.unpack("<I", ofs)[0] if self.data.read(ofs, 4) != "PE\0\0": return False magic = self.data.read(ofs + 24, 2) if len(magic) != 2: return False magic = struct.unpack("<H", magic)[0] return (magic == 0x10b) or (magic == 0x20b) def architecture(self): if self.header.machine == 0x14c: return "x86" if self.header.machine == 0x8664: return "x86_64" if self.header.machine == 0x166: return "mips" if self.header.machine == 0x266: return "mips16" if self.header.machine == 0x366: return "mips" if self.header.machine == 0x466: return "mips16" if self.header.machine == 0x1f0: return "ppc" if self.header.machine == 0x1f1: return "ppc" if self.header.machine == 0x1c0: return "arm" if self.header.machine == 0x1c2: return "thumb" if self.header.machine == 0x1c4: return "thumb" if self.header.machine == 0xaa64: return "arm64" if self.header.machine == 0x200: return "ia64" return None def decorate_plt_name(self, name): return name + "@IAT" def create_symbol(self, addr, name): self.symbols_by_name[name] = addr self.symbols_by_addr[addr] = name def delete_symbol(self, addr, name): if name in self.symbols_by_name: del (self.symbols_by_name[name]) if addr in self.symbols_by_addr: del (self.symbols_by_addr[addr]) def add_callback(self, cb): self.callbacks.append(cb) def remove_callback(self, cb): self.callbacks.remove(cb) def is_modified(self): return self.data.is_modified() def find(self, regex, addr): while (addr < self.end()) and (addr != -1): data = self.read(addr, 0xfffffffff) match = regex.search(data) if match != None: return match.start() + addr addr += len(data) addr = self.next_valid_addr(addr) return -1 def has_undo_actions(self): return self.data.has_undo_actions() def commit_undo(self, before_loc, after_loc): self.data.commit_undo(before_loc, after_loc) def undo(self): self.data.undo() def redo(self): self.data.redo()
def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_pe(): return try: self.tree = Struct(self.data) self.mz = self.tree.struct("MZ header", "mz") self.mz.uint16("magic") self.mz.uint16("lastsize") self.mz.uint16("nblocks") self.mz.uint16("nreloc") self.mz.uint16("hdrsize") self.mz.uint16("minalloc") self.mz.uint16("maxalloc") self.mz.uint16("ss") self.mz.uint16("sp") self.mz.uint16("checksum") self.mz.uint16("ip") self.mz.uint16("cs") self.mz.uint16("relocpos") self.mz.uint16("noverlay") self.mz.bytes(8, "reserved1") self.mz.uint16("oem_id") self.mz.uint16("oem_info") self.mz.bytes(20, "reserved2") self.mz.uint32("pe_offset") self.header = self.tree.struct("PE header", "header") self.header.seek(self.mz.pe_offset) self.header.uint32("magic") self.header.uint16("machine") self.header.uint16("section_count") self.header.uint32("timestamp") self.header.uint32("coff_symbol_table") self.header.uint32("coff_symbol_count") self.header.uint16("optional_header_size") self.header.uint16("characteristics") self.header.struct("Optional header", "opt") self.header.opt.uint16("magic") self.header.opt.uint8("major_linker_version") self.header.opt.uint8("minor_linker_version") self.header.opt.uint32("size_of_code") self.header.opt.uint32("size_of_init_data") self.header.opt.uint32("size_of_uninit_data") self.header.opt.uint32("address_of_entry") self.header.opt.uint32("base_of_code") if self.header.opt.magic == 0x10b: # 32-bit self.bits = 32 self.header.opt.uint32("base_of_data") self.header.opt.uint32("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint32("size_of_stack_reserve") self.header.opt.uint32("size_of_stack_commit") self.header.opt.uint32("size_of_heap_reserve") self.header.opt.uint32("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") elif self.header.opt.magic == 0x20b: # 64-bit self.bits = 64 self.header.opt.uint64("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint64("size_of_stack_reserve") self.header.opt.uint64("size_of_stack_commit") self.header.opt.uint64("size_of_heap_reserve") self.header.opt.uint64("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") else: self.valid = False return self.image_base = self.header.opt.image_base self.data_dirs = self.header.array(self.header.opt.data_dir_count, "data_dirs") for i in xrange(0, self.header.opt.data_dir_count): self.data_dirs[i].uint32("virtual_address") self.data_dirs[i].uint32("size") self.sections = [] header_section_obj = PEFile.SectionInfo() header_section_obj.virtual_size = self.header.opt.size_of_headers header_section_obj.virtual_address = 0 header_section_obj.size_of_raw_data = self.header.opt.size_of_headers header_section_obj.pointer_to_raw_data = 0 header_section_obj.characteristics = 0 self.sections.append(header_section_obj) self.tree.array(self.header.section_count, "sections") for i in xrange(0, self.header.section_count): section = self.tree.sections[i] section.seek(self.mz.pe_offset + self.header.optional_header_size + 24 + (i * 40)) section.bytes(8, "name") section.uint32("virtual_size") section.uint32("virtual_address") section.uint32("size_of_raw_data") section.uint32("pointer_to_raw_data") section.uint32("pointer_to_relocs") section.uint32("pointer_to_line_numbers") section.uint16("reloc_count") section.uint16("line_number_count") section.uint32("characteristics") section_obj = PEFile.SectionInfo() section_obj.virtual_size = section.virtual_size section_obj.virtual_address = section.virtual_address & ~( self.header.opt.section_align - 1) section_obj.size_of_raw_data = section.size_of_raw_data section_obj.pointer_to_raw_data = section.pointer_to_raw_data & ~( self.header.opt.file_align - 1) section_obj.characteristics = section.characteristics self.sections.append(section_obj) self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" if self.header.opt.data_dir_count >= 2: self.imports = self.tree.array(0, "imports") for i in xrange(0, self.data_dirs[1].size / 20): if self.read( self.image_base + self.data_dirs[1].virtual_address + (i * 20), 4) == "\0\0\0\0": break if self.read( self.image_base + self.data_dirs[1].virtual_address + (i * 20) + 16, 4) == "\0\0\0\0": break self.imports.append() dll = self.imports[i] dll.seek( self.virtual_address_to_file_offset( self.image_base + self.data_dirs[1].virtual_address) + (i * 20)) dll.uint32("lookup") dll.uint32("timestamp") dll.uint32("forward_chain") dll.uint32("name") dll.uint32("iat") for dll in self.imports: name = self.read_string(self.image_base + dll.name).split('.') if len(name) > 1: name = '.'.join(name[0:-1]) else: name = name[0] entry_ofs = self.image_base + dll.lookup iat_ofs = self.image_base + dll.iat while True: if self.bits == 32: entry = self.read_uint32(entry_ofs) is_ordinal = (entry & 0x80000000) != 0 entry &= 0x7fffffff else: entry = self.read_uint64(entry_ofs) is_ordinal = (entry & 0x8000000000000000) != 0 entry &= 0x7fffffffffffffff if (not is_ordinal) and (entry == 0): break if is_ordinal: func = name + "!Ordinal%d" % (entry & 0xffff) else: func = name + "!" + self.read_string( self.image_base + entry + 2) self.symbols_by_name[func] = iat_ofs self.symbols_by_addr[iat_ofs] = func entry_ofs += self.bits / 8 iat_ofs += self.bits / 8 if (self.header.opt.data_dir_count >= 1) and (self.data_dirs[0].size >= 40): self.exports = self.tree.struct("Export directory", "exports") self.exports.seek( self.virtual_address_to_file_offset( self.image_base + self.data_dirs[0].virtual_address)) self.exports.uint32("characteristics") self.exports.uint32("timestamp") self.exports.uint16("major_version") self.exports.uint16("minor_version") self.exports.uint32("dll_name") self.exports.uint32("base") self.exports.uint32("function_count") self.exports.uint32("name_count") self.exports.uint32("address_of_functions") self.exports.uint32("address_of_names") self.exports.uint32("address_of_name_ordinals") self.exports.array(self.exports.function_count, "functions") for i in xrange(0, self.exports.function_count): self.exports.functions[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_functions) + (i * 4)) self.exports.functions[i].uint32("address") self.exports.array(self.exports.name_count, "names") for i in xrange(0, self.exports.name_count): self.exports.names[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_names) + (i * 4)) self.exports.names[i].uint32("address_of_name") self.exports.array(self.exports.name_count, "name_ordinals") for i in xrange(0, self.exports.name_count): self.exports.name_ordinals[i].seek( self.virtual_address_to_file_offset( self.image_base + self.exports.address_of_name_ordinals) + (i * 2)) self.exports.name_ordinals[i].uint16("ordinal") for i in xrange(0, self.exports.name_count): function_index = self.exports.name_ordinals[ i].ordinal - self.exports.base address = self.image_base + self.exports.functions[ function_index].address name = self.read_string( self.image_base + self.exports.names[i].address_of_name) self.symbols_by_addr[address] = name self.symbols_by_name[name] = address self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self)
def bands(self, args): """ This method performs the band structure calculations. """ dest_dir = "bands" dummy_broaden = 1.0 # spin polarized calculation? sp = args.sp # creating directory for bands if os.path.exists("bands"): print("bands directory already exists.") else: os.makedirs("bands") # copy Sig.out into /bands if self.checksig(): shutil.copyfile("./ac/Sig.out", "./bands/Sig1.out") else: sys.exit() # interpolating self.interpol(args.emin, args.emax, args.rom, dummy_broaden, dest_dir, sp) #############################Xingu's contribution################################################################################### #########################Read POSCAR ################################################### TB = Struct.TBstructure("POSCAR", p["atomnames"], p["orbs"]) cor_at = p["cor_at"] cor_orb = p["cor_orb"] TB.Compute_cor_idx(cor_at, cor_orb) ############################# Generate sequence list ################################## sort_atm = sorted([atm for atms in cor_at for atm in atms]) atm_sqn = self.Make_coor_list(sort_atm, cor_at) print("atm_sqn:%s" % atm_sqn) orb_sqn = [] for i in atm_sqn: len_sf = 0 for j in range(i): len_sf += max( Make_coor_list(TB.TB_orbs[cor_at[j][0]], cor_orb[j])) + 1 orb_idx = self.Make_coor_list(TB.TB_orbs[cor_at[i][0]], cor_orb[i]) for idx in orb_idx: orb_sqn.append(idx + len_sf) print("orb_sqn:%s" % orb_sqn) ################################# Read sig.inp_real #################################### # non spin-polarized calculation if sp == False: fi = open("./bands/sig.inp_real", "r") [nom, ncor_orb] = [int(ele) for ele in fi.readline().split()[-2:]] temperature = float(fi.readline().split()[-1]) sigmdc_tmp = [ float(ele) for ele in fi.readline().split()[-1 * ncor_orb:] ] sigoo = fi.readline().split() vdc = fi.readline().split() sig_real = np.array([ele.split() for ele in fi.readlines()]) fi.close() assert np.shape(sig_real)[0] == nom ###################### Write SigMoo ################## SigMoo = np.zeros((nom, len(orb_sqn) * 2 + 1), dtype=float) SigMoo[:, 0] = np.array(sig_real[:, 0]) for i in range(len(orb_sqn)): SigMoo[:, i * 2 + 1] = np.array(sig_real[:, orb_sqn[i] * 2 + 1]) SigMoo[:, i * 2 + 2] = np.array(sig_real[:, orb_sqn[i] * 2 + 2]) np.savetxt("./bands/SigMoo_real.out", SigMoo, fmt="%.10f") ############################ Srite SigMdc.out ######################## SigMdc = np.array([sigmdc_tmp[i] for i in orb_sqn]) np.savetxt("./bands/SigMdc.out", SigMdc[None], fmt="%.12f") # spin polarized calculation if sp: siginpreal_files = ["sig.inp_real", "sig.inp_real_dn"] SigMooreal_files = ["SigMoo_real.out", "SigMoo_dn_real.out"] SigMdc_files = ["SigMdc.out", "SigMdc_dn.out"] for filecounter in range(len(siginpreal_files)): filestr = "./bands/" + siginpreal_files[filecounter] fi = open(filestr, "r") [nom, ncor_orb] = [int(ele) for ele in fi.readline().split()[-2:]] temperature = float(fi.readline().split()[-1]) sigmdc_tmp = [ float(ele) for ele in fi.readline().split()[-1 * ncor_orb:] ] sigoo = fi.readline().split() vdc = fi.readline().split() sig_real = np.array([ele.split() for ele in fi.readlines()]) fi.close() assert np.shape(sig_real)[0] == nom ###################### Write SigMoo ################## SigMoo = np.zeros((nom, len(orb_sqn) * 2 + 1), dtype=float) SigMoo[:, 0] = np.array(sig_real[:, 0]) for i in range(len(orb_sqn)): SigMoo[:, i * 2 + 1] = np.array(sig_real[:, orb_sqn[i] * 2 + 1]) SigMoo[:, i * 2 + 2] = np.array(sig_real[:, orb_sqn[i] * 2 + 2]) filestr = "./bands/" + SigMooreal_files[filecounter] np.savetxt(filestr, SigMoo, fmt="%.10f") ############################ Write SigMdc.out ######################## SigMdc = np.array([sigmdc_tmp[i] for i in orb_sqn]) print(sigmdc_tmp) print(SigMdc) filestr = "./bands/" + SigMdc_files[filecounter] np.savetxt(filestr, SigMdc[None], fmt="%.12f") # ################################################################################################################ print("kpband=%s" % args.kpband) print("kplist=%s" % args.kplist) print("knames=%s" % args.knames) # generating k-path klist, dist_K, dist_SK = self.Create_kpath(args.kplist, args.kpband) fi = open("./bands/klist.dat", "w") for i in range(args.kpband): kcheck = 0 for j, d in enumerate(dist_SK): if abs(dist_K[i] - d) < 1e-10: fi.write("%.14f %.14f %.14f %.14f %s \n" % ( dist_K[i], klist[i][0], klist[i][1], klist[i][2], args.knames[j], )) kcheck = 1 break if kcheck == 0: fi.write("%.14f %.14f %.14f %.14f \n" % (dist_K[i], klist[i][0], klist[i][1], klist[i][2])) print("k-path generated.") fi.close() # copying files from DMFT directory to dos directory cmd = "cd bands && Copy_input.py ../ -post bands" out, err = subprocess.Popen(cmd, shell=True).communicate() if err: print("File copy failed!\n") print(err) sys.exit() else: print(out) # generating ksum.input self.genksum(args.rom, args.kpband) # running dmft_ksum_band if args.plotplain: print("\nCalculating plain band structure...") cmd = "cd bands && " + self.para_com + " " + "dmft_ksum_band" out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() if err: print(err) print("Band structure calculation failed!\n") sys.exit() else: print("Band structure calculation complete.\n") self.plot_plain_bands(args) if args.plotpartial: print("\nCalculating projected band structure...") cmd = "cd bands && " + self.para_com + " " + "dmft_ksum_partial_band" out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() if err: print(err) print("Band structure calculation failed!\n") sys.exit() else: print("Band structure calculation complete.\n") self.plot_partial_bands(args) if sp: print("\nCalculating spin-polarized band structure...") cmd = "cd bands && " + self.para_com + " " + "dmft_ksum_band" out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() if err: print(err) print("Band structure calculation failed!\n") sys.exit() else: print("Band structure calculation complete.\n") self.plot_sp_bands(args)
def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_pe(): return try: self.tree = Struct(self.data) self.mz = self.tree.struct("MZ header", "mz") self.mz.uint16("magic") self.mz.uint16("lastsize") self.mz.uint16("nblocks") self.mz.uint16("nreloc") self.mz.uint16("hdrsize") self.mz.uint16("minalloc") self.mz.uint16("maxalloc") self.mz.uint16("ss") self.mz.uint16("sp") self.mz.uint16("checksum") self.mz.uint16("ip") self.mz.uint16("cs") self.mz.uint16("relocpos") self.mz.uint16("noverlay") self.mz.bytes(8, "reserved1") self.mz.uint16("oem_id") self.mz.uint16("oem_info") self.mz.bytes(20, "reserved2") self.mz.uint32("pe_offset") self.header = self.tree.struct("PE header", "header") self.header.seek(self.mz.pe_offset) self.header.uint32("magic") self.header.uint16("machine") self.header.uint16("section_count") self.header.uint32("timestamp") self.header.uint32("coff_symbol_table") self.header.uint32("coff_symbol_count") self.header.uint16("optional_header_size") self.header.uint16("characteristics") self.header.struct("Optional header", "opt") self.header.opt.uint16("magic") self.header.opt.uint8("major_linker_version") self.header.opt.uint8("minor_linker_version") self.header.opt.uint32("size_of_code") self.header.opt.uint32("size_of_init_data") self.header.opt.uint32("size_of_uninit_data") self.header.opt.uint32("address_of_entry") self.header.opt.uint32("base_of_code") if self.header.opt.magic == 0x10b: # 32-bit self.bits = 32 self.header.opt.uint32("base_of_data") self.header.opt.uint32("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint32("size_of_stack_reserve") self.header.opt.uint32("size_of_stack_commit") self.header.opt.uint32("size_of_heap_reserve") self.header.opt.uint32("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") elif self.header.opt.magic == 0x20b: # 64-bit self.bits = 64 self.header.opt.uint64("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint64("size_of_stack_reserve") self.header.opt.uint64("size_of_stack_commit") self.header.opt.uint64("size_of_heap_reserve") self.header.opt.uint64("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") else: self.valid = False return self.image_base = self.header.opt.image_base self.data_dirs = self.header.array(self.header.opt.data_dir_count, "data_dirs") for i in xrange(0, self.header.opt.data_dir_count): self.data_dirs[i].uint32("virtual_address") self.data_dirs[i].uint32("size") self.sections = [] header_section_obj = PEFile.SectionInfo() header_section_obj.virtual_size = self.header.opt.size_of_headers header_section_obj.virtual_address = 0 header_section_obj.size_of_raw_data = self.header.opt.size_of_headers header_section_obj.pointer_to_raw_data = 0 header_section_obj.characteristics = 0 self.sections.append(header_section_obj) self.tree.array(self.header.section_count, "sections") for i in xrange(0, self.header.section_count): section = self.tree.sections[i] section.seek(self.mz.pe_offset + self.header.optional_header_size + 24 + (i * 40)) section.bytes(8, "name") section.uint32("virtual_size") section.uint32("virtual_address") section.uint32("size_of_raw_data") section.uint32("pointer_to_raw_data") section.uint32("pointer_to_relocs") section.uint32("pointer_to_line_numbers") section.uint16("reloc_count") section.uint16("line_number_count") section.uint32("characteristics") section_obj = PEFile.SectionInfo() section_obj.virtual_size = section.virtual_size section_obj.virtual_address = section.virtual_address & ~(self.header.opt.section_align - 1) section_obj.size_of_raw_data = section.size_of_raw_data section_obj.pointer_to_raw_data = section.pointer_to_raw_data & ~(self.header.opt.file_align - 1) section_obj.characteristics = section.characteristics self.sections.append(section_obj) self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" if self.header.opt.data_dir_count >= 2: self.imports = self.tree.array(0, "imports") for i in xrange(0, self.data_dirs[1].size / 20): if self.read(self.image_base + self.data_dirs[1].virtual_address + (i * 20), 4) == "\0\0\0\0": break if self.read(self.image_base + self.data_dirs[1].virtual_address + (i * 20) + 16, 4) == "\0\0\0\0": break self.imports.append() dll = self.imports[i] dll.seek(self.virtual_address_to_file_offset(self.image_base + self.data_dirs[1].virtual_address) + (i * 20)) dll.uint32("lookup") dll.uint32("timestamp") dll.uint32("forward_chain") dll.uint32("name") dll.uint32("iat") for dll in self.imports: name = self.read_string(self.image_base + dll.name).split('.') if len(name) > 1: name = '.'.join(name[0:-1]) else: name = name[0] entry_ofs = self.image_base + dll.lookup iat_ofs = self.image_base + dll.iat while True: if self.bits == 32: entry = self.read_uint32(entry_ofs) is_ordinal = (entry & 0x80000000) != 0 entry &= 0x7fffffff else: entry = self.read_uint64(entry_ofs) is_ordinal = (entry & 0x8000000000000000) != 0 entry &= 0x7fffffffffffffff if (not is_ordinal) and (entry == 0): break if is_ordinal: func = name + "!Ordinal%d" % (entry & 0xffff) else: func = name + "!" + self.read_string(self.image_base + entry + 2) self.symbols_by_name[func] = iat_ofs self.symbols_by_addr[iat_ofs] = func entry_ofs += self.bits / 8 iat_ofs += self.bits / 8 if (self.header.opt.data_dir_count >= 1) and (self.data_dirs[0].size >= 40): self.exports = self.tree.struct("Export directory", "exports") self.exports.seek(self.virtual_address_to_file_offset(self.image_base + self.data_dirs[0].virtual_address)) self.exports.uint32("characteristics") self.exports.uint32("timestamp") self.exports.uint16("major_version") self.exports.uint16("minor_version") self.exports.uint32("dll_name") self.exports.uint32("base") self.exports.uint32("function_count") self.exports.uint32("name_count") self.exports.uint32("address_of_functions") self.exports.uint32("address_of_names") self.exports.uint32("address_of_name_ordinals") self.exports.array(self.exports.function_count, "functions") for i in xrange(0, self.exports.function_count): self.exports.functions[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_functions) + (i * 4)) self.exports.functions[i].uint32("address") self.exports.array(self.exports.name_count, "names") for i in xrange(0, self.exports.name_count): self.exports.names[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_names) + (i * 4)) self.exports.names[i].uint32("address_of_name") self.exports.array(self.exports.name_count, "name_ordinals") for i in xrange(0, self.exports.name_count): self.exports.name_ordinals[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_name_ordinals) + (i * 2)) self.exports.name_ordinals[i].uint16("ordinal") for i in xrange(0, self.exports.name_count): function_index = self.exports.name_ordinals[i].ordinal - self.exports.base address = self.image_base + self.exports.functions[function_index].address name = self.read_string(self.image_base + self.exports.names[i].address_of_name) self.symbols_by_addr[address] = name self.symbols_by_name[name] = address self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self)
def __init__(self): layout = [[ sg.Button('Adicionar novo dado'), sg.Button('Remover item') ], [sg.Button('Ver dados')], [sg.Button('Exportar para arquivo de texto')], [sg.Button('Voltar')]] win = sg.Window('Opções', layout) event, value = win.read() if (event == 'Ver dados'): win.close() janela1_tel() elif (event == 'Adicionar novo dado'): dado = [] layout = [ [sg.Text('Por favor, informe aqui os dados:')], [sg.Text('Chave', size=(30, 1)), sg.InputText()], [sg.Text('Data de Observação', size=(30, 1)), sg.InputText()], [ sg.Text('Estado da Província (Se for na China)', size=(30, 1)), sg.InputText() ], [sg.Text('Região do País', size=(30, 1)), sg.InputText()], [sg.Text('Última Atualização', size=(30, 1)), sg.InputText()], [sg.Text('Casos confirmados', size=(30, 1)), sg.InputText()], [sg.Text('Número de mortos', size=(30, 1)), sg.InputText()], [ sg.Text('Números de recuperados', size=(30, 1)), sg.InputText() ], [sg.Submit(), sg.Cancel()] ] window_ins = sg.Window('Dados', layout) event, values = window_ins.read() window_ins.close() for i in values: dado.append(values[i]) aux2 = Struct.CovidLine(*dado) for i in values: dado.append(i) estrutura.inserir(aux2) win.close() janela1() elif (event == 'Remover item'): item = estrutura.excluir() pop_done = sg.popup("Removido um item 1 item da estrutura") win.close() janela1_tel() elif (event == 'Exportar para arquivo de texto'): outf = open("saida.txt", "w") estrutura.escrever(outf) sg.popup('Arquivo criado com sucesso!') win.close() janela1() elif (event == 'Voltar'): win.close() Main() elif (event == sg.WIN_CLOSED): win.close()
def __init__(self): layout = [[ sg.Button('Lista'), sg.Button('Fila'), sg.Button('Pilha'), sg.Button('Árvore'), sg.Button('Grafo') ], [sg.Button('Fechar')]] win = sg.Window('Projeto de ED', layout) event, value = win.read() random.shuffle(aux) global estrutura global estrutura2 global estrutura3 if (event == sg.WIN_CLOSED or event == 'Fechar'): win.close() elif (event == "Lista"): estrutura = ListaDinamica.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela_lista() elif (event == "Fila"): estrutura = Fila.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1() elif (event == "Pilha"): estrutura = Pilha.CoviList() x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 win.close() janela1() elif (event == "Árvore"): texto = '''Escolha a lista dos dados que irão ser escolhidos para cada árvore: 0-Somente a chave 1-Data da observação 2-Província (China) 3-País 4-Última atualização 5-Casos Confirmados 6-Número de mortos 7-Número de recuperados ''' for i in range(3): aux2 = sg.popup_get_text( message=texto, title="Digite uma chave da árvore {0}:".format(i + 1)) while (aux2 == None or aux2.isnumeric() == False or not (int(aux2) in range(8))): aux2 = sg.popup_get_text( message=texto, title="Digite uma chave da árvore {0}:".format(i + 1)) if (i == 0): estrutura = Arvore.CoviList(int(aux2)) x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura.inserir(dado) x += 1 if (i == 1): estrutura2 = Arvore.CoviList(int(aux2)) x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura2.inserir(dado) x += 1 if (i == 2): estrutura3 = Arvore.CoviList(int(aux2)) x = 0 while (x < 100): dado = Struct.CovidLine(*data.loc[aux[x]]) estrutura3.inserir(dado) x += 1 win.close() janela_arvore() elif (event == 'Grafo'): estrutura = Grafo.Grafo() for node in Struct.starwars["nodes"]: estrutura.add_vertice(node) for link in Struct.starwars["links"]: estrutura.add_aresta(link["source"], link["target"], 10.0 / link["value"]) estrutura.add_aresta(link["target"], link["source"], 10.0 / link["value"]) win.close() janela_grafo()
class PEFile(BinaryAccessor): class SectionInfo: def __init__(self): self.virtual_size = None self.virtual_address = None self.size_of_raw_data = None self.pointer_to_raw_data = None self.characteristics = None def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_pe(): return try: self.tree = Struct(self.data) self.mz = self.tree.struct("MZ header", "mz") self.mz.uint16("magic") self.mz.uint16("lastsize") self.mz.uint16("nblocks") self.mz.uint16("nreloc") self.mz.uint16("hdrsize") self.mz.uint16("minalloc") self.mz.uint16("maxalloc") self.mz.uint16("ss") self.mz.uint16("sp") self.mz.uint16("checksum") self.mz.uint16("ip") self.mz.uint16("cs") self.mz.uint16("relocpos") self.mz.uint16("noverlay") self.mz.bytes(8, "reserved1") self.mz.uint16("oem_id") self.mz.uint16("oem_info") self.mz.bytes(20, "reserved2") self.mz.uint32("pe_offset") self.header = self.tree.struct("PE header", "header") self.header.seek(self.mz.pe_offset) self.header.uint32("magic") self.header.uint16("machine") self.header.uint16("section_count") self.header.uint32("timestamp") self.header.uint32("coff_symbol_table") self.header.uint32("coff_symbol_count") self.header.uint16("optional_header_size") self.header.uint16("characteristics") self.header.struct("Optional header", "opt") self.header.opt.uint16("magic") self.header.opt.uint8("major_linker_version") self.header.opt.uint8("minor_linker_version") self.header.opt.uint32("size_of_code") self.header.opt.uint32("size_of_init_data") self.header.opt.uint32("size_of_uninit_data") self.header.opt.uint32("address_of_entry") self.header.opt.uint32("base_of_code") if self.header.opt.magic == 0x10b: # 32-bit self.bits = 32 self.header.opt.uint32("base_of_data") self.header.opt.uint32("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint32("size_of_stack_reserve") self.header.opt.uint32("size_of_stack_commit") self.header.opt.uint32("size_of_heap_reserve") self.header.opt.uint32("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") elif self.header.opt.magic == 0x20b: # 64-bit self.bits = 64 self.header.opt.uint64("image_base") self.header.opt.uint32("section_align") self.header.opt.uint32("file_align") self.header.opt.uint16("major_os_version") self.header.opt.uint16("minor_os_version") self.header.opt.uint16("major_image_version") self.header.opt.uint16("minor_image_version") self.header.opt.uint16("major_subsystem_version") self.header.opt.uint16("minor_subsystem_version") self.header.opt.uint32("win32_version") self.header.opt.uint32("size_of_image") self.header.opt.uint32("size_of_headers") self.header.opt.uint32("checksum") self.header.opt.uint16("subsystem") self.header.opt.uint16("dll_characteristics") self.header.opt.uint64("size_of_stack_reserve") self.header.opt.uint64("size_of_stack_commit") self.header.opt.uint64("size_of_heap_reserve") self.header.opt.uint64("size_of_heap_commit") self.header.opt.uint32("loader_flags") self.header.opt.uint32("data_dir_count") else: self.valid = False return self.image_base = self.header.opt.image_base self.data_dirs = self.header.array(self.header.opt.data_dir_count, "data_dirs") for i in xrange(0, self.header.opt.data_dir_count): self.data_dirs[i].uint32("virtual_address") self.data_dirs[i].uint32("size") self.sections = [] header_section_obj = PEFile.SectionInfo() header_section_obj.virtual_size = self.header.opt.size_of_headers header_section_obj.virtual_address = 0 header_section_obj.size_of_raw_data = self.header.opt.size_of_headers header_section_obj.pointer_to_raw_data = 0 header_section_obj.characteristics = 0 self.sections.append(header_section_obj) self.tree.array(self.header.section_count, "sections") for i in xrange(0, self.header.section_count): section = self.tree.sections[i] section.seek(self.mz.pe_offset + self.header.optional_header_size + 24 + (i * 40)) section.bytes(8, "name") section.uint32("virtual_size") section.uint32("virtual_address") section.uint32("size_of_raw_data") section.uint32("pointer_to_raw_data") section.uint32("pointer_to_relocs") section.uint32("pointer_to_line_numbers") section.uint16("reloc_count") section.uint16("line_number_count") section.uint32("characteristics") section_obj = PEFile.SectionInfo() section_obj.virtual_size = section.virtual_size section_obj.virtual_address = section.virtual_address & ~(self.header.opt.section_align - 1) section_obj.size_of_raw_data = section.size_of_raw_data section_obj.pointer_to_raw_data = section.pointer_to_raw_data & ~(self.header.opt.file_align - 1) section_obj.characteristics = section.characteristics self.sections.append(section_obj) self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" if self.header.opt.data_dir_count >= 2: self.imports = self.tree.array(0, "imports") for i in xrange(0, self.data_dirs[1].size / 20): if self.read(self.image_base + self.data_dirs[1].virtual_address + (i * 20), 4) == "\0\0\0\0": break if self.read(self.image_base + self.data_dirs[1].virtual_address + (i * 20) + 16, 4) == "\0\0\0\0": break self.imports.append() dll = self.imports[i] dll.seek(self.virtual_address_to_file_offset(self.image_base + self.data_dirs[1].virtual_address) + (i * 20)) dll.uint32("lookup") dll.uint32("timestamp") dll.uint32("forward_chain") dll.uint32("name") dll.uint32("iat") for dll in self.imports: name = self.read_string(self.image_base + dll.name).split('.') if len(name) > 1: name = '.'.join(name[0:-1]) else: name = name[0] entry_ofs = self.image_base + dll.lookup iat_ofs = self.image_base + dll.iat while True: if self.bits == 32: entry = self.read_uint32(entry_ofs) is_ordinal = (entry & 0x80000000) != 0 entry &= 0x7fffffff else: entry = self.read_uint64(entry_ofs) is_ordinal = (entry & 0x8000000000000000) != 0 entry &= 0x7fffffffffffffff if (not is_ordinal) and (entry == 0): break if is_ordinal: func = name + "!Ordinal%d" % (entry & 0xffff) else: func = name + "!" + self.read_string(self.image_base + entry + 2) self.symbols_by_name[func] = iat_ofs self.symbols_by_addr[iat_ofs] = func entry_ofs += self.bits / 8 iat_ofs += self.bits / 8 if (self.header.opt.data_dir_count >= 1) and (self.data_dirs[0].size >= 40): self.exports = self.tree.struct("Export directory", "exports") self.exports.seek(self.virtual_address_to_file_offset(self.image_base + self.data_dirs[0].virtual_address)) self.exports.uint32("characteristics") self.exports.uint32("timestamp") self.exports.uint16("major_version") self.exports.uint16("minor_version") self.exports.uint32("dll_name") self.exports.uint32("base") self.exports.uint32("function_count") self.exports.uint32("name_count") self.exports.uint32("address_of_functions") self.exports.uint32("address_of_names") self.exports.uint32("address_of_name_ordinals") self.exports.array(self.exports.function_count, "functions") for i in xrange(0, self.exports.function_count): self.exports.functions[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_functions) + (i * 4)) self.exports.functions[i].uint32("address") self.exports.array(self.exports.name_count, "names") for i in xrange(0, self.exports.name_count): self.exports.names[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_names) + (i * 4)) self.exports.names[i].uint32("address_of_name") self.exports.array(self.exports.name_count, "name_ordinals") for i in xrange(0, self.exports.name_count): self.exports.name_ordinals[i].seek(self.virtual_address_to_file_offset(self.image_base + self.exports.address_of_name_ordinals) + (i * 2)) self.exports.name_ordinals[i].uint16("ordinal") for i in xrange(0, self.exports.name_count): function_index = self.exports.name_ordinals[i].ordinal - self.exports.base address = self.image_base + self.exports.functions[function_index].address name = self.read_string(self.image_base + self.exports.names[i].address_of_name) self.symbols_by_addr[address] = name self.symbols_by_name[name] = address self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self) def read_string(self, addr): result = "" while True: ch = self.read(addr, 1) addr += 1 if (len(ch) == 0) or (ch == '\0'): break result += ch return result def virtual_address_to_file_offset(self, addr): for i in self.sections: if ((addr >= (self.image_base + i.virtual_address)) and (addr < (self.image_base + i.virtual_address + i.virtual_size))) and (i.virtual_size != 0): cur = i if cur == None: return None ofs = addr - (self.image_base + cur.virtual_address) return cur.pointer_to_raw_data + ofs def read(self, ofs, len): result = "" while len > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size))) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += "\x00" * mem_len len -= mem_len ofs += mem_len continue result += self.data.read(cur.pointer_to_raw_data + prog_ofs, file_len) len -= file_len ofs += file_len return result def next_valid_addr(self, ofs): result = -1 for i in self.sections: if ((self.image_base + i.virtual_address) >= ofs) and (i.virtual_size != 0) and ((result == -1) or ((self.image_base + i.virtual_address) < result)): result = self.image_base + i.virtual_address return result def get_modification(self, ofs, len): result = [] while len > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size))) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += [DATA_ORIGINAL] * mem_len len -= mem_len ofs += mem_len continue result += self.data.get_modification(cur.pointer_to_raw_data + prog_ofs, file_len) len -= file_len ofs += file_len return result def write(self, ofs, data): result = 0 while len(data) > 0: cur = None for i in self.sections: if ((ofs >= (self.image_base + i.virtual_address)) and (ofs < (self.image_base + i.virtual_address + i.virtual_size))) and (i.virtual_size != 0): cur = i if cur == None: break prog_ofs = ofs - (self.image_base + cur.virtual_address) mem_len = cur.virtual_size - prog_ofs file_len = cur.size_of_raw_data - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: break result += self.data.write(cur.pointer_to_raw_data + prog_ofs, data[0:file_len]) data = data[file_len:] ofs += file_len return result def insert(self, ofs, data): return 0 def remove(self, ofs, size): return 0 def notify_data_write(self, data, ofs, contents): # Find sections that hold data backed by updated regions of the file for i in self.sections: if ((ofs + len(contents)) > i.pointer_to_raw_data) and (ofs < (i.pointer_to_raw_data + i.size_of_raw_data)) and (i.virtual_size != 0): # This section has been updated, compute which region has been changed from_start = ofs - i.pointer_to_raw_data data_ofs = 0 length = len(contents) if from_start < 0: length += from_start data_ofs -= from_start from_start = 0 if (from_start + length) > i.size_of_raw_data: length = i.size_of_raw_data - from_start # Notify callbacks if length > 0: for cb in self.callbacks: if hasattr(cb, "notify_data_write"): cb.notify_data_write(self, self.image_base + i.virtual_address + from_start, contents[data_ofs:(data_ofs + length)]) def save(self, filename): self.data.save(filename) def start(self): return self.image_base def entry(self): return self.image_base + self.header.opt.address_of_entry def __len__(self): max = None for i in self.sections: if ((max == None) or ((self.image_base + i.virtual_address + i.virtual_size) > max)) and (i.virtual_size != 0): max = self.image_base + i.virtual_address + i.virtual_size return max - self.start() def is_pe(self): if self.data.read(0, 2) != "MZ": return False ofs = self.data.read(0x3c, 4) if len(ofs) != 4: return False ofs = struct.unpack("<I", ofs)[0] if self.data.read(ofs, 4) != "PE\0\0": return False magic = self.data.read(ofs + 24, 2) if len(magic) != 2: return False magic = struct.unpack("<H", magic)[0] return (magic == 0x10b) or (magic == 0x20b) def architecture(self): if self.header.machine == 0x14c: return "x86" if self.header.machine == 0x8664: return "x86_64" if self.header.machine == 0x166: return "mips" if self.header.machine == 0x266: return "mips16" if self.header.machine == 0x366: return "mips" if self.header.machine == 0x466: return "mips16" if self.header.machine == 0x1f0: return "ppc" if self.header.machine == 0x1f1: return "ppc" if self.header.machine == 0x1c0: return "arm" if self.header.machine == 0x1c2: return "thumb" if self.header.machine == 0x1c4: return "thumb" if self.header.machine == 0xaa64: return "arm64" if self.header.machine == 0x200: return "ia64" return None def decorate_plt_name(self, name): return name + "@IAT" def create_symbol(self, addr, name): self.symbols_by_name[name] = addr self.symbols_by_addr[addr] = name def delete_symbol(self, addr, name): if name in self.symbols_by_name: del(self.symbols_by_name[name]) if addr in self.symbols_by_addr: del(self.symbols_by_addr[addr]) def add_callback(self, cb): self.callbacks.append(cb) def remove_callback(self, cb): self.callbacks.remove(cb) def is_modified(self): return self.data.is_modified() def find(self, regex, addr): while (addr < self.end()) and (addr != -1): data = self.read(addr, 0xfffffffff) match = regex.search(data) if match != None: return match.start() + addr addr += len(data) addr = self.next_valid_addr(addr) return -1 def has_undo_actions(self): return self.data.has_undo_actions() def commit_undo(self, before_loc, after_loc): self.data.commit_undo(before_loc, after_loc) def undo(self): self.data.undo() def redo(self): self.data.redo()
else: print "ksum.input is missing" exit() if nspin != 2: print "nspin must be 2 for HF calculations" exit() if ncor_orb != len(SigMdc): print "ncor_orb is not consistent with SigMdc" exit() if ncor_orb / norb != len(U): print "ncor_orb is not consistent with U" exit() execfile('INPUT.py') TB = Struct.TBstructure('POSCAR', p['atomnames'], p['orbs']) cor_at = p['cor_at'] cor_orb = p['cor_orb'] #TB.Compute_cor_idx(cor_at,cor_orb) if rank == 0: WAN = WAN90.WANNIER('wannier90') WAN.load_chk(p['path_bin']) WAN.load_eig() WAN.Compute_HamR0() ntet, kibz, tetkptr, tet, gptr, tet_idx = Get_Tetra( WAN.recip_latt, WAN.mp_grid, WAN.ikpt) ed = [] for i, ats in enumerate(cor_at): ed.append([]) for j, orbs in enumerate(cor_orb[i]):
def getProductInfo(keyword): # https://www.ulta.com/ulta/a/_/Ntt-temp/ searchUrl = 'https://www.ulta.com/ulta/a/_/Ntt-' + keyword # headless chrome_options = Options() chrome_options.add_argument('--headless') # chrome_options.add_argument('--window-size=1920,1080'); driver = webdriver.Chrome(executable_path='./chromedriver', chrome_options=chrome_options) driver.get(searchUrl) time.sleep(0.5) # Delays for 0.5 seconds. # Move five times can scroll to the end (the height of the website is 4284px) for i in range(5): driver.execute_script("window.scrollBy(0,1000)") time.sleep(0.3) html = driver.page_source # from bs4 import BeautifulSoup soup = BeautifulSoup(html.encode('utf-8'), 'html.parser') products = soup.findAll('div', {'class': 'productQvContainer'}) # Brand productsBrands = [] for product in products: temp = product.findAll('h4', {'class': 'prod-title'}) productsBrand = temp[0].findAll('a', {})[0].contents[0].encode( 'utf-8', 'ignore').strip() productsBrands.append(productsBrand) # print productsBrands[0]; # Name productsNames = [] for product in products: temp = product.findAll('p', {'class': 'prod-desc'}) productsName = temp[0].findAll('a', {})[0].contents[0].encode( 'utf-8', 'ignore').strip() productsNames.append(productsName) # print productsNames[0]; # URL productsUrls = [] for product in products: temp = product.findAll('p', {'class': 'prod-desc'}) productsUrl = temp[0].findAll('a', {})[0].get('href') productsUrls.append(productsUrl) # print productsUrls[0]; # Price productsPrices = [] for product in products: temp = product.findAll('span', {'class': 'regPrice'}) productsPrice = 0 # Deal with promotion if len(temp) == 0: temp = product.findAll('span', {'class': 'pro-new-price'}) productsPrice = temp[0].contents[0].encode('utf-8', 'ignore').strip() productsPrices.append(productsPrice) # print prices[0]; # IMG_URL imageUrls = [] for product in products: temp = product.findAll('a', {'class': 'product'}) imageUrl = temp[0].findAll('img', {})[0].get('src').encode('utf-8', 'ignore').strip() imageUrls.append(imageUrl) # print imageUrls[0]; # Rating productsRatings = [] for product in products: temp = product.findAll('label', {'class': 'sr-only'}) productsRating = temp[0].contents[0].encode('utf-8', 'ignore').strip() productsRating = productsRating.split()[0] productsRatings.append(productsRating) # print productsRatings[0]; L = [] baseUrl = 'https://www.ulta.com' for i in range(len(productsNames)): price = productsPrices[i] price = price.decode('utf-8') if '-' in price: price = price[0:price.find('-') - 1] price = price[price.find('$') + 1:] product = Struct.Product(productsBrands[i].decode('utf-8'), productsNames[i].decode('utf-8'), float(price), baseUrl + productsUrls[i], imageUrls[i].decode('utf-8'), float(productsRatings[i])) # print 'Brand:' + productsBrands[i]; # print 'Product Name:' + productsNames[i]; # print 'Product Url:' + productsUrls[i]; # print 'Price:' + productsPrices[i]; # print 'Image Url:' + imageUrls[i]; # print 'Rating:' + productsRatings[i]; # print '-----------' L.append(product) driver.close() return L
def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} self.plt = {} if not self.is_macho(): return try: self.tree = Struct(self.data) self.header = self.tree.struct("Mach-O header", "header") self.header.uint32_le("magic") if (self.header.magic == 0xfeedface) or (self.header.magic == 0xfeedfacf): self.header.uint32_le("cputype") self.header.uint32_le("cpusubtype") self.header.uint32_le("filetype") self.header.uint32_le("cmds") self.header.uint32_le("cmdsize") self.header.uint32_le("flags") if self.header.magic == 0xfeedfacf: self.header.uint32_le("reserved") self.bits = 64 else: self.bits = 32 self.big_endian = False elif (self.header.magic == 0xcefaedfe) or (self.header.magic == 0xcffaedfe): self.header.uint32_be("cputype") self.header.uint32_be("cpusubtype") self.header.uint32_be("filetype") self.header.uint32_be("cmds") self.header.uint32_be("cmdsize") self.header.uint32_be("flags") if self.header.magic == 0xcffaedfe: self.header.uint32_be("reserved") self.bits = 64 else: self.bits = 32 self.big_endian = True self.symbol_table = None self.dynamic_symbol_table = None # Parse loader commands self.commands = self.tree.array(self.header.cmds, "commands") self.segments = [] self.sections = [] offset = self.header.getSize() for i in xrange(0, self.header.cmds): cmd = self.commands[i] cmd.seek(offset) if self.big_endian: cmd.uint32_be("cmd") cmd.uint32_be("size") else: cmd.uint32_le("cmd") cmd.uint32_le("size") if cmd.cmd == 1: # SEGMENT cmd.bytes(16, "name") if self.big_endian: cmd.uint32_be("vmaddr") cmd.uint32_be("vmsize") cmd.uint32_be("fileoff") cmd.uint32_be("filesize") cmd.uint32_be("maxprot") cmd.uint32_be("initprot") cmd.uint32_be("nsects") cmd.uint32_be("flags") else: cmd.uint32_le("vmaddr") cmd.uint32_le("vmsize") cmd.uint32_le("fileoff") cmd.uint32_le("filesize") cmd.uint32_le("maxprot") cmd.uint32_le("initprot") cmd.uint32_le("nsects") cmd.uint32_le("flags") if cmd.initprot != 0: # Ignore __PAGE_ZERO or anything like it self.segments.append(cmd) cmd.array(cmd.nsects, "sections") for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.bytes(16, "name") section.bytes(16, "segment") if self.big_endian: section.uint32_be("addr") section.uint32_be("size") section.uint32_be("offset") section.uint32_be("align") section.uint32_be("reloff") section.uint32_be("nreloc") section.uint32_be("flags") section.uint32_be("reserved1") section.uint32_be("reserved2") else: section.uint32_le("addr") section.uint32_le("size") section.uint32_le("offset") section.uint32_le("align") section.uint32_le("reloff") section.uint32_le("nreloc") section.uint32_le("flags") section.uint32_le("reserved1") section.uint32_le("reserved2") self.sections.append(section) for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.array(section.nreloc, "relocs") for j in xrange(0, section.nreloc): reloc = section.relocs[j] reloc.seek(section.reloff + (j * 8)) if self.big_endian: reloc.uint32_be("addr") reloc.uint32_be("value") else: reloc.uint32_le("addr") reloc.uint32_le("value") elif cmd.cmd == 25: # SEGMENT_64 cmd.bytes(16, "name") if self.big_endian: cmd.uint64_be("vmaddr") cmd.uint64_be("vmsize") cmd.uint64_be("fileoff") cmd.uint64_be("filesize") cmd.uint32_be("maxprot") cmd.uint32_be("initprot") cmd.uint32_be("nsects") cmd.uint32_be("flags") else: cmd.uint64_le("vmaddr") cmd.uint64_le("vmsize") cmd.uint64_le("fileoff") cmd.uint64_le("filesize") cmd.uint32_le("maxprot") cmd.uint32_le("initprot") cmd.uint32_le("nsects") cmd.uint32_le("flags") if cmd.initprot != 0: # Ignore __PAGE_ZERO or anything like it self.segments.append(cmd) cmd.array(cmd.nsects, "sections") for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.bytes(16, "name") section.bytes(16, "segment") if self.big_endian: section.uint64_be("addr") section.uint64_be("size") section.uint32_be("offset") section.uint32_be("align") section.uint32_be("reloff") section.uint32_be("nreloc") section.uint32_be("flags") section.uint32_be("reserved1") section.uint32_be("reserved2") section.uint32_be("reserved3") else: section.uint64_le("addr") section.uint64_le("size") section.uint32_le("offset") section.uint32_le("align") section.uint32_le("reloff") section.uint32_le("nreloc") section.uint32_le("flags") section.uint32_le("reserved1") section.uint32_le("reserved2") section.uint32_le("reserved3") self.sections.append(section) for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.array(section.nreloc, "relocs") for j in xrange(0, section.nreloc): reloc = section.relocs[j] reloc.seek(section.reloff + (j * 8)) if self.big_endian: reloc.uint32_be("addr") reloc.uint32_be("value") else: reloc.uint32_le("addr") reloc.uint32_le("value") elif cmd.cmd == 5: # UNIX_THREAD if self.header.cputype == 7: # x86 cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["eax", "ebx", "ecx", "edx", "edi", "esi", "ebp", "esp", "ss", "eflags", "eip", "cs", "ds", "es", "fs", "gs"]: cmd.uint32_le(reg) self.entry_addr = cmd.eip elif self.header.cputype == 0x01000007: # x86_64 cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "rsp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "rip", "rflags", "cs", "fs", "gs"]: cmd.uint64_le(reg) self.entry_addr = cmd.rip elif self.header.cputype == 18: # PPC32 cmd.uint32_be("flavor") cmd.uint32_be("count") for reg in ["srr0", "srr1"] + ["r%d" % i for i in xrange(0, 32)] + ["cr", "xer", "lr", "ctr", "mq", "vrsave"]: cmd.uint32_be(reg) self.entry_addr = cmd.srr0 elif self.header.cputype == 0x01000012: # PPC64 cmd.uint32_be("flavor") cmd.uint32_be("count") for reg in ["srr0", "srr1"] + ["r%d" % i for i in xrange(0, 32)] + ["cr", "xer", "lr", "ctr", "mq", "vrsave"]: cmd.uint64_be(reg) self.entry_addr = cmd.srr0 elif self.header.cputype == 12: # ARM cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["r%d" % i for i in xrange(0, 13)] + ["sp", "lr", "pc", "cpsr"]: cmd.uint32_le(reg) self.entry_addr = cmd.pc elif cmd.cmd == 2: # SYMTAB if self.big_endian: cmd.uint32_be("symoff") cmd.uint32_be("nsyms") cmd.uint32_be("stroff") cmd.uint32_be("strsize") else: cmd.uint32_le("symoff") cmd.uint32_le("nsyms") cmd.uint32_le("stroff") cmd.uint32_le("strsize") self.symbol_table = self.tree.array(cmd.nsyms, "symtab") strings = self.data.read(cmd.stroff, cmd.strsize) sym_offset = cmd.symoff for j in xrange(0, cmd.nsyms): entry = self.symbol_table[j] entry.seek(sym_offset) if self.big_endian: entry.uint32_be("strx") entry.uint8("type") entry.uint8("sect") entry.uint16_be("desc") if self.bits == 32: entry.uint32_be("value") else: entry.uint64_be("value") else: entry.uint32_le("strx") entry.uint8("type") entry.uint8("sect") entry.uint16_le("desc") if self.bits == 32: entry.uint32_le("value") else: entry.uint64_le("value") str_end = strings.find("\x00", entry.strx) entry.name = strings[entry.strx:str_end] if self.bits == 32: sym_offset += 12 else: sym_offset += 16 elif cmd.cmd == 11: # DYSYMTAB if self.big_endian: cmd.uint32_be("ilocalsym") cmd.uint32_be("nlocalsym") cmd.uint32_be("iextdefsym") cmd.uint32_be("nextdefsym") cmd.uint32_be("iundefsym") cmd.uint32_be("nundefsym") cmd.uint32_be("tocoff") cmd.uint32_be("ntoc") cmd.uint32_be("modtaboff") cmd.uint32_be("nmodtab") cmd.uint32_be("extrefsymoff") cmd.uint32_be("nextrefsyms") cmd.uint32_be("indirectsymoff") cmd.uint32_be("nindirectsyms") cmd.uint32_be("extreloff") cmd.uint32_be("nextrel") cmd.uint32_be("locreloff") cmd.uint32_be("nlocrel") else: cmd.uint32_le("ilocalsym") cmd.uint32_le("nlocalsym") cmd.uint32_le("iextdefsym") cmd.uint32_le("nextdefsym") cmd.uint32_le("iundefsym") cmd.uint32_le("nundefsym") cmd.uint32_le("tocoff") cmd.uint32_le("ntoc") cmd.uint32_le("modtaboff") cmd.uint32_le("nmodtab") cmd.uint32_le("extrefsymoff") cmd.uint32_le("nextrefsyms") cmd.uint32_le("indirectsymoff") cmd.uint32_le("nindirectsyms") cmd.uint32_le("extreloff") cmd.uint32_le("nextrel") cmd.uint32_le("locreloff") cmd.uint32_le("nlocrel") elif (cmd.cmd & 0x7fffffff) == 0x22: # DYLD_INFO self.dynamic_symbol_table = cmd if self.big_endian: cmd.uint32_be("rebaseoff") cmd.uint32_be("rebasesize") cmd.uint32_be("bindoff") cmd.uint32_be("bindsize") cmd.uint32_be("weakbindoff") cmd.uint32_be("weakbindsize") cmd.uint32_be("lazybindoff") cmd.uint32_be("lazybindsize") cmd.uint32_be("exportoff") cmd.uint32_be("exportsize") else: cmd.uint32_le("rebaseoff") cmd.uint32_le("rebasesize") cmd.uint32_le("bindoff") cmd.uint32_le("bindsize") cmd.uint32_le("weakbindoff") cmd.uint32_le("weakbindsize") cmd.uint32_le("lazybindoff") cmd.uint32_le("lazybindsize") cmd.uint32_le("exportoff") cmd.uint32_le("exportsize") offset += cmd.size # Add symbols from symbol table if self.symbol_table: for i in xrange(0, len(self.symbol_table)): symbol = self.symbol_table[i] # Only use symbols that are within a section if ((symbol.type & 0xe) == 0xe) and (symbol.sect <= len(self.sections)): self.create_symbol(symbol.value, symbol.name) # If there is a DYLD_INFO section, parse it and add PLT entries if self.dynamic_symbol_table: self.parse_dynamic_tables([[self.dynamic_symbol_table.bindoff, self.dynamic_symbol_table.bindsize], [self.dynamic_symbol_table.lazybindoff, self.dynamic_symbol_table.lazybindsize]]) self.tree.complete() self.valid = True except: self.valid = False raise if self.valid: self.data.add_callback(self)
class MachOFile(BinaryAccessor): def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} self.plt = {} if not self.is_macho(): return try: self.tree = Struct(self.data) self.header = self.tree.struct("Mach-O header", "header") self.header.uint32_le("magic") if (self.header.magic == 0xfeedface) or (self.header.magic == 0xfeedfacf): self.header.uint32_le("cputype") self.header.uint32_le("cpusubtype") self.header.uint32_le("filetype") self.header.uint32_le("cmds") self.header.uint32_le("cmdsize") self.header.uint32_le("flags") if self.header.magic == 0xfeedfacf: self.header.uint32_le("reserved") self.bits = 64 else: self.bits = 32 self.big_endian = False elif (self.header.magic == 0xcefaedfe) or (self.header.magic == 0xcffaedfe): self.header.uint32_be("cputype") self.header.uint32_be("cpusubtype") self.header.uint32_be("filetype") self.header.uint32_be("cmds") self.header.uint32_be("cmdsize") self.header.uint32_be("flags") if self.header.magic == 0xcffaedfe: self.header.uint32_be("reserved") self.bits = 64 else: self.bits = 32 self.big_endian = True self.symbol_table = None self.dynamic_symbol_table = None # Parse loader commands self.commands = self.tree.array(self.header.cmds, "commands") self.segments = [] self.sections = [] offset = self.header.getSize() for i in xrange(0, self.header.cmds): cmd = self.commands[i] cmd.seek(offset) if self.big_endian: cmd.uint32_be("cmd") cmd.uint32_be("size") else: cmd.uint32_le("cmd") cmd.uint32_le("size") if cmd.cmd == 1: # SEGMENT cmd.bytes(16, "name") if self.big_endian: cmd.uint32_be("vmaddr") cmd.uint32_be("vmsize") cmd.uint32_be("fileoff") cmd.uint32_be("filesize") cmd.uint32_be("maxprot") cmd.uint32_be("initprot") cmd.uint32_be("nsects") cmd.uint32_be("flags") else: cmd.uint32_le("vmaddr") cmd.uint32_le("vmsize") cmd.uint32_le("fileoff") cmd.uint32_le("filesize") cmd.uint32_le("maxprot") cmd.uint32_le("initprot") cmd.uint32_le("nsects") cmd.uint32_le("flags") if cmd.initprot != 0: # Ignore __PAGE_ZERO or anything like it self.segments.append(cmd) cmd.array(cmd.nsects, "sections") for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.bytes(16, "name") section.bytes(16, "segment") if self.big_endian: section.uint32_be("addr") section.uint32_be("size") section.uint32_be("offset") section.uint32_be("align") section.uint32_be("reloff") section.uint32_be("nreloc") section.uint32_be("flags") section.uint32_be("reserved1") section.uint32_be("reserved2") else: section.uint32_le("addr") section.uint32_le("size") section.uint32_le("offset") section.uint32_le("align") section.uint32_le("reloff") section.uint32_le("nreloc") section.uint32_le("flags") section.uint32_le("reserved1") section.uint32_le("reserved2") self.sections.append(section) for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.array(section.nreloc, "relocs") for j in xrange(0, section.nreloc): reloc = section.relocs[j] reloc.seek(section.reloff + (j * 8)) if self.big_endian: reloc.uint32_be("addr") reloc.uint32_be("value") else: reloc.uint32_le("addr") reloc.uint32_le("value") elif cmd.cmd == 25: # SEGMENT_64 cmd.bytes(16, "name") if self.big_endian: cmd.uint64_be("vmaddr") cmd.uint64_be("vmsize") cmd.uint64_be("fileoff") cmd.uint64_be("filesize") cmd.uint32_be("maxprot") cmd.uint32_be("initprot") cmd.uint32_be("nsects") cmd.uint32_be("flags") else: cmd.uint64_le("vmaddr") cmd.uint64_le("vmsize") cmd.uint64_le("fileoff") cmd.uint64_le("filesize") cmd.uint32_le("maxprot") cmd.uint32_le("initprot") cmd.uint32_le("nsects") cmd.uint32_le("flags") if cmd.initprot != 0: # Ignore __PAGE_ZERO or anything like it self.segments.append(cmd) cmd.array(cmd.nsects, "sections") for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.bytes(16, "name") section.bytes(16, "segment") if self.big_endian: section.uint64_be("addr") section.uint64_be("size") section.uint32_be("offset") section.uint32_be("align") section.uint32_be("reloff") section.uint32_be("nreloc") section.uint32_be("flags") section.uint32_be("reserved1") section.uint32_be("reserved2") section.uint32_be("reserved3") else: section.uint64_le("addr") section.uint64_le("size") section.uint32_le("offset") section.uint32_le("align") section.uint32_le("reloff") section.uint32_le("nreloc") section.uint32_le("flags") section.uint32_le("reserved1") section.uint32_le("reserved2") section.uint32_le("reserved3") self.sections.append(section) for i in xrange(0, cmd.nsects): section = cmd.sections[i] section.array(section.nreloc, "relocs") for j in xrange(0, section.nreloc): reloc = section.relocs[j] reloc.seek(section.reloff + (j * 8)) if self.big_endian: reloc.uint32_be("addr") reloc.uint32_be("value") else: reloc.uint32_le("addr") reloc.uint32_le("value") elif cmd.cmd == 5: # UNIX_THREAD if self.header.cputype == 7: # x86 cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["eax", "ebx", "ecx", "edx", "edi", "esi", "ebp", "esp", "ss", "eflags", "eip", "cs", "ds", "es", "fs", "gs"]: cmd.uint32_le(reg) self.entry_addr = cmd.eip elif self.header.cputype == 0x01000007: # x86_64 cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "rsp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "rip", "rflags", "cs", "fs", "gs"]: cmd.uint64_le(reg) self.entry_addr = cmd.rip elif self.header.cputype == 18: # PPC32 cmd.uint32_be("flavor") cmd.uint32_be("count") for reg in ["srr0", "srr1"] + ["r%d" % i for i in xrange(0, 32)] + ["cr", "xer", "lr", "ctr", "mq", "vrsave"]: cmd.uint32_be(reg) self.entry_addr = cmd.srr0 elif self.header.cputype == 0x01000012: # PPC64 cmd.uint32_be("flavor") cmd.uint32_be("count") for reg in ["srr0", "srr1"] + ["r%d" % i for i in xrange(0, 32)] + ["cr", "xer", "lr", "ctr", "mq", "vrsave"]: cmd.uint64_be(reg) self.entry_addr = cmd.srr0 elif self.header.cputype == 12: # ARM cmd.uint32_le("flavor") cmd.uint32_le("count") for reg in ["r%d" % i for i in xrange(0, 13)] + ["sp", "lr", "pc", "cpsr"]: cmd.uint32_le(reg) self.entry_addr = cmd.pc elif cmd.cmd == 2: # SYMTAB if self.big_endian: cmd.uint32_be("symoff") cmd.uint32_be("nsyms") cmd.uint32_be("stroff") cmd.uint32_be("strsize") else: cmd.uint32_le("symoff") cmd.uint32_le("nsyms") cmd.uint32_le("stroff") cmd.uint32_le("strsize") self.symbol_table = self.tree.array(cmd.nsyms, "symtab") strings = self.data.read(cmd.stroff, cmd.strsize) sym_offset = cmd.symoff for j in xrange(0, cmd.nsyms): entry = self.symbol_table[j] entry.seek(sym_offset) if self.big_endian: entry.uint32_be("strx") entry.uint8("type") entry.uint8("sect") entry.uint16_be("desc") if self.bits == 32: entry.uint32_be("value") else: entry.uint64_be("value") else: entry.uint32_le("strx") entry.uint8("type") entry.uint8("sect") entry.uint16_le("desc") if self.bits == 32: entry.uint32_le("value") else: entry.uint64_le("value") str_end = strings.find("\x00", entry.strx) entry.name = strings[entry.strx:str_end] if self.bits == 32: sym_offset += 12 else: sym_offset += 16 elif cmd.cmd == 11: # DYSYMTAB if self.big_endian: cmd.uint32_be("ilocalsym") cmd.uint32_be("nlocalsym") cmd.uint32_be("iextdefsym") cmd.uint32_be("nextdefsym") cmd.uint32_be("iundefsym") cmd.uint32_be("nundefsym") cmd.uint32_be("tocoff") cmd.uint32_be("ntoc") cmd.uint32_be("modtaboff") cmd.uint32_be("nmodtab") cmd.uint32_be("extrefsymoff") cmd.uint32_be("nextrefsyms") cmd.uint32_be("indirectsymoff") cmd.uint32_be("nindirectsyms") cmd.uint32_be("extreloff") cmd.uint32_be("nextrel") cmd.uint32_be("locreloff") cmd.uint32_be("nlocrel") else: cmd.uint32_le("ilocalsym") cmd.uint32_le("nlocalsym") cmd.uint32_le("iextdefsym") cmd.uint32_le("nextdefsym") cmd.uint32_le("iundefsym") cmd.uint32_le("nundefsym") cmd.uint32_le("tocoff") cmd.uint32_le("ntoc") cmd.uint32_le("modtaboff") cmd.uint32_le("nmodtab") cmd.uint32_le("extrefsymoff") cmd.uint32_le("nextrefsyms") cmd.uint32_le("indirectsymoff") cmd.uint32_le("nindirectsyms") cmd.uint32_le("extreloff") cmd.uint32_le("nextrel") cmd.uint32_le("locreloff") cmd.uint32_le("nlocrel") elif (cmd.cmd & 0x7fffffff) == 0x22: # DYLD_INFO self.dynamic_symbol_table = cmd if self.big_endian: cmd.uint32_be("rebaseoff") cmd.uint32_be("rebasesize") cmd.uint32_be("bindoff") cmd.uint32_be("bindsize") cmd.uint32_be("weakbindoff") cmd.uint32_be("weakbindsize") cmd.uint32_be("lazybindoff") cmd.uint32_be("lazybindsize") cmd.uint32_be("exportoff") cmd.uint32_be("exportsize") else: cmd.uint32_le("rebaseoff") cmd.uint32_le("rebasesize") cmd.uint32_le("bindoff") cmd.uint32_le("bindsize") cmd.uint32_le("weakbindoff") cmd.uint32_le("weakbindsize") cmd.uint32_le("lazybindoff") cmd.uint32_le("lazybindsize") cmd.uint32_le("exportoff") cmd.uint32_le("exportsize") offset += cmd.size # Add symbols from symbol table if self.symbol_table: for i in xrange(0, len(self.symbol_table)): symbol = self.symbol_table[i] # Only use symbols that are within a section if ((symbol.type & 0xe) == 0xe) and (symbol.sect <= len(self.sections)): self.create_symbol(symbol.value, symbol.name) # If there is a DYLD_INFO section, parse it and add PLT entries if self.dynamic_symbol_table: self.parse_dynamic_tables([[self.dynamic_symbol_table.bindoff, self.dynamic_symbol_table.bindsize], [self.dynamic_symbol_table.lazybindoff, self.dynamic_symbol_table.lazybindsize]]) self.tree.complete() self.valid = True except: self.valid = False raise if self.valid: self.data.add_callback(self) def read_leb128(self, data, ofs): value = 0 shift = 0 while ofs < len(data): cur = ord(data[ofs]) ofs += 1 value |= (cur & 0x7f) << shift shift += 7 if (cur & 0x80) == 0: break return value, ofs def parse_dynamic_tables(self, tables): # Interpret DYLD_INFO instructions (not documented by Apple) # http://networkpx.blogspot.com/2009/09/about-lcdyldinfoonly-command.html ordinal = 0 segment = 0 offset = 0 sym_type = 0 name = "" for table in tables: offset = table[0] size = table[1] opcodes = self.data.read(offset, size) i = 0 while i < len(opcodes): opcode = ord(opcodes[i]) i += 1 if (opcode >> 4) == 0: continue elif (opcode >> 4) == 1: ordinal = opcode & 0xf elif (opcode >> 4) == 2: ordinal, i = self.read_leb128(opcodes, i) elif (opcode >> 4) == 3: ordinal = -(opcode & 0xf) elif (opcode >> 4) == 4: name = "" while i < len(opcodes): ch = opcodes[i] i += 1 if ch == '\x00': break name += ch elif (opcode >> 4) == 5: sym_type = opcode & 0xf elif (opcode >> 4) == 6: addend, i = self.read_leb128(opcodes, i) elif (opcode >> 4) == 7: segment = opcode & 0xf offset, i = self.read_leb128(opcodes, i) elif (opcode >> 4) == 8: rel, i = self.read_leb128(opcodes, i) offset += rel elif (opcode >> 4) >= 9: if (sym_type == 1) and (segment <= len(self.segments)): # Add pointer type entries to the PLT addr = self.segments[segment - 1].vmaddr + offset self.plt[addr] = name self.create_symbol(addr, self.decorate_plt_name(name)) if self.bits == 32: offset += 4 else: offset += 8 if (opcode >> 4) == 10: rel, i = self.read_leb128(opcodes, i) offset += rel elif (opcode >> 4) == 11: offset += (opcode & 0xf) * 4 elif (opcode >> 4) == 12: count, i = self.read_leb128(opcodes, i) skip, i = self.read_leb128(opcodes, i) def read(self, ofs, len): result = "" while len > 0: cur = None for i in self.segments: if ((ofs >= i.vmaddr) and (ofs < (i.vmaddr + i.vmsize))) and (i.vmsize != 0): cur = i if cur == None: break prog_ofs = ofs - cur.vmaddr mem_len = cur.vmsize - prog_ofs file_len = cur.filesize - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += "\x00" * mem_len len -= mem_len ofs += mem_len continue result += self.data.read(cur.fileoff + prog_ofs, file_len) len -= file_len ofs += file_len return result def next_valid_addr(self, ofs): result = -1 for i in self.segments: if (i.vmaddr >= ofs) and (i.vmsize != 0) and ((result == -1) or (i.vmaddr < result)): result = i.vmaddr return result def get_modification(self, ofs, len): result = [] while len > 0: cur = None for i in self.segments: if ((ofs >= i.vmaddr) and (ofs < (i.vmaddr + i.vmsize))) and (i.vmsize != 0): cur = i if cur == None: break prog_ofs = ofs - cur.vmaddr mem_len = cur.vmsize - prog_ofs file_len = cur.filesize - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += [DATA_ORIGINAL] * mem_len len -= mem_len ofs += mem_len continue result += self.data.get_modification(cur.fileoff + prog_ofs, file_len) len -= file_len ofs += file_len return result def write(self, ofs, data): result = 0 while len(data) > 0: cur = None for i in self.segments: if ((ofs >= i.vmaddr) and (ofs < (i.vmaddr + i.vmsize))) and (i.vmsize != 0): cur = i if cur == None: break prog_ofs = ofs - cur.vmaddr mem_len = cur.vmsize - prog_ofs file_len = cur.filesize - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: break result += self.data.write(cur.fileoff + prog_ofs, data[0:file_len]) data = data[file_len:] ofs += file_len return result def insert(self, ofs, data): return 0 def remove(self, ofs, size): return 0 def notify_data_write(self, data, ofs, contents): # Find sections that hold data backed by updated regions of the file for i in self.segments: if ((ofs + len(contents)) > i.fileoff) and (ofs < (i.fileoff + i.filesize)) and (i.vmsize != 0): # This section has been updated, compute which region has been changed from_start = ofs - i.fileoff data_ofs = 0 length = len(contents) if from_start < 0: length += from_start data_ofs -= from_start from_start = 0 if (from_start + length) > i.filesize: length = i.filesize - from_start # Notify callbacks if length > 0: for cb in self.callbacks: if hasattr(cb, "notify_data_write"): cb.notify_data_write(self, i.vmaddr + from_start, contents[data_ofs:(data_ofs + length)]) def save(self, filename): self.data.save(filename) def start(self): result = None for i in self.segments: if ((result == None) or (i.vmaddr < result)) and (i.vmsize != 0): result = i.vmaddr return result def entry(self): if not hasattr(self, "entry_addr"): return self.start() return self.entry_addr def __len__(self): max = None for i in self.segments: if ((max == None) or ((i.vmaddr + i.vmsize) > max)) and (i.vmsize != 0): max = i.vmaddr + i.vmsize return max - self.start() def is_macho(self): if self.data.read(0, 4) == "\xfe\xed\xfa\xce": return True if self.data.read(0, 4) == "\xfe\xed\xfa\xcf": return True if self.data.read(0, 4) == "\xce\xfa\xed\xfe": return True if self.data.read(0, 4) == "\xcf\xfa\xed\xfe": return True return False def architecture(self): if self.header.cputype == 7: return "x86" if self.header.cputype == 0x01000007: return "x86_64" if self.header.cputype == 12: return "arm" if self.header.cputype == 18: return "ppc" if self.header.cputype == 0x01000012: return "ppc" return None def decorate_plt_name(self, name): return name + "@PLT" def create_symbol(self, addr, name): self.symbols_by_name[name] = addr self.symbols_by_addr[addr] = name def delete_symbol(self, addr, name): if name in self.symbols_by_name: del(self.symbols_by_name[name]) if addr in self.symbols_by_addr: del(self.symbols_by_addr[addr]) def add_callback(self, cb): self.callbacks.append(cb) def remove_callback(self, cb): self.callbacks.remove(cb) def is_modified(self): return self.data.is_modified() def find(self, regex, addr): while (addr < self.end()) and (addr != -1): data = self.read(addr, 0xfffffffff) match = regex.search(data) if match != None: return match.start() + addr addr += len(data) addr = self.next_valid_addr(addr) return -1 def has_undo_actions(self): return self.data.has_undo_actions() def commit_undo(self, before_loc, after_loc): self.data.commit_undo(before_loc, after_loc) def undo(self): self.data.undo() def redo(self): self.data.redo()
def gen_win(self): """ This method generates wannier90.win for the initial DFT run. """ # generating wannier90.win TB = Struct.TBstructure("POSCAR", p["atomnames"], p["orbs"]) TB.Compute_cor_idx(p["cor_at"], p["cor_orb"]) # print((TB.TB_orbs)) # Read number of bands from DFT input file try: if self.dft == "vasp": fi = open("INCAR", "r") data = fi.read() fi.close() self.DFT.NBANDS = int( re.findall(r"\n\s*NBANDS\s*=\s*([\d\s]*)", data)[0]) print("Number of bands read from INCAR = %d " % self.DFT.NBANDS) elif self.dft == "siesta": fi = open(self.structurename + ".fdf", "r") data = fi.read() fi.close() self.DFT.NBANDS = int( re.findall(r"\n\s*Siesta2Wannier90.NumberOfBands[\s0-9]*", data)[0].split()[-1]) print("Number of bands read from .fdf = %d " % self.DFT.NBANDS) elif self.dft == "qe": fi = open(self.structurename + ".scf.out", "r") data = fi.read() fi.close() self.DFT.NBANDS = int( re.findall( r"\n\s*number\s*of\s*Kohn-Sham\s*states=([\s\d]*)", data)[0]) print("Number of bands read from .scf.out = %d " % self.DFT.NBANDS) except: self.DFT.NBANDS = 100 print("WARNING: Number of bands not set in DFT input file!") # Setting num_bands in .win file. # If set to False num_bands is set to number of DFT bands. if list(p.keys()).count("num_bands_win"): if p["num_bands_win"]: self.wanbands = p["num_bands_win"] self.updatewanbands = False else: self.wanbands = self.DFT.NBANDS else: self.wanbands = self.DFT.NBANDS self.DFT.Create_win( TB, p["atomnames"], p["orbs"], p["L_rot"], self.wanbands, # Initially DFT.EFERMI is taken from DFT_mu.out but will # be updated later once the DFT calculation is complete. self.DFT.EFERMI + p["ewin"][0], self.DFT.EFERMI + p["ewin"][1], self.kmeshtol, ) # If exclude_bands are to be included in the .win file. # Appending to current .win file. if list(p.keys()).count("exclude_bands"): if p["exclude_bands"]: f = open("wannier90.win", "a") f.write("\nexclude_bands :\t") f.write(", ".join(str(x) for x in p["exclude_bands"])) f.write("\n") f.close() else: pass else: pass # VASP populates the .win file when running but Siesta # does not so we need to create a complete .win file for # Siesta runs. if self.dft == "siesta": # Update wannier90.win file. f = open("wannier90.win", "a") f.write("\nbegin unit_cell_cart\n") np.savetxt(f, self.cell) f.write("end unit_cell_cart\n\n") # writing the atoms cart block f.write("begin atoms_frac\n") aT = (np.array([self.symbols])).T b = self.positions atoms_cart = np.concatenate((aT, b), axis=1) np.savetxt(f, atoms_cart, fmt="%s") f.write("end atoms_frac\n\n") # writing the mp_grid line fi = open(self.structurename + ".fdf") data = fi.read() fi.close() grid = re.findall( r"%block kgrid_Monkhorst_Pack([\s0-9.]*)%endblock kgrid_Monkhorst_Pack", data, )[0].split() f.write("mp_grid= %s %s %s \n" % (grid[0], grid[5], grid[10])) # kpoints f.write("\nbegin kpoints\n") cmd = "kmesh.pl " + grid[0] + " " + grid[5] + " " + grid[ 10] + " wannier" out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() f.write(out.decode("utf-8")) if err: print(err.decode("utf-8")) f.write("end kpoints") f.close() print("wannier90.win generated.") # Similar to Siesta, Quantum Espresso requires the generation # of the .win file manually. # self.cell, self.symbols and self.positions is set from # read_poscar(). elif self.dft == "qe" and self.aiida == False: # reading poscar that should be generated. self.read_poscar() # Update wannier90.win file then rename it f = open("wannier90.win", "a") f.write("\nbegin unit_cell_cart\n") np.savetxt(f, self.cell) f.write("end unit_cell_cart\n\n") # writing the atoms cart block f.write("begin atoms_frac\n") aT = (np.array([self.symbols])).T b = self.positions atoms_cart = np.concatenate((aT, b), axis=1) np.savetxt(f, atoms_cart, fmt="%s") f.write("end atoms_frac\n\n") # writing the mp_grid line fi = open(self.structurename + ".scf.in") data = fi.read() fi.close() self.grid = re.findall( r"K_POINTS\s*automatic\s*([\d\s]*)", data, )[0].split()[0:3] self.grid = [int(x) for x in self.grid] f.write("mp_grid= %s %s %s \n" % (self.grid[0], self.grid[1], self.grid[2])) # kpoints f.write("\nbegin kpoints\n") cmd = ("kmesh.pl " + str(self.grid[0]) + " " + str(self.grid[1]) + " " + str(self.grid[2]) + " wannier") out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() f.write(out.decode("utf-8")) if err: print(err.decode("utf-8")) f.write("end kpoints") f.close() print("wannier90.win generated.")
def __init__(self): layout = [[ sg.Button('Adicionar novo dado'), sg.Button('Remover algum dado') ], [sg.Button('Ver dados')], [sg.Button('Exportar para arquivo de texto')], [sg.Button('Voltar')]] win = sg.Window('Opções', layout) event, value = win.read() print(event) if (event == 'Ver dados'): win.close() janela_lista_tel() elif (event == 'Adicionar novo dado'): pop = sg.popup_get_text( message='Digite a chave nova do dado que vai ser adicionado:') if (pop == None): win.close() else: at, prev = estrutura.buscar(int(pop)) if at: pop_error = sg.popup("A chave digitada já existe") else: dado = [] dado.append(int(pop)) layout = [[sg.Text('Por favor, informe aqui os dados:')], [ sg.Text('Data de Observação', size=(30, 1)), sg.InputText() ], [ sg.Text( 'Estado da Província (Se for na China)', size=(30, 1)), sg.InputText() ], [ sg.Text('Região do País', size=(30, 1)), sg.InputText() ], [ sg.Text('Última Atualização', size=(30, 1)), sg.InputText() ], [ sg.Text('Casos confirmados', size=(30, 1)), sg.InputText() ], [ sg.Text('Número de mortos', size=(30, 1)), sg.InputText() ], [ sg.Text('Números de recuperados', size=(30, 1)), sg.InputText() ], [sg.Submit(), sg.Cancel()]] window_ins = sg.Window('Dados', layout) event, values = window_ins.read() window_ins.close() if (event == 'Cancel'): win.close() janela_lista() for i in values: dado.append(values[i]) aux2 = Struct.CovidLine(*dado) for i in values: dado.append(i) estrutura.inserir(aux2) win.close() janela_lista() elif (event == 'Remover algum dado'): pop = sg.popup_get_text(message='Digite a chave do dado desejado:') if (pop == None): win.close() elif (estrutura.excluir(int(pop)) == False): pop_error = sg.popup("A chave digitada não existe") else: pop_done = sg.popup("Chave removida com sucesso") win.close() janela_lista() elif (event == 'Exportar para arquivo de texto'): outf = open("saida.txt", "w") estrutura.escrever(outf) sg.popup('Arquivo criado com sucesso!') win.close() janela_lista() elif (event == 'Voltar'): win.close() Main() elif (event == sg.WIN_CLOSED): win.close()
class ElfFile(BinaryAccessor): def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_elf(): return try: self.tree = Struct(self.data) self.header = self.tree.struct("ELF header", "header") self.header.struct("ELF identification", "ident") self.header.ident.uint32("magic") self.header.ident.uint8("file_class") self.header.ident.uint8("encoding") self.header.ident.uint8("version") self.header.ident.uint8("abi") self.header.ident.uint8("abi_version") self.header.ident.bytes(7, "pad") self.header.uint16("type") self.header.uint16("arch") self.header.uint32("version") self.symbol_table_section = None self.dynamic_symbol_table_section = None if self.header.ident.file_class == 1: # 32-bit self.header.uint32("entry") self.header.uint32("program_header_offset") self.header.uint32("section_header_offset") self.header.uint32("flags") self.header.uint16("header_size") self.header.uint16("program_header_size") self.header.uint16("program_header_count") self.header.uint16("section_header_size") self.header.uint16("section_header_count") self.header.uint16("string_table") try: self.sections = self.tree.array(self.header.section_header_count, "sections") for i in range(0, self.header.section_header_count): section = self.sections[i] section.seek(self.header.section_header_offset + (i * 40)) section.uint32("name") section.uint32("type") section.uint32("flags") section.uint32("addr") section.uint32("offset") section.uint32("size") section.uint32("link") section.uint32("info") section.uint32("align") section.uint32("entry_size") if section.type == 2: self.symbol_table_section = section elif section.type == 11: self.dynamic_symbol_table_section = section except: # Section headers are not required to load an ELF, skip errors self.sections = self.tree.array(0, "sections") pass self.program_headers = self.tree.array(self.header.program_header_count, "programHeaders") for i in range(0, self.header.program_header_count): header = self.program_headers[i] header.seek(self.header.program_header_offset + (i * 32)) header.uint32("type") header.uint32("offset") header.uint32("virtual_addr") header.uint32("physical_addr") header.uint32("file_size") header.uint32("memory_size") header.uint32("flags") header.uint32("align") # Parse symbol tables self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" try: if self.symbol_table_section: self.symbol_table = self.tree.array(self.symbol_table_section.size / 16, "Symbols", "symbols") self.parse_symbol_table_32(self.symbol_table, self.symbol_table_section, self.sections[self.symbol_table_section.link]) if self.dynamic_symbol_table_section: self.dynamic_symbol_table = self.tree.array(self.dynamic_symbol_table_section.size / 16, "Symbols", "symbols") self.parse_symbol_table_32(self.dynamic_symbol_table, self.dynamic_symbol_table_section, self.sections[self.dynamic_symbol_table_section.link]) except: # Skip errors in symbol table pass # Parse relocation tables self.plt = {} for section in self.sections: if section.type == 9: self.parse_reloc_32(section) elif section.type == 4: self.parse_reloca_32(section) elif self.header.ident.file_class == 2: # 64-bit self.header.uint64("entry") self.header.uint64("program_header_offset") self.header.uint64("section_header_offset") self.header.uint32("flags") self.header.uint16("header_size") self.header.uint16("program_header_size") self.header.uint16("program_header_count") self.header.uint16("section_header_size") self.header.uint16("section_header_count") self.header.uint16("string_table") try: self.sections = self.tree.array(self.header.section_header_count, "sections") for i in range(0, self.header.section_header_count): section = self.sections[i] section.seek(self.header.section_header_offset + (i * 64)) section.uint32("name") section.uint32("type") section.uint64("flags") section.uint64("addr") section.uint64("offset") section.uint64("size") section.uint32("link") section.uint32("info") section.uint64("align") section.uint64("entry_size") if section.type == 2: self.symbol_table_section = section elif section.type == 11: self.dynamic_symbol_table_section = section except: # Section headers are not required to load an ELF, skip errors self.sections = self.tree.array(0, "sections") pass self.program_headers = self.tree.array(self.header.program_header_count, "program_headers") for i in range(0, self.header.program_header_count): header = self.program_headers[i] header.seek(self.header.program_header_offset + (i * 56)) header.uint32("type") header.uint32("flags") header.uint64("offset") header.uint64("virtual_addr") header.uint64("physical_addr") header.uint64("file_size") header.uint64("memory_size") header.uint64("align") # Parse symbol tables self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" try: if self.symbol_table_section: self.symbol_table = self.tree.array(self.symbol_table_section.size / 24, "Symbols", "symbols") self.parse_symbol_table_64(self.symbol_table, self.symbol_table_section, self.sections[self.symbol_table_section.link]) if self.dynamic_symbol_table_section: self.dynamic_symbol_table = self.tree.array(self.dynamic_symbol_table_section.size / 24, "Symbols", "symbols") self.parse_symbol_table_64(self.dynamic_symbol_table, self.dynamic_symbol_table_section, self.sections[self.dynamic_symbol_table_section.link]) except: # Skip errors in symbol table pass # Parse relocation tables self.plt = {} for section in self.sections: if section.type == 9: self.parse_reloc_64(section) elif section.type == 4: self.parse_reloca_64(section) self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self) def read_string_table(self, strings, offset): end = strings.find("\x00", offset) return strings[offset:end] def parse_symbol_table_32(self, table, section, string_table): strings = self.data.read(string_table.offset, string_table.size) for i in range(0, section.size / 16): table[i].seek(section.offset + (i * 16)) table[i].uint32("name_offset") table[i].uint32("value") table[i].uint32("size") table[i].uint8("info") table[i].uint8("other") table[i].uint16("section") table[i].name = self.read_string_table(strings, table[i].name_offset) if len(table[i].name) > 0: self.symbols_by_name[table[i].name] = table[i].value self.symbols_by_addr[table[i].value] = table[i].name def parse_symbol_table_64(self, table, section, string_table): strings = self.data.read(string_table.offset, string_table.size) for i in range(0, section.size / 24): table[i].seek(section.offset + (i * 24)) table[i].uint32("name_offset") table[i].uint8("info") table[i].uint8("other") table[i].uint16("section") table[i].uint64("value") table[i].uint64("size") table[i].name = self.read_string_table(strings, table[i].name_offset) if len(table[i].name) > 0: self.symbols_by_name[table[i].name] = table[i].value self.symbols_by_addr[table[i].value] = table[i].name def parse_reloc_32(self, section): for i in range(0, section.size / 8): ofs = self.data.read_uint32(section.offset + (i * 8)) info = self.data.read_uint32(section.offset + (i * 8) + 4) sym = info >> 8 reloc_type = info & 0xff if reloc_type == 7: # R_386_JUMP_SLOT self.plt[ofs] = self.dynamic_symbol_table[sym].name self.symbols_by_name[self.decorate_plt_name(self.dynamic_symbol_table[sym].name)] = ofs self.symbols_by_addr[ofs] = self.decorate_plt_name(self.dynamic_symbol_table[sym].name) def parse_reloca_32(self, section): for i in range(0, section.size / 12): ofs = self.data.read_uint32(section.offset + (i * 12)) info = self.data.read_uint32(section.offset + (i * 12) + 4) sym = info >> 8 reloc_type = info & 0xff if reloc_type == 7: # R_386_JUMP_SLOT self.plt[ofs] = self.dynamic_symbol_table[sym].name self.symbols_by_name[self.decorate_plt_name(self.dynamic_symbol_table[sym].name)] = ofs self.symbols_by_addr[ofs] = self.decorate_plt_name(self.dynamic_symbol_table[sym].name) def parse_reloc_64(self, section): for i in range(0, section.size / 16): ofs = self.data.read_uint64(section.offset + (i * 16)) info = self.data.read_uint64(section.offset + (i * 16) + 8) sym = info >> 32 reloc_type = info & 0xff if reloc_type == 7: # R_X86_64_JUMP_SLOT self.plt[ofs] = self.dynamic_symbol_table[sym].name self.symbols_by_name[self.decorate_plt_name(self.dynamic_symbol_table[sym].name)] = ofs self.symbols_by_addr[ofs] = self.decorate_plt_name(self.dynamic_symbol_table[sym].name) def parse_reloca_64(self, section): for i in range(0, section.size / 24): ofs = self.data.read_uint64(section.offset + (i * 24)) info = self.data.read_uint64(section.offset + (i * 24) + 8) sym = info >> 32 reloc_type = info & 0xff if reloc_type == 7: # R_X86_64_JUMP_SLOT self.plt[ofs] = self.dynamic_symbol_table[sym].name self.symbols_by_name[self.decorate_plt_name(self.dynamic_symbol_table[sym].name)] = ofs self.symbols_by_addr[ofs] = self.decorate_plt_name(self.dynamic_symbol_table[sym].name) def read(self, ofs, len): result = "" while len > 0: cur = None for i in self.program_headers: if ((ofs >= i.virtual_addr) and (ofs < (i.virtual_addr + i.memory_size))) and (i.memory_size != 0): cur = i if cur == None: break prog_ofs = ofs - cur.virtual_addr mem_len = cur.memory_size - prog_ofs file_len = cur.file_size - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += "\x00" * mem_len len -= mem_len ofs += mem_len continue result += self.data.read(cur.offset + prog_ofs, file_len) len -= file_len ofs += file_len return result def next_valid_addr(self, ofs): result = -1 for i in self.program_headers: if (i.virtual_addr >= ofs) and (i.memory_size != 0) and ((result == -1) or (i.virtual_addr < result)): result = i.virtual_addr return result def get_modification(self, ofs, len): result = [] while len > 0: cur = None for i in self.program_headers: if ((ofs >= i.virtual_addr) and (ofs < (i.virtual_addr + i.memory_size))) and (i.memory_size != 0): cur = i if cur == None: break prog_ofs = ofs - cur.virtual_addr mem_len = cur.memory_size - prog_ofs file_len = cur.file_size - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: result += [DATA_ORIGINAL] * mem_len len -= mem_len ofs += mem_len continue result += self.data.get_modification(cur.offset + prog_ofs, file_len) len -= file_len ofs += file_len return result def write(self, ofs, data): result = 0 while len(data) > 0: cur = None for i in self.program_headers: if ((ofs >= i.virtual_addr) and (ofs < (i.virtual_addr + i.memory_size))) and (i.memory_size != 0): cur = i if cur == None: break prog_ofs = ofs - cur.virtual_addr mem_len = cur.memory_size - prog_ofs file_len = cur.file_size - prog_ofs if mem_len > len: mem_len = len if file_len > len: file_len = len if file_len <= 0: break result += self.data.write(cur.offset + prog_ofs, data[0:file_len]) data = data[file_len:] ofs += file_len return result def insert(self, ofs, data): return 0 def remove(self, ofs, size): return 0 def notify_data_write(self, data, ofs, contents): # Find sections that hold data backed by updated regions of the file for i in self.program_headers: if ((ofs + len(contents)) > i.offset) and (ofs < (i.offset + i.file_size)) and (i.memory_size != 0): # This section has been updated, compute which region has been changed from_start = ofs - i.offset data_ofs = 0 length = len(contents) if from_start < 0: length += from_start data_ofs -= from_start from_start = 0 if (from_start + length) > i.file_size: length = i.file_size - from_start # Notify callbacks if length > 0: for cb in self.callbacks: if hasattr(cb, "notify_data_write"): cb.notify_data_write(self, i.virtual_addr + from_start, contents[data_ofs:(data_ofs + length)]) def save(self, filename): self.data.save(filename) def start(self): result = None for i in self.program_headers: if ((result == None) or (i.virtual_addr < result)) and (i.memory_size != 0): result = i.virtual_addr return result def entry(self): return self.header.entry def __len__(self): max = None for i in self.program_headers: if ((max == None) or ((i.virtual_addr + i.memory_size) > max)) and (i.memory_size != 0): max = i.virtual_addr + i.memory_size return max - self.start() def is_elf(self): return self.data.read(0, 4) == "\x7fELF" def architecture(self): if self.header.arch == 2: return "sparc" if self.header.arch == 3: return "x86" if self.header.arch == 4: return "m68000" if self.header.arch == 8: return "mips" if self.header.arch == 15: return "pa_risc" if self.header.arch == 18: return "sparc_32plus" if self.header.arch == 20: return "ppc" if self.header.arch == 40: return "arm" if self.header.arch == 41: return "alpha" if self.header.arch == 43: return "sparc_v9" if self.header.arch == 62: return "x86_64" return None def decorate_plt_name(self, name): return name + "@PLT" def create_symbol(self, addr, name): self.symbols_by_name[name] = addr self.symbols_by_addr[addr] = name def delete_symbol(self, addr, name): if name in self.symbols_by_name: del(self.symbols_by_name[name]) if addr in self.symbols_by_addr: del(self.symbols_by_addr[addr]) def add_callback(self, cb): self.callbacks.append(cb) def remove_callback(self, cb): self.callbacks.remove(cb) def is_modified(self): return self.data.is_modified() def find(self, regex, addr): while (addr < self.end()) and (addr != -1): data = self.read(addr, 0xfffffffff) match = regex.search(data) if match != None: return match.start() + addr addr += len(data) addr = self.next_valid_addr(addr) return -1 def has_undo_actions(self): return self.data.has_undo_actions() def commit_undo(self, before_loc, after_loc): self.data.commit_undo(before_loc, after_loc) def undo(self): self.data.undo() def redo(self): self.data.redo()
TB.idx[at][TB.TB_orbs[at][0]], TB.idx[at][TB.TB_orbs[at][-1]] + 1, ) ] ), self.ommesh, "G_loc_" + at + ".out", ) if __name__ == "__main__": import Struct, VASP execfile("INPUT.py") # Read input file TB = Struct.TBstructure("POSCAR", p["atomnames"], p["orbs"]) cor_at = p["cor_at"] cor_orb = p["cor_orb"] TB.Compute_cor_idx(cor_at, cor_orb) print TB.TB_orbs DFT = VASP.VASP_class() DMFT = DMFT_class(p, pC, TB) DMFT.Update_Sigoo_and_Vdc(TB, "sig.inp") DMFT.Update_Nlatt(TB, p["nspin"]) DMFT.Read_Sig(TB, p["nspin"]) # print DMFT.Sig # DMFT.Compute_Sigoo_and_Vdc(Nd_qmc,p,TB) ed = array([loadtxt("Ed.out")]) print ed DMFT.Compute_Energy(DFT, TB, ed) DMFT.Compute_Sigoo_and_Vdc(p, TB)
import csv import Struct import gzip counts=dict() TUMOR=sys.argv[1] NORMAL=sys.argv[2] MINCOV_NORMAL=25 print >>sys.stderr, "Reading normal ..." cin=csv.DictReader(gzip.open(NORMAL),delimiter="\t") CovStruct=Struct.Struct CovStruct.setFields(cin.fieldnames) for recD in cin: rec=Struct.Struct(recD) if len(rec.Ref)>1 or len(rec.Alt)>1: continue if rec.Ref=="N": continue if int(rec.BASEQ_depth)<MINCOV_NORMAL: continue key=(rec.Chrom, rec.Pos, rec.Ref, rec.Alt) counts[key]=rec print >>sys.stderr, "done" print >>sys.stderr, "Reading tumor ..." HEADER=""" Chrom Pos Ref Alt TUM.DP TUM.Ap TUM.Cp TUM.Gp TUM.Tp
def __init__(self, data): self.data = data self.valid = False self.callbacks = [] self.symbols_by_name = {} self.symbols_by_addr = {} if not self.is_elf(): return try: self.tree = Struct(self.data) self.header = self.tree.struct("ELF header", "header") self.header.struct("ELF identification", "ident") self.header.ident.uint32("magic") self.header.ident.uint8("file_class") self.header.ident.uint8("encoding") self.header.ident.uint8("version") self.header.ident.uint8("abi") self.header.ident.uint8("abi_version") self.header.ident.bytes(7, "pad") self.header.uint16("type") self.header.uint16("arch") self.header.uint32("version") self.symbol_table_section = None self.dynamic_symbol_table_section = None if self.header.ident.file_class == 1: # 32-bit self.header.uint32("entry") self.header.uint32("program_header_offset") self.header.uint32("section_header_offset") self.header.uint32("flags") self.header.uint16("header_size") self.header.uint16("program_header_size") self.header.uint16("program_header_count") self.header.uint16("section_header_size") self.header.uint16("section_header_count") self.header.uint16("string_table") try: self.sections = self.tree.array(self.header.section_header_count, "sections") for i in range(0, self.header.section_header_count): section = self.sections[i] section.seek(self.header.section_header_offset + (i * 40)) section.uint32("name") section.uint32("type") section.uint32("flags") section.uint32("addr") section.uint32("offset") section.uint32("size") section.uint32("link") section.uint32("info") section.uint32("align") section.uint32("entry_size") if section.type == 2: self.symbol_table_section = section elif section.type == 11: self.dynamic_symbol_table_section = section except: # Section headers are not required to load an ELF, skip errors self.sections = self.tree.array(0, "sections") pass self.program_headers = self.tree.array(self.header.program_header_count, "programHeaders") for i in range(0, self.header.program_header_count): header = self.program_headers[i] header.seek(self.header.program_header_offset + (i * 32)) header.uint32("type") header.uint32("offset") header.uint32("virtual_addr") header.uint32("physical_addr") header.uint32("file_size") header.uint32("memory_size") header.uint32("flags") header.uint32("align") # Parse symbol tables self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" try: if self.symbol_table_section: self.symbol_table = self.tree.array(self.symbol_table_section.size / 16, "Symbols", "symbols") self.parse_symbol_table_32(self.symbol_table, self.symbol_table_section, self.sections[self.symbol_table_section.link]) if self.dynamic_symbol_table_section: self.dynamic_symbol_table = self.tree.array(self.dynamic_symbol_table_section.size / 16, "Symbols", "symbols") self.parse_symbol_table_32(self.dynamic_symbol_table, self.dynamic_symbol_table_section, self.sections[self.dynamic_symbol_table_section.link]) except: # Skip errors in symbol table pass # Parse relocation tables self.plt = {} for section in self.sections: if section.type == 9: self.parse_reloc_32(section) elif section.type == 4: self.parse_reloca_32(section) elif self.header.ident.file_class == 2: # 64-bit self.header.uint64("entry") self.header.uint64("program_header_offset") self.header.uint64("section_header_offset") self.header.uint32("flags") self.header.uint16("header_size") self.header.uint16("program_header_size") self.header.uint16("program_header_count") self.header.uint16("section_header_size") self.header.uint16("section_header_count") self.header.uint16("string_table") try: self.sections = self.tree.array(self.header.section_header_count, "sections") for i in range(0, self.header.section_header_count): section = self.sections[i] section.seek(self.header.section_header_offset + (i * 64)) section.uint32("name") section.uint32("type") section.uint64("flags") section.uint64("addr") section.uint64("offset") section.uint64("size") section.uint32("link") section.uint32("info") section.uint64("align") section.uint64("entry_size") if section.type == 2: self.symbol_table_section = section elif section.type == 11: self.dynamic_symbol_table_section = section except: # Section headers are not required to load an ELF, skip errors self.sections = self.tree.array(0, "sections") pass self.program_headers = self.tree.array(self.header.program_header_count, "program_headers") for i in range(0, self.header.program_header_count): header = self.program_headers[i] header.seek(self.header.program_header_offset + (i * 56)) header.uint32("type") header.uint32("flags") header.uint64("offset") header.uint64("virtual_addr") header.uint64("physical_addr") header.uint64("file_size") header.uint64("memory_size") header.uint64("align") # Parse symbol tables self.symbols_by_name["_start"] = self.entry() self.symbols_by_addr[self.entry()] = "_start" try: if self.symbol_table_section: self.symbol_table = self.tree.array(self.symbol_table_section.size / 24, "Symbols", "symbols") self.parse_symbol_table_64(self.symbol_table, self.symbol_table_section, self.sections[self.symbol_table_section.link]) if self.dynamic_symbol_table_section: self.dynamic_symbol_table = self.tree.array(self.dynamic_symbol_table_section.size / 24, "Symbols", "symbols") self.parse_symbol_table_64(self.dynamic_symbol_table, self.dynamic_symbol_table_section, self.sections[self.dynamic_symbol_table_section.link]) except: # Skip errors in symbol table pass # Parse relocation tables self.plt = {} for section in self.sections: if section.type == 9: self.parse_reloc_64(section) elif section.type == 4: self.parse_reloca_64(section) self.tree.complete() self.valid = True except: self.valid = False if self.valid: self.data.add_callback(self)