def __init__(self, *args, **kwargs):
self.mainWindow = None
self.connections = {}
self.connectionsChanged = Signal()
self.update = Signal()
self.update.connect(self.connectionsChanged)
self.qObj = QtCore.QObject()
# common shared data from processes
self.sharedData = {}
# bridge files and directories to watch for updates
# could make this a map of
# {file : every callback that depends on it?}
self._bridgeFilePaths = []
# watch them
# test to make file paths update live
self.watcher = QtCore.QFileSystemWatcher(
parent=self.qObj)
# actually this is probably extremely unsafe
# map of fileName : pid? or process object?
self.processes = {}
# timer to poll them so we know if a program is shut down
self.timer = QtCore.QTimer(parent=self.qObj)
self.timer.setTimerType(QtCore.Qt.VeryCoarseTimer)
def process_helper(hwd):
input = Path(hwd.process_input_text.text())
output = Path(input) / 'output'
if not output.exists():
os.makedirs(str(output), exist_ok=True)
hwd.statusbar.showMessage('Starting threads')
hwd.old_frames = count_dir_files(output)
hwd.current_frame = 0
hwd.total_frames = count_dir_files(input) - 1 # one is our output folder
hwd.process_progressbar.setMaximum(hwd.total_frames)
process_update_progress_count(hwd, hwd.current_frame, hwd.total_frames)
hwd.fs_watcher = QtCore.QFileSystemWatcher([str(output)], hwd.win)
hwd.fs_watcher.directoryChanged.connect(
lambda: process_update_process(hwd, output))
#backend.pre_process_folder(input, output, 'cnn')
import threading
hwd.win.masker = Process(target=backend.pre_process_folder,
args=(input, output, get_method(hwd)))
#hwd.win.masker = threading.Thread(target=backend.pre_process_folder, args=(input,output, get_method(hwd)))
hwd.win.masker.start()
def __init__(self, label, parent=None,
default_path=None, extensions=None, sort=True):
"""
:param extensions: A list of string terminations to match, or ``None``
for match-all.
:param default_path: If None, 'home' is picked as default.
:param sort: If true, contents will always be shown sorted
"""
super().__init__(parent)
self.sort = sort
self.dirpath = (os.path.expanduser("~") if default_path is None
else default_path)
self.extensions = [""] if extensions is None else extensions
self.label = label
# create widgets
self.file_button = QtWidgets.QPushButton(self.label)
self.file_list = QtWidgets.QListWidget()
# add widgets to layout
self.main_layout = QtWidgets.QVBoxLayout(self)
self.main_layout.addWidget(self.file_button)
self.main_layout.addWidget(self.file_list)
# connect
self.file_button.pressed.connect(self._file_dialog_handler)
# track filesystem changes
self.file_watcher = QtCore.QFileSystemWatcher()
self.file_watcher.fileChanged.connect(
lambda: self.update_path(self.dirpath))
self.file_watcher.directoryChanged.connect(
lambda: self.update_path(self.dirpath))
def add_watcher(parm):
""" Create a file with the current parameter contents and
create a file watcher, if not already created and found in hou.Session,
add the file to the list of watched files.
Link the file created to a parameter where the tool has been executed from
and when the file changed, edit the parameter contents with text contents.
"""
file_path = get_file_name(parm)
if os.path.exists(file_path):
os.remove(file_path)
# fetch parm content, either raw value or expression if any
try:
data = parm.expression()
except hou.OperationFailed:
data = str(parm.eval())
with open(file_path, 'w') as f:
f.write(data)
vsc = get_external_editor()
if not vsc:
hou.ui.setStatusMessage("No external editor set",
severity=hou.severityType.Error)
return
p = QtCore.QProcess(parent=hou.ui.mainQtWindow())
p.start(vsc, [file_path])
watcher = get_file_watcher()
if not watcher:
watcher = QtCore.QFileSystemWatcher([file_path],
parent=hou.ui.mainQtWindow())
watcher.fileChanged.connect(filechanged)
hou.session.FILE_WATCHER = watcher
else:
if not file_path in watcher.files():
watcher.addPath(file_path)
parms_bindings = get_parm_bindings()
if not parms_bindings:
hou.session.PARMS_BINDINGS = {}
parms_bindings = hou.session.PARMS_BINDINGS
parms_bindings[file_path] = parm
def start(self,
path,
callback,
include=None,
exclude=None,
recursive=False):
super().start(path, callback, include, exclude, recursive)
watcher = QtCore.QFileSystemWatcher()
dirs, files = walk(path, include, exclude)
watcher.addPaths(dirs + files)
watcher.fileChanged.connect(self.on_file_changed)
watcher.directoryChanged.connect(self.on_directory_changed)
self._watch = watcher
def __init__(self, pParentDialog):
super(NamespaceTableModel, self).__init__()
self.mParentDialog = pParentDialog
self.mRefFilePath = {}
self.mRefFileReload = {}
self.mSys = FBSystem()
self.mWatcher = QtCore.QFileSystemWatcher()
self.mOnlyRef = True
self.mNamespaces = []
self.mNamespacesFlag = [] # is loaded and file exist
self.Init()
def __init__(self, path):
QtSvg.QSvgWidget.__init__(self)
self.path = path
self.watch = QtCore.QFileSystemWatcher(self)
self.watch.addPath(self.path)
self.watch.fileChanged.connect(self.reload)
self.setMouseTracking(True)
self.ds = None
self.scale = 0
self.center_x = 0
self.center_y = 0
self.setPalette(QtGui.QPalette(QtCore.Qt.white))
self.setAutoFillBackground(True)
QtSvg.QSvgWidget.load(self, path)
self.defViewBox = self.renderer().viewBoxF()
self.center()
def extract_helper(hwd):
input = hwd.extract_input_text.text()
output = hwd.extract_output_text.text()
p = Path(output)
if not p.exists():
os.makedirs(str(p), exist_ok=True)
hwd.old_frames = count_dir_files(output)
hwd.current_frame = 0
hwd.total_frames = backend.get_frame_count(input)
hwd.extract_progressbar.setMaximum(hwd.total_frames)
extract_update_progress_count(hwd, hwd.current_frame, hwd.total_frames)
hwd.fs_watcher = QtCore.QFileSystemWatcher([output], hwd.win)
hwd.fs_watcher.directoryChanged.connect(
lambda: extract_update_process(hwd, output))
print(hwd.win)
hwd.win.ffmpeg = Process(target=backend.extract_frames,
args=(input, output, 'jpg'))
hwd.win.ffmpeg.start()
def __init__(self,
path: pathlib.Path,
sort_existing=True,
folders_dict: dict = {},
parent=None):
super().__init__(parent)
self.FOLDERS = folders_dict
self.EXTENSIONS = [
item for ext_list in list(self.FOLDERS.values())
for item in ext_list
]
self.IGNORED_NAMES = ['desktop.ini']
self.path = pathlib.Path(path)
self.watcher = QtCore.QFileSystemWatcher()
self.watcher.addPath(self.path.as_posix())
self.previous = []
Logger.info(self)
if not sort_existing:
self.previous = [f for f in self.path.iterdir() if f.is_file()]
self.check_files()
self.watcher.directoryChanged.connect(self.check_files)
def add_watcher(selection, type_="parm"):
""" Create a file with the current parameter contents and
create a file watcher, if not already created and found in hou.Session,
add the file to the list of watched files.
Link the file created to a parameter where the tool has been executed from
and when the file changed, edit the parameter contents with text contents.
"""
file_path = get_file_name(selection, type_=type_)
if type_ == "parm":
# fetch parm content, either raw value or expression if any
try:
data = selection.expression()
except hou.OperationFailed:
data = str(selection.eval())
elif type_ == "python_node":
data = selection.type().definition().sections()["PythonCook"].contents(
)
elif "extra_section|" in type_:
sec_name = type_.split('|')[-1]
sec = selection.type().definition().sections().get(sec_name)
if not sec:
print("Error: No section {} found.".format(sec))
data = sec.contents()
elif type_ == "__temp__python_source_editor":
data = hou.sessionModuleSource()
with open(file_path, 'w') as f:
f.write(data)
vsc = get_external_editor()
if not vsc:
hou.ui.setStatusMessage("No external editor set",
severity=hou.severityType.Error)
return
p = QtCore.QProcess(parent=hou.ui.mainQtWindow())
p.start(vsc, [file_path])
watcher = get_file_watcher()
if not watcher:
watcher = QtCore.QFileSystemWatcher([file_path],
parent=hou.ui.mainQtWindow())
watcher.fileChanged.connect(filechanged)
hou.session.FILE_WATCHER = watcher
else:
if not file_path in watcher.files():
watcher.addPath(file_path)
parms_bindings = get_parm_bindings()
if not parms_bindings:
hou.session.PARMS_BINDINGS = {}
parms_bindings = hou.session.PARMS_BINDINGS
if not file_path in parms_bindings.keys():
parms_bindings[file_path] = selection
# add "on removed" callback to remove file from watcher
# when node is deleted
if type_ == "python_node" or "extra_section|" in type_:
selection.addEventCallback((hou.nodeEventType.BeingDeleted, ),
_node_deleted)
clean_files()
parser = OptionParser()
parser.add_option('-t','--toplevel',action="store_true", default=False)
parser.add_option('-c','--compmobs',action="store_true", default=False)
parser.add_option('-m','--mastermobs',action="store_true", default=False)
parser.add_option('-s','--sourcemobs',action="store_true", default=False)
parser.add_option('-d','--dictionary',action="store_true", default=False)
parser.add_option('--metadict',action="store_true", default=False)
parser.add_option('-r','--root',action="store_true", default=False)
(options, args) = parser.parse_args()
if not args:
parser.error("not enough arguments")
file_path = args[0]
app = QtWidgets.QApplication(sys.argv)
tree = QtWidgets.QTreeView()
window = Window(options)
window.setFilePath(file_path)
window.show()
fs_watcher = QtCore.QFileSystemWatcher([file_path])
fs_watcher.fileChanged.connect(window.setFilePath)
sys.exit(app.exec_())
def __init__(self):
super().__init__()
self.sourceModel = QtWidgets.QFileSystemModel()
self.watcher = QtCore.QFileSystemWatcher()
self.proxyModel = SortFilterProxyModel()
self.proxyView = QtWidgets.QListView()
self.proxyView.setModel(self.proxyModel)
self.proxyModel.setSourceModel(self.sourceModel)
self.proxyModel.filterOut.append(config.markedImageFolderName.lower())
self.proxyModel.filterOut.append(config.imageWaoMetaFolderName.lower())
self.proxyModel.filterOut.append(config.flightDataFolderName.lower())
self.address = AddressBar()
# When the root path changes, we'll need to update the file watcher
self.sourceModel.rootPathChanged.connect(self._changeWatchedPath)
# When the file watcher has the directory change, we'll want to *maybe* update the layout
self.watcher.directoryChanged.connect(self.setConditionalLayout)
self.watcher.fileChanged.connect(self.setConditionalLayout)
# Context menu policy must be CustomContextMenu for us to implement
# our own context menu. Connect the context menu request to our internal slot.
self.menu: LibraryMenu = LibraryMenu(self)
self.menu.showFlightInfoRequested.connect(
self.showFlightInfoRequested.emit)
self.menu.showMigrationLogRequested.connect(
self.showMigrationLogRequested.emit)
self.menu.showDistributionFormRequested.connect(
self.showDistributionFormRequested.emit)
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._customMenuRequested)
# For optimization purposes, determining the proper layout
self._rootDirPreviouslyBlank = None
# Handle selection changes and map to appropriate signals
self.proxyView.selectionModel().selectionChanged.connect(
self._handleSelectionChange)
# Root path. Defaults to $HOME$/Pictures/ImageWAO
rootPath: str = config.libraryDirectory
# Widget for use when there are no folders
label = QtWidgets.QLabel(
" There is nothing here :( \n Right click to import flight images "
)
label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
# add to layout
layout = QtWidgets.QVBoxLayout()
layout.addWidget(label, stretch=1)
# Make widget with this layout
self.noFoldersWidget = QtWidgets.QWidget()
self.noFoldersWidget.setLayout(layout)
# Widget for use when there are folders
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.address)
layout.addWidget(self.proxyView, stretch=1)
self.hasFoldersWidget = QtWidgets.QWidget()
self.hasFoldersWidget.setLayout(layout)
# Create the stacked layout
self.stackedLayout = QtWidgets.QStackedLayout()
self.setLayout(self.stackedLayout)
self.stackedLayout.addWidget(self.noFoldersWidget)
self.stackedLayout.addWidget(self.hasFoldersWidget)
# Re-base the model on the new root path.
self.rebase(rootPath)
def init_monitor():
common.monitors = {
FileItemMonitor: QtCore.QFileSystemWatcher(),
}
common.monitors[FileItemMonitor].directoryChanged.connect(
functools.partial(directory_changed, FileItemMonitor))
def __init__(self, in_file):
super(PreprocessIncludeWatcher, self).__init__()
self.in_file = in_file
self.qt_watcher = QtCore.QFileSystemWatcher([in_file])
self.qt_watcher.fileChanged.connect(self.handle_changed)
self.update(emit_signal=False)
def load_image(self):
"""
run the tile generation and show it
:return:
"""
self.DirectoryWatcher = QtCore.QFileSystemWatcher(
[self.fname, self.fbgname])
self.DirectoryWatcher.fileChanged.connect(self.load_image)
self.labelerror.setText("")
self.saveAction.setIcon(
QtGui.QIcon("images" + os.path.sep + "save.png"))
self.clearButtonStyle()
self.loadUI()
self.timer.stop()
try:
self.result, frames, bg, size = tile_gen.treat_image(
self.fname, self.fbgname, self.frames_value)
demo_images = tile_gen.create_demo_images(
self.result, frames, bg, size, (int(345 / 2), int(280 / 2)))
except ValueError as e:
self.labelerror.setText(str(e))
pixmaperror = QtGui.QPixmap("images" + os.path.sep + "error.png")
self.saveAction.setIcon(
QtGui.QIcon("images" + os.path.sep + "error.png"))
self.label_load_background.setPixmap(pixmaperror)
self.label_load_background.setStyleSheet(
"#btnbg {background-color:rgb(183, 88, 94);}")
return
except Exception as e:
print(e)
self.labelerror.setText(str(e))
pixmaperror = QtGui.QPixmap("images" + os.path.sep + "error.png")
self.label_load.setPixmap(pixmaperror)
self.label_load.setStyleSheet(
"#btn {background-color:rgb(183, 88, 94);}")
self.main_render.setPixmap(pixmaperror)
self.saveAction.setIcon(
QtGui.QIcon("images" + os.path.sep + "error.png"))
self.main_render.setStyleSheet(
"#main {border-right: 1px solid #2d2d2d; background-color:rgb(183, 88, 94);}"
)
return
self.loaded = True
self.pixmaps = []
self.current_index = 0
for i, image in enumerate(demo_images):
self.pixmaps.append(QtGui.QPixmap.fromImage(image))
self.pixmaps[i] = self.pixmaps[i].scaled(345, 280,
QtCore.Qt.KeepAspectRatio)
if len(demo_images) == 1:
self.pixmaps[0] = self.pixmaps[0].scaled(345, 280,
QtCore.Qt.KeepAspectRatio)
self.main_render.setPixmap(self.pixmaps[0])
return
self.timer.start(200)
print "Reloading hotkeys..."
global __actions
__actions = defaultdict(lambda: defaultdict(list))
with open(__hotkeysfile) as f:
reader = csv.DictReader(f)
for row in reader:
for context in ("OBJECT", "SOP", "VOP", "DOP", "COP", "CHOP",
"SHOP", "ROP", "TOP", "LOP"):
if row[context] != '':
__actions[context][row["Key Name"]].append(
(row["Selection"], row[context]))
__load_actions()
this.fs_watcher = QtCore.QFileSystemWatcher()
this.fs_watcher.addPath(__hotkeysfile)
this.fs_watcher.fileChanged.connect(__load_actions)
def invoke_action_from_key(uievent):
# Some normal keys that we override are volatile, like 'A'; these come as keydown/keyup rather
# than keyhit. We only process the 'keydown' and ignore the up event to prevent doubling.
if uievent.eventtype != 'keyhit' and uievent.eventtype != 'keydown':
return None, False
editor = uievent.editor
context = editor.pwd().childTypeCategory().name()
csv_context = context.upper()
if csv_context in __actions and uievent.key in __actions[csv_context]:
from functools import partial
import _scandir
from PySide2 import QtWidgets, QtGui, QtCore
from . import log
from . import common
from . import lists
from . import listdelegate
from . import contextmenu
from . import images
from . import settings
from . import threads
from . import defaultpaths
MONITOR = QtCore.QFileSystemWatcher()
def reset_monitor():
MONITOR.removePaths(MONITOR.files())
MONITOR.removePaths(MONITOR.directories())
class TaskFolderContextMenu(contextmenu.BaseContextMenu):
"""The context menu associated with the TaskFolderWidget."""
def __init__(self, index, parent=None):
super(TaskFolderContextMenu, self).__init__(index, parent=parent)
self.add_reveal_item_menu()
self.add_copy_menu()
