wandb 0.19.1rc1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/watchdog_0_9_0/wandb_watchdog/patterns.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# patterns.py: Common wildcard searching/filtering functionality for files.
+#
+# Copyright (C) 2010 Yesudeep Mangalapilly <yesudeep@gmail.com>
+#
+# 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.
+
+"""
+:module: pathtools.patterns
+:synopsis: Wildcard pattern matching and filtering functions for paths.
+:author: Yesudeep Mangalapilly <yesudeep@gmail.com>
+
+Functions
+---------
+.. autofunction:: match_path
+.. autofunction:: match_path_against
+.. autofunction:: filter_paths
+"""
+
+from fnmatch import fnmatch, fnmatchcase
+
+__all__ = ['match_path',
+           'match_path_against',
+           'match_any_paths',
+           'filter_paths']
+
+
+def _string_lower(s):
+    """
+    Convenience function to lowercase a string (the :mod:`string` module is
+    deprecated/removed in Python 3.0).
+
+    :param s:
+        The string which will be lowercased.
+    :returns:
+        Lowercased copy of string s.
+    """
+    return s.lower()
+
+
+def match_path_against(pathname, patterns, case_sensitive=True):
+    """
+    Determines whether the pathname matches any of the given wildcard patterns,
+    optionally ignoring the case of the pathname and patterns.
+
+    :param pathname:
+        A path name that will be matched against a wildcard pattern.
+    :param patterns:
+        A list of wildcard patterns to match_path the filename against.
+    :param case_sensitive:
+        ``True`` if the matching should be case-sensitive; ``False`` otherwise.
+    :returns:
+        ``True`` if the pattern matches; ``False`` otherwise.
+
+    Doctests::
+        >>> match_path_against("/home/username/foobar/blah.py", ["*.py", "*.txt"], False)
+        True
+        >>> match_path_against("/home/username/foobar/blah.py", ["*.PY", "*.txt"], True)
+        False
+        >>> match_path_against("/home/username/foobar/blah.py", ["*.PY", "*.txt"], False)
+        True
+        >>> match_path_against("C:\\windows\\blah\\BLAH.PY", ["*.py", "*.txt"], True)
+        False
+        >>> match_path_against("C:\\windows\\blah\\BLAH.PY", ["*.py", "*.txt"], False)
+        True
+    """
+    if case_sensitive:
+        match_func = fnmatchcase
+        pattern_transform_func = (lambda w: w)
+    else:
+        match_func = fnmatch
+        pathname = pathname.lower()
+        pattern_transform_func = _string_lower
+    for pattern in set(patterns):
+        pattern = pattern_transform_func(pattern)
+        if match_func(pathname, pattern):
+            return True
+    return False
+
+
+def _match_path(pathname,
+                included_patterns,
+                excluded_patterns,
+                case_sensitive=True):
+    """Internal function same as :func:`match_path` but does not check arguments.
+
+    Doctests::
+        >>> _match_path("/users/gorakhargosh/foobar.py", ["*.py"], ["*.PY"], True)
+        True
+        >>> _match_path("/users/gorakhargosh/FOOBAR.PY", ["*.py"], ["*.PY"], True)
+        False
+        >>> _match_path("/users/gorakhargosh/foobar/", ["*.py"], ["*.txt"], False)
+        False
+        >>> _match_path("/users/gorakhargosh/FOOBAR.PY", ["*.py"], ["*.PY"], False)
+        Traceback (most recent call last):
+            ...
+        ValueError: conflicting patterns `set(['*.py'])` included and excluded
+    """
+    if not case_sensitive:
+        included_patterns = set(map(_string_lower, included_patterns))
+        excluded_patterns = set(map(_string_lower, excluded_patterns))
+    else:
+        included_patterns = set(included_patterns)
+        excluded_patterns = set(excluded_patterns)
+    common_patterns = included_patterns & excluded_patterns
+    if common_patterns:
+        raise ValueError('conflicting patterns `%s` included and excluded'\
+                         % common_patterns)
+    return (match_path_against(pathname, included_patterns, case_sensitive)\
+            and not match_path_against(pathname, excluded_patterns,
+                                       case_sensitive))
+
+
+def match_path(pathname,
+               included_patterns=None,
+               excluded_patterns=None,
+               case_sensitive=True):
+    """
+    Matches a pathname against a set of acceptable and ignored patterns.
+
+    :param pathname:
+        A pathname which will be matched against a pattern.
+    :param included_patterns:
+        Allow filenames matching wildcard patterns specified in this list.
+        If no pattern is specified, the function treats the pathname as
+        a match_path.
+    :param excluded_patterns:
+        Ignores filenames matching wildcard patterns specified in this list.
+        If no pattern is specified, the function treats the pathname as
+        a match_path.
+    :param case_sensitive:
+        ``True`` if matching should be case-sensitive; ``False`` otherwise.
+    :returns:
+        ``True`` if the pathname matches; ``False`` otherwise.
+    :raises:
+        ValueError if included patterns and excluded patterns contain the
+        same pattern.
+
+    Doctests::
+        >>> match_path("/Users/gorakhargosh/foobar.py")
+        True
+        >>> match_path("/Users/gorakhargosh/foobar.py", case_sensitive=False)
+        True
+        >>> match_path("/users/gorakhargosh/foobar.py", ["*.py"], ["*.PY"], True)
+        True
+        >>> match_path("/users/gorakhargosh/FOOBAR.PY", ["*.py"], ["*.PY"], True)
+        False
+        >>> match_path("/users/gorakhargosh/foobar/", ["*.py"], ["*.txt"], False)
+        False
+        >>> match_path("/users/gorakhargosh/FOOBAR.PY", ["*.py"], ["*.PY"], False)
+        Traceback (most recent call last):
+            ...
+        ValueError: conflicting patterns `set(['*.py'])` included and excluded
+    """
+    included = ["*"] if included_patterns is None else included_patterns
+    excluded = [] if excluded_patterns is None else excluded_patterns
+    return _match_path(pathname, included, excluded, case_sensitive)
+
+
+def filter_paths(pathnames,
+                 included_patterns=None,
+                 excluded_patterns=None,
+                 case_sensitive=True):
+    """
+    Filters from a set of paths based on acceptable patterns and
+    ignorable patterns.
+
+    :param pathnames:
+        A list of path names that will be filtered based on matching and
+        ignored patterns.
+    :param included_patterns:
+        Allow filenames matching wildcard patterns specified in this list.
+        If no pattern list is specified, ["*"] is used as the default pattern,
+        which matches all files.
+    :param excluded_patterns:
+        Ignores filenames matching wildcard patterns specified in this list.
+        If no pattern list is specified, no files are ignored.
+    :param case_sensitive:
+        ``True`` if matching should be case-sensitive; ``False`` otherwise.
+    :returns:
+        A list of pathnames that matched the allowable patterns and passed
+        through the ignored patterns.
+
+    Doctests::
+        >>> pathnames = set(["/users/gorakhargosh/foobar.py", "/var/cache/pdnsd.status", "/etc/pdnsd.conf", "/usr/local/bin/python"])
+        >>> set(filter_paths(pathnames)) == pathnames
+        True
+        >>> set(filter_paths(pathnames, case_sensitive=False)) == pathnames
+        True
+        >>> set(filter_paths(pathnames, ["*.py", "*.conf"], ["*.status"], case_sensitive=True)) == set(["/users/gorakhargosh/foobar.py", "/etc/pdnsd.conf"])
+        True
+    """
+    included = ["*"] if included_patterns is None else included_patterns
+    excluded = [] if excluded_patterns is None else excluded_patterns
+
+    for pathname in pathnames:
+        # We don't call the public match_path because it checks arguments
+        # and sets default values if none are found. We're already doing that
+        # above.
+        if _match_path(pathname, included, excluded, case_sensitive):
+            yield pathname
+
+def match_any_paths(pathnames,
+                    included_patterns=None,
+                    excluded_patterns=None,
+                    case_sensitive=True):
+    """
+    Matches from a set of paths based on acceptable patterns and
+    ignorable patterns.
+
+    :param pathnames:
+        A list of path names that will be filtered based on matching and
+        ignored patterns.
+    :param included_patterns:
+        Allow filenames matching wildcard patterns specified in this list.
+        If no pattern list is specified, ["*"] is used as the default pattern,
+        which matches all files.
+    :param excluded_patterns:
+        Ignores filenames matching wildcard patterns specified in this list.
+        If no pattern list is specified, no files are ignored.
+    :param case_sensitive:
+        ``True`` if matching should be case-sensitive; ``False`` otherwise.
+    :returns:
+        ``True`` if any of the paths matches; ``False`` otherwise.
+
+    Doctests::
+        >>> pathnames = set(["/users/gorakhargosh/foobar.py", "/var/cache/pdnsd.status", "/etc/pdnsd.conf", "/usr/local/bin/python"])
+        >>> match_any_paths(pathnames)
+        True
+        >>> match_any_paths(pathnames, case_sensitive=False)
+        True
+        >>> match_any_paths(pathnames, ["*.py", "*.conf"], ["*.status"], case_sensitive=True)
+        True
+        >>> match_any_paths(pathnames, ["*.txt"], case_sensitive=False)
+        False
+        >>> match_any_paths(pathnames, ["*.txt"], case_sensitive=True)
+        False
+    """
+    included = ["*"] if included_patterns is None else included_patterns
+    excluded = [] if excluded_patterns is None else excluded_patterns
+
+    for pathname in pathnames:
+        # We don't call the public match_path because it checks arguments
+        # and sets default values if none are found. We're already doing that
+        # above.
+        if _match_path(pathname, included, excluded, case_sensitive):
+            return True
+    return False

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

@@ -0,0 +1,174 @@
+#!/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 os
+import signal
+import subprocess
+import time
+
+from wandb_watchdog.utils import echo, has_attribute
+from wandb_watchdog.events import PatternMatchingEventHandler
+
+
+class Trick(PatternMatchingEventHandler):
+
+    """Your tricks should subclass this class."""
+
+    @classmethod
+    def generate_yaml(cls):
+        context = dict(module_name=cls.__module__,
+                       klass_name=cls.__name__)
+        template_yaml = """- %(module_name)s.%(klass_name)s:
+  args:
+  - argument1
+  - argument2
+  kwargs:
+    patterns:
+    - "*.py"
+    - "*.js"
+    ignore_patterns:
+    - "version.py"
+    ignore_directories: false
+"""
+        return template_yaml % context
+
+
+class LoggerTrick(Trick):
+
+    """A simple trick that does only logs events."""
+
+    def on_any_event(self, event):
+        pass
+
+    @echo.echo
+    def on_modified(self, event):
+        pass
+
+    @echo.echo
+    def on_deleted(self, event):
+        pass
+
+    @echo.echo
+    def on_created(self, event):
+        pass
+
+    @echo.echo
+    def on_moved(self, event):
+        pass
+
+
+class ShellCommandTrick(Trick):
+
+    """Executes shell commands in response to matched events."""
+
+    def __init__(self, shell_command=None, patterns=None, ignore_patterns=None,
+                 ignore_directories=False, wait_for_process=False,
+                 drop_during_process=False):
+        super(ShellCommandTrick, self).__init__(patterns, ignore_patterns,
+                                                ignore_directories)
+        self.shell_command = shell_command
+        self.wait_for_process = wait_for_process
+        self.drop_during_process = drop_during_process
+        self.process = None
+
+    def on_any_event(self, event):
+        from string import Template
+
+        if self.drop_during_process and self.process and self.process.poll() is None:
+            return
+
+        if event.is_directory:
+            object_type = 'directory'
+        else:
+            object_type = 'file'
+
+        context = {
+            'watch_src_path': event.src_path,
+            'watch_dest_path': '',
+            'watch_event_type': event.event_type,
+            'watch_object': object_type,
+        }
+
+        if self.shell_command is None:
+            if has_attribute(event, 'dest_path'):
+                context.update({'dest_path': event.dest_path})
+                command = 'echo "${watch_event_type} ${watch_object} from ${watch_src_path} to ${watch_dest_path}"'
+            else:
+                command = 'echo "${watch_event_type} ${watch_object} ${watch_src_path}"'
+        else:
+            if has_attribute(event, 'dest_path'):
+                context.update({'watch_dest_path': event.dest_path})
+            command = self.shell_command
+
+        command = Template(command).safe_substitute(**context)
+        self.process = subprocess.Popen(command, shell=True)
+        if self.wait_for_process:
+            self.process.wait()
+
+
+class AutoRestartTrick(Trick):
+
+    """Starts a long-running subprocess and restarts it on matched events.
+
+    The command parameter is a list of command arguments, such as
+    ['bin/myserver', '-c', 'etc/myconfig.ini'].
+
+    Call start() after creating the Trick. Call stop() when stopping
+    the process.
+    """
+
+    def __init__(self, command, patterns=None, ignore_patterns=None,
+                 ignore_directories=False, stop_signal=signal.SIGINT,
+                 kill_after=10):
+        super(AutoRestartTrick, self).__init__(
+            patterns, ignore_patterns, ignore_directories)
+        self.command = command
+        self.stop_signal = stop_signal
+        self.kill_after = kill_after
+        self.process = None
+
+    def start(self):
+        self.process = subprocess.Popen(self.command, preexec_fn=os.setsid)
+
+    def stop(self):
+        if self.process is None:
+            return
+        try:
+            os.killpg(os.getpgid(self.process.pid), self.stop_signal)
+        except OSError:
+            # Process is already gone
+            pass
+        else:
+            kill_time = time.time() + self.kill_after
+            while time.time() < kill_time:
+                if self.process.poll() is not None:
+                    break
+                time.sleep(0.25)
+            else:
+                try:
+                    os.killpg(os.getpgid(self.process.pid), 9)
+                except OSError:
+                    # Process is already gone
+                    pass
+        self.process = None
+
+    @echo.echo
+    def on_any_event(self, event):
+        self.stop()
+        self.start()

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

@@ -0,0 +1,151 @@
+#!/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.utils
+:synopsis: Utility classes and functions.
+:author: yesudeep@google.com (Yesudeep Mangalapilly)
+
+Classes
+-------
+.. autoclass:: BaseThread
+   :members:
+   :show-inheritance:
+   :inherited-members:
+
+"""
+import os
+import sys
+import threading
+from wandb_watchdog.utils import platform
+from wandb_watchdog.utils.compat import Event
+
+
+if sys.version_info[0] == 2 and platform.is_windows():
+    # st_ino is not implemented in os.stat on this platform
+    import win32stat
+    stat = win32stat.stat
+else:
+    stat = os.stat
+
+
+def has_attribute(ob, attribute):
+    """
+    :func:`hasattr` swallows exceptions. :func:`has_attribute` tests a Python object for the
+    presence of an attribute.
+
+    :param ob:
+        object to inspect
+    :param attribute:
+        ``str`` for the name of the attribute.
+    """
+    return getattr(ob, attribute, None) is not None
+
+
+class UnsupportedLibc(Exception):
+    pass
+
+
+class BaseThread(threading.Thread):
+    """ Convenience class for creating stoppable threads. """
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.daemon = True
+        self._stopped_event = Event()
+
+    @property
+    def stopped_event(self):
+        return self._stopped_event
+
+    def should_keep_running(self):
+        """Determines whether the thread should continue running."""
+        return not self._stopped_event.is_set()
+
+    def on_thread_stop(self):
+        """Override this method instead of :meth:`stop()`.
+        :meth:`stop()` calls this method.
+
+        This method is called immediately after the thread is signaled to stop.
+        """
+        pass
+
+    def stop(self):
+        """Signals the thread to stop."""
+        self._stopped_event.set()
+        self.on_thread_stop()
+
+    def on_thread_start(self):
+        """Override this method instead of :meth:`start()`. :meth:`start()`
+        calls this method.
+
+        This method is called right before this thread is started and this
+        object’s run() method is invoked.
+        """
+        pass
+
+    def start(self):
+        self.on_thread_start()
+        threading.Thread.start(self)
+
+
+def load_module(module_name):
+    """Imports a module given its name and returns a handle to it."""
+    try:
+        __import__(module_name)
+    except ImportError:
+        raise ImportError('No module named %s' % module_name)
+    return sys.modules[module_name]
+
+
+def load_class(dotted_path):
+    """Loads and returns a class definition provided a dotted path
+    specification the last part of the dotted path is the class name
+    and there is at least one module name preceding the class name.
+
+    Notes:
+    You will need to ensure that the module you are trying to load
+    exists in the Python path.
+
+    Examples:
+    - module.name.ClassName    # Provided module.name is in the Python path.
+    - module.ClassName         # Provided module is in the Python path.
+
+    What won't work:
+    - ClassName
+    - modle.name.ClassName     # Typo in module name.
+    - module.name.ClasNam      # Typo in classname.
+    """
+    dotted_path_split = dotted_path.split('.')
+    if len(dotted_path_split) > 1:
+        klass_name = dotted_path_split[-1]
+        module_name = '.'.join(dotted_path_split[:-1])
+
+        module = load_module(module_name)
+        if has_attribute(module, klass_name):
+            klass = getattr(module, klass_name)
+            return klass
+            # Finally create and return an instance of the class
+            # return klass(*args, **kwargs)
+        else:
+            raise AttributeError('Module %s does not have class attribute %s' % (
+                                 module_name, klass_name))
+    else:
+        raise ValueError(
+            'Dotted module path %s must contain a module name and a classname' % dotted_path)