wandb 0.18.2__py3-none-musllinux_1_2_x86_64.whl

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

@@ -0,0 +1,44 @@
+from ...error import GraphQLError
+from ...language.printer import print_ast
+from ...type.definition import GraphQLNonNull
+from ...utils.is_valid_literal_value import is_valid_literal_value
+from .base import ValidationRule
+
+
+class DefaultValuesOfCorrectType(ValidationRule):
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        name = node.variable.name.value
+        default_value = node.default_value
+        type = self.context.get_input_type()
+
+        if isinstance(type, GraphQLNonNull) and default_value:
+            self.context.report_error(GraphQLError(
+                self.default_for_non_null_arg_message(name, type, type.of_type),
+                [default_value]
+            ))
+
+        if type and default_value:
+            errors = is_valid_literal_value(type, default_value)
+            if errors:
+                self.context.report_error(GraphQLError(
+                    self.bad_value_for_default_arg_message(name, type, print_ast(default_value), errors),
+                    [default_value]
+                ))
+        return False
+
+    def enter_SelectionSet(self, node, key, parent, path, ancestors):
+        return False
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        return False
+
+    @staticmethod
+    def default_for_non_null_arg_message(var_name, type, guess_type):
+        return u'Variable "${}" of type "{}" is required and will not use the default value. ' \
+               u'Perhaps you meant to use type "{}".'.format(var_name, type, guess_type)
+
+    @staticmethod
+    def bad_value_for_default_arg_message(var_name, type, value, verbose_errors):
+        message = (u'\n' + u'\n'.join(verbose_errors)) if verbose_errors else u''
+        return u'Variable "${}" of type "{}" has invalid default value: {}.{}'.format(var_name, type, value, message)

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

@@ -0,0 +1,113 @@
+from collections import Counter
+
+from ...error import GraphQLError
+from ...pyutils.ordereddict import OrderedDict
+from ...type.definition import (GraphQLInterfaceType, GraphQLObjectType,
+                                GraphQLUnionType)
+from ...utils.quoted_or_list import quoted_or_list
+from ...utils.suggestion_list import suggestion_list
+from .base import ValidationRule
+
+try:
+    # Python 2
+    from itertools import izip
+except ImportError:
+    # Python 3
+    izip = zip
+
+
+def _undefined_field_message(field_name, type, suggested_types,
+                             suggested_fields):
+    message = 'Cannot query field "{}" on type "{}".'.format(field_name, type)
+
+    if suggested_types:
+        suggestions = quoted_or_list(suggested_types)
+        message += " Did you mean to use an inline fragment on {}?".format(suggestions)
+    elif suggested_fields:
+        suggestions = quoted_or_list(suggested_fields)
+        message += " Did you mean {}?".format(suggestions)
+
+    return message
+
+
+class OrderedCounter(Counter, OrderedDict):
+    pass
+
+
+class FieldsOnCorrectType(ValidationRule):
+    '''Fields on correct type
+
+      A GraphQL document is only valid if all fields selected are defined by the
+      parent type, or are an allowed meta field such as __typenamme
+    '''
+
+    def enter_Field(self, node, key, parent, path, ancestors):
+        parent_type = self.context.get_parent_type()
+        if not parent_type:
+            return
+
+        field_def = self.context.get_field_def()
+        if not field_def:
+            #  This field doesn't exist, lets look for suggestions.
+            schema = self.context.get_schema()
+            field_name = node.name.value
+
+            # First determine if there are any suggested types to condition on.
+            suggested_type_names = get_suggested_type_names(schema, parent_type, field_name)
+            # if there are no suggested types perhaps it was a typo?
+            suggested_field_names = [] if suggested_type_names else get_suggested_field_names(schema, parent_type, field_name)
+
+            # report an error including helpful suggestions.
+            self.context.report_error(GraphQLError(
+                _undefined_field_message(field_name, parent_type.name, suggested_type_names, suggested_field_names),
+                [node]
+            ))
+
+
+def get_suggested_type_names(schema, output_type, field_name):
+    '''Go through all of the implementations of type, as well as the interfaces
+      that they implement. If any of those types include the provided field,
+      suggest them, sorted by how often the type is referenced,  starting
+      with Interfaces.'''
+
+    if isinstance(output_type, (GraphQLInterfaceType, GraphQLUnionType)):
+        suggested_object_types = []
+        interface_usage_count = OrderedDict()
+        for possible_type in schema.get_possible_types(output_type):
+            if not possible_type.fields.get(field_name):
+                return
+
+            # This object type defines this field.
+            suggested_object_types.append(possible_type.name)
+
+            for possible_interface in possible_type.interfaces:
+                if not possible_interface.fields.get(field_name):
+                    continue
+
+                # This interface type defines this field.
+                interface_usage_count[possible_interface.name] = (
+                    interface_usage_count.get(possible_interface.name, 0) + 1)
+
+        # Suggest interface types based on how common they are.
+        suggested_interface_types = sorted(list(interface_usage_count.keys()), key=lambda k: interface_usage_count[k],
+                                           reverse=True)
+
+        # Suggest both interface and object types.
+        suggested_interface_types.extend(suggested_object_types)
+        return suggested_interface_types
+
+    # Otherwise, must be an Object type, which does not have possible fields.
+    return []
+
+
+def get_suggested_field_names(schema, graphql_type, field_name):
+    '''For the field name provided, determine if there are any similar field names
+    that may be the result of a typo.'''
+
+    if isinstance(graphql_type, (GraphQLInterfaceType, GraphQLObjectType)):
+        possible_field_names = list(graphql_type.fields.keys())
+
+        return suggestion_list(field_name, possible_field_names)
+
+    # Otherwise, must be a Union type, which does not define fields.
+    return []

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

@@ -0,0 +1,33 @@
+from ...error import GraphQLError
+from ...language.printer import print_ast
+from ...type.definition import is_composite_type
+from .base import ValidationRule
+
+
+class FragmentsOnCompositeTypes(ValidationRule):
+
+    def enter_InlineFragment(self, node, key, parent, path, ancestors):
+        type = self.context.get_type()
+
+        if node.type_condition and type and not is_composite_type(type):
+            self.context.report_error(GraphQLError(
+                self.inline_fragment_on_non_composite_error_message(print_ast(node.type_condition)),
+                [node.type_condition]
+            ))
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        type = self.context.get_type()
+
+        if type and not is_composite_type(type):
+            self.context.report_error(GraphQLError(
+                self.fragment_on_non_composite_error_message(node.name.value, print_ast(node.type_condition)),
+                [node.type_condition]
+            ))
+
+    @staticmethod
+    def inline_fragment_on_non_composite_error_message(type):
+        return 'Fragment cannot condition on non composite type "{}".'.format(type)
+
+    @staticmethod
+    def fragment_on_non_composite_error_message(frag_name, type):
+        return 'Fragment "{}" cannot condition on non composite type "{}".'.format(frag_name, type)

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

@@ -0,0 +1,70 @@
+from ...error import GraphQLError
+from ...language import ast
+from ...utils.quoted_or_list import quoted_or_list
+from ...utils.suggestion_list import suggestion_list
+from .base import ValidationRule
+
+
+def _unknown_arg_message(arg_name, field_name, type, suggested_args):
+    message = 'Unknown argument "{}" on field "{}" of type "{}".'.format(arg_name, field_name, type)
+    if suggested_args:
+        message += ' Did you mean {}?'.format(quoted_or_list(suggested_args))
+
+    return message
+
+
+def _unknown_directive_arg_message(arg_name, directive_name, suggested_args):
+    message = 'Unknown argument "{}" on directive "@{}".'.format(arg_name, directive_name)
+    if suggested_args:
+        message += ' Did you mean {}?'.format(quoted_or_list(suggested_args))
+
+    return message
+
+
+class KnownArgumentNames(ValidationRule):
+
+    def enter_Argument(self, node, key, parent, path, ancestors):
+        argument_of = ancestors[-1]
+
+        if isinstance(argument_of, ast.Field):
+            field_def = self.context.get_field_def()
+            if not field_def:
+                return
+
+            field_arg_def = field_def.args.get(node.name.value)
+
+            if not field_arg_def:
+                parent_type = self.context.get_parent_type()
+                assert parent_type
+                self.context.report_error(GraphQLError(
+                    _unknown_arg_message(
+                        node.name.value,
+                        argument_of.name.value,
+                        parent_type.name,
+                        suggestion_list(
+                            node.name.value,
+                            (arg_name for arg_name in field_def.args.keys())
+                        )
+                    ),
+                    [node]
+                ))
+
+        elif isinstance(argument_of, ast.Directive):
+            directive = self.context.get_directive()
+            if not directive:
+                return
+
+            directive_arg_def = directive.args.get(node.name.value)
+
+            if not directive_arg_def:
+                self.context.report_error(GraphQLError(
+                    _unknown_directive_arg_message(
+                        node.name.value,
+                        directive.name,
+                        suggestion_list(
+                            node.name.value,
+                            (arg_name for arg_name in directive.args.keys())
+                        )
+                    ),
+                    [node]
+                ))

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

@@ -0,0 +1,97 @@
+from ...error import GraphQLError
+from ...language import ast
+from ...type.directives import DirectiveLocation
+from .base import ValidationRule
+
+
+class KnownDirectives(ValidationRule):
+
+    def enter_Directive(self, node, key, parent, path, ancestors):
+        directive_def = next((
+            definition for definition in self.context.get_schema().get_directives()
+            if definition.name == node.name.value
+        ), None)
+
+        if not directive_def:
+            return self.context.report_error(GraphQLError(
+                self.unknown_directive_message(node.name.value),
+                [node]
+            ))
+
+        candidate_location = get_directive_location_for_ast_path(ancestors)
+        if not candidate_location:
+            self.context.report_error(GraphQLError(
+                self.misplaced_directive_message(node.name.value, node.type),
+                [node]
+            ))
+        elif candidate_location not in directive_def.locations:
+            self.context.report_error(GraphQLError(
+                self.misplaced_directive_message(node.name.value, candidate_location),
+                [node]
+            ))
+
+    @staticmethod
+    def unknown_directive_message(directive_name):
+        return 'Unknown directive "{}".'.format(directive_name)
+
+    @staticmethod
+    def misplaced_directive_message(directive_name, location):
+        return 'Directive "{}" may not be used on "{}".'.format(directive_name, location)
+
+
+_operation_definition_map = {
+    'query': DirectiveLocation.QUERY,
+    'mutation': DirectiveLocation.MUTATION,
+    'subscription': DirectiveLocation.SUBSCRIPTION,
+}
+
+
+def get_directive_location_for_ast_path(ancestors):
+    applied_to = ancestors[-1]
+    if isinstance(applied_to, ast.OperationDefinition):
+        return _operation_definition_map.get(applied_to.operation)
+
+    elif isinstance(applied_to, ast.Field):
+        return DirectiveLocation.FIELD
+
+    elif isinstance(applied_to, ast.FragmentSpread):
+        return DirectiveLocation.FRAGMENT_SPREAD
+
+    elif isinstance(applied_to, ast.InlineFragment):
+        return DirectiveLocation.INLINE_FRAGMENT
+
+    elif isinstance(applied_to, ast.FragmentDefinition):
+        return DirectiveLocation.FRAGMENT_DEFINITION
+
+    elif isinstance(applied_to, ast.SchemaDefinition):
+        return DirectiveLocation.SCHEMA
+
+    elif isinstance(applied_to, ast.ScalarTypeDefinition):
+        return DirectiveLocation.SCALAR
+
+    elif isinstance(applied_to, ast.ObjectTypeDefinition):
+        return DirectiveLocation.OBJECT
+
+    elif isinstance(applied_to, ast.FieldDefinition):
+        return DirectiveLocation.FIELD_DEFINITION
+
+    elif isinstance(applied_to, ast.InterfaceTypeDefinition):
+        return DirectiveLocation.INTERFACE
+
+    elif isinstance(applied_to, ast.UnionTypeDefinition):
+        return DirectiveLocation.UNION
+
+    elif isinstance(applied_to, ast.EnumTypeDefinition):
+        return DirectiveLocation.ENUM
+
+    elif isinstance(applied_to, ast.EnumValueDefinition):
+        return DirectiveLocation.ENUM_VALUE
+
+    elif isinstance(applied_to, ast.InputObjectTypeDefinition):
+        return DirectiveLocation.INPUT_OBJECT
+
+    elif isinstance(applied_to, ast.InputValueDefinition):
+        parent_node = ancestors[-3]
+        return (DirectiveLocation.INPUT_FIELD_DEFINITION
+                if isinstance(parent_node, ast.InputObjectTypeDefinition)
+                else DirectiveLocation.ARGUMENT_DEFINITION)

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

@@ -0,0 +1,19 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class KnownFragmentNames(ValidationRule):
+
+    def enter_FragmentSpread(self, node, key, parent, path, ancestors):
+        fragment_name = node.name.value
+        fragment = self.context.get_fragment(fragment_name)
+
+        if not fragment:
+            self.context.report_error(GraphQLError(
+                self.unknown_fragment_message(fragment_name),
+                [node.name]
+            ))
+
+    @staticmethod
+    def unknown_fragment_message(fragment_name):
+        return 'Unknown fragment "{}".'.format(fragment_name)

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

@@ -0,0 +1,43 @@
+from ...error import GraphQLError
+from ...utils.quoted_or_list import quoted_or_list
+from ...utils.suggestion_list import suggestion_list
+from .base import ValidationRule
+
+
+def _unknown_type_message(type, suggested_types):
+    message = 'Unknown type "{}".'.format(type)
+    if suggested_types:
+        message += ' Perhaps you meant {}?'.format(quoted_or_list(suggested_types))
+
+    return message
+
+
+class KnownTypeNames(ValidationRule):
+
+    def enter_ObjectTypeDefinition(self, node, *args):
+        return False
+
+    def enter_InterfaceTypeDefinition(self, node, *args):
+        return False
+
+    def enter_UnionTypeDefinition(self, node, *args):
+        return False
+
+    def enter_InputObjectTypeDefinition(self, node, *args):
+        return False
+
+    def enter_NamedType(self, node, *args):
+        schema = self.context.get_schema()
+        type_name = node.name.value
+        type = schema.get_type(type_name)
+
+        if not type:
+            self.context.report_error(
+                GraphQLError(
+                    _unknown_type_message(
+                        type_name,
+                        suggestion_list(type_name, list(schema.get_type_map().keys()))
+                    ),
+                    [node]
+                )
+            )

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

@@ -0,0 +1,23 @@
+from ...error import GraphQLError
+from ...language import ast
+from .base import ValidationRule
+
+
+class LoneAnonymousOperation(ValidationRule):
+    __slots__ = 'operation_count',
+
+    def __init__(self, context):
+        self.operation_count = 0
+        super(LoneAnonymousOperation, self).__init__(context)
+
+    def enter_Document(self, node, key, parent, path, ancestors):
+        self.operation_count = \
+            sum(1 for definition in node.definitions if isinstance(definition, ast.OperationDefinition))
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        if not node.name and self.operation_count > 1:
+            self.context.report_error(GraphQLError(self.anonymous_operation_not_alone_message(), [node]))
+
+    @staticmethod
+    def anonymous_operation_not_alone_message():
+        return 'This anonymous operation must be the only defined operation.'

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

@@ -0,0 +1,59 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class NoFragmentCycles(ValidationRule):
+    __slots__ = 'errors', 'visited_frags', 'spread_path', 'spread_path_index_by_name'
+
+    def __init__(self, context):
+        super(NoFragmentCycles, self).__init__(context)
+        self.errors = []
+        self.visited_frags = set()
+        self.spread_path = []
+        self.spread_path_index_by_name = {}
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        return False
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        if node.name.value not in self.visited_frags:
+            self.detect_cycle_recursive(node)
+        return False
+
+    def detect_cycle_recursive(self, fragment):
+        fragment_name = fragment.name.value
+        self.visited_frags.add(fragment_name)
+
+        spread_nodes = self.context.get_fragment_spreads(fragment.selection_set)
+        if not spread_nodes:
+            return
+
+        self.spread_path_index_by_name[fragment_name] = len(self.spread_path)
+
+        for spread_node in spread_nodes:
+            spread_name = spread_node.name.value
+            cycle_index = self.spread_path_index_by_name.get(spread_name)
+
+            if cycle_index is None:
+                self.spread_path.append(spread_node)
+                if spread_name not in self.visited_frags:
+                    spread_fragment = self.context.get_fragment(spread_name)
+                    if spread_fragment:
+                        self.detect_cycle_recursive(spread_fragment)
+                self.spread_path.pop()
+            else:
+                cycle_path = self.spread_path[cycle_index:]
+                self.context.report_error(GraphQLError(
+                    self.cycle_error_message(
+                        spread_name,
+                        [s.name.value for s in cycle_path]
+                    ),
+                    cycle_path + [spread_node]
+                ))
+
+        self.spread_path_index_by_name[fragment_name] = None
+
+    @staticmethod
+    def cycle_error_message(fragment_name, spread_names):
+        via = ' via {}'.format(', '.join(spread_names)) if spread_names else ''
+        return 'Cannot spread fragment "{}" within itself{}.'.format(fragment_name, via)

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

@@ -0,0 +1,36 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class NoUndefinedVariables(ValidationRule):
+    __slots__ = 'defined_variable_names',
+
+    def __init__(self, context):
+        self.defined_variable_names = set()
+        super(NoUndefinedVariables, self).__init__(context)
+
+    @staticmethod
+    def undefined_var_message(var_name, op_name=None):
+        if op_name:
+            return 'Variable "${}" is not defined by operation "{}".'.format(
+                var_name, op_name
+            )
+        return 'Variable "${}" is not defined.'.format(var_name)
+
+    def enter_OperationDefinition(self, operation, key, parent, path, ancestors):
+        self.defined_variable_names = set()
+
+    def leave_OperationDefinition(self, operation, key, parent, path, ancestors):
+        usages = self.context.get_recursive_variable_usages(operation)
+
+        for variable_usage in usages:
+            node = variable_usage.node
+            var_name = node.name.value
+            if var_name not in self.defined_variable_names:
+                self.context.report_error(GraphQLError(
+                    self.undefined_var_message(var_name, operation.name and operation.name.value),
+                    [node, operation]
+                ))
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        self.defined_variable_names.add(node.variable.name.value)

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

@@ -0,0 +1,38 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class NoUnusedFragments(ValidationRule):
+    __slots__ = 'fragment_definitions', 'operation_definitions', 'fragment_adjacencies', 'spread_names'
+
+    def __init__(self, context):
+        super(NoUnusedFragments, self).__init__(context)
+        self.operation_definitions = []
+        self.fragment_definitions = []
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        self.operation_definitions.append(node)
+        return False
+
+    def enter_FragmentDefinition(self, node, key, parent, path, ancestors):
+        self.fragment_definitions.append(node)
+        return False
+
+    def leave_Document(self, node, key, parent, path, ancestors):
+        fragment_names_used = set()
+
+        for operation in self.operation_definitions:
+            fragments = self.context.get_recursively_referenced_fragments(operation)
+            for fragment in fragments:
+                fragment_names_used.add(fragment.name.value)
+
+        for fragment_definition in self.fragment_definitions:
+            if fragment_definition.name.value not in fragment_names_used:
+                self.context.report_error(GraphQLError(
+                    self.unused_fragment_message(fragment_definition.name.value),
+                    [fragment_definition]
+                ))
+
+    @staticmethod
+    def unused_fragment_message(fragment_name):
+        return 'Fragment "{}" is never used.'.format(fragment_name)

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

@@ -0,0 +1,37 @@
+from ...error import GraphQLError
+from .base import ValidationRule
+
+
+class NoUnusedVariables(ValidationRule):
+    __slots__ = 'variable_definitions'
+
+    def __init__(self, context):
+        self.variable_definitions = []
+        super(NoUnusedVariables, self).__init__(context)
+
+    def enter_OperationDefinition(self, node, key, parent, path, ancestors):
+        self.variable_definitions = []
+
+    def leave_OperationDefinition(self, operation, key, parent, path, ancestors):
+        variable_name_used = set()
+        usages = self.context.get_recursive_variable_usages(operation)
+        op_name = operation.name and operation.name.value or None
+
+        for variable_usage in usages:
+            variable_name_used.add(variable_usage.node.name.value)
+
+        for variable_definition in self.variable_definitions:
+            if variable_definition.variable.name.value not in variable_name_used:
+                self.context.report_error(GraphQLError(
+                    self.unused_variable_message(variable_definition.variable.name.value, op_name),
+                    [variable_definition]
+                ))
+
+    def enter_VariableDefinition(self, node, key, parent, path, ancestors):
+        self.variable_definitions.append(node)
+
+    @staticmethod
+    def unused_variable_message(variable_name, op_name):
+        if op_name:
+            return 'Variable "${}" is never used in operation "{}".'.format(variable_name, op_name)
+        return 'Variable "${}" is never used.'.format(variable_name)