def dispatch(self, event): """Dispatches events to the appropriate methods. :param event: The event object representing the file system event. :type event: :class:`FileSystemEvent` """ if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, 'dest_path'): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive): self.on_any_event(event) _method_map = { EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_DELETED: self.on_deleted, } event_type = event.event_type _method_map[event_type](event)
def dispatch(self, event): """Override superclass method. Append trailing slash to event src_path if it is a directory event and its dest_path if exists before matching using fnmatch. Args: event: The event object to dispatch. """ if event.is_directory and self._ignore_directories: return paths = [] if hasattr(event, 'dest_path'): dest_path = self._slash(event, event.dest_path) paths.append(unicode_paths.decode(dest_path)) if event.src_path: src_path = self._slash(event, event.src_path) paths.append(unicode_paths.decode(src_path)) if match_any_paths(paths, included_patterns=self._patterns, excluded_patterns=self._ignore_patterns, case_sensitive=self.case_sensitive): self.on_any_event(event) method_map = { EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_DELETED: self.on_deleted, } event_type = event.event_type method_map[event_type](event)
def dispatch(self, event): """Dispatches events to the appropriate methods. :param event: The event object representing the file system event. :type event: :class:`FileSystemEvent` """ if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, 'dest_path'): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive): self.on_any_event(event) _method_map = { EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_ATTR_MODIFIED: self.on_attr_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_DELETED: self.on_deleted, } event_type = event.event_type _method_map[event_type](event)
def dispatch(self, event): if has_attribute(event, 'dest_path'): paths = [event.src_path, event.dest_path] else: paths = [event.src_path] if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns): self.on_any_event(event)
def dispatch(self, event): """Dispatches events to the appropriate methods.""" current_time = datetime.now() if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, "dest_path"): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths( paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive, ): _method_map = { EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_DELETED: self.on_deleted, } event_type = event.event_type event_tuple = (event.src_path, event_type) if not self._coalesce: self.on_any_event(*self._args, event=event, **self._kwargs) _method_map[event_type](*self._args, event=event, **self._kwargs) elif event_tuple in self._src_path_timing: if (current_time - self._src_path_timing[event_tuple] > self._min_delta_time): # Update the time self._src_path_timing[event_tuple] = datetime.now() self.on_any_event(*self._args, event=event, **self._kwargs) _method_map[event_type](*self._args, event=event, **self._kwargs) else: self._src_path_timing[event_tuple] = datetime.now() self.on_any_event(*self._args, event=event, **self._kwargs) _method_map[event_type](*self._args, event=event, **self._kwargs)
def dispatch(self, event): if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, 'dest_path'): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive): self.on_any_event(event) _method_map = {EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_DELETED: self.on_deleted} event_type = event.event_type _method_map[event_type](event)
def _load_images(self): self.images = {} for root, dirs, files in os.walk(self.config.images_path): for file in files: filepath = os.path.join(root, file) if os.path.isfile(filepath): relpath = os.path.relpath(filepath, self.config.images_path) if match_any_paths( [relpath], excluded_patterns=self.config.ignore_patterns): category, filename = os.path.split(relpath) if self.images.get(category): if not filename in self.images[category]: self.images[category].append(filename) else: self.images[category] = [filename]
def checkPacklist(self): folder_list = [self.config["watch_directory"]] file_list = [] while folder_list: new_folder_list = [] for folder in folder_list: for root, folders, files in os.walk(folder): new_folder_list.extend([os.path.join(root, f) for f in folders]) file_list.extend([os.path.abspath(os.path.join(root, f)) for f in files]) folder_list = new_folder_list file_list = filter(lambda filename: filename not in self.pack_lookup and match_any_paths([filename], included_patterns=self.config["include"], excluded_patterns=self.config["exclude"], case_sensitive=False), file_list) file_list.sort(key=lambda path: os.path.basename(path)) for f in file_list: self.addPack(f)
def on_created(self, event): try: if event.is_directory: # Create directory print "Created directory: ", event.src_path self._create_dir(event.src_path) else: paths = [] if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, case_sensitive=False): print "Created file: ", event.src_path self._create_file(event.src_path) except Exception as e: print "Unable to upload change: ", e
def dispatch(self, event): if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, 'dest_path'): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive): self.on_any_event(event) _method_map = { EVENT_TYPE_MODIFIED: self.on_modified, EVENT_TYPE_MOVED: self.on_moved, EVENT_TYPE_CREATED: self.on_created, EVENT_TYPE_DELETED: self.on_deleted } event_type = event.event_type _method_map[event_type](event)
def dispatch(self, event): """Dispatches events to the appropriate methods. :param event: The event object representing the file system event. :type event: :class:`FileSystemEvent` """ if self.ignore_directories and event.is_directory: return paths = [] if has_attribute(event, 'dest_path'): paths.append(unicode_paths.decode(event.dest_path)) if event.src_path: paths.append(unicode_paths.decode(event.src_path)) if match_any_paths(paths, included_patterns=self.patterns, excluded_patterns=self.ignore_patterns, case_sensitive=self.case_sensitive): super(PatternMatchingEventHandler, self).dispatch(event)
from pathtools.patterns import match_any_paths """config.yaml's include/exclude patterns are implemented using pathtools.match_any_path: https://github.com/gorakhargosh/pathtools/blob/master/pathtools/patterns.py#L220 which ultimately supports unix glob pattern syntax. you can test your patterns here these patterns are passed to the watchdog as well as aws cli, which also uses the same syntax: https://docs.aws.amazon.com/cli/latest/reference/s3/index.html#use-of-exclude-and-include-filters """ if __name__ == "__main__": print match_any_paths(["./.git/file"], included_patterns=None, excluded_patterns=["*.git/*"], case_sensitive=False)
def _update_handler(self, event): if event.src_path in self.files and match_any_paths([event.src_path], included_patterns=self.patterns): self.files[event.src_path] = datetime.now() self.logger.info('File modified: %s', event)
def _handle_autoreload(self, cfg_file, *args, **options): """Command 'supervisor autoreload' watches for code changes. This command provides a simulation of the Django dev server's auto-reloading mechanism that will restart all supervised processes. It's not quite as accurate as Django's autoreloader because it runs in a separate process, so it doesn't know the precise set of modules that have been loaded. Instead, it tries to watch all python files that are "nearby" the files loaded at startup by Django. """ if args: raise CommandError("supervisor autoreload takes no arguments") live_dirs = self._find_live_code_dirs() (reload_progs, graceful_reload_progs) = self._get_autoreload_programs(cfg_file) # Call the autoreloader callback whenever a .py file changes. # To prevent thrashing, limit callbacks to one per second. handler = ThrottledModifiedHandler( patterns=AUTORELOAD_PATTERNS, ignore_patterns=AUTORELOAD_IGNORE, ignore_directories=True ) # Try to add watches using the platform-specific observer. # If this fails, print a warning and fall back to the PollingObserver. # This will avoid errors with e.g. too many inotify watches. observer = Observer() for live_dir in set(live_dirs): observer.schedule(handler, live_dir, True) # Poll if we have an observer. # TODO: Is this sleep necessary? Or will it suffice # to block indefinitely on something and wait to be killed? prev_count = -1 from pathtools.patterns import match_any_paths observer.start() try: while True: time.sleep(1) # Do we have some events in the queue and if yes, has # this number changed since last time we checked? if handler.event_count > 0 and prev_count == handler.event_count: for prog, patterns in graceful_reload_progs.iteritems(): if match_any_paths( handler.event_files, included_patterns=patterns, excluded_patterns=AUTORELOAD_IGNORE ): self.handle("gracefulrestart", prog, **options) for prog, patterns in reload_progs.iteritems(): if match_any_paths( handler.event_files, included_patterns=patterns, excluded_patterns=AUTORELOAD_IGNORE ): self.handle("restart", prog, **options) handler.reset_counter() prev_count = handler.event_count except KeyboardInterrupt: observer.stop() observer.join() return 0
def _create_handler(self, event): if match_any_paths([event.src_path], included_patterns=self.patterns): self.files[event.src_path] = datetime.now() self.logger.info('File created: %s', event)