def __init__(self): self.header = Header() self.fdata = Data() self.fdict = Dict() self.__fd = None
class Table: rotations = [0, 90, 180, 270] def __init__(self): self.header = Header() self.meta = Meta() self.grid = [] self.objects = dict() def __iter__(self): yield('header', dict(self.header)) yield('meta', dict(self.meta)) yield('objects', self.objects) yield('grid', self.grid) def update(self): self.makeFakeGrid() self.meta.update() def makeFakeGrid(self): # TODO: should I prefix the grid length?? self.grid = [] for i in range(self.header.totalCellNum()): self.grid.append(self.header.makeFakeCell())
def __init__(self): QtGui.QMainWindow.__init__(self) self.setWindowTitle("Salary Manager") self.setGeometry(50,50, 900, 700) self.setWindowState(QtCore.Qt.WindowMaximized) self.setWindowIcon(QtGui.QIcon("Resources/rupee.png")) self.bgWidget = QtGui.QWidget() self.header = Header() self.header.setLogo("Resources/iiitk.png") self.header.setHeaderText("Salary Management System", "Indian Institute of Information Technology Kalyani") self.widgetStack = QtGui.QStackedWidget() self.setCentralWidget(self.bgWidget) self.setupUI() self.pages = { "Login": LoginWidget, "Home": HomeWidget, "Add Employee": AddEmployeeWidget, "Del Employee": DelEmployeeWidget, "Edit Employee": EditEmployeeWidget, "Show Employee": ShowEmployeeWidget, "Add Designation": AddDesignationWidget, "Edit Designation": EditDesignationWidget, "Show Designation": ShowDesigationWidget, "Calc Salary": CalculateSalaryWidget, "Result": ShowPaySlipWidget } self.gotoPage("Login")
def parseMessage(message): #if server message is an empty msg with no header - total timeout if len(message) == 0: return 0, 0, 0, 0 #otherwise handle the file as normal else: hdr = Header() hdr.Write() print "msg" print message headerData = message[:39] print repr(headerData) headerdict = hdr.Read(headerData) #splitMessage = message.split("@") messageType = headerdict["datatype"] data = message[40:] index = headerdict["sequencenumber"] fileName = headerdict["options"] #index:message populate file dict #if data exists its part of the file and should be stored if len(data) != 0: fileDict[index] = data return data, index, fileName, messageType
def process(url): header = Header(url) header.reader() print("Scanning: " + color.blue + url + color.end) if header.status: scanObj = Scan(url) scanObj._start() else: print(color.blue + url + color.red + " is Unreachable") sleep(3)
def create(self, db_path: str, db_name: str): full_path = os.path.join(db_path, db_name) if not os.path.exists(full_path): os.mkdir(full_path) header = Header(full_path) header.save() self.__db_path = full_path
class Block: def __init__(self, block_bytes_array, _block_num): bytes_magic = block_bytes_array[:4] bytes_rest = block_bytes_array[4:] bytes_size = bytes_rest[:4] bytes_rest = bytes_rest[4:] bytes_header = bytes_rest[:80] bytes_rest = bytes_rest[80:] bytes_tx_count = bytes_rest[:1] # get varInt prefix bytes_rest = bytes_rest[1:] # check if varInt is on 1, 2, 4, or 8 bytes if(bytes_tx_count[0] == 253): # varInt is on 2 bytes AFTER the prefix bytes_tx_count = bytes_rest[:2] bytes_rest = bytes_rest[2:] elif(bytes_tx_count[0] == 254): # varInt is on 4 bytes AFTER the prefix bytes_tx_count = bytes_rest[:4] bytes_rest = bytes_rest[4:] elif(bytes_tx_count[0] == 255): # varInt is on 8 bytes AFTER the prefix bytes_tx_count = bytes_rest[:8] bytes_rest = bytes_rest[8:] # else varInt was on 1 bytes, nothing to do bytes_tx_data = bytes_rest self.block_num = _block_num self.magic = int.from_bytes(bytes_magic, byteorder='little') self.size = int.from_bytes(bytes_size, byteorder='little') self.tx_count = int.from_bytes(bytes_tx_count, byteorder='little') self.header = Header(bytes_header) self.transactions = Transactions(bytes_tx_data, self.tx_count) def getNet(self): if(self.magic == 3652501241): return 'main network' elif(self.magic == 3669344250): return 'test network' elif(self.magic == 118034699): return 'test network 3' elif(self.magic == 4273258233): return 'namecoin network' else: return 'unknown network' def print(self): print() print('Block :', self.block_num) print(' ', self.getNet()) print(' block size :', self.size) print(' ', self.tx_count, 'transaction(s)') self.header.print() self.transactions.print() print() print('*** END OF BLOCK',self.block_num,'***')
def test_header_render(self): h1 = Header("test", 1) self.assertEqual(h1.render(), "<h1> test </h1>") h1 = Header("hello", 2) self.assertEqual(h1.render(), "<h2> hello </h2>") h1 = Header(("hello world"), 3) self.assertEqual(h1.render(), "<h3> hello world </h3>")
def __init__(self, rfc, contrasena): self.__rfc = rfc self.__contrasena = contrasena self.__sesion = requests.Session() self.__directorioAGuardar = '' self.__header = Header() self.__hostCfdiau = 'cfdiau.sat.gob.mx' self.__hostPortalCfdi = 'portalcfdi.facturaelectronica.sat.gob.mx' self.__urlCfdiau = 'https://' + self.__hostCfdiau + '/' self.__urlPortalCfdi = 'https://' + self.__hostPortalCfdi + '/' self.__urlCfdiCont = 'https://cfdicontribuyentes.accesscontrol.windows.net/' self.__error = '' self.__listaDocumentos = []
def __init__(self, file_path): self.file_path = file_path fd = gzip.open(file_path, "rb") bheader = fd.read(Header.SIZE) self.header = Header(bheader) fd.seek(self.header.data_start) bin_data = fd.read(self.header.data_size) self.fdata = Data(bin_data) fd.close()
def __init__(self,parentInfo,foldBuffer,countsBuffer, period,dm,nbins,nints,nbands): Header.__init__(self,parentInfo) self.foldBuffer = foldBuffer self.countsBuffer = countsBuffer self.foldArray = foldBuffer.Ndarray.reshape(nints,nbands,nbins) self.countsArray = countsBuffer.Ndarray.reshape(nints,nbands,nbins) self.foldArray = self.foldArray/self.countsArray self.period = period self.dm = dm self.nbins = nbins self.nints = nints self.nbands = nbands self.reset()
def __init__(self): Header.__init__(self) self.contents = { "name_index": 0, "type": 0, "flag": 0, "address": 0, "offset": 0, "size": 0, "link": 0, "info": 0, "address_align": 0, "entry_table_size": 0, }
def __init__(self): Header.__init__(self) self.contents = { 'name_index' : 0, 'type' : 0, 'flag' : 0, 'address' : 0, 'offset' : 0, 'size' : 0, 'link' : 0, 'info' : 0, 'address_align' : 0, 'entry_table_size': 0, }
def _write_headers(self, msg): for h, v in msg.items(): print >> self._fp, '%s:' % h, if self.__maxheaderlen == 0: # Explicit no-wrapping print >> self._fp, v elif isinstance(v, Header): # Header instances know what to do print >> self._fp, v.encode() elif _is8bitstring(v): # If we have raw 8bit data in a byte string, we have no idea # what the encoding is. There is no safe way to split this # string. If it's ascii-subset, then we could do a normal # ascii split, but if it's multibyte then we could break the # string. There's no way to know so the least harm seems to # be to not split the string and risk it being too long. print >> self._fp, v else: # Header's got lots of smarts, so use it. print >> self._fp, Header(v, maxlinelen=self.__maxheaderlen, header_name=h, continuation_ws='\t').encode() # A blank line always separates headers from body print >> self._fp
def read_db(self, file_path): print("read_db") print(file_path) #--- open file with open(file_path, "rb") as fd: #--- header bheader = fd.read(Header.SIZE) header = Header(bheader) print(header) #--- dict bdict = fd.read(header.dict_size) fdict = Dict(bdict) # for r in fdict.records_map.values(): # print(r) # print(fdict) #--- data bdata = fd.read(header.data_size) fdata = Data(bdata) print() print("root files: ") for r in fdict.records_map.values(): if r.pid == 0: ff = fdata.get_record(r.daddr, r.dsize) print(ff)
def read_db(self, file_path): print("read_db") print(file_path) #--- open file with open(file_path, "rb") as fd: #--- header bheader = fd.read(Header.SIZE) header = Header(bheader) print(header) #--- dict fd.seek(header.dict_start) bdict = fd.read(header.dict_size) fdict = Dict(bdict) # for r in fdict.records_map.values(): # print(r) #--- data # for r in fdict.records_map.values(): # if r.pid == 0: # # print(r.fid, r.pid) # start = r.daddr # size = r.dsize # fd.seek(start) # bfile_data = fd.read(size) # record = DataRecord(bfile_data) # print(record) Store.reprint(fd, fdict, 0, 0)
def __init__(self, urlBase, name, token): self.name = name self.token = token self.urlBase = urlBase self.auth = Auth(self.token) self.header = [ Header("Content-Type", "Content-Type", "application/json", "text") ]
class Reader(object): def __init__(self, file_path): self.file_path = file_path fd = gzip.open(file_path, "rb") bheader = fd.read(Header.SIZE) self.header = Header(bheader) fd.seek(self.header.data_start) bin_data = fd.read(self.header.data_size) self.fdata = Data(bin_data) fd.close() def print_root_files(self): self.header.print_header() for record in self.fdata.records: # print("{} : {:>8} {:>8}".format(record.name, record.size, record.st_ctime)) if record.pid == 0: # start = r.daddr # size = r.dsize # self.__fd.seek(start) # bfile_data = self.__fd.read(size) # record = DataRecord(bfile_data) print("{} : {:>8} {:>8}".format(record.name, record.size, record.st_ctime)) def print_tree(self): print("tree") self.header.print_header() Reader.reprint(self.fdata, 0, 0) @staticmethod def reprint(fdata, parent_id, ind): for record in fdata.records: if record.pid == parent_id: print(ind * "\t" + record.name + str(record.ftype)) if record.ftype == 2: Reader.reprint(fdata, record.fid, ind + 1)
def __init__(self,parentInfo,mallocBuffer=None): """Construct time series object from buffer or file. Args: parentInfo -- may be a file name or a dict instance containing header information mallocBuffer -- a SigPyProcUtils Buffer instance. If parentInfo is a file, this argument is ignored """ Header.__init__(self,parentInfo) if isinstance(parentInfo,dict) and not mallocBuffer == None: self.timBuffer = mallocBuffer elif isinstance(parentInfo,str) and mallocBuffer == None: self._readTim()
def __init__(self,parentInfo,mallocBuffer): """Construct spectrum object from buffer. Args: parentInfo -- dict instance containing header information mallocBuffer -- a SigPyProcUtils Buffer instance. """ Header.__init__(self,parentInfo) self.fftBuffer = mallocBuffer self.info = parentInfo self.candDtype = [("bin","int"), ("freq","float"), ("period","float"), ("sigma","float"), ("fold","int"), ("refdm","float")] self._formSpec()
def make_db(self, scan_path, out_file): print("make_db") print(scan_path) print(out_file) header = Header() fdict = Dict() fdata = Data() self.__start_scan(scan_path, fdata) print(len(fdata.records)) #--- make dict for record in fdata.records: fdict.append_record(record.fid, record.pid) print(len(fdict.records_map)) #--- update header data header.dict_start = Header.SIZE header.dict_size = fdict.get_bdata_size() header.data_start = Header.SIZE + header.dict_size # fdata_bin = fdata.pack() # header.data_size = len(fdata_bin) #--- fdata_bin = b"" # fdata_start = header.data_start fdata_start = 0 for record in fdata.records: rb = record.pack() #--- update dict addr fdict.set_addr(record.fid, fdata_start, len(rb)) fdata_bin += rb fdata_start += len(rb) header.data_size = len(fdata_bin) # flat: 1496, gzip: 8182 # gzip_fdata_bin = gzip.compress(fdata_bin,9) # print("-"*80) # print("flat: {:>4}, gzip: {:>4}".format(len(gzip_fdata_bin), len(fdata_bin))) # print("-"*80) #--- make binary bdata = b"" bdata += header.pack() bdata += fdict.pack() bdata += fdata_bin #--- write file with open(out_file, "wb") as fd: fd.write(bdata)
def inputs(): #define global variables global state global putFile #create header to populate request message with while(1): #sys arg input scheme datatype = sys.argv[1] #original input scheme #datatype = raw_input("GET or PUT a file?\n") if (datatype == "GET") or (datatype == "PUT"): break else: print "Please input a proper request (GET or PUT)" while(1): #sysarg input filename = sys.argv[2] #original input method #filename = raw_input("What file do you want/have?\n") if datatype == "PUT": if os.path.isfile(filename): print "Fetching File..." putFile = filename break else: print "File does not exist. Choose another file..." if datatype == "GET": break print"Processing Request..." #create instance of header class request = Header() #populate it with the input and write a header for the request request.datatype = datatype request.options = filename reqHead = request.Write() #update state variable if request.datatype == "GET": state=1 else: state=2 #return the header meant to be sent with the request return state, reqHead
def __init__(self, rom_path: str): with open(rom_path, "rb") as file: self.rom = file.read() self.header = Header(self.rom[0:15]) self.trainer_data = [] if self.header.trainer: self.trainer_data = self.rom[16:16 + 512] self.prg_data = self.rom[16 + 512:16 + 512 + self.header.prg_data_size] else: self.prg_data = self.rom[16:16 + self.header.prg_data_size]
def __init__(self,filename): """Create Filterbank instance. Args: filename -- string containing name of file to process """ Header.__init__(self,filename) self.f = File(filename,"r",nbits=self.info["nbits"]) infofile = "%s.info"%(self.basename) if os.path.isfile(infofile): try: self.stats = cPickle.load(open(infofile,"r")) except: self.stats = None else: self.stats = None if self.ctype == C.c_float: self.lib = C.CDLL("libSigPyProc32.so") else: self.lib = C.CDLL("libSigPyProc8.so")
def __init__(self, rfc, contrasena): self.__rfc = rfc self.__contrasena = contrasena self.__sesion = requests.Session() self.__directorio_guardar = '' self.__header = Header() self.__host_cfdiau = 'cfdiau.sat.gob.mx' self.__host_portal_cfdi = 'portalcfdi.facturaelectronica.sat.gob.mx' self.__url_cfdiau = 'https://' + self.__host_cfdiau + '/' self.__url_portal_cfdi = 'https://' + self.__host_portal_cfdi + '/' self.__url_cfdi_cont = ('https://cfdicontribuyentes.accesscontrol.' 'windows.net/') self.__error = '' self.__lista_documentos = []
def readFileHeader(self, inFile): """ Read the header of the open file """ for line_counter in range(constants.HEADER_LINES): line_read = inFile.readline() if (line_counter == constants.HEADER_DATE): date = line_read elif (line_counter == constants.HEADER_HOURS): time = line_read elif (line_counter == constants.HEADER_FILETYPE): scope = line_read return Header(date, time, scope)
def miner(transaction_pool): last_block_header = '0'*64 # genesis header last_block_target = '%064x' % (0x7ffff * 2 ** (8 * (0x20 - 3))) #uncomment the line below for harder difficulty #last_block_target = '000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff' # init the block chains block_chain = BlockChain() block = Block(Header(last_block_header), last_block_target) # use variable to keep track of where in the pool we left off reading from # so that we're not going to re-mine the same block left_off_in_pool = 0 # add coinbase transaction block.add_transaction(CoinbaseTransaction(0)) for i in range(1, 9): block.add_transaction(transaction_pool.transactions[i]) left_off_in_pool = i # now that our block is full, we can start to mine it. while not block.mine_this_block(): continue block_chain.add_block(block) print("current blockchain height ", block_chain.size_of_chain()) sleep(5) # our new header for block 2 will need the hash of block 1 last_block_header = double_hash(encode_and_concenate([block_chain.latest_block().BlockHash])) block_2 = Block(Header(last_block_header), last_block_target) block_2.add_transaction(CoinbaseTransaction(block.transactions[0].current_total)) for i in range(left_off_in_pool+9): block_2.add_transaction(transaction_pool.transactions[i]) left_off_in_pool = i # now that our block is full, we can start to mine it. while not block_2.mine_this_block(): continue block_chain.add_block(block_2) print("current blockchain height ", block_chain.size_of_chain()) print() for i, block_added in enumerate(block_chain.blocks): print('Block #{} was added. It took {} steps to find it.'.format(i, block_added.nonce))
def __init__(self, block_bytes_array, _block_num): bytes_magic = block_bytes_array[:4] bytes_rest = block_bytes_array[4:] bytes_size = bytes_rest[:4] bytes_rest = bytes_rest[4:] bytes_header = bytes_rest[:80] bytes_rest = bytes_rest[80:] bytes_tx_count = bytes_rest[:1] # get varInt prefix bytes_rest = bytes_rest[1:] # check if varInt is on 1, 2, 4, or 8 bytes if(bytes_tx_count[0] == 253): # varInt is on 2 bytes AFTER the prefix bytes_tx_count = bytes_rest[:2] bytes_rest = bytes_rest[2:] elif(bytes_tx_count[0] == 254): # varInt is on 4 bytes AFTER the prefix bytes_tx_count = bytes_rest[:4] bytes_rest = bytes_rest[4:] elif(bytes_tx_count[0] == 255): # varInt is on 8 bytes AFTER the prefix bytes_tx_count = bytes_rest[:8] bytes_rest = bytes_rest[8:] # else varInt was on 1 bytes, nothing to do bytes_tx_data = bytes_rest self.block_num = _block_num self.magic = int.from_bytes(bytes_magic, byteorder='little') self.size = int.from_bytes(bytes_size, byteorder='little') self.tx_count = int.from_bytes(bytes_tx_count, byteorder='little') self.header = Header(bytes_header) self.transactions = Transactions(bytes_tx_data, self.tx_count)
def sendAck(index, fileName): ack = Header() #populate it with the sequencenum and file name and ACK message type ack.datatype = "ACK" ack.sequencenumber = index ack.options = fileName ackHead = ack.Write() #send just the ACK header clientSocket.sendto(ackHead, serverAddr)
def main(): file_name = verificador(sys.argv) nomeArqFinal = file_name nomeArqFinal = nomeArqFinal.replace('.s', '.m') print(nomeArqFinal) arq = open(file_name, 'r') codigoCompleto = arq.readlines() #codigoCompleto.remove('\n') final = open(nomeArqFinal, 'w') header = Header() listaText = [] qntInstrucoes(header, codigoCompleto, listaText) content = [] # HEADER content.append("f0f0 f0f0 ") content.append("0000 0000 ") content.append(hex(header.qntInstrucoes)[2:].zfill(4)) content.append(' ') content.append("0000 ") content.append("f0f0 f0f0") final.write(''.join(content)) # TEXT regs = Listas() for l in listaText: linhaAtual = [] linhaAtual = l.split(' ') print(linhaAtual) arq.close() final.close()
def readHeader(fileName): """ Returns a tuple with the date, time, company and scope specified in input file. Requires: input file is a text file in established format and fileName is a string with the name of the file. Ensures: returnal of a tuple in format (date, time, company, scope). """ inFile = open(fileName, "r") inFile.readline() time = inFile.readline().replace( "\n", "") #removes leftover \n from ending of lines in text file inFile.readline() date = inFile.readline().replace("\n", "") inFile.readline() company = inFile.readline().replace("\n", "") scope = inFile.readline().replace("\n", "").replace(":", "") inFile.close() header = Header(date, time, company, scope) return header
def build(self): appLayout = FloatLayout(size=(800, 600)) bg = Image(source='Images/Metal2.jpg', pos=(0, 0), size=(1500, 840)) g1 = Gauge() g1s = ScatterLayout(scale=0.5, size=g1.size, pos=(30, 80)) g1s.add_widget(g1) g2 = Gauge() g2s = ScatterLayout(scale=0.5, size=g1.size, pos=(200, 80)) g2s.add_widget(g2) g3 = Gauge() g3s = ScatterLayout(scale=0.5, size=g1.size, pos=(300, 80)) g3s.add_widget(g3) head = Header() headscat = Scatter(size=head.size, pos=(0, 530), do_translation=False) headscat.add_widget(head) foot = Footer() Footer.updatedate(foot) #Clock.schedule_interval(foot.updatetime, 1) Clock.schedule_interval(partial(Footer.updatetime, foot), 1) Clock.schedule_interval(partial(Footer.updatedate, foot), 3600) #footscat = Scatter(size=foot.size, pos=(0,-10), do_translation=False) #footscat.add_widget(foot) appLayout.add_widget(bg) appLayout.add_widget(g1s) appLayout.add_widget(g2s) appLayout.add_widget(g3s) appLayout.add_widget(headscat) appLayout.add_widget(foot) Window.size = (800, 600) return appLayout
class PortalCfdi: def __init__(self, rfc, contrasena): self.__rfc = rfc self.__contrasena = contrasena self.__sesion = requests.Session() self.__directorio_guardar = '' self.__header = Header() self.__host_cfdiau = 'cfdiau.sat.gob.mx' self.__host_portal_cfdi = 'portalcfdi.facturaelectronica.sat.gob.mx' self.__url_cfdiau = 'https://' + self.__host_cfdiau + '/' self.__url_portal_cfdi = 'https://' + self.__host_portal_cfdi + '/' self.__url_cfdi_cont = ('https://cfdicontribuyentes.accesscontrol.' 'windows.net/') self.__error = '' self.__lista_documentos = [] def __entrar_pagina_inicio(self): url = self.__url_cfdiau + \ '/nidp/app/login?id=SATUPCFDiCon&sid=0&option=credential&sid=0' self.__sesion.post(url) def __enviar_formulario_ciec(self): url = self.__url_cfdiau + 'nidp/app/login?sid=0&sid=0' encabezados = self.__header.obtener( self.__host_cfdiau, self.__url_cfdiau + '/nidp/app/login?id=SATUPCFDiCon&sid=0&option=credential&sid=0' ) valores_post = { 'option': 'credential', 'Ecom_User_ID': self.__rfc, 'Ecom_Password': self.__contrasena, 'submit': 'Enviar' } self.__sesion.post(url, data=valores_post, headers=encabezados) def __leer_formulario(self, html): html_formulario = HTMLForm(html, 'form') input_valores = html_formulario.get_form_values() return input_valores def __leer_formulario_respuesta(self): url = self.__url_portal_cfdi respuesta = self.__sesion.get(url) html_respuesta = respuesta.text return self.__leer_formulario(html_respuesta) def __leer_formulario_access_control(self, valores_post): url = self.__url_cfdi_cont + 'v2/wsfederation' respuesta = self.__sesion.post(url, data=valores_post) html_respuesta = respuesta.text return self.__leer_formulario(html_respuesta) def __entrar_pantalla_inicio_sistema(self, valores_post): url = self.__url_portal_cfdi respuesta = self.__sesion.post(url, data=valores_post) html_respuesta = respuesta.text return html_respuesta def __obtener_valores_post_tipo_busqueda(self, html_fuente): tipo_busqueda = 'RdoTipoBusquedaReceptor' input_valores = self.__leer_formulario(html_fuente) input_valores['ctl00$MainContent$TipoBusqueda'] = tipo_busqueda input_valores['__ASYNCPOST'] = 'true' input_valores['__EVENTTARGET'] = '' input_valores['__EVENTARGUMENT'] = '' input_valores['ctl00$ScriptManager1'] = ('ctl00$MainContent$' 'UpnlBusqueda|' 'ctl00$MainContent$' 'BtnBusqueda') return input_valores def __seleccionar_tipo(self, html_fuente): url = self.__url_portal_cfdi + 'Consulta.aspx' post = self.__obtener_valores_post_tipo_busqueda(html_fuente) encabezados = self.__header.obtener( self.__host_cfdiau, self.__url_portal_cfdi ) respuesta = self.__sesion.post(url, data=post, headers=encabezados) return respuesta.text def __logueo_usuario_ciec(self): self.__entrar_pagina_inicio() self.__enviar_formulario_ciec() valores_post = self.__leer_formulario_respuesta() valores_post_access_ctrl = self.\ __leer_formulario_access_control(valores_post) html = self.__entrar_pantalla_inicio_sistema(valores_post_access_ctrl) self.__seleccionar_tipo(html) def __entra_consulta_receptor(self, filtros): url = self.__url_portal_cfdi + 'ConsultaReceptor.aspx' respuesta = self.__sesion.get(url) html_respuesta = respuesta.text input_valores = self.__leer_formulario(html_respuesta) util = Utilerias() post = util.\ mezcla_listas( input_valores, filtros.obtener_post_formulario_fechas() ) encabezados = self.__header.obtener_ajax( self.__host_portal_cfdi, self.__url_portal_cfdi + 'ConsultaReceptor.aspx' ) respuesta = self.__sesion.post(url, data=post, headers=encabezados) return respuesta.text, input_valores def __obtener_valores_post_busqueda_fechas(self, html, inputs, filtros): parser = ParserFormatSAT(html) valores_cambio_estado = parser.obtener_valores_formulario() util = Utilerias() temporal = util.mezcla_listas(inputs, filtros.obtener_post()) return util.mezcla_listas(temporal, valores_cambio_estado) def __consulta_receptor_fecha(self, filtros): url = self.__url_portal_cfdi + 'ConsultaReceptor.aspx' html_respuesta, input_valores = self.__entra_consulta_receptor(filtros) valores_post = self.__obtener_valores_post_busqueda_fechas( html_respuesta, input_valores, filtros ) encabezados = self.__header.obtener_ajax( self.__host_portal_cfdi, self.__url_portal_cfdi + 'ConsultaReceptor.aspx' ) respuesta = self.__sesion.post( url, data=valores_post, headers=encabezados ) return respuesta.text def __consulta_receptor_folio(self, fltrs): url = self.__url_portal_cfdi + 'ConsultaReceptor.aspx' respuesta = self.__sesion.get(url) html_respuesta = respuesta.text input_valores = self.__leer_formulario(html_respuesta) util = Utilerias() valores_post = util.mezcla_listas(input_valores, fltrs.obtener_post()) encabezados = self.__header.obtener_ajax( self.__host_portal_cfdi, self.__url_portal_cfdi + 'ConsultaReceptor.aspx' ) respuesta = self.__sesion.post( url, data=valores_post, headers=encabezados ) return respuesta.text def error(self): return self.__error def lista_cfdis(self): return self.__lista_documentos def consultar(self, directorio_guardar, filtros): try: self.__logueo_usuario_ciec() if filtros.folio_fiscal != '': html_respuesta = self.__consulta_receptor_folio(filtros) nombre = filtros.folio_fiscal else: html_respuesta = self.__consulta_receptor_fecha(filtros) nombre = '' xml = DescargarXML( self.__sesion, html_respuesta, directorio_guardar ) xml.obtener_enlaces_descargar(nombre) self.__lista_documentos = xml.get_lista_documentos_descargados() return True except: error = traceback.format_exc() self.__error = error return False
from CorpusReader import CorpusReader from levenshtein import levenshtein as lev from collections import Counter from pdb import set_trace from Header import Header header = Header() SUFF = ('eas', 'is', 'ais', 'as', 'eamar', 'amar', 'eabhair', 'abhair', 'ead ar', 'adar') books = False sentences = True print "Loading Corpora..." if books: print "\tloading munster" M = CorpusReader('munster') print "\tloading connacht" C = CorpusReader('connacht',M.countBooks()) C.truncateBooks(M.countBooks()) print "\tloading ulster" U = CorpusReader('ulster', M.countBooks()) U.truncateBooks(M.countBooks()) l = [U,M,C] #print "Done." if sentences: print "Creating Balanced Set of sentences" M = CorpusReader('munster') C = CorpusReader('connacht') U = CorpusReader('ulster') l = [U,M,C] MIN_LENG = min([x.countSentences() for x in l])
def __init__(self): super(Query, self).__init__(Header(MessageType.query))
def __init__(self,parentInfo,mallocBuffer=None): Header.__init__(self,parentInfo) if not mallocBuffer == None: self.bpassBuffer = mallocBuffer
def __init__(self): super().__init__() self.setWindowTitle('Petro-Explorer v1.0') win_icon = QIcon('icons/Logo.ico') self.setWindowIcon(win_icon) self.setStyleSheet('background-color: #363f49;') self.header = Header() self.navigation = Navigation() self.p_top_bar = PetrophysicsTopBar() self.s_top_bar = StatisticsTopBar() self.p_options_1 = PetrophysicsOptions(_mode='KCarman') self.p_options_2 = PetrophysicsOptions(_mode='TCoates') self.p_options_3 = PetrophysicsOptions(_mode='Winland') self.p_options_4 = PetrophysicsOptions(_mode='RQIFZI') self.p_options_5 = PetrophysicsOptions(_mode='Lucia') self.p_options_6 = PetrophysicsOptions(_mode='DParsons') self.s_options_1 = StatisticsOptions(_mode='Regression') self.s_options_2 = StatisticsOptions(_mode='Statistics') self.s_options_3 = StatisticsOptions(_mode='Histogram') self.s_options_4 = StatisticsOptions(_mode='Boxplot') self.sp_controls = SpreadsheetControls() self.plot_controls = PlotControls() self.plot_viewer = PlotViewer() self.spreadsheet = Spreadsheet() self.status_bar = QStatusBar() self.scroll_area_1 = QScrollArea() self.scroll_area_1.setWidget(self.spreadsheet) self.scroll_area_1.setWidgetResizable(True) self.scroll_area_2 = QScrollArea() self.scroll_area_2.setWidget(self.plot_viewer) self.scroll_area_2.setWidgetResizable(True) self.bar_widget = QWidget() self.bar_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum) self.central_widget = QWidget() self.options_widget = QWidget() self.docking_options = QDockWidget() self.docking_options.setWidget(self.options_widget) self.docking_options.setTitleBarWidget( DockWidgetRibbon(' Opções de cálculo')) self.docking_options2 = QDockWidget() self.docking_options2.setWidget(self.sp_controls) self.docking_options2.setTitleBarWidget( DockWidgetRibbon(' Controles de visualização')) self.setCentralWidget(self.central_widget) self.setStatusBar(self.status_bar) self.addToolBar(self.navigation) self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options) self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options2) self.connections() self.buildLayout() self.centralWidget().setStyleSheet('background-color: #2e3843') self.spreadsheet.setStyleSheet('background-color: white') self.status_bar.setStyleSheet('color: white')
def main(self): header = Header() header.setDividerLength(60) header.setValueColumn(20) header.setUserID("ADET_ID") header.setProgrammer("Lname, Fname MI.") header.setCourse("CSCI-400") header.setTerm("SP14") header.setProject("01") header.setPython("3.3.3") print("******************************************") print("*** Header Format Examples ***") print("******************************************") print('') for ext in ["hack","xml","hdl","asm","vm","jack","py"]: print("---------------") print(ext.upper()) print("---------------") print(header.gen("AnExample." + ext)) print("******************************************") print("*** End of Header Format Examples ***") print("******************************************")
def __init__(self): Gtk.Window.__init__(self, title="Network Traffic Based Software Generation") # screenWidth = Gdk.Screen.get_width(Gdk.Screen.get_default()) # screenHeigth = Gdk.Screen.get_height(Gdk.Screen.get_default()) # Gtk.Window.resize(self,screenWidth/10,screenHeigth/3) self.PCAPWidget = "" self.PacketList = {} self.ProtocolList = {} self.filterExpression = "le Filter" self.PacketAreaBox = PacketArea(self) mainGrid = Gtk.Grid() # mainGrid.set_column_spacing(4) # mainGrid.set_row_spacing(4) # mainGrid.set_row_homogeneous(False) # mainGrid.set_hexpand(False) self.add(mainGrid) # # for x in range(4): # mainGrid.set_row_baseline_position(x,Gtk.BaselinePosition.CENTER) #Start of Header HeaderBox = Header(self, "Network Traffic Based Software Generation") HeaderBox.addButton("State Machine") HeaderBox.addButton("Create Session") HeaderBox.addButton("Open Session") HeaderBox.addButton("Close Session") HeaderBox.addButton("Switch Workspace") HeaderBox.addButton("Open PCAP") HeaderBox.addButton("Terminal") HeaderBox.showButtons() HeaderButtons = HeaderBox._buttons HeaderButtons[6].connect("clicked", HeaderBox.Terminal_clicked) HeaderButtons[5].connect("clicked", HeaderBox.PCAP_clicked) HeaderButtons[4].connect("clicked", HeaderBox.Workspace_clicked) HeaderButtons[3].connect("clicked", HeaderBox.OpenSession_clicked) HeaderButtons[2].connect("clicked", HeaderBox.OpenSession_clicked) HeaderButtons[1].connect("clicked", HeaderBox.NewSession_clicked) HeaderButtons[0].connect("clicked", HeaderBox.StateMachine_clicked) mainGrid.attach(HeaderBox, 0, 0, 4, 1) #End of Header #Image Containing the status. StatusIndicator = Gtk.Image.new_from_file("statusIndicator.png") StatusFrame = Gtk.Frame() StatusBox = Gtk.Box(spacing=0) StatusBox.add(StatusFrame) mainGrid.attach(StatusBox, 0, 1, 4, 1) StatusBox.pack_start(StatusIndicator, False, True, 0) #End of Image containing the Status. #Start of Sessions View SessionsBox = Session() SessionsBox.addSession("Session A") SessionsBox.addSession("Session B") SessionsBox.addSession("Session C") SessionsBox.showSessions() SessionsBox.set_vexpand(True) mainGrid.attach(SessionsBox, 0, 2, 1, 1) #End of Sessions View #Start of PDML View # PDMLFrame = Gtk.Frame() PDMLBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) PDMLLabel = Gtk.Label("PDML View") PDMLLabel.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse("light blue")) PDMLBox.pack_start(PDMLLabel, False, False, 0) PDMLViewBox = PDMLView(self) PDMLBox.pack_start(PDMLViewBox, False, False, 0) PDMLBox.add(self.PacketAreaBox) PDMLBox.set_hexpand(True) # PDMLBox.pack_start(self.PacketAreaBox,True,True,0) mainGrid.attach(PDMLBox, 1, 2, 4, 1) #End of PDML View #Start of Tagging View TagBox = TagArea() TagBox.addCombobox("Saved Tag") TagBox.addField("Tag Name") TagBox.addField("Tagged Field") TagBox.addField("Tag Description") TagBox.populateFields() TagBox.showFields() TagBox.addButton("Update") TagBox.addButton("Cancel") TagBox.showButtons() mainGrid.attach(TagBox, 0, 3, 1, 1) #End of Tagging View #Start of field area View FieldAreaBox = FieldArea() mainGrid.attach(FieldAreaBox, 1, 3, 1, 1) FieldAreaBox.addField("icmp.type", "Type 8 [Echo ping request]", 1, 34, "8", "8", 2) #Start of Message Type View MessageTypeBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) mainGrid.attach(MessageTypeBox, 2, 3, 2, 1) MessageTypeFrame = Gtk.Frame() MessageTypeBox.add(MessageTypeFrame) # # # #IMPORTANT: Notebook requires all views to be inside a box. This section is all the views until I find a way to have it set up more efficiently. # #Start of New/Modify MessageTypeTabs = Gtk.Notebook() NewModifyView = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) InstructionsLabel = Gtk.Label( "To create a new message type, please enter a message type name and select message type field value pair(s). \n To Update/delete an existing message type, please select from the existing message type first \n and the previously selected name and field value pair(s) will be pre-populated." ) InstructionsLabel.set_line_wrap(True) ExistingMessageTypeBox = Gtk.Box(spacing=1) ExistingMessageLabel = Gtk.Label("Existing Message Type") ExistingMessageTypeBox.pack_start(ExistingMessageLabel, False, False, 0) ExistingMessageType = Gtk.Entry() ExistingMessageTypeBox.pack_start(ExistingMessageType, False, False, 0) MessageTypeNameBox = Gtk.Box(spacing=2) MessageTypeLabel = Gtk.Label("Message Type Name") MessageTypeNameBox.pack_start(MessageTypeLabel, False, False, 0) MessageTypeName = Gtk.Entry() MessageTypeNameBox.pack_start(MessageTypeName, False, False, 0) MessageTypePairsBox = Gtk.Box(spacing=2) MessageTypePairsLabel = Gtk.Label("Message Type Field\n Value Pair(s)") MessageTypePairsBox.pack_start(MessageTypePairsLabel, False, False, 0) ValuePairs = Gtk.Entry() MessageTypePairsBox.pack_start(ValuePairs, False, False, 0) NewModifyView.pack_start(InstructionsLabel, False, False, 0) NewModifyView.pack_start(ExistingMessageTypeBox, False, False, 0) NewModifyView.pack_start(MessageTypeNameBox, False, False, 0) NewModifyView.pack_start(MessageTypePairsBox, False, False, 0) SelectBothField = Gtk.CheckButton( label="Select both field name and value") SelectFieldNameOnly = Gtk.CheckButton(label="Select field name only") NewModifyView.pack_start(SelectBothField, False, False, 0) NewModifyView.pack_start(SelectFieldNameOnly, False, False, 0) OperationButtons = Gtk.Box(spacing=2) SaveButtonMessageType = Gtk.Button(label="Save") DeleteButtonMessageType = Gtk.Button(label="Delete") ClearButtonMessageType = Gtk.Button(label="Clear") OperationButtons.pack_start(SaveButtonMessageType, False, False, 0) OperationButtons.pack_start(DeleteButtonMessageType, False, False, 0) OperationButtons.pack_start(ClearButtonMessageType, False, False, 0) NewModifyView.pack_start(OperationButtons, False, False, 0) MessageTypeTabs.append_page(NewModifyView) MessageTypeTabs.set_tab_label_text(NewModifyView, "New/Modify") #End of New/Modify #Start of Template TemplateBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) ExistingMessageTypebox = Gtk.Box(spacing=0) ExistingMessageTypeLabel = Gtk.Label("Existing Message Type") ExistingMessageType = Gtk.Entry() ExistingMessageTypebox.pack_start(ExistingMessageTypeLabel, False, False, 0) ExistingMessageTypebox.pack_start(ExistingMessageType, False, False, 0) TemplateBox.pack_start(ExistingMessageTypebox, False, False, 0) CycleThroughPackets = Gtk.Button(label="Cycle Through Packets") TemplateBox.pack_start(CycleThroughPackets, False, False, 0) MessageTypeTemplateBox = Gtk.Box(spacing=0) MessageTypeTemplateLabel = Gtk.Label( "Message Type \n Template Field Value \n Pair(s)") PacketAreaField = Gtk.ListStore(str) PacketAreaField.append(["No packets"]) PacketView = Gtk.TreeView(PacketAreaField) Render_Packet = Gtk.CellRendererText() PacketViewCol = Gtk.TreeViewColumn("Packets", Render_Packet, text=0) PacketView.append_column(PacketViewCol) MessageTypeTemplateBox.pack_start(MessageTypeTemplateLabel, False, False, 0) MessageTypeTemplateBox.pack_start(PacketView, False, False, 0) TemplateBox.pack_start(MessageTypeTemplateBox, False, False, 0) OperationButtonsTypeTemplate = Gtk.Box(spacing=2) SaveButtonTypeTemplate = Gtk.Button(label="Save") ClearButtonTypeTemplate = Gtk.Button(label="Clear") OperationButtonsTypeTemplate.pack_start(SaveButtonTypeTemplate, False, False, 0) OperationButtonsTypeTemplate.pack_start(ClearButtonTypeTemplate, False, False, 0) TemplateBox.pack_start(OperationButtonsTypeTemplate, False, False, 0) MessageTypeTabs.append_page(TemplateBox) MessageTypeTabs.set_tab_label_text(TemplateBox, "Template") #End of Template #Start of Equivalency EquivalencyBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) FieldEquivalencyEqualBox = Gtk.Box(spacing=0) FieldEquivalencyLabel = Gtk.Label("Field Equivalency") FieldName = Gtk.Entry() FieldOR = Gtk.Label("OR") MessageType = Gtk.Entry() FieldEqual = Gtk.Label("=") FieldEquivalencyEqualBox.pack_start(FieldEquivalencyLabel, False, False, 0) FieldEquivalencyEqualBox.pack_start(FieldName, False, False, 0) FieldEquivalencyEqualBox.pack_start(FieldOR, False, False, 0) FieldEquivalencyEqualBox.pack_start(MessageType, False, False, 0) FieldEquivalencyEqualBox.pack_start(FieldEqual, False, False, 0) EquivalencyBox.pack_start(FieldEquivalencyEqualBox, False, False, 0) SecondFieldEquivalencyEqualBox = Gtk.Box(spacing=0) FieldName = Gtk.Entry() FieldOR = Gtk.Label("OR") IndentLabel = Gtk.Label(" ") MessageType = Gtk.Entry() SecondFieldEquivalencyEqualBox.pack_start(IndentLabel, False, False, 0) SecondFieldEquivalencyEqualBox.pack_start(FieldName, False, False, 0) SecondFieldEquivalencyEqualBox.pack_start(FieldOR, False, False, 0) SecondFieldEquivalencyEqualBox.pack_start(MessageType, False, False, 0) FieldPLUS = Gtk.Label("+") SecondFieldEquivalencyEqualBox.pack_start(FieldPLUS, False, False, 0) EquivalencyBox.pack_start(SecondFieldEquivalencyEqualBox, False, False, 0) OperationButtonsEquivalency = Gtk.Box(spacing=2) SaveButtonEquivalency = Gtk.Button(label="Save") ClearButtonEquivalency = Gtk.Button(label="Clear") OperationButtonsEquivalency.pack_start(SaveButtonEquivalency, False, False, 0) OperationButtonsEquivalency.pack_start(ClearButtonEquivalency, False, False, 0) EquivalencyBox.pack_start(OperationButtonsEquivalency, False, False, 0) MessageTypeTabs.append_page(EquivalencyBox) MessageTypeTabs.set_tab_label_text(EquivalencyBox, "Equivalency") #End of Equivalency #Start of Generation GenerationBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) ExistingMessageTypeInGeneration = Gtk.Box(spacing=0) ExistingMessageTypeLabel = Gtk.Label("Existing Message Type") ExistingMessageTypeInGeneration.pack_start(ExistingMessageTypeLabel, False, False, 0) MessageTypeName = Gtk.Entry() ExistingMessageTypeInGeneration.pack_start(MessageTypeName, False, False, 0) GenerationBox.pack_start(ExistingMessageTypeInGeneration, False, False, 0) MessageTemplateFormatBox = Gtk.Box(spacing=0) MessageTemplateFormatLabel = Gtk.Label( "Message Template \n Output Format") MessageTemplateFormat = Gtk.Entry() MessageTemplateFormatBox.pack_start(MessageTemplateFormatLabel, False, False, 0) MessageTemplateFormatBox.pack_start(MessageTemplateFormat, False, False, 0) GenerationBox.pack_start(MessageTemplateFormatBox, False, False, 0) MessageTemplateNameBox = Gtk.Box(spacing=0) MessageTemplateNameLabel = Gtk.Label("Message Template \n Name") MessageTemplateName = Gtk.Entry() MessageTemplateNameBox.pack_start(MessageTemplateNameLabel, False, False, 0) MessageTemplateNameBox.pack_start(MessageTemplateName, False, False, 0) GenerationBox.pack_start(MessageTemplateNameBox, False, False, 0) ButtonsMessageType = Gtk.Box(spacing=0) GenerateButton = Gtk.Button(label="Generate") ClearMessageType = Gtk.Button(label="Clear") ButtonsMessageType.pack_start(GenerateButton, False, False, 0) ButtonsMessageType.pack_start(ClearMessageType, False, False, 0) GenerationBox.pack_start(ButtonsMessageType, False, False, 0) MessageTypeTabs.append_page(GenerationBox) MessageTypeTabs.set_tab_label_text(GenerationBox, "Generation") #End of Generation MessageTypeArea = Gtk.Label("Message Type Area") MessageTypeArea.set_text("Message Type") MessageTypeBox.pack_start(MessageTypeArea, False, False, 0) MessageTypeBox.pack_start(MessageTypeTabs, False, False, 0)
def extract_pieces( msg_lines, msg_offset, mbx, inner_mesg=False ): """Takes four parameters. The first is a list of line strings containing the headers and body of a message from a Eudora MBX file. The second is the offset of the first character in the first line in the msg_lines list within the MBX file we're processing. The third is the name of the MBX file we're reading. The fourth, inner_mesg, is a boolean controlling whether or not the pieces were are extracting are a top-level message in the MBX file. If inner_mesg is true, we will carry out our processing under the assumption that we are handling an attached message carried in an message/rfc822 segment. Returns a tuple (header, body, attachments, embeddeds, mbx) containing a Header object, a body String containing the body of the message, a list of attachment definition tuples, a list of embedded definition tuples, and the name of the MBX file we're processing.""" global toc_info, replies global target headers = Header() body = [] attachments = [] embeddeds = [] in_headers = True found_rfc822_inner_mesg = False is_html = False if not inner_mesg: headers.add( 'From ', msg_lines[0][5:].strip() ) for line in msg_lines: if in_headers: if re_initial_whitespace.match( line ): # Header "folding" (RFC 2822 3.2.3) headers.appendToLast( line ) elif len( line.strip() ) != 0: # Message header headers.add_line(line) attachment_matcher = re_x_attachment.match( line ) if attachment_matcher: files = attachment_matcher.group(1) attach_list = re.split(';\s*', files) for attachment in attach_list: attachments.append( (attachment, target) ) else: # End of message headers. # scrub the header lines we've scanned if not inner_mesg: headers.clean(toc_info, msg_offset, replies) in_headers = False content_type = headers.getValue('Content-Type:') if content_type and content_type.lower() == 'message/rfc822': found_rfc822_inner_mesg = True print "+", elif found_rfc822_inner_mesg: # We're processing a message/rfc822 message, # and so we don't want to process attachments # at this level. Instead, we want to properly # extract all body lines for later processing body.append(strip_linesep(line) + "\n") else: # We're in the body of the text and we need to # handle attachments if not is_html and re_xhtml.search( line ) or re_normal_html.search( line ): is_html = True if attachments_dirs and re_attachment.search( line ): # remove the newline that # Eudora inserts before the # 'Attachment Converted' line. if len(body) > 0 and (body[-1] == '\n' or body[-1] == '\r\n'): body.pop() #EudoraLog.log.warn("Adding attachment with contenttype = " + contenttype) attachments.append( (line, target) ) else: embedded_matcher = re_embedded.match ( line ) if embedded_matcher: filename = embedded_matcher.group(1) embeddeds.append( filename ) else: orig_line = line if scrub_xflowed: line = re.sub(re_xflowed, '', line) line = re.sub(re_xhtml, '', line) line = re.sub(re_pete_stuff, '', line) if orig_line == line or line != '': body.append(strip_linesep(line) + "\n") return ( headers, body, attachments, embeddeds, mbx, is_html )
def __init__(self): super(Withdraw, self).__init__(Header(MessageType.withdraw))
def readHeaders(filename): """Read all of the headers from a file""" fh = open(filename) data = fh.read() fh.close() #data = filename parser = getHeaderBNF() intRE = re.compile(r'^\d+$') opRE = re.compile(r'^[+\-*]|<<|>>$') refCounts = {} headerList = [] headers = {} for item in parser.parseString(data, True): #print item #print item.hdr if item.hdr not in headers: hdr = Header(item.hdr) headerList.append(hdr) headers[item.hdr] = hdr if item.fields != '': for fieldData in item.fields: (name, width) = fieldData[0:2] if width == '*': width = None else: width = int(width) hdr.addField(name, width) if len(fieldData) == 3: hdr.addExtractField(name) if item.pseudofields != '': for (name, width) in item.pseudofields: if width == '*': width = None else: width = int(width) hdr.addPseudofield(name, width) if item.next_header != '': if item.next_header.field != '': hdr.setNextHeader(str(item.next_header.field)) else: from_fields = item.next_header.mapping.from_header.asList() rangeCount = 0 widths = hdr.getFieldWidths(from_fields) hdrMap = {} for (keys, value) in item.next_header.mapping.maplist: for key in keys: if key.find('0x') == 0: key = int(key, 16) elif key.find('b') == 0: pass else: key = int(key) (mask, data) = crackKey(hdr, key, from_fields) hdrMap[key] = ((mask, data), value) # Approximate counting of the number of entries covered wildcards = 0 for i in xrange(len(widths)): fieldWidth = widths[i] fieldMask = mask[i] wildcards += sum([(~fieldMask >> shift) & 1 for shift in xrange(fieldWidth)]) rangeCount += 2 ** wildcards # Attempt to sort the header map by key keys = hdrMap.keys() keys.sort() hdrList = [] for key in keys: hdrList.append(hdrMap[key]) # Add a wildcard entry if we haven't covered all inputs if rangeCount < 2 ** sum(widths) and wantWildcard: hdrList.append((([0] * len(from_fields), [0] * len(from_fields)), None)) hdr.setNextHeader((from_fields, hdrList)) if item.next_header_def != '': if item.next_header == '' or item.next_header.field != '': raise Exception("next_header_def value specified but next_header is not specified/is not a map") from_fields = item.next_header.mapping.from_header.asList() (mask, data) = crackKey(hdr, item.next_header_def[0], from_fields) hdr.setDefNxtHdrVal((mask, data)) if item.maxvar != '': item.maxvar = str(item.maxvar) if item.maxvar not in refCounts: refCounts[item.maxvar] = RefCount(item.maxvar) hdr.setRefCount(refCounts[item.maxvar]) if item.maxval != '': if not hdr.getRefCount(): if item.hdr not in refCounts: refCounts[item.hdr] = RefCount(item.hdr) hdr.setRefCount(refCounts[item.hdr]) hdr.getRefCount().setMax(int(item.maxval[0])) if item.hdr_len != '': newExp = [] if type(item.hdr_len[0]) == str: newExp.append(item.hdr_len[0]) else: #print item.hdr_len[0] #print type(item.hdr_len[0]) #print len(item.hdr_len[0]) #print len(item.hdr_len.asList()) for exp in item.hdr_len[0]: if intRE.match(exp): exp = int(exp) newExp.append(exp) elif opRE.match(exp): newExp.append(exp) else: newExp.append(exp) hdr.setCalcLength(newExp) #hdr.setMax(int(item.maxval[0])) if item.max_len != '': hdr.setMaxLength(int(item.max_len[0])) #print hdr else: print "Error: header '%s' seen multiple times" % item.hdr sys.exit(-1) #print hdr # Merge fixed/deterministic transitions if requested if shouldMergeFixedTransitions: headerList = mergeTransitions(headerList, headers) # Work out which headers are reachable if shouldTrimNonReachable: headerList = trimNonReachable(headerList, headers) return (headerList, headers)
def mergeTransitions(headerList, headers): mergedHeaderList = [] remapHdrs = {} for hdr in headerList: origHdrName = hdr.name if hdr.nextHeader: pos = 1 while isinstance(hdr.nextHeader, str): nextHdr = headers[hdr.nextHeader] mergedHeader = Header('%s+%s' % (hdr.name, nextHdr.name)) for field in hdr.fieldList: mergedHeader.addField(field.name, field.width) for field in nextHdr.fieldList: mergedHeader.addField('%d-%s' % (pos, field.name), field.width) for field in hdr.pseudofieldList: mergedHeader.addPseudofield(field.name, field.width) for field in nextHdr.pseudofieldList: mergedHeader.addPseudofield('%d-%s' % (pos, field.name), field.width) mergedHeader.nextHeader = nextHdr.nextHeader if isinstance(mergedHeader.nextHeader, tuple): mergedHeader.nextHeader = copy.deepcopy(mergedHeader.nextHeader) from_fields = mergedHeader.nextHeader[0] for i in xrange(len(from_fields)): from_fields[i] = '%d-%s' % (pos, from_fields[i]) #print from_fields if hdr.getRefCount() and nextHdr.getRefCount(): print "Headers being merged both have a reference count. Exiting..." sys.exit(-1) elif hdr.getRefCount(): mergedHeader.setRefCount(hdr.getRefCount()) else: mergedHeader.setRefCount(nextHdr.getRefCount()) if hdr.calcLength: print "First header being merged has a calculated length. Unable to merge..." sys.exit(-1) elif nextHdr.calcLength: newExp = [hdr.length()[0], '+'] + nextHdr.calcLength for i in xrange(len(newExp)): if isinstance(newExp[i], str) and not opRE.match(newExp[i]): newExp[i] = '%d-%s' % (pos, newExp[i]) mergedHeader.setCalcLength(newExp) if hdr.maxLength: print "First header being merged has a max length. Unable to merge..." sys.exit(-1) elif nextHdr.maxLength: mergedHeader.setMaxLength(hdr.length()[0] + nextHdr.maxLength) remapHdrs[origHdrName] = mergedHeader.name hdr = mergedHeader headers[hdr.name] = hdr pos += 1 mergedHeaderList.append(hdr) # Update references to the new headers for hdr in mergedHeaderList: if hdr.nextHeader: if isinstance(hdr.nextHeader, tuple): hdrList = hdr.nextHeader[1] for i in xrange(len(hdrList)): nxtHdrName = hdrList[i][1] if nxtHdrName in remapHdrs: hdrList[i] = (hdrList[i][0], remapHdrs[nxtHdrName]) return mergedHeaderList