def validate_math_symbols(opcode: str, symb1: Symbol, symb2: Symbol):
""" Pomocna funkce pro kontroly matematickych operandu.
Parameters
----------
opcode: str
Aktualni operacni kod. Bude pouzit pouze v pripade, ze bude vypsana chyba.
symb1, symb2: Symbol
Vstupni symboly k proverovani.
"""
types = [DataTypes.FLOAT, DataTypes.INT]
if not symb1.one_of_types(types):
exit_app(
exitCodes.INVALID_DATA_TYPE,
'Incomatible type in second operand at instruction {}.'.format(
opcode) + ' Expected: int or float', True)
if not symb2.one_of_types(types):
exit_app(
exitCodes.INVALID_DATA_TYPE,
'Incomatible type in first operand at instruction {}.'.format(
opcode) + ' Expected: int or float', True)
if not symb1.equal_type(symb2.data_type) and\
not symb1.is_nil() and not symb2.is_nil():
exit_app(exitCodes.INVALID_DATA_TYPE,
'Data types at instruction {} must be same.'.format(opcode),
True)
def validate_comparable_symbols(opcode: str, symb1: Symbol, symb2: Symbol,
allowedTypes: List[DataTypes]):
""" Pomocna funkce pro kontrolu porovnavacich operandu.
Parameters
----------
opcode: str
Aktualni operacni kod. Bude pouzit pouze v pripade, ze bude vypsana chyba.
symb1, symb2: Symbol
Vstupni symboly k proverovani.
"""
if not symb1.one_of_types(allowedTypes):
exit_app(
exitCodes.INVALID_DATA_TYPE,
'Incomatible type in second operand at instruction {}.'.format(
opcode), True)
if not symb2.one_of_types(allowedTypes):
exit_app(
exitCodes.INVALID_DATA_TYPE,
'Incomatible type in second operand at instruction {}.'.format(
opcode), True)
if not symb1.equal_type(symb2.data_type) and not symb1.is_nil() and\
not symb2.is_nil():
exit_app(exitCodes.INVALID_DATA_TYPE, 'Data types must be same.', True)
def execute(self, program: Program):
symb = program.get_symb('TYPE', self.args[1], False)
if symb is None:
program.var_set('TYPE', self.args[0], Symbol(DataTypes.STRING, ''))
else:
program.var_set('TYPE', self.args[0],
Symbol(DataTypes.STRING, symb.data_type.value))
def insert_symbol(exchange_name, symbol_name):
"""
目前只考虑部分交易对
"""
t_symbol = Symbol().collection
symbol = {
"exchange": exchange_name,
"name": symbol_name,
"research_usable": True,
"trade_usable": True
}
t_symbol.replace_one(filter=symbol, replacement=symbol, upsert=True)
def execute(self, program: Program):
variable = program.var_get('SETCHAR', self.args[0])
index = program.get_symb('SETCHAR', self.args[1])
toModify = program.get_symb('SETCHAR', self.args[2])
if variable is None:
exit_app(exitCodes.UNDEFINED_VALUE, 'SETCHAR\nUndefined variable.',
True)
if not index.is_int() or not variable.is_string() or\
not toModify.is_string():
exit_app(exitCodes.INVALID_DATA_TYPE,
'SETCHAR\nExpected: string variable, int, string', True)
if len(toModify.value) == 0 or index.value >= len(variable.value):
exit_app(exitCodes.INVALID_STRING_OPERATION,
'SETCHAR\nZero length of to modify characters.', True)
try:
result = "{}{}{}".format(variable.value[:index.value],
toModify.value[0],
variable.value[index.value + 1:])
program.var_set('SETCHAR', self.args[0],
Symbol(DataTypes.STRING, result))
except IndexError:
exit_app(exitCodes.INVALID_STRING_OPERATION,
'SETCHAR\nIndex is out of range.', True)
def add_symbol(plantlist_id, plant_id):
"""Creates symbol and add connection to a plant on plantlist page"""
print("REQUEST", request.json)
plantlists_plants = PlantLists_Plants.query.filter(
PlantLists_Plants.plantlist_id == plantlist_id,
PlantLists_Plants.plant_id == plant_id,
).first()
# Check to see if they symbol has been created before, and use it as opposed to creating a duplicate
symbol = Symbol.query.filter(
Symbol.symbol == request.json["symbol"]).first()
# If the symbol hasn't been created by anyone yet, create a new one
if not symbol:
try:
symbol = Symbol.add(symbol=request.json["symbol"])
db.session.commit()
except IntegrityError as e:
flash("Failed to create symbol.", "danger")
return redirect(
url_for("show_plantlist", plantlist_id=plantlist_id))
# Update which symbol is connected to plant on plantlist
plantlists_plants.edit(plantlist_id=plantlist_id,
plant_id=plant_id,
symbol_id=symbol.id)
# return symbol for display on frontend
return jsonify(symbol.symbol)
def symbols(self, pathname, version):
total_commit = 0
_files = [(pathname, version)]
while _files:
pathname, version = _files.pop(0)
if self.files.isdir(pathname, version):
dirs, files = self.files.getdir(pathname, version)
for i in dirs + files:
_files.append((os.path.join(pathname, i), version))
else:
o = self.pathname_to_obj[pathname]
if o.filetype in self.parses and not o.has_indexed():
tags = ctags(self.files.toreal(pathname, version), o.filetype)
for tag in tags:
sym, line, lang_type, ext = tag
lang_typeid = langcache.get_typeid(o.filetype, self.parses[o.filetype].typemap[lang_type])
symbol_obj = Symbol(self.treeid, sym, self.symid)
defin = Definitions(self.symid, o.fileid, line, lang_typeid)
db.session.add(symbol_obj)
db.session.add(defin)
self.symid += 1
o.set_indexed()
db.session.add(o)
total_commit += 1
if total_commit % 1000 == 0:
print total_commit
db.session.commit()
db.session.commit()
print
print
symbolcache.load(self.treeid)
def read_file(zip_file):
file_names = ignore(
[zip_info.filename for zip_info in zip_file.infolist()])
for file_name in file_names:
# TODO: 添加对file_name split结果的校验
file_name_split = file_name.split("_")
# 是否存储
symbol_name = file_name_split[1].lower()
focus_symbol = Symbol.is_focus(symbol_name)
if not focus_symbol:
continue
print(file_name)
# exchange 转换
exchange_name = file_name_split[0].lower()
exchange_name = EXCHANGE_NAME.get(exchange_name, exchange_name)
# 插入symbol
insert_symbol(exchange_name, symbol_name)
with zip_file.open(file_name) as f:
# 跳过第一行. 第一行为联系信息
df = pandas.read_csv(f, skiprows=1)
# trade 数据
if "TICK" in file_name:
handle_trade(exchange_name, symbol_name, df)
# order book 数据
elif "ORDER" in file_name:
handle_order_book(exchange_name, symbol_name, df)
def execute(self, program: Program):
symbols = program.pop_stack(2)
validate_comparable_symbols(self.opcode, symbols[1], symbols[0],
self.allowedTypes)
result = Symbol(DataTypes.BOOL, self.compare(symbols[1], symbols[0]))
program.data_stack.append(result)
def __init__(self, config, tree):
self.files = Files(tree)
self.filestype = {}
self.tree = tree
self.commit_cnt = 0
self.MAX_COMMIT = 1000
self.config = config
self.symid = Symbol.next_symid()
def execute(self, program: Program):
string = program.get_symb('STRLEN', self.args[1])
if not string.is_string():
exit_app(exitCodes.INVALID_DATA_TYPE, 'STRLEN\nExpected string',
True)
string_length = Symbol(DataTypes.INT, len(string.value))
program.var_set('STRLEN', self.args[0], string_length)
def execute(self, program: Program):
symb1 = program.get_symb(self.opcode, self.args[1])
symb2 = program.get_symb(self.opcode, self.args[2])
validate_comparable_symbols(self.opcode, symb1, symb2,
self.allowedTypes)
result = Symbol(DataTypes.BOOL, self.compare(symb1, symb2))
program.var_set(self.opcode, self.args[0], result)
def execute(self, program: Program):
symb = program.pop_stack(1)[0]
if not symb.is_float():
exit_app(
exitCodes.INVALID_DATA_TYPE, 'INT2CHAR\nInvalid data type' +
' Expected FLOAT in second parameter.')
symbol = Symbol(DataTypes.INT, int(symb.value))
program.data_stack.append(symbol)
def execute(self, program: Program):
symb = program.get_symb('FLOAT2INT', self.args[1])
if not symb.is_float():
exit_app(
exitCodes.INVALID_DATA_TYPE, 'INT2CHAR\nInvalid data type' +
' Expected FLOAT in second parameter.')
symbol = Symbol(DataTypes.INT, int(symb.value))
program.var_set('FLOAT2INT', self.args[0], symbol)
def execute(self, program: Program):
symb = program.pop_stack(1)[0]
if not symb.is_bool():
exit_app(
exitCodes.INVALID_DATA_TYPE,
'NOT\nInvalid data type. Expected: bool. Have: ({})'.format(
symb.data_type.value), True)
result = Symbol(DataTypes.BOOL, not symb.value)
program.data_stack.append(result)
def execute(self, program: Program):
symb = program.get_symb('NOT', self.args[1])
if not symb.is_bool():
exit_app(
exitCodes.INVALID_DATA_TYPE,
'NOT\nInvalid data type. Expected: bool. Have: ({})'.format(
symb.data_type.value), True)
result = Symbol(DataTypes.BOOL, not symb.value)
program.var_set('NOT', self.args[0], result)
def example():
dataset = Dataset()
meta, data = dataset.at(0, xy=False)
symbol = Symbol(meta, data)
symbols = (
symbol['count'].apply(np.log)
==
symbol[['age', 'smoke']].interact(lambda x: x[0]*x[1], name='age_smoke') +
symbol['age'] + symbol['smoke'] + symbol['drug'] + symbol['partners'] + symbol['cesd']
)
return symbols
def sync_symbols(self):
response = requests.get('{}/api/symbols/'.format(
self.SERVER_URL), timeout=7,
headers={'Authorization': 'Token {}'.format(self.settings.exa_token.strip())})
if response.status_code == 200:
for item in response.json():
symbol = Symbol.query.filter_by(name=item).first()
if not symbol:
db_session.add(Symbol(name=item))
db_session.commit()
else:
self.log(message='Sync symbols failed: {}'.format(response.content))
def execute(self, program: Program):
string = program.get_symb('GETCHAR', self.args[1])
index = program.get_symb('GETCHAR', self.args[2])
if not string.is_string() or not index.is_int():
exit_app(exitCodes.INVALID_DATA_TYPE,
'GETCHAR\nExpected string and int', True)
try:
result = Symbol(DataTypes.STRING, string.value[index.value])
program.var_set('GETCHAR', self.args[0], result)
except IndexError:
exit_app(exitCodes.INVALID_STRING_OPERATION,
'GETCHAR\nIndex out of range.', True)
def execute(self, program: Program):
symb1 = program.get_symb('CONCAT', self.args[1])
if not symb1.is_string():
exit_app(exitCodes.INVALID_DATA_TYPE,
'CONCAT\nInvalid type at second operand.', True)
symb2 = program.get_symb('CONCAT', self.args[2])
if not symb2.is_string():
exit_app(exitCodes.INVALID_DATA_TYPE,
'CONCAT\nInvalid type at third operand.', True)
result = Symbol(DataTypes.STRING, symb1.value + symb2.value)
program.var_set('CONCAT', self.args[0], result)
def example_1_2_6():
# 数据预处理
meta, data= Dataset().at(4, xy=False)
mapper = collections.Counter(data['id'])
for id in mapper:
index = data['id'] == id
data.loc[index, 'weight'] = data.loc[index, 'weight'].mean()
# 线性模型的符号表示
symbol = Symbol(meta, data)
symbols = (
symbol['weight']
==
symbol['gender'] + symbol['dose'] +
symbol['id'].apply(lambda xs: [mapper[x] for x in xs], 'size')
)
return symbols
def execute(self, program: Program):
var = self.args[0]
symb = program.get_symb('INT2CHAR', self.args[1])
if not symb.is_int():
exit_app(exitCodes.INVALID_DATA_TYPE,
'INT2CHARS\nInvalid data type. Expected: int', True)
try:
char = chr(symb.value)
program.var_set('INT2CHAR', var, Symbol(DataTypes.STRING, char))
except Exception:
exit_app(
exitCodes.INVALID_STRING_OPERATION,
'INT2CHAR\nInvalid int to char conversion value. {}'.format(
symb.value))
def execute(self, program: Program):
symb = program.pop_stack(1)[0]
if not symb.is_int():
exit_app(exitCodes.INVALID_DATA_TYPE,
'INT2CHARS\nInvalid data type. Expected: int', True)
try:
char = chr(symb.value)
except Exception:
exit_app(
exitCodes.INVALID_STRING_OPERATION,
'INT2CHARS\nInvalid int to char conversion value. {}'.format(
symb.value))
else:
program.data_stack.append(Symbol(DataTypes.STRING, char))
def execute(self, program: Program):
try:
if program.input == stdin:
line = input().rstrip()
else:
line = program.input.readline().rstrip()
except Exception:
line = None
arg_type = self.args[1]
if line is None:
program.var_set('READ', self.args[0], Symbol(DataTypes.NIL, None))
elif arg_type.type is bool:
program.var_set('READ', self.args[0],
Symbol(DataTypes.BOOL,
line.lower() == 'true'))
elif arg_type.type is str:
program.var_set('READ', self.args[0],
Symbol(DataTypes.STRING, line))
elif arg_type.type is int:
try:
temp_val = int(line)
if str(temp_val) != line:
program.var_set('READ', self.args[0],
Symbol(DataTypes.NIL, None))
else:
program.var_set('READ', self.args[0],
Symbol(DataTypes.INT, temp_val))
except ValueError:
program.var_set('READ', self.args[0],
Symbol(DataTypes.NIL, None))
elif arg_type.type is float:
try:
try:
float_value = float(line)
except ValueError:
float_value = float.fromhex(line)
except Exception:
program.var_set('READ', self.args[0],
Symbol(DataTypes.NIL, None))
else:
program.var_set('READ', self.args[0],
Symbol(DataTypes.FLOAT, float_value))
def symbols(self, pathname):
total_commit = 0
_files = [pathname]
exist_syms = {}
while _files:
pathname = _files.pop(0)
if self.files.isdir(pathname):
dirs, files = self.files.getdir(pathname)
for i in dirs + files:
_files.append(os.path.join(pathname, i))
else:
o = self.pathname_to_obj[pathname]
if o.filetype in self.parses and not o.has_indexed():
logger.info('find tags: %s' % pathname)
tags = find_tags(self.files.toreal(pathname), o.filetype)
for tag in tags:
sym, line, lang_typeid = tag
if sym in exist_syms:
sym_id = exist_syms[sym]
else:
symbol_obj = Symbol(sym, self.symid)
sym_id = self.symid
exist_syms[sym] = sym_id
self.symid += 1
self.session.add(symbol_obj)
defin = Definitions(sym_id, o.fileid, line,
lang_typeid)
self.sym_filetype[sym_id] = o.filetype
self.session.add(defin)
total_commit += 1
if total_commit % 1000 == 0:
self.session.commit()
o.set_indexed()
self.session.add(o)
logger.info('find %s tags: %s' % (len(tags), pathname))
self.session.commit()
self.track_info['total_symbol'] = total_commit
logger.info('finish tags, total = %s' % total_commit)
def execute(self, program: Program):
symbols = program.pop_stack(2)
index = symbols[0]
string = symbols[1]
if not string.is_string() or not index.is_int():
exit_app(
exitCodes.INVALID_DATA_TYPE,
'STRI2INTS\nInvalid data type. Expected: string and int.' +
' Have: {} and {}'.format(string.data_type.value,
index.data_type.value), True)
try:
ordinary = ord(string.value[index.value])
except IndexError:
exit_app(exitCodes.INVALID_STRING_OPERATION,
'String is out of range.', True)
else:
program.data_stack.append(Symbol(DataTypes.INT, ordinary))
def execute(self, program: Program):
string = program.get_symb('STRI2INT', self.args[1])
index = program.get_symb('STRI2INT', self.args[2])
if string is None or not string.is_string(
) or index is None or not index.is_int():
exit_app(
exitCodes.INVALID_DATA_TYPE,
'STRI2INT\nInvalid data type. Expected: string and int.' +
' Have: {} and {}'.format(string.data_type.value,
index.data_type.value), True)
try:
ordinary = ord(string.value[index.value])
program.var_set('STRI2INT', self.args[0],
Symbol(DataTypes.INT, ordinary))
except IndexError:
exit_app(exitCodes.INVALID_STRING_OPERATION,
'String is out of range.', True)
def add_stock(self,
ticker,
name=None,
exchange=None,
sector=None,
industry=None):
""" Add a stock to the stock database
Add the stock to the symbols table and populate quotes table with all
available historical quotes. If any of the optional parameters are left
out, the corresponding information will be obtained from Yahoo!
Finance.
:param ticker: Stock ticker symbol
:param name: (optional) Company/security name
:param exchange: (optional) Exchange on which the security is traded
:param sector: (optional) Company/security sector
:param Industry (optional) Company/security industry
"""
ticker = ticker.lower()
session = self.db.Session()
if self.check_stock_exists(ticker, session):
print "Stock %s already exists!" % (ticker.upper())
return
if name is None:
name = quotes.get_name(ticker)
if exchange is None:
exchange = quotes.get_stock_exchange(ticker)
if sector is None:
sector = quotes.get_sector(ticker)
if industry is None:
industry = quotes.get_industry(ticker)
stock = Symbol(ticker, name, exchange, sector, industry)
session.add(stock)
q = self._download_quotes(ticker, date(1900, 01, 01), date.today())
for quote in q:
quote.Features = Indicator(quote.Id)
session.add_all(q)
session.commit()
session.close()
self.update_quotes(ticker)
"""Seed file to create db tables"""
from models import db, Symbol
from app import app
# Create all tables
db.drop_all()
db.create_all()
# Add default symbol
symbol = Symbol(
symbol="<i class='symbol fas fa-seedling' style='color:#228B22;'></i>")
db.session.add(symbol)
db.session.commit()
def compare(self, symb1: Symbol, symb2: Symbol) -> bool:
return symb1.equals(symb2)
