def start_downoading(file_name):
import run
import logging
print "FILE NAME ", file_name
logging.basicConfig(level=logging.INFO)
run = run.Run(file_name)
run.start()
def run(delay=30, debug=False, do_one=False, stop=False, mode="web"):
p = Parameters()
p.set_delay_seconds(delay)
p.do_one(do_one, stop)
p.run_type(mode)
p.is_debug(debug)
start(p)
def run(command, location, on_fail, on_success, config, name):
crun.start(
command=command,
location=location,
on_fail=on_fail,
on_success=on_success,
config=config,
name=name
)
def index():
if request.method == 'POST':
# clean contents of uploads/ folder before each session
cleanUploadFolder()
clearLogfile()
uploaded_files = request.files.getlist('data[]')
for f in uploaded_files:
csvs.save(f)
inputpath = "uploads/"
messagelist = run.start(inputpath)
path = messagelist[0]
if not path:
#printerr = []
with open('_pre.log_') as f:
content = f.readlines()
printerr = [x.strip() for x in content]
return flask.render_template("outputmsg.html", msglist=printerr)
res = "" # path for output file to download
try:
csv_files = glob.glob(path + "*.csv")
for f in csv_files:
if 'unfilled' not in f:
res = os.path.join(os.path.dirname(app.instance_path), f)
return flask.send_file(res, as_attachment=True)
except Exception as e:
return flask.render_template("outputmsg.html",
msglist=messagelist[1:])
return render_template('index.html')
def start_task(self):
"""任务主程序"""
print('-----start-----')
sql = self.generate_sql()
try:
start(sql=sql)
with open('log/record_sql.log', 'a+') as f:
f.write('\n[%s]: SQL="%s;"' % (time.strftime(
"%Y-%m-%d %H:%M:%S", time.localtime()), sql))
f.close()
self.error_count = 0
except Exception as e:
self.error_count += 1
logger.error(traceback.format_exc())
time.sleep(30)
if self.error_count == 10:
quit()
s.enter(10, 0, self.start_task, ())
cv2.imshow('original', original_img)
# 灰度图
# cv2.imshow('screen', cvt_img)
# print('fps {} '.format(1 / (time.time() - last_time)))
last_time = time.time()
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
# 10 fps
def screen_pil():
last_time = time.time()
bbox = Win32screen().window()
while True:
img = np.array(ImageGrab.grab(bbox=bbox))
print('fps {} '.format(1 / (time.time() - last_time)))
last_time = time.time()
# cv2.resizeWindow('sync window', 640, 360)
cv2.imshow('sync window', cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
if __name__ == '__main__':
time.sleep(7)
# Direct.cruising()
# screen_mss()
start()
def Execute(self): self.FSM.SetState(run.start()) self.FSM.Execute()
def start_basic():
""" Load & run programs and commands and hand over to interactive mode. """
import program
import run
import error
import state
import devices
import disk
import cassette
import reset
import sound
do_reset = False
backend, console = None, None
try:
# resume from saved emulator state if requested and available
resume = config.get('resume') and state.load()
# choose the video and sound backends
backend, console = prepare_console()
# greet, load and run only if not resuming
if resume:
# override selected settings from command line
cassette.override()
disk.override()
# suppress double prompt
if not state.basic_state.execute_mode:
state.basic_state.prompt = False
run.start('', False, config.get('quit'))
else:
# load/run program
config.options['run'] = config.get(0) or config.get('run')
prog = config.get('run') or config.get('load')
if prog:
# on load, accept capitalised versions and default extension
with open_native_or_dos_filename(prog) as progfile:
program.load(progfile)
reset.clear()
print_greeting(console)
# start the interpreter (and get out if we ran with -q)
run.start(config.get('exec'), config.get('run'), config.get('quit'))
except error.RunError as e:
msg = error.get_message(e.err)
if console and config.get('wait'):
console.write_error_message(msg, None)
if backend and backend.video:
# close terminal to avoid garbled error message
backend.video.close()
backend.video = None
logging.error(msg)
except error.Exit:
pass
except error.Reset:
do_reset = True
except KeyboardInterrupt:
if config.get('debug'):
raise
except Exception as e:
logging.error("Unhandled exception\n%s", traceback.format_exc())
finally:
try:
# fix the terminal on exit (important for ANSI terminals)
# and save display interface state into screen state
state.console_state.screen.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing screen: %s', e)
# delete state if resetting
if do_reset:
state.delete()
if plat.system == 'Android':
shutil.rmtree(plat.temp_dir)
else:
state.save()
try:
# close files if we opened any
devices.close_files()
except (NameError, AttributeError) as e:
logging.debug('Error on closing files: %s', e)
try:
devices.close_devices()
except (NameError, AttributeError) as e:
logging.debug('Error on closing devices: %s', e)
try:
sound.audio.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing audio: %s', e)
class GenerateUrls():
def __init__(self):
self.base_url = "http://www.poradnikzdrowie.pl/"
self.urls = []
self.days = []
def get_urls(self):
cats = [
'bol', 'alergie', 'cukrzyca', 'hormony', 'laryngologia',
'nowotwory', 'zeby', 'choroby-meskie', 'choroby-kobiece',
'choroby-genetyczne', 'choroby-pasozytnicze', 'choroby-zakazne',
'domowa-apteczka', 'uklad-moczowy', 'uklad-nerwowy',
'uklad-krwionosny', 'uklad-oddechowy', 'uklad-odpornosciowy',
'uklad-pokarmowy', 'urazy-wypadki', 'grypa-i-przeziebienia'
]
# cats = ['oczy', 'skora']
for cat in cats:
for i in range(1, 6):
self.days.append('http://www.poradnikzdrowie.pl/zdrowie/' +
cat + '/?page=' + str(i))
print('http://www.poradnikzdrowie.pl/zdrowie/' + cat +
'/?page=' + str(i))
print('ggggggggggg')
return self.days
if __name__ == '__main__':
import run
run.start('poradnikzdrowie', '.')
self.context = ""
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.base_url = "http://www.forumzdrowia.pl/"
self.urls = []
self.days = []
def get_urls(self):
# self.days = ['http://www.forumzdrowia.pl/id,216,strona,4']
# [215, 257,216,218,606,320,184,183,283,185,373,375,320]
cats = [
353, 189, 233, 322, 338, 373, 612, 620, 566, 567, 568, 402, 403,
577, 447, 497, 530
]
for cat in cats:
for i in range(1, 5):
self.days.append('http://www.forumzdrowia.pl/id,' + str(cat) +
',strona,' + str(i))
print('ggggggggggg', self.days)
return self.days
if __name__ == '__main__':
import run
run.start('forumzdrowia', '.')
if happening["name"] == self.happening["name"]:
break
def __init__(self):
HTMLParser.__init__(self, strict=False)
self.date = ""
self.happenings = []
self.context = ""
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.base_url = "http://www.portalzdrowia.pl/"
self.urls = []
self.days = []
def get_urls(self):
self.days = [
'http://www.portalzdrowia.pl/category.html,9,name,dieta_i_odchudzanie'
]
print('ggggggggggg')
return self.days
if __name__ == '__main__':
import run
run.start('portalzdrowia', '.')
import sys
import train as Train
import run as Run
if __name__ == "__main__":
if len(sys.argv) is 1:
print("Please select the mode")
else:
arg = sys.argv[1]
if arg == "train":
print("Trainning mode")
Train.start()
elif arg == "run":
print("Running mode")
Run.start()
else:
print("Please choose the correct mode")
for happening in self.happenings:
if happening["name"] == self.happening["name"]:
break
def __init__(self):
HTMLParser.__init__(self, strict=False)
self.date = ""
self.happenings = []
self.context = ""
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.base_url = "http://www.portalzdrowia.pl/"
self.urls = []
self.days = []
def get_urls(self):
self.urls = []
print('ggggggggggg')
return self.urls
if __name__ == '__main__':
import run
run.start('mp', '.')
def start_basic():
""" Load & run programs and commands and hand over to interactive mode. """
import program
import run
import error
import state
import devices
import disk
import cassette
import reset
import sound
import audio
do_reset = False
backend, console = None, None
exit_error = ''
try:
# resume from saved emulator state if requested and available
resume = config.get('resume') and state.load()
# choose the video and sound backends
backend, console = prepare_console()
# greet, load and run only if not resuming
if resume:
# override selected settings from command line
cassette.override()
disk.override()
# suppress double prompt
if not state.basic_state.execute_mode:
state.basic_state.prompt = False
run.start('', False, config.get('quit'))
else:
# load/run program
config.options['run'] = config.get(1) or config.get('run')
prog = config.get('run') or config.get('load')
if prog:
# on load, accept capitalised versions and default extension
with open_native_or_dos_filename(prog) as progfile:
program.load(progfile)
reset.clear()
print_greeting(console)
# start the interpreter (and get out if we ran with -q)
run.start(config.get('exec'), config.get('run'), config.get('quit'))
except error.RunError as e:
exit_error = error.get_message(e.err)
except error.Exit:
# pause before exit if requested
if config.get('wait'):
backend.video_queue.put(backend.Event(backend.VIDEO_SET_CAPTION, 'Press a key to close window'))
backend.video_queue.put(backend.Event(backend.VIDEO_SHOW_CURSOR, False))
state.console_state.keyb.pause = True
# this performs a blocking keystroke read if in pause state
backend.check_events()
except error.Reset:
do_reset = True
except KeyboardInterrupt:
if config.get('debug'):
raise
except Exception as e:
print traceback.print_exc()
exit_error = "Unhandled exception\n%s" % traceback.format_exc()
finally:
try:
audio.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing audio: %s', e)
try:
# fix the terminal on exit (important for ANSI terminals)
# and save display interface state into screen state
state.console_state.screen.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing screen: %s', e)
# delete state if resetting
if do_reset:
state.delete()
if plat.system == 'Android':
shutil.rmtree(plat.temp_dir)
else:
state.save()
try:
# close files if we opened any
devices.close_files()
except (NameError, AttributeError) as e:
logging.debug('Error on closing files: %s', e)
try:
devices.close_devices()
except (NameError, AttributeError) as e:
logging.debug('Error on closing devices: %s', e)
if exit_error:
logging.error(exit_error)
def actionRouter(self, event):
# =============Projects Actions ===========
if event == "act_Backup_Project_From_OP_1":
image = Image.new('1', (128, 64))
image.paste(
Image.open(workDir +
"/Assets/Img/BackupProject.png").convert("1"))
displayImage(image)
time.sleep(0.1)
try:
tape = TapeBackup()
tape.copyToLocal()
except:
print("File Transfer Error")
image = Image.new('1', (128, 64))
image.paste(
Image.open(workDir + "/Assets/Img/Done.png").convert("1"))
displayImage(image)
time.sleep(0.1)
getAnyKeyEvent()
self.renderPage(-1, 1)
if event == "act_Load_Project_From_Local":
renderFolders(savePaths["Local_Projects"], "Upload")
self.renderPage(-1, 1)
# ===========Patches Actions===========
if event == "OP1_Synth_Patches":
option = "RETURN"
# while option == "RETURN":
renderFolders(savePaths["OP_1_Synth"], "Backup")
self.renderPage(-1, 1)
if event == "OP1_Drum_Patches":
renderFolders(savePaths["OP_1_Drum"], "Backup")
self.renderPage(-1, 1)
if event == "UploadSynthPatches":
# option = "RETURN"
# while option == "RETURN":
renderFolders(savePaths["Local_Synth"], "Upload")
# if option == "Upload":
# print("Upload")
# if option == "Rename":
# print("Rename")
# if option == "Delete":
# print("Delete")
self.renderPage(-1, 1)
if event == "UploadDrumPatches":
renderFolders(savePaths["Local_Drum"], "Upload")
self.renderPage(-1, 1)
if event == "act_5_Backup_All_Patches":
self.renderPage(-1, 1)
# ===========Eject Actions===========
if event == "act_ESC_Eject_OP_1":
# unmount_OP_1()
cmd = "sudo umount " + config["OP_1_Mounted_Dir"]
try:
os.system(cmd)
except:
pass
print("Ejected")
time.sleep(5)
start()
# pass
if event == "checkStorage":
image = Image.new('1', (128, 64))
image.paste(
Image.open(workDir +
"/Assets/Img/Storage_64.png").convert("1"))
draw = ImageDraw.Draw(image)
sampler, synth, drum = update_Current_Storage_Status()
Disk = subprocess.check_output(
"df -h | awk '$NF==\"/\"{printf \"%d/%dGB %s\", $3,$2,$5}'",
shell=True)
draw.text((50, 13), Disk, font=getFont(),
fill="white") # Disk Storage Render
draw.text((28, 48),
str(config["Max_Synth_Sampler_patches"] - sampler),
font=getFont(),
fill="white")
draw.text((70, 48),
str(config["Max_Synth_Synthesis_patches"] - synth),
font=getFont(),
fill="white")
draw.text((112, 48),
str(config["Max_Drum_Patches"] - drum),
font=getFont(),
fill="white")
displayImage(image)
getAnyKeyEvent() # Press any key to proceed
self.renderPage(-1, 1)
if self.context == "GOT IT" and tag == "a":
self.context = "MAIN"
def __init__(self):
HTMLParser.__init__(self, strict=False)
self.date = ""
self.happenings = []
self.context = ""
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.base_url = "http://www.portalzdrowia.pl/"
self.urls = []
self.days = []
def get_urls(self):
self.days = ['https://www.doz.pl/ziola/w_1-wszystkie']
# for i in range(20,98):
# self.days.append('https://www.doz.pl/zdrowie/w0_' + str(i) + '-wszystkie')
# print('https://www.doz.pl/zdrowie/w0_' + str(i) + '-wszystkie')
return self.days
if __name__ == '__main__':
import run
run.start('doz', '.')
self.happenings.append(happening)
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.base_url = "https://pl.wikipedia.org/"
self.urls = []
self.days = []
def get_urls(self):
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute("SELECT title FROM dr_medi")
all_articles = c.fetchall()
# all_articles = all_articles[0]
# all_articles = c.fetchone()
for article in all_articles:
article = "_".join(article[0].split())
print("new url is https://pl.wikipedia.org/wiki/" + article)
self.days.append("https://pl.wikipedia.org/wiki/" + article)
print('ggggggggggg')
return self.days
if __name__ == '__main__':
import run
run.start('wiki', '.')
import time
import run
if __name__ in "__main__":
print("\n\n")
print(time.strftime("%c", time.localtime(time.time())))
start_time = time.time()
run.start()
end_time = time.time() - start_time
print(end_time)
def prepare_happening(self):
for happening in self.happenings:
if happening["name"] == self.happening["name"]:
break
def __init__(self):
HTMLParser.__init__(self, strict=False)
self.date = ""
self.happenings = []
self.context = ""
def get_happenings(self):
return self.happenings
class GenerateUrls():
def __init__(self):
self.urls = []
self.days = []
def get_urls(self):
self.days = ['http://www.medisa.pl/spis_p.html']
print('ggggggggggg')
return self.days
if __name__ == '__main__':
import run
run.start('medisa', '.')
def start_basic():
""" Load & run programs and commands and hand over to interactive mode. """
import program
import run
import error
import state
import devices
import disk
import cassette
import reset
import sound
do_reset = False
backend, console = None, None
try:
# resume from saved emulator state if requested and available
resume = config.get('resume') and state.load()
# choose the video and sound backends
backend, console = prepare_console()
# greet, load and run only if not resuming
if resume:
# override selected settings from command line
cassette.override()
disk.override()
# suppress double prompt
if not state.basic_state.execute_mode:
state.basic_state.prompt = False
run.start('', False, config.get('quit'))
else:
# load/run program
config.options['run'] = config.get(0) or config.get('run')
prog = config.get('run') or config.get('load')
if prog:
# on load, accept capitalised versions and default extension
with open_native_or_dos_filename(prog) as progfile:
program.load(progfile)
reset.clear()
print_greeting(console)
# start the interpreter (and get out if we ran with -q)
run.start(config.get('exec'), config.get('run'),
config.get('quit'))
except error.RunError as e:
msg = error.get_message(e.err)
if console and config.get('wait'):
console.write_error_message(msg, None)
if backend and backend.video:
# close terminal to avoid garbled error message
backend.video.close()
backend.video = None
logging.error(msg)
except error.Exit:
pass
except error.Reset:
do_reset = True
except KeyboardInterrupt:
if config.get('debug'):
raise
except Exception as e:
logging.error("Unhandled exception\n%s", traceback.format_exc())
finally:
try:
# fix the terminal on exit (important for ANSI terminals)
# and save display interface state into screen state
state.console_state.screen.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing screen: %s', e)
# delete state if resetting
if do_reset:
state.delete()
if plat.system == 'Android':
shutil.rmtree(plat.temp_dir)
else:
state.save()
try:
# close files if we opened any
devices.close_files()
except (NameError, AttributeError) as e:
logging.debug('Error on closing files: %s', e)
try:
devices.close_devices()
except (NameError, AttributeError) as e:
logging.debug('Error on closing devices: %s', e)
try:
sound.audio.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing audio: %s', e)
def start_basic():
""" Load & run programs and commands and hand over to interactive mode. """
import program
import run
import error
import state
import devices
import disk
import cassette
import reset
import sound
import audio
do_reset = False
backend, console = None, None
exit_error = ''
try:
# resume from saved emulator state if requested and available
resume = config.get('resume') and state.load()
# choose the video and sound backends
backend, console = prepare_console()
# greet, load and run only if not resuming
if resume:
# override selected settings from command line
cassette.override()
disk.override()
# suppress double prompt
if not state.basic_state.execute_mode:
state.basic_state.prompt = False
run.start('', False, config.get('quit'))
else:
# load/run program
config.options['run'] = config.get(0) or config.get('run')
prog = config.get('run') or config.get('load')
if prog:
# on load, accept capitalised versions and default extension
with open_native_or_dos_filename(prog) as progfile:
program.load(progfile)
reset.clear()
print_greeting(console)
# start the interpreter (and get out if we ran with -q)
run.start(config.get('exec'), config.get('run'),
config.get('quit'))
except error.RunError as e:
exit_error = e.message
except error.Exit:
# pause before exit if requested
if config.get('wait'):
backend.video_queue.put(
backend.Event(backend.VIDEO_SET_CAPTION,
'Press a key to close window'))
backend.video_queue.put(
backend.Event(backend.VIDEO_SHOW_CURSOR, False))
state.console_state.keyb.pause = True
# this performs a blocking keystroke read if in pause state
backend.check_events()
except error.Reset:
do_reset = True
except KeyboardInterrupt:
if config.get('debug'):
raise
except Exception as e:
exit_error = "Unhandled exception\n%s" % traceback.format_exc()
finally:
try:
audio.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing audio: %s', e)
try:
# fix the terminal on exit (important for ANSI terminals)
# and save display interface state into screen state
state.console_state.screen.close()
except (NameError, AttributeError) as e:
logging.debug('Error on closing screen: %s', e)
# delete state if resetting
if do_reset:
state.delete()
if plat.system == 'Android':
shutil.rmtree(plat.temp_dir)
else:
state.save()
try:
# close files if we opened any
devices.close_files()
except (NameError, AttributeError) as e:
logging.debug('Error on closing files: %s', e)
try:
devices.close_devices()
except (NameError, AttributeError) as e:
logging.debug('Error on closing devices: %s', e)
if exit_error:
logging.error(exit_error)
