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 __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
