def run(self):
self.curr_time = self.get_time()
patterns = "*"
ignore_patterns = "*\logs.txt", "*\logs.csv", "*\logs", "*.py"
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
path = ".\\" + self.path_to_watch
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def stream(graph, tags, communities, args):
# Code credit: http://thepythoncorner.com/dev/how-to-create-a-watchdog-in-python-to-look-for-filesystem-changes/
event_handler = PatternMatchingEventHandler(patterns=["*.md"],
case_sensitive=True)
smds_event_handler = SMDSEventHandler(graph, tags, communities, args)
event_handler.on_created = smds_event_handler.on_created()
event_handler.on_deleted = smds_event_handler.on_deleted()
event_handler.on_modified = smds_event_handler.on_modified()
event_handler.on_moved = smds_event_handler.on_moved()
observer = Observer()
path = Path(args.input)
if smdc.DEBUG:
print(path.absolute(), flush=True)
observer.schedule(event_handler, path=Path(args.input), recursive=args.r)
observer.start()
try:
print("Stream is active!", flush=True)
import sys
sys.stdout.flush()
while True:
# TODO: Catch when connection to neo4j server is down.
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def main(argv):
global my_observer
global stop
log("user:"******"*kisokos.txt"]
ignore_patterns = None
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
my_event_handler.on_moved = on_moved
path = "c:\\Users\\eharvin\\OneDrive - Ericsson AB\\00company"
go_recursively = False
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
if stop:
break
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def __init__(self,
path,
queue_out=None,
log=False,
pattern='*',
ignore_pattern='//'):
self.queue_out = queue_out
self.stdout = True if queue_out is None else False
self.log = log
self.prev_ev = {'path': None, 'time': None}
patterns = list(pattern.split())
for i, p in enumerate(patterns): # Setup directories matching
if p.endswith('/'):
patterns[i] = '*' + p + '*'
ignore_patterns = list(IGNORED_PATTERNS) + list(ignore_pattern.split())
for i, p in enumerate(ignore_patterns):
if p.endswith('/'):
ignore_patterns[i] = '*' + p + '*'
ignore_directories = True
case_sensitive = True
handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
handler.on_created = self.on_created
handler.on_deleted = self.on_deleted
handler.on_modified = self.on_modified
handler.on_moved = self.on_moved
go_recursively = True
self.observer = Observer()
self.observer.schedule(handler, path, recursive=go_recursively)
self.observer.start()
def __init__(self):
# set up the values for the handler
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
# configure the handler
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
# set the path for the directory that should be watched
path = "../Reports"
go_recursively = True
# set up the observer to watch the directory
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def popup_scan(self):
source_path = Path(__file__).resolve()
source_dir = str(source_path.parent) + "\\scans\\"
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_created = self.on_created
my_event_handler.on_deleted = self.on_deleted
my_event_handler.on_modified = self.on_modified
my_event_handler.on_moved = self.on_moved
go_recursively = True
self.my_observer = Observer()
self.my_observer.schedule(my_event_handler,
source_dir,
recursive=go_recursively)
self.my_observer.start()
try:
self.open()
except KeyboardInterrupt:
self.my_observer.stop()
self.my_observer.join()
def watchFolder(conn):
# Keep watching the folder for any change
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
def on_change(event):
# Update the file list with the indexing server
files = os.listdir("./")
register_data = {
"action": "UPDATE",
"filelist": files
}
register_json = json.dumps(register_data)
conn.send(register_json.encode(FORMAT))
event_handler.on_created = on_change
event_handler.on_deleted = on_change
path = "."
go_recursively = True
folder_observer = Observer()
folder_observer.schedule(event_handler, path, recursive=go_recursively)
folder_observer.start()
def start(self):
"""Runs the watchdog service on the given path. Handles
various events to different functions as per the
requirement
"""
event_handler = PatternMatchingEventHandler(self.patterns,
self.ignore_patterns,
self.ignore_directories,
self.case_sensitive)
event_handler.on_created = self.__on_created
event_handler.on_deleted = self.__on_deleted
event_handler.on_modified = self.__on_modified
event_handler.on_moved = self.__on_moved
go_recursively = self.recursive
observer = Observer()
observer.schedule(
event_handler,
self.src_dir,
recursive=go_recursively
)
observer.start()
print(f'Started watching for changes on path {self.src_dir}')
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def start():
patterns = "*/auth.log"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
path = "/var/log/"
go_recursively = True
observer = Observer()
observer.schedule(event_handler, path, recursive=go_recursively)
observer.start()
try:
while True:
time.sleep(500)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watchdog(ctx, jobs="auto", sleep_time = 5):
"""
Start watchdog service to watch F90 files and execute `make` when changes are detected.
"""
from monty.termcolor import cprint
cprint("Starting watchdog service to watch F90 files and execute `make` when changes are detected", "green")
cprint("Enter <CTRL + C> in the terminal to kill the service.", "green")
cprint(f"Start watching py files with sleep_time {sleep_time} s ....", "green")
top = find_top_build_tree(".", with_abinit=True)
jobs = max(1, number_of_cpus() // 2) if jobs == "auto" else int(jobs)
# http://thepythoncorner.com/dev/how-to-create-a-watchdog-in-python-to-look-for-filesystem-changes/
# https://stackoverflow.com/questions/19991033/generating-multiple-observers-with-python-watchdog
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
event_handler = PatternMatchingEventHandler(patterns="*.py", ignore_patterns="",
ignore_directories=False, case_sensitive=True)
def on_created(event):
print(f"hey, {event.src_path} has been created!")
def on_deleted(event):
print(f"what the f**k! Someone deleted {event.src_path}!")
def on_modified(event):
print(f"hey buddy, {event.src_path} has been modified")
cmd = "abicheck.py"
cprint("Executing: %s" % cmd, "yellow")
with cd(top):
try:
result = ctx.run(cmd, pty=True)
if result.ok:
cprint("Command completed successfully", "green")
cprint("Watching for changes ...", "green")
except Exception:
cprint(f"Command returned non-zero exit status", "red")
cprint(f"Keep on watching for changes hoping you get it right ...", "red")
def on_moved(event):
print(f"ok ok ok, someone moved {event.src_path} to {event.dest_path}")
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
path = ABIPY_ROOTDIR
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
try:
while True:
time.sleep(sleep_time)
except KeyboardInterrupt:
observer.stop()
observer.join()
def startWatchdog():
if not Config.isSetted():
raise RuntimeError("Server not configured")
config = Config.config("library-watchdog")
print("Starting watchdog with config: " + str(config))
patterns = config["patterns"]
ignore_patterns = config["ignore-patterns"]
ignore_directories = config["ignore-directories"]
case_sensitive = config["case-sensitive"]
path = config["path"]
recursively = config["recursively"]
watchdog_events = PatternMatchingEventHandler(
patterns=patterns,
ignore_patterns=ignore_patterns,
ignore_directories=ignore_directories,
case_sensitive=case_sensitive)
watchdog_events.on_created = on_created
watchdog_events.on_deleted = on_deleted
watchdog_events.on_modified = on_modified
watchdog_events.on_moved = on_moved
observer = Observer()
observer.schedule(event_handler=watchdog_events,
recursive=recursively,
path=path)
observer.daemon = True
observer.start()
print("Watchdog started...")
return observer
def setup_filesystem_watchdog(self):
"""
Initializes a filesystem watchdog (sets up file system event handler) and returns an observer object
"""
logging.debug("Initializing fs watchdog...")
# Unfortunately you can't ignore sub dirs with watchdog
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
fs_event_handler = PatternMatchingEventHandler(patterns,
ignore_patterns,
ignore_directories,
case_sensitive)
fs_event_handler.on_created = self.file_on_created
fs_event_handler.on_deleted = self.file_on_deleted
fs_event_handler.on_modified = self.file_on_modified
fs_event_handler.on_moved = self.file_on_moved
self.fs_observer = Observer()
self.fs_observer.schedule(fs_event_handler,
self.backup_src_path,
recursive=True)
logging.debug("fs watchdog created.")
def setup_event_handler():
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
return event_handler
def build_event_handler():
patterns = "*"
ignore_patterns = ""
ignore_directories = True
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = on_created
event_handler.on_modified = on_modified
event_handler.on_deleted = on_deleted
event_handler.on_moved = on_moved
return event_handler
def create_event_handler():
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_moved = on_event
my_event_handler.on_created = on_event
my_event_handler.on_deleted = on_event
return my_event_handler
def add_task(self, task: ForemonTask) -> 'Monitor':
if task in self.all_tasks:
raise ForemonError(f'cannot add duplicate task {task.name}',
errno.EINVAL)
conf: ForemonConfig = task.config
if display_verbose():
display_debug('alias', task.name)
display_debug('paths', conf.paths)
display_debug('patterns', conf.patterns)
display_debug('ignore_defaults', conf.ignore_defaults)
display_debug('ignore', conf.ignore)
display_debug('ignore_dirs', conf.ignore_dirs)
display_debug('ignore_case', conf.ignore_case)
display_debug('events', list(map(lambda e: e.name, conf.events)))
for path in list(conf.paths):
if not op.exists(path):
display_warning(f'cannot watch {path}, path does not exist')
conf.paths.remove(path)
if not conf.paths:
raise ForemonError(
'no valid paths specified, cannot add watch task',
errno.ENOENT)
callback = partial(self.debounce.submit_threadsafe, task)
handler = PatternMatchingEventHandler(
patterns=conf.patterns,
ignore_patterns=conf.ignore_defaults + conf.ignore,
ignore_directories=conf.ignore_dirs,
case_sensitive=not conf.ignore_case)
if Events.created in conf.events:
handler.on_created = callback
if Events.deleted in conf.events:
handler.on_deleted = callback
if Events.moved in conf.events:
handler.on_moved = callback
if Events.modified in conf.events:
handler.on_modified = callback
for path in conf.paths:
self.observer.schedule(handler, path, recursive=conf.recursive)
self.all_tasks.add(task)
return self
def start_watchdog():
pattern = [str(watch_file_path)]
my_event_handler = PatternMatchingEventHandler(patterns=pattern)
my_event_handler.on_created = make_new_html_file
my_event_handler.on_deleted = do_nothing
my_event_handler.on_modified = make_new_html_file
my_event_handler.on_moved = make_new_html_file
observer = Observer()
observer.schedule(my_event_handler,
str(watch_file_path.parents[0]),
recursive=True)
observer.start()
return observer
def main():
watchFolder = sys.argv[1]
writeFolder = sys.argv[2]
if (len(sys.argv) == 4):
cmd = sys.argv[3]
if cmd == "init":
# currentdir = os.getcwd()
watchFolder = watchFolder + "/"
writeFolder = writeFolder + "/"
if (not os.path.exists(watchFolder)):
os.mkdir(watchFolder)
if (not os.path.exists(writeFolder)):
os.mkdir(writeFolder)
completeWriteFolder = os.path.abspath(writeFolder) + "/"
os.chdir(writeFolder)
relWatchFolder = os.path.relpath(watchFolder)
print("Watching " + relWatchFolder)
print("Writing to " + completeWriteFolder)
print("**********----**********")
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
structManager = StructureManager(completeWriteFolder)
fileMonEventHandler = FileMonEventHandler(structManager)
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
event_handler.on_created = fileMonEventHandler.on_created
event_handler.on_deleted = fileMonEventHandler.on_deleted
event_handler.on_modified = fileMonEventHandler.on_modified
event_handler.on_moved = fileMonEventHandler.on_moved
observer = Observer()
observer.schedule(event_handler, relWatchFolder, recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def watch_configurationfolder(config_folder: str):
directory = path.normpath(config_folder)
logger.debug(f'Directory: {directory}')
event_handler = PatternMatchingEventHandler(
patterns=['*.yaml', '*.yml'],
ignore_patterns=['*.example.yaml'],
ignore_directories=True,
case_sensitive=True)
event_handler.on_created = _on_created
event_handler.on_deleted = _on_deleted
event_handler.on_modified = _on_modifiedfolder
event_handler.on_moved = _on_moved
logger.info(f'Starting to watch {config_folder}')
_start_observer(event_handler, directory)
def watch_configurationfile(config_file: str):
directory = path.dirname(config_file)
logger.debug(f'Directory: {directory}')
filename = path.basename(config_file)
logger.debug(f'File: {filename}')
event_handler = PatternMatchingEventHandler(
patterns=[f'*{filename}'],
ignore_patterns=['*.example.yaml'],
ignore_directories=True,
case_sensitive=True)
event_handler.on_created = _on_created
event_handler.on_deleted = _on_deleted
event_handler.on_modified = _on_modifiedfile
event_handler.on_moved = _on_moved
logger.info(f'Starting to watch {config_file}')
_start_observer(event_handler, directory)
def _create_watchdog(self):
"""Creates a watchdog on everything in the specified folder."""
f = self.folder
# Abort if folder is not set
if not os.path.exists(f) or not os.path.isdir(f):
print(f"Path '{f}' does not exist or is not a folder!")
sys.exit(1)
# Create a Watchdog on the folder
eh = PatternMatchingEventHandler("*", "", False, False) # match everything
eh.on_created = self._on_created
eh.on_modified = self._on_modified
eh.on_moved = self._on_moved
eh.on_deleted = self._on_deleted
self.wd = Observer()
self.wd.schedule(eh, f, recursive=True)
def create_observer(config):
'''
Create a Watchdog Observer instance to watch SCSS directory
specified in the config.
'''
patterns = '*.scss'
ignore_patterns = ''
ignore_directories = False
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):
'''
Executed on every change within the SCSS directory
'''
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)
# echo(f"File {event.event_type}: {event.src_path}")
echo(f"\nWatching {config['scss_dir']}...")
echo("Press Ctrl + C to stop.")
fileChangeHandler.on_modified = on_change
fileChangeHandler.on_created = on_change
fileChangeHandler.on_moved = on_change
fileChangeHandler.on_deleted = on_change
path = config['scss_dir']
observer = Observer()
observer.schedule(
fileChangeHandler,
path,
recursive=True
)
return observer
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 __init_observer(self):
# setting the event handler
event_handler = PatternMatchingEventHandler(patterns='*',
ignore_patterns='',
ignore_directories=False,
case_sensitive=True)
event_handler.on_created = self.on_created
event_handler.on_deleted = self.on_deleted
event_handler.on_modified = self.on_modified
event_handler.on_moved = self.on_moved
# schedule the observer
observer = Observer()
observer.schedule(event_handler=event_handler,
path=self.source_path,
recursive=False)
observer.start()
print('Observer started...')
return observer
def main():
#set watch dog
patterns = ["*.csv", "*.CSV"]
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
my_event_handler.on_modified = on_changed
my_event_handler.on_created = on_changed
my_event_handler.on_deleted = on_changed
#Craete observer
go_recursively = True
my_observer = Observer()
#the observer will watch all CSV files in the path even in anotthe sub directory
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
def start_watchdog(method_to_call):
'''
Starts the watchdog thread, defines its behaviour
:param method_to_call: the method that repeatedly is called
:return:
'''
import time
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
patterns = "*"
ignore_patterns = ""
ignore_directories = True
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns,
ignore_directories,
case_sensitive)
# events watchdog detects
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
my_event_handler.on_moved = on_moved
# location which is watched
path = client_config['location']
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
try:
while True:
print('----------------------------------------')
method_to_call()
time.sleep(1)
logging.info('next input:')
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def server(graph, tags, args):
# Code credit: http://thepythoncorner.com/dev/how-to-create-a-watchdog-in-python-to-look-for-filesystem-changes/
event_handler = PatternMatchingEventHandler(patterns=["*.md"], case_sensitive=True)
smds_event_handler = SMDSEventHandler(graph, FORMAT_TYPES[args.input_format], args.vault_name, tags)
event_handler.on_created = smds_event_handler.on_created()
event_handler.on_deleted = smds_event_handler.on_deleted()
event_handler.on_modified = smds_event_handler.on_modified()
event_handler.on_moved = smds_event_handler.on_moved()
observer = Observer()
observer.schedule(event_handler, path=args.input, recursive=args.r)
observer.start()
try:
print("Server is active!")
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
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 main():
print("Sort photos from camera")
# patterns = [".nef", ".jpeg", ".jpg", ".raw", ".NEF", ".JPG"]
patterns = "*"
ignore_patterns = ""
ignore_directories = False
case_sensitive = True
my_event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
my_event_handler.on_created = on_created
my_event_handler.on_moved = on_moved
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
go_recursively = False
my_observer = Observer()
my_observer.schedule(my_event_handler, track_path, recursive=go_recursively)
my_observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
my_observer.stop()
my_observer.join()
def create_event_handler(to_path, from_path):
to_path = pathlib.Path(to_path)
from_path = pathlib.Path(from_path)
def on_created(event):
event_path = pathlib.Path(event.src_path)
relative_event_path = event_path.relative_to(to_path)
destination = from_path.joinpath(relative_event_path)
print(f"Moved from {event_path} to {destination}")
while True:
try:
destination.parent.mkdir(exist_ok=True, parents=True)
shutil.move(event_path, destination)
break
except PermissionError:
time.sleep(1)
def on_deleted(event):
pass
def on_modified(event):
pass
def on_moved(event):
pass
event_handler = PatternMatchingEventHandler(patterns="*",
ignore_patterns="",
ignore_directories=True,
case_sensitive=True)
event_handler.on_created = on_created
event_handler.on_deleted = on_deleted
event_handler.on_modified = on_modified
event_handler.on_moved = on_moved
return event_handler
def on_deleted(self, event):
PatternMatchingEventHandler.on_deleted(self, event)
logging.info("Deleted file: %s", event.src_path)
