def __init__(self, parentWidget=None): super().__init__(parentWidget) self.ui = UiTargetClass() self.ui.setupUi(self) self.fileChanged.connect(self._fileChanged, QtCore.Qt.QueuedConnection) self.ui.autoScrollCB.stateChanged.connect(self._autoScrollChanged) self.ui.autoScrollCB.setChecked(True) self.ui.splitByThredCB.stateChanged.connect(self._splitThreadsChanged) # self.ui.splitByThredCB.setChecked( True ) self.logFile = get_logging_output_file() ## prevents infinite feedback loop logging.getLogger('watchdog.observers.inotify_buffer').setLevel( logging.INFO) event_handler = PatternMatchingEventHandler(patterns=[self.logFile]) event_handler.on_any_event = self._logFileCallback dirPath = os.path.dirname(self.logFile) self.observer = Observer() self.observer.schedule(event_handler, path=dirPath, recursive=False) self.updateLogView() self.observer.start()
def __init__(self, parent, path): patterns = "*" ignore_patterns = "" ignore_directories = False case_sensitive = True self.parent = parent my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive) def on_any_event(event): parent.ftpListUpdate() my_event_handler.on_any_event = on_any_event go_recursively = False my_observer = Observer() my_observer.schedule(my_event_handler, path, recursive=go_recursively) my_observer.start() while self.parent.keepWatching(): time.sleep(1) my_observer.stop() my_observer.join()
def add(self, path): """ Set root directories with attached watchdogs """ # filter .tmp changes def onChange(e): if not e.src_path.endswith('.tmp'): if not e.src_path.endswith('project.json'): self.emit('file-changed', e) if not isinstance(path, list): path = [path] for p in path: if not os.path.isdir(p): self.log("Basepath "+p+" not found... ignoring") continue # p = '/tmp'+os.path.abspath(p) # pathlib.Path(p).mkdir(parents=True, exist_ok=True) else: self.log("Adding "+p+" as root paths") self.root_paths.append(p) handler = PatternMatchingEventHandler("*", None, False, True) handler.on_any_event = onChange my_observer = Observer() my_observer.schedule(handler, p, recursive=True) my_observer.start() self.pathObservers.append(my_observer) self.refresh()
def start_params_monitor(): load_values_from_file() event_handler = PatternMatchingEventHandler(patterns=["*.properties", "*.profile"], ignore_patterns=[], ignore_directories=True) event_handler.on_any_event = on_any_event observer = Observer() observer.schedule(event_handler, '.', recursive=False) observer.start()
def launch(roots, watch, debounce): debounce = datetime.timedelta(milliseconds=debounce) collections = collect_mappings(map(find_collections, roots)) log.msg("collections found", collections=collections) def install_all(): log.msg("init", dir_count=len(collections)) for c in collections.items(): install(*c) if watch: to_process = {} def handle_change(event): event_path = event.src_path path = next((path for path in collections.keys() if event_path.startswith(path))) log.msg("change event", trigger=event.src_path, collection_path=path) to_process[path] = datetime.datetime.now() handler = PatternMatchingEventHandler(patterns="*", ignore_patterns="", ignore_directories=False, case_sensitive=True) handler.on_any_event = handle_change my_observer = Observer() for d in collections.keys(): my_observer.schedule(handler, path=d, recursive=True) my_observer.start() log.msg("observation", op="start", dir_count=len(collections)) try: while True: time.sleep(1) now = datetime.datetime.now() to_remove = [] for k, v in to_process.copy().items(): if now > v + debounce: install(k, collections[k]) to_remove.append(k) for k in to_remove: del to_process[k] except KeyboardInterrupt: log.msg("observation", op="stop") my_observer.stop() my_observer.join() else: install_all()
def init_watchdog(self): ev_handler = PatternMatchingEventHandler(['*.waypoints', '*.poly'], ignore_directories=True) ev_handler.on_any_event = self.on_any_file_event if self.mission_folder is None: self.mission_folder = getcwd() self.ev_observer.schedule(ev_handler, self.mission_folder, recursive=False) self.ev_observer.start() pass
def start_watchdog(self): def on_any_event(_): self.reset_controllers_flag = True event_handler = PatternMatchingEventHandler(patterns=["*.py"], ignore_patterns=[], ignore_directories=True) event_handler.on_any_event = on_any_event path = CONTROLLERS_DIR self.observer = Observer() self.observer.schedule(event_handler, path, recursive=True) self.observer.start()
def main(): """CLI Command to execute the provided script with pymon""" # CLI Argument Parser parser = argparse.ArgumentParser( prog="pymon", description="Executes the provided script with pymon" ) # Adding arguments to the command parser.add_argument("filename", type=str, help="The file to execute with pymon", metavar="filename") parser.add_argument("--force-kill", action="store_true", default=False, help="Force kills the file instead of terminating it", dest="force_kill") # Fetch arguments arguments = parser.parse_args() global process event_handler = PatternMatchingEventHandler(patterns=["*.py"]) def handle_event(event): global process print(Fore.GREEN + "[pymon] restarting due to changes..." + Style.RESET_ALL) if arguments.force_kill: process.kill() else: process.terminate() process = subprocess.Popen([sys.executable, arguments.filename]) event_handler.on_any_event = handle_event observer = Observer() observer.schedule(event_handler, os.getcwd(), recursive=True) observer.start() print(Fore.YELLOW + Style.BRIGHT + "\n[pymon] watching directory" + Style.RESET_ALL) process = subprocess.Popen([sys.executable, arguments.filename]) print(Fore.GREEN + f"[pymon] starting {arguments.filename}" + Style.RESET_ALL) try: while True: time.sleep(2) except KeyboardInterrupt: observer.stop() observer.join()
def run(application_path: 'the path to the application to run', reloader: 'reload the application on changes' = False, workers: 'the number of asynchronous tasks to run' = 1, debug: 'enable debug mode' = False): """Import and run an application.""" import_path, app = _import_application(application_path) if reloader: # If the reloader is requested, create threads for running the # application and watching the file system for changes print('Running {!r} with reloader...'.format(app)) # Find the root of the application and watch for changes watchdir = os.path.abspath(import_module(import_path).__file__) for _ in import_path.split('.'): watchdir = os.path.dirname(watchdir) # Create observer and runner threads observer = Observer() loop = asyncio.new_event_loop() runner = Thread( target=app.run_forever, kwargs={ 'num_workers': workers, 'loop': loop }, ) # This function is called by watchdog event handler when changes # are detected by the observers def restart_process(event): """Restart the process in-place.""" os.execv(sys.executable, [sys.executable] + sys.argv[:]) # Create the handler and watch the files handler = PatternMatchingEventHandler( patterns=['*.py', '*.ini'], ignore_directories=True, ) handler.on_any_event = restart_process observer.schedule(handler, watchdir, recursive=True) # Start running everything runner.start() observer.start() else: # If the reloader is not needed, avoid the overhead print('Running {!r} forever...'.format(app)) app.run_forever(num_workers=workers)
def watcher(self): def onchange(e): self.regieinterface.log('project updated ! pushing it...') self.sendBuffer.put(('data', self.projectData())) handler = PatternMatchingEventHandler("*/project.json", None, False, True) handler.on_any_event = onchange self.projectObserver = Observer() self.projectObserver.schedule(handler, os.path.dirname(self.projectPath())) try: self.projectObserver.start() except: self.regieinterface.log('project.json not found')
def run(application_path: 'the path to the application to run', reloader: 'reload the application on changes' = False, workers: 'the number of asynchronous tasks to run' = 1, debug: 'enable debug mode' = False): """Import and run an application.""" import_path, app = _import_application(application_path) if reloader: # If the reloader is requested, create threads for running the # application and watching the file system for changes print('Running {!r} with reloader...'.format(app)) # Find the root of the application and watch for changes watchdir = os.path.abspath(import_module(import_path).__file__) for _ in import_path.split('.'): watchdir = os.path.dirname(watchdir) # Create observer and runner threads observer = Observer() loop = asyncio.new_event_loop() runner = Thread( target=app.run_forever, kwargs={'num_workers': workers, 'loop': loop}, ) # This function is called by watchdog event handler when changes # are detected by the observers def restart_process(event): """Restart the process in-place.""" os.execv(sys.executable, [sys.executable] + sys.argv[:]) # Create the handler and watch the files handler = PatternMatchingEventHandler( patterns=['*.py', '*.ini'], ignore_directories=True, ) handler.on_any_event = restart_process observer.schedule(handler, watchdir, recursive=True) # Start running everything runner.start() observer.start() else: # If the reloader is not needed, avoid the overhead print('Running {!r} forever...'.format(app)) app.run_forever(num_workers=workers)
def _create_handler(callback): """Wrapper for the watchdog EventHandler to store file paths in a set""" bmp_paths = set() def on_created(e): bmp_paths.add(e.src_path) callback(bmp_paths) def on_deleted(e): bmp_paths.discard(e.src_path) event_handler = PatternMatchingEventHandler(patterns=["*.bmp"], ignore_directories=True, case_sensitive=False) event_handler.on_any_event = lambda e: logging.debug(e.src_path) event_handler.on_created = on_created event_handler.on_deleted = on_deleted return event_handler
def le_start(): if DOMAIN_DIR and WATCH: event_handler = PatternMatchingEventHandler("*.(yml|yaml)", "", ignore_directories=True, case_sensitive=False) event_handler.on_any_event = lambda event: le_run() obs = Observer() obs.schedule(event_handler, DOMAIN_DIR) obs.start() try: while True: le_run() if ONCE: break time.sleep(60*CHECK_FREQ) except KeyboardInterrupt: pass finally: if DOMAIN_DIR and WATCH: obs.stop() obs.join()
def _loop(): try: if name is not None: print("Watching '{}'".format(name)) handler = PatternMatchingEventHandler(patterns=include, ignore_patterns=exclude, case_sensitive=True) handler.on_any_event = _update observer = Observer() observer.schedule(handler, folder, recursive=True) observer.start() while not stop.is_set(): stop.wait(1) if _test(): state.last_action = time.clock() execute(command, name) if name is not None: print("Unwatching '{}'".format(name)) observer.stop() observer.join() finally: done.set()
def stage_scenarios(self): if self.options.follow: watch_dir = os.path.realpath(self.watch_dir) else: watch_dir = self.watch_dir for rules in self.scenarios: event_handler = PatternMatchingEventHandler(patterns=rules.pattern, ignore_directories=self.options.files) # log_handler = self.PatternMatchingLoggingEventHandler(patterns=rules.pattern, # ignore_directories=self.options.files, # rule_id=rules.number, # action=rules.actions, # log_dir=self.dirwatch_dir) cmd_handler = self.EogShellCommandTrick(shell_command=rules.command, ) if rules.action == 'update': # create or modified event_handler.on_modified = cmd_handler.on_any_event event_handler.on_created = cmd_handler.on_any_event # log_handler.on_modified = log_handler.append_log # log_handler.on_created = log_handler.append_log elif rules.action == 'created': event_handler.on_created = cmd_handler.on_any_event # log_handler.on_created = log_handler.append_log elif rules.action == 'modified': event_handler.on_modified = cmd_handler.on_any_event # log_handler.on_modified = log_handler.append_log elif rules.action == 'deleted': event_handler.on_deleted = cmd_handler.on_any_event # log_handler.on_deleted = log_handler.append_log elif rules.action == 'existing': # this is not a exact mapping event_handler.on_any_event = cmd_handler.on_any_event # log_handler.on_any_event = log_handler.append_log self.observer.schedule(event_handler, watch_dir, recursive=self.options.recursive)
def create_observer(config): patterns = '*' ignore_patterns = '' ignore_directories = '' fileChangeHandler = PatternMatchingEventHandler( patterns = patterns, # watched patterns ignore_patterns = ignore_patterns, # ignored patterns ignore_directories = ignore_directories, # ignored directories case_sensitive = True ) def on_change(event, config=config): scss_dir = config['scss_dir'] file_tree = get_include_paths(scss_dir) raw_scss = get_raw_scss(file_tree, scss_dir) write_css(raw_scss, config) fileChangeHandler.on_any_event = on_change path = config['scss_dir'] observer = Observer() observer.schedule( fileChangeHandler, path, recursive=True ) observer.start() try: print(f"\nWatching {config['scss_dir']}...") print("Press Ctrl + C to stop.") while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def event_handler_factory(self, *args, patterns=["*"], ignore_directories=True, **kwargs): event_handler = PatternMatchingEventHandler( *args, patterns=patterns, ignore_directories=ignore_directories, **kwargs) def on_any_event_callback(event): """ Callback to react on any watchdog filesystem event. """ containers = self.get_target_containers() if containers: logger.info(event) logger.info(f"Scheduling reloading of containers") self.scheduled_reload(containers) event_handler.on_any_event = on_any_event_callback return event_handler
def main(): """CLI Command to execute the provided script with pymon""" init() # CLI Argument Parser parser = argparse.ArgumentParser( prog="pymon", description="Executes the provided script with pymon") # Adding arguments to the command parser.add_argument("filename", type=str, help="The file to execute with pymon", metavar="filename") parser.add_argument("--all", action="store_true", default=False, help="Watch all python Files in directory", dest="all_py") parser.add_argument("--force-kill", action="store_true", default=False, help="Force kills the file instead of terminating it", dest="force_kill") # Fetch arguments arguments = parser.parse_args() event_handler = PatternMatchingEventHandler( patterns=['*.py' if arguments.all_py else arguments.filename]) observer = Observer() observer.schedule(event_handler, getcwd(), recursive=True) observer.start() def _run_file(): global process process = subprocess.Popen([executable, arguments.filename]) def handle_event(event): file_change_type = event.event_type print(Fore.GREEN + "[pymon] restarting due to {}...".format(file_change_type) + Style.RESET_ALL) process.kill() if arguments.force_kill else process.terminate() if file_change_type == 'deleted': exit() elif file_change_type == 'modified': _run_file() def _prompt_terminate(): confirm_terminate = input('Are you sure you want to Terminate?(Y|n) ') if confirm_terminate.lower() == 'y': observer.stop() event_handler.on_any_event = handle_event if arguments.all_py: print(Fore.YELLOW + Style.BRIGHT + f"[pymon] watching Directory`" + Style.RESET_ALL) print(Fore.GREEN + f"[pymon] starting `python {arguments.filename}`" + Style.RESET_ALL) _run_file() try: while True: pass except KeyboardInterrupt: _prompt_terminate() observer.join()
src_dir = args.src dest_dir = args.dest if not is_dest_in_user_dir(dest_dir): print('! Destination path not in user folder, exiting now !') exit(1) # Run once initially replace_dest_with_src(src_dir, dest_dir) convert_all_mcf_files(dest_dir) patterns = "*" ignore_patterns = "" ignore_directories = False case_sensitive = True pattern_event_handler = PatternMatchingEventHandler( patterns, ignore_patterns, ignore_directories, case_sensitive) pattern_event_handler.on_any_event = on_watchdog_event observer = Observer() observer.schedule(pattern_event_handler, src_dir, recursive=True) observer.start() try: while True: time.sleep(1) while len(QUEUE) > 0: handle_fs_change_event(QUEUE.pop()) except KeyboardInterrupt: observer.stop() observer.join()
def __init__(self, host, port, content_dir='.'): self.host = host self.port = port self.content_dir = content_dir self.status_codes = { 100: 'Continue', 101: 'Switching Protocols', 102: 'Processing', 103: 'Early Hints', 200: 'OK', 201: 'Created', 202: 'Accepted', 203: 'Non-Authoritative Information', 204: 'No Content', 205: 'Reset Content', 206: 'Partial Content', 207: 'Multi-Status', 208: 'Already Reported', 226: 'IM Used', 300: 'Multiple Choices', 301: 'Moved Permanently', 302: 'Found', 303: 'See Other', 304: 'Not Modified', 305: 'Use Proxy', 306: 'Switch Proxy', 307: 'Temporary Redirect', 308: 'Permanent Redirect', 400: 'Bad Request', 401: 'Unauthorized', 402: 'Payment Required', 403: 'Forbidded', 404: 'Not Found', 405: 'Method Not Allowed', 406: 'Not Acceptable', 407: 'Proxy Authentication Required', 408: 'Request Timeout', 409: 'Conflict', 410: 'Gone', 411: 'Length Required', 412: 'Precondition Failed', 413: 'Payload Too Large', 414: 'URI Too Long', 415: 'Unsupported Media Type', 416: 'Range Not Satisfiable', 417: 'Expectation Failed', 418: "I'm a cup of coffee :3", 421: 'Misdirected Request', 422: 'Unprocessable Entity', 423: 'Locked', 424: 'Failed Dependency', 425: 'Too Early', 426: 'Upgrade Required', 428: 'Precondition Required', 429: 'Too Many Requests', 431: 'Request Header Fields Too Large', 451: 'Unavailable For Legal Reasons', 500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway', 503: 'Service Unavailable', 504: 'Gateway Timeout', 505: 'HTTP Version Not Supported', 506: 'Variant Also Negotiates', 507: 'Insufficient Storage', 508: 'Loop Detected', 510: 'Not Extended', 511: 'Network Authentication Required' } self.headers = { 'Server': 'SAI', 'Content-Type': 'text/html', 'Connection': 'keep-alive' } self.driver = webdriver.Chrome( os.path.join(os.path.abspath(os.getcwd()), 'src', 'chromedriver.exe')) event_handler = PatternMatchingEventHandler(patterns="*", ignore_patterns="", ignore_directories=False, case_sensitive=True) event_handler.on_any_event = self.on_file_event self.observer = Observer() self.observer.schedule(event_handler=event_handler, path=self.content_dir, recursive=True)
def run(application_path: 'the path to the application to run', reloader: 'reload the application on changes' = False, workers: 'the number of asynchronous tasks to run' = 1, debug: 'enable debug mode' = False, **kwargs): """Import and run an application.""" if kwargs['quiet']: # If quiet mode has been enabled, set the number of verbose # flags to -1 so that the level above warning will be used. verbosity = -1 else: # argparse gives None not 0. verbosity = kwargs['verbose'] or 0 # Set the log level based on the number of verbose flags. Do this # before the app is imported so any log calls made will respect the # specified level. log_level = logging.WARNING - (verbosity * 10) logging.basicConfig(level=log_level) import_path, app = _import_application(application_path) # Now that we have an application, set it's log level, too. app.logger.setLevel(log_level) if reloader or debug: # If the reloader is requested (or debug is enabled), create # threads for running the application and watching the file # system for changes. app.logger.info('Running {!r} with reloader...'.format(app)) # Find the root of the application and watch for changes watchdir = os.path.abspath(import_module(import_path).__file__) for _ in import_path.split('.'): watchdir = os.path.dirname(watchdir) # Create observer and runner threads observer = Observer() loop = _new_event_loop() runner = Thread( target=app.run_forever, kwargs={'num_workers': workers, 'loop': loop, 'debug': debug}, ) # This function is called by watchdog event handler when changes # are detected by the observers def restart_process(event): """Restart the process in-place.""" os.execv(sys.executable, [sys.executable] + sys.argv[:]) # Create the handler and watch the files handler = PatternMatchingEventHandler( patterns=['*.py', '*.ini'], ignore_directories=True, ) handler.on_any_event = restart_process observer.schedule(handler, watchdir, recursive=True) # Start running everything runner.start() observer.start() else: # If the reloader is not needed, avoid the overhead app.logger.info('Running {!r} forever...'.format(app)) app.run_forever(num_workers=workers, debug=debug)
generator.generate_all() def event_proc(event): generator.generate_all() patterns = ['*'] ignore_patterns = [ os.path.join('.', conf.OUTPUT_DIR) + '*', os.path.join('.', DB_FILE) ] ignore_dirs = False case_sensitive = True event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_dirs, case_sensitive) event_handler.on_any_event = event_proc observer = Observer() observer.schedule(event_handler, '.', True) observer.start() try: serve_path = os.path.join(CWD, conf.OUTPUT_DIR) Handler = functools.partial(http.server.SimpleHTTPRequestHandler, directory=serve_path) with socketserver.TCPServer(("", HTTP_PORT), Handler) as httpd: print("serving at port", HTTP_PORT) httpd.serve_forever() except KeyboardInterrupt: observer.stop() observer.join()
def run(application_path: 'the path to the application to run', reloader: 'reload the application on changes' = False, workers: 'the number of asynchronous tasks to run' = 1, debug: 'enable debug mode' = False, **kwargs): """Import and run an application.""" if kwargs['quiet']: # If quiet mode has been enabled, set the number of verbose # flags to -1 so that the level above warning will be used. verbosity = -1 else: # argparse gives None not 0. verbosity = kwargs['verbose'] or 0 # Set the log level based on the number of verbose flags. Do this # before the app is imported so any log calls made will respect the # specified level. log_level = logging.WARNING - (verbosity * 10) logging.basicConfig(level=log_level) import_path, app = _import_application(application_path) # Now that we have an application, set it's log level, too. app.logger.setLevel(log_level) if reloader or debug: # If the reloader is requested (or debug is enabled), create # threads for running the application and watching the file # system for changes. app.logger.info('Running {!r} with reloader...'.format(app)) # Find the root of the application and watch for changes watchdir = os.path.abspath(import_module(import_path).__file__) for _ in import_path.split('.'): watchdir = os.path.dirname(watchdir) # Create observer and runner threads observer = Observer() loop = _new_event_loop() runner = Thread( target=app.run_forever, kwargs={ 'num_workers': workers, 'loop': loop, 'debug': debug }, ) # This function is called by watchdog event handler when changes # are detected by the observers def restart_process(event): """Restart the process in-place.""" os.execv(sys.executable, [sys.executable] + sys.argv[:]) # Create the handler and watch the files handler = PatternMatchingEventHandler( patterns=['*.py', '*.ini'], ignore_directories=True, ) handler.on_any_event = restart_process observer.schedule(handler, watchdir, recursive=True) # Start running everything runner.start() observer.start() else: # If the reloader is not needed, avoid the overhead app.logger.info('Running {!r} forever...'.format(app)) app.run_forever(num_workers=workers, debug=debug)
available_dir.sort() if len(available_dir) == 0: available_dir.insert(0, '') if len(available_dir) >= 2: set_activedir(1) else: set_activedir(0) print('File list updated') def file_change(event): global refreshTimer if not refreshTimer: refreshTimer = Timer(3.0, refresh_filelist) refreshTimer.start() my_event_handler = PatternMatchingEventHandler("*", "", False, True) my_event_handler.on_any_event = file_change my_observer = Observer() my_observer.schedule(my_event_handler, base_path, recursive=True) my_observer.start() player.setBasePath(base_path) def play_activedir(index): broadcast('/playlist', current_dir(), index) broadcast('/scene', available_dir[active_dir]) def play_lastdir(index): sel_lastdir() play_activedir(index)