def testWriteObjectToFileAsJosn(self):
obj=[1,2,3]
testFile="testWriteTofile.txt"
Util.writeObjectToFileAsJson(obj,testFile)
res=Util.readJsonFileIntoObject(testFile)
self.assertEqual(obj,res)
def setUp(self):
'''
Chama o setup do Pai e instala a calculadora
'''
super(TestesCalculadora,self).setUp()
util = Util (self.device,self.vc)
util.instala_calculadora()
def QuotePost(self, svc, post_id, xid, include_mode, index_mode, include_data):
if (index_mode == 'junk' or index_mode == 'deleted'):
raise NoPerm("invalid index_mode!")
(post, _) = self.FindPost(post_id, xid, index_mode)
if (post is None):
raise NotFound("referred post not found")
quote = Post.Post.DoQuote(include_mode, self.GetBoardPath(post.filename), True, include_data)
orig_title = ''
if (post.title[:3] == "Re:"):
# Re: <title>
orig_title = post.title[4:]
elif (post.title[:3] == u"├ ".encode('gbk')):
orig_title = post.title[3:]
elif (post.title[:3] == u"└ ".encode('gbk')):
orig_title = post.title[3:]
else:
orig_title = post.title
if include_mode == 'C':
quote_title = orig_title
else:
quote_title = "Re: " + orig_title
quote_obj = {}
quote_obj['title'] = Util.gbkDec(quote_title)
quote_obj['content'] = Util.gbkDec(quote)
svc.writedata(json.dumps(quote_obj))
def testOK(self):
msg="AAAAA"
msgSeq=Util.encodeStringIntoByteList(msg)
self.level.inputMsg=msgSeq
resultLevel=self.levelEncryptor.encryptLevel()
decMsg=Util.decodeByteListIntoString(resultLevel.inputMsg)
self.assertEqual(msg,decMsg)
def GetInfo(self, mode = 'post'):
post = {'title': Util.gbkDec(self.title)}
post['attachflag'] = self.attachflag
post['attachment'] = self.attachment
post['owner'] = Util.gbkDec(self.owner)
try:
post['posttime'] = self.GetPostTime()
except:
post['posttime'] = 0
flags = []
if (self.IsMarked()):
flags += ['marked']
if (mode == 'post'):
post['xid'] = self.id
post['thread'] = self.groupid
post['reply_to'] = self.reid
post['size'] = self.eff_size
if (self.CannotReply()):
flags += ['noreply']
if (self.InDigest()):
flags += ['g']
if (mode == 'mail'):
if (self.IsReplied()):
flags += ['replied']
if (self.IsForwarded()):
flags += ['forwarded']
if (self.IsRead()):
post['read'] = True
else:
post['read'] = False
post['flags'] = flags
return post
def main():
cates_feature=collect_cates()
all_features=loadFeatures()
rocchioIndex=loadIndex()
totalentroy=loadEntroy()
myutil.makedirectory('cache/subkNNs/')
while True:
test_entry=(yield)
vectorOfme=createVector(test_entry,all_features)
entroy_of_me={k:v for k,v in totalentroy.items() if k in vectorOfme}
if not isEmptyVector(vectorOfme):
yield (test_entry.url,-1)
continue
first_candidate=choose_candidate_cate(vectorOfme,rocchioIndex,entroy_of_me)
if not first_candidate:
yield (test_entry.url,-1)
continue
candidate_cates,cates_tfidf=\
further_choose_candidate_cate(test_entry,cates_feature,first_candidate,all_features)
threads=[]
for cate in candidate_cates:
t=threading.Thread(target=exec_Maper,args=(cate,vectorOfme,entroy_of_me,))
threads.append(t)
for t in threads:t.start()
for t in threads:t.join()
result=Reducer.main(tfidf=cates_tfidf,cateweight=candidate_cates)
test_entry.thinkbe=result
yield (test_entry.url,test_entry.thinkbe)
def PrepareHeader(user, in_mail, board, title, anony, mode, session):
result = ""
uid = Util.gbkDec(user.name[:20])
uname = Util.gbkDec(user.userec.username[:40])
if not in_mail:
bname = board.name.decode('gbk')
bbs_name = Config.Config.GetString('BBS_FULL_NAME', 'Python BBS')
if (in_mail):
result += u'寄信人: %s (%s)\n' % (uid, uname)
else:
if (anony):
pid = (binascii.crc32(session.GetID()) % 0xffffffff) % (200000 - 1000) + 1000
result += u'发信人: %s (%s%d), 信区: %s\n' % (bname, Config.Config.GetString('NAME_ANONYMOUS', 'Anonymous'), pid, bname)
else:
result += u'发信人: %s (%s), 信区: %s\n' % (uid, uname, bname)
result += u'标 题: %s\n' % (title)
if (in_mail):
result += u'发信站: %s (%24.24s)\n' % (bbs_name, time.ctime())
result += u'来 源: %s \n' % session._fromip
elif (mode != 2):
result += u'发信站: %s (%24.24s), 站内\n' % (bbs_name, time.ctime())
else:
result += u'发信站: %s (%24.24s), 转信\n' % (bbs_name, time.ctime())
result += '\n'
return result
def __transmit(self, args):
"""Thread method to transmit an apdu;"""
if not self.__checkContext(): return
if not self.__checkCardInfo(): return
cmd = args[0]
t0AutoGetResponse = args[1]
handlerArgs = args[2]
transtime = 0
try:
commandValue = Util.s2vs(cmd)
self.__handler.handleAPDUCommand("".join("%02X " %(ord(vb)) for vb in commandValue), handlerArgs)
timeStart = timeit.default_timer()
rsp = gp.sendApdu(self.__context, self.__cardInfo, None, Util.s2vs(cmd))
timeStop = timeit.default_timer()
transtime = timeStop - timeStart
self.__handler.handleAPDUResponse("".join("%02X " %(ord(vb)) for vb in rsp), transtime, handlerArgs)
if t0AutoGetResponse and (rsp[0] == '\x61') and (len(handlerArgs) == 0):
cmd = '\x00\xC0\x00\x00' + rsp[1]
self.__handler.handleAPDUCommand("".join("%02X " %(ord(vb)) for vb in cmd))
timeStart = timeit.default_timer()
rsp = gp.sendApdu(self.__context, self.__cardInfo, None, cmd)
timeStop = timeit.default_timer()
transtime = timeStop - timeStart
self.__handler.handleAPDUResponse("".join("%02X " %(ord(vb)) for vb in rsp), transtime)
except Exception, e:
self.__handler.handleAPDUResponse('', transtime, handlerArgs)
self.__handler.handleException(e)
def force_learn(self, text):
## some checks
assert (self.click_matrix.shape[0] == self.click_matrix.shape[1]), \
"Something wrong with the dimentions of the click matrix!"
assert (self.click_matrix.shape[0] == len(self.known_urls)), \
"Something wrong with the number of known urls!"
assert (len(self.spend_time) == len(self.known_urls)), \
"Time/url mismatch: {}-{}".format(len(self.spend_time),
len(self.known_urls))
info = Util.parse_log_line(text)
if info != None:
if Guesser.use_derived_urls:
all_urls = [info.url]
all_urls.extend(Util.get_derived_urls(info.url))
all_urls2 = [info.url2]
all_urls2.extend(Util.get_derived_urls(info.url2))
for idx, url in enumerate(reversed(all_urls)):
for idx2, url2 in enumerate(reversed(all_urls2)):
info.url = url
info.url2 = url2
self.force_learn_from_info(info, idx + idx2)
else:
self.force_learn_from_info(info)
def main():
algo = sys.argv[1]
trainfile = sys.argv[2]
weightfile = sys.argv[3]
testfilename = sys.argv[4]
isCr = sys.argv[5]
if(algo == 'LR'):
D = 2**20
lr = LR(D)
lr.train(trainfile)
lr.saveWeight(weightfile)
#lr.readWeight(weightfile)
if(isCr == 'cr'):
Util.cross_validation(testfilename, lr.get_features, lr.get_prediction)
elif(algo == 'LR_CONV'):
D = 2**30
lr = LR(D)
lr.train_conjecture(trainfile)
lr.saveWeight(weightfile)
if(isCr == 'cr'):
Util.cross_validation(testfilename, lr.get_features_conjectured, lr.get_prediction)
else:
Util.test(testfilename, 'LR_CONV_TEST', lr.get_features_conjectured, lr.get_prediction)
elif(algo == 'PROBIT'):
D = 2**20
pr = PROBIT_R(D, 0.3, 0.05, 0.01)
pr.train(trainfile)
pr.saveWeight(weightfile)
if(isCr == 'cr'):
Util.cross_validation(testfilename, pr.get_features, pr.predict)
else:
Util.test(testfilename, 'PROBIT_TEST',pr.get_features, pr.predict)
def setFromBytes(self, midiData):
eventData = Util.stripLeadingVariableLength(midiData[2:])
# True for major, False for minor
self.majorKey = (Util.intFromBytes(eventData[1:2]) == 0)
# true for sharps, false for flats
self.sharpKey = (Util.intFromBytes(eventData[0:1], True) > 0)
self.numberOfAccidentals = abs(Util.intFromBytes(eventData[0:1], True))
def genIndex(desPath, fileInfo, param):
defaultIndexTemplate = Util.readAll(param["defaultIndexPath"])
category= GenIndex.getCateGory("/site", fileInfo, param)
indexContent = re.sub(r"\{[\s]*\{[\s]*category[\s]*\}[\s]*\}", category, defaultIndexTemplate)
#pureCategory = GenIndex.getCateGory("/site", fileInfo, param)
#indexContent = re.sub(r"\{[\s]*\{[\s]*pureCategory[\s]*\}[\s]*\}", pureCategory, defaultIndexTemplate)
Util.fwrite(desPath, indexContent)
def checkDeprecatorOptions(options, parser):
MarketplaceUtil.checkEndpointOption(options)
if not P12Certificate.checkOptions(options):
parser.error('Missing credentials. Please provide %s' % P12Certificate.optionString)
if not options.email:
parser.error('Missing email address. Please provide email of endorser')
def setFromBytes(self, midiData):
eventData = Util.stripLeadingVariableLength(midiData[2:])
# default is 4
self.numerator = Util.intFromBytes(eventData[0:1])
# default is 4 (or encoded 2 since 2^2 is 4)
self.denominator = math.pow(2, Util.intFromBytes(eventData[1:2]))
# default is 1 (or 24 encoded since 24/24 = 1)
self.beatsPerTick = Util.intFromBytes(eventData[2:3]) / 24
# default is 8
self.thirtySecondNotesPerBeat = Util.intFromBytes(eventData[3:])
def _mutualAuthButtonOnButtonClick( self, event ):
scp = -1
scpi = -1
if self._scpinfoMethod.GetSelection() == 1:
scp = self._scpChoice.GetSelection() + 1
scpi = int(self._scpiTextCtrl.GetValue(), 0x10)
key1 = Util.s2vs(self._key1TextCtrl.GetValue())
key2 = Util.s2vs(self._key2TextCtrl.GetValue())
key3 = Util.s2vs(self._key3TextCtrl.GetValue())
self.__controller.doMutualAuth(scp, scpi, key1, key2, key3)
def initV6Db(self):
db = self.db
self.osLen = Util.byte2int(db[6])
# print('offset: %s' % self.osLen)
self.ipLen = Util.byte2int(db[7])
self.dLen = self.osLen + self.ipLen
# print('iplen: %s' % self.ipLen)
self.size = Util.byte2int(db[8:0x10], False)
# print('total: %s' % self.size)
self.dbAddr = Util.byte2int(db[0x10:0x18], False)
def executar(dirBase, listN, listL, comConsultaRetirada, comQuebraLinha, comComentariosELiterais, comTermos1Ocorrencia):
resultadosExperimentos = []
for n in listN:
preparador = Preparador(config.dirBasePreparada, config.extensaoPadrao, n, comQuebraLinha, comComentariosELiterais)
# Configura o preparador da consulta (o baseline e comComentariosELiterais = False)
preparadorConsulta = Preparador(config.dirBasePreparada, config.extensaoPadrao, n, comQuebraLinha, False)
# Antes de iniciar a preparacao dos arquivos, esvazia o diretorio onde os n-grams ficarao
Util.esvaziarDiretorio(config.dirBasePreparada)
# Recupera e salva as caracteristicas relevantes dos arquivos para posterior indexacao
arquivosParaPreparar = glob.glob(os.path.join(dirBase, "*" + config.extensaoAceita))
preparador.prepararArquivos(arquivosParaPreparar)
for L in listL:
indexador = Indexador(preparador, L, comTermos1Ocorrencia)
# Configura o indexador da consulta (o baseline e comTermos1Ocorrencia = True)
indexadorConsulta = Indexador(preparadorConsulta, L, True)
buscador = Buscador(preparadorConsulta, indexadorConsulta)
experimento = Experimento(indexador, buscador, comConsultaRetirada)
if (comComentariosELiterais):
print "COM comentarios e literais"
else: print "SEM comentarios e literais"
if (comTermos1Ocorrencia):
print "COM termos com 1 ocorrencia"
else: print "SEM termos com 1 ocorrencia"
print "Para n = ", n
print "Para L = ", L
print "=> RESULTADO <="
# Indexa os arquivos do diretorio de acordo com as regras do algoritmo spi
arquivosParaIndexar = glob.glob(os.path.join(config.dirBasePreparada, "*" + config.extensaoPadrao))
# dictPerfilAutores = {"autor", "vocabularioAutorIndexado"}
dictPerfilAutores = indexador.indexarArquivos(arquivosParaIndexar)
# Antes de salvar os indides para validacao, esvazia o diretorio onde eles ficarao
Util.esvaziarDiretorio(config.dirIndicesValidacao)
indexador.salvarValidacaoIndices(config.dirIndicesValidacao, dictPerfilAutores, config.extensaoPadrao)
# Compara 1 arquivo-consulta com todos da base, depois outro com todos e assim por diante...
# Reindexando o perfil do autor desse arquivo antes da comparacao
# A fim de encontrar o autor do arquivo
arquivosConsulta = glob.glob(os.path.join(dirBase, "*" + config.extensaoAceita))
# resultadoExperimento = numExperimentos + numAcertos + acuracia
resultadoExperimento = experimento.testar(arquivosConsulta, dictPerfilAutores, config.dirBasePreparada, config.extensaoPadrao)
resultadosExperimentos.append(ExecucaoExperimento.guardarResultado(n, L, comComentariosELiterais, comTermos1Ocorrencia, resultadoExperimento))
print "[FIM DO n]"
print "******************************************************************************\n"
print "[FIM DO TESTE]"
print "******************************************************************************\n"
return "".join(resultadosExperimentos)
def __atualizaPosicao(self, passaro):
velocidade_atual = sum(passaro.velocidade)/TSPConstants.N_DIMENSION;
#A velocidade atual vai definir o numero de mudan�as que v�o precisar ser feitas
for j in range(int(velocidade_atual)):
# 50/50 chance.
if random.random() > 0.5:
Util.dispor_aleatoriamente(passaro)
# Push it closer to it's best neighbor.
Util.copiar_da_particula(passaro.g, passaro.posicao)
def initV4Db(self):
db = self.db
self.dbAddr = Util.byte2int(db[0:4], False)
# print('dbaddr: %s' % self.dbAddr)
endAddr = Util.byte2int(db[4:8], False)
# print('endAddr: %s' % endAddr)
self.osLen = 3
# print('offset: %s' % self.osLen)
self.ipLen = 4
# print('iplen: %s' % self.ipLen)
self.dLen = self.osLen + self.ipLen
self.size = (endAddr - self.dbAddr) / self.dLen
def openWebpageForPosition(self, modelIndex):
"""
@param QModelIndex modelIndex
"""
exchange = self.positionsModel.getExchange(modelIndex)
ticker = self.positionsModel.getTicker(modelIndex)
exchangeTicker = "%s:%s" % (exchange, ticker)
googleUrl = self.prop.getGoogleUrl()
url = "http://%s/finance?q=%s" % (googleUrl, exchangeTicker)
qDebug("Opening URL: %s" % (url))
Util.openUrl(url)
def quote_mail(self, folder_name, mode, index):
folder = self.get_folder(folder_name)
if folder is None:
raise NotFound("no such mailbox: %s" % folder_name)
entry = folder.get_entry(index - 1)
path = self.path_of(entry.filename)
quote_content = Util.gbkDec(Post.Post.DoQuote(mode, path, False))
if entry.title[:3] == "Re:":
quote_title = Util.gbkDec(entry.title)
else:
quote_title = "Re: " + Util.gbkDec(entry.title)
return (quote_title, quote_content)
def testar(self, arquivosConsulta, dictPerfilAutor, dirBasePreparada, extensaoPadrao):
# Informacoes do experimento
numExperimentos = 0
numAcertos = 0
autorAnterior = ""
for arquivoConsulta in arquivosConsulta:
autorVerdadeiro = Util.getNomeAutor(arquivoConsulta)
# Se (comConsultaRetirada = True), retira o arquivo-consulta da base para nao constar na comparacao
if (self.comConsultaRetirada):
if (autorAnterior != "" and autorAnterior != autorVerdadeiro):
# Reindexa todos os codigos do autor anterior
arquivosParaIndexar = glob.glob(os.path.join(dirBasePreparada, autorAnterior + "*" + extensaoPadrao))
vocabularioAutorAnteriorIndexado = self.indexador.indexarArquivos(arquivosParaIndexar)
vocabularioAutorAnteriorIndexado = dict(vocabularioAutorAnteriorIndexado[autorAnterior])
dictPerfilAutor[autorAnterior] = vocabularioAutorAnteriorIndexado
# Reindexa os codigo deste autor (sem o arquivoParaRetirar)
arquivosParaIndexar = glob.glob(os.path.join(dirBasePreparada, autorVerdadeiro + "*" + extensaoPadrao))
arquivoParaRetirar = Util.getNomeArquivo(arquivoConsulta)
arquivoParaRetirar = dirBasePreparada[0:len(dirBasePreparada)-1] + "\\" + arquivoParaRetirar + extensaoPadrao
vocabularioAutorIndexado = self.indexador.indexarArquivosSemArquivoEspecifico(arquivosParaIndexar, arquivoParaRetirar)
vocabularioAutorIndexado = dict(vocabularioAutorIndexado[autorVerdadeiro])
dictPerfilAutor[autorVerdadeiro] = vocabularioAutorIndexado
# Verifica a presenca de termos com 1 ocorrencia na base indexada
#for autor, ngramsIndexado in dictPerfilAutor.iteritems():
# for ngrams, frequencia in ngramsIndexado.iteritems():
# if (frequencia == 1):
# print "igual a 1"
# print autor
# print ngrams, " : " , frequencia
# Faz a consulta/comparacao e sugere quem e o autor do arquivo
autorScap = self.buscador.compararComTodosDaBase(arquivoConsulta, dictPerfilAutor)
autorAnterior = autorVerdadeiro
numExperimentos += 1
if (autorVerdadeiro == autorScap):
numAcertos += 1
acuracia = numAcertos/float(numExperimentos)
#self.imprimirResultado(arquivoConsulta, autorVerdadeiro, autorScap, numExperimentos, numAcertos, acuracia)
# if para imprimir somente o ultimo resultado, ou seja, a acuracia total do algoritmo
if (numExperimentos == len(arquivosConsulta)):
self.imprimirResultado(numExperimentos, numAcertos, acuracia)
return self.guardarResultado(numExperimentos, numAcertos, acuracia)
def solve (self, n): """ Solves the euler problem 026 """ util = Util() denominator = 2 maxCycle = 0 d = 2 bestD = 0 while d<n: cycle = util.periodSize(d) if cycle > maxCycle: maxCycle=cycle bestD=d d+=1 return bestD
def processPayload(self, payload):
stripped = Util.removeNewLine(payload)
jsonRegexResult = self.JSON_RE.search(stripped)
jsonRegexMatched = jsonRegexResult.group(0)
jsonRegexMatched = Util.evalJson(jsonRegexMatched)
jsonObjects = Util.loadsJsonString(jsonRegexMatched, "utf-8")
for jsonObj in jsonObjects:
exchange = jsonObj['e']
symbol = jsonObj['t']
self.storeQuote(exchange, symbol, jsonObj)
self.emit(SIGNAL("quotesCached"))
def getLoc(self, index):
self.checkIndex(index)
addr = self.dbAddr + index * self.dLen
ip = Util.byte2int(self.db[addr : addr + self.ipLen], False)
lAddr = Util.byte2int(self.db[addr + self.ipLen : addr + self.dLen], False)
# print('ip_addr: %d ip: %d lAddr:%d' % (addr, ip, lAddr))
if self.type == 4:
lAddr += 4
loc = self.readLoc(lAddr, True)
if self.type == 4:
loc = loc.decode("cp936").encode("gbk")
if self.type == 6:
loc = loc.decode("utf-8").encode("gbk")
return loc
def main():
print("******************************************")
print("*** FileSet Report ***")
print("******************************************")
print()
fileORdir = Util.getCommandLineArgument(1)
level = Util.getCommandLineArgument(2)
files = FileSet(fileORdir, "hack")
files.report()
print()
print("******************************************")
print("*** Processing Report ***")
print("******************************************")
print()
while files.hasMoreFiles():
inputFileSpec = files.nextFile()
print("Processing: %s" % inputFileSpec)
outputFileSpec = os.path.splitext(inputFileSpec)[0]+".dis"
inputFile = open(inputFileSpec, "rU")
outputFile = open(outputFileSpec, "w")
parser = Parser(inputFile)
while parser.hasMoreInstructions():
parser.advance()
if (parser.instructionType() == "A_TYPE"):
value = parser.value()
inst = Code.a_type(value)
if (parser.instructionType() == "C_TYPE"):
dest = parser.dest()
comp = parser.comp()
jump = parser.jump()
destMnemonic = Code.destMnemonic(dest)
compMnemonic = Code.compMnemonic(comp)
jumpMnemonic = Code.jumpMnemonic(jump)
inst = Code.c_type(destMnemonic, compMnemonic, jumpMnemonic)
if (parser.instructionType() == "INVALID"):
inst = Code.invalid_type()
inst += Util.repeatedChar(" ", 20-len(inst))
inst += "// %05i:" % parser.address()
inst += " [%s]" % parser.hexInstruction()
inst += " %s\n" % parser.parsedInstruction()
outputFile.write(inst)
outputFile.close()
inputFile.close()
print()
print("Processing of file(s) complete.")
def ReadPostText(path, start = 0, count = 0):
try:
postf = open(path, 'rb')
except IOError:
raise ServerError("fail to load post")
try:
ret = ''
if (start == 0 and count == 0):
while (True):
data = postf.read(512)
i = data.find('\0')
if (i != -1):
ret = ret + data[:i]
break
else:
ret = ret + data
if (len(data) < 512):
break
return (Util.gbkDec(ret), len(ret), True)
else:
current = 0
has_end = False
while True:
data = postf.read(512)
nullpos = data.find('\0')
if nullpos != -1:
# this makes data shorter
# so len(data) must <512
data = data[:nullpos]
assert len(data) < 512
final = len(data) < 512
newline = data.find('\n')
while newline != -1:
if count != 0 and current >= start + count:
break
if current >= start:
ret += data[:newline + 1]
data = data[newline + 1:]
newline = data.find('\n')
current += 1
if count != 0 and current >= start + count:
break
if current >= start:
ret += data
if final:
has_end = True
break
return (Util.gbkDec(ret), 0, has_end)
finally:
postf.close()
def getMostCommonHex(self, position):
#Position should be either 22, 23, 24
equalsGroupNum = [] #Dev_Data_3 sometimes equals the group number.
elements = []
for _, address in enumerate(self.aldb):
elements.append(address[position])
equalsGroupNum.append(address[position] == address[17] and position == Device.DEV_DATA_3)
if position == Device.DEV_END and address[position] != 0x00:
return 0xbad
#The below method returns true if true is the most common value
if Util.most_common(equalsGroupNum):
return 0xbad
return Util.most_common(elements)
def new_entry(self, owner, title, content):
if not self.create():
raise ServerError("fail to create mail dir for user '%s'" % self.name)
entry = PostEntry.PostEntry()
entry.owner = owner
entry.title = Util.gbkEnc(title)
# create file
entry.filename = Post.Post.GetPostFilename(self.path_of(""), False)
encoded_content = Util.gbkEnc(content)
entry.eff_size = len(encoded_content)
path = self.path_of(entry.filename)
with open(path, "wb") as f:
f.write(encoded_content)
return entry
def application(self,request):
# Dispatcher is dictionary {<method_name>: callable}
bmcUtil = Util()
bmcListOfMethods = {}
bmcListOfMethod = bmcUtil.readLocalAppVariableFile("BMC_JSONRPCCALL_METHODS")
bmcListOfMethod = bmcUtil.removeDoubleQuotas(bmcListOfMethod)
bmcListOfMethods = bmcListOfMethod.split(",")
for methodName in bmcListOfMethods:
dispatcher[methodName] = lambda methodName: methodName
#dispatcher["event"] = lambda a: a
response = JSONRPCResponseManager.handle(
request.data, dispatcher)
print response.json
bmcUtil.writeRPCCallDataTOFile(response.json)
return Response(response.json, mimetype='application/json')
def get_diagonal(self, case_name):
mat_build, normalized_mat_build = \
Util.read_array(case_name, self.m_lambda, self.N, "input")
return np.diag(mat_build)
def WriteHeader(fp, user, in_mail, board, title, anony, mode, session):
header = Post.PrepareHeader(user, in_mail, board, title, anony, mode,
session)
fp.write(Util.gbkEnc(header))
def GetOriginLine(self):
for line in self.GetBody().split('\n'):
if Post.IsOriginLine(Util.gbkEnc(line)):
return line
return ""
# This tries to find an algorithm that finds the longest suffix of any given word with length N while using only M # comparisons import time from cmath import sqrt from multiprocessing import Pool from time import gmtime, strftime from anytree import Node from bitarray._bitarray import bitarray from Util import Util n = 5 m = 4 DEBUG = True MY_UTIL = Util(n, m) NR_WORKERS = 1 ALL_COMPS = MY_UTIL.comp_pairs NR_COMPS = len(ALL_COMPS) WD_TIME = 0 COPY_TIME = 0 NR_CALLS = 0 NR_COMP_EVALS = 0 # define how many comparisons are allowed that do not extend the underlying dependency graph max_m = int((4 * n - 5) / 3) max_non_endogeneous = max_m - n + 1 # Generates an initial decision tree for M comparisons with given root value # Anytree helps navigating, manipulating and printing the tree (i.e. finding children, parents etc.)
def gen_gateway_ips(self):
for subnet_ip in self.subnets:
gw_ip = Util.get_gateway_ip(subnet_ip)
self.gateway_ips[subnet_ip] = gw_ip
return
def calculate_file_size_score(self, number_of_terms, max, min):
return 1 / (1 + math.e**
(-1 * Util.normalization(number_of_terms, max, min)))
sys.path.append(os.getcwd() + "/runtime")
from SessionManagerProvider import SessionManagerProvider
from ConfigurationProvider import ConfigurationProvider
from ApplicationManagerProvider import ApplicationManagerProvider
from Util import Util
config_provider = ConfigurationProvider()
appmgr_provider = ApplicationManagerProvider()
appmgr = appmgr_provider.get_app_mgr(config_provider.get_config('DM_APP_MGR'))
sessionmgr_provider = SessionManagerProvider()
sessionmgr = sessionmgr_provider.get_session_mgr(
config_provider.get_config('DM_SESSION_MGR'))
util = Util()
status = False
action = os.environ['PAS_ACTION_DM_CUSTOM_ACTION_TYPE']
if action == "START_APP":
status=appmgr.start_app(config_provider.get_config('PAS_EXECUTABLE'), config_provider.get_config('PAS_ACTION_DM_APP_ARGS'), \
config_provider.get_config('PAS_ACTION_DM_APP_ENVS'),config_provider.get_config('PAS_ACTION_DM_APP_WDIR'), util.getValue("display"))
elif action == "GET_OTP":
status = sessionmgr.gen_password()
elif action == "WAIT_ON_SESSION":
sessionmgr.set_waitflag()
elif action == "STOP_SESSION":
status = sessionmgr.stop_session()
elif action == "GET_SESSION":
status = sessionmgr.get_session()
elif action == "SET_SESSION_EXPIRY":
def solve(self, filterVector=[0, 0, 0, 0, 0], nbThread=1):
if nbThread > 1:
return self.solveMultiThread(nbThread, filterVector)
tStart = time.time()
opt = False
while not opt:
self.nbIteration += 1
opt = True
t = time.time()
self.objRelax = self.master.solve(self.verbose)
if self.nbIteration == param.nbIterationMaxFoCG or (
time.time() - tStart) > (self.timeLimit * 0.80):
break
duals, constraintOnePath, constraintLinkCapacity, constraintNodeCapacity, constraintVnfUsed = self.master.getDuals(
)
self.timeMaster += time.time() - t
t = time.time()
for sub in self.subs:
listPath = []
for step in range(self.nbStepsReconf, 0, -1):
sub.updateObjective(duals,
constraintOnePath[sub.slice.id][step],
constraintLinkCapacity,
constraintNodeCapacity,
constraintVnfUsed, step)
reduceCost, path = sub.solve(step)
if reduceCost < 0:
listPath.append(path)
self.nbColumn += 1
opt = False
#print(path.alloc)
for path in listPath:
self.master.addPath(path, sub.slice)
self.timeSubs += time.time() - t
if self.stableStop:
stableCycle = param.stableCycle
self.oldObj.append(self.objRelax)
if len(self.oldObj) > stableCycle:
oldObj = self.oldObj.popleft()
if (oldObj - self.objRelax) / float(oldObj) * 100 < 0.1:
opt = True
t = time.time()
if (filterVector[0]):
self.master.reduceNumberOfPath1()
if (self.verbose):
print("Filtre reduceNumberOfPath1")
elif (filterVector[1]):
self.master.reduceNumberOfPath2()
if (self.verbose):
print("Filtre reduceNumberOfPath2")
elif (filterVector[2]):
self.master.reduceNumberOfPath3()
if (self.verbose):
print("Filtre reduceNumberOfPath3")
elif (filterVector[3]):
self.master.reduceNumberOfPath4()
if (self.verbose):
print("Filtre reduceNumberOfPath4")
elif (filterVector[4]):
self.master.reduceNumberOfPath5()
if (self.verbose):
print("Filtre reduceNumberOfPath5")
limit = max(self.timeLimit * 0.2, time.time() - tStart)
limit = max(limit, 5)
self.master.solveOpt(limit)
self.timeOptimal = time.time() - t
self.timeTotal += time.time() - tStart
res_Reconf, NumPathUsed_Reconf, pathUsed_Reconf = self.master.getResult(
checkSolution=self.checkSolution)
self.obj, self.bwUsed, self.objVnf = Util.objective(
self.nodes, self.listSlice, res_Reconf, self.beta)
self.master.terminate()
for sub in self.subs:
sub.terminate()
return res_Reconf, pathUsed_Reconf
import socket
from Util import Util
util = Util()
import time
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv.bind(('127.0.0.1',8082))
serv.listen(1)
trusted_initializer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
trusted_initializer.connect(util.server_address_builder())
desired_input = input('Please input an integer: \n')
desired_operation = input('Secure Two-party Computation for addition or multiplication (a/m): \n')
y = int(desired_input)
prime = util.closest_large_prime_finder(y)
y_a, y_b = util.two_party_secret_share(y,prime)
alice_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
alice_client.connect(('127.0.0.1',8081))
alice_client.send(str('y_a:' + str(y_a)).encode())
if desired_operation == 'a':
trusted_initializer.send('y_prime:-1'.encode())
initialized_share = str(trusted_initializer.recv(1024).decode())
x_b = -1
alice_sub_addition = -1
alice_addition = -1
while True:
alice_conn, addr = serv.accept()
data = str(alice_conn.recv(4096).decode())
def punishDelta(self, delta, avg):
if avg < .1:
return
diff = avg - .1
gradient = Util.sigmoid_prime(diff)
self.delta = self.delta + (delta * gradient * -.1)
from operate.base import BaseClass
import codecs
from Util import Util
from redis_operate import RecisClusterOperate
from redis_operate.RedisStruct import RedisHash
from DispatchControl import PaperJournalReptileDispatch, PaperReptileDispatch
from PaperReptile import PaperReptile
import time
import re
import Util
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
year = Util.get_last_year()
def sql_get_paper_data():
print "开始从数据库读入相关信息"
sqlConn = base_operate.connection_sql("techpooldata")
papertable = BaseClass(sqlConn, "paper")
columns = ["PAPER_ID", "url"]
fp_w = codecs.open(r"result\paper%s" % year, "wb", encoding="utf-8")
for infos in papertable.select_term(
*columns, where="year = '%s' and url is not NULL" % year):
uuid, url = infos
fp_w.write("%s\t%s\n" % (uuid, url))
fp_w.close()
print "读取信息成功"
def setup_periodic_tasks(sender, **kwargs):
Util.bootstrap()
'asize3', 'asize2', 'asize1',
'bsize1', 'bsize2', 'bsize3']] # 20160622, MK
px_mid_this_day_this_stk['ask1'] = px_mid_this_day_this_stk['ask1']/Util.px_multiplier
px_mid_this_day_this_stk['bid1'] = px_mid_this_day_this_stk['bid1']/Util.px_multiplier
px_mid_this_day_this_stk['mid_prc'] = (px_mid_this_day_this_stk['bid1'] + px_mid_this_day_this_stk['ask1'])/2
transaction_data_set_index = self.transaction_data_from_csv_filter_time
volume_buy = transaction_data_set_index[transaction_data_set_index['bs_flag'] == 66][['trade_volume']] # 66 is ascii code for 'B'
volume_sell = transaction_data_set_index[transaction_data_set_index['bs_flag'] == 83][['trade_volume']] # 83 is ascii code for 'S
self.px_mid_this_day_this_stk = px_mid_this_day_this_stk.loc[px_mid_this_day_this_stk['mid_prc'] > 0]
self.volume_buy = volume_buy
self.volume_sell = volume_sell
# px_mid_this_day_this_stk = (self.data_from_csv_filter_time['bid1'] +
# self.data_from_csv_filter_time['ask1'])/2/10000
# self.px_mid_this_day_this_stk = px_mid_this_day_this_stk[px_mid_this_day_this_stk>0]
except Exception as e:
print('data_error, {}, {}, {}'.format(self.date_str, self.stk_str, e))
self.px_mid_this_day_this_stk = pd.DataFrame({"mid_prc": [], "ask1": [], "bid1": [],
"asize3": [], "asize2": [], "asize1": [],
"bsize1": [], "bsize2": [], "bsize3": [],
'volume_buy': [], 'volume_sell': []})
self.volume_buy = pd.Series()
self.volume_sell = pd.Series()
if __name__ == "__main__":
test_data = DataFramework("20160401", "20160401", Util.get_path_tickdata())
test_tickdata = TickdataOneDayOneStk("20160401", "000005", test_data)
from Tree import BuiltIn
from Tree import Environment
from Tree import Closure
from Special import Special
from Util import Util
if __name__ == "__main__":
# Initialization file with Scheme definitions of built-in functions
ini_file = "ini.scm"
prompt = "> "
# Create scanner that reads from standard input
scanner = Scanner(sys.stdin)
util = Util()
Cons.setUtil(util)
BuiltIn.setUtil(util)
Closure.setUtil(util)
Special.setUtil(util)
if (len(sys.argv) > 2 or (len(sys.argv) == 2 and sys.argv[1] != "-d")):
sys.stderr.write("Usage: python3 SPP.py [-d]\n")
sys.stderr.flush()
sys.exit(2)
# If command line option -d is provided, debug the scanner.
if len(sys.argv) == 2 and sys.argv[1] == "-d":
tok = scanner.getNextToken()
while tok != None:
tt = tok.getType()
def cpu_put(self):
mass_list_temp = Util.copy_mass_list(self.board.mass_list)
x, y = self.players[self.turn].put(mass_list_temp)
self.update(x, y)
def solveMultiThread(self, nbThreadSub, filterVector=[0, 0, 0, 0, 0]):
def doYourJobYouUselessThread(listSub, duals, constraintOnePath,
constraintLinkCapacity,
constraintNodeCapacity,
constraintVnfUsed, nbStepsReconf,
dictPath):
for sub in listSub:
listPath = []
for step in range(nbStepsReconf, 0, -1):
sub.updateObjective(duals,
constraintOnePath[sub.slice.id][step],
constraintLinkCapacity,
constraintNodeCapacity,
constraintVnfUsed, step)
reduceCost, path = sub.solve(step)
if reduceCost < 0:
listPath.append(path)
dictPath[sub.slice.id] = listPath
tStart = time.time()
#On creer les lists pour le partage dessubs parmis les threads
listSubThread = [[] for i in range(nbThreadSub)]
listSubTmp = copy(self.subs)
shuffle(listSubTmp)
nbSubByHtread = len(listSubTmp) // nbThreadSub
dictSubThread = Manager().dict()
it = 0
#On remplit les listes
for i in range(nbSubByHtread):
for subThread in listSubThread:
subThread.append(listSubTmp[it])
dictSubThread[listSubTmp[it].slice.id] = []
it += 1
for i in range(len(listSubTmp) % len(listSubThread)):
listSubThread[i].append(listSubTmp[it])
dictSubThread[listSubTmp[it].slice.id] = []
it += 1
opt = False
while not opt:
self.nbIteration += 1
opt = True
t = time.time()
self.objRelax = self.master.solve(self.verbose)
if self.nbIteration == 150 or (time.time() -
tStart) > (self.timeLimit * 0.80):
break
duals, constraintOnePath, constraintLinkCapacity, constraintNodeCapacity, constraintVnfUsed = self.master.getDuals(
)
self.timeMaster += time.time() - t
t = time.time()
#We launch all the threads
listProcess = []
for listSub in listSubThread:
p = Process(target=doYourJobYouUselessThread,
args=(listSub, duals, constraintOnePath,
constraintLinkCapacity,
constraintNodeCapacity, constraintVnfUsed,
self.nbStepsReconf, dictSubThread))
p.start()
listProcess.append(p)
#We wait for the ends of the threads
for p in listProcess:
p.join()
#We add the new paths
for sub in self.subs:
listPath = dictSubThread[sub.slice.id]
if len(listPath) > 0:
opt = False
self.nbColumn += len(listPath)
for path in listPath:
self.master.addPath(path, sub.slice)
self.timeSubs += time.time() - t
for p in listProcess:
p.terminate()
if self.stableStop:
stableCycle = param.stableCycle
self.oldObj.append(self.objRelax)
if len(self.oldObj) > stableCycle:
oldObj = self.oldObj.popleft()
if (oldObj - self.objRelax) / float(oldObj) * 100 < 0.1:
opt = True
#print("Reconfiguration GC subs Ok")
t = time.time()
if (filterVector[0]):
self.master.reduceNumberOfPath1()
if (self.verbose):
print("Filtre reduceNumberOfPath1")
elif (filterVector[1]):
self.master.reduceNumberOfPath2()
if (self.verbose):
print("Filtre reduceNumberOfPath2")
elif (filterVector[2]):
self.master.reduceNumberOfPath3()
if (self.verbose):
print("Filtre reduceNumberOfPath3")
elif (filterVector[3]):
self.master.reduceNumberOfPath4()
if (self.verbose):
print("Filtre reduceNumberOfPath4")
elif (filterVector[4]):
self.master.reduceNumberOfPath5()
if (self.verbose):
print("Filtre reduceNumberOfPath5")
else:
if (self.verbose):
print("Pas de Filtre")
#limit = max(self.timeLimit - time.time()-tStart + 5, 5)
limit = min(self.timeLimit * 0.2, (time.time() - tStart) * 0.25)
limit = max(limit, 5)
self.master.solveOpt(limit)
self.timeOptimal = time.time() - t
self.timeTotal += time.time() - tStart
res_Reconf, NumPathUsed_Reconf, pathUsed_Reconf = self.master.getResult(
checkSolution=self.checkSolution)
self.bwUsed, self.objVnf = Util.objective(self.topology.listAllDC,
self.listSlice,
self.functions, res_Reconf)
self.obj = self.bwUsed + (self.objVnf * self.beta)
self.master.terminate()
for sub in self.subs:
sub.terminate()
return res_Reconf, pathUsed_Reconf
def DoQuote(include_mode, quote_file, for_post, include_data=None):
""" Quote modes:
R: full text
C: full text, add comment
N: empty
S: short quote, limited lines
A: full quote
"""
if (quote_file == ""):
return ""
if (include_mode == 'N'):
return "\n"
quser = ""
result = ""
with open(quote_file, "rb") as inf:
buf = Post.SkipAttachFgets(inf)
match_user = re.match('[^:]*: *(.*\))[^)]*$', buf)
if (match_user):
quser = match_user.group(1)
if include_mode != 'R' and include_mode != 'C':
if (for_post):
result = result + (u"\n【 在 %s 的大作中提到: 】\n".encode('gbk') %
quser)
else:
result = result + (u"\n【 在 %s 的来信中提到: 】\n".encode('gbk') %
quser)
if (include_mode == 'A'):
while (True):
buf = Post.SkipAttachFgets(inf)
if (buf == ""):
break
result += ": %s" % buf
else:
# skip header
while (True):
buf = Post.SkipAttachFgets(inf)
if (buf == "" or buf[0] == '\n'):
break
if include_mode == 'R':
while (True):
buf = Post.SkipAttachFgets(inf)
if (buf == ""):
break
if (not Post.IsOriginLine(buf)):
result += buf
elif include_mode == 'C':
while True:
buf = Post.SkipAttachFgets(inf)
if buf == "" or buf == "--\n":
break
if not Post.IsOriginLine(buf):
result += buf
else:
line_count = 0
while (True):
buf = Post.SkipAttachFgets(inf)
if (buf == "" or buf == "--\n"):
break
if (len(buf) > 250):
buf = Util.CutLine(buf, 250) + "\n"
if (not Post.IsGarbageLine(buf)):
result += ": %s" % buf
if (include_mode == 'S'):
line_count += 1
if (line_count >= Config.QUOTED_LINES):
result += ": ..................."
break
if include_mode == 'C' and include_data is not None:
result += Util.gbkEnc(include_data['comment'])
result += "\n"
return result
inputDataPath='../originalData/'
outputDataPath='../cleaneddata/'
# 删除没用的列
'静态方法可以没有self参数，可以访问类变量，不能访问实例变量'
@staticmethod
def deleteUsenessColumns(data,delColumnList):
print '删除属性个数：',len(delColumnList)
return data.drop(delColumnList,axis=1)
'删除原始数据的周围info等额外数据'
def delExtraData(self,data,outputPath):
data=data.iloc[7:,10:] #除去最前面的9列和前5行
data.index=[i for i in range(len(data))] # 从0开始重新索引
print '总的属性个数：',len(data.columns)
data=DataClean.deleteUsenessColumns(data,DataClean.usernessColumns) #删除没有的列
print '剩余属性个数：',len(data.columns)
data.to_excel(outputPath)
if __name__=='__main__':
print '在此模块中运行'
cleanData=DataClean()
fileList=Util.readAllFileNameFromDir(cleanData.inputDataPath) #先调用读取文件夹下面所有的文件名
# print len(fileList)
for i in range(len(fileList)):
if fileList[i]=='.DS_Store':
continue;
data=Util.readDataFromExcel(cleanData.inputDataPath+fileList[i])
cleanData.delExtraData(data,cleanData.outputDataPath+fileList[i][:3]+'.xls') #循环处理
def setFromBytes(self, midiData):
eventData = Util.stripLeadingVariableLength(midiData[2:])
self.copyrightNotice = eventData.decode()
def isConnectionEstablished(self):
bmcUtil = Util()
bmcPluginName = bmcUtil.readPluginName()
bmcIsRpcORStdout = bmcUtil.readLocalAppVariableFile(
"BMC_TYPE_OF_OUTPUT")
bmcIsRpcORStdout = bmcUtil.removeDoubleQuotas(bmcIsRpcORStdout)
if bmcIsRpcORStdout == "stdout":
bmcfileData = bmcUtil.readVagrantStdoutFile(bmcPluginName)
bmcMsg = bmcUtil.readLocalAppVariableFile("BMC_ERROR_MSG")
bmcMsg = bmcUtil.removeDoubleQuotas(bmcMsg)
bmcIsConnectionEstablished = bmcUtil.serchSubstring(
bmcfileData, bmcMsg)
else:
bmcfileData = bmcUtil.readVagrantRPCLogFile(bmcPluginName)
bmcMsg = bmcUtil.readLocalAppVariableFile("BMC_ERROR_MSG")
bmcMsg = bmcUtil.removeDoubleQuotas(bmcMsg)
bmcIsConnectionEstablished = bmcUtil.serchSubstring(
bmcfileData, bmcMsg)
return bmcIsConnectionEstablished
from statistics import median
from anytree import Node, LevelOrderIter
import matplotlib.pyplot as plt
from Util import Util
n = 8
m = 8
MY_UTIL = Util(n, m)
root = MY_UTIL.load_working_tree([0, 3])
for node in LevelOrderIter(root):
new_children = []
for i, child in enumerate(node.children):
if child.is_leaf:
new_children.append(
Node(child.name, obj=child.obj, parent=node, nr_words=0))
else:
new_children.append(child)
node.children = tuple(new_children)
for words in MY_UTIL.generate_all_words():
for w in words:
current_node = root
while not current_node.is_leaf:
i1, i2 = current_node.obj
c1 = w[i1]
c2 = w[i2]
if c1 < c2:
def rewardDelta(self, delta, avg):
if avg > .9:
return
diff = .9 - avg
gradient = Util.sigmoid_prime(diff)
self.delta = self.delta + (delta * gradient * .1)
class Processor:
dirs = Util()
def __init__(self,usingCuda=False,verbose=False):
self.imgDim = 96
networkModel = os.path.join(Processor.dirs.openfaceModelDir,'nn4.small2.v1.t7')
self.net = openface.TorchNeuralNet(networkModel, self.imgDim, cuda=usingCuda) # model used for formatting
self.dlibFacePredictor = os.path.join(Processor.dirs.dlibModelDir, "shape_predictor_68_face_landmarks.dat")
self.align = openface.AlignDlib(self.dlibFacePredictor)
self.verbose = verbose
openface.helper.mkdirP(Processor.dirs.alignedImgsDir)
def processImage(self,imgObject,isTrain=False):
"""
Get aligned reps and their bounding boxes
"""
reps = []
print("=== {} ===".format(imgObject.path))
# Preprocess image
if isTrain:
outDir = os.path.join(Processor.dirs.alignedImgsDir, imgObject.cls)
openface.helper.mkdirP(outDir)
outputPrefix = os.path.join(outDir, imgObject.name)
imgName = outputPrefix + ".png"
# TODO check if file is already found. if so, then nothing needs to be done.
# Otherwise, continue.
if os.path.isfile(imgName):
if self.verbose:
print(" + Already found, skipping.")
return []
imgPath = imgObject.path
rgbImg = imgObject.getRGB()
if rgbImg is None:
raise Exception("Unable to load image: {}".format(imgPath))
bbs = self.align.getAllFaceBoundingBoxes(rgbImg)
if bbs is None:
raise Exception("Unable to find a face: {}".format(imgPath))
for bb in bbs:
start = time.time()
alignedFace = self.align.align(self.imgDim, rgbImg, bb,
landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE)
if alignedFace is None:
raise Exception("Unable to align image: {}".format(imgPath))
if self.verbose:
print(" + Face alignment took {} seconds.".format(time.time() - start))
# Stored aligned face into directory if we are training this mofo
if isTrain:
cv.imwrite(imgName,alignedFace)
# Pass these reps through NN to get vec representation
start = time.time()
rep = self.net.forward(alignedFace)
if self.verbose:
print(" + OpenFace forward pass took {} seconds.".format(time.time() - start))
print("Representation:")
# print(rep)
print("-----\n")
reps.append((rep,bb))
# Return the bb's and their vec representations. Rep[0]=bounding box Rep[1]=vector
return reps
def rect_to_css(self,rect):
"""
Convert a dlib 'rect' object to a tuple(top,right,bottom,left)
"""
return rect.top(), rect.right(), rect.bottom(), rect.left()
def getTextScale(fontFace, thickness, height):
view_x = 0
# TODO
def markFace(self,frame,faces):
"""
Adds a bounding box with a label to an image.
Params:
frame - cv numpy array?
faces - list of (string, float, rectangle)
"""
# Draw rectangle around faces
for face in faces:
name = face[0]
confidence = face[1]
(top,right,bottom,left) = self.rect_to_css(face[2]) # or is it (top,right,bottom,left?
text = "{0} ({1:.2f}%)".format(name,confidence*100)
# Draw a box around the face
cv.rectangle(frame, (left, top), (right,bottom), (0, 255, 0), 2)
# Draw a label with a name below the face
# cv.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), 2)
font = cv.FONT_HERSHEY_DUPLEX
cv.putText(frame,text, (left + 6, bottom - 6), font, 0.5, (128, 128, 0), 1)
return frame
def build_kernel(self, case_name):
self.build_kernel_mat(case_name)
return Util.normalized_array(self.mat_build)
def setFromBytes(self, midiData):
eventData = Util.stripLeadingVariableLength(midiData[2:])
self.instrumentName = eventData.decode()
from selenium import webdriver
import time
from Util import Util
from MenuUtil import MenuUtil
commonUtil=Util();
menuUtil=MenuUtil();
driver = webdriver.Chrome()
#登陆
url='http://localhost:3001/#/onlineFeedbackShopList'
driver.get(url)
driver.set_window_size(1410,900)
commonUtil.checkIsLoading(driver, time)
hashRunList = [];
for i in range(0,menuUtil.getCycleCount()):
menuUtil.openSubMenuNode(driver);
commonUtil.checkIsLoading(driver, time)
menuUtil.runSubMenuNode(driver, hashRunList);
def setFromBytes(self, midiData):
eventData = Util.stripLeadingVariableLength(midiData[2:])
self.cuePoint = eventData.decode()
def add_entry(self, entry):
return (Util.AppendRecord(self.path, entry.pack()) == 0)
class DividendsBuyBacks(object):
util = Util()
def __init__(self):
pass
# questions:
# how does cash buy back figure into retained earnings?
def calcDividendBuyBacks(self, incomeStmtData, balanceSheetData,
cashFlowData):
print "--------------- Dividend Buybacks --------------------------------------------"
# Calculate Retained earnings per share
retainedearningspershare = balanceSheetData.loc[:,
"retainedearnings"] / incomeStmtData.loc[:,
"weightedavedilutedsharesos"]
retainedearningspershare.name = "retainedearningspershare"
# Calculate earnings per share
# calculatedearningspershare = incomeStmtData.loc[:, "netincometocommon"] / incomeStmtData.loc[:,
# "weightedavedilutedsharesos"]
# calculatedearningspershare.name = "calculated diluted earnings per share"
# print calculatedearningspershare, incomeStmtData.loc[:, 'dilutedeps']
retainedData = pd.concat([
incomeStmtData.loc[:, 'netincometocommon'],
balanceSheetData.loc[:, 'retainedearnings'],
incomeStmtData.loc[:, 'dilutedeps'],
incomeStmtData.loc[:, 'weightedavedilutedsharesos'],
retainedearningspershare,
incomeStmtData.loc[:, "cashdividendspershare"],
cashFlowData.loc[:, "paymentofdividends"],
cashFlowData.loc[:, 'repurchaseofcommonequity']
],
axis=1)
retainedData = self.util.dropNaInAllColumns(retainedData)
print "\nReturn as percent of income"
print "Year Div StockBuyBack Total %"
for index, row in retainedData.iterrows():
print "{} {:5,.2f}% {:5,.2f}% {:5,.2f}% ".format(
index, ((abs(row['paymentofdividends']) * 100) /
row['netincometocommon']),
(abs(row['repurchaseofcommonequity'] * 100)) /
row['netincometocommon'],
(abs(row['paymentofdividends'] * 100)) /
row['netincometocommon'] +
(abs(row['repurchaseofcommonequity'] * 100)) /
row['netincometocommon'])
print "\nYear Dividend per share"
for index, row in retainedData.iterrows():
print "{} ${:0,.2f}".format(index,
row['cashdividendspershare'])
print "Over {} years:".format(
len(retainedData.loc[:, 'cashdividendspershare'].index))
print "Total Dividend payout of ${:0,.2f}".format(
retainedData['cashdividendspershare'].sum())
payoutRatio = retainedData.loc[:, 'cashdividendspershare'].sum(
) / retainedData.loc[:, 'dilutedeps'].sum()
print "Total Dividend payout as percent of earnings is {:0,.2f}%".format(
payoutRatio * 100)
print "Total Retained ratio is {:0,.2f}%".format(
float(1.0 - payoutRatio) * 100)
print "------------------------------------------------------------------------------\n"
def compute(self, obs):
self.personalPrediction = Util.sigmoid(
np.dot(self.w + self.delta, obs.transpose()))
self.prediction = self.personalPrediction
return self.prediction
