def work(item):
code, name, idx = item.split(',')
print(idx)
fund_url = 'http://fund.eastmoney.com/' + code + '.html'
page_text = parse_page(fund_url)
parser = MyParser(page_text)
fund_type, fund_performance = parser.parse_all()
parser.parse_netvalue()
try:
ACWorthTrend, grow_rate, mdd = plot_trend(code)
fund_info = {
'_id': code,
'name': name,
'grow_rate': grow_rate,
'mdd': mdd
}
fund_trend = {'_id': code, 'acworth_trend': ACWorthTrend}
mycol_info.insert_one(fund_info)
mycol_trend.insert_one(fund_trend)
except:
fail_fund_info = ','.join([name, code, fund_type]) + '\n'
fail_funds.append(fail_fund_info)
print(fail_fund_info)
def start_simulation(self):
self.res_print.delete(0.0, END)
#print(self.net)
self.res_print.insert(END, '#--------------------Start Parse the Netlist---------------------#\n')
sim_parse=MyParser(self.net)
a,b=sim_parse.parse()
#print (a,'hi')
if (a==-1):
parser_info=sim_parse.showParseResult()
else:
parser_info='have error at line '+str(b)
for lines in parser_info:
self.res_print.insert(END,lines)
self.res_print.insert(END, ' ')
self.res_print.insert(END,'#----------------------Start the Simulation----------------------#\n')
sim_simulator=simulator(self.net)
sim_simulator.solve_net()
self.res_print.insert(END,'#----------------------Successful Simulation----------------------#\n')
def translate(self, formula, file_name, num, quiet=False):
objects, constraints = formula
self.objects = objects
parser = MyParser()
parsed_formula = parser(constraints)
if not quiet:
print(parsed_formula)
formulas = self.get_all_formulas(parsed_formula)
automatas = self.get_automatas(formulas)
return automatas
def read_dfa(self, f):
with open(f'{f}', 'r') as file:
formula = file.read().strip()
parser = MyParser()
parsed_formula = parser(formula)
dfa, init, goals, states = self.get_dfa(parsed_formula,
parser.change_dict)
alpha = set(parser.change_dict.values())
alpha.remove('#')
return {
"alphabet": alpha,
"states": states,
"initial_state": init,
"accepting_states": goals,
"transitions": dfa
}
def translate(self, formula, file_name, quiet=False):
parser = MyParser()
parsed_formula = parser(formula)
if not quiet:
print(parsed_formula)
formula = self.trans_fol(parsed_formula)
try:
with open("formula.mona", "w") as file:
file.write(formula)
except IOError:
print("IOError pass_trough_mona")
raise ValueError
try:
os.system(f"mona -u -w -q formula.mona > {file_name}")
return self.read_dfa(file_name)
except:
print("Mona error")
raise ValueError
def __call__(self, f):
parser = MyParser()
parsed_formula = parser(f)
if type(parsed_formula) != tuple:
return ('at-end', parsed_formula)
return parsed_formula
def __call__(self, f):
parser = MyParser()
parsed_formula = parser(f)
return self.trans_fol(parsed_formula)
import re
import time
from Parser import MyParser
print(
'>>OPTIONS<<\n1. Check strings in a small test file\n2. Check strings in a 1 000 000 file\n3. Enter strings yourself\n0. Exit'
)
System = dict()
parser = MyParser()
while True:
choice = input()
if choice == '1':
System.clear()
_data = open('test.txt', 'r')
_time = open('test_time.txt', 'w')
_result = open('test_servers.txt', 'w')
nf = _data.read()
_data.close()
start_time = time.perf_counter()
parser = MyParser(True)
parser.check_string(nf)
System = parser.get_A()
_time.write(str(time.perf_counter() - start_time) + '\n')
_time.close()
for i in System:
_result.write(i + '\t' + str(System[i]) + '\n')
_result.close()
elif choice == '2':
System.clear()
import config
import asyncio
import logging
import time
from aiogram import Bot, Dispatcher, executor
from Parser import MyParser, ErrorParser
logging.basicConfig(level=logging.INFO)
bot = Bot(token=config.TOKEN)
dp = Dispatcher(bot)
parser = MyParser()
async def main(wait_for):
old_coins = {"coin_gecko": {},
"coin_market": {}}
while True:
skip_gecko = False
skip_market = False
await asyncio.sleep(wait_for)
with open('data.txt', 'r') as file:
temp = eval(file.readlines()[0])
old_coins['coin_gecko'] = temp['coin_gecko']
old_coins['coin_market'] = temp['coin_market']
if len(old_coins['coin_gecko']) == 0:
skip_gecko = True
def __call__(self, f):
parser = MyParser()
parsed_formula = parser(f)
return parsed_formula, parser.change_dict