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 __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 __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 __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 __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 __init__(self, *args, **kwargs):
RegexMatchingEventHandler.__init__(self, *args, **kwargs)
def __init__(self):
RegexMatchingEventHandler.__init__(self, regexes=[r'.*\.ui$'])
self.last_time = 0
def __init__(self, regs=[r".*.py$"]):
RegexMatchingEventHandler.__init__(self, regexes=regs)
self.reload_set = set()
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 __init__(self, *args, **kwargs):
RegexMatchingEventHandler.__init__(self, *args, **kwargs)