wandb 0.18.2__py3-none-musllinux_1_2_x86_64.whl

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/schema_printer.py

@@ -0,0 +1,168 @@
+from ..language.printer import print_ast
+from ..type.definition import (GraphQLEnumType, GraphQLInputObjectType,
+                               GraphQLInterfaceType, GraphQLObjectType,
+                               GraphQLScalarType, GraphQLUnionType)
+from ..type.directives import DEFAULT_DEPRECATION_REASON
+from .ast_from_value import ast_from_value
+
+
+def print_schema(schema):
+    return _print_filtered_schema(schema, lambda n: not(is_spec_directive(n)), _is_defined_type)
+
+
+def print_introspection_schema(schema):
+    return _print_filtered_schema(schema, is_spec_directive, _is_introspection_type)
+
+
+def is_spec_directive(directive_name):
+    return directive_name in ('skip', 'include', 'deprecated')
+
+
+def _is_defined_type(typename):
+    return not _is_introspection_type(typename) and not _is_builtin_scalar(typename)
+
+
+def _is_introspection_type(typename):
+    return typename.startswith('__')
+
+
+_builtin_scalars = frozenset(['String', 'Boolean', 'Int', 'Float', 'ID'])
+
+
+def _is_builtin_scalar(typename):
+    return typename in _builtin_scalars
+
+
+def _print_filtered_schema(schema, directive_filter, type_filter):
+    return '\n\n'.join([
+        _print_schema_definition(schema)
+    ] + [
+        _print_directive(directive)
+        for directive in schema.get_directives()
+        if directive_filter(directive.name)
+    ] + [
+        _print_type(type)
+        for typename, type in sorted(schema.get_type_map().items())
+        if type_filter(typename)
+    ]) + '\n'
+
+
+def _print_schema_definition(schema):
+    operation_types = []
+
+    query_type = schema.get_query_type()
+    if query_type:
+        operation_types.append('  query: {}'.format(query_type))
+
+    mutation_type = schema.get_mutation_type()
+    if mutation_type:
+        operation_types.append('  mutation: {}'.format(mutation_type))
+
+    subscription_type = schema.get_subscription_type()
+    if subscription_type:
+        operation_types.append('  subscription: {}'.format(subscription_type))
+
+    return 'schema {{\n{}\n}}'.format('\n'.join(operation_types))
+
+
+def _print_type(type):
+    if isinstance(type, GraphQLScalarType):
+        return _print_scalar(type)
+
+    elif isinstance(type, GraphQLObjectType):
+        return _print_object(type)
+
+    elif isinstance(type, GraphQLInterfaceType):
+        return _print_interface(type)
+
+    elif isinstance(type, GraphQLUnionType):
+        return _print_union(type)
+
+    elif isinstance(type, GraphQLEnumType):
+        return _print_enum(type)
+
+    assert isinstance(type, GraphQLInputObjectType)
+    return _print_input_object(type)
+
+
+def _print_scalar(type):
+    return 'scalar {}'.format(type.name)
+
+
+def _print_object(type):
+    interfaces = type.interfaces
+    implemented_interfaces = \
+        ' implements {}'.format(', '.join(i.name for i in interfaces)) if interfaces else ''
+
+    return (
+        'type {}{} {{\n'
+        '{}\n'
+        '}}'
+    ).format(type.name, implemented_interfaces, _print_fields(type))
+
+
+def _print_interface(type):
+    return (
+        'interface {} {{\n'
+        '{}\n'
+        '}}'
+    ).format(type.name, _print_fields(type))
+
+
+def _print_union(type):
+    return 'union {} = {}'.format(type.name, ' | '.join(str(t) for t in type.types))
+
+
+def _print_enum(type):
+    return (
+        'enum {} {{\n'
+        '{}\n'
+        '}}'
+    ).format(type.name, '\n'.join('  ' + v.name + _print_deprecated(v) for v in type.values))
+
+
+def _print_input_object(type):
+    return (
+        'input {} {{\n'
+        '{}\n'
+        '}}'
+    ).format(type.name, '\n'.join('  ' + _print_input_value(name, field) for name, field in type.fields.items()))
+
+
+def _print_fields(type):
+    return '\n'.join('  {}{}: {}{}'.format(f_name, _print_args(f), f.type, _print_deprecated(f))
+                     for f_name, f in type.fields.items())
+
+
+def _print_deprecated(field_or_enum_value):
+    reason = field_or_enum_value.deprecation_reason
+
+    if reason is None:
+        return ''
+    elif reason in ('', DEFAULT_DEPRECATION_REASON):
+        return ' @deprecated'
+    else:
+        return ' @deprecated(reason: {})'.format(print_ast(ast_from_value(reason)))
+
+
+def _print_args(field_or_directives):
+    if not field_or_directives.args:
+        return ''
+
+    return '({})'.format(', '.join(_print_input_value(arg_name, arg) for arg_name, arg in field_or_directives.args.items()))
+
+
+def _print_input_value(name, arg):
+    if arg.default_value is not None:
+        default_value = ' = ' + print_ast(ast_from_value(arg.default_value, arg.type))
+    else:
+        default_value = ''
+
+    return '{}: {}{}'.format(name, arg.type, default_value)
+
+
+def _print_directive(directive):
+    return 'directive @{}{} on {}'.format(directive.name, _print_args(directive), ' | '.join(directive.locations))
+
+
+__all__ = ['print_schema', 'print_introspection_schema']

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/suggestion_list.py

@@ -0,0 +1,56 @@
+from collections import OrderedDict
+
+
+def suggestion_list(inp, options):
+    '''
+     Given an invalid input string and a list of valid options, returns a filtered
+     list of valid options sorted based on their similarity with the input.
+    '''
+    options_by_distance = OrderedDict()
+    input_threshold = len(inp) / 2
+
+    for option in options:
+        distance = lexical_distance(inp, option)
+        threshold = max(input_threshold, len(option) / 2, 1)
+        if distance <= threshold:
+            options_by_distance[option] = distance
+
+    return sorted(list(options_by_distance.keys()), key=lambda k: options_by_distance[k])
+
+
+def lexical_distance(a, b):
+    '''
+     Computes the lexical distance between strings A and B.
+     The "distance" between two strings is given by counting the minimum number
+     of edits needed to transform string A into string B. An edit can be an
+     insertion, deletion, or substitution of a single character, or a swap of two
+     adjacent characters.
+     This distance can be useful for detecting typos in input or sorting
+     @returns distance in number of edits
+    '''
+
+    d = [[i] for i in range(len(a) + 1)] or []
+    d_len = len(d) or 1
+    for i in range(d_len):
+        for j in range(1, len(b) + 1):
+            if i == 0:
+                d[i].append(j)
+            else:
+                d[i].append(0)
+
+    for i in range(1, len(a) + 1):
+        for j in range(1, len(b) + 1):
+            cost = 0 if a[i - 1] == b[j - 1] else 1
+
+            d[i][j] = min(
+                d[i - 1][j] + 1,
+                d[i][j - 1] + 1,
+                d[i - 1][j - 1] + cost
+            )
+
+            if (i > 1 and j < 1 and
+               a[i - 1] == b[j - 2] and
+               a[i - 2] == b[j - 1]):
+                d[i][j] = min(d[i][j], d[i - 2][j - 2] + cost)
+
+    return d[len(a)][len(b)]

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_comparators.py

@@ -0,0 +1,69 @@
+from ..type.definition import (GraphQLInterfaceType, GraphQLList,
+                               GraphQLNonNull, GraphQLObjectType,
+                               GraphQLUnionType, is_abstract_type)
+
+
+def is_equal_type(type_a, type_b):
+    if type_a is type_b:
+        return True
+
+    if isinstance(type_a, GraphQLNonNull) and isinstance(type_b, GraphQLNonNull):
+        return is_equal_type(type_a.of_type, type_b.of_type)
+
+    if isinstance(type_a, GraphQLList) and isinstance(type_b, GraphQLList):
+        return is_equal_type(type_a.of_type, type_b.of_type)
+
+    return False
+
+
+def is_type_sub_type_of(schema, maybe_subtype, super_type):
+    if maybe_subtype is super_type:
+        return True
+
+    if isinstance(super_type, GraphQLNonNull):
+        if isinstance(maybe_subtype, GraphQLNonNull):
+            return is_type_sub_type_of(schema, maybe_subtype.of_type, super_type.of_type)
+        return False
+    elif isinstance(maybe_subtype, GraphQLNonNull):
+        return is_type_sub_type_of(schema, maybe_subtype.of_type, super_type)
+
+    if isinstance(super_type, GraphQLList):
+        if isinstance(maybe_subtype, GraphQLList):
+            return is_type_sub_type_of(schema, maybe_subtype.of_type, super_type.of_type)
+        return False
+    elif isinstance(maybe_subtype, GraphQLList):
+        return False
+
+    if is_abstract_type(super_type) and isinstance(
+            maybe_subtype, GraphQLObjectType) and schema.is_possible_type(
+            super_type, maybe_subtype):
+        return True
+
+    return False
+
+
+def do_types_overlap(schema, t1, t2):
+    # print 'do_types_overlap', t1, t2
+    if t1 == t2:
+        # print '1'
+        return True
+
+    if isinstance(t1, (GraphQLInterfaceType, GraphQLUnionType)):
+        if isinstance(t2, (GraphQLInterfaceType, GraphQLUnionType)):
+            # If both types are abstract, then determine if there is any intersection
+            # between possible concrete types of each.
+            s = any([schema.is_possible_type(t2, type) for type in schema.get_possible_types(t1)])
+            # print '2',s
+            return s
+        # Determine if the latter type is a possible concrete type of the former.
+        r = schema.is_possible_type(t1, t2)
+        # print '3', r
+        return r
+
+    if isinstance(t2, (GraphQLInterfaceType, GraphQLUnionType)):
+        t = schema.is_possible_type(t2, t1)
+        # print '4', t
+        return t
+
+    # print '5'
+    return False

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_from_ast.py

@@ -0,0 +1,21 @@
+from ..language import ast
+from ..type.definition import GraphQLList, GraphQLNonNull
+
+
+def type_from_ast(schema, input_type_ast):
+    if isinstance(input_type_ast, ast.ListType):
+        inner_type = type_from_ast(schema, input_type_ast.type)
+        if inner_type:
+            return GraphQLList(inner_type)
+        else:
+            return None
+
+    if isinstance(input_type_ast, ast.NonNullType):
+        inner_type = type_from_ast(schema, input_type_ast.type)
+        if inner_type:
+            return GraphQLNonNull(inner_type)
+        else:
+            return None
+
+    assert isinstance(input_type_ast, ast.NamedType), 'Must be a type name.'
+    return schema.get_type(input_type_ast.name.value)

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_info.py

@@ -0,0 +1,149 @@
+from ..language import visitor_meta
+from ..type.definition import (GraphQLInputObjectType, GraphQLList,
+                               get_named_type, get_nullable_type,
+                               is_composite_type)
+from .get_field_def import get_field_def
+from .type_from_ast import type_from_ast
+
+
+def pop(lst):
+    if lst:
+        lst.pop()
+
+
+# noinspection PyPep8Naming
+class TypeInfo(metaclass=visitor_meta.VisitorMeta):
+    __slots__ = '_schema', '_type_stack', '_parent_type_stack', '_input_type_stack', '_field_def_stack', '_directive', \
+                '_argument', '_get_field_def_fn'
+
+    def __init__(self, schema, get_field_def_fn=get_field_def):
+        self._schema = schema
+        self._type_stack = []
+        self._parent_type_stack = []
+        self._input_type_stack = []
+        self._field_def_stack = []
+        self._directive = None
+        self._argument = None
+        self._get_field_def_fn = get_field_def_fn
+
+    def get_type(self):
+        if self._type_stack:
+            return self._type_stack[-1]
+
+    def get_parent_type(self):
+        if self._parent_type_stack:
+            return self._parent_type_stack[-1]
+
+    def get_input_type(self):
+        if self._input_type_stack:
+            return self._input_type_stack[-1]
+
+    def get_field_def(self):
+        if self._field_def_stack:
+            return self._field_def_stack[-1]
+
+    def get_directive(self):
+        return self._directive
+
+    def get_argument(self):
+        return self._argument
+
+    def leave(self, node):
+        method = self._get_leave_handler(type(node))
+        if method:
+            return method(self)
+
+    def enter(self, node):
+        method = self._get_enter_handler(type(node))
+        if method:
+            return method(self, node)
+
+    def enter_SelectionSet(self, node):
+        named_type = get_named_type(self.get_type())
+        composite_type = None
+        if is_composite_type(named_type):
+            composite_type = named_type
+        self._parent_type_stack.append(composite_type)
+
+    def enter_Field(self, node):
+        parent_type = self.get_parent_type()
+        field_def = None
+        if parent_type:
+            field_def = self._get_field_def_fn(self._schema, parent_type, node)
+        self._field_def_stack.append(field_def)
+        self._type_stack.append(field_def and field_def.type)
+
+    def enter_Directive(self, node):
+        self._directive = self._schema.get_directive(node.name.value)
+
+    def enter_OperationDefinition(self, node):
+        definition_type = None
+        if node.operation == 'query':
+            definition_type = self._schema.get_query_type()
+        elif node.operation == 'mutation':
+            definition_type = self._schema.get_mutation_type()
+
+        self._type_stack.append(definition_type)
+
+    def enter_InlineFragment(self, node):
+        type_condition_ast = node.type_condition
+        type = type_from_ast(self._schema, type_condition_ast) if type_condition_ast else self.get_type()
+        self._type_stack.append(type)
+
+    enter_FragmentDefinition = enter_InlineFragment
+
+    def enter_VariableDefinition(self, node):
+        self._input_type_stack.append(type_from_ast(self._schema, node.type))
+
+    def enter_Argument(self, node):
+        arg_def = None
+        arg_type = None
+        field_or_directive = self.get_directive() or self.get_field_def()
+        if field_or_directive:
+            arg_def = field_or_directive.args.get(node.name.value)
+            if arg_def:
+                arg_type = arg_def.type
+        self._argument = arg_def
+        self._input_type_stack.append(arg_type)
+
+    def enter_ListValue(self, node):
+        list_type = get_nullable_type(self.get_input_type())
+        self._input_type_stack.append(
+            list_type.of_type if isinstance(list_type, GraphQLList) else None
+        )
+
+    def enter_ObjectField(self, node):
+        object_type = get_named_type(self.get_input_type())
+        field_type = None
+        if isinstance(object_type, GraphQLInputObjectType):
+            input_field = object_type.fields.get(node.name.value)
+            field_type = input_field.type if input_field else None
+        self._input_type_stack.append(field_type)
+
+    def leave_SelectionSet(self):
+        pop(self._parent_type_stack)
+
+    def leave_Field(self):
+        pop(self._field_def_stack)
+        pop(self._type_stack)
+
+    def leave_Directive(self):
+        self._directive = None
+
+    def leave_OperationDefinition(self):
+        pop(self._type_stack)
+
+    leave_InlineFragment = leave_OperationDefinition
+    leave_FragmentDefinition = leave_OperationDefinition
+
+    def leave_VariableDefinition(self):
+        pop(self._input_type_stack)
+
+    def leave_Argument(self):
+        self._argument = None
+        pop(self._input_type_stack)
+
+    def leave_ListType(self):
+        pop(self._input_type_stack)
+
+    leave_ObjectField = leave_ListType

wandb/vendor/graphql-core-1.1/wandb_graphql/utils/value_from_ast.py

@@ -0,0 +1,69 @@
+from ..language import ast
+from ..type import (GraphQLEnumType, GraphQLInputObjectType, GraphQLList,
+                    GraphQLNonNull, GraphQLScalarType)
+
+
+def value_from_ast(value_ast, type, variables=None):
+    """Given a type and a value AST node known to match this type, build a
+    runtime value."""
+    if isinstance(type, GraphQLNonNull):
+        # Note: we're not checking that the result of coerceValueAST is non-null.
+        # We're assuming that this query has been validated and the value used here is of the correct type.
+        return value_from_ast(value_ast, type.of_type, variables)
+
+    if not value_ast:
+        return None
+
+    if isinstance(value_ast, ast.Variable):
+        variable_name = value_ast.name.value
+        if not variables or variable_name not in variables:
+            return None
+
+        # Note: we're not doing any checking that this variable is correct. We're assuming that this query
+        # has been validated and the variable usage here is of the correct type.
+        return variables[variable_name]
+
+    if isinstance(type, GraphQLList):
+        item_type = type.of_type
+        if isinstance(value_ast, ast.ListValue):
+            return [value_from_ast(item_ast, item_type, variables)
+                    for item_ast in value_ast.values]
+
+        else:
+            return [value_from_ast(value_ast, item_type, variables)]
+
+    if isinstance(type, GraphQLInputObjectType):
+        fields = type.fields
+        if not isinstance(value_ast, ast.ObjectValue):
+            return None
+
+        field_asts = {}
+
+        for field in value_ast.fields:
+            field_asts[field.name.value] = field
+
+        obj = {}
+        for field_name, field in fields.items():
+            field_ast = field_asts.get(field_name)
+            field_value_ast = None
+
+            if field_ast:
+                field_value_ast = field_ast.value
+
+            field_value = value_from_ast(
+                field_value_ast, field.type, variables
+            )
+            if field_value is None:
+                field_value = field.default_value
+
+            if field_value is not None:
+                # We use out_name as the output name for the
+                # dict if exists
+                obj[field.out_name or field_name] = field_value
+
+        return obj
+
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
+        'Must be input type'
+
+    return type.parse_literal(value_ast)

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

@@ -0,0 +1,4 @@
+from .validation import validate
+from .rules import specified_rules
+
+__all__ = ['validate', 'specified_rules']

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

@@ -0,0 +1,79 @@
+from .arguments_of_correct_type import ArgumentsOfCorrectType
+from .default_values_of_correct_type import DefaultValuesOfCorrectType
+from .fields_on_correct_type import FieldsOnCorrectType
+from .fragments_on_composite_types import FragmentsOnCompositeTypes
+from .known_argument_names import KnownArgumentNames
+from .known_directives import KnownDirectives
+from .known_fragment_names import KnownFragmentNames
+from .known_type_names import KnownTypeNames
+from .lone_anonymous_operation import LoneAnonymousOperation
+from .no_fragment_cycles import NoFragmentCycles
+from .no_undefined_variables import NoUndefinedVariables
+from .no_unused_fragments import NoUnusedFragments
+from .no_unused_variables import NoUnusedVariables
+from .overlapping_fields_can_be_merged import OverlappingFieldsCanBeMerged
+from .possible_fragment_spreads import PossibleFragmentSpreads
+from .provided_non_null_arguments import ProvidedNonNullArguments
+from .scalar_leafs import ScalarLeafs
+from .unique_argument_names import UniqueArgumentNames
+from .unique_fragment_names import UniqueFragmentNames
+from .unique_input_field_names import UniqueInputFieldNames
+from .unique_operation_names import UniqueOperationNames
+from .unique_variable_names import UniqueVariableNames
+from .variables_are_input_types import VariablesAreInputTypes
+from .variables_in_allowed_position import VariablesInAllowedPosition
+
+specified_rules = [
+    UniqueOperationNames,
+    LoneAnonymousOperation,
+    KnownTypeNames,
+    FragmentsOnCompositeTypes,
+    VariablesAreInputTypes,
+    ScalarLeafs,
+    FieldsOnCorrectType,
+    UniqueFragmentNames,
+    KnownFragmentNames,
+    NoUnusedFragments,
+    PossibleFragmentSpreads,
+    NoFragmentCycles,
+    NoUndefinedVariables,
+    NoUnusedVariables,
+    KnownDirectives,
+    KnownArgumentNames,
+    UniqueArgumentNames,
+    ArgumentsOfCorrectType,
+    ProvidedNonNullArguments,
+    DefaultValuesOfCorrectType,
+    VariablesInAllowedPosition,
+    OverlappingFieldsCanBeMerged,
+    UniqueInputFieldNames,
+    UniqueVariableNames
+]
+
+__all__ = [
+    'ArgumentsOfCorrectType',
+    'DefaultValuesOfCorrectType',
+    'FieldsOnCorrectType',
+    'FragmentsOnCompositeTypes',
+    'KnownArgumentNames',
+    'KnownDirectives',
+    'KnownFragmentNames',
+    'KnownTypeNames',
+    'LoneAnonymousOperation',
+    'NoFragmentCycles',
+    'UniqueVariableNames',
+    'NoUndefinedVariables',
+    'NoUnusedFragments',
+    'NoUnusedVariables',
+    'OverlappingFieldsCanBeMerged',
+    'PossibleFragmentSpreads',
+    'ProvidedNonNullArguments',
+    'ScalarLeafs',
+    'UniqueArgumentNames',
+    'UniqueFragmentNames',
+    'UniqueInputFieldNames',
+    'UniqueOperationNames',
+    'VariablesAreInputTypes',
+    'VariablesInAllowedPosition',
+    'specified_rules'
+]

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

@@ -0,0 +1,24 @@
+from ...error import GraphQLError
+from ...language.printer import print_ast
+from ...utils.is_valid_literal_value import is_valid_literal_value
+from .base import ValidationRule
+
+
+class ArgumentsOfCorrectType(ValidationRule):
+
+    def enter_Argument(self, node, key, parent, path, ancestors):
+        arg_def = self.context.get_argument()
+        if arg_def:
+            errors = is_valid_literal_value(arg_def.type, node.value)
+            if errors:
+                self.context.report_error(GraphQLError(
+                    self.bad_value_message(node.name.value, arg_def.type,
+                                           print_ast(node.value), errors),
+                    [node.value]
+                ))
+        return False
+
+    @staticmethod
+    def bad_value_message(arg_name, type, value, verbose_errors):
+        message = (u'\n' + u'\n'.join(verbose_errors)) if verbose_errors else ''
+        return 'Argument "{}" has invalid value {}.{}'.format(arg_name, value, message)

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

@@ -0,0 +1,8 @@
+from ...language.visitor import Visitor
+
+
+class ValidationRule(Visitor):
+    __slots__ = 'context',
+
+    def __init__(self, context):
+        self.context = context