def reload(file, logger):
path = os.path.dirname(os.path.abspath(file))
handler = RegexMatchingEventHandler([r".*"], [], False, True)
handler.on_modified = on_modified(logger)
my_observer = Observer()
my_observer.schedule(handler, path, recursive=True)
my_observer.start()
def test_ignore_directories(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
self.assertTrue(handler1.ignore_directories)
self.assertFalse(handler2.ignore_directories)
def __init__(self, root, reg):
RegexMatchingEventHandler.__init__(self, regexes=[reg])
self.handlers = {}
self.df_total = None # 所有文件的最后记录的总数据
self._root = root
self._reg = reg
self._init()
def test_ignore_directories():
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
assert handler1.ignore_directories
assert not handler2.ignore_directories
def test___init__(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, False)
self.assertEqual([r.pattern for r in handler1.regexes], g_allowed_regexes)
self.assertEqual([r.pattern for r in handler1.ignore_regexes], g_ignore_regexes)
self.assertTrue(handler1.ignore_directories)
self.assertFalse(handler2.ignore_directories)
def _watch_reducers(self):
event_handler = RegexMatchingEventHandler(['.*'])
event_handler.on_modified = self._on_reducer_modifed
observer = Observer()
observer.schedule(event_handler,
os.path.join(ROOT_DIR, 'reducers'),
recursive=False)
observer.start()
def main():
# load config and values
loadConfig()
# clean up any unix accoutn that was not removed
cleanupZombieUsers()
# Start the file watch service
fileEventHandler = RegexMatchingEventHandler(regexMatch, ignore_patterns,
ignoreDirectories,
caseSensitive)
fileEventHandler.on_modified = watchFile.on_modified
my_observer = Observer()
my_observer.schedule(fileEventHandler, path, recursive=goRecursively)
my_observer.start()
"""Start the bot."""
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
updater = Updater(TOKEN, use_context=True)
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# on different commands - answer in Telegram
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(CommandHandler("help", help_command))
dispatcher.add_handler(CommandHandler("restart", restart_command))
dispatcher.add_handler(CommandHandler("backup", backup_command))
dispatcher.add_handler(CommandHandler("perm", perm_command))
dispatcher.add_handler(CommandHandler("genssh", genSSH_command))
dispatcher.add_handler(CommandHandler("list", list_command))
dispatcher.add_handler(CommandHandler("clone", clone_command))
dispatcher.add_handler(CommandHandler("op", op_command))
dispatcher.add_handler(CommandHandler("deop", deop_command))
dispatcher.add_handler(CommandHandler("hwinfo", hwinfo_command))
dispatcher.add_handler(CommandHandler("broadcast", broadcast_command))
dispatcher.add_handler(CommandHandler("test", test_command))
dispatcher.add_handler(CommandHandler("players", players_command))
dispatcher.add_handler(CommandHandler("status", status_command))
dispatcher.add_handler(CommandHandler("propGet", propGet_command))
dispatcher.add_handler(CommandHandler("cmd", anyCommand_command))
dispatcher.add_handler(CommandHandler("mapreg", mapReg_command))
# dispatcher.add_handler(CommandHandler("kb", kb))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
# on noncommand i.e message - echo the message on Telegram
dispatcher.add_handler(
MessageHandler(Filters.text & ~Filters.command, badCMD))
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def test_handler():
handler1 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, True)
handler2 = RegexMatchingEventHandler(g_allowed_regexes,
g_ignore_regexes, False)
assert [r.pattern for r in handler1.regexes] == g_allowed_regexes
assert [r.pattern for r in handler1.ignore_regexes] == g_ignore_regexes
assert handler1.ignore_directories
assert not handler2.ignore_directories
def __init__(self,
callback: callable,
regexes: list,
wait: bool = True,
**kwargs):
RegexMatchingEventHandler.__init__(self, regexes=regexes)
self.callback_arguments = kwargs
self.callback = callback
self.wait = wait
def __init__(self, callback, loop=None, **kwargs):
"""asyncio compatible minimal regex matching event
handler for watchdog.
:param callback: function to apply to filenames.
:param loop: ayncio-like event loop.
"""
RegexMatchingEventHandler.__init__(self, **kwargs)
self._loop = loop or asyncio.get_event_loop()
self.callback = callback
def __init__(self, callback, loop=None, **kwargs):
"""asyncio compatible minimal regex matching event
handler for watchdog.
:param callback: function to apply to filenames.
:param loop: ayncio-like event loop.
"""
RegexMatchingEventHandler.__init__(self, **kwargs)
self._loop = loop or asyncio.get_event_loop()
self.callback = callback
def get_event_handler(converter):
def on_created(event):
converter(event.src_path)
def on_modified(event):
print(f'[MODIFIED] {event.__dict__}')
handler = RegexMatchingEventHandler(regexes=[r".*[.]djvu"])
handler.on_created = on_created
handler.on_modified = on_modified
return handler
def __init__(self, path, **kwargs):
"""Create observer for the directory at `path`."""
Observer.__init__(self, **kwargs)
# replace default event queue with ordered set queue to disallow
# duplicate events even if added out of order
self._event_queue = OrderedSetQueue()
RegexMatchingEventHandler.__init__(self)
self.path = os.path.abspath(path)
self.root_observer = Observer(**kwargs)
self.root_watch = None
self._stopped_handlers = dict()
self._dispatching_enabled = True
def _watcher(self):
handler = RegexMatchingEventHandler(regexes=[self.regex],
ignore_directories=True)
handler.on_modified = lambda x: self.q.put(x.src_path)
observer = Observer()
observer.schedule(handler, self.path)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
def __init__(self):
RegexMatchingEventHandler.__init__(self, ignore_regexes=Daemon.IGNORED_REGEX, ignore_directories=True)
# Just Initialize variable the Daemon.start() do the other things
self.daemon_state = 'down' # TODO implement the daemon state (disconnected, connected, syncronizing, ready...)
self.running = 0
self.client_snapshot = {} # EXAMPLE {'<filepath1>: ['<timestamp>', '<md5>', '<filepath2>: ...}
self.local_dir_state = {} # EXAMPLE {'last_timestamp': '<timestamp>', 'global_md5': '<md5>'}
self.listener_socket = None
self.observer = None
self.cfg = self.load_cfg(Daemon.CONFIG_FILEPATH)
self.init_sharing_path()
self.conn_mng = ConnectionManager(self.cfg)
def _set_root(self, root):
"""Set up watching `root` or closest existing parent."""
if self.root_watch is not None and self.root_watch.path == root:
# already watching the specified root, return early
return
# schedule new root watch
while True:
try:
watch = self.root_observer.schedule(
event_handler=self, path=root, recursive=False
)
except OSError as sched_err:
# root doesn't exist, move up one directory and try again
try:
# clean up from failed scheduling
self.root_observer.unschedule(ObservedWatch(root, False))
except KeyError:
pass
newroot = os.path.dirname(root)
if newroot == root:
# we've gotten to system root and still failed
raise sched_err
else:
root = newroot
else:
# watch was set, break out of while loop
break
# add regex for root and next subdirectory
regexes = []
regexes.append("^" + re.escape(root) + "$")
nextdir = self._get_next_dir_in_path(root)
if nextdir != root:
regexes.append("^" + re.escape(nextdir) + "$")
# update handler (self) with regexes
RegexMatchingEventHandler.__init__(
self, regexes=regexes, ignore_directories=False
)
# unschedule old root watch
if self.root_watch is not None:
try:
self.root_observer.unschedule(self.root_watch)
except KeyError:
# emitter already stopped
pass
self.root_watch = watch
def start(self):
"""
Starts watchdog thread to monitor for incoming files. Calls the
child class's `read` method when a new file appears.
"""
print 'FileSource start method called...', self.directory
event_handler = RegexMatchingEventHandler(regexes=['.*'],
ignore_regexes=[],
ignore_directories=False,
case_sensitive=False)
event_handler.on_created = self.read # Call child's `read` method
event_handler.on_modified = self.read
watch_path = self.directory
observer = Observer()
observer.schedule(event_handler, watch_path, recursive=False)
observer.start()
print 'observer started.'
def __init__(
self,
folder_config: FolderConfig = None,
bucket_operator: BucketOperatorS3 = None,
):
self.event_dict = dict()
self.folder_config = folder_config or FolderConfig.default()
self.bucket_operator = bucket_operator or BucketOperatorS3()
BaseThread.__init__(self)
FolderVisitor.__init__(
self,
self.folder_config,
)
RegexMatchingEventHandler.__init__(
self,
ignore_directories=True,
regexes=self.folder_config.regex_include_list,
ignore_regexes=self.folder_config.regex_exclude_list,
)
def __init__(self, path, force_polling=False, **kwargs):
"""Create observer for the directory at `path`."""
if force_polling:
observer_class = PollingObserver
else:
observer_class = Observer
self.root_observer = observer_class(**kwargs)
# get proper emitter class from root_observer instance of observer_class
BaseObserver.__init__(
self, emitter_class=self.root_observer._emitter_class, **kwargs
)
# initialize as an event handler as well for handling the root observer events
RegexMatchingEventHandler.__init__(self)
self.path = os.path.abspath(path)
self.root_watch = None
self._stopped_handlers = dict()
def __init__(self, do_restart):
RegexMatchingEventHandler.__init__(
self,
regexes=[r".+\.py"],
ignore_regexes=[
# VSCode's Black integration creates temp files like kaldi_main.py.80dd20e69f7d6eef4107c17b335180be.py
# and if vscode runs Black on save, and we use those as a trigger to restart, we may restart before
# the reformatted file is actually written, so we'll run old code in that case.
# So as a workaround, ignore these temp files.
# A more generic fix might be to wait until we see no more filesystem events for a time X before restarting,
# but that would introduce a noticeable restart delay and would not be guaranteed to work either (say X is
# less than the amount of time for a format operation to run - imagine big files).
# A more reliable fix would be to MD5 everything right before restarting, save that to a file
# somewhere, then check on startup restart if further changes have occurred.
r".+\.py\.[a-f0-9]{32}\.py$"
],
ignore_directories=True,
case_sensitive=False,
)
self.last_modified = datetime.datetime.now()
self.do_restart = do_restart
def __init__(self, path, force_polling=False, **kwargs):
"""Create observer for the directory at `path`."""
if force_polling:
observer_class = PollingObserver
else:
observer_class = Observer
self.root_observer = observer_class(**kwargs)
# get proper emitter class from root_observer instance of observer_class
BaseObserver.__init__(self,
emitter_class=self.root_observer._emitter_class,
**kwargs)
# replace default event queue with ordered set queue to disallow
# duplicate events even if added out of order
self._event_queue = OrderedSetQueue()
RegexMatchingEventHandler.__init__(self)
self.path = os.path.abspath(path)
self.root_watch = None
self._stopped_handlers = dict()
self._dispatching_enabled = True
def main():
if len(sys.argv) < 2:
print(f"Error: At least one arg is required. Usage: miro_uploader <destination_path> [monitored_path]")
exit(1)
destination_path = sys.argv[1]
monitored_path = sys.argv[2] if len(sys.argv) > 2 else '.'
def on_created(event):
print(f"hey, {event.src_path} has been created!")
def on_modified(event):
try:
print(f"hey buddy, {event.src_path} has been modified")
return_path = copy2(event.src_path, destination_path)
print(f"hey, that a copy path {return_path}")
remove(event.src_path)
except Exception:
pass
event_handler = RegexMatchingEventHandler(regexes=[r"^[\x00-\x7F]*jpg$"],
ignore_directories=True, case_sensitive=False)
event_handler.on_created = on_created
event_handler.on_modified = on_modified
observer = Observer()
observer.schedule(event_handler, monitored_path, recursive=False)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
finally:
observer.stop()
observer.join()
def __init__(self, warehouse, file_path, **kwargs):
super().__init__(**kwargs)
self.warehouse = warehouse
self.file_path = file_path
self.observer = None
patterns = str(self.file_path)
ignore_patterns = ""
ignore_directories = True
case_sensitive = True
self.my_event_handler = RegexMatchingEventHandler(
patterns, ignore_patterns, ignore_directories, case_sensitive)
self.my_event_handler.on_created = self.on_created
self.my_event_handler.on_modified = self.on_modified
setup_logging("debug", f"listener.log")
def __init__(self, path: str, watchdog_queue: Queue,
rabbitmq_queue: str) -> None:
self.rabbitmq_queue = rabbitmq_queue
self.path = path
self.event_handler = RegexMatchingEventHandler(
regexes=self.regexes,
ignore_directories=self.ignore_directories,
case_sensitive=self.case_sensitive,
)
self.event_handler.on_created = self.__on_created_event
self.watchdog_queue = watchdog_queue
for file in listdir(path):
fpath = join(path, file)
if isfile(fpath):
event = FileCreatedEvent(fpath)
self.watchdog_queue.put(item=event)
while not watchdog_queue.empty():
self.__on_created_event(watchdog_queue.get())
def on_modified(event):
print(f"{event.src_path} has been modified")
os.system(f"git add .")
os.system(f"git commit -m '{event.src_path} modified'")
os.system("git push origin master")
# create the event handler
if __name__ == "__main__":
# patterns = [".*"]
ignore_patterns = ["^./.git"]
ignore_directories = False
case_sensitive = True
# my_event_handler = RegexMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
my_event_handler = RegexMatchingEventHandler(
ignore_regexes=ignore_patterns)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_deleted
my_event_handler.on_modified = on_modified
# create an observer
path = "."
go_recursively = True
my_observer = Observer()
my_observer.schedule(my_event_handler, path, recursive=go_recursively)
my_observer.start()
# try:
# while True:
# time.sleep(5)
def __init__(self):
RegexMatchingEventHandler.__init__(self, regexes=[r'.*\.ui$'])
self.last_time = 0
def test_regexes(self):
handler1 = RegexMatchingEventHandler(g_allowed_regexes, g_ignore_regexes, True)
self.assertEqual([r.pattern for r in handler1.regexes], g_allowed_regexes)
def __init__(self, regs=[r".*.py$"]):
RegexMatchingEventHandler.__init__(self, regexes=regs)
self.reload_set = set()
if __name__ == '__main__':
FORMAT = '%(asctime)-15s %(message)s'
logging.basicConfig(filename='/tmp/watchdog.log',
level=logging.INFO,
format=FORMAT)
logging.info('Started')
path = sys.argv[1] if len(sys.argv) > 1 else '/home/norbert/Desktop'
patterns = ['.+']
ignore_patterns = [f"^{path}\.+"]
ignore_dirs = False
case_sensitive = True
my_event_handler = RegexMatchingEventHandler(patterns, ignore_patterns,
ignore_dirs, case_sensitive)
my_event_handler.on_created = on_created
my_event_handler.on_deleted = on_delete
my_event_handler.on_moved = on_moved
my_event_handler.on_modified = on_modified
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:
def __init__(self):
# Set the patterns for RegexMatchingEventHandler
RegexMatchingEventHandler.__init__(self,
regexes=['^\.(/|\\\\)test.*\.log$'],
ignore_directories=True)
def __init__(self, regexes, event_dict):
RegexMatchingEventHandler.__init__(self, regexes, ignore_directories=True)
self._event_dict = event_dict
def FileHandler():
handler = RegexMatchingEventHandler(regexes=[r".*[.](epub|pdf|mobi)"])
return handler
def KindleConnectionHandler():
handler = RegexMatchingEventHandler(regexes=[r".*/Kindle"])
return handler
def __init__(self, *args, **kwargs):
RegexMatchingEventHandler.__init__(self, *args, **kwargs)