wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/dirsnapshot.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
+# Copyright 2012 Google, Inc.
+# Copyright 2014 Thomas Amland <thomas.amland@gmail.com>
+#
+# 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.utils.dirsnapshot
+:synopsis: Directory snapshots and comparison.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+
+.. ADMONITION:: Where are the moved events? They "disappeared"
+
+        This implementation does not take partition boundaries
+        into consideration. It will only work when the directory
+        tree is entirely on the same file system. More specifically,
+        any part of the code that depends on inode numbers can
+        break if partition boundaries are crossed. In these cases,
+        the snapshot diff will represent file/directory movement as
+        created and deleted events.
+
+Classes
+-------
+.. autoclass:: DirectorySnapshot
+   :members:
+   :show-inheritance:
+
+.. autoclass:: DirectorySnapshotDiff
+   :members:
+   :show-inheritance:
+
+"""
+
+import errno
+import os
+from stat import S_ISDIR
+from wandb_watchdog.utils import stat as default_stat
+
+
+class DirectorySnapshotDiff(object):
+    """
+    Compares two directory snapshots and creates an object that represents
+    the difference between the two snapshots.
+
+    :param ref:
+        The reference directory snapshot.
+    :type ref:
+        :class:`DirectorySnapshot`
+    :param snapshot:
+        The directory snapshot which will be compared
+        with the reference snapshot.
+    :type snapshot:
+        :class:`DirectorySnapshot`
+    """
+    
+    def __init__(self, ref, snapshot):
+        created = snapshot.paths - ref.paths
+        deleted = ref.paths - snapshot.paths
+        
+        # check that all unchanged paths have the same inode
+        for path in ref.paths & snapshot.paths:
+            if ref.inode(path) != snapshot.inode(path):
+                created.add(path)
+                deleted.add(path)
+        
+        # find moved paths
+        moved = set()
+        for path in set(deleted):
+            inode = ref.inode(path)
+            new_path = snapshot.path(inode)
+            if new_path:
+                # file is not deleted but moved
+                deleted.remove(path)
+                moved.add((path, new_path))
+        
+        for path in set(created):
+            inode = snapshot.inode(path)
+            old_path = ref.path(inode)
+            if old_path:
+                created.remove(path)
+                moved.add((old_path, path))
+        
+        # find modified paths
+        # first check paths that have not moved
+        modified = set()
+        for path in ref.paths & snapshot.paths:
+            if ref.inode(path) == snapshot.inode(path):
+                if ref.mtime(path) != snapshot.mtime(path):
+                    modified.add(path)
+        
+        for (old_path, new_path) in moved:
+            if ref.mtime(old_path) != snapshot.mtime(new_path):
+                modified.add(old_path)
+        
+        self._dirs_created = [path for path in created if snapshot.isdir(path)]
+        self._dirs_deleted = [path for path in deleted if ref.isdir(path)]
+        self._dirs_modified = [path for path in modified if ref.isdir(path)]
+        self._dirs_moved = [(frm, to) for (frm, to) in moved if ref.isdir(frm)]
+        
+        self._files_created = list(created - set(self._dirs_created))
+        self._files_deleted = list(deleted - set(self._dirs_deleted))
+        self._files_modified = list(modified - set(self._dirs_modified))
+        self._files_moved = list(moved - set(self._dirs_moved))
+    
+    @property
+    def files_created(self):
+        """List of files that were created."""
+        return self._files_created
+
+    @property
+    def files_deleted(self):
+        """List of files that were deleted."""
+        return self._files_deleted
+
+    @property
+    def files_modified(self):
+        """List of files that were modified."""
+        return self._files_modified
+
+    @property
+    def files_moved(self):
+        """
+        List of files that were moved.
+
+        Each event is a two-tuple the first item of which is the path
+        that has been renamed to the second item in the tuple.
+        """
+        return self._files_moved
+
+    @property
+    def dirs_modified(self):
+        """
+        List of directories that were modified.
+        """
+        return self._dirs_modified
+
+    @property
+    def dirs_moved(self):
+        """
+        List of directories that were moved.
+
+        Each event is a two-tuple the first item of which is the path
+        that has been renamed to the second item in the tuple.
+        """
+        return self._dirs_moved
+
+    @property
+    def dirs_deleted(self):
+        """
+        List of directories that were deleted.
+        """
+        return self._dirs_deleted
+
+    @property
+    def dirs_created(self):
+        """
+        List of directories that were created.
+        """
+        return self._dirs_created
+
+class DirectorySnapshot(object):
+    """
+    A snapshot of stat information of files in a directory.
+
+    :param path:
+        The directory path for which a snapshot should be taken.
+    :type path:
+        ``str``
+    :param recursive:
+        ``True`` if the entire directory tree should be included in the
+        snapshot; ``False`` otherwise.
+    :type recursive:
+        ``bool``
+    :param walker_callback:
+        .. deprecated:: 0.7.2
+    :param stat:
+        Use custom stat function that returns a stat structure for path.
+        Currently only st_dev, st_ino, st_mode and st_mtime are needed.
+        
+        A function with the signature ``walker_callback(path, stat_info)``
+        which will be called for every entry in the directory tree.
+    :param listdir:
+        Use custom listdir function. See ``os.listdir`` for details.
+    """
+    
+    def __init__(self, path, recursive=True,
+                 walker_callback=(lambda p, s: None),
+                 stat=default_stat,
+                 listdir=os.listdir):
+        self._stat_info = {}
+        self._inode_to_path = {}
+        
+        st = stat(path)
+        self._stat_info[path] = st
+        self._inode_to_path[(st.st_ino, st.st_dev)] = path
+
+        def walk(root):
+            try:
+                paths = [os.path.join(root, name) for name in listdir(root)]
+            except OSError as e:
+                # Directory may have been deleted between finding it in the directory
+                # list of its parent and trying to delete its contents. If this
+                # happens we treat it as empty.
+                if e.errno == errno.ENOENT:
+                    return
+                else:
+                    raise
+            entries = []
+            for p in paths:
+                try:
+                    entries.append((p, stat(p)))
+                except OSError:
+                    continue
+            for _ in entries:
+                yield _
+            if recursive:
+                for path, st in entries:
+                    if S_ISDIR(st.st_mode):
+                        for _ in walk(path):
+                            yield _
+
+        for p, st in walk(path):
+            i = (st.st_ino, st.st_dev)
+            self._inode_to_path[i] = p
+            self._stat_info[p] = st
+            walker_callback(p, st)
+
+    @property
+    def paths(self):
+        """
+        Set of file/directory paths in the snapshot.
+        """
+        return set(self._stat_info.keys())
+    
+    def path(self, id):
+        """
+        Returns path for id. None if id is unknown to this snapshot.
+        """
+        return self._inode_to_path.get(id)
+    
+    def inode(self, path):
+        """ Returns an id for path. """
+        st = self._stat_info[path]
+        return (st.st_ino, st.st_dev)
+    
+    def isdir(self, path):
+        return S_ISDIR(self._stat_info[path].st_mode)
+    
+    def mtime(self, path):
+        return self._stat_info[path].st_mtime
+    
+    def stat_info(self, path):
+        """
+        Returns a stat information object for the specified path from
+        the snapshot.
+
+        Attached information is subject to change. Do not use unless
+        you specify `stat` in constructor. Use :func:`inode`, :func:`mtime`,
+        :func:`isdir` instead.
+
+        :param path:
+            The path for which stat information should be obtained
+            from a snapshot.
+        """
+        return self._stat_info[path]
+
+    def __sub__(self, previous_dirsnap):
+        """Allow subtracting a DirectorySnapshot object instance from
+        another.
+
+        :returns:
+            A :class:`DirectorySnapshotDiff` object.
+        """
+        return DirectorySnapshotDiff(previous_dirsnap, self)
+    
+    def __str__(self):
+        return self.__repr__()
+    
+    def __repr__(self):
+        return str(self._stat_info)

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/echo.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# echo.py: Tracing function calls using Python decorators.
+#
+# Written by Thomas Guest <tag@wordaligned.org>
+# Please see http://wordaligned.org/articles/echo
+#
+# Place into the public domain.
+
+""" Echo calls made to functions and methods in a module.
+
+"Echoing" a function call means printing out the name of the function
+and the values of its arguments before making the call (which is more
+commonly referred to as "tracing", but Python already has a trace module).
+
+Example: to echo calls made to functions in "my_module" do:
+
+  import echo
+  import my_module
+  echo.echo_module(my_module)
+
+Example: to echo calls made to functions in "my_module.my_class" do:
+
+  echo.echo_class(my_module.my_class)
+
+Alternatively, echo.echo can be used to decorate functions. Calls to the
+decorated function will be echoed.
+
+Example:
+
+  @echo.echo
+  def my_function(args):
+      pass
+"""
+import inspect
+import sys
+
+
+def name(item):
+    " Return an item's name. "
+    return item.__name__
+
+
+def is_classmethod(instancemethod, klass):
+    " Determine if an instancemethod is a classmethod. "
+    return inspect.ismethod(instancemethod) and instancemethod.__self__ is klass
+
+def is_static_method(method, klass):
+    """Returns True if method is an instance method of klass."""
+    for c in klass.mro():
+        if name(method) in c.__dict__:
+            return isinstance(c.__dict__[name(method)], staticmethod)
+    else:
+        return False
+
+def is_class_private_name(name):
+    " Determine if a name is a class private name. "
+    # Exclude system defined names such as __init__, __add__ etc
+    return name.startswith("__") and not name.endswith("__")
+
+
+def method_name(method):
+    """ Return a method's name.
+
+    This function returns the name the method is accessed by from
+    outside the class (i.e. it prefixes "private" methods appropriately).
+    """
+    mname = name(method)
+    if is_class_private_name(mname):
+        mname = "_%s%s" % (name(method.__self__.__class__), mname)
+    return mname
+
+
+def format_arg_value(arg_val):
+    """ Return a string representing a (name, value) pair.
+
+    >>> format_arg_value(('x', (1, 2, 3)))
+    'x=(1, 2, 3)'
+    """
+    arg, val = arg_val
+    return "%s=%r" % (arg, val)
+
+
+def echo(fn, write=sys.stdout.write):
+    """ Echo calls to a function.
+
+    Returns a decorated version of the input function which "echoes" calls
+    made to it by writing out the function's name and the arguments it was
+    called with.
+    """
+    import functools
+    # Unpack function's arg count, arg names, arg defaults
+    code = fn.__code__
+    argcount = code.co_argcount
+    argnames = code.co_varnames[:argcount]
+    fn_defaults = fn.__defaults__ or list()
+    argdefs = dict(list(zip(argnames[-len(fn_defaults):], fn_defaults)))
+
+    @functools.wraps(fn)
+    def wrapped(*v, **k):
+        # Collect function arguments by chaining together positional,
+        # defaulted, extra positional and keyword arguments.
+        positional = list(map(format_arg_value, list(zip(argnames, v))))
+        defaulted = [format_arg_value((a, argdefs[a]))
+                     for a in argnames[len(v):] if a not in k]
+        nameless = list(map(repr, v[argcount:]))
+        keyword = list(map(format_arg_value, list(k.items())))
+        args = positional + defaulted + nameless + keyword
+        write("%s(%s)\n" % (name(fn), ", ".join(args)))
+        return fn(*v, **k)
+
+    return wrapped
+
+
+def echo_instancemethod(klass, method, write=sys.stdout.write):
+    """ Change an instancemethod so that calls to it are echoed.
+
+    Replacing a classmethod is a little more tricky.
+    See: http://www.python.org/doc/current/ref/types.html
+    """
+    mname = method_name(method)
+    never_echo = "__str__", "__repr__",  # Avoid recursion printing method calls
+    if mname in never_echo:
+        pass
+    elif is_classmethod(method, klass):
+        setattr(klass, mname, classmethod(echo(method.__func__, write)))
+    else:
+        setattr(klass, mname, echo(method, write))
+
+def echo_class(klass, write=sys.stdout.write):
+    """ Echo calls to class methods and static functions
+    """
+    for _, method in inspect.getmembers(klass, inspect.ismethod):
+        #In python 3 only class methods are returned here, but in python2 instance methods are too.
+        echo_instancemethod(klass, method, write)
+    for _, fn in inspect.getmembers(klass, inspect.isfunction):
+        if is_static_method(fn, klass):
+            setattr(klass, name(fn), staticmethod(echo(fn, write)))
+        else:
+            #It's not a class or a static method, so it must be an instance method.
+            #This should only be called in python 3, because in python 3 instance methods are considered functions.
+            echo_instancemethod(klass, fn, write)
+
+def echo_module(mod, write=sys.stdout.write):
+    """ Echo calls to functions and methods in a module.
+    """
+    for fname, fn in inspect.getmembers(mod, inspect.isfunction):
+        setattr(mod, fname, echo(fn, write))
+    for _, klass in inspect.getmembers(mod, inspect.isclass):
+        echo_class(klass, write)
+
+if __name__ == "__main__":
+    import doctest
+
+    optionflags = doctest.ELLIPSIS
+    doctest.testfile('echoexample.txt', optionflags=optionflags)
+    doctest.testmod(optionflags=optionflags)

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/event_backport.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Backport of Event from py2.7 (method wait in py2.6 returns None)
+
+from threading import Condition, Lock
+
+
+class Event(object):
+
+    def __init__(self,):
+        self.__cond = Condition(Lock())
+        self.__flag = False
+
+    def isSet(self):
+        return self.__flag
+
+    is_set = isSet
+
+    def set(self):
+        self.__cond.acquire()
+        try:
+            self.__flag = True
+            self.__cond.notify_all()
+        finally:
+            self.__cond.release()
+
+    def clear(self):
+        self.__cond.acquire()
+        try:
+            self.__flag = False
+        finally:
+            self.__cond.release()
+
+    def wait(self, timeout=None):
+        self.__cond.acquire()
+        try:
+            if not self.__flag:
+                self.__cond.wait(timeout)
+            return self.__flag
+        finally:
+            self.__cond.release()

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/importlib2.py

@@ -0,0 +1,40 @@
+# The MIT License (MIT)
+
+# Copyright (c) 2013 Peter M. Elias
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE
+
+
+def import_module(target, relative_to=None):
+    target_parts = target.split('.')
+    target_depth = target_parts.count('')
+    target_path = target_parts[target_depth:]
+    target = target[target_depth:]
+    fromlist = [target]
+    if target_depth and relative_to:
+        relative_parts = relative_to.split('.')
+        relative_to = '.'.join(relative_parts[:-(target_depth - 1) or None])
+    if len(target_path) > 1:
+        relative_to = '.'.join(filter(None, [relative_to]) + target_path[:-1])
+        fromlist = target_path[-1:]
+        target = fromlist[0]
+    elif not relative_to:
+        fromlist = []
+    mod = __import__(relative_to or target, globals(), locals(), fromlist)
+    return getattr(mod, target, mod)

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/platform.py

@@ -0,0 +1,57 @@
+#!/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.
+
+
+import sys
+
+PLATFORM_WINDOWS = 'windows'
+PLATFORM_LINUX = 'linux'
+PLATFORM_BSD = 'bsd'
+PLATFORM_DARWIN = 'darwin'
+PLATFORM_UNKNOWN = 'unknown'
+
+
+def get_platform_name():
+    if sys.platform.startswith("win"):
+        return PLATFORM_WINDOWS
+    elif sys.platform.startswith('darwin'):
+        return PLATFORM_DARWIN
+    elif sys.platform.startswith('linux'):
+        return PLATFORM_LINUX
+    elif sys.platform.startswith(('dragonfly', 'freebsd', 'netbsd', 'openbsd', )):
+        return PLATFORM_BSD
+    else:
+        return PLATFORM_UNKNOWN
+
+__platform__ = get_platform_name()
+
+
+def is_linux():
+    return __platform__ == PLATFORM_LINUX
+
+
+def is_bsd():
+    return __platform__ == PLATFORM_BSD
+
+
+def is_darwin():
+    return __platform__ == PLATFORM_DARWIN
+
+
+def is_windows():
+    return __platform__ == PLATFORM_WINDOWS

wandb/vendor/watchdog_0_9_0/wandb_watchdog/utils/unicode_paths.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2013 Will Bond <will@wbond.net>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+import sys
+
+from wandb_watchdog.utils import platform
+
+try:
+    # Python 2
+    str_cls = unicode
+    bytes_cls = str
+except NameError:
+    # Python 3
+    str_cls = str
+    bytes_cls = bytes
+
+
+# This is used by Linux when the locale seems to be improperly set. UTF-8 tends
+# to be the encoding used by all distros, so this is a good fallback.
+fs_fallback_encoding = 'utf-8'
+fs_encoding = sys.getfilesystemencoding() or fs_fallback_encoding
+
+
+def encode(path):
+    if isinstance(path, str_cls):
+        try:
+            path = path.encode(fs_encoding, 'strict')
+        except UnicodeEncodeError:
+            if not platform.is_linux():
+                raise
+            path = path.encode(fs_fallback_encoding, 'strict')
+    return path
+
+
+def decode(path):
+    if isinstance(path, bytes_cls):
+        try:
+            path = path.decode(fs_encoding, 'strict')
+        except UnicodeDecodeError:
+            if not platform.is_linux():
+                raise
+            path = path.decode(fs_fallback_encoding, 'strict')
+    return path