wandb 0.18.2__py3-none-musllinux_1_2_x86_64.whl

wandb/vendor/watchdog_0_9_0/wandb_watchdog/observers/__init__.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+:module: watchdog.observers
+:synopsis: Observer that picks a native implementation if available.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+
+
+Classes
+=======
+.. autoclass:: Observer
+   :members:
+   :show-inheritance:
+   :inherited-members:
+   
+Observer thread that schedules watching directories and dispatches
+calls to event handlers.
+
+You can also import platform specific classes directly and use it instead
+of :class:`Observer`.  Here is a list of implemented observer classes.:
+
+============== ================================ ==============================
+Class          Platforms                        Note
+============== ================================ ==============================
+|Inotify|      Linux 2.6.13+                    ``inotify(7)`` based observer
+|FSEvents|     Mac OS X                         FSEvents based observer
+|Kqueue|       Mac OS X and BSD with kqueue(2)  ``kqueue(2)`` based observer
+|WinApi|       MS Windows                       Windows API-based observer
+|Polling|      Any                              fallback implementation
+============== ================================ ==============================
+
+.. |Inotify|     replace:: :class:`.inotify.InotifyObserver`
+.. |FSEvents|    replace:: :class:`.fsevents.FSEventsObserver`
+.. |Kqueue|      replace:: :class:`.kqueue.KqueueObserver`
+.. |WinApi|      replace:: :class:`.read_directory_changes.WindowsApiObserver`
+.. |WinApiAsync| replace:: :class:`.read_directory_changes_async.WindowsApiAsyncObserver`
+.. |Polling|     replace:: :class:`.polling.PollingObserver`
+
+"""
+
+import warnings
+from wandb_watchdog.utils import platform
+from wandb_watchdog.utils import UnsupportedLibc
+
+if platform.is_linux():
+    try:
+        from .inotify import InotifyObserver as Observer
+    except UnsupportedLibc:
+        from .polling import PollingObserver as Observer
+
+elif platform.is_darwin():
+    # FIXME: catching too broad. Error prone
+    try:
+        from .fsevents import FSEventsObserver as Observer
+    except:
+        try:
+            from .kqueue import KqueueObserver as Observer
+            # Note: (tim): Commenting out these warnings since the _watchdog_fsevents
+            # module is not available unless installed directly.
+            # warnings.warn("Failed to import fsevents. Fall back to kqueue")
+        except:
+            from .polling import PollingObserver as Observer
+            # Note: (tim): Commenting out these warnings since the _watchdog_fsevents
+            # module is not available unless installed directly.
+            # warnings.warn("Failed to import fsevents and kqueue. Fall back to polling.")
+
+elif platform.is_bsd():
+    from .kqueue import KqueueObserver as Observer
+
+elif platform.is_windows():
+    # TODO: find a reliable way of checking Windows version and import
+    # polling explicitly for Windows XP
+    try:
+        from .read_directory_changes import WindowsApiObserver as Observer
+    except:
+        from .polling import PollingObserver as Observer
+        warnings.warn("Failed to import read_directory_changes. Fall back to polling.")
+
+else:
+    from .polling import PollingObserver as Observer
+
+__all__ = ["Observer"]

wandb/vendor/watchdog_0_9_0/wandb_watchdog/observers/api.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import with_statement
+import threading
+from wandb_watchdog.utils import BaseThread
+from wandb_watchdog.utils.compat import queue
+from wandb_watchdog.utils.bricks import SkipRepeatsQueue
+
+DEFAULT_EMITTER_TIMEOUT = 1    # in seconds.
+DEFAULT_OBSERVER_TIMEOUT = 1   # in seconds.
+
+
+# Collection classes
+class EventQueue(SkipRepeatsQueue):
+    """Thread-safe event queue based on a special queue that skips adding
+    the same event (:class:`FileSystemEvent`) multiple times consecutively.
+    Thus avoiding dispatching multiple event handling
+    calls when multiple identical events are produced quicker than an observer
+    can consume them.
+    """
+
+
+class ObservedWatch(object):
+    """An scheduled watch.
+
+    :param path:
+        Path string.
+    :param recursive:
+        ``True`` if watch is recursive; ``False`` otherwise.
+    """
+
+    def __init__(self, path, recursive):
+        self._path = path
+        self._is_recursive = recursive
+
+    @property
+    def path(self):
+        """The path that this watch monitors."""
+        return self._path
+
+    @property
+    def is_recursive(self):
+        """Determines whether subdirectories are watched for the path."""
+        return self._is_recursive
+
+    @property
+    def key(self):
+        return self.path, self.is_recursive
+
+    def __eq__(self, watch):
+        return self.key == watch.key
+
+    def __ne__(self, watch):
+        return self.key != watch.key
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def __repr__(self):
+        return "<ObservedWatch: path=%s, is_recursive=%s>" % (
+            self.path, self.is_recursive)
+
+
+# Observer classes
+class EventEmitter(BaseThread):
+    """
+    Producer thread base class subclassed by event emitters
+    that generate events and populate a queue with them.
+
+    :param event_queue:
+        The event queue to populate with generated events.
+    :type event_queue:
+        :class:`watchdog.events.EventQueue`
+    :param watch:
+        The watch to observe and produce events for.
+    :type watch:
+        :class:`ObservedWatch`
+    :param timeout:
+        Timeout (in seconds) between successive attempts at reading events.
+    :type timeout:
+        ``float``
+    """
+
+    def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
+        BaseThread.__init__(self)
+        self._event_queue = event_queue
+        self._watch = watch
+        self._timeout = timeout
+
+    @property
+    def timeout(self):
+        """
+        Blocking timeout for reading events.
+        """
+        return self._timeout
+
+    @property
+    def watch(self):
+        """
+        The watch associated with this emitter.
+        """
+        return self._watch
+
+    def queue_event(self, event):
+        """
+        Queues a single event.
+
+        :param event:
+            Event to be queued.
+        :type event:
+            An instance of :class:`watchdog.events.FileSystemEvent`
+            or a subclass.
+        """
+        self._event_queue.put((event, self.watch))
+
+    def queue_events(self, timeout):
+        """Override this method to populate the event queue with events
+        per interval period.
+
+        :param timeout:
+            Timeout (in seconds) between successive attempts at
+            reading events.
+        :type timeout:
+            ``float``
+        """
+
+    def run(self):
+        try:
+            while self.should_keep_running():
+                self.queue_events(self.timeout)
+        finally:
+            pass
+
+
+class EventDispatcher(BaseThread):
+    """
+    Consumer thread base class subclassed by event observer threads
+    that dispatch events from an event queue to appropriate event handlers.
+
+    :param timeout:
+        Event queue blocking timeout (in seconds).
+    :type timeout:
+        ``float``
+    """
+
+    def __init__(self, timeout=DEFAULT_OBSERVER_TIMEOUT):
+        BaseThread.__init__(self)
+        self._event_queue = EventQueue()
+        self._timeout = timeout
+
+    @property
+    def timeout(self):
+        """Event queue block timeout."""
+        return self._timeout
+
+    @property
+    def event_queue(self):
+        """The event queue which is populated with file system events
+        by emitters and from which events are dispatched by a dispatcher
+        thread."""
+        return self._event_queue
+
+    def dispatch_events(self, event_queue, timeout):
+        """Override this method to consume events from an event queue, blocking
+        on the queue for the specified timeout before raising :class:`queue.Empty`.
+
+        :param event_queue:
+            Event queue to populate with one set of events.
+        :type event_queue:
+            :class:`EventQueue`
+        :param timeout:
+            Interval period (in seconds) to wait before timing out on the
+            event queue.
+        :type timeout:
+            ``float``
+        :raises:
+            :class:`queue.Empty`
+        """
+
+    def run(self):
+        while self.should_keep_running():
+            try:
+                self.dispatch_events(self.event_queue, self.timeout)
+            except queue.Empty:
+                continue
+
+
+class BaseObserver(EventDispatcher):
+    """Base observer."""
+
+    def __init__(self, emitter_class, timeout=DEFAULT_OBSERVER_TIMEOUT):
+        EventDispatcher.__init__(self, timeout)
+        self._emitter_class = emitter_class
+        self._lock = threading.RLock()
+        self._watches = set()
+        self._handlers = dict()
+        self._emitters = set()
+        self._emitter_for_watch = dict()
+
+    def _add_emitter(self, emitter):
+        self._emitter_for_watch[emitter.watch] = emitter
+        self._emitters.add(emitter)
+
+    def _remove_emitter(self, emitter):
+        del self._emitter_for_watch[emitter.watch]
+        self._emitters.remove(emitter)
+        emitter.stop()
+        try:
+            emitter.join()
+        except RuntimeError:
+            pass
+
+    def _clear_emitters(self):
+        for emitter in self._emitters:
+            emitter.stop()
+        for emitter in self._emitters:
+            try:
+                emitter.join()
+            except RuntimeError:
+                pass
+        self._emitters.clear()
+        self._emitter_for_watch.clear()
+
+    def _add_handler_for_watch(self, event_handler, watch):
+        if watch not in self._handlers:
+            self._handlers[watch] = set()
+        self._handlers[watch].add(event_handler)
+
+    def _remove_handlers_for_watch(self, watch):
+        del self._handlers[watch]
+
+    @property
+    def emitters(self):
+        """Returns event emitter created by this observer."""
+        return self._emitters
+
+    def start(self):
+        for emitter in self._emitters:
+            emitter.start()
+        super(BaseObserver, self).start()
+
+    def schedule(self, event_handler, path, recursive=False):
+        """
+        Schedules watching a path and calls appropriate methods specified
+        in the given event handler in response to file system events.
+
+        :param event_handler:
+            An event handler instance that has appropriate event handling
+            methods which will be called by the observer in response to
+            file system events.
+        :type event_handler:
+            :class:`watchdog.events.FileSystemEventHandler` or a subclass
+        :param path:
+            Directory path that will be monitored.
+        :type path:
+            ``str``
+        :param recursive:
+            ``True`` if events will be emitted for sub-directories
+            traversed recursively; ``False`` otherwise.
+        :type recursive:
+            ``bool``
+        :return:
+            An :class:`ObservedWatch` object instance representing
+            a watch.
+        """
+        with self._lock:
+            watch = ObservedWatch(path, recursive)
+            self._add_handler_for_watch(event_handler, watch)
+
+            # If we don't have an emitter for this watch already, create it.
+            if self._emitter_for_watch.get(watch) is None:
+                emitter = self._emitter_class(event_queue=self.event_queue,
+                                              watch=watch,
+                                              timeout=self.timeout)
+                self._add_emitter(emitter)
+                if self.is_alive():
+                    emitter.start()
+            self._watches.add(watch)
+        return watch
+
+    def add_handler_for_watch(self, event_handler, watch):
+        """Adds a handler for the given watch.
+
+        :param event_handler:
+            An event handler instance that has appropriate event handling
+            methods which will be called by the observer in response to
+            file system events.
+        :type event_handler:
+            :class:`watchdog.events.FileSystemEventHandler` or a subclass
+        :param watch:
+            The watch to add a handler for.
+        :type watch:
+            An instance of :class:`ObservedWatch` or a subclass of
+            :class:`ObservedWatch`
+        """
+        with self._lock:
+            self._add_handler_for_watch(event_handler, watch)
+
+    def remove_handler_for_watch(self, event_handler, watch):
+        """Removes a handler for the given watch.
+
+        :param event_handler:
+            An event handler instance that has appropriate event handling
+            methods which will be called by the observer in response to
+            file system events.
+        :type event_handler:
+            :class:`watchdog.events.FileSystemEventHandler` or a subclass
+        :param watch:
+            The watch to remove a handler for.
+        :type watch:
+            An instance of :class:`ObservedWatch` or a subclass of
+            :class:`ObservedWatch`
+        """
+        with self._lock:
+            self._handlers[watch].remove(event_handler)
+
+    def unschedule(self, watch):
+        """Unschedules a watch.
+
+        :param watch:
+            The watch to unschedule.
+        :type watch:
+            An instance of :class:`ObservedWatch` or a subclass of
+            :class:`ObservedWatch`
+        """
+        with self._lock:
+            emitter = self._emitter_for_watch[watch]
+            del self._handlers[watch]
+            self._remove_emitter(emitter)
+            self._watches.remove(watch)
+
+    def unschedule_all(self):
+        """Unschedules all watches and detaches all associated event
+        handlers."""
+        with self._lock:
+            self._handlers.clear()
+            self._clear_emitters()
+            self._watches.clear()
+
+    def on_thread_stop(self):
+        self.unschedule_all()
+
+    def dispatch_events(self, event_queue, timeout):
+        event, watch = event_queue.get(block=True, timeout=timeout)
+
+        with self._lock:
+            # To allow unschedule/stop and safe removal of event handlers
+            # within event handlers itself, check if the handler is still
+            # registered after every dispatch.
+            for handler in list(self._handlers.get(watch, [])):
+                if handler in self._handlers.get(watch, []):
+                    handler.dispatch(event)
+        event_queue.task_done()

wandb/vendor/watchdog_0_9_0/wandb_watchdog/observers/fsevents.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+:module: watchdog.observers.fsevents
+:synopsis: FSEvents based emitter implementation.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+:platforms: Mac OS X
+"""
+
+from __future__ import with_statement
+
+import sys
+import threading
+import unicodedata
+import _watchdog_fsevents as _fsevents
+
+from wandb_watchdog.events import (
+    FileDeletedEvent,
+    FileModifiedEvent,
+    FileCreatedEvent,
+    FileMovedEvent,
+    DirDeletedEvent,
+    DirModifiedEvent,
+    DirCreatedEvent,
+    DirMovedEvent
+)
+
+from wandb_watchdog.utils.dirsnapshot import DirectorySnapshot
+from wandb_watchdog.observers.api import (
+    BaseObserver,
+    EventEmitter,
+    DEFAULT_EMITTER_TIMEOUT,
+    DEFAULT_OBSERVER_TIMEOUT
+)
+
+
+class FSEventsEmitter(EventEmitter):
+
+    """
+    Mac OS X FSEvents Emitter class.
+
+    :param event_queue:
+        The event queue to fill with events.
+    :param watch:
+        A watch object representing the directory to monitor.
+    :type watch:
+        :class:`watchdog.observers.api.ObservedWatch`
+    :param timeout:
+        Read events blocking timeout (in seconds).
+    :type timeout:
+        ``float``
+    """
+
+    def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT):
+        EventEmitter.__init__(self, event_queue, watch, timeout)
+        self._lock = threading.Lock()
+        self.snapshot = DirectorySnapshot(watch.path, watch.is_recursive)
+
+    def on_thread_stop(self):
+        _fsevents.remove_watch(self.watch)
+        _fsevents.stop(self)
+
+    def queue_events(self, timeout):
+        with self._lock:
+            if not self.watch.is_recursive\
+                and self.watch.path not in self.pathnames:
+                return
+            new_snapshot = DirectorySnapshot(self.watch.path,
+                                             self.watch.is_recursive)
+            events = new_snapshot - self.snapshot
+            self.snapshot = new_snapshot
+
+            # Files.
+            for src_path in events.files_deleted:
+                self.queue_event(FileDeletedEvent(src_path))
+            for src_path in events.files_modified:
+                self.queue_event(FileModifiedEvent(src_path))
+            for src_path in events.files_created:
+                self.queue_event(FileCreatedEvent(src_path))
+            for src_path, dest_path in events.files_moved:
+                self.queue_event(FileMovedEvent(src_path, dest_path))
+
+            # Directories.
+            for src_path in events.dirs_deleted:
+                self.queue_event(DirDeletedEvent(src_path))
+            for src_path in events.dirs_modified:
+                self.queue_event(DirModifiedEvent(src_path))
+            for src_path in events.dirs_created:
+                self.queue_event(DirCreatedEvent(src_path))
+            for src_path, dest_path in events.dirs_moved:
+                self.queue_event(DirMovedEvent(src_path, dest_path))
+
+    def run(self):
+        try:
+            def callback(pathnames, flags, emitter=self):
+                emitter.queue_events(emitter.timeout)
+
+            # for pathname, flag in zip(pathnames, flags):
+            # if emitter.watch.is_recursive: # and pathname != emitter.watch.path:
+            #    new_sub_snapshot = DirectorySnapshot(pathname, True)
+            #    old_sub_snapshot = self.snapshot.copy(pathname)
+            #    diff = new_sub_snapshot - old_sub_snapshot
+            #    self.snapshot += new_subsnapshot
+            # else:
+            #    new_snapshot = DirectorySnapshot(emitter.watch.path, False)
+            #    diff = new_snapshot - emitter.snapshot
+            #    emitter.snapshot = new_snapshot
+
+            # INFO: FSEvents reports directory notifications recursively
+            # by default, so we do not need to add subdirectory paths.
+            #pathnames = set([self.watch.path])
+            # if self.watch.is_recursive:
+            #    for root, directory_names, _ in os.walk(self.watch.path):
+            #        for directory_name in directory_names:
+            #            full_path = absolute_path(
+            #                            os.path.join(root, directory_name))
+            #            pathnames.add(full_path)
+            self.pathnames = [self.watch.path]
+            _fsevents.add_watch(self,
+                                self.watch,
+                                callback,
+                                self.pathnames)
+            _fsevents.read_events(self)
+        except:
+            pass
+
+
+class FSEventsObserver(BaseObserver):
+
+    def __init__(self, timeout=DEFAULT_OBSERVER_TIMEOUT):
+        BaseObserver.__init__(self, emitter_class=FSEventsEmitter,
+                              timeout=timeout)
+
+    def schedule(self, event_handler, path, recursive=False):
+        # Python 2/3 compat
+        try:
+            str_class = unicode
+        except NameError:
+            str_class = str
+
+        # Fix for issue #26: Trace/BPT error when given a unicode path
+        # string. https://github.com/gorakhargosh/watchdog/issues#issue/26
+        if isinstance(path, str_class):
+            #path = unicode(path, 'utf-8')
+            path = unicodedata.normalize('NFC', path)
+            # We only encode the path in Python 2 for backwards compatibility.
+            # On Python 3 we want the path to stay as unicode if possible for
+            # the sake of path matching not having to be rewritten to use the
+            # bytes API instead of strings. The _watchdog_fsevent.so code for
+            # Python 3 can handle both str and bytes paths, which is why we
+            # do not HAVE to encode it with Python 3. The Python 2 code in
+            # _watchdog_fsevents.so was not changed for the sake of backwards
+            # compatibility.
+            if sys.version_info < (3,):
+                path = path.encode('utf-8')
+        return BaseObserver.schedule(self, event_handler, path, recursive)