def __init__(self, parent=None):
super(WranglingHelper, self).__init__(parent=parent)
QtCompat.loadUi(_MAIN_UI, self)
self._background_process = None
self._started = False
self._list_model = self.loaded_rules_lw.model()
# self._rules_widgets = list()
self.console = Console()
self.tabbar = CustomTabBar()
self.rules_tabs_widget.setTabBar(self.tabbar)
self._connect_signals()
def __init__(self):
print("Started Gesture Recognition")
self._setConfig()
self.soundPlayer = Sound(self.audioConfig, self.osConfig)
self.gestureFileIO = GestureFileIO(self.name, self.path)
self.recorder = SwhRecorder(self.gestureFileIO, self.audioConfig, self.recordConfig)
self.view = Console(self.recorder, self.soundPlayer, self.applicationClose, self.gestureFileIO.setFileName, self.gestureFileIO.getFileName)
self.t1 = None
self.t2 = None
self.t3 = None
class SenseGesture():
def __init__(self):
print("Started Gesture Recognition")
self._setConfig()
self.soundPlayer = Sound(self.audioConfig, self.osConfig)
self.gestureFileIO = GestureFileIO(self.name, self.path)
self.recorder = SwhRecorder(self.gestureFileIO, self.audioConfig, self.recordConfig)
self.view = Console(self.recorder, self.soundPlayer, self.applicationClose, self.gestureFileIO.setFileName, self.gestureFileIO.getFileName)
self.t1 = None
self.t2 = None
self.t3 = None
def _setConfig(self):
self.config = c.getInstance()
self.checkNameSet()
self.checkOSet()
self.audioConfig = self.config.getAudioConfig()
self.pathsConfig = self.config.getPathsConfig()
self.recordConfig = self.config.getRecordConfig()
self.frequency = float(self.audioConfig['frequency'])
self.amplitude = float(self.audioConfig['amplitude'])
self.framerate = int(self.audioConfig['framerate'])
self.duration = int(self.audioConfig['duration'])
self.bufsize = int(self.audioConfig['buffersize'])
self.path = self.pathsConfig['gesturepath']
def checkNameSet(self):
userconfig = self.config.getUserConfig()
if(userconfig['name'] == ""):
name = raw_input('Bitte schreibe deinen Namen:\n')
self.config.setConfig("user", "name", name)
self.name = name
else:
self.name = userconfig['name']
def checkOSet(self):
self.osConfig = self.config.getOSConfig()
if(self.osConfig['type'] == ""):
self.config.setConfig("os", "type", os.name)
self.osConfig = self.config.getOSConfig()
def start(self):
try:
# self.t1 = Thread(name="Soundplayer", target=self.soundPlayer.startPlaying, args=(self.frequency, self.amplitude, self.framerate, self.duration, self.bufsize))
# self.t2 = self.recorder.startNewThread()
self.t3 = self.view.startNewThread()
# self.t1.start()
except:
print("Error: unable to start thread " + str(sys.exc_info()))
while True:
try:
self.t3.join(1)
except KeyboardInterrupt:
print("KeyboardInterrupt. Stopping current task (no guarantees for failures), if possible...")
self.view.interrupt()
if not self.t3.isAlive():
break
# self.applicationClose()
# print("Player alive: \t" + str(self.t1.is_alive()))
# print("Recorder alive:\t" + str(self.recorder.is_alive()))
# print("View alive: \t" + str(self.view.is_alive()))
exitApp()
def applicationClose(self, code=0):
self.recorder.close()
self.soundPlayer.stopPlaying()
if(self.recorder.thread != None):
self.recorder.thread.join()
self.soundPlayer.t.join()
graph.setMinimumSize(512, 512)
text = TextEditor()
text.setMinimumSize(212, 212)
text.connectGraph(graph)
nodeTree = NodeSelectorTree(
"Function") # todo: rename to specify this is the function tree
nodeTree.Widget().setMinimumSize(212, 600)
nodeTree.setMinimumSize(212, 212)
nodeTreeVar = NodeSelectorTree("Variable")
nodeTreeVar.Widget().setMinimumSize(212, 600)
nodeTreeVar.setMinimumSize(212, 212)
nodeTree.filterSignal.connect(nodeTreeVar.onFilterEvent)
console = Console()
console.connectLog(cmake_output_log)
# create dock widget "containers" for the text and graph widgets
graphContainer = QDockWidget(settings.cmakeFilePath)
graphContainer.setAllowedAreas(Qt.LeftDockWidgetArea)
graphContainer.setWidget(graph)
textContainer = QDockWidget("Cmake Text")
textContainer.setAllowedAreas(Qt.RightDockWidgetArea)
textContainer.setWidget(text)
nodeSelectorContainer = QDockWidget("Functions")
nodeSelectorContainer.setAllowedAreas(Qt.LeftDockWidgetArea)
nodeSelectorContainer.setWidget(nodeTree)
class WranglingHelper(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super(WranglingHelper, self).__init__(parent=parent)
QtCompat.loadUi(_MAIN_UI, self)
self._background_process = None
self._started = False
self._list_model = self.loaded_rules_lw.model()
# self._rules_widgets = list()
self.console = Console()
self.tabbar = CustomTabBar()
self.rules_tabs_widget.setTabBar(self.tabbar)
self._connect_signals()
@property
def rules_widgets(self):
"""A property that hold all loaded rules
Returns:
list: list of RulesWidgets
"""
return [self.rules_tabs_widget.widget(x) for x in xrange(self.rules_tabs_widget.count())]
def _connect_signals(self):
"""Connect default signals
"""
self.actionNew.triggered.connect(self._create_new_rule)
self.actionRemove.triggered.connect(self._remove_rule)
self.actionConsole.triggered.connect(self._show_console)
self.actionStart.triggered.connect(self.start)
self.actionExport.triggered.connect(self._export_rule)
self.actionImport.triggered.connect(self._import_rule)
self.actionPriority_excel_import.triggered.connect(self._import_priority_rule)
self.rules_tabs_widget.tabBar().tabMoved.connect(self._tab_moved)
self._list_model.rowsMoved.connect(self._item_in_list_moved)
self.loaded_rules_lw.itemDoubleClicked.connect(self._handle_item_double_clicked)
self.rules_searcher_le.textChanged.connect(self._search_in_list)
self.tabbar.change_name.connect(self._change_name_requested)
logger.handlers[0].signalHander.logEvent.connect(self.registerLogger)
def registerLogger(self, log):
"""Insert all log entries into the Console
Args:
log (str): Log entry
"""
self.console.console_widget.insertHtml(log)
def _change_name_requested(self, tab_index):
tab_name = self.rules_tabs_widget.tabText(tab_index)
item = self.loaded_rules_lw.item(tab_index)
item.setText(tab_name)
def _tab_moved(self, from_index, to_index):
"""Slot that handle the tabMoved signal. It will reorder also the ListWidget with
all rules loaded (self.loaded_rules_lw)
Args:
from_index (int): Index referencing the Source
to_index (int): Index referencing the target
"""
self.loaded_rules_lw.clear()
count = self.rules_tabs_widget.tabBar().count()
for index in xrange(count):
tab_name = self.rules_tabs_widget.tabBar().tabText(index)
self.loaded_rules_lw.addItem(tab_name)
def _search_in_list(self, text):
"""Filter the loaded rules in the ListWidget based on the text
Args:
text (str): Search pattern
"""
if text and self.loaded_rules_lw.count() != 0:
items = self.loaded_rules_lw.findItems(text, QtCore.Qt.MatchContains)
# if not items:
# return
# We need to do this little hacky fix, because if we check if an item is contained in a list
# an NotImplementedError will occur:
# if item in items:
# NotImplementedError: operator not implemented.
# https://bugreports.qt.io/browse/PYSIDE-74
items_ids = list()
if items:
items_ids = [id(item) for item in items]
for row in xrange(self.loaded_rules_lw.count()):
item = self.loaded_rules_lw.item(row)
selected = False
if id(item) in items_ids:
selected = True
tab = self.rules_tabs_widget.widget(row)
for tag in tab.tags:
if text in tag:
selected = True
break
item.setSelected(selected)
def _item_in_list_moved(self, parent, start, end, destination, row):
"""Slot that handle the rowMoved signal from the ListWidget. It will also move the tab within
the tabbar
Args:
parent ([type]): [description]
start ([type]): [description]
end ([type]): [description]
destination ([type]): [description]
row ([type]): [description]
"""
if row != 0:
row = row - 1
self.rules_tabs_widget.tabBar().moveTab(start, row)
def _handle_item_double_clicked(self, item):
"""Slot that handle the itemDoubleClicked signal from the ListWidget.
It will select the tab that corresponds to the clicked item
Args:
item (QListWidgetItem): Double clicked item
"""
row = self.loaded_rules_lw.row(item)
self.rules_tabs_widget.setCurrentIndex(row)
def _import_priority_rule(self):
"""This method handles the import priority Excel
It will opens a QFileDialog that allows you to choose the file.
It will import all the priorities rules in individual tabs
"""
file, filters = QtWidgets.QFileDialog.getOpenFileName(self, "Priority file...")
if file:
for rule in generate_priority_rules(file):
info = rule.get("info")
rule_data = rule.get("rule")
shot = info.get("shot")
user = info.get("login")
rule_name = "{} - {}".format(shot, user)
rule_widget = self._create_new_rule(rule_name)
rule_widget.import_rule(rule_data)
def _show_console(self):
"""Shows the Console Widget
"""
self.console.show()
def _create_new_rule(self, name=None):
"""Handles the creation of a rule.
This method is one of the main methods of this class
If a name is not provided, a prompt will ask you to provide a name.
It creates a RuleWidget widget
Args:
name (str, optional): Name of the Rule. Defaults to None.
Returns:
RuleWidget: The rule created
"""
accepted = True
if not name:
name, accepted = QtWidgets.QInputDialog.getText(self, "Wrangling helper", "Rule name: ")
if name and accepted:
rule_widget = RulesWidget()
self.rules_tabs_widget.addTab(rule_widget, name)
# self._rules_widgets.append(rule_widget)
self.loaded_rules_lw.addItem(name)
return rule_widget
return None
def _remove_rule(self):
"""Remove the current focused RuleWidget
"""
widget = self.rules_tabs_widget.currentWidget()
index = self.rules_tabs_widget.currentIndex()
# self._rules_widgets.remove(widget)
self.rules_tabs_widget.removeTab(index)
self.loaded_rules_lw.takeItem(index)
def _results_emitted(self, jobs):
"""This method is called whenever the Background process emits some results
If the emit it is not empty, it will try to match a rule, and if it matchs,
it will apply the specified options
Args:
jobs (list): List of Deadline Jobs
"""
if not jobs:
logger.info("Any job received this time")
return
logger.info("Getting {} new jobs!".format(len(jobs)))
for job in jobs:
for rule_widget in self.rules_widgets:
rule = rule_widget.create_rule(job)
match = rule.job_match_rule(job)
if not match:
continue
rule.apply_rule_options(job)
send_wrangling_email(job, rule.options)
logger.info("Rule {} applied to job {} with ID {}".format(rule.options, job["Props"]["Name"], job["_id"]))
def _thread_finished(self):
print("Thread Finished")
def _export_rule(self):
"""Export the current Rule in a Json file
"""
widget = self.rules_tabs_widget.currentWidget()
index = self.rules_tabs_widget.currentIndex()
tab_name = self.rules_tabs_widget.tabText(index)
rule = widget.export_rule()
path = export_rule(tab_name, rule)
if path:
QtWidgets.QMessageBox.information(self, "Exported", "File exported in:\n{}".format(path))
def _import_rule(self):
"""Import a Json file rule.
"""
file, filters = QtWidgets.QFileDialog.getOpenFileName(self, "Import file...", "T:/framework/settings/wrangling")
if file:
rule_data = decode_json(file)
rule_name = os.path.splitext(os.path.basename(file))[0]
rule_widget = self._create_new_rule(rule_name)
rule_widget.import_rule(rule_data)
def start(self):
"""Main method of this class
It will create a BackgroundProcess that will be interacting with Deadline.
The Background process is a Daemon Thread. It will be triggered every 30 secs.
It will get any new job that is Active (Rendering, Queried) or Pending
Once this BackgroundProcess timedout, it will automatically pass all the results
through the method ``_results_emitted``
"""
if not self._started:
if not self._background_process:
only_new_jobs = self.actionWrangler_only_jobs_from_now_on.isChecked()
self._background_process = BackgroundProcess(only_new_jobs=only_new_jobs, parent=self)
self._background_process.finished.connect(self._thread_finished)
self._background_process.emit_results.connect(self._results_emitted)
self._timer = QtCore.QTimer(self)
self._timer.setInterval(30000)
# self._timer.setSingleShot(True)
self._timer.timeout.connect(self._background_process.start)
self._timer.start()
self._started = True
self.actionStart.setText("Pause")
self.actionStart.setIcon(QtGui.QIcon(":/icons/light/pause.svg"))
logger.info("Starting")
else:
self._timer.stop()
self._background_process.terminate()
self._background_process.wait()
self.actionStart.setText("Start")
self.actionStart.setIcon(QtGui.QIcon(":/icons/light/play.svg"))
self._started = False
logger.info("Pausing")
self.rules_tabs_widget.setDisabled(self._started)
