wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/gql-0.2.0/wandb_gql/client.py

@@ -0,0 +1,75 @@
+import logging
+
+from wandb_graphql import parse, introspection_query, build_ast_schema, build_client_schema
+from wandb_graphql.validation import validate
+
+from .transport.local_schema import LocalSchemaTransport
+
+log = logging.getLogger(__name__)
+
+
+class RetryError(Exception):
+    """Custom exception thrown when retry logic fails"""
+    def __init__(self, retries_count, last_exception):
+        message = "Failed %s retries: %s" % (retries_count, last_exception)
+        super(RetryError, self).__init__(message)
+        self.last_exception = last_exception
+
+
+class Client(object):
+    def __init__(self, schema=None, introspection=None, type_def=None, transport=None,
+                 fetch_schema_from_transport=False, retries=0):
+        assert not(type_def and introspection), 'Cant provide introspection type definition at the same time'
+        if transport and fetch_schema_from_transport:
+            assert not schema, 'Cant fetch the schema from transport if is already provided'
+            introspection = transport.execute(parse(introspection_query)).data
+        if introspection:
+            assert not schema, 'Cant provide introspection and schema at the same time'
+            schema = build_client_schema(introspection)
+        elif type_def:
+            assert not schema, 'Cant provide Type definition and schema at the same time'
+            type_def_ast = parse(type_def)
+            schema = build_ast_schema(type_def_ast)
+        elif schema and not transport:
+            transport = LocalSchemaTransport(schema)
+
+        self.schema = schema
+        self.introspection = introspection
+        self.transport = transport
+        self.retries = retries
+
+    def validate(self, document):
+        if not self.schema:
+            raise Exception("Cannot validate locally the document, you need to pass a schema.")
+        validation_errors = validate(self.schema, document)
+        if validation_errors:
+            raise validation_errors[0]
+
+    def execute(self, document, *args, **kwargs):
+        if self.schema:
+            self.validate(document)
+
+        result = self._get_result(document, *args, **kwargs)
+        if result.errors:
+            raise Exception(str(result.errors[0]))
+
+        return result.data
+
+    def _get_result(self, document, *args, **kwargs):
+        if not self.retries:
+            return self.transport.execute(document, *args, **kwargs)
+
+        last_exception = None
+        retries_count = 0
+        while retries_count < self.retries:
+            try:
+                result = self.transport.execute(document, *args, **kwargs)
+                return result
+            except Exception as e:
+                last_exception = e
+                log.warning("Request failed with exception %s. Retrying for the %s time...",
+                            e, retries_count + 1, exc_info=True)
+            finally:
+                retries_count += 1
+
+        raise RetryError(retries_count, last_exception)

wandb/vendor/gql-0.2.0/wandb_gql/dsl.py

@@ -0,0 +1,152 @@
+from collections.abc import Iterable
+import decimal
+from functools import partial
+
+from wandb_graphql.language import ast
+from wandb_graphql.language.printer import print_ast
+from wandb_graphql.type import (GraphQLField, GraphQLList,
+                          GraphQLNonNull, GraphQLEnumType)
+
+from .utils import to_camel_case
+
+
+class DSLSchema(object):
+    def __init__(self, client):
+        self.client = client
+
+    @property
+    def schema(self):
+        return self.client.schema
+
+    def __getattr__(self, name):
+        type_def = self.schema.get_type(name)
+        return DSLType(type_def)
+
+    def query(self, *args, **kwargs):
+        return self.execute(query(*args, **kwargs))
+
+    def mutate(self, *args, **kwargs):
+        return self.query(*args, operation='mutate', **kwargs)
+
+    def execute(self, document):
+        return self.client.execute(document)
+
+
+class DSLType(object):
+    def __init__(self, type):
+        self.type = type
+
+    def __getattr__(self, name):
+        formatted_name, field_def = self.get_field(name)
+        return DSLField(formatted_name, field_def)
+
+    def get_field(self, name):
+        camel_cased_name = to_camel_case(name)
+
+        if name in self.type.fields:
+            return name, self.type.fields[name]
+
+        if camel_cased_name in self.type.fields:
+            return camel_cased_name, self.type.fields[camel_cased_name]
+
+        raise KeyError('Field {} doesnt exist in type {}.'.format(name, self.type.name))
+
+
+def selections(*fields):
+    for _field in fields:
+        yield field(_field).ast
+
+
+def get_ast_value(value):
+    if isinstance(value, ast.Node):
+        return value
+    if isinstance(value, str):
+        return ast.StringValue(value=value)
+    elif isinstance(value, bool):
+        return ast.BooleanValue(value=value)
+    elif isinstance(value, (float, decimal.Decimal)):
+        return ast.FloatValue(value=value)
+    elif isinstance(value, int):
+        return ast.IntValue(value=value)
+    return None
+
+
+class DSLField(object):
+
+    def __init__(self, name, field):
+        self.field = field
+        self.ast_field = ast.Field(name=ast.Name(value=name), arguments=[])
+        self.selection_set = None
+
+    def select(self, *fields):
+        if not self.ast_field.selection_set:
+            self.ast_field.selection_set = ast.SelectionSet(selections=[])
+        self.ast_field.selection_set.selections.extend(selections(*fields))
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self.args(*args, **kwargs)
+
+    def alias(self, alias):
+        self.ast_field.alias = ast.Name(value=alias)
+        return self
+
+    def args(self, **args):
+        for name, value in args.items():
+            arg = self.field.args.get(name)
+            arg_type_serializer = get_arg_serializer(arg.type)
+            value = arg_type_serializer(value)
+            self.ast_field.arguments.append(
+                ast.Argument(
+                    name=ast.Name(value=name),
+                    value=get_ast_value(value)
+                )
+            )
+        return self
+
+    @property
+    def ast(self):
+        return self.ast_field
+
+    def __str__(self):
+        return print_ast(self.ast_field)
+
+
+def field(field, **args):
+    if isinstance(field, GraphQLField):
+        return DSLField(field).args(**args)
+    elif isinstance(field, DSLField):
+        return field
+
+    raise Exception('Received incompatible query field: "{}".'.format(field))
+
+
+def query(*fields):
+    return ast.Document(
+        definitions=[ast.OperationDefinition(
+            operation='query',
+            selection_set=ast.SelectionSet(
+                selections=list(selections(*fields))
+            )
+        )]
+    )
+
+
+def serialize_list(serializer, values):
+    assert isinstance(values, Iterable), 'Expected iterable, received "{}"'.format(repr(values))
+    return [serializer(v) for v in values]
+
+
+def get_arg_serializer(arg_type):
+    if isinstance(arg_type, GraphQLNonNull):
+        return get_arg_serializer(arg_type.of_type)
+    if isinstance(arg_type, GraphQLList):
+        inner_serializer = get_arg_serializer(arg_type.of_type)
+        return partial(serialize_list, inner_serializer)
+    if isinstance(arg_type, GraphQLEnumType):
+        return lambda value: ast.EnumValue(value=arg_type.serialize(value))
+    return arg_type.serialize
+
+
+def var(name):
+    return ast.Variable(name=name)

wandb/vendor/gql-0.2.0/wandb_gql/gql.py

@@ -0,0 +1,10 @@
+from wandb_graphql.language.parser import parse
+from wandb_graphql.language.source import Source
+
+
+def gql(request_string):
+    if isinstance(request_string, str):
+        source = Source(request_string, 'GraphQL request')
+        return parse(source)
+    else:
+        raise Exception('Received incompatible request "{}".'.format(request_string))

wandb/vendor/gql-0.2.0/wandb_gql/transport/http.py

@@ -0,0 +1,6 @@
+class HTTPTransport(object):
+
+    def __init__(self, url, headers=None, cookies=None):
+        self.url = url
+        self.headers = headers
+        self.cookies = cookies

wandb/vendor/gql-0.2.0/wandb_gql/transport/local_schema.py

@@ -0,0 +1,15 @@
+from wandb_graphql.execution import execute
+
+
+class LocalSchemaTransport(object):
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def execute(self, document, *args, **kwargs):
+        return execute(
+            self.schema,
+            document,
+            *args,
+            **kwargs
+        )

wandb/vendor/gql-0.2.0/wandb_gql/transport/requests.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import
+
+import requests
+from wandb_graphql.execution import ExecutionResult
+from wandb_graphql.language.printer import print_ast
+
+from .http import HTTPTransport
+
+
+class RequestsHTTPTransport(HTTPTransport):
+    def __init__(self, url, auth=None, use_json=False, timeout=None, **kwargs):
+        """
+        :param url: The GraphQL URL
+        :param auth: Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth
+        :param use_json: Send request body as JSON instead of form-urlencoded
+        :param timeout: Specifies a default timeout for requests (Default: None)
+        """
+        super(RequestsHTTPTransport, self).__init__(url, **kwargs)
+        self.auth = auth
+        self.default_timeout = timeout
+        self.use_json = use_json
+
+    def execute(self, document, variable_values=None, timeout=None):
+        query_str = print_ast(document)
+        payload = {
+            'query': query_str,
+            'variables': variable_values or {}
+        }
+
+        data_key = 'json' if self.use_json else 'data'
+        post_args = {
+            'headers': self.headers,
+            'auth': self.auth,
+            'cookies': self.cookies,
+            'timeout': timeout or self.default_timeout,
+            data_key: payload
+        }
+        request = requests.post(self.url, **post_args)
+        request.raise_for_status()
+
+        result = request.json()
+        assert 'errors' in result or 'data' in result, 'Received non-compatible response "{}"'.format(result)
+        return ExecutionResult(
+            errors=result.get('errors'),
+            data=result.get('data')
+        )

wandb/vendor/gql-0.2.0/wandb_gql/utils.py

@@ -0,0 +1,21 @@
+import re
+
+
+# From this response in Stackoverflow
+# http://stackoverflow.com/a/19053800/1072990
+def to_camel_case(snake_str):
+    components = snake_str.split('_')
+    # We capitalize the first letter of each component except the first one
+    # with the 'title' method and join them together.
+    return components[0] + "".join(x.title() if x else '_' for x in components[1:])
+
+
+# From this response in Stackoverflow
+# http://stackoverflow.com/a/1176023/1072990
+def to_snake_case(name):
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+
+def to_const(string):
+    return re.sub(r'[\W|^]+', '_', string).upper()

wandb/vendor/graphql-core-1.1/setup.py

@@ -0,0 +1,86 @@
+from setuptools import setup, find_packages
+from setuptools.command.test import test as TestCommand
+import sys
+
+if sys.version_info[0] < 3:
+    import __builtin__ as builtins
+else:
+    import builtins
+
+# This is a bit (!) hackish: we are setting a global variable so that the main
+# graphql __init__ can detect if it is being loaded by the setup routine, to
+# avoid attempting to load components that aren't built yet:
+# the numpy distutils extensions that are used by scikit-learn to recursively
+# build the compiled extensions in sub-packages is based on the Python import
+# machinery.
+if 'test' not in sys.argv:
+    builtins.__GRAPHQL_SETUP__ = True
+
+version = __import__('graphql').get_version()
+
+install_requires = [
+    'six>=1.10.0',
+    'promise>=2.0'
+]
+
+tests_requires = [
+    'pytest==3.0.2',
+    'pytest-django==2.9.1',
+    'pytest-cov==2.3.1',
+    'coveralls',
+    'gevent==1.1rc1',
+    'six>=1.10.0',
+    'pytest-benchmark==3.0.0',
+    'pytest-mock==1.2',
+]
+
+class PyTest(TestCommand):
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = ['graphql', '-vrsx']
+        self.test_suite = True
+
+    def run_tests(self):
+        #import here, cause outside the eggs aren't loaded
+        import pytest
+        errno = pytest.main(self.test_args)
+        sys.exit(errno)
+
+
+setup(
+    name='graphql-core',
+    version=version,
+    description='GraphQL implementation for Python',
+    url='https://github.com/graphql-python/graphql-core',
+    download_url='https://github.com/graphql-python/graphql-core/releases',
+    author='Syrus Akbary, Jake Heinz, Taeho Kim',
+    author_email='Syrus Akbary <me@syrusakbary.com>, Jake Heinz <me@jh.gg>, Taeho Kim <dittos@gmail.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 :: Implementation :: PyPy',
+        'License :: OSI Approved :: MIT License',
+        'Topic :: Database :: Front-Ends',
+        'Topic :: Internet :: WWW/HTTP',
+    ],
+
+    keywords='api graphql protocol rest',
+    packages=find_packages(exclude=['tests', 'tests_py35']),
+    install_requires=install_requires,
+    tests_require=tests_requires,
+    cmdclass = {'test': PyTest},
+    extras_require={
+        'gevent': [
+            'gevent==1.1rc1'
+        ],
+        'test': tests_requires
+    }
+)