def parseReadln(self):
callW = Symbols.KeyWordNode(self.lexAnalizer.getLex())
self.Require(['readln'])
oplex = self.lexAnalizer.getLex()
self.Require(['('])
toinput = []
while oplex.lex == ',' or oplex.lex == '(':
toinput.append(self.parseExpression())
oplex = self.lexAnalizer.getLex()
self.Require([')'])
return Symbols.ReadlnNode(callW, toinput)
def parsePocedure(self):
self.Require(['procedure'])
self.stackTable.append(OrderedDict())
params = self.formalParameter("procedure")
self.Require([";"])
body = self.parseStmt()
self.Require([";"])
self.stackTable.pop()
resultLexref = Symbols.Symfunc(params[0].lex, Symbols.SymVoid(""),
params[1])
self.stackTable[-1][params[0].lex] = resultLexref
return Symbols.ProcedureNode(resultLexref, body)
def parseIf(self):
self.Require(['if'])
expression = self.parseExpression()
if expression.lexref.typeref.name != "boolean":
self.errorshow(f'Условие должно быть типа boolean')
self.Require(['then'])
body = self.parseStmt()
if self.lexAnalizer.getLex() == 'else':
self.lexAnalizer.nextLex()
elsebody = self.parseStmt()
else:
elsebody = Symbols.NullNode()
return Symbols.IfNode(expression, body, elsebody)
def __init__(self, source_text):
self.scanner = Scanner(
source_text) # initialize the scanner with the source_text
self.scanner.file_read()
self.symbols = Symbols() # initialise the Jack standard symbol table
self.token_list = []
self.endmark = "\0"
def parseFor(self):
self.Require(['for'])
self.stackTable.append(OrderedDict())
condit1 = self.parseStmt()
try:
if condit1.lexref.lexref.typeref.name != "integer":
self.errorshow(f'Ожидался тип integer')
except:
if condit1.stmts[0].vartype != "integer":
self.errorshow(f'Ожидался тип integer')
ProgVarBlockNode
toW = self.lexAnalizer.getLex()
self.Require(['to', 'downto'])
condit2 = self.parseExpression()
try:
if condit2.lexref.typeref.name != "integer":
self.errorshow(f'Ожидался тип integer')
except:
if condit2.stmts[0].vartype.name != "integer":
self.errorshow(f'Ожидался тип integer')
ProgVarBlockNode
self.Require(['do'])
body = self.parseStmt()
self.stackTable.pop()
return Symbols.ForNode(condit1, condit2, body, toW)
def generate():
frameObjects = [] #for holding the frame objects
symbol_objects = Symbols.generateSymbols()
id = 0
for frame in frames: #for all of the frames
lastData = None
newData = []
save_id = None
for symbol in symbol_objects:
if symbol.value == id:
save_id = symbol
break
for data in frame: #for the data in each frame
if lastData!=None:
if lastData.name == data:
lastData.symbolLength += 1
else:
newData.append(lastData)
lastData = Block(name=data,symbolLength=1)
else:
lastData = Block(name=data,symbolLength=1)
newData.append(lastData)
frameObjects.append(SymbolFrame(identifier=save_id,blocks=newData))
id += 1
return frameObjects
def parseVar(self):
self.curlex = self.lexAnalizer.getLex()
varnames = []
if self.curlex.type == 'Delimiter':
return (Symbols.NullNode())
self.RequireType(["Identifier"])
if self.curlex.lex not in self.stackTable[-1]:
self.stackTable[-1][self.curlex.lex] = ''
else:
self.errorshow(
f'Переменная {str(self.curlex.lex)} объявлена повторно')
oplex = self.lexAnalizer.nextLex()
varnames.append(self.curlex)
while oplex.lex == ",":
self.curlex = self.lexAnalizer.nextLex()
self.RequireType(["Identifier"])
if self.curlex.lex not in self.stackTable[-1]:
self.stackTable[-1][self.curlex.lex] = ''
else:
self.errorshow(
f'Переменная {str(self.curlex.lex)} объявлена повторно')
varibl = self.parseFactor()
varnames.append(self.curlex)
oplex = self.lexAnalizer.getLex()
oprtn = Symbols.VarAssignNode(self.lexAnalizer.getLex())
self.Require([":", ":="])
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex == ";":
self.errorshow(
f'Встречено {str(self.curlex.lex)}, ожидалось выражение')
if (self.curlex.type == "Identifier"
or self.curlex.lex == "array") and oprtn.name == ':':
vartype = self.perseInitType(
) # возращать надо SymType или SymArray
oprtn = Symbols.NullNode()
self.curlex = self.lexAnalizer.nextLex()
exprnode = Symbols.NullNode()
elif oprtn.name == ':=':
exprnode = self.parseExpression()
vartype = exprnode.lexref.typeref.name
varnodeslist = []
for i in varnames:
self.stackTable[-1][i.lex] = vartype
varnodeslist.append(
Symbols.ProgVarNode(i, self.stackTable[-1][i.lex], exprnode,
oprtn))
return varnodeslist
def parseRepeatUntil(self):
self.Require(['repeat'])
body = self.parseStmt()
self.Require(['until'])
expression = self.parseExpression()
if expression.lexref.typeref.name != "boolean":
self.errorshow(f'Условие должно быть типа boolean')
return Symbols.repeatUntilNode(expression, body)
def parseWhile(self):
self.Require(['while'])
expression = self.parseExpression()
if expression.lexref.typeref.name != "boolean":
self.errorshow(f'Условие должно быть типа boolean')
self.Require(['do'])
body = self.parseStmt()
return Symbols.WhileNode(expression, body)
def __init__(self):
print("Initialize TOS Object")
self.message = {}
self.TOS = self.loadtos("TOS_2_MILAN-2019-10-25.log")
self.sym = Symbols.Symbols("Milan.csv").getsymbols()
print(self.TOS.__len__())
print(self.sym.__len__())
self.getlasttrades()
def parseFunction(self):
self.Require(['function'])
self.stackTable.append(OrderedDict())
params = self.formalParameter("function")
dotdot = self.lexAnalizer.getLex()
self.Require([":"])
self.RequireType(["Identifier"])
resulttype = self.lexAnalizer.getLex()
self.lexAnalizer.nextLex()
self.Require([";"])
body = self.parseStmt()
self.Require([";"])
self.stackTable.pop()
resultLexref = Symbols.Symfunc(params[0].lex,
Symbols.SymType(resulttype.lex),
params[1])
self.stackTable[-1][params[0].lex] = resultLexref
return Symbols.FuncNode(resultLexref, body)
def perseInitType(self):
typeLex = self.lexAnalizer.getLex()
diap = []
if typeLex.lex == "array":
while typeLex.lex == "array":
oplex = self.lexAnalizer.nextLex()
if oplex.lex == '[':
while oplex.lex in [",", "["]:
self.lexAnalizer.nextLex()
parsedDiap = self.parseDiap()
oplex = self.lexAnalizer.getLex()
diap.append(parsedDiap)
self.Require([']'])
self.Require(['of'])
typeLex = self.lexAnalizer.getLex()
typel = self.perseInitType()
return Symbols.SymArray(typel.name, diap)
else:
return Symbols.SymType(typeLex.lex)
def parseExpression(self):
left = self.parseTerm()
oplex = self.lexAnalizer.getLex()
leftpoints = [left]
while (oplex.type == "Operator"
or oplex.type == "Key Word") and oplex.lex in ['+', '-', 'or']:
self.curlex = self.lexAnalizer.nextLex()
right = self.parseTerm()
if oplex.lex == "or":
if right.lexref.typeref.name == "boolean" and left.lexref.typeref.name == "boolean":
newtyperef = right.lexref.typeref
else:
self.errorshow(
f'Нельзя сравнить типы {str(right.lexref.typeref.name)} и {str(left.lexref.typeref.name)}'
)
elif oplex.lex == '-':
if right.lexref.typeref.name == "string" or left.lexref.typeref.name == "string":
self.errorshow(
f'Оператор "{oplex.lex}" не применим к типу "String"')
newtyperef = right.lexref.typeref
if left.lexref.typeref.name == right.lexref.typeref.name:
symexpr = Symbols.SymExpr(oplex, left, right, newtyperef)
elif left.lexref.typeref.name in [
'integer', 'float'
] and right.lexref.typeref.name in ['integer', 'float']:
if oplex.lex in ['-', '+']:
newtyperef = Symbols.SymType("float")
else:
newtyperef = Symbols.SymType("integer")
symexpr = Symbols.SymExpr(oplex, left, right, newtyperef)
else:
self.errorshow(
f'Нельзя преобразовать тип {str(right.lexref.typeref.name)} к {str(left.lexref.typeref.name)}'
)
leftpoints = [Symbols.BinOpNode(symexpr)]
oplex = self.lexAnalizer.getLex()
if (oplex.type == "Operator"
or oplex.type == "Key Word") and oplex.lex in [
'=', '<>', '<', '>', '>=', '<=', 'in'
]:
self.curlex = self.lexAnalizer.nextLex()
right = self.parseExpression()
newtyperef = Symbols.SymType("boolean")
if left.lexref.typeref.name == right.lexref.typeref.name:
symexpr = Symbols.SymExpr(oplex, left, right, newtyperef)
else:
self.errorshow(
f'Нельзя сравнить переменные типа {str(right.lexref.typeref.name)} и {str(left.lexref.typeref.name)}'
)
leftpoints = [Symbols.BinOpNode(symexpr)]
oplex = self.lexAnalizer.getLex()
return leftpoints[0]
return leftpoints[0]
def parseStmt(self):
self.curlex = self.lexAnalizer.getLex()
stmt = ''
if self.curlex.lex == "begin":
stmt = self.parseBlock()
elif self.curlex.lex == "if":
stmt = self.parseIf()
elif self.curlex.lex == "while":
stmt = self.parseWhile()
elif self.curlex.lex == "repeat":
stmt = self.parseRepeatUntil()
elif self.curlex.lex == "var":
varW = Symbols.KeyWordNode(self.curlex)
self.lexAnalizer.nextLex()
stmt = Symbols.ProgVarBlockNode(varW, self.parseVar())
elif self.curlex.lex == "for":
stmt = self.parseFor()
elif self.curlex.lex == "break":
self.lexAnalizer.nextLex()
stmt = Symbols.KeyWordNode(self.curlex)
elif self.curlex.lex == "continue":
self.lexAnalizer.nextLex()
stmt = Symbols.KeyWordNode(self.curlex)
elif self.curlex.type == "Identifier":
stmt = self.parseAssigmOrFunc()
elif self.curlex.lex == "readln":
stmt = self.parseReadln()
elif self.curlex.lex == "writeln":
stmt = self.parseWriteln()
elif self.curlex.lex == "end" or self.curlex.lex == ";":
return Symbols.NullNode()
if stmt:
return stmt
return Symbols.NullNode()
def formalParameter(self, name):
funcname = self.lexAnalizer.getLex()
self.RequireType(["Identifier"])
self.lexAnalizer.nextLex()
self.curlex = self.lexAnalizer.getLex()
args = []
if self.curlex.lex == "(":
self.lexAnalizer.nextLex()
while self.curlex.lex == ";" or self.curlex.lex == "(":
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex == 'var':
varcallW = Symbols.KeyWordNode(self.curlex)
self.curlex = self.lexAnalizer.nextLex()
for i in self.parseVar():
args.append(Symbols.FuncProcRefArg(varcallW, i))
else:
for i in self.parseVar():
args.append(Symbols.FuncProcValArg(i))
self.curlex = self.lexAnalizer.getLex()
self.Require([")"])
else:
args.append(Symbols.NullNode())
return [funcname, args]
def parseBlock(self):
self.Require(['begin'])
self.stackTable.append(OrderedDict())
self.curlex = self.lexAnalizer.getLex()
stmnts = []
while self.curlex.lex != "end":
stmnts.append(self.parseStmt())
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex != ";":
break
self.lexAnalizer.nextLex()
self.Require(['end'])
self.stackTable.pop()
return Symbols.BlockNode(stmnts)
def parseAssigmOrFunc(self):
left = self.parseFactor() #Node
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex in [";", "end"]:
return left
elif self.curlex.lex in [":=", "+=", "-=", "*=", "/="]:
oper = self.curlex
self.lexAnalizer.nextLex()
right = self.parseExpression()
if left.lexref.typeref.name != right.lexref.typeref.name:
self.errorshow(
f'Нельзя преобразовать тип {str(right.lexref.typeref.name)} к {str(left.lexref.typeref.name)}'
)
return Symbols.AssignNode(oper, right, left)
else:
self.Require([":=", "+=", "-=", "*=", "/="])
def parseTerm(self):
left = self.parseFactor()
oplex = self.lexAnalizer.getLex()
leftpoints = [left]
while oplex.type == "Operator" or oplex.type == "Key Word":
if oplex.lex in ['*', '/', 'div', 'mod', 'and']:
self.curlex = self.lexAnalizer.nextLex()
right = self.parseFactor()
if oplex.lex == "and":
if right.lexref.typeref.name == "boolean" and left.lexref.typeref.name == "boolean":
newtyperef = right.lexref.typeref
else:
self.errorshow(
f'Нельзя сравнить типы {str(right.lexref.typeref.name)} и {str(left.lexref.typeref.name)}'
)
elif oplex.lex in ["/", 'div', 'mod']:
if right.lexref.typeref.name == "string" or left.lexref.typeref.name == "string":
self.errorshow(
f'Оператор "{oplex.lex}" не применим к типу "String"'
)
elif oplex.lex == "/":
newtyperef = Symbols.SymType("float")
else:
newtyperef = right.lexref.typeref
else:
newtyperef = right.lexref.typeref
if left.lexref.typeref.name == right.lexref.typeref.name:
symexpr = Symbols.SymExpr(oplex, left, right, newtyperef)
elif left.lexref.typeref.name in [
'integer', 'float'
] and right.lexref.typeref.name in ['integer', 'float']:
if oplex.lex in [
'/'
] or left.lexref.typeref.name == 'float' or left.lexref.typeref.name == 'float':
newtyperef = Symbols.SymType("float")
elif oplex.lex in ['div', 'mod']:
newtyperef = Symbols.SymType("integer")
else:
self.errorshow(
"Операция {oplex.lex} не применима к переменым такого типа"
)
symexpr = Symbols.SymExpr(oplex, left, right, newtyperef)
else:
self.errorshow(
f'Нельзя преобразовать тип {str(right.lexref.typeref.name)} к {str(left.lexref.typeref.name)}'
)
leftpoints = [Symbols.BinOpNode(symexpr)]
oplex = self.lexAnalizer.getLex()
else:
return leftpoints[0]
return leftpoints[0]
def MakeWorkVars(self):
"""Create working variables used in the fluid solver."""
ScalarDim, VectorDim, MatrixDim = self.FieldDims()
self.Lookup = None # Used to store a lookup table for the Spread/Interpolated Stokes Greens function
self.Symbols = Symbols.InitSymbols(self.N, self.h)
self.du = zeros(
MatrixDim,
float64) # The fluid total derivative (difference) matrix field
self.p = zeros(ScalarDim, float64) # The fluid pressure scalar field
self.c = zeros(
VectorDim,
float64) # The current timestep's explicit terms, a vector field
self.f = zeros(
VectorDim,
float64) # A vector field to potentially hold a force field
self.u_Hat = zeros(VectorDim,
complex64) # The fluid velocity transform
self.p_Hat = zeros(ScalarDim,
complex64) # The fluid pressure transform
self.c_Hat = zeros(VectorDim,
complex64) # The transform of the explicit terms
self.tempvec_complex = zeros(
VectorDim,
complex64) # A vector field for storing temporary values
self.tempscl_complex = zeros(
ScalarDim,
complex64) # A scalar field for storing temporary values
self.tempvec_real = zeros(
VectorDim, float64) # A vector field for storing temporary values
self.tempscl_real = zeros(
ScalarDim, float64) # A scalar field for storing temporary values
self.Output_u = self.u.copy(
) # The output of the fluid solver, not associated with the actual evolution of the fluid
def parseProgramm(self):
try:
stmts = []
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex == 'program':
progW = Symbols.KeyWordNode(self.curlex)
self.curlex = self.lexAnalizer.nextLex()
self.RequireType(["Identifier"])
stmts.append(Symbols.ProgramNameNode(progW, self.curlex))
self.Require([";"])
self.stackTable.append(OrderedDict())
self.curlex = self.lexAnalizer.getLex()
while self.curlex.lex in ["function", "procedure", 'var']:
if self.curlex.lex == "function":
parsed = self.parseFunction()
elif self.curlex.lex == "procedure":
parsed = self.parsePocedure()
elif self.curlex.lex == "var":
varstmts = []
progW = Symbols.KeyWordNode(self.curlex)
self.lexAnalizer.nextLex()
while self.curlex.lex not in [
"function", "procedure", 'begin'
]:
for i in self.parseVar():
varstmts.append(i)
self.Require([";"])
self.curlex = self.lexAnalizer.getLex()
parsed = Symbols.ProgVarBlockNode(progW, varstmts)
stmts.append(parsed)
self.curlex = self.lexAnalizer.getLex()
if self.curlex.lex == 'begin':
stmts.append(self.parseStmt())
self.Require(["."])
return (Symbols.ProgrammNode(stmts))
except Exception as e:
return (Symbols.ErrorNode(e))
L = obj[u'data']
end = len(L)
lastDay = consecutive(L[end - (limit + 1):end], red, min)
if lastDay:
return closeLowDiff(L[lastDay]) >= 2 * openCloseDiff(L[lastDay])
return False
def algorithm(symbols):
found = []
for sym in symbols:
if algorithm_helper(sym):
found.append(sym)
return found
if __name__ == '__main__':
print "Hello."
print "Updating symbols..."
# Update symbol list
Symbols.main()
# Update database
up = Update.Update()
print "Updating database..."
up.updateAll()
found = algorithm(up.symbols)
print "Symbols that satisfy algorithm:"
for f in found:
print f
def parseFactor(self):
self.curlex = self.lexAnalizer.getLex()
oplex = self.lexAnalizer.getLex()
if oplex.lex.lower() in ['not', '+', '-', '^', '@']:
operation = oplex
self.lexAnalizer.nextLex()
right = self.parseFactor()
self.checkNodeType([Symbols.NullNode], right)
symexpr = Symbols.SymExpr(operation, Symbols.NullNode(), right,
right.lexref.typeref)
return Symbols.UnarOpNode(symexpr)
if self.curlex.type == "Identifier":
ident = self.curlex
symb_var = ''
for i in reversed(self.stackTable):
if ident.lex in i:
self.lexAnalizer.nextLex()
symb_var = Symbols.SymVar(ident, i[ident.lex])
tableElem = i[ident.lex]
break
if not symb_var:
self.errorshow(
f'Переменная {self.curlex.lex} не была объявлена')
oplex = self.lexAnalizer.getLex()
if oplex.type == "Delimiter" and oplex.lex == "[":
mid = []
middle = []
while oplex.lex in [',', '[']:
self.lexAnalizer.nextLex()
mid.append(self.parseExpression())
oplex = self.lexAnalizer.getLex()
if len(mid) != len(tableElem.diap):
self.errorshow(
f'Неверное количество индексов, ожидалось {len(tableElem.diap)}'
)
for i in range(len(mid)):
mint = ''
try:
mint = int(mid[i].lexref.name.lex)
except:
pass
if mint:
if mint <= tableElem.diap[i][
0] or mint >= tableElem.diap[i][1]:
self.errorshow(f'Индекс за пределами диапазона')
else:
if mid[i].lexref.typeref.name != 'integer':
self.errorshow(f'Тип должен быть integer')
middle.append(mid[i].lexref.name.lex)
self.curlex = self.lexAnalizer.getLex()
self.Require(["]"])
return Symbols.toMassNode(symb_var, middle)
if oplex.type == "Delimiter" and oplex.lex == "(":
main = self.curlex
open = oplex
self.curlex = self.lexAnalizer.nextLex()
mid = []
if self.lexAnalizer.getLex().lex == ')':
self.curlex = self.lexAnalizer.nextLex()
else:
while self.curlex.lex != ")":
mid.append(self.parseExpression())
self.curlex = self.lexAnalizer.getLex()
self.Require([")", ","])
if type(tableElem) != Symbols.SymVoid:
if len(mid) != len(tableElem.args):
self.errorshow(
f'Указано неверное количество аргументов')
for i in range(len(mid)):
if mid[i].lexref.typeref.name != tableElem.args[
i].varNode.vartype.name:
if not (mid[i].lexref.typeref.name == "integer"
and tableElem.args[i].varNode.vartype.name
== 'float'):
self.errorshow(
f'Указана переменная неверного типа')
return Symbols.callNode(tableElem, mid)
return Symbols.IdentNode(symb_var)
elif self.curlex.type == "Integer":
varSym = Symbols.SymInt(self.curlex,
Symbols.SymType(self.curlex.type.lower()))
self.lexAnalizer.nextLex()
return Symbols.NumberNode(varSym)
elif self.curlex.type == "Float":
varSym = Symbols.SymFlaot(
self.curlex, Symbols.SymType(self.curlex.type.lower()))
self.lexAnalizer.nextLex()
return Symbols.NumberNode(varSym)
elif self.curlex.type == "String":
varSym = Symbols.SymStr(self.curlex,
Symbols.SymType(self.curlex.type.lower()))
self.lexAnalizer.nextLex()
return Symbols.StringConstNode(varSym)
elif self.curlex.lex == "(":
self.lexAnalizer.nextLex()
self.curlex = self.lexAnalizer.getLex()
curNode = self.parseExpression()
self.checkNodeType([Symbols.NullNode], curNode)
self.curlex = self.lexAnalizer.getLex()
self.Require([")"])
return curNode
return Symbols.NullNode()
Ndoc = 10
Kfresh = 10
# Create training set
# Each document will have exactly Npersymbol/Ndoc examples of each cluster
# For exactly Npersymbol total examples of each cluster across the corpus
Xlist = list()
Zlist = list()
doc_range = [0]
PRNG = np.random.RandomState(0)
for d in range(Ndoc):
N_doc = 0
for k, patch_name in enumerate(
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']):
N_d_k = Npersymbol // Ndoc
X_ND = S.generate_patches_for_symbol(patch_name, N_d_k)
Xlist.append(X_ND)
Zlist.append(k * np.ones(N_d_k, dtype=np.int32))
N_doc += N_d_k
doc_range.append(N_doc + doc_range[-1])
X = np.vstack(Xlist)
TrainData = bnpy.data.GroupXData(
X,
doc_range=doc_range,
TrueZ=np.hstack(Zlist))
TrainData.name = 'SimpleSymbols'
# Train simple HDP model on this set
trainedModel, RInfo = bnpy.run(
TrainData, 'HDPTopicModel', 'ZeroMeanGauss', 'memoVB',
initname='truelabels',
if str(datetime.datetime.now()) < str(self.triggertime):
print("Current Price: " + message_dict['Price'] + " Max Price = " + str(self.max) + " Min Price = " + str(self.min))
if self.symbol == self.this_symbol.__str__() and float(message_dict['Price']) > self.max:
print("Triggered through upside")
self.stopProtocol()
if self.symbol == self.this_symbol.__str__() and float(message_dict['Price']) < self.min:
print("Triggered through downside")
self.stopProtocol()
else:
pass
print("No Trigger through MIN or MAX for " + self.symbol)
self.stopProtocol()
def connectionRefused(self):
print("No one listening")
if len(sys.argv) > 1:
my_symbol = sys.argv[1].__str__()
print("\nStarting L1TOS monitor for symbol: " + my_symbol.__str__())
# Load and register symbols of intrest
Symbols.Symbols(my_symbol, "TOS", "5556", "symbol")
# Note: If the _SYMBOL_ is omitted it will default to ES\U19.CM
#pause.until(datetime(n.year, n.month, n.day, 14, 30, 0, 0))
n = datetime.datetime.now()
print(n.year.__str__()+n.month.__str__()+n.day.__str__())
reactor.listenUDP(5556, ppro_datagram(my_symbol,
datetime.datetime(n.year, n.month, n.day, 1, 0, 0, 0),
datetime.datetime(n.year, n.month, n.day, 10, 45, 0, 0)))
reactor.run()
import WhiteSpace
import Symbols
import Code
import os
import sys
# Opens the program and the output file
program = open(sys.argv[0], "r").readlines()
outFile = open(os.path.splitext(sys.argv[0]) + ".hack", "w")
# The main program
program = WhiteSpace.removeAllWhiteSpace(program)
program = Symbols.removeSymbols(program)
program = Code.translateProgram(program)
# Writes the result into the output file
for instruction in program:
outFile.write(instruction + "\n")
# Closes the output file
outFile.close()
def run(self):
"""
This is the main loop which captures and analyzes input, and displays
objects on the screen.
"""
### Initialize variables that help with capturing gestures.
# Track the mouse position
xPos, yPos = pygame.mouse.get_pos()
xPrev = xPos
yPrev = yPos
# drawing describes whether a shape is currently being captured, so that
# sepecial actions can be taken at the start and end of the gestures
drawing = 0
lastDrawTime = inf
waitToFinish = 0
# stores the coordinates of points along the drawn path
shape = []
# Main loop for capturing input
looping = True
while looping:
# Catch any major events (quit button pressed, screen resize, etc)
events = pygame.event.get()
for event in events:
# This is caused by pressing the "X" in the top right corner
if event.type == pygame.QUIT:
# Causing the while loop to stop, and quits the program.
# Alternatively, this could be caught with a "do you want
# to save" message.
looping = False
# Update the tracked mouse position
xPrev = xPos
yPrev = yPos
xPos, yPos = pygame.mouse.get_pos()
# Get mouse buttons (detect whether stylus is touching)
mouseButtons = pygame.mouse.get_pressed()
# This means the left mouse button is down, which corresponds to
# the stylus touching.
if mouseButtons[0]:
# Set flag to indicate that a shape is being recorded
drawing = 1
# Add a new point, unless the cursor hasn't moved
if len(shape
) == 0 or shape[-1][0] != xPos or shape[-1][1] != yPos:
shape.append([xPos, yPos])
# Draw the corresponding line segment on the overlay
pygame.draw.line(self.overlay, pygame.Color("black"),
(xPrev, yPrev), (xPos, yPos), int(2))
# As soon as the button is lifted, go into a waiting state for multi
# segment gestures to be classified/trained
elif drawing == 1:
# We are no longer drawing; turn off the flag
drawing = 0
waitToFinish = 1
lastDrawTime = time()
# classify/train the shape
elif waitToFinish and time() - lastDrawTime > CLASSIFYTIMETHRESHOLD:
waitToFinish = 0
if self.symbol == 'classify':
print Symbols.classify(shape)
else: # Otherwise, train
Symbols.train(shape, self.symbol)
# get a bounding rectangle for this shape
rect = Symbols.boundingBox(shape)
# erase the ink from the gesture, and reset the shape
self.overlay.fill((0, 0, 0, 0))
shape = []
# Draw our mouse pointer representation:
pygame.draw.circle(self.mouseSurface, pygame.Color("orange"),
(1, 1), 1)
# Blit (write) all of the background and overlay data to the screen
self.screen.blit(self.background, (0, 0))
self.screen.blit(self.overlay, (0, 0))
self.screen.blit(self.mouseSurface, (xPos - 1, yPos - 1))
pygame.display.flip()
pygame.quit()
def run(self):
"""
This is the main loop which captures and analyzes input, and displays
objects on the screen.
"""
### Initialize variables that help with capturing gestures.
# Track the mouse position
xPos, yPos = pygame.mouse.get_pos()
xPrev = xPos
yPrev = yPos
# drawing describes whether a shape is currently being captured, so that
# sepecial actions can be taken at the start and end of the gestures
drawing = 0
lastDrawTime = inf
waitToFinish = 0
# stores the coordinates of points along the drawn path
shape = []
# Main loop for capturing input
looping = True
while looping:
# Catch any major events (quit button pressed, screen resize, etc)
events = pygame.event.get()
for event in events:
# This is caused by pressing the "X" in the top right corner
if event.type == pygame.QUIT:
# Causing the while loop to stop, and quits the program.
# Alternatively, this could be caught with a "do you want
# to save" message.
looping = False
# If the window is resized, update the Pygame screen, the
# screen area, and cue a redraw
if event.type == pygame.VIDEORESIZE:
self.resizeScreen(event.size)
self.redraw()
# Update the tracked mouse position
xPrev = xPos
yPrev = yPos
xPos, yPos = pygame.mouse.get_pos()
# Get mouse buttons (detect whether stylus is touching)
mouseButtons = pygame.mouse.get_pressed()
# This means the left mouse button is down, which corresponds to
# the stylus touching.
if mouseButtons[0]:
# Set flag to indicate that a shape is being recorded
drawing = 1
# Add a new point, unless the cursor hasn't moved
if len(shape
) == 0 or shape[-1][0] != xPos or shape[-1][1] != yPos:
shape.append([xPos, yPos])
# Draw the corresponding line segment on the overlay
pygame.draw.line(self.overlay, pygame.Color("black"),
(xPrev, yPrev), (xPos, yPos),
int(self.radius * 2))
# As soon as the button is lifted, go into a waiting state for multi
# segment gestures to be classified.
elif drawing == 1:
# We are no longer drawing; turn off the flag
drawing = 0
waitToFinish = 1
lastDrawTime = time()
# classify the gesture, and add the object.
elif waitToFinish and time() - lastDrawTime > CLASSIFYTIMETHRESHOLD:
waitToFinish = 0
# classify the gesture into a shape
type = Symbols.classify(shape)
# get a bounding rectangle for this shape
rect = Symbols.boundingBox(shape)
# Convert screen coordinates to page coordinates!
pageRect = self.screenToPage(rect)
# Given the classified shape, we must now determine what it
# semantically means. For example, is a vertical line a barline
# or a note stem?
# This is done at the page level, which means the coordinates
# passed in to this function should be page coordinates.
self.pages[self.currentPage].addObject(type, pageRect)
# erase the ink from the gesture, and reset the shape
self.overlay.fill((0, 0, 0, 0))
shape = []
# This means the eraser is touching.
if mouseButtons[1]:
pagePoint = self.screenToPage([(xPos, yPos)])[0]
self.pages[self.currentPage].removeObjectAtPoint(pagePoint)
# Draw our mouse pointer representation:
pygame.draw.circle(self.mouseSurface, pygame.Color("orange"),
(int(self.radius), int(self.radius)),
int(self.radius))
# Blit (write) all of the background and overlay data to the screen
self.screen.blit(self.background, (0, 0))
self.screen.blit(self.overlay, (0, 0))
self.screen.blit(self.mouseSurface,
(xPos - self.zoom * self.radius,
yPos - self.zoom * self.radius))
pygame.display.flip()
pygame.quit()
import sys
import Records as rc
import Symbols as sym
import OpcodeHelper as oh
import Assembly as asm
OBJ_DIR = 'input/test.obj'
SYM_DIR = 'input/test.sym'
ASM_DIR = 'output/out.asm'
if __name__ == '__main__':
# input
hRecord, tRecords, mRecords, eRecord = rc.ReadRecords(OBJ_DIR)
symbols = sym.ReadSymbols(SYM_DIR)
ocHelper = oh.OpcodeHelper()
# Header & End
header = asm.AssemblyLine(hRecord.startingAddr, hRecord.programName,
'START', hRecord.startingAddr)
end = asm.AssemblyLine(None,
mnemonic='END',
operand=symbols[eRecord.startingAddr].label)
# for output
BASE_R = 0
LOCCTR = 0
assembly = asm.AssemblyDict(header, end)
# Symbol
locList = list(symbols.keys()) # Symbol locs
obj = collection.find_one({"company":company})
L = obj[u'data']
end = len(L)
lastDay = consecutive(L[end-(limit+1):end], red, min)
if lastDay:
return closeLowDiff(L[lastDay]) >= 2*openCloseDiff(L[lastDay])
return False
def algorithm(symbols):
found = []
for sym in symbols:
if algorithm_helper(sym):
found.append(sym)
return found
if __name__ == '__main__':
print "Hello."
print "Updating symbols..."
# Update symbol list
Symbols.main()
# Update database
up = Update.Update()
print "Updating database..."
up.updateAll()
found = algorithm(up.symbols)
print "Symbols that satisfy algorithm:"
for f in found:
print f