def exportSelectedNodes(self, output):
progress = ProgressBar("Exporting data...", self.mainWindow)
#indexes = self.mainWindow.tree.selectionModel().selectedRows()
#if child nodes should be exported as well, uncomment this line an comment the previous one
indexes = self.mainWindow.tree.selectedIndexesAndChildren()
indexes = list(indexes)
progress.setMaximum(len(indexes))
try:
delimiter = self.optionSeparator.currentText()
delimiter = delimiter.encode('utf-8').decode('unicode_escape')
writer = csv.writer(output,
delimiter=delimiter,
quotechar='"',
quoting=csv.QUOTE_ALL,
doublequote=True,
lineterminator='\r\n')
#headers
row = [
str(val)
for val in self.mainWindow.tree.treemodel.getRowHeader()
]
if self.optionLinebreaks.isChecked():
row = [
val.replace('\n', ' ').replace('\r', ' ') for val in row
]
row = ['path'] + row
writer.writerow(row)
#rows
path = []
for index in indexes:
if progress.wasCanceled:
break
# data
rowdata = self.mainWindow.tree.treemodel.getRowData(index)
# path of parents (#2=level;#3=object ID)
while rowdata[2] < len(path):
path.pop()
path.append(rowdata[3])
# values
row = [str(val) for val in rowdata]
row = ["/".join(path)] + row
if self.optionLinebreaks.isChecked():
row = [
val.replace('\n', ' ').replace('\r', ' ')
for val in row
]
writer.writerow(row)
progress.step()
finally:
progress.close()
def clipboardNodes(self):
progress = ProgressBar("Copy to clipboard", self.mainWindow)
indexes = self.mainWindow.tree.selectionModel().selectedRows()
progress.setMaximum(len(indexes))
output = io.StringIO()
try:
writer = csv.writer(output, delimiter='\t', quotechar='"', quoting=csv.QUOTE_ALL, doublequote=True,
lineterminator='\r\n')
#headers
row = [str(val) for val in self.mainWindow.tree.treemodel.getRowHeader()]
writer.writerow(row)
#rows
for no in range(len(indexes)):
if progress.wasCanceled:
break
row = [str(val) for val in self.mainWindow.tree.treemodel.getRowData(indexes[no])]
writer.writerow(row)
progress.step()
clipboard = QApplication.clipboard()
clipboard.setText(output.getvalue())
finally:
output.close()
progress.close()
def create_widgets(self):
""" Setup the widgets for the solver window """
tk.Label(self,
text=self.solver.cipher_name + " - Guess Decryption Key",
**TITLE_LABEL_OPTIONS).grid(row=0, column=0)
# back button
tk.Button(self, text="Back", command=self.go_back).grid(row=0,
column=1,
sticky="NE")
# stop button
self.stop_button = tk.Button(self,
text="Stop",
command=self.stop_solver)
self.stop_button.grid(row=3, column=1, sticky="NE")
# progress bar
tk.Label(self, text="Progress",
**SUBTITLE_LABEL_OPTIONS).grid(row=3, column=0)
self.progress_bar = ProgressBar(self)
self.progress_bar.grid(row=4, column=0, sticky="NSEW")
# set the first column to be expandable
self.grid_columnconfigure(0, weight=1)
# setup the output scroll frame
tk.Label(self, text="Outputs", **SUBTITLE_LABEL_OPTIONS).grid(row=1,
column=0)
self.outputs_scroll_frame = ScrollFrame(self)
self.outputs_scroll_frame.grid(row=2, column=0, sticky="NSEW")
self.outputs_inner_frame = self.outputs_scroll_frame.inner_frame
# setup headings in the output scroll frame
tk.Label(self.outputs_inner_frame, text="Score").grid(row=0,
column=0,
padx=10)
tk.Label(self.outputs_inner_frame,
text="Decryption Key").grid(row=0, column=1, padx=10)
tk.Label(self.outputs_inner_frame, text="Text").grid(row=0, column=2)
def __init__(self, screen_manager, keyboard_manager, disp):
super(ContrastScreen, self).__init__(screen_manager, keyboard_manager)
self._disp = disp
self._contrast = 0xCF # initial value from SSD1306.py
self._pbar = ProgressBar((0, 25), (128, 14), 255)
self._pbar.set_value(0xCF)
font = fonts.DEFAULT_FONT_12
self._label = ScrollingText((25, 5), (100, 15), font, 'Contrast')
def __init__(self, screen_manager, keyboard_manager, client, status_screen, volmgr):
super(MainScreen, self).__init__(screen_manager, keyboard_manager)
self._client = client
self._status_screen = status_screen
self._volmgr = volmgr
font = fonts.DEFAULT_FONT_14
self._status = PlayingWidget((0, 0), (9, 9))
self._seekbar = ProgressBar((24, 1), (128 - 24, 7), 100)
self._artist = ScrollingText((0, 12), (128, 16), font, u'')
self._title = ScrollingText((0, 32), (128, 16), font, u'')
self._volume = ProgressBar((0, 54), (128, 7), 100)
self._play_list_screen = PlayListsScreen(screen_manager, keyboard_manager, client)
self._last_update = time.time()
def addCsv(self, filename, updateProgress=None):
progress = ProgressBar("Adding nodes...", self.mainWindow)
try:
with open(filename, encoding="UTF-8-sig") as csvfile:
rows = csv.DictReader(csvfile, delimiter=';', quotechar='"', doublequote=True)
self.mainWindow.tree.treemodel.addSeedNodes(rows, progress=updateProgress)
self.mainWindow.tree.selectLastRow()
self.mainWindow.tree.selectLastRow()
finally:
progress.close()
def exportAllNodes(self,output):
progress = ProgressBar("Exporting data...", self.mainWindow)
progress.setMaximum(Node.query.count())
try:
delimiter = self.optionSeparator.currentText()
delimiter = delimiter.encode('utf-8').decode('unicode_escape')
writer = csv.writer(output, delimiter=delimiter, quotechar='"',
quoting=csv.QUOTE_ALL, doublequote=True,
lineterminator='\r\n')
# Headers
row = ["level", "id", "parent_id", "object_id", "object_type","object_key",
"query_status", "query_time", "query_type"]
for key in extractNames(self.mainWindow.tree.treemodel.customcolumns):
row.append(key)
if self.optionLinebreaks.isChecked():
row = [val.replace('\n', ' ').replace('\r',' ') for val in row]
writer.writerow(row)
# Rows
page = 0
while not progress.wasCanceled:
allnodes = Node.query.offset(page * 5000).limit(5000)
if allnodes.count() == 0:
break
for node in allnodes:
if progress.wasCanceled:
break
row = [node.level, node.id, node.parent_id, node.objectid,
node.objecttype,getDictValue(node.queryparams,'nodedata'),
node.querystatus, node.querytime, node.querytype]
for key in self.mainWindow.tree.treemodel.customcolumns:
row.append(node.getResponseValue(key)[1])
if self.optionLinebreaks.isChecked():
row = [str(val).replace('\n', ' ').replace('\r',' ') for val in row]
writer.writerow(row)
# Step the bar
progress.step()
page += 1
finally:
progress.close()
def __init__(self, screen_manager, keyboard_manager, contrast_screen):
super(WidgetsTestScreen, self).__init__(screen_manager,
keyboard_manager)
font = fonts.DEFAULT_FONT_12
self._val = 0
self._pbar = ProgressBar((0, 30), (40, 10), 100)
self._tlist = TextList((45, 5), (80, 55), font, "no playlists")
self._tlist.set_draw_border(True)
self._tlist.set_items([
"one one one one", "two two two two", "three three three three",
"four", "five"
])
self._stext = ScrollingText((0, 0), (40, 20), font, u'Hello::Привет!')
self._stext.set_invert(True)
self._status = PlayingWidget((5, 45), (15, 15))
# self._status.set_draw_border(True)
self._contrast_screen = contrast_screen
def addAllColumns(self):
progress = ProgressBar("Analyzing data...", self.mainWindow)
columns = self.mainWindow.fieldList.toPlainText().splitlines()
try:
indexes = self.mainWindow.tree.selectedIndexesAndChildren()
indexes = list(indexes)
progress.setMaximum(len(indexes))
for no in range(len(indexes)):
progress.step()
item = indexes[no].internalPointer()
columns.extend([key for key in recursiveIterKeys(item.data['response']) if not key in columns])
if progress.wasCanceled:
break
finally:
self.mainWindow.fieldList.setPlainText("\n".join(columns))
self.mainWindow.tree.treemodel.setCustomColumns(columns)
progress.close()
def __init__(self, QWidgetParent=None):
QMainWindow.__init__(self, QWidgetParent)
self._set_main_window()
self.centralwidget = QWidget(self)
layout = QVBoxLayout(self.centralwidget)
layout.setContentsMargins(0, 0, 2, 0)
layout.setSpacing(0)
# query frame
self.frame_query = QueryFrame()
self._set_frame()
layout.addWidget(self.frame_query)
self.setCentralWidget(self.centralwidget)
# status bar
self.statusbar = QStatusBar(self)
self._set_status_bar()
self.setStatusBar(self.statusbar)
self.progress_bar = ProgressBar(self)
self.statusbar.addPermanentWidget(self.progress_bar)
self.progress_bar.setVisible(False)
self.dw_top = DockWidget(460, 90, 20000, 50)
self.dw_top.setTitleBarWidget(QWidget())
self.dwc_top = DockWidgetContentsTop()
self.dw_top.setWidget(self.dwc_top)
self.addDockWidget(QtCore.Qt.TopDockWidgetArea, self.dw_top)
# dockwidget collection (left side)
self.dw_collections = DockWidget(350, 620, 700, 20000)
self.dw_collections.setTitleBarWidget(QWidget())
self.dwc_left = DockWidgetContentsLeft(self)
self.dw_collections.setWidget(self.dwc_left)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dw_collections)
QtCore.QMetaObject.connectSlotsByName(self)
def deleteNodes(self):
reply = QMessageBox.question(self.mainWindow, 'Delete Nodes', "Are you sure to delete all selected nodes?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply != QMessageBox.Yes:
return
progress = ProgressBar("Deleting data...", self.mainWindow)
self.mainWindow.tree.setUpdatesEnabled(False)
try:
todo = self.mainWindow.tree.selectedIndexesAndChildren({'persistent': True})
todo = list(todo)
progress.setMaximum(len(todo))
for index in todo:
progress.step()
self.mainWindow.tree.treemodel.deleteNode(index, delaycommit=True)
if progress.wasCanceled:
break
finally:
# commit the operation on the db-layer afterwards (delaycommit is True)
self.mainWindow.tree.treemodel.commitNewNodes()
self.mainWindow.tree.setUpdatesEnabled(True)
progress.close()
def create_widgets(self, *args, **kwargs):
if globals.debug > 1: print("datafromserver.create_widgets")
# Create widgets
self.description = ttk.Label(
self,
text=
"You must first ensure that you can ssh to the specified server without a password prompt. You can either specify a path to a single file, such as '/home/myuser/data0.dat' or to a pattern of files, such as '/home/myuser/data*.dat'.",
wraplength=self.width - 2 * self.pad,
justify='left',
)
self.server_info_frame = tk.Frame(self)
self.server_username_label = tk.Label(
self.server_info_frame,
text="Username:"******"Server address:",
)
self.server_address_entry = tk.Entry(
self.server_info_frame,
width=30,
textvariable=self.address,
)
self.filepath_label = tk.Label(
self.server_info_frame,
text="Remote file path:",
)
self.filepath_entry = tk.Entry(
self.server_info_frame,
width=30,
textvariable=self.path,
)
self.command_choice_label = tk.Label(
self.server_info_frame,
text='Command:',
)
self.command_choice_frame = tk.Frame(self.server_info_frame)
self.scp_button = tk.Radiobutton(
self.command_choice_frame,
text="scp",
value="scp",
variable=self.command_choice,
command=self.on_scp_button_pressed,
)
self.rsync_button = tk.Radiobutton(
self.command_choice_frame,
text="rsync",
value="rsync",
variable=self.command_choice,
command=self.on_rsync_button_pressed,
)
self.command_options_label = tk.Label(
self.server_info_frame,
text="Options:",
)
self.command_options_entry = tk.Entry(
self.server_info_frame,
textvariable=self.command_options,
)
self.progressbar = ProgressBar(self,
orient='horizontal',
maximum=100,
mode='determinate')
self.buttons_frame = tk.Frame(self)
self.download_button = tk.Button(
self.buttons_frame,
text="Download",
width=len("Download"),
command=self.download_pressed,
)
self.close_button = tk.Button(
self.buttons_frame,
text="Close",
command=self.close_soft,
)
def fetchData(self, indexes=None, apimodule=False, options=None):
# Check seed nodes
if not (self.mainWindow.tree.selectedCount() or self.mainWindow.allnodesCheckbox.isChecked() or (indexes is not None)):
return False
# Get options
apimodule, options = self.getQueryOptions(apimodule, options)
if not apimodule.auth_userauthorized and apimodule.auth_preregistered:
msg = 'You are not authorized, login please!'
QMessageBox.critical(self.mainWindow, "Not authorized",msg,QMessageBox.StandardButton.Ok)
return False
#Show progress window
progress = ProgressBar("Fetching Data", parent=self.mainWindow)
try:
# Get seed nodes
indexes = self.getIndexes(options, indexes, progress)
# Update progress window
self.mainWindow.logmessage("Start fetching data.")
totalnodes = 0
hasindexes = True
progress.setMaximum(totalnodes)
self.mainWindow.tree.treemodel.nodecounter = 0
#Init status messages
statuscount = defaultdict(int)
errorcount = 0
ratelimitcount = 0
allowedstatus = ['fetched (200)','downloaded (200)','fetched (202)']
try:
#Spawn Threadpool
threadpool = ApiThreadPool(apimodule)
threadpool.spawnThreads(options.get("threads", 1))
#Process Logging/Input/Output Queue
while True:
try:
#Logging (sync logs in threads with main thread)
msg = threadpool.getLogMessage()
if msg is not None:
self.mainWindow.logmessage(msg)
# Jobs in: packages of 100 at a time
jobsin = 0
while hasindexes and (jobsin < 100):
index = next(indexes, False)
if index:
jobsin += 1
totalnodes += 1
if index.isValid():
job = self.prepareJob(index, options)
threadpool.addJob(job)
else:
threadpool.applyJobs()
progress.setRemaining(threadpool.getJobCount())
progress.resetRate()
hasindexes = False
progress.removeInfo('input')
self.mainWindow.logmessage("Added {} node(s) to queue.".format(totalnodes))
if jobsin > 0:
progress.setMaximum(totalnodes)
#Jobs out
job = threadpool.getJob()
#-Finished all nodes (sentinel)...
if job is None:
break
#-Finished one node...
elif 'progress' in job:
progresskey = 'nodeprogress' + str(job.get('threadnumber', ''))
# Update single progress
if 'current' in job:
percent = int((job.get('current',0) * 100.0 / job.get('total',1)))
progress.showInfo(progresskey, "{}% of current node processed.".format(percent))
elif 'page' in job:
if job.get('page', 0) > 1:
progress.showInfo(progresskey, "{} page(s) of current node processed.".format(job.get('page',0)))
# Update total progress
else:
progress.removeInfo(progresskey)
if not threadpool.suspended:
progress.step()
#-Add data...
elif 'data' in job and (not progress.wasCanceled):
if not job['nodeindex'].isValid():
continue
# Add data
treeindex = job['nodeindex']
treenode = treeindex.internalPointer()
newcount = treenode.appendNodes(job['data'], job['options'], True)
if options.get('expand',False):
self.mainWindow.tree.setExpanded(treeindex,True)
# Count status and errors
status = job['options'].get('querystatus', 'empty')
statuscount[status] += 1
errorcount += int(not status in allowedstatus)
# Detect rate limit
ratelimit = job['options'].get('ratelimit', False)
#ratelimit = ratelimit or (not newcount)
ratelimitcount += int(ratelimit)
autoretry = (ratelimitcount) or (status == "request error")
# Clear errors when everything is ok
if not threadpool.suspended and (status in allowedstatus) and (not ratelimit):
#threadpool.clearRetry()
errorcount = 0
ratelimitcount = 0
self.state = 'fetchdata'
# Suspend on error or ratelimit
elif (errorcount >= options['errors']) or (ratelimitcount > 0):
threadpool.suspendJobs()
self.state = 'ratelimit'
if ratelimit:
msg = "You reached the rate limit of the API."
else:
msg = "{} consecutive errors occurred.\nPlease check your settings.".format(errorcount)
timeout = 60 * 5 # 5 minutes
# Adjust progress
progress.showError(msg, timeout, autoretry)
self.mainWindow.tree.treemodel.commitNewNodes()
# Add job for retry
if not status in allowedstatus:
threadpool.addError(job)
# Show info
progress.showInfo(status,"{} response(s) with status: {}".format(statuscount[status],status))
progress.showInfo('newnodes',"{} new node(s) created".format(self.mainWindow.tree.treemodel.nodecounter))
progress.showInfo('threads',"{} active thread(s)".format(threadpool.getThreadCount()))
progress.setRemaining(threadpool.getJobCount())
# Custom info from modules
info = job['options'].get('info', {})
for name, value in info.items():
progress.showInfo(name, value)
# Abort
elif progress.wasCanceled:
progress.showInfo('cancel', "Disconnecting from stream, may take some time.")
threadpool.stopJobs()
# Retry
elif progress.wasResumed:
if progress.wasRetried:
threadpool.retryJobs()
else:
threadpool.clearRetry()
# errorcount = 0
# ratelimitcount = 0
threadpool.resumeJobs()
progress.setRemaining(threadpool.getJobCount())
progress.hideError()
# Continue
elif not threadpool.suspended:
threadpool.resumeJobs()
# Finished with pending errors
if not threadpool.hasJobs() and threadpool.hasErrorJobs():
msg = "All nodes finished but you have {} pending errors. Skip or retry?".format(threadpool.getErrorJobsCount())
autoretry = False
timeout = 60 * 5 # 5 minutes
progress.showError(msg, timeout, autoretry)
# Finished
if not threadpool.hasJobs():
progress.showInfo('cancel', "Work finished, shutting down threads.")
threadpool.stopJobs()
#-Waiting...
progress.computeRate()
time.sleep(1.0 / 1000.0)
finally:
QApplication.processEvents()
finally:
request_summary = [str(val)+" x "+key for key,val in statuscount.items()]
request_summary = ", ".join(request_summary)
request_end = "Fetching completed" if not progress.wasCanceled else 'Fetching cancelled by user'
self.mainWindow.logmessage("{}, {} new node(s) created. Summary of responses: {}.".format(request_end, self.mainWindow.tree.treemodel.nodecounter,request_summary))
self.mainWindow.tree.treemodel.commitNewNodes()
except Exception as e:
self.mainWindow.logmessage("Error in scheduler, fetching aborted: {}.".format(str(e)))
finally:
progress.close()
return not progress.wasCanceled
def __init__(self, parent=None):
super(PresetWindow, self).__init__(parent)
self.mainWindow = parent
self.setWindowTitle("Presets")
self.setMinimumWidth(800)
self.setMinimumHeight(600)
#layout
layout = QVBoxLayout(self)
self.setLayout(layout)
#loading indicator
self.loadingLock = threading.Lock()
self.loadingIndicator = QLabel('Loading...please wait a second.')
self.loadingIndicator.hide()
layout.addWidget(self.loadingIndicator)
#Middle
central = QSplitter(self)
layout.addWidget(central, 1)
#list view
self.presetList = QTreeWidget(self)
self.presetList.setHeaderHidden(True)
self.presetList.setColumnCount(1)
self.presetList.setIndentation(15)
self.presetList.itemSelectionChanged.connect(self.currentChanged)
central.addWidget(self.presetList)
central.setStretchFactor(0, 0)
# category / pipeline
self.categoryWidget = QWidget()
p = self.categoryWidget.palette()
p.setColor(self.categoryWidget.backgroundRole(), Qt.white)
self.categoryWidget.setPalette(p)
self.categoryWidget.setAutoFillBackground(True)
self.categoryLayout = QVBoxLayout()
#self.categoryLayout.setContentsMargins(0, 0, 0, 0)
self.categoryWidget.setLayout(self.categoryLayout)
self.categoryView = QScrollArea()
self.categoryView.setWidgetResizable(True)
self.categoryView.setWidget(self.categoryWidget)
central.addWidget(self.categoryView)
central.setStretchFactor(1, 2)
# Pipeline header
self.pipelineName = QLabel('')
self.pipelineName.setWordWrap(True)
self.pipelineName.setStyleSheet("QLabel {font-size:15pt;}")
self.categoryLayout.addWidget(self.pipelineName)
# Pipeline items
# self.pipelineWidget = QTreeWidget()
# self.pipelineWidget.setIndentation(0)
# self.pipelineWidget.setUniformRowHeights(True)
# self.pipelineWidget.setColumnCount(4)
# self.pipelineWidget.setHeaderLabels(['Name','Module','Basepath','Resource'])
# self.categoryLayout.addWidget(self.pipelineWidget)
# preset widget
self.presetWidget = QWidget()
p = self.presetWidget.palette()
p.setColor(self.presetWidget.backgroundRole(), Qt.white)
self.presetWidget.setPalette(p)
self.presetWidget.setAutoFillBackground(True)
#self.presetWidget.setStyleSheet("background-color: rgb(255,255,255);")
self.presetView = QScrollArea()
self.presetView.setWidgetResizable(True)
self.presetView.setWidget(self.presetWidget)
central.addWidget(self.presetView)
central.setStretchFactor(2, 2)
#self.detailView.setFrameStyle(QFrame.Box)
self.presetLayout = QVBoxLayout()
self.presetWidget.setLayout(self.presetLayout)
self.detailName = QLabel('')
self.detailName.setWordWrap(True)
self.detailName.setStyleSheet("QLabel {font-size:15pt;}")
self.presetLayout.addWidget(self.detailName)
self.detailDescription = TextViewer()
self.presetLayout.addWidget(self.detailDescription)
self.presetForm = QFormLayout()
self.presetForm.setRowWrapPolicy(QFormLayout.DontWrapRows)
self.presetForm.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
self.presetForm.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
self.presetForm.setLabelAlignment(Qt.AlignLeft)
self.presetLayout.addLayout(self.presetForm, 1)
# Module
self.detailModule = QLabel('')
self.presetForm.addRow('<b>Module</b>', self.detailModule)
#Options
self.detailOptionsLabel = QLabel('<b>Options</b>')
self.detailOptionsLabel.setStyleSheet("QLabel {height:25px;}")
self.detailOptions = TextViewer()
self.presetForm.addRow(self.detailOptionsLabel, self.detailOptions)
# Columns
self.detailColumnsLabel = QLabel('<b>Columns</b>')
self.detailColumnsLabel.setStyleSheet("QLabel {height:25px;}")
self.detailColumns = TextViewer()
self.presetForm.addRow(self.detailColumnsLabel, self.detailColumns)
# Speed
self.detailSpeed = QLabel('')
self.presetForm.addRow('<b>Speed</b>', self.detailSpeed)
# Timeout
self.detailTimeout = QLabel('')
self.presetForm.addRow('<b>Timeout</b>', self.detailTimeout)
# Headers
self.detailHeaders = QLabel('')
self.presetForm.addRow('<b>Header nodes</b>', self.detailHeaders)
# Buttons
buttons = QHBoxLayout() #QDialogButtonBox()
self.saveButton = QPushButton('New preset')
self.saveButton.clicked.connect(self.newPreset)
self.saveButton.setToolTip(
wraptip(
"Create a new preset using the current tab and parameters"))
#buttons.addButton(self.saveButton,QDialogButtonBox.ActionRole)
buttons.addWidget(self.saveButton)
self.overwriteButton = QPushButton('Edit preset')
self.overwriteButton.clicked.connect(self.overwritePreset)
self.overwriteButton.setToolTip(wraptip("Edit the selected preset."))
#buttons.addButton(self.overwriteButton,QDialogButtonBox.ActionRole)
buttons.addWidget(self.overwriteButton)
self.deleteButton = QPushButton('Delete preset')
self.deleteButton.clicked.connect(self.deletePreset)
self.deleteButton.setToolTip(
wraptip(
"Delete the selected preset. Default presets can not be deleted."
))
#buttons.addButton(self.deleteButton,QDialogButtonBox.ActionRole)
buttons.addWidget(self.deleteButton)
#layout.addWidget(buttons,1)
buttons.addStretch()
self.reloadButton = QPushButton('Reload')
self.reloadButton.clicked.connect(self.reloadPresets)
self.reloadButton.setToolTip(wraptip("Reload all preset files."))
buttons.addWidget(self.reloadButton)
self.rejectButton = QPushButton('Cancel')
self.rejectButton.clicked.connect(self.close)
self.rejectButton.setToolTip(wraptip("Close the preset dialog."))
buttons.addWidget(self.rejectButton)
self.applyButton = QPushButton('Apply')
self.applyButton.setDefault(True)
self.applyButton.clicked.connect(self.applyPreset)
self.applyButton.setToolTip(wraptip("Load the selected preset."))
buttons.addWidget(self.applyButton)
layout.addLayout(buttons)
#status bar
self.statusbar = QStatusBar()
#self.folderLabel = QLabel("")
self.folderButton = QPushButton("")
self.folderButton.setFlat(True)
self.folderButton.clicked.connect(self.statusBarClicked)
self.statusbar.insertWidget(0, self.folderButton)
layout.addWidget(self.statusbar)
#self.presetFolder = os.path.join(os.path.dirname(self.mainWindow.settings.fileName()),'presets')
self.presetFolder = os.path.join(os.path.expanduser("~"), 'Facepager',
'Presets')
self.presetFolderDefault = os.path.join(os.path.expanduser("~"),
'Facepager', 'DefaultPresets')
self.folderButton.setText(self.presetFolder)
self.presetsDownloaded = False
self.presetSuffix = ['.3_9.json', '.3_10.json', '.fp4.json']
self.lastSelected = None
# Progress bar (sync with download thread by signals
self.progress = ProgressBar(
"Downloading default presets from GitHub...", self, hidden=True)
self.progressStart.connect(self.setProgressStart)
self.progressShow.connect(self.setProgressShow)
self.progressMax.connect(self.setProgressMax)
self.progressStep.connect(self.setProgressStep)
self.progressStop.connect(self.setProgressStop)
def setProgressStart(self):
if self.progress is None:
self.progress = ProgressBar(
"Downloading default presets from GitHub...",
self,
hidden=True)
def initProgress(self):
self.progressBar = ProgressBar("Extracting data...", self.mainWindow)
self.progressTotal = None
self.progressLevel = None
self.progressUpdate = datetime.now()
def initProgress(self):
self.progressBar = ProgressBar("Transferring nodes...", self.mainWindow)
self.progressTotal = None
self.progressLevel = None
self.progressUpdate = datetime.now()
def downloadDefaultFiles(self, silent=False):
with self.loadingLock:
if self.filesDownloaded:
return False
# Progress
progress = ProgressBar(
"Downloading default API definitions from GitHub...",
self) if not silent else None
QApplication.processEvents()
# Create temporary download folder
tmp = TemporaryDirectory(suffix='FacepagerDefaultAPIs')
try:
#Download
files = requests.get(
"https://api.github.com/repos/strohne/Facepager/contents/apis"
).json()
files = [
f['path'] for f in files
if f['path'].endswith(tuple(self.filesSuffix))
]
if progress is not None:
progress.setMaximum(len(files))
for filename in files:
response = requests.get(
"https://raw.githubusercontent.com/strohne/Facepager/master/"
+ filename)
if response.status_code != 200:
raise Exception(
f"GitHub is not available (status code {response.status_code})"
)
with open(
os.path.join(tmp.name, os.path.basename(filename)),
'wb') as f:
f.write(response.content)
if progress is not None:
progress.step()
# Create folder
if not os.path.exists(self.folderDefault):
os.makedirs(self.folderDefault)
# Clear folder
for filename in os.listdir(self.folderDefault):
os.remove(os.path.join(self.folderDefault, filename))
# Move files from tempfolder
for filename in os.listdir(tmp.name):
shutil.move(os.path.join(tmp.name, filename),
self.folderDefault)
self.logmessage.emit(
"Default API definitions downloaded from GitHub.")
except Exception as e:
if not silent:
QMessageBox.information(
self, "Facepager",
"Error downloading default API definitions:" + str(e))
self.logmessage.emit(
"Error downloading default API definitions:" + str(e))
return False
else:
self.filesDownloaded = True
return True
finally:
tmp.cleanup()
if progress is not None:
progress.close()