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()