wandb 0.18.2__py3-none-musllinux_1_2_x86_64.whl

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

@@ -0,0 +1,357 @@
+from collections import defaultdict
+
+from ..error import GraphQLError
+from ..language import ast
+from ..pyutils.ordereddict import OrderedDict
+from ..type.definition import (GraphQLArgument, GraphQLEnumType,
+                               GraphQLEnumValue, GraphQLField,
+                               GraphQLInputObjectField, GraphQLInputObjectType,
+                               GraphQLInterfaceType, GraphQLList,
+                               GraphQLNonNull, GraphQLObjectType,
+                               GraphQLScalarType, GraphQLUnionType)
+from ..type.introspection import (__Directive, __DirectiveLocation,
+                                  __EnumValue, __Field, __InputValue, __Schema,
+                                  __Type, __TypeKind)
+from ..type.scalars import (GraphQLBoolean, GraphQLFloat, GraphQLID,
+                            GraphQLInt, GraphQLString)
+from ..type.schema import GraphQLSchema
+from .value_from_ast import value_from_ast
+
+
+def extend_schema(schema, documentAST=None):
+    """Produces a new schema given an existing schema and a document which may
+    contain GraphQL type extensions and definitions. The original schema will
+    remain unaltered.
+
+    Because a schema represents a graph of references, a schema cannot be
+    extended without effectively making an entire copy. We do not know until it's
+    too late if subgraphs remain unchanged.
+
+    This algorithm copies the provided schema, applying extensions while
+    producing the copy. The original schema remains unaltered."""
+
+    assert isinstance(
+        schema, GraphQLSchema), 'Must provide valid GraphQLSchema'
+    assert documentAST and isinstance(
+        documentAST, ast.Document), 'Must provide valid Document AST'
+
+    # Collect the type definitions and extensions found in the document.
+    type_definition_map = {}
+    type_extensions_map = defaultdict(list)
+
+    for _def in documentAST.definitions:
+        if isinstance(_def, (
+            ast.ObjectTypeDefinition,
+            ast.InterfaceTypeDefinition,
+            ast.EnumTypeDefinition,
+            ast.UnionTypeDefinition,
+            ast.ScalarTypeDefinition,
+            ast.InputObjectTypeDefinition,
+        )):
+            # Sanity check that none of the defined types conflict with the
+            # schema's existing types.
+            type_name = _def.name.value
+            if schema.get_type(type_name):
+                raise GraphQLError(
+                    ('Type "{}" already exists in the schema. It cannot also ' +
+                     'be defined in this type definition.').format(type_name),
+                    [_def]
+                )
+
+            type_definition_map[type_name] = _def
+        elif isinstance(_def, ast.TypeExtensionDefinition):
+            # Sanity check that this type extension exists within the
+            # schema's existing types.
+            extended_type_name = _def.definition.name.value
+            existing_type = schema.get_type(extended_type_name)
+            if not existing_type:
+                raise GraphQLError(
+                    ('Cannot extend type "{}" because it does not ' +
+                     'exist in the existing schema.').format(extended_type_name),
+                    [_def.definition]
+                )
+            if not isinstance(existing_type, GraphQLObjectType):
+                raise GraphQLError(
+                    'Cannot extend non-object type "{}".'.format(
+                        extended_type_name),
+                    [_def.definition]
+                )
+
+            type_extensions_map[extended_type_name].append(_def)
+
+    # Below are functions used for producing this schema that have closed over
+    # this scope and have access to the schema, cache, and newly defined types.
+
+    def get_type_from_def(type_def):
+        type = _get_named_type(type_def.name)
+        assert type, 'Invalid schema'
+        return type
+
+    def get_type_from_AST(astNode):
+        type = _get_named_type(astNode.name.value)
+        if not type:
+            raise GraphQLError(
+                ('Unknown type: "{}". Ensure that this type exists ' +
+                 'either in the original schema, or is added in a type definition.').format(
+                    astNode.name.value),
+                [astNode]
+            )
+        return type
+
+    # Given a name, returns a type from either the existing schema or an
+    # added type.
+    def _get_named_type(typeName):
+        cached_type_def = type_def_cache.get(typeName)
+        if cached_type_def:
+            return cached_type_def
+
+        existing_type = schema.get_type(typeName)
+        if existing_type:
+            type_def = extend_type(existing_type)
+            type_def_cache[typeName] = type_def
+            return type_def
+
+        type_ast = type_definition_map.get(typeName)
+        if type_ast:
+            type_def = build_type(type_ast)
+            type_def_cache[typeName] = type_def
+            return type_def
+
+    # Given a type's introspection result, construct the correct
+    # GraphQLType instance.
+    def extend_type(type):
+        if isinstance(type, GraphQLObjectType):
+            return extend_object_type(type)
+        if isinstance(type, GraphQLInterfaceType):
+            return extend_interface_type(type)
+        if isinstance(type, GraphQLUnionType):
+            return extend_union_type(type)
+        return type
+
+    def extend_object_type(type):
+        return GraphQLObjectType(
+            name=type.name,
+            description=type.description,
+            interfaces=lambda: extend_implemented_interfaces(type),
+            fields=lambda: extend_field_map(type),
+        )
+
+    def extend_interface_type(type):
+        return GraphQLInterfaceType(
+            name=type.name,
+            description=type.description,
+            fields=lambda: extend_field_map(type),
+            resolve_type=cannot_execute_client_schema,
+        )
+
+    def extend_union_type(type):
+        return GraphQLUnionType(
+            name=type.name,
+            description=type.description,
+            types=list(map(get_type_from_def, type.types)),
+            resolve_type=cannot_execute_client_schema,
+        )
+
+    def extend_implemented_interfaces(type):
+        interfaces = list(map(get_type_from_def, type.interfaces))
+
+        # If there are any extensions to the interfaces, apply those here.
+        extensions = type_extensions_map[type.name]
+        for extension in extensions:
+            for namedType in extension.definition.interfaces:
+                interface_name = namedType.name.value
+                if any([_def.name == interface_name for _def in interfaces]):
+                    raise GraphQLError(
+                        ('Type "{}" already implements "{}". ' +
+                         'It cannot also be implemented in this type extension.').format(
+                            type.name, interface_name),
+                        [namedType]
+                    )
+                interfaces.append(get_type_from_AST(namedType))
+
+        return interfaces
+
+    def extend_field_map(type):
+        new_field_map = OrderedDict()
+        old_field_map = type.fields
+        for field_name, field in old_field_map.items():
+            new_field_map[field_name] = GraphQLField(
+                extend_field_type(field.type),
+                description=field.description,
+                deprecation_reason=field.deprecation_reason,
+                args=field.args,
+                resolver=cannot_execute_client_schema,
+            )
+
+        # If there are any extensions to the fields, apply those here.
+        extensions = type_extensions_map[type.name]
+        for extension in extensions:
+            for field in extension.definition.fields:
+                field_name = field.name.value
+                if field_name in old_field_map:
+                    raise GraphQLError(
+                        ('Field "{}.{}" already exists in the ' +
+                         'schema. It cannot also be defined in this type extension.').format(
+                            type.name, field_name),
+                        [field]
+                    )
+                new_field_map[field_name] = GraphQLField(
+                    build_field_type(field.type),
+                    args=build_input_values(field.arguments),
+                    resolver=cannot_execute_client_schema,
+                )
+
+        return new_field_map
+
+    def extend_field_type(type):
+        if isinstance(type, GraphQLList):
+            return GraphQLList(extend_field_type(type.of_type))
+        if isinstance(type, GraphQLNonNull):
+            return GraphQLNonNull(extend_field_type(type.of_type))
+        return get_type_from_def(type)
+
+    def build_type(type_ast):
+        _type_build = {
+            ast.ObjectTypeDefinition: build_object_type,
+            ast.InterfaceTypeDefinition: build_interface_type,
+            ast.UnionTypeDefinition: build_union_type,
+            ast.ScalarTypeDefinition: build_scalar_type,
+            ast.EnumTypeDefinition: build_enum_type,
+            ast.InputObjectTypeDefinition: build_input_object_type
+        }
+        func = _type_build.get(type(type_ast))
+        if func:
+            return func(type_ast)
+
+    def build_object_type(type_ast):
+        return GraphQLObjectType(
+            type_ast.name.value,
+            interfaces=lambda: build_implemented_interfaces(type_ast),
+            fields=lambda: build_field_map(type_ast),
+        )
+
+    def build_interface_type(type_ast):
+        return GraphQLInterfaceType(
+            type_ast.name.value,
+            fields=lambda: build_field_map(type_ast),
+            resolve_type=cannot_execute_client_schema,
+        )
+
+    def build_union_type(type_ast):
+        return GraphQLUnionType(
+            type_ast.name.value,
+            types=list(map(get_type_from_AST, type_ast.types)),
+            resolve_type=cannot_execute_client_schema,
+        )
+
+    def build_scalar_type(type_ast):
+        return GraphQLScalarType(
+            type_ast.name.value,
+            serialize=lambda *args, **kwargs: None,
+            # Note: validation calls the parse functions to determine if a
+            # literal value is correct. Returning null would cause use of custom
+            # scalars to always fail validation. Returning false causes them to
+            # always pass validation.
+            parse_value=lambda *args, **kwargs: False,
+            parse_literal=lambda *args, **kwargs: False,
+        )
+
+    def build_enum_type(type_ast):
+        return GraphQLEnumType(
+            type_ast.name.value,
+            values={v.name.value: GraphQLEnumValue() for v in type_ast.values},
+        )
+
+    def build_input_object_type(type_ast):
+        return GraphQLInputObjectType(
+            type_ast.name.value,
+            fields=lambda: build_input_values(
+                type_ast.fields, GraphQLInputObjectField),
+        )
+
+    def build_implemented_interfaces(type_ast):
+        return list(map(get_type_from_AST, type_ast.interfaces))
+
+    def build_field_map(type_ast):
+        return {
+            field.name.value: GraphQLField(
+                build_field_type(field.type),
+                args=build_input_values(field.arguments),
+                resolver=cannot_execute_client_schema,
+            ) for field in type_ast.fields
+        }
+
+    def build_input_values(values, input_type=GraphQLArgument):
+        input_values = OrderedDict()
+        for value in values:
+            type = build_field_type(value.type)
+            input_values[value.name.value] = input_type(
+                type,
+                default_value=value_from_ast(value.default_value, type)
+            )
+        return input_values
+
+    def build_field_type(type_ast):
+        if isinstance(type_ast, ast.ListType):
+            return GraphQLList(build_field_type(type_ast.type))
+        if isinstance(type_ast, ast.NonNullType):
+            return GraphQLNonNull(build_field_type(type_ast.type))
+        return get_type_from_AST(type_ast)
+
+    # If this document contains no new types, then return the same unmodified
+    # GraphQLSchema instance.
+    if not type_extensions_map and not type_definition_map:
+        return schema
+
+    # A cache to use to store the actual GraphQLType definition objects by name.
+    # Initialize to the GraphQL built in scalars and introspection types. All
+    # functions below are inline so that this type def cache is within the scope
+    # of the closure.
+
+    type_def_cache = {
+        'String': GraphQLString,
+        'Int': GraphQLInt,
+        'Float': GraphQLFloat,
+        'Boolean': GraphQLBoolean,
+        'ID': GraphQLID,
+        '__Schema': __Schema,
+        '__Directive': __Directive,
+        '__DirectiveLocation': __DirectiveLocation,
+        '__Type': __Type,
+        '__Field': __Field,
+        '__InputValue': __InputValue,
+        '__EnumValue': __EnumValue,
+        '__TypeKind': __TypeKind,
+    }
+
+    # Get the root Query, Mutation, and Subscription types.
+    query_type = get_type_from_def(schema.get_query_type())
+
+    existing_mutation_type = schema.get_mutation_type()
+    mutationType = existing_mutation_type and get_type_from_def(
+        existing_mutation_type) or None
+
+    existing_subscription_type = schema.get_subscription_type()
+    subscription_type = existing_subscription_type and get_type_from_def(
+        existing_subscription_type) or None
+
+    # Iterate through all types, getting the type definition for each, ensuring
+    # that any type not directly referenced by a field will get created.
+    types = [get_type_from_def(_def) for _def in schema.get_type_map().values()]
+
+    # Do the same with new types, appending to the list of defined types.
+    types += [get_type_from_AST(_def) for _def in type_definition_map.values()]
+
+    # Then produce and return a Schema with these types.
+    return GraphQLSchema(
+        query=query_type,
+        mutation=mutationType,
+        subscription=subscription_type,
+        # Copy directives.
+        directives=schema.get_directives(),
+        types=types
+    )
+
+
+def cannot_execute_client_schema(*args, **kwargs):
+    raise Exception('Client Schema cannot be used for execution.')

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

@@ -0,0 +1,27 @@
+from ..type.definition import (GraphQLInterfaceType, GraphQLObjectType,
+                               GraphQLUnionType)
+from ..type.introspection import (SchemaMetaFieldDef, TypeMetaFieldDef,
+                                  TypeNameMetaFieldDef)
+
+
+def get_field_def(schema, parent_type, field_ast):
+    """Not exactly the same as the executor's definition of get_field_def, in this
+    statically evaluated environment we do not always have an Object type,
+    and need to handle Interface and Union types."""
+    name = field_ast.name.value
+    if name == '__schema' and schema.get_query_type() == parent_type:
+        return SchemaMetaFieldDef
+
+    elif name == '__type' and schema.get_query_type() == parent_type:
+        return TypeMetaFieldDef
+
+    elif name == '__typename' and \
+            isinstance(parent_type, (
+                GraphQLObjectType,
+                GraphQLInterfaceType,
+                GraphQLUnionType,
+            )):
+        return TypeNameMetaFieldDef
+
+    elif isinstance(parent_type, (GraphQLObjectType, GraphQLInterfaceType)):
+        return parent_type.fields.get(name)

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

@@ -0,0 +1,21 @@
+from ..language import ast
+
+
+def get_operation_ast(document_ast, operation_name=None):
+    operation = None
+
+    for definition in document_ast.definitions:
+        if isinstance(definition, ast.OperationDefinition):
+            if not operation_name:
+                # If no operation name is provided, only return an Operation if it is the only one present in the
+                # document. This means that if we've encountered a second operation as we were iterating over the
+                # definitions in the document, there are more than one Operation defined, and we should return None.
+                if operation:
+                    return None
+
+                operation = definition
+
+            elif definition.name and definition.name.value == operation_name:
+                return definition
+
+    return operation

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

@@ -0,0 +1,90 @@
+introspection_query = '''
+  query IntrospectionQuery {
+    __schema {
+      queryType { name }
+      mutationType { name }
+      subscriptionType { name }
+      types {
+        ...FullType
+      }
+      directives {
+        name
+        description
+        locations
+        args {
+          ...InputValue
+        }
+      }
+    }
+  }
+  fragment FullType on __Type {
+    kind
+    name
+    description
+    fields(includeDeprecated: true) {
+      name
+      description
+      args {
+        ...InputValue
+      }
+      type {
+        ...TypeRef
+      }
+      isDeprecated
+      deprecationReason
+    }
+    inputFields {
+      ...InputValue
+    }
+    interfaces {
+      ...TypeRef
+    }
+    enumValues(includeDeprecated: true) {
+      name
+      description
+      isDeprecated
+      deprecationReason
+    }
+    possibleTypes {
+      ...TypeRef
+    }
+  }
+  fragment InputValue on __InputValue {
+    name
+    description
+    type { ...TypeRef }
+    defaultValue
+  }
+  fragment TypeRef on __Type {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+'''

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

@@ -0,0 +1,67 @@
+from ..language import ast
+from ..language.printer import print_ast
+from ..type.definition import (GraphQLEnumType, GraphQLInputObjectType,
+                               GraphQLList, GraphQLNonNull, GraphQLScalarType)
+
+_empty_list = []
+
+
+def is_valid_literal_value(type, value_ast):
+    if isinstance(type, GraphQLNonNull):
+        of_type = type.of_type
+        if not value_ast:
+            return [u'Expected "{}", found null.'.format(type)]
+
+        return is_valid_literal_value(of_type, value_ast)
+
+    if not value_ast:
+        return _empty_list
+
+    if isinstance(value_ast, ast.Variable):
+        return _empty_list
+
+    if isinstance(type, GraphQLList):
+        item_type = type.of_type
+        if isinstance(value_ast, ast.ListValue):
+            errors = []
+
+            for i, item_ast in enumerate(value_ast.values):
+                item_errors = is_valid_literal_value(item_type, item_ast)
+                for error in item_errors:
+                    errors.append(u'In element #{}: {}'.format(i, error))
+
+            return errors
+
+        return is_valid_literal_value(item_type, value_ast)
+
+    if isinstance(type, GraphQLInputObjectType):
+        if not isinstance(value_ast, ast.ObjectValue):
+            return [u'Expected "{}", found not an object.'.format(type)]
+
+        fields = type.fields
+        field_asts = value_ast.fields
+
+        errors = []
+        for provided_field_ast in field_asts:
+            if provided_field_ast.name.value not in fields:
+                errors.append(u'In field "{}": Unknown field.'.format(provided_field_ast.name.value))
+
+        field_ast_map = {field_ast.name.value: field_ast for field_ast in field_asts}
+
+        def get_field_ast_value(field_name):
+            if field_name in field_ast_map:
+                return field_ast_map[field_name].value
+
+        for field_name, field in fields.items():
+            subfield_errors = is_valid_literal_value(field.type, get_field_ast_value(field_name))
+            errors.extend(u'In field "{}": {}'.format(field_name, e) for e in subfield_errors)
+
+        return errors
+
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), 'Must be input type'
+
+    parse_result = type.parse_literal(value_ast)
+    if parse_result is None:
+        return [u'Expected type "{}", found {}.'.format(type.name, print_ast(value_ast))]
+
+    return _empty_list

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

@@ -0,0 +1,66 @@
+"""
+    Implementation of isValidJSValue from graphql.s
+"""
+
+from collections.abc import Iterable, Mapping
+import json
+
+from ..type import (GraphQLEnumType, GraphQLInputObjectType, GraphQLList,
+                    GraphQLNonNull, GraphQLScalarType)
+
+_empty_list = []
+
+
+def is_valid_value(value, type):
+    """Given a type and any value, return True if that value is valid."""
+    if isinstance(type, GraphQLNonNull):
+        of_type = type.of_type
+        if value is None:
+            return [u'Expected "{}", found null.'.format(type)]
+
+        return is_valid_value(value, of_type)
+
+    if value is None:
+        return _empty_list
+
+    if isinstance(type, GraphQLList):
+        item_type = type.of_type
+        if not isinstance(value, str) and isinstance(value, Iterable):
+            errors = []
+            for i, item in enumerate(value):
+                item_errors = is_valid_value(item, item_type)
+                for error in item_errors:
+                    errors.append(u'In element #{}: {}'.format(i, error))
+
+            return errors
+
+        else:
+            return is_valid_value(value, item_type)
+
+    if isinstance(type, GraphQLInputObjectType):
+        if not isinstance(value, Mapping):
+            return [u'Expected "{}", found not an object.'.format(type)]
+
+        fields = type.fields
+        errors = []
+
+        for provided_field in sorted(value.keys()):
+            if provided_field not in fields:
+                errors.append(u'In field "{}": Unknown field.'.format(provided_field))
+
+        for field_name, field in fields.items():
+            subfield_errors = is_valid_value(value.get(field_name), field.type)
+            errors.extend(u'In field "{}": {}'.format(field_name, e) for e in subfield_errors)
+
+        return errors
+
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
+        'Must be input type'
+
+    # Scalar/Enum input checks to ensure the type can parse the value to
+    # a non-null value.
+    parse_result = type.parse_value(value)
+    if parse_result is None:
+        return [u'Expected type "{}", found {}.'.format(type, json.dumps(value))]
+
+    return _empty_list

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

@@ -0,0 +1,21 @@
+import functools
+
+MAX_LENGTH = 5
+
+
+def quoted_or_list(items):
+    '''Given [ A, B, C ] return '"A", "B" or "C"'.'''
+    selected = items[:MAX_LENGTH]
+    quoted_items = ('"{}"'.format(t) for t in selected)
+
+    def quoted_or_text(text, quoted_and_index):
+        index = quoted_and_index[0]
+        quoted_item = quoted_and_index[1]
+        text += ((', ' if len(selected) > 2 and not index == len(selected) - 1 else ' ') +
+                 ('or ' if index == len(selected) - 1 else '') +
+                 quoted_item)
+        return text
+
+    enumerated_items = enumerate(quoted_items)
+    first_item = next(enumerated_items)[1]
+    return functools.reduce(quoted_or_text, enumerated_items, first_item)