def main(arguments):
"""Process the arguments and fetch data according to them"""
arguments = vars(arguments)
current_time = utils.get_current_timestamp()
wikidata_site = utils.create_site_instance("wikidata", "wikidata")
existing_areas = get_wd_items_using_prop("P3613")
area_data = load_nature_area_file(arguments["dataset"])
data_files = load_mapping_files()
if arguments["offset"]:
print("Using offset: {}.".format(str(arguments["offset"])))
area_data = area_data[arguments["offset"]:]
if arguments["limit"]:
print("Using limit: {}.".format(str(arguments["limit"])))
area_data = area_data[:arguments["limit"]]
for area in area_data:
reserve = NatureArea(area, wikidata_site, data_files, existing_areas)
if arguments["table"]:
filename = "{}_{}.txt".format(arguments["dataset"], current_time)
preview = PreviewTable(reserve)
utils.append_line_to_file(preview.make_table(), filename)
if arguments["upload"]:
live = True if arguments["upload"] == "live" else False
if arguments["dataset"] == "nr":
edit_summary = edit_summary_reserves
elif arguments["dataset"] == "np":
edit_summary = edit_summary_nationalparks
uploader = Uploader(reserve,
repo=wikidata_site,
live=live,
edit_summary=edit_summary)
uploader.upload()
def main(arguments):
arguments = vars(arguments)
wikidata_site = utils.create_site_instance("wikidata", "wikidata")
existing_people = get_wd_items_using_prop("P4357")
auth_data = load_auth_file()
data_files = load_mapping_files()
if arguments["offset"]:
print("Using offset: {}.".format(str(arguments["offset"])))
auth_data = auth_data[arguments["offset"]:]
if arguments["limit"]:
print("Using limit: {}.".format(str(arguments["limit"])))
auth_data = auth_data[:arguments["limit"]]
for p in auth_data:
p_data = p[list(p.keys())[0]]
person = Person(p_data, wikidata_site, data_files, existing_people)
if arguments["upload"]:
live = True if arguments["upload"] == "live" else False
uploader = Uploader(
person,
repo=wikidata_site,
live=live,
edit_summary="importing #Musikverket authority file")
try:
uploader.upload()
except pywikibot.data.api.APIError:
continue
def upload():
"""Render and upload eml.xml, and create entry in registry table."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
# Create eml.xml
eml = render_eml(request)
# Upload to NDB datastore
uploader = Uploader()
uploader.upload_eml(eml)
# Create CartoDB registry record
success = uploader.cartodb_meta(request.form)
if success == False:
return render_template('metadata.html')
# Store datum
session.pop('geodeticDatum', None)
session['geodeticDatum'] = request.form[
'datum'] if 'datum' in request.form and request.form[
'datum'] != "" else "WGS84"
# Create occurrence.txt
# uploader.build_occurrence()
# TODO: Implement build_dwca and move to Cloud Storage with googleapis
session['from'] = 'upload'
return render_template('upload_cartodb.html')
def upload(self):
try:
login = self.lineEdit_3.text()
password = self.lineEdit_4.text()
group_id = abs(int(self.lineEdit.text()))
path_to_folder = self.lineEdit_2.text()
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
uploader = Uploader(login, password, group_id, path_to_folder)
self.progressBar = QtWidgets.QProgressBar(self.gridLayoutWidget)
self.progressBar.setEnabled(True)
self.progressBar.setValue(0)
self.progressBar.setTextVisible(True)
self.progressBar.setObjectName("progressBar")
self.gridLayout.addWidget(self.progressBar, 10, 0, 1, 1)
self.pushButton.setEnabled(False)
self.pushButton_2.setEnabled(False)
self.update()
for i, j in uploader.upload_album():
self.progressBar.setValue(int(i / j * 100))
QApplication.processEvents()
except Exception as e:
errMsgBox = QErrorMessage()
errMsgBox.showMessage(repr(e))
errMsgBox.exec_()
finally:
self.progressBar.setParent(None)
self.pushButton.setEnabled(True)
self.pushButton_2.setEnabled(True)
QApplication.restoreOverrideCursor()
def headers_selector():
"""Basic file-level assessment and proper redirection."""
# Generate and store new UUID for file
file_uuid = str(uuid.uuid4())
session.pop('file_uuid', None)
session['file_uuid'] = file_uuid
# Get file
up_file = request.files['file']
if not up_file:
flash("Please, provide a file to upload")
return redirect(url_for("main"))
# Parse and upload file to NDB, key in session['raw_key']
uploader = Uploader()
uploader.parse_file(up_file)
if uploader.any_error is True:
return redirect(url_for('main'))
# Redirect to proper handler
session['from'] = 'headers_selector'
if "useTemplate" in request.form:
return redirect(url_for('with_template'))
else:
return redirect(url_for('without_template'))
def metadata():
"""Store extra fields, if any, and prepare and upload meta.xml."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
# Parse metafields if coming from there
if session['from'] == 'metafields':
session['extra_fields'] = {}
for i in request.form.keys():
if i != 'submitBtn' and not i.endswith("_dwc"):
term_dict = {
"description": request.form[i],
"term": request.form["%s_dwc" % i]
}
session['extra_fields'][i] = term_dict
# Create meta.xml
meta = render_meta()
# Upload to NDB datastore
uploader = Uploader()
uploader.upload_meta(meta)
# Render metadata template
session['from'] = 'metadata'
return render_template('metadata.html')
def headers_selector():
"""Basic file-level assessment and proper redirection."""
# Generate and store new UUID for file
file_uuid = str(uuid.uuid4())
session.pop('file_uuid', None)
session['file_uuid'] = file_uuid
# Get file
up_file = request.files['file']
if not up_file:
flash("Please, provide a file to upload")
return redirect(url_for("main"))
# Parse and upload file to NDB, key in session['raw_key']
uploader = Uploader()
uploader.parse_file(up_file)
if uploader.any_error is True:
return redirect(url_for('main'))
# Redirect to proper handler
session['from'] = 'headers_selector'
if "useTemplate" in request.form:
return redirect(url_for('with_template'))
else:
return redirect(url_for('without_template'))
def metadata():
"""Store extra fields, if any, and prepare and upload meta.xml."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
# Parse metafields if coming from there
if session['from'] == 'metafields':
session['extra_fields'] = {}
for i in request.form.keys():
if i != 'submitBtn' and not i.endswith("_dwc"):
term_dict = {"description": request.form[i], "term": request.form["%s_dwc" % i]}
session['extra_fields'][i] = term_dict
# Create meta.xml
meta = render_meta()
# Upload to NDB datastore
uploader = Uploader()
uploader.upload_meta(meta)
# Render metadata template
session['from'] = 'metadata'
return render_template('metadata.html')
def main(arguments):
"""Process the arguments and fetch data according to them."""
arguments = vars(arguments)
filenames = generate_filenames("Bosnia", utils.get_current_timestamp())
repo = utils.create_site_instance("wikidata", "wikidata")
source_data = load_source_data(arguments["datadir"])
data_files = load_mapping_files()
mapping = data_files["_static"]["ba_(bs)"]
existing = get_wd_items_using_prop(
data_files["_static"]["ba_(bs)"]["unique"]["property"])
if arguments["offset"]:
print("Using offset: {}.".format(str(arguments["offset"])))
source_data = source_data[arguments["offset"]:]
if arguments["short"]:
print("Using limit: {}.".format(str(arguments["short"])))
source_data = source_data[:arguments["short"]]
for row in source_data:
monument = BosniaMonument(row, mapping, data_files, existing, repo)
if arguments["table"]:
raw_data = "<pre>" + str(row) + "</pre>\n"
monument_table = monument.print_wd_to_table()
utils.append_line_to_file(raw_data, filenames['examples'])
utils.append_line_to_file(monument_table, filenames['examples'])
if arguments["upload"]:
live = True if arguments["upload"] == "live" else False
uploader = Uploader(monument, repo=repo, live=live, tablename="ba")
uploader.upload()
def upload():
"""Render and upload eml.xml, and create entry in registry table."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
# Create eml.xml
eml = render_eml(request)
# Upload to NDB datastore
uploader = Uploader()
uploader.upload_eml(eml)
# Create CartoDB registry record
success = uploader.cartodb_meta(request.form)
if success == False:
return render_template('metadata.html')
# Store datum
session.pop('geodeticDatum', None)
session['geodeticDatum'] = request.form['datum'] if 'datum' in request.form and request.form['datum'] != "" else "WGS84"
# Create occurrence.txt
# uploader.build_occurrence()
# TODO: Implement build_dwca and move to Cloud Storage with googleapis
session['from'] = 'upload'
return render_template('upload_cartodb.html')
def main():
args = parseArguments()
fileManager = FileManager(args=args)
demoPathAttributes = fileManager.getAttributes()
uploader = Uploader(demoPathAttributes)
uploader.upload()
def proc(self, config: dict, record_dir: str, danmu_path: str,
current_state, state_change_time) -> None:
p = Processor(config, record_dir, danmu_path)
p.run()
if config.get('spec', {}).get('uploader', {}).get('record', {}).get(
'upload_record', False) or config.get('spec', {}).get(
'uploader', {}).get('clips', {}).get(
'upload_clips', False):
current_state.value = int(utils.state.UPLOADING_TO_BILIBILI)
state_change_time.value = time.time()
try:
u = Uploader(p.outputs_dir, p.splits_dir, config)
d = u.upload(p.global_start)
except Exception as e:
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
if d is None:
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
else:
if not config.get('spec', {}).get('uploader', {}).get(
'record',
{}).get('keep_record_after_upload', True) and d.get(
"record",
None) is not None and not config.get('root', {}).get(
'uploader', {}).get('upload_by_edit', False):
rc = BiliVideoChecker(d['record']['bvid'], p.splits_dir,
config)
rc.start()
if not config.get('spec', {}).get('uploader', {}).get(
'clips',
{}).get('keep_clips_after_upload', True) and d.get(
"clips",
None) is not None and not config.get('root', {}).get(
'uploader', {}).get('upload_by_edit', False):
cc = BiliVideoChecker(d['clips']['bvid'], p.outputs_dir,
config)
cc.start()
if config.get('root', {}).get('enable_baiduyun', False) and config.get(
'spec', {}).get('backup', False):
current_state.value = int(utils.state.UPLOADING_TO_BAIDUYUN)
state_change_time.value = time.time()
try:
from bypy import ByPy
bp = ByPy()
bp.upload(p.merged_file_path)
except Exception as e:
logging.error('Error when uploading to Baiduyun:' + str(e) +
traceback.format_exc())
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
return
if current_state.value != int(utils.state.LIVE_STARTED):
current_state.value = int(utils.state.WAITING_FOR_LIVE_START)
state_change_time.value = time.time()
def __init__(self, pathToMain):
self.pathToSketchbook = ""
# Get path on mac
if platform.system() == "Darwin":
# logging.debug('self.pathToMain');
# logging.debug(self.pathToMain);
# logging.debug('PWD=');
# logging.debug(os.environ.get('PWD'));
# logging.debug('PYTHONPATH=');
# logging.debug(os.environ.get('PYTHONPATH'));
# logging.debug('ENVIRON=');
# logging.debug(os.environ);
if os.environ.get("PYTHONPATH") != None:
self.pathToMain = os.environ.get("PYTHONPATH")
else:
self.pathToMain = pathToMain
elif platform.system() == "Windows" or platform.system() == "Linux":
self.pathToMain = pathToMain
if platform.system() == "Linux":
self.pathToSketchbook = expanduser("~").decode("latin1") + "/Arduino"
elif platform.system() == "Darwin":
self.pathToSketchbook = base.sys_path.get_document_path() + "/Arduino"
elif platform.system() == "Windows":
self.pathToSketchbook = (
os.path.dirname(os.path.dirname(os.path.dirname(base.sys_path.get_tmp_path()))) + "/Documents/Arduino"
)
self.pathToArduinoDir = pathToMain + "/res/arduino/"
self.uploader = Uploader(pathToMain)
self.compiler = Compiler(pathToMain)
self.boardSettings = defaultdict(BoardConfig)
self.parseBoardSettings(self.pathToMain + "/res/boards.txt")
self.board = "uno"
self.port = None
def startUpload(self):
argsdict = self.getUploadArgs()
if not self.checkUploadArgs(argsdict):
return
self.uploader = Uploader()
self.connect(self.uploader.qobj, QtCore.SIGNAL(const.finish_sig),
self.onUploadFinish)
self.uploader.resetUploadArgs(argsdict)
self.ui.textEdit.clear()
self.ui.textEdit.append("Start uploading\n")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.onUploading)
self.uploader.start()
self.timer.start(const.process_interval)
def __init__(self, pathToMain):
#Get path on mac
if platform.system() == 'Darwin':
# logging.debug('self.pathToMain');
# logging.debug(self.pathToMain);
# logging.debug('PWD=');
# logging.debug(os.environ.get('PWD'));
#logging.debug('PYTHONPATH=');
#logging.debug(os.environ.get('PYTHONPATH'));
# logging.debug('ENVIRON=');
# logging.debug(os.environ);
if os.environ.get('PYTHONPATH') != None:
self.pathToMain = os.environ.get('PYTHONPATH')
else:
self.pathToMain = pathToMain
elif platform.system() == 'Windows' or platform.system() == 'Linux':
self.pathToMain = pathToMain
if platform.system() == 'Linux':
self.pathToSketchbook = expanduser("~").decode('latin1')+'/Arduino'
elif platform.system() == 'Windows' or platform.system() == 'Darwin':
self.pathToSketchbook = expanduser("~").decode('latin1')+'/Documents/Arduino'
self.pathToSketchbook = self.pathToSketchbook.decode('latin1')
self.pathToArduinoDir = pathToMain+'/res/arduino/'
self.uploader = Uploader(pathToMain)
self.compiler = Compiler(pathToMain)
self.boardSettings = defaultdict(BoardConfig)
self.parseBoardSettings(self.pathToMain+"/res/boards.txt")
self.board = 'uno'
self.port = None
def main(arguments):
"""Get arguments and process data."""
libris_files = list_available_files(arguments.get("dir"),
arguments.get("limit"),
arguments.get("uri"))
filenames = make_filenames(utils.get_current_timestamp())
wikidata_site = utils.create_site_instance("wikidata", "wikidata")
data_files = load_mapping_files()
existing_people = utils.get_wd_items_using_prop(
data_files["properties"]["libris_uri"])
problem_reports = []
for fname in libris_files:
data = utils.load_json(fname)
cache = load_caches(["surname", "first_name"])
if is_person(data):
person = Person(data,
wikidata_site,
data_files,
existing_people,
cache)
dump_caches(person.get_caches())
problem_report = person.get_report()
if arguments.get("upload"):
live = True if arguments["upload"] == "live" else False
uploader = Uploader(person, repo=wikidata_site,
live=live, edit_summary=EDIT_SUMMARY)
if "Q" in problem_report and problem_report["Q"] == "":
"""
If the Person didn't have an associated Qid,
this means the Uploader has now created a new Item
for it -- insert that id into the problem report.
"""
problem_report["Q"] = uploader.wd_item_q
try:
uploader.upload()
except pywikibot.data.api.APIError as e:
print(e)
if problem_report:
problem_reports.append(problem_report)
utils.json_to_file(
filenames['reports'], problem_reports, silent=True)
if problem_reports:
print("SAVED PROBLEM REPORTS TO {}".format(filenames['reports']))
def __init__(self, pathToMain):
self.pathToMain = pathToMain
self.pathToSketchbook = expanduser("~")+'/sketchbook'
self.pathToArduinoDir = pathToMain+'/res/arduino/'
self.uploader = Uploader(pathToMain)
self.compiler = Compiler(pathToMain)
self.boardSettings = defaultdict(BoardConfig)
self.parseBoardSettings(self.pathToMain+"/res/boards.txt")
self.board = 'uno'
self.port = None
def parse():
"""Check the consistency of the uploaded file."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
parser = Parser()
uploader = Uploader()
f = uploader.open_file(session['file_uuid'])
parser.parse_content(f)
if len(parser.errors) == 0:
target = 'metafields'
else:
session.pop('errors', None)
session['errors'] = parser.errors
flash('ERROR: We found some problems when parsing your file. <a href="#" data-toggle="modal" data-target="#parsingModal">Click here</a> to get a detailed review.')
target = 'main'
return redirect(url_for(target))
def proc(config: dict, record_dir: str, danmu_path: str) -> None:
p = Processor(config, record_dir, danmu_path)
p.run()
u = Uploader(p.outputs_dir, p.splits_dir, config)
d = u.upload(p.global_start)
if not config['spec']['uploader']['record'][
'keep_record_after_upload'] and d.get("record", None) is not None:
rc = BiliVideoChecker(d['record']['bvid'], p.splits_dir, config)
rc_process = Process(target=rc.check)
rc_process.start()
if not config['spec']['uploader']['clips'][
'keep_clips_after_upload'] and d.get("clips", None) is not None:
cc = BiliVideoChecker(d['clips']['bvid'], p.outputs_dir, config)
cc_process = Process(target=cc.check)
cc_process.start()
if config['root']['enable_baiduyun'] and config['spec']['backup']:
from bypy import ByPy
bp = ByPy()
bp.upload(p.merged_file_path)
def render_recipe_to_ebook(self, recipe_dict):
self.update_state(state='PROGRESS',
meta={
'type': 'update',
'message': 'Starting conversion to ebook'
})
ebook_generator = EbookGenerator(recipe_dict)
self.update_state(state='PROGRESS',
meta={
'type': 'update',
'message': 'Creating folders'
})
ebook_generator.setup()
self.update_state(state='PROGRESS',
meta={
'type': 'update',
'message': 'Generating ebook'
})
file_path = ebook_generator.generate_mobi()
self.update_state(state='PROGRESS',
meta={
'type': 'update',
'message': 'Uploading'
})
uploader = Uploader()
response = uploader.upload(file_path)
self.update_state(state='PROGRESS',
meta={
'type': 'update',
'message': 'Cleaning up'
})
ebook_generator.cleanup()
return {
'type': 'update',
'message': 'Ebook converted and uploaded',
'url': response["url"]
}
def parse():
"""Check the consistency of the uploaded file."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
parser = Parser()
uploader = Uploader()
f = uploader.open_file(session['file_uuid'])
parser.parse_content(f)
if len(parser.errors) == 0:
target = 'metafields'
else:
session.pop('errors', None)
session['errors'] = parser.errors
flash(
'ERROR: We found some problems when parsing your file. <a href="#" data-toggle="modal" data-target="#parsingModal">Click here</a> to get a detailed review.'
)
target = 'main'
return redirect(url_for(target))
def main(arguments):
wikidata_site = utils.create_site_instance("wikidata", "wikidata")
data_files = load_mapping_files()
cache = {}
existing_editions = utils.get_wd_items_using_prop(
data_files["properties"]["libris_uri"])
if arguments.get("uri"):
mode = "uri"
data = get_from_uri(arguments.get("uri"))
edition = Edition(data, wikidata_site, data_files, existing_editions,
cache, mode)
problem_report = edition.get_report()
if arguments.get("upload"):
live = True if arguments["upload"] == "live" else False
uploader = Uploader(edition,
repo=wikidata_site,
live=live,
edit_summary=EDIT_SUMMARY)
if "Q" in problem_report and problem_report["Q"] == "":
problem_report["Q"] = uploader.wd_item_q
try:
uploader.upload()
except pywikibot.data.api.APIError as e:
print(e)
elif arguments.get("dir") and arguments.get("libris_list"):
mode = "local"
available_files = list_available_files(arguments.get("dir"))
libris_list = get_lines_from_file(arguments["libris_list"])
for fname in available_files:
data = utils.load_json(fname)
selibr = get_libris_id(data)
if selibr and selibr in libris_list:
edition = Edition(data, wikidata_site, data_files,
existing_editions, cache, mode)
problem_report = edition.get_report()
if arguments.get("upload"):
live = True if arguments["upload"] == "live" else False
uploader = Uploader(edition,
repo=wikidata_site,
live=live,
edit_summary=EDIT_SUMMARY)
if "Q" in problem_report and problem_report["Q"] == "":
problem_report["Q"] = uploader.wd_item_q
try:
uploader.upload()
except pywikibot.data.api.APIError as e:
print(e)
def startUpload(self):
argsdict = self.getUploadArgs()
if not self.checkUploadArgs(argsdict):
return
self.uploader = Uploader()
self.connect(self.uploader.qobj, QtCore.SIGNAL(const.finish_sig), self.onUploadFinish)
self.uploader.resetUploadArgs(argsdict)
self.ui.textEdit.clear()
self.ui.textEdit.append("Start uploading\n")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.onUploading)
self.uploader.start()
self.timer.start(const.process_interval)
def upload_cartodb():
"""Parse records and upload to point table."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
uploader = Uploader()
# Prepare the file for CartoDB
uploader.cartodb_points()
# Delete everything NDB datastore
#uploader.delete_entity('raw_key')
uploader.delete_entity('meta_key')
uploader.delete_entity('eml_key')
#uploader.delete_entity('occurrence_key')
# Go back to main page
return redirect(url_for('records', datasetid=session['file_uuid']))
def upload_cartodb():
"""Parse records and upload to point table."""
if 'file_uuid' not in session.keys():
return redirect(url_for('main'))
uploader = Uploader()
# Prepare the file for CartoDB
uploader.cartodb_points()
# Delete everything NDB datastore
#uploader.delete_entity('raw_key')
uploader.delete_entity('meta_key')
uploader.delete_entity('eml_key')
#uploader.delete_entity('occurrence_key')
# Go back to main page
return redirect(url_for('records', datasetid=session['file_uuid']))
def makeUploader(self):
self.uploader = Uploader()
self.uploader.setConfig(self.conf)
self.uploader.setConnector(self.connect)
self.uploader.setAccess(self.username, self.password)
self.uploader.setWindow(self)
class ArduinoCompilerUploader:
def __init__(self, pathToMain):
#Get path on mac
if platform.system() == 'Darwin':
# logging.debug('self.pathToMain');
# logging.debug(self.pathToMain);
# logging.debug('PWD=');
# logging.debug(os.environ.get('PWD'));
#logging.debug('PYTHONPATH=');
#logging.debug(os.environ.get('PYTHONPATH'));
# logging.debug('ENVIRON=');
# logging.debug(os.environ);
if os.environ.get('PYTHONPATH') != None:
self.pathToMain = os.environ.get('PYTHONPATH')
else:
self.pathToMain = pathToMain
elif platform.system() == 'Windows' or platform.system() == 'Linux':
self.pathToMain = pathToMain
if platform.system() == 'Linux':
self.pathToSketchbook = expanduser("~").decode('latin1')+'/Arduino'
elif platform.system() == 'Windows' or platform.system() == 'Darwin':
self.pathToSketchbook = expanduser("~").decode('latin1')+'/Documents/Arduino'
self.pathToSketchbook = self.pathToSketchbook.decode('latin1')
self.pathToArduinoDir = pathToMain+'/res/arduino/'
self.uploader = Uploader(pathToMain)
self.compiler = Compiler(pathToMain)
self.boardSettings = defaultdict(BoardConfig)
self.parseBoardSettings(self.pathToMain+"/res/boards.txt")
self.board = 'uno'
self.port = None
def setBoard (self, board):
self.board = board
return self.searchPort()
def setPort (self,port=''):
self.port = port
def getPort (self):
return self.port
def getBoard(self):
return self.board
def getBoardBaudRate(self):
return self.boardSettings[self.board].getBaudRate()
def getBoardMCU(self):
return self.boardSettings[self.board].getMCU()
def getBoardFCPU(self):
return self.boardSettings[self.board].getFCPU()
def parseBoardSettings (self, path):
file=open(path,'r')
#Split the file using the separator in boards.txt to separate the config of the different boards
a = file.read().split('\n\n##############################################################\n\n');
a.pop(0) #Remove first element which is only a url
for line in a:
boardName = line.split('.')[0]
boardConfig = line.split('\n')
boardConfig= [i.split('=')for i in boardConfig]
boardConfig.pop(0) #Remove empty first element
self.boardSettings[boardName]=BoardConfig(boardConfig)
def getAvailablePorts (self):
if platform.system() =='Windows':
from serial.tools.list_ports import comports
comPorts = list(comports())
availablePorts = []
for port in comPorts:
if not 'Bluetooth' in port[1]: #discard bluetooth ports
availablePorts.append(port[0])
elif platform.system() =='Darwin':
if self.board == 'uno':
availablePorts = glob.glob('/dev/tty.usbmodem*')
elif self.board == 'bt328':
availablePorts = glob.glob('/dev/tty.usbserial-*')
else:
availablePorts = glob.glob('/dev/tty*')
elif platform.system() =='Linux':
if self.board == 'uno':
availablePorts = glob.glob('/dev/ttyACM*')
elif self.board == 'bt328':
availablePorts = glob.glob('/dev/ttyUSB*')
else:
availablePorts = glob.glob('/dev/tty*')
return availablePorts
def searchPort (self):
availablePorts = self.getAvailablePorts()
if len(availablePorts) <=0:
return []
ports = []
for port in availablePorts:
args = "-P "+port+" -p "+ self.getBoardMCU() +" -b "+ self.getBoardBaudRate()+" -c arduino"
output, err = callAvrdude(args);
if 'Device signature =' in output or 'Device signature =' in err:
ports.append(port)
if len(ports)==1:
self.setPort(ports[0])
return ports
def compile (self, code):
return self.compiler.compile( code, self.getBoard() or 'uno', self.pathToArduinoDir, self.pathToSketchbook, self.getBoardMCU(), self.getBoardFCPU())
def upload (self, code):
compilationErrorReport = self.compile(code)
if compilationErrorReport['status'] == 'OK':
uploadErrorReport = self.uploader.upload(code, self.getPort(), self.getBoard(), self.getBoardMCU(), self.getBoardBaudRate(), self.pathToMain, self.pathToSketchbook)
return uploadErrorReport
else:
return compilationErrorReport
from Analyzer import Analyzer
from Cleaner import Cleaner
from Cluster import Cluster
from Crawler import Crawler
from Uploader import Uploader
this_date = time.strftime("%Y%m%d", time.localtime())
# 爬取新闻
crawler = Crawler(this_date=this_date)
crawler.crawl()
# 聚类
cluster = Cluster(date=this_date)
cluster.remove_useless_articles()
cluster.load_articles()
cluster.cluster()
cluster.upload_groups_to_DB()
# 情绪分析
analyzer = Analyzer(date=this_date)
analyzer.analyze()
# 上传至LeanCloud
uploader = Uploader(date=this_date)
uploader.upload_new_groups()
# 删除过老或分数过低的新闻组
cleaner = Cleaner(date=this_date)
cleaner.clean()
class ArduloaderWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.portManager = PortManager(self.ui, startmonitor=True)
self.configHelper = ConfigHelper(self.ui)
self.initSignal()
self.setupUi_Ex()
def setupUi_Ex(self):
self.setWindowTitle(const.windowtitle)
self.ui.textEdit.append(const.aboutinfo)
self.ui.headLabel.setPixmap(
QPixmap(":/main/icons/main/arduloader.png"))
self.setWindowIcon(QtGui.QIcon(":/main/icons/main/logo.png"))
self.setBoards()
self.configHelper.updateUiByConfig()
def setBoards(self):
ret, self.__boardsinfodict = BoardHelper.getBoardsInfo()
if not ret:
self.__boardsinfodict = {}
return
for boardname in self.__boardsinfodict.keys():
self.ui.mcuCombox.addItem(boardname)
def onUploadFinish(self, ret, text):
self.timer.stop()
try:
res = ret == 0 and "Upload SUCCESS:)" or ("%s\nUpload FAILED:(" %
text)
except IOError:
res = "Read tmp file error"
except:
res = "Unknown error"
self.ui.textEdit.append(res)
def onUploading(self):
prev_cursor = self.ui.textEdit.textCursor()
self.ui.textEdit.moveCursor(QtGui.QTextCursor.End)
self.ui.textEdit.insertPlainText(".")
self.ui.textEdit.setTextCursor(prev_cursor)
def getUploadArgs(self):
infodict = self.__boardsinfodict.get(
tostr(self.ui.mcuCombox.currentText()))
if not infodict:
return
mcu = infodict["mcu"]
speed = infodict["speed"]
protocol = infodict["protocol"]
maximum_size = infodict["maximum_size"]
comport = tostr(self.ui.portCombox.currentText())
flash_bin = togbk(self.ui.hexfileCombox.currentText())
return {
"mcu": mcu,
"speed": speed,
"protocol": protocol,
"maximum_size": maximum_size,
"comport": comport,
"flash_bin": flash_bin
}
def checkUploadArgs(self, argsdict):
if not argsdict:
self.ui.textEdit.append("Get chip data error")
return False
if not OSPath.exists(argsdict.get("flash_bin", "")):
self.ui.textEdit.append("Hex file not exists")
return False
# TODO: 检查文件大小是否超多当前芯片允许的最大值
return True
def startUpload(self):
argsdict = self.getUploadArgs()
if not self.checkUploadArgs(argsdict):
return
self.uploader = Uploader()
self.connect(self.uploader.qobj, QtCore.SIGNAL(const.finish_sig),
self.onUploadFinish)
self.uploader.resetUploadArgs(argsdict)
self.ui.textEdit.clear()
self.ui.textEdit.append("Start uploading\n")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.onUploading)
self.uploader.start()
self.timer.start(const.process_interval)
def onOpenHexFile(self):
filename = QtGui.QFileDialog.getOpenFileName(self, "Choose a HEX file",
".", "HEX (*.hex)")
if filename == "":
return
index = self.ui.hexfileCombox.findText(filename)
if index < 0:
self.ui.hexfileCombox.insertItem(0, filename)
index = 0
self.ui.hexfileCombox.setCurrentIndex(index)
def closeEvent(self, e):
hex = tostr(self.ui.hexfileCombox.currentText())
com = tostr(self.ui.portCombox.currentText())
board = tostr(self.ui.mcuCombox.currentText())
self.configHelper.updateConfig(hex, com, board)
e.accept()
def initSignal(self):
self.ui.exitButton.clicked.connect(self.close)
self.ui.uploadButton.clicked.connect(self.startUpload)
self.ui.openHexButton.clicked.connect(self.onOpenHexFile)
class ArduloaderWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.portManager = PortManager(self.ui, startmonitor=True)
self.configHelper = ConfigHelper(self.ui)
self.initSignal()
self.setupUi_Ex()
def setupUi_Ex(self):
self.setWindowTitle(const.windowtitle)
self.ui.textEdit.append(const.aboutinfo)
self.ui.headLabel.setPixmap(QPixmap(":/main/icons/main/arduloader.png"))
self.setWindowIcon(QtGui.QIcon(":/main/icons/main/logo.png"))
self.setBoards()
self.configHelper.updateUiByConfig()
def setBoards(self):
ret, self.__boardsinfodict = BoardHelper.getBoardsInfo()
if not ret:
self.__boardsinfodict = {}
return
for boardname in self.__boardsinfodict.keys():
self.ui.mcuCombox.addItem(boardname)
def onUploadFinish(self, ret, text):
self.timer.stop()
try:
res = ret == 0 and "Upload SUCCESS:)" or ("%s\nUpload FAILED:(" % text)
except IOError:
res = "Read tmp file error"
except:
res = "Unknown error"
self.ui.textEdit.append(res)
def onUploading(self):
prev_cursor = self.ui.textEdit.textCursor()
self.ui.textEdit.moveCursor(QtGui.QTextCursor.End)
self.ui.textEdit.insertPlainText (".")
self.ui.textEdit.setTextCursor(prev_cursor)
def getUploadArgs(self):
infodict = self.__boardsinfodict.get(tostr(self.ui.mcuCombox.currentText()))
if not infodict:
return
mcu = infodict["mcu"]
speed = infodict["speed"]
protocol = infodict["protocol"]
maximum_size = infodict["maximum_size"]
comport = tostr(self.ui.portCombox.currentText())
flash_bin = togbk(self.ui.hexfileCombox.currentText())
return {"mcu": mcu,
"speed": speed,
"protocol": protocol,
"maximum_size": maximum_size,
"comport": comport,
"flash_bin": flash_bin
}
def checkUploadArgs(self, argsdict):
if not argsdict:
self.ui.textEdit.append("Get chip data error")
return False
if not OSPath.exists(argsdict.get("flash_bin", "")):
self.ui.textEdit.append("Hex file not exists")
return False
# TODO: 检查文件大小是否超多当前芯片允许的最大值
return True
def startUpload(self):
argsdict = self.getUploadArgs()
if not self.checkUploadArgs(argsdict):
return
self.uploader = Uploader()
self.connect(self.uploader.qobj, QtCore.SIGNAL(const.finish_sig), self.onUploadFinish)
self.uploader.resetUploadArgs(argsdict)
self.ui.textEdit.clear()
self.ui.textEdit.append("Start uploading\n")
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.onUploading)
self.uploader.start()
self.timer.start(const.process_interval)
def onOpenHexFile(self):
filename = QtGui.QFileDialog.getOpenFileName(self, "Choose a HEX file", ".", "HEX (*.hex)")
if filename == "":
return
index = self.ui.hexfileCombox.findText(filename)
if index < 0:
self.ui.hexfileCombox.insertItem(0, filename)
index = 0
self.ui.hexfileCombox.setCurrentIndex(index)
def closeEvent(self, e):
hex = tostr(self.ui.hexfileCombox.currentText())
com = tostr(self.ui.portCombox.currentText())
board = tostr(self.ui.mcuCombox.currentText())
self.configHelper.updateConfig(hex, com, board)
e.accept()
def initSignal(self):
self.ui.exitButton.clicked.connect(self.close)
self.ui.uploadButton.clicked.connect(self.startUpload)
self.ui.openHexButton.clicked.connect(self.onOpenHexFile)
print(e)
position = Position()
position.fix()
filename = BoatImage().click(position)
voltages = Voltages()
voltages = voltages.read_voltages()
gyro = Gyro()
x_angle = gyro.get_x_degrees()
temperature = gyro.get_temperature()
tide = Tide()
tide_height = tide.current_height()
uploader = Uploader(bucket_name)
uploader.download_json()
disk_usage = Disk.current_usage()
state = State(position, voltages, filename, x_angle, temperature, tide_height,
disk_usage)
state.save()
uploader.upload_json()
if filename is not None:
uploader.upload_image(filename)
from flask import Flask, render_template, Response, request, flash
from Camera import Camera
from Database import Database
from Face import Face
from Uploader import Uploader
app = Flask(__name__)
app.secret_key = "aaaaaaa"
UPLOAD_FOLDER = "."
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
db = Database()
face = Face(db)
cam = Camera(0, face)
uploader = Uploader(app, UPLOAD_FOLDER)
@app.route("/")
def index():
return render_template("index.html")
@app.route("/video_feed")
def video_feed():
return Response(cam.stream(scale=0.3),
mimetype="multipart/x-mixed-replace; boundary=frame")
@app.route("/register", methods=["GET", "POST"])
def register():
class Mytago ( wxFrame ):
def __init__ ( self ):
wxFrame.__init__ ( self, None, -1, 'MYTAGO Uploader', size = ( 600, 445 ),
style = wx.DEFAULT_FRAME_STYLE ^ ( wx.MAXIMIZE_BOX | wx.RESIZE_BORDER ) )
self.SetBackgroundColour("WHITE")
self.TESTING = False
self.username = ''
self.password = ''
wx.lib.colourdb.updateColourDB()
_icon = wx.IconFromBitmap(getAppIcon())
self.SetIcon(_icon)
self.panel = wxPanel ( self, -1, size=(580, 50) )
self.panel.SetBackgroundColour('WHITE')
self.addbutton = wxButton ( self.panel, -1, "+" )
self.Bind(wx.EVT_BUTTON, self.OnAddButton, self.addbutton)
self.addbutton.SetForegroundColour('CHARTREUSE2')
self.addbutton.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
self.addbutton.SetMaxSize((30,30))
self.addbutton.SetMinSize((30,30))
self.addbutton.SetToolTipString("Add Images")
self.delbutton = wxButton ( self.panel, -1, "-" )
self.Bind(wx.EVT_BUTTON, self.OnDelButton, self.delbutton)
self.delbutton.Enable(False)
self.delbutton.SetForegroundColour('ORANGE1')
self.delbutton.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
self.delbutton.SetMaxSize((30,30))
self.delbutton.SetMinSize((30,30))
self.delbutton.SetToolTipString("Remove Selected Images")
self.progpanel = wxPanel(self, -1, size=(565, 10) )
self.progpanel.SetBackgroundColour('GREY70')
self.progress = wx.Gauge(self.progpanel, -1, 50, size =(565, 10))
self.progress.Show(False)
self.upbutton = wxButton ( self.panel, -1, "Upload" )
self.Bind(wx.EVT_BUTTON, self.OnUpButton, self.upbutton)
self.upbutton.Enable(False)
self.upbutton.SetForegroundColour('GREY30')
self.upbutton.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
self.upbutton.SetMaxSize((120,30))
self.upbutton.SetMinSize((120,30))
self.upbutton.SetToolTipString("Upload Images")
self.helpbutton = wxButton ( self.panel, -1, "i" )
self.Bind(wx.EVT_BUTTON, self.OnHelpButton, self.helpbutton)
self.helpbutton.SetForegroundColour('DEEPSKYBLUE')
self.helpbutton.SetFont(wx.Font(15, wx.SWISS, wx.NORMAL, wx.BOLD, False))
self.helpbutton.SetMaxSize((30,30))
self.helpbutton.SetMinSize((30,30))
self.helpbutton.SetToolTipString("Help")
self.imgpanel = scrolled.ScrolledPanel(self, -1, size=(560, 290),
style = wx.TAB_TRAVERSAL|wx.NO_BORDER, name="imgpanel" )
self.imgpanel.SetBackgroundColour("WHITE")
logo = getAppLogo()
if not self.TESTING:
self.logoimg = wx.StaticBitmap(self.panel, -1, logo)
self.scrollsizer = wx.FlexGridSizer(rows=1, cols=3, vgap=10, hgap=10)
self.imgpanel.SetSizer( self.scrollsizer )
self.imgpanel.SetAutoLayout(1)
self.imgpanel.SetupScrolling()
self.footer = wxPanel ( self, -1, size=(580, 20) )
self.footer.SetBackgroundColour("WHITE")
self.message = wx.StaticText(self.footer, -1, "", size = (450, 10))
font = wx.Font(8, wx.SWISS, wx.NORMAL, wx.BOLD)
self.message.SetFont(font)
self.hyper1 = hl.HyperLinkCtrl(self.footer, wx.ID_ANY, "www.mytago.com",
URL="http://www.mytago.com")
self.hyper1.SetBold(True)
self.hyper1.SetColours("STEELBLUE1", "STEELBLUE1", "STEELBLUE1")
self.hyper1.SetUnderlines(False, False, False)
self.hyper1.SetToolTip(wx.ToolTip("Mytago"))
self.hyper1.UpdateLink()
self.sizertop = wxBoxSizer ( wxALIGN_CENTER_HORIZONTAL )
self.sizerbot = wxBoxSizer ( wxALIGN_CENTER_HORIZONTAL )
self.sizermain = wxBoxSizer ( wx.VERTICAL )
self.sizertop.Add ( (10, 40), 0, wx.EXPAND )
if self.TESTING:
self.sizertop.Add ( (230, 40), 0, wx.ALIGN_TOP | wx.EXPAND )
else:
self.sizertop.Add ( self.logoimg, 0, wx.ALIGN_TOP | wx.EXPAND )
self.sizertop.Add ( (100, 40), 0, wx.EXPAND )
self.sizertop.Add ( self.addbutton, 0 )
self.sizertop.Add ( (5, 40), 0, wx.EXPAND )
self.sizertop.Add ( self.delbutton, 0 )
self.sizertop.Add ( (15, 40), 0, wx.EXPAND )
self.sizertop.Add ( self.upbutton, 0)
self.sizertop.Add ( (10, 40), 0, wx.EXPAND )
self.sizertop.Add ( self.helpbutton, 0)
self.sizerbot.Add ( (15, 10), 0, wx.EXPAND )
self.sizerbot.Add ( self.message, 0, wx.ALIGN_LEFT | wx.EXPAND )
self.sizerbot.Add ( (10, 10), 0, wx.EXPAND )
self.sizerbot.Add ( self.hyper1, 0, wx.ALIGN_RIGHT | wx.EXPAND )
self.sizerbot.Add ( (15, 10), 0, wx.EXPAND )
self.sizermain.Add ((600, 10) )
self.sizermain.Add ( self.panel, 0, wx.EXPAND | wx.FIXED_MINSIZE )
self.sizermain.Add ((600, 10) )
self.sizermain.Add ( self.progpanel, 0, wx.ALIGN_CENTER | wx.FIXED_MINSIZE )
self.sizermain.Add ((600, 10) )
self.sizermain.Add ( self.imgpanel, 0, wx.ALIGN_CENTER | wx.FIXED_MINSIZE )
self.sizermain.Add ((600, 5) )
self.sizermain.Add ( wx.StaticLine(self, -1, size=(565,-1)), 0, wx.TOP | wx.ALIGN_CENTER | wx.FIXED_MINSIZE )
self.sizermain.Add ((600, 5) )
self.sizermain.Add ( self.footer, 0, wx.EXPAND | wx.FIXED_MINSIZE )
self.sizermain.Add ((600, 5) )
self.panel.SetSizer ( self.sizertop )
self.footer.SetSizer ( self.sizerbot )
self.SetSizer(self.sizermain)
self.Show ( True )
self.maskimg = getMask()
self.lastsel = None
self.lastdesel = None
self.shifted = False
self.delimglist = []
self.pathlist = []
self.upimglist = []
self.upcount = 0
self.lastupcount = -1
self.uploading = False
self.cancelnow = False
# Catch all shift key presses
self.panel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown, self.panel)
self.panel.Bind(wx.EVT_KEY_UP, self.OnKeyUp, self.panel)
self.imgpanel.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown, self.imgpanel)
self.imgpanel.Bind(wx.EVT_KEY_UP, self.OnKeyUp, self.imgpanel)
self.footer.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown, self.footer)
self.footer.Bind(wx.EVT_KEY_UP, self.OnKeyUp, self.footer)
def initConfig(self):
self.conf = Config()
if self.TESTING:
self.conf.setAPI('http://localhost/api')
self.message.SetForegroundColour('ROYALBLUE1')
self.message.SetLabel("checking network connection...")
def connectLogin(self):
self.connect = Connect()
self.connect.setConfig(self.conf)
wx.BeginBusyCursor()
if self.connect.testConnect():
wx.EndBusyCursor()
self.message.SetForegroundColour('ROYALBLUE1')
self.message.SetLabel("network connected please login")
self.tryLogin()
else:
wx.EndBusyCursor()
self.message.SetForegroundColour(wxNamedColour('ORANGE1'))
self.message.SetLabel("network failed. please try proxy")
self.proxy = ProxyDialog(self)
keeptrying = True
while keeptrying:
if self.proxy.showProxy(self):
self.connect.setProxy(self.proxy.getProxyServer() + ':' + self.proxy.getProxyPort())
wx.BeginBusyCursor()
window.message.SetForegroundColour('ROYALBLUE1')
window.message.SetLabel("checking network connection...")
if self.connect.testConnect():
wx.EndBusyCursor()
self.message.SetForegroundColour('ROYALBLUE1')
self.message.SetLabel("network connected. please login")
if self.tryLogin():
keeptrying = False
else:
wx.EndBusyCursor()
self.message.SetForegroundColour(wxNamedColour('ORANGE1'))
if len(self.proxy.getProxyServer()) > 0: #FIXME add proper check
self.message.SetLabel("proxy failed. please try again")
else:
self.message.SetLabel("network failed. please try proxy")
else:
self.Destroy()
sys.exit(0)
def tryLogin(self):
wx.SafeYield()
login = LoginDialog(self)
if login.showLogin(self):
self.username = login.getUser()
self.password = login.getPassword()
self.updateMessage()
return True
else:
self.Destroy()
sys.exit(0)
def makeUploader(self):
self.uploader = Uploader()
self.uploader.setConfig(self.conf)
self.uploader.setConnector(self.connect)
self.uploader.setAccess(self.username, self.password)
self.uploader.setWindow(self)
def showUploadFailedMessage(self):
self.message.SetForegroundColour('ORANGE1')
if self.connect.getError() == '105' :
self.showMessage( 'upload limit reached, ' + `len(self.upimglist)` + ' image(s) left to upload')
elif self.connect.getError() == '106' :
self.showMessage( 'server is busy, ' + `len(self.upimglist)` + ' image(s) left to upload')
elif len(self.upimglist) == 1:
self.showMessage( 'upload failed, ' + `len(self.upimglist)` + ' image left to upload')
elif len(self.upimglist) > 1:
self.showMessage( 'upload failed, ' + `len(self.upimglist)` + ' images left to upload')
else:
self.message.SetForegroundColour('GREY30')
def showMessage(self, msg):
self.message.SetForegroundColour('STEELBLUE1')
if len(self.username) < 33: # prevent long username to overflow footer space
self.message.SetLabel( self.username + ' | ' + msg )
else:
self.message.SetLabel( msg )
def updateMessage(self):
if len(self.upimglist) == 1:
self.showMessage( `len(self.upimglist)` + ' image ready for upload')
elif len(self.upimglist) > 1:
self.showMessage( `len(self.upimglist)` + ' images ready for upload')
else:
self.showMessage( 'please add images to upload')
def addImages(self, dlg):
try:
paths = dlg.GetPaths()
self.conf.setLastPath(dlg.GetDirectory())
wx.BeginBusyCursor()
wx.Yield()
self.panel.Update()
#self.progress.Show(True)
#self.progress.SetRange( len(paths) )
i = 0
if len(paths) > 0:
tilesize = self.conf.tileSize()
for path in paths:
i += 1
self.progress.SetValue(i)
if path in self.pathlist:
if self.conf.debug: print "Skip: %s" % path
else:
if self.conf.debug: print "Adding: %s" % path
self.showMessage('adding image ' + str(i) + ' of ' + `len(paths)`)
self.pathlist.append(path)
img = wx.Image(path, wx.BITMAP_TYPE_ANY)
imgtile = self.conf.imgSize(img.GetWidth(), img.GetHeight())
nw = imgtile[0]
nh = imgtile[1]
if nh and nw:
img.Rescale(nw,nh)
sizedimg = img.ConvertToBitmap()
self.imgbutton = buttons.GenBitmapToggleButton( self.imgpanel, -1, None, size=tilesize )
self.imgbutton.SetToolTipString(path);
self.imgbutton.SetBitmapLabel(sizedimg);
self.maskimg.Rescale(nw,nh)
maskbmp = self.maskimg.ConvertToBitmap()
mask = wx.Mask(maskbmp, wx.BLACK)
sizedimgtoggle = img.ConvertToBitmap()
sizedimgtoggle.SetMask(mask);
self.imgbutton.SetBitmapSelected(sizedimgtoggle)
self.imgbutton.SetBackgroundColour("WHITE")
#self.scrollsizer.Add( self.imgbutton )
#self.upimglist.append(self.imgbutton)
self.scrollsizer.Prepend(self.imgbutton)
self.upimglist.insert(0, self.imgbutton)
self.Bind(wx.EVT_BUTTON, self.OnImgButton, self.imgbutton)
self.imgbutton.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown, self.imgbutton)
self.imgbutton.Bind(wx.EVT_KEY_UP, self.OnKeyUp, self.imgbutton)
#redraw
wx.Yield()
#self.scrollsizer.Layout()
#self.imgpanel.Layout()
self.imgpanel.SetupScrolling()
#self.imgpanel.Refresh()
self.imgpanel.Update()
self.upbutton.Enable(True) #if its disabled by delbutton
#self.progress.SetRange(0)
#self.progress.Show(False)
self.scrollsizer.Layout()
self.imgpanel.Layout()
self.imgpanel.SetupScrolling()
self.imgpanel.Refresh()
self.imgpanel.Update()
self.panel.Update()
wx.EndBusyCursor()
except:
self.upbutton.Enable(True)
#self.imgpanel.Show(True)
self.progress.SetRange(0)
self.progress.Show(False)
self.imgpanel.SetupScrolling()
self.imgpanel.Update()
self.panel.Update()
wx.EndBusyCursor()
# All event handler functions
def OnResult(self, event): # Gets events triggered from Uploader->Worker Thread
if event.data is None:
self.upimglist = self.upimglist[self.upcount:] #slice out uploaded
self.uploader.closeThread()
if self.cancelnow:
self.postUpload(False)
else:
self.postUpload(True)
elif event.data == 0:
self.uploader.closeThread()
self.postUpload(False)
else:
count = int(event.data) - 1
if(count == self.lastupcount):
button = self.upimglist[count]
self.showMessage('uploading image ' + str(count+1) + ' of ' + `len(self.upimglist)`)
self.progress.SetValue((count*2)+2)
self.scrollsizer.Remove(button)
self.pathlist.remove(button.GetToolTip().GetTip()) #clear pathlist
button.Destroy()
self.scrollsizer.Layout()
self.imgpanel.Layout()
self.imgpanel.Refresh()
self.imgpanel.Update()
self.upcount += 1
else: #hack for progess update using same event
self.progress.SetValue((count*2)+1)
self.lastupcount = count
def OnAddButton(self, event):
wildcard = "All Supported Images|*.gif;*.jpg;*.jpeg;*.png|" \
"JPEG Images|*.jpg;*jpeg|" \
"GIF Images|*.gif|" \
"PNG Images|*.png"
dlg = wx.FileDialog(
self, message="Choose Images", defaultDir=self.conf.getLastPath(),
defaultFile="", wildcard=wildcard, style=wx.OPEN | wx.MULTIPLE | wx.CHANGE_DIR)
if dlg.ShowModal() == wx.ID_OK:
self.imgpanel.Enable(False)
self.imgpanel.Refresh()
self.imgpanel.Update()
self.addbutton.Enable(False)
self.upbutton.Enable(False)
self.delbutton.Enable(False)
self.addImages(dlg)
self.addbutton.Enable(True)
self.upbutton.Enable(True)
if len(self.delimglist) > 0:
self.delbutton.Enable(True)
self.imgpanel.Enable(True)
self.imgpanel.Refresh()
self.imgpanel.Update()
self.updateMessage()
dlg.Destroy()
def OnDelButton(self, event):
for button in self.delimglist:
if self.conf.debug: print "Removing: %s" % button.GetToolTip().GetTip()
self.scrollsizer.Detach(button)
self.pathlist.remove(button.GetToolTip().GetTip()) #clear pathlist
self.upimglist.remove(button)
button.Destroy()
#redraw
wx.Yield()
self.scrollsizer.Layout()
self.imgpanel.Layout()
self.imgpanel.Refresh()
self.imgpanel.Update()
self.imgpanel.SetupScrolling()
self.delimglist = []
if len(self.pathlist) > 0:
self.upbutton.Enable(True)
if not len(self.delimglist):
self.delbutton.Enable(False)
else:
self.upbutton.Enable(False)
self.delbutton.Enable(False)
self.updateMessage()
def OnUpButton(self, event):
connectionbroke = False
self.scrollsizer.Layout()
self.imgpanel.Layout()
self.imgpanel.SetupScrolling()
self.imgpanel.Enable(False)
self.imgpanel.Refresh()
self.imgpanel.Update()
if self.uploading:
if self.conf.debug: print "Cancel"
self.cancelnow = True
self.uploading = False
self.upbutton.Enable(False)
self.showMessage('cancelling upload..')
self.uploader.abortUpload()
else:
for b in self.upimglist: # reset selected for delete
b.SetBackgroundColour("WHITE")
b.SetValue(False)
self.upbutton.SetLabel("Cancel")
self.upbutton.SetToolTipString("Cancel Upload")
self.addbutton.Enable(False)
self.delbutton.Enable(False)
self.progress.Show(True)
self.progress.SetRange(len(self.upimglist) * 2)
self.upcount = 0
self.lastupcount = -1
self.uploading = True
self.showMessage('starting upload...')
self.uploader.uploadFiles(self.upimglist)
def postUpload(self, connectionbroke):
if self.cancelnow:
self.cancelnow = False
elif len(self.upimglist) == self.upcount:
self.upimglist = [] # all uploaded
else:
self.upimglist = self.upimglist[self.upcount:] #slice out uploaded
if len(self.upimglist) > 0: # upload cancelled in middle
for button in self.upimglist:
button.Update()
self.upbutton.Enable(True)
else:
self.upbutton.Enable(False)
#reset control flags
self.uploading = False
self.upcount = 0
self.delimglist = [] #always reset delete list once in upload
self.upbutton.SetLabel("Upload")
self.upbutton.SetToolTipString("Upload Images")
self.upbutton.Enable(True)
self.addbutton.Enable(True)
self.progress.SetRange(0)
self.progress.Enable(False)
self.imgpanel.Enable(True)
self.scrollsizer.Layout()
self.imgpanel.Layout()
self.imgpanel.SetupScrolling()
self.imgpanel.Refresh()
self.imgpanel.Update()
if connectionbroke:
self.showUploadFailedMessage()
else:
self.updateMessage()
def OnImgButton(self, event):
self.delbutton.Enable(True)
button = event.GetEventObject()
if button in self.delimglist:
self.delimglist.remove(button)
button.SetBackgroundColour("WHITE")
self.multiDesel(button)
self.lastdesel = button
self.lastsel = None
else:
self.delimglist.append(button)
button.SetBackgroundColour("ORANGE1")
self.multiSel(button)
self.lastsel = button
self.lastdesel = None
if len(self.delimglist) > 0:
self.delbutton.Enable(True)
else:
self.delbutton.Enable(False)
self.updateMessage()
def multiDesel(self, button):
if not self.shifted:
return
if self.lastdesel == None:
return
if not self.lastdesel in self.upimglist:
return
x = self.upimglist.index(self.lastdesel)
y = self.upimglist.index(button)
if x < 0 or y < 0:
return
if x < y:
start = x
end = y
else:
start = y
end = x
for i in range(len(self.upimglist)):
if i > start and i < end:
b = self.upimglist[i]
if b in self.delimglist: # safe remove
self.delimglist.remove(b)
b.SetBackgroundColour("WHITE")
b.SetValue(False)
b.Update()
wx.Yield()
self.imgpanel.Refresh()
self.imgpanel.Update()
def multiSel(self, button):
if not self.shifted:
return
if self.lastsel == None:
return
if not self.lastsel in self.upimglist:
return
x = self.upimglist.index(self.lastsel)
y = self.upimglist.index(button)
if x < 0 or y < 0:
return
if x < y:
start = x
end = y
else:
start = y
end = x
for i in range(len(self.upimglist)):
if i > start and i < end:
b = self.upimglist[i]
if not b in self.delimglist: # safe append
self.delimglist.append(b)
b.SetBackgroundColour("ORANGE1")
b.SetValue(True)
b.Update()
wx.Yield()
self.imgpanel.Refresh()
self.imgpanel.Update()
def OnHelpButton(self, event):
about = AboutDialog(self)
about.showAbout(self.conf.version)
about.Destroy()
def OnKeyDown(self, evt):
if evt.GetKeyCode() == wx.WXK_SHIFT:
self.shifted = True
def OnKeyUp(self, evt):
if evt.GetKeyCode() == wx.WXK_SHIFT:
self.shifted = False
def proc(config: dict, record_dir: str, danmu_path: str) -> None:
p = Processor(config, record_dir, danmu_path)
p.run()
u = Uploader(p.outputs_dir, p.splits_dir, config)
u.upload(p.global_start)
class ArduinoCompilerUploader:
def __init__(self, pathToMain):
self.pathToSketchbook = ""
# Get path on mac
if platform.system() == "Darwin":
# logging.debug('self.pathToMain');
# logging.debug(self.pathToMain);
# logging.debug('PWD=');
# logging.debug(os.environ.get('PWD'));
# logging.debug('PYTHONPATH=');
# logging.debug(os.environ.get('PYTHONPATH'));
# logging.debug('ENVIRON=');
# logging.debug(os.environ);
if os.environ.get("PYTHONPATH") != None:
self.pathToMain = os.environ.get("PYTHONPATH")
else:
self.pathToMain = pathToMain
elif platform.system() == "Windows" or platform.system() == "Linux":
self.pathToMain = pathToMain
if platform.system() == "Linux":
self.pathToSketchbook = expanduser("~").decode("latin1") + "/Arduino"
elif platform.system() == "Darwin":
self.pathToSketchbook = base.sys_path.get_document_path() + "/Arduino"
elif platform.system() == "Windows":
self.pathToSketchbook = (
os.path.dirname(os.path.dirname(os.path.dirname(base.sys_path.get_tmp_path()))) + "/Documents/Arduino"
)
self.pathToArduinoDir = pathToMain + "/res/arduino/"
self.uploader = Uploader(pathToMain)
self.compiler = Compiler(pathToMain)
self.boardSettings = defaultdict(BoardConfig)
self.parseBoardSettings(self.pathToMain + "/res/boards.txt")
self.board = "uno"
self.port = None
def setBoard(self, board):
self.board = board
return self.searchPort()
def setPort(self, port=""):
self.port = port
def getPort(self):
return self.port
def getBoard(self):
return self.board
def getBoardBaudRate(self):
return self.boardSettings[self.board].getBaudRate()
def getBoardMCU(self):
return self.boardSettings[self.board].getMCU()
def getBoardFCPU(self):
return self.boardSettings[self.board].getFCPU()
def parseBoardSettings(self, path):
file = open(path, "r")
# Split the file using the separator in boards.txt to separate the config of the different boards
a = file.read().split("\n\n##############################################################\n\n")
a.pop(0) # Remove first element which is only a url
for line in a:
boardName = line.split(".")[0]
boardConfig = line.split("\n")
boardConfig = [i.split("=") for i in boardConfig]
boardConfig.pop(0) # Remove empty first element
self.boardSettings[boardName] = BoardConfig(boardConfig)
def getAvailablePorts(self):
availablePorts = []
if platform.system() == "Windows":
from serial.tools.list_ports import comports
comPorts = list(comports())
for port in comPorts:
if not "Bluetooth" in port[1]: # discard bluetooth ports
availablePorts.append(port[0])
elif platform.system() == "Darwin":
darwinPorts = glob.glob("/dev/tty.*")
for port in darwinPorts:
if not "Bluetooth" in port: # discard bluetooth ports
availablePorts.append(port)
elif platform.system() == "Linux":
availablePorts = glob.glob("/dev/ttyACM*")
availablePorts += glob.glob("/dev/ttyUSB*")
return availablePorts
def searchPort(self):
availablePorts = self.getAvailablePorts()
if len(availablePorts) <= 0:
return []
ports = []
for port in availablePorts:
args = "-P " + port + " -p " + self.getBoardMCU() + " -b " + self.getBoardBaudRate() + " -c arduino"
output, err = callAvrdude(args)
if "Device signature =" in output or "Device signature =" in err:
ports.append(port)
if len(ports) == 1:
self.setPort(ports[0])
return ports
def compile(self, code):
return self.compiler.compile(
code,
self.getBoard() or "uno",
self.pathToArduinoDir,
self.pathToSketchbook,
self.getBoardMCU(),
self.getBoardFCPU(),
)
def upload(self, code):
compilationErrorReport = self.compile(code)
if compilationErrorReport["status"] == "OK":
uploadErrorReport = self.uploader.upload(
code,
self.getPort(),
self.getBoard(),
self.getBoardMCU(),
self.getBoardBaudRate(),
self.pathToMain,
self.pathToSketchbook,
)
return uploadErrorReport
else:
return compilationErrorReport
def main():
logger.info('Starting')
every = 1
#Map of used pins
pins = {'data': 15, 'enable': 18}
try:
state = {}
try:
tmp = json.loads(open('status.txt', 'r').read())
#if is not passed midnight or aren't elapsed 10 mins, restore the state
now = localtime()
if tmp['timestamp'][2] == now.tm_mday and (
now.tm_hour * 60 + now.tm_min) - (
tmp['timestamp'][3] * 60 + tmp['timestamp'][4]) <= 10:
logger.info('Restored previous state')
state = tmp
except Exception:
pass
#Create threads
v = VentusDecoder(pins['data'], pins['enable'], logger, state)
uploader = Uploader(HTTP_ENDPOINT, 'weather.db', logger)
#Create thread exit handler
def close(signum=None, frame=None, exitcode=0):
v.stop()
#Save current state
state = v.serialize()
state['timestamp'] = localtime()
with open('status.txt', 'w') as f:
f.write(json.dumps(state))
uploader.stop()
logger.info('Quitted safely')
sys.exit(exitcode)
#for systemd exit
signal.signal(signal.SIGINT, close)
signal.signal(signal.SIGTERM, close)
#Start threads
v.start()
uploader.start()
start = time()
#Wait until is ready
while not v.isReady() and v.is_alive() and uploader.is_alive():
sleep(1)
if v.isReady():
logger.info('Checking completed!')
lastUpdateMin = 60 #impossible minute
#Upload every x minutes
while v.is_alive() and uploader.is_alive():
nowMin = localtime().tm_min
if lastUpdateMin != nowMin and nowMin % every == 0:
data = v.getData()
data['timestamp'] = datetime.now().strftime(
'%Y-%m-%d %H:%M:00')
uploader.push(data)
lastUpdateMin = nowMin
sleep(1)
logger.info('Quitting for thread death!')
close(exitcode=1)
except (KeyboardInterrupt, SystemExit) as e:
sys.exit()
except Exception as e:
logger.info('Exception : ' + str(e))
raise
def getUploadedFiles(): fileManager = FileManager(args=[None, None, None]) demoPathAttributes = fileManager.getAttributes() uploader = Uploader(demoPathAttributes)
