wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/promise-2.3.0/wandb_promise/promise_list.py

@@ -0,0 +1,151 @@
+from functools import partial
+try:
+    from collections.abc import Iterable
+except ImportError:
+    from collections import Iterable
+
+if False:
+    from .promise import Promise
+    from typing import (
+        Any,
+        Optional,
+        Tuple,
+        Union,
+        List,
+        Type,
+        Collection,
+    )  # flake8: noqa
+
+
+class PromiseList(object):
+
+    __slots__ = ("_values", "_length", "_total_resolved", "promise", "_promise_class")
+
+    def __init__(self, values, promise_class):
+        # type: (Union[Collection, Promise[Collection]], Type[Promise]) -> None
+        self._promise_class = promise_class
+        self.promise = self._promise_class()
+
+        self._length = 0
+        self._total_resolved = 0
+        self._values = None  # type: Optional[Collection]
+        Promise = self._promise_class
+        if Promise.is_thenable(values):
+            values_as_promise = Promise._try_convert_to_promise(
+                values
+            )._target()  # type: ignore
+            self._init_promise(values_as_promise)
+        else:
+            self._init(values)  # type: ignore
+
+    def __len__(self):
+        # type: () -> int
+        return self._length
+
+    def _init_promise(self, values):
+        # type: (Promise[Collection]) -> None
+        if values.is_fulfilled:
+            values = values._value()
+        elif values.is_rejected:
+            self._reject(values._reason())
+            return
+
+        self.promise._is_async_guaranteed = True
+        values._then(self._init, self._reject)
+        return
+
+    def _init(self, values):
+        # type: (Collection) -> None
+        self._values = values
+        if not isinstance(values, Iterable):
+            err = Exception(
+                "PromiseList requires an iterable. Received {}.".format(repr(values))
+            )
+            self.promise._reject_callback(err, False)
+            return
+
+        if not values:
+            self._resolve([])
+            return
+
+        self._iterate(values)
+        return
+
+    def _iterate(self, values):
+        # type: (Collection[Any]) -> None
+        Promise = self._promise_class
+        is_resolved = False
+
+        self._length = len(values)
+        self._values = [None] * self._length
+
+        result = self.promise
+
+        for i, val in enumerate(values):
+            if Promise.is_thenable(val):
+                maybe_promise = Promise._try_convert_to_promise(val)._target()
+                # if is_resolved:
+                #     # maybe_promise.suppressUnhandledRejections
+                #     pass
+                if maybe_promise.is_pending:
+                    maybe_promise._add_callbacks(
+                        partial(self._promise_fulfilled, i=i),
+                        self._promise_rejected,
+                        None,
+                    )
+                    self._values[i] = maybe_promise
+                elif maybe_promise.is_fulfilled:
+                    is_resolved = self._promise_fulfilled(maybe_promise._value(), i)
+                elif maybe_promise.is_rejected:
+                    is_resolved = self._promise_rejected(maybe_promise._reason())
+
+            else:
+                is_resolved = self._promise_fulfilled(val, i)
+
+            if is_resolved:
+                break
+
+        if not is_resolved:
+            result._is_async_guaranteed = True
+
+    def _promise_fulfilled(self, value, i):
+        # type: (Any, int) -> bool
+        if self.is_resolved:
+            return False
+        # assert not self.is_resolved
+        # assert isinstance(self._values, Iterable)
+        # assert isinstance(i, int)
+        self._values[i] = value  # type: ignore
+        self._total_resolved += 1
+        if self._total_resolved >= self._length:
+            self._resolve(self._values)  # type: ignore
+            return True
+        return False
+
+    def _promise_rejected(self, reason):
+        # type: (Exception) -> bool
+        if self.is_resolved:
+            return False
+        # assert not self.is_resolved
+        # assert isinstance(self._values, Iterable)
+        self._total_resolved += 1
+        self._reject(reason)
+        return True
+
+    @property
+    def is_resolved(self):
+        # type: () -> bool
+        return self._values is None
+
+    def _resolve(self, value):
+        # type: (Collection[Any]) -> None
+        assert not self.is_resolved
+        assert not isinstance(value, self._promise_class)
+        self._values = None
+        self.promise._fulfill(value)
+
+    def _reject(self, reason):
+        # type: (Exception) -> None
+        assert not self.is_resolved
+        self._values = None
+        self.promise._reject_callback(reason, False)

wandb/vendor/promise-2.3.0/wandb_promise/pyutils/version.py

@@ -0,0 +1,83 @@
+from __future__ import unicode_literals
+
+import datetime
+import os
+import subprocess
+
+
+def get_version(version=None):
+    "Returns a PEP 440-compliant version number from VERSION."
+    version = get_complete_version(version)
+
+    # Now build the two parts of the version number:
+    # main = X.Y[.Z]
+    # sub = .devN - for pre-alpha releases
+    #     | {a|b|rc}N - for alpha, beta, and rc releases
+
+    main = get_main_version(version)
+
+    sub = ""
+    if version[3] == "alpha" and version[4] == 0:
+        git_changeset = get_git_changeset()
+        if git_changeset:
+            sub = ".dev%s" % git_changeset
+        else:
+            sub = ".dev"
+    elif version[3] != "final":
+        mapping = {"alpha": "a", "beta": "b", "rc": "rc"}
+        sub = mapping[version[3]] + str(version[4])
+
+    return str(main + sub)
+
+
+def get_main_version(version=None):
+    "Returns main version (X.Y[.Z]) from VERSION."
+    version = get_complete_version(version)
+    parts = 2 if version[2] == 0 else 3
+    return ".".join(str(x) for x in version[:parts])
+
+
+def get_complete_version(version=None):
+    """Returns a tuple of the promise version. If version argument is non-empty,
+    then checks for correctness of the tuple provided.
+    """
+    if version is None:
+        from promise import VERSION
+
+        return VERSION
+    else:
+        assert len(version) == 5
+        assert version[3] in ("alpha", "beta", "rc", "final")
+
+    return version
+
+
+def get_docs_version(version=None):
+    version = get_complete_version(version)
+    if version[3] != "final":
+        return "dev"
+    else:
+        return "%d.%d" % version[:2]
+
+
+def get_git_changeset():
+    """Returns a numeric identifier of the latest git changeset.
+    The result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format.
+    This value isn't guaranteed to be unique, but collisions are very unlikely,
+    so it's sufficient for generating the development version numbers.
+    """
+    repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    try:
+        git_log = subprocess.Popen(
+            "git log --pretty=format:%ct --quiet -1 HEAD",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            cwd=repo_dir,
+            universal_newlines=True,
+        )
+        timestamp = git_log.communicate()[0]
+        timestamp = datetime.datetime.utcfromtimestamp(int(timestamp))
+    except Exception:
+        return None
+    return timestamp.strftime("%Y%m%d%H%M%S")

wandb/vendor/promise-2.3.0/wandb_promise/schedulers/asyncio.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import
+
+from asyncio import get_event_loop, Event
+
+
+class AsyncioScheduler(object):
+    def __init__(self, loop=None):
+        self.loop = loop or get_event_loop()
+
+    def call(self, fn):
+        self.loop.call_soon(fn)
+
+    def wait(self, promise, timeout=None):
+        e = Event()
+
+        def on_resolve_or_reject(_):
+            e.set()
+
+        promise._then(on_resolve_or_reject, on_resolve_or_reject)
+
+        # We can't use the timeout in Asyncio event
+        e.wait()

wandb/vendor/promise-2.3.0/wandb_promise/schedulers/gevent.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import
+
+from gevent.event import Event  # type: ignore
+import gevent  # type: ignore
+
+
+class GeventScheduler(object):
+    def call(self, fn):
+        # print fn
+        gevent.spawn(fn)
+
+    def wait(self, promise, timeout=None):
+        e = Event()
+
+        def on_resolve_or_reject(_):
+            e.set()
+
+        promise._then(on_resolve_or_reject, on_resolve_or_reject)
+        waited = e.wait(timeout)
+        if not waited:
+            raise Exception("Timeout")

wandb/vendor/promise-2.3.0/wandb_promise/schedulers/immediate.py

@@ -0,0 +1,27 @@
+from threading import Event
+
+if False:
+    from ..promise import Promise
+    from typing import Callable, Any, Optional  # flake8: noqa
+
+
+class ImmediateScheduler(object):
+    def call(self, fn):
+        # type: (Callable) -> None
+        try:
+            fn()
+        except:
+            pass
+
+    def wait(self, promise, timeout=None):
+        # type: (Promise, Optional[float]) -> None
+        e = Event()
+
+        def on_resolve_or_reject(_):
+            # type: (Any) -> None
+            e.set()
+
+        promise._then(on_resolve_or_reject, on_resolve_or_reject)
+        waited = e.wait(timeout)
+        if not waited:
+            raise Exception("Timeout")

wandb/vendor/promise-2.3.0/wandb_promise/schedulers/thread.py

@@ -0,0 +1,18 @@
+from threading import Thread, Event
+
+
+class ThreadScheduler(object):
+    def call(self, fn):
+        thread = Thread(target=fn)
+        thread.start()
+
+    def wait(self, promise, timeout=None):
+        e = Event()
+
+        def on_resolve_or_reject(_):
+            e.set()
+
+        promise._then(on_resolve_or_reject, on_resolve_or_reject)
+        waited = e.wait(timeout)
+        if not waited:
+            raise Exception("Timeout")

wandb/vendor/promise-2.3.0/wandb_promise/utils.py

@@ -0,0 +1,56 @@
+import functools
+import inspect
+import types
+import warnings
+import sys
+
+
+def warn(msg):
+    # type: (str) -> None
+    warnings.simplefilter("always", DeprecationWarning)  # turn off filter
+    warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+    warnings.simplefilter("default", DeprecationWarning)  # reset filter
+
+
+class deprecated(object):
+    def __init__(self, reason, name=None):
+        if inspect.isclass(reason) or inspect.isfunction(reason):
+            raise TypeError("Reason for deprecation must be supplied")
+        self.reason = reason
+        self.name = name
+
+    def __call__(self, cls_or_func):
+        if inspect.isfunction(cls_or_func):
+            fmt = "Call to deprecated function or method {name} ({reason})."
+
+        elif inspect.isclass(cls_or_func):
+            fmt = "Call to deprecated class {name} ({reason})."
+
+        else:
+            raise TypeError(type(cls_or_func))
+
+        msg = fmt.format(name=self.name or cls_or_func.__name__, reason=self.reason)
+
+        @functools.wraps(cls_or_func)
+        def new_func(*args, **kwargs):
+            warn(msg)
+            return cls_or_func(*args, **kwargs)
+
+        return new_func
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    string_types = (str,)  # type: tuple
+    integer_types = (int,)  # type: tuple
+    class_types = (type,)  # type: tuple
+    text_type = str
+    binary_type = bytes
+else:
+    string_types = (basestring,)  # type: tuple
+    integer_types = (int, long)  # type: tuple
+    class_types = (type, types.ClassType)  # type: tuple
+    text_type = unicode
+    binary_type = str

wandb/vendor/pygments/__init__.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+    Pygments
+    ~~~~~~~~
+
+    Pygments is a syntax highlighting package written in Python.
+
+    It is a generic syntax highlighter for general use in all kinds of software
+    such as forum systems, wikis or other applications that need to prettify
+    source code. Highlights are:
+
+    * a wide range of common languages and markup formats is supported
+    * special attention is paid to details, increasing quality by a fair amount
+    * support for new languages and formats are added easily
+    * a number of output formats, presently HTML, LaTeX, RTF, SVG, all image
+      formats that PIL supports, and ANSI sequences
+    * it is usable as a command-line tool and as a library
+    * ... and it highlights even Brainfuck!
+
+    The `Pygments tip`_ is installable with ``easy_install Pygments==dev``.
+
+    .. _Pygments tip:
+       http://bitbucket.org/birkenfeld/pygments-main/get/tip.zip#egg=Pygments-dev
+
+    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+import sys
+
+from pygments.util import StringIO, BytesIO
+
+__version__ = '2.2.0'
+__docformat__ = 'restructuredtext'
+
+__all__ = ['lex', 'format', 'highlight']
+
+
+def lex(code, lexer):
+    """
+    Lex ``code`` with ``lexer`` and return an iterable of tokens.
+    """
+    try:
+        return lexer.get_tokens(code)
+    except TypeError as err:
+        if (isinstance(err.args[0], str) and
+            ('unbound method get_tokens' in err.args[0] or
+             'missing 1 required positional argument' in err.args[0])):
+            raise TypeError('lex() argument must be a lexer instance, '
+                            'not a class')
+        raise
+
+
+def format(tokens, formatter, outfile=None):  # pylint: disable=redefined-builtin
+    """
+    Format a tokenlist ``tokens`` with the formatter ``formatter``.
+
+    If ``outfile`` is given and a valid file object (an object
+    with a ``write`` method), the result will be written to it, otherwise
+    it is returned as a string.
+    """
+    try:
+        if not outfile:
+            realoutfile = getattr(formatter, 'encoding', None) and BytesIO() or StringIO()
+            formatter.format(tokens, realoutfile)
+            return realoutfile.getvalue()
+        else:
+            formatter.format(tokens, outfile)
+    except TypeError as err:
+        if (isinstance(err.args[0], str) and
+            ('unbound method format' in err.args[0] or
+             'missing 1 required positional argument' in err.args[0])):
+            raise TypeError('format() argument must be a formatter instance, '
+                            'not a class')
+        raise
+
+
+def highlight(code, lexer, formatter, outfile=None):
+    """
+    Lex ``code`` with ``lexer`` and format it with the formatter ``formatter``.
+
+    If ``outfile`` is given and a valid file object (an object
+    with a ``write`` method), the result will be written to it, otherwise
+    it is returned as a string.
+    """
+    return format(lex(code, lexer), formatter, outfile)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    from pygments.cmdline import main
+    sys.exit(main(sys.argv))