wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_fragment_names.py

@@ -0,0 +1,28 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class UniqueFragmentNames(ValidationRule):
+    __slots__ = 'known_fragment_names',
+
+    def __init__(self, context):
+        super(UniqueFragmentNames, self).__init__(context)
+        self.known_fragment_names = {}
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        return False
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        fragment_name = node.name.value
+        if fragment_name in self.known_fragment_names:
+            self.context.report_error(GraphQLError(
+                self.duplicate_fragment_name_message(fragment_name),
+                [self.known_fragment_names[fragment_name], node.name]
+            ))
+        else:
+            self.known_fragment_names[fragment_name] = node.name
+        return False
+
+    @staticmethod
+    def duplicate_fragment_name_message(field):
+        return 'There can only be one fragment named "{}".'.format(field)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_input_field_names.py

@@ -0,0 +1,33 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class UniqueInputFieldNames(ValidationRule):
+    __slots__ = 'known_names', 'known_names_stack'
+
+    def __init__(self, context):
+        super(UniqueInputFieldNames, self).__init__(context)
+        self.known_names = {}
+        self.known_names_stack = []
+
+    def enter_ObjectValue(self, node, key, parent, path, ancestors):
+        self.known_names_stack.append(self.known_names)
+        self.known_names = {}
+
+    def leave_ObjectValue(self, node, key, parent, path, ancestors):
+        self.known_names = self.known_names_stack.pop()
+
+    def enter_ObjectField(self, node, key, parent, path, ancestors):
+        field_name = node.name.value
+        if field_name in self.known_names:
+            self.context.report_error(GraphQLError(
+                self.duplicate_input_field_message(field_name),
+                [self.known_names[field_name], node.name]
+            ))
+        else:
+            self.known_names[field_name] = node.name
+        return False
+
+    @staticmethod
+    def duplicate_input_field_message(field_name):
+        return 'There can only be one input field named "{}".'.format(field_name)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_operation_names.py

@@ -0,0 +1,31 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class UniqueOperationNames(ValidationRule):
+    __slots__ = 'known_operation_names',
+
+    def __init__(self, context):
+        super(UniqueOperationNames, self).__init__(context)
+        self.known_operation_names = {}
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        operation_name = node.name
+        if not operation_name:
+            return
+
+        if operation_name.value in self.known_operation_names:
+            self.context.report_error(GraphQLError(
+                self.duplicate_operation_name_message(operation_name.value),
+                [self.known_operation_names[operation_name.value], operation_name]
+            ))
+        else:
+            self.known_operation_names[operation_name.value] = operation_name
+        return False
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        return False
+
+    @staticmethod
+    def duplicate_operation_name_message(operation_name):
+        return 'There can only be one operation named "{}".'.format(operation_name)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_variable_names.py

@@ -0,0 +1,27 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class UniqueVariableNames(ValidationRule):
+    __slots__ = 'known_variable_names',
+
+    def __init__(self, context):
+        super(UniqueVariableNames, self).__init__(context)
+        self.known_variable_names = {}
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        self.known_variable_names = {}
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        variable_name = node.variable.name.value
+        if variable_name in self.known_variable_names:
+            self.context.report_error(GraphQLError(
+                self.duplicate_variable_message(variable_name),
+                [self.known_variable_names[variable_name], node.variable.name]
+            ))
+        else:
+            self.known_variable_names[variable_name] = node.variable.name
+
+    @staticmethod
+    def duplicate_variable_message(operation_name):
+        return 'There can be only one variable named "{}".'.format(operation_name)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/variables_are_input_types.py

@@ -0,0 +1,21 @@
+from ...error import GraphQLError
+from ...language.printer import print_ast
+from ...type.definition import is_input_type
+from ...utils.type_from_ast import type_from_ast
+from .base import ValidationRule
+
+
+class VariablesAreInputTypes(ValidationRule):
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        type = type_from_ast(self.context.get_schema(), node.type)
+
+        if type and not is_input_type(type):
+            self.context.report_error(GraphQLError(
+                self.non_input_type_on_variable_message(node.variable.name.value, print_ast(node.type)),
+                [node.type]
+            ))
+
+    @staticmethod
+    def non_input_type_on_variable_message(variable_name, type_name):
+        return 'Variable "${}" cannot be non-input type "{}".'.format(variable_name, type_name)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/variables_in_allowed_position.py

@@ -0,0 +1,53 @@
+from ...error import GraphQLError
+from ...type.definition import GraphQLNonNull
+from ...utils.type_comparators import is_type_sub_type_of
+from ...utils.type_from_ast import type_from_ast
+from .base import ValidationRule
+
+
+class VariablesInAllowedPosition(ValidationRule):
+    __slots__ = 'var_def_map'
+
+    def __init__(self, context):
+        super(VariablesInAllowedPosition, self).__init__(context)
+        self.var_def_map = {}
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        self.var_def_map = {}
+
+    def leave_OperationDefinition(self, operation, key, parent, path, ancestors):
+        usages = self.context.get_recursive_variable_usages(operation)
+
+        for usage in usages:
+            node = usage.node
+            type = usage.type
+            var_name = node.name.value
+            var_def = self.var_def_map.get(var_name)
+            if var_def and type:
+                # A var type is allowed if it is the same or more strict (e.g. is
+                # a subtype of) than the expected type. It can be more strict if
+                # the variable type is non-null when the expected type is nullable.
+                # If both are list types, the variable item type can be more strict
+                # than the expected item type (contravariant).
+                schema = self.context.get_schema()
+                var_type = type_from_ast(schema, var_def.type)
+                if var_type and not is_type_sub_type_of(schema, self.effective_type(var_type, var_def), type):
+                    self.context.report_error(GraphQLError(
+                        self.bad_var_pos_message(var_name, var_type, type),
+                        [var_def, node]
+                    ))
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        self.var_def_map[node.variable.name.value] = node
+
+    @staticmethod
+    def effective_type(var_type, var_def):
+        if not var_def.default_value or isinstance(var_type, GraphQLNonNull):
+            return var_type
+
+        return GraphQLNonNull(var_type)
+
+    @staticmethod
+    def bad_var_pos_message(var_name, var_type, expected_type):
+        return 'Variable "{}" of type "{}" used in position expecting type "{}".'.format(var_name, var_type,
+                                                                                         expected_type)

wandb/vendor/graphql-core-1.1/wandb_graphql/validation/validation.py

@@ -0,0 +1,158 @@
+from ..language.ast import (FragmentDefinition, FragmentSpread,
+                            OperationDefinition)
+from ..language.visitor import ParallelVisitor, TypeInfoVisitor, Visitor, visit
+from ..type import GraphQLSchema
+from ..utils.type_info import TypeInfo
+from .rules import specified_rules
+
+
+def validate(schema, ast, rules=specified_rules):
+    assert schema, 'Must provide schema'
+    assert ast, 'Must provide document'
+    assert isinstance(schema, GraphQLSchema)
+    type_info = TypeInfo(schema)
+    return visit_using_rules(schema, type_info, ast, rules)
+
+
+def visit_using_rules(schema, type_info, ast, rules):
+    context = ValidationContext(schema, ast, type_info)
+    visitors = [rule(context) for rule in rules]
+    visit(ast, TypeInfoVisitor(type_info, ParallelVisitor(visitors)))
+    return context.get_errors()
+
+
+class VariableUsage(object):
+    __slots__ = 'node', 'type'
+
+    def __init__(self, node, type):
+        self.node = node
+        self.type = type
+
+
+class UsageVisitor(Visitor):
+    __slots__ = 'usages', 'type_info'
+
+    def __init__(self, usages, type_info):
+        self.usages = usages
+        self.type_info = type_info
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        return False
+
+    def enter_Variable(self, node, key, parent, path, ancestors):
+        usage = VariableUsage(node, type=self.type_info.get_input_type())
+        self.usages.append(usage)
+
+
+class ValidationContext(object):
+    __slots__ = ('_schema', '_ast', '_type_info', '_errors', '_fragments', '_fragment_spreads',
+                 '_recursively_referenced_fragments', '_variable_usages', '_recursive_variable_usages')
+
+    def __init__(self, schema, ast, type_info):
+        self._schema = schema
+        self._ast = ast
+        self._type_info = type_info
+        self._errors = []
+        self._fragments = None
+        self._fragment_spreads = {}
+        self._recursively_referenced_fragments = {}
+        self._variable_usages = {}
+        self._recursive_variable_usages = {}
+
+    def report_error(self, error):
+        self._errors.append(error)
+
+    def get_errors(self):
+        return self._errors
+
+    def get_schema(self):
+        return self._schema
+
+    def get_variable_usages(self, node):
+        usages = self._variable_usages.get(node)
+        if usages is None:
+            usages = []
+            sub_visitor = UsageVisitor(usages, self._type_info)
+            visit(node, TypeInfoVisitor(self._type_info, sub_visitor))
+            self._variable_usages[node] = usages
+
+        return usages
+
+    def get_recursive_variable_usages(self, operation):
+        assert isinstance(operation, OperationDefinition)
+        usages = self._recursive_variable_usages.get(operation)
+        if usages is None:
+            usages = self.get_variable_usages(operation)
+            fragments = self.get_recursively_referenced_fragments(operation)
+            for fragment in fragments:
+                usages.extend(self.get_variable_usages(fragment))
+            self._recursive_variable_usages[operation] = usages
+
+        return usages
+
+    def get_recursively_referenced_fragments(self, operation):
+        assert isinstance(operation, OperationDefinition)
+        fragments = self._recursively_referenced_fragments.get(operation)
+        if not fragments:
+            fragments = []
+            collected_names = set()
+            nodes_to_visit = [operation.selection_set]
+            while nodes_to_visit:
+                node = nodes_to_visit.pop()
+                spreads = self.get_fragment_spreads(node)
+                for spread in spreads:
+                    frag_name = spread.name.value
+                    if frag_name not in collected_names:
+                        collected_names.add(frag_name)
+                        fragment = self.get_fragment(frag_name)
+                        if fragment:
+                            fragments.append(fragment)
+                            nodes_to_visit.append(fragment.selection_set)
+            self._recursively_referenced_fragments[operation] = fragments
+        return fragments
+
+    def get_fragment_spreads(self, node):
+        spreads = self._fragment_spreads.get(node)
+        if not spreads:
+            spreads = []
+            sets_to_visit = [node]
+            while sets_to_visit:
+                _set = sets_to_visit.pop()
+                for selection in _set.selections:
+                    if isinstance(selection, FragmentSpread):
+                        spreads.append(selection)
+                    elif selection.selection_set:
+                        sets_to_visit.append(selection.selection_set)
+
+            self._fragment_spreads[node] = spreads
+        return spreads
+
+    def get_ast(self):
+        return self._ast
+
+    def get_fragment(self, name):
+        fragments = self._fragments
+        if fragments is None:
+            self._fragments = fragments = {}
+            for statement in self.get_ast().definitions:
+                if isinstance(statement, FragmentDefinition):
+                    fragments[statement.name.value] = statement
+        return fragments.get(name)
+
+    def get_type(self):
+        return self._type_info.get_type()
+
+    def get_parent_type(self):
+        return self._type_info.get_parent_type()
+
+    def get_input_type(self):
+        return self._type_info.get_input_type()
+
+    def get_field_def(self):
+        return self._type_info.get_field_def()
+
+    def get_directive(self):
+        return self._type_info.get_directive()
+
+    def get_argument(self):
+        return self._type_info.get_argument()

wandb/vendor/promise-2.3.0/conftest.py

@@ -0,0 +1,30 @@
+# Configuration for pytest to automatically collect types.
+# Thanks to Guilherme Salgado.
+import pytest
+
+try:
+    import pyannotate_runtime
+    PYANOTATE_PRESENT = True
+except ImportError:
+    PYANOTATE_PRESENT = False
+
+if PYANOTATE_PRESENT:
+    def pytest_collection_finish(session):
+        """Handle the pytest collection finish hook: configure pyannotate.
+        Explicitly delay importing `collect_types` until all tests have
+        been collected.  This gives gevent a chance to monkey patch the
+        world before importing pyannotate.
+        """
+        from pyannotate_runtime import collect_types
+        collect_types.init_types_collection()
+
+    @pytest.fixture(autouse=True)
+    def collect_types_fixture():
+        from pyannotate_runtime import collect_types
+        collect_types.resume()
+        yield
+        collect_types.pause()
+
+    def pytest_sessionfinish(session, exitstatus):
+        from pyannotate_runtime import collect_types
+        collect_types.dump_stats("type_info.json")

wandb/vendor/promise-2.3.0/setup.py

@@ -0,0 +1,64 @@
+import sys
+from setuptools import setup, find_packages
+
+if sys.version_info[0] < 3:
+    import __builtin__ as builtins
+else:
+    import builtins
+
+builtins.__SETUP__ = True
+
+version = __import__("promise").get_version()
+
+
+IS_PY3 = sys.hexversion >= 0x03000000
+
+tests_require = [
+    "pytest>=2.7.3",
+    "pytest-cov",
+    "coveralls",
+    "futures",
+    "pytest-benchmark",
+    "mock",
+]
+if IS_PY3:
+    tests_require += ["pytest-asyncio"]
+
+
+setup(
+    name="promise",
+    version=version,
+    description="Promises/A+ implementation for Python",
+    long_description=open("README.rst").read(),
+    url="https://github.com/syrusakbary/promise",
+    download_url="https://github.com/syrusakbary/promise/releases",
+    author="Syrus Akbary",
+    author_email="me@syrusakbary.com",
+    license="MIT",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: Implementation :: PyPy",
+        "License :: OSI Approved :: MIT License",
+    ],
+    keywords="concurrent future deferred promise",
+    packages=find_packages(exclude=["tests"]),
+    # PEP-561: https://www.python.org/dev/peps/pep-0561/
+    package_data={"promise": ["py.typed"]},
+    extras_require={"test": tests_require},
+    install_requires=[
+        "typing>=3.6.4; python_version < '3.5'",
+        "six"
+    ],
+    tests_require=tests_require,
+)

wandb/vendor/promise-2.3.0/tests/conftest.py

@@ -0,0 +1,8 @@
+from sys import version_info
+
+collect_ignore = []
+if version_info[:2] < (3, 4):
+    collect_ignore.append("test_awaitable.py")
+if version_info[:2] < (3, 5):
+    collect_ignore.append("test_awaitable_35.py")
+    collect_ignore.append("test_dataloader_awaitable_35.py")

wandb/vendor/promise-2.3.0/tests/test_awaitable.py

@@ -0,0 +1,32 @@
+from asyncio import coroutine
+from pytest import mark
+from time import sleep
+from promise import Promise
+
+
+@mark.asyncio
+@coroutine
+def test_await():
+    yield from Promise.resolve(True)
+
+
+@mark.asyncio
+@coroutine
+def test_await_time():
+    def resolve_or_reject(resolve, reject):
+        sleep(.1)
+        resolve(True)
+
+    p = Promise(resolve_or_reject)
+    assert p.get() is True
+
+
+@mark.asyncio
+@coroutine
+def test_promise_coroutine():
+    @coroutine
+    def my_coro():
+        yield from Promise.resolve(True)
+
+    promise = Promise.resolve(my_coro())
+    assert isinstance(promise, Promise)

wandb/vendor/promise-2.3.0/tests/test_awaitable_35.py

@@ -0,0 +1,47 @@
+from asyncio import sleep, Future, wait, FIRST_COMPLETED
+from pytest import mark
+from promise import Promise, is_thenable
+
+
+@mark.asyncio
+async def test_await():
+    assert await Promise.resolve(True)
+
+
+@mark.asyncio
+async def test_promisify_coroutine():
+    async def my_coroutine():
+        await sleep(.01)
+        return True
+
+    assert await Promise.resolve(my_coroutine())
+
+
+@mark.asyncio
+async def test_coroutine_is_thenable():
+    async def my_coroutine():
+        await sleep(.01)
+        return True
+
+    assert is_thenable(my_coroutine())
+
+
+@mark.asyncio
+async def test_promisify_future():
+    future = Future()
+    future.set_result(True)
+    assert await Promise.resolve(future)
+
+
+@mark.asyncio
+async def test_await_in_safe_promise():
+    async def inner():
+        @Promise.safe
+        def x():
+            promise = Promise.resolve(True).then(lambda x: x)
+            return promise
+
+        return await x()
+
+    result = await inner()
+    assert result == True

wandb/vendor/promise-2.3.0/tests/test_benchmark.py

@@ -0,0 +1,116 @@
+from pytest import raises
+import time
+from promise import Promise, promisify, is_thenable
+
+
+def test_benchmark_promise_creation(benchmark):
+    @benchmark
+    def create_promise():  # unnecessary function call
+        p = Promise()
+
+
+def test_benchmark_promise_resolve(benchmark):
+    def create_promise():
+        return Promise.resolve(True)
+
+    result = benchmark(create_promise).get()
+    assert result == True
+
+
+def test_benchmark_is_thenable_basic_type(benchmark):
+    def create_promise():
+        return is_thenable(True)
+
+    result = benchmark(create_promise)
+    assert result == False
+
+
+def test_benchmark_is_thenable_custom_type(benchmark):
+    class MyType(object):
+        pass
+
+    my_type_instance = MyType()
+
+    def create_promise():
+        return is_thenable(my_type_instance)
+
+    result = benchmark(create_promise)
+    assert result == False
+
+
+def test_benchmark_promise_creation_with_resolve(benchmark):
+    do_resolve = lambda resolve, reject: resolve(True)
+
+    def create_promise():  # unnecessary function call
+        p = Promise(do_resolve)
+        # p._wait()
+        return p
+
+    result = benchmark(create_promise).get()
+    assert result == True
+
+
+def test_benchmark_promise_creation_with_reject(benchmark):
+    do_resolve = lambda resolve, reject: reject(Exception("Error"))
+
+    def create_promise():  # unnecessary function call
+        p = Promise(do_resolve)
+        # p._wait()
+        return p
+
+    with raises(Exception) as exc_info:
+        result = benchmark(create_promise).get()
+
+    assert str(exc_info.value) == "Error"
+
+
+# def test_benchmark_promisify_promise(benchmark):
+#     instance = Promise()
+
+#     def create_promise():  # unnecessary function call
+#         return promisify(instance)
+
+#     result = benchmark(create_promise)
+
+#     assert isinstance(result, Promise)
+
+
+def test_benchmark_promisify_custom_type(benchmark):
+    class CustomThenable(object):
+        pass
+        # def then(self, resolve, reject):
+        #     return resolve(True)
+
+    instance = CustomThenable()
+
+    def create_promise():  # unnecessary function call
+        return Promise.resolve(instance)
+
+    result = benchmark(create_promise)
+
+    assert isinstance(result, Promise)
+    assert result.get() == instance
+
+
+def test_benchmark_promise_all(benchmark):
+    values = range(1000)
+
+    def create_promise():  # unnecessary function call
+        return Promise.all(values)
+
+    result = benchmark(create_promise)
+
+    assert isinstance(result, Promise)
+    assert result.get() == list(range(1000))
+
+
+def test_benchmark_promise_all_promise(benchmark):
+    values = [Promise.resolve(i) for i in range(100000)]
+
+    def create_promise():  # unnecessary function call
+        return Promise.all(values)
+
+    result = benchmark(create_promise)
+
+    assert isinstance(result, Promise)
+    assert result.get() == list(range(100000))

wandb/vendor/promise-2.3.0/tests/test_complex_threads.py

@@ -0,0 +1,23 @@
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+from promise import Promise
+from operator import mul
+
+executor = ThreadPoolExecutor(max_workers=40000)
+
+
+def promise_factorial(n):
+    if n < 2:
+        return 1
+    sleep(.02)
+    a = executor.submit(promise_factorial, n - 1)
+
+    def promise_then(r):
+        return mul(r, n)
+
+    return Promise.resolve(a).then(promise_then)
+
+
+def test_factorial():
+    p = promise_factorial(10)
+    assert p.get() == 3628800