wandb 0.19.1rc1__py3-none-musllinux_1_2_aarch64.whl

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

@@ -0,0 +1,291 @@
+from ..execution.values import get_argument_values
+from ..language import ast
+from ..pyutils.ordereddict import OrderedDict
+from ..type import (GraphQLArgument, GraphQLBoolean,
+                    GraphQLDeprecatedDirective, GraphQLDirective,
+                    GraphQLEnumType, GraphQLEnumValue, GraphQLField,
+                    GraphQLFloat, GraphQLID, GraphQLIncludeDirective,
+                    GraphQLInputObjectField, GraphQLInputObjectType,
+                    GraphQLInt, GraphQLInterfaceType, GraphQLList,
+                    GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                    GraphQLSchema, GraphQLSkipDirective, GraphQLString,
+                    GraphQLUnionType)
+from ..type.introspection import (__Directive, __DirectiveLocation,
+                                  __EnumValue, __Field, __InputValue, __Schema,
+                                  __Type, __TypeKind)
+from ..utils.value_from_ast import value_from_ast
+
+
+def _build_wrapped_type(inner_type, input_type_ast):
+    if isinstance(input_type_ast, ast.ListType):
+        return GraphQLList(_build_wrapped_type(inner_type, input_type_ast.type))
+
+    if isinstance(input_type_ast, ast.NonNullType):
+        return GraphQLNonNull(_build_wrapped_type(inner_type, input_type_ast.type))
+
+    return inner_type
+
+
+def _get_inner_type_name(type_ast):
+    if isinstance(type_ast, (ast.ListType, ast.NonNullType)):
+        return _get_inner_type_name(type_ast.type)
+
+    return type_ast.name.value
+
+
+def _get_named_type_ast(type_ast):
+    named_type = type_ast
+    while isinstance(named_type, (ast.ListType, ast.NonNullType)):
+        named_type = named_type.type
+
+    return named_type
+
+
+def _false(*_):
+    return False
+
+
+def _none(*_):
+    return None
+
+
+def build_ast_schema(document):
+    assert isinstance(document, ast.Document), 'must pass in Document ast.'
+
+    schema_def = None
+
+    type_asts = (
+        ast.ScalarTypeDefinition,
+        ast.ObjectTypeDefinition,
+        ast.InterfaceTypeDefinition,
+        ast.EnumTypeDefinition,
+        ast.UnionTypeDefinition,
+        ast.InputObjectTypeDefinition,
+    )
+
+    type_defs = []
+    directive_defs = []
+
+    for d in document.definitions:
+        if isinstance(d, ast.SchemaDefinition):
+            if schema_def:
+                raise Exception('Must provide only one schema definition.')
+            schema_def = d
+        if isinstance(d, type_asts):
+            type_defs.append(d)
+        elif isinstance(d, ast.DirectiveDefinition):
+            directive_defs.append(d)
+
+    if not schema_def:
+        raise Exception('Must provide a schema definition.')
+
+    query_type_name = None
+    mutation_type_name = None
+    subscription_type_name = None
+
+    for operation_type in schema_def.operation_types:
+        type_name = operation_type.type.name.value
+        if operation_type.operation == 'query':
+            if query_type_name:
+                raise Exception('Must provide only one query type in schema.')
+            query_type_name = type_name
+        elif operation_type.operation == 'mutation':
+            if mutation_type_name:
+                raise Exception('Must provide only one mutation type in schema.')
+            mutation_type_name = type_name
+        elif operation_type.operation == 'subscription':
+            if subscription_type_name:
+                raise Exception('Must provide only one subscription type in schema.')
+            subscription_type_name = type_name
+
+    if not query_type_name:
+        raise Exception('Must provide schema definition with query type.')
+
+    ast_map = {d.name.value: d for d in type_defs}
+
+    if query_type_name not in ast_map:
+        raise Exception('Specified query type "{}" not found in document.'.format(query_type_name))
+
+    if mutation_type_name and mutation_type_name not in ast_map:
+        raise Exception('Specified mutation type "{}" not found in document.'.format(mutation_type_name))
+
+    if subscription_type_name and subscription_type_name not in ast_map:
+        raise Exception('Specified subscription type "{}" not found in document.'.format(subscription_type_name))
+
+    inner_type_map = OrderedDict([
+        ('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),
+    ])
+
+    def get_directive(directive_ast):
+        return GraphQLDirective(
+            name=directive_ast.name.value,
+            locations=[node.value for node in directive_ast.locations],
+            args=make_input_values(directive_ast.arguments, GraphQLArgument),
+        )
+
+    def get_object_type(type_ast):
+        type = type_def_named(type_ast.name.value)
+        assert isinstance(type, GraphQLObjectType), 'AST must provide object type'
+        return type
+
+    def produce_type_def(type_ast):
+        type_name = _get_named_type_ast(type_ast).name.value
+        type_def = type_def_named(type_name)
+        return _build_wrapped_type(type_def, type_ast)
+
+    def type_def_named(type_name):
+        if type_name in inner_type_map:
+            return inner_type_map[type_name]
+
+        if type_name not in ast_map:
+            raise Exception('Type "{}" not found in document'.format(type_name))
+
+        inner_type_def = make_schema_def(ast_map[type_name])
+        if not inner_type_def:
+            raise Exception('Nothing constructed for "{}".'.format(type_name))
+
+        inner_type_map[type_name] = inner_type_def
+        return inner_type_def
+
+    def make_schema_def(definition):
+        if not definition:
+            raise Exception('def must be defined.')
+
+        handler = _schema_def_handlers.get(type(definition))
+        if not handler:
+            raise Exception('Type kind "{}" not supported.'.format(type(definition).__name__))
+
+        return handler(definition)
+
+    def make_type_def(definition):
+        return GraphQLObjectType(
+            name=definition.name.value,
+            fields=lambda: make_field_def_map(definition),
+            interfaces=make_implemented_interfaces(definition)
+        )
+
+    def make_field_def_map(definition):
+        return OrderedDict(
+            (f.name.value, GraphQLField(
+                type=produce_type_def(f.type),
+                args=make_input_values(f.arguments, GraphQLArgument),
+                deprecation_reason=get_deprecation_reason(f.directives),
+            ))
+            for f in definition.fields
+        )
+
+    def make_implemented_interfaces(definition):
+        return [produce_type_def(i) for i in definition.interfaces]
+
+    def make_input_values(values, cls):
+        return OrderedDict(
+            (value.name.value, cls(
+                type=produce_type_def(value.type),
+                default_value=value_from_ast(value.default_value, produce_type_def(value.type))
+            ))
+            for value in values
+        )
+
+    def make_interface_def(definition):
+        return GraphQLInterfaceType(
+            name=definition.name.value,
+            resolve_type=_none,
+            fields=lambda: make_field_def_map(definition)
+        )
+
+    def make_enum_def(definition):
+        values = OrderedDict((v.name.value, GraphQLEnumValue(deprecation_reason=get_deprecation_reason(v.directives)))
+                             for v in definition.values)
+        return GraphQLEnumType(
+            name=definition.name.value,
+            values=values
+        )
+
+    def make_union_def(definition):
+        return GraphQLUnionType(
+            name=definition.name.value,
+            resolve_type=_none,
+            types=[produce_type_def(t) for t in definition.types]
+        )
+
+    def make_scalar_def(definition):
+        return GraphQLScalarType(
+            name=definition.name.value,
+            serialize=_none,
+            # Validation calls the parse functions to determine if a literal value is correct.
+            # Returning none, however would cause the scalar to fail validation. Returning false,
+            # will cause them to pass.
+            parse_literal=_false,
+            parse_value=_false
+        )
+
+    def make_input_object_def(definition):
+        return GraphQLInputObjectType(
+            name=definition.name.value,
+            fields=make_input_values(definition.fields, GraphQLInputObjectField)
+        )
+
+    _schema_def_handlers = {
+        ast.ObjectTypeDefinition: make_type_def,
+        ast.InterfaceTypeDefinition: make_interface_def,
+        ast.EnumTypeDefinition: make_enum_def,
+        ast.UnionTypeDefinition: make_union_def,
+        ast.ScalarTypeDefinition: make_scalar_def,
+        ast.InputObjectTypeDefinition: make_input_object_def
+    }
+    types = [type_def_named(definition.name.value) for definition in type_defs]
+    directives = [get_directive(d) for d in directive_defs]
+
+    # If specified directive were not explicitly declared, add them.
+    find_skip_directive = (directive.name for directive in directives if directive.name == 'skip')
+    find_include_directive = (directive.name for directive in directives if directive.name == 'include')
+    find_deprecated_directive = (directive.name for directive in directives if directive.name == 'deprecated')
+
+    if not next(find_skip_directive, None):
+        directives.append(GraphQLSkipDirective)
+
+    if not next(find_include_directive, None):
+        directives.append(GraphQLIncludeDirective)
+
+    if not next(find_deprecated_directive, None):
+        directives.append(GraphQLDeprecatedDirective)
+
+    schema_kwargs = {'query': get_object_type(ast_map[query_type_name])}
+
+    if mutation_type_name:
+        schema_kwargs['mutation'] = get_object_type(ast_map[mutation_type_name])
+
+    if subscription_type_name:
+        schema_kwargs['subscription'] = get_object_type(ast_map[subscription_type_name])
+
+    if directive_defs:
+        schema_kwargs['directives'] = directives
+
+    if types:
+        schema_kwargs['types'] = types
+
+    return GraphQLSchema(**schema_kwargs)
+
+
+def get_deprecation_reason(directives):
+    deprecated_ast = next((directive for directive in directives
+                          if directive.name.value == GraphQLDeprecatedDirective.name),
+                          None)
+
+    if deprecated_ast:
+        args = get_argument_values(GraphQLDeprecatedDirective.args, deprecated_ast.arguments)
+        return args['reason']
+    else:
+        return None

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

@@ -0,0 +1,250 @@
+from ..language.parser import parse_value
+from ..pyutils.ordereddict import OrderedDict
+from ..type import (GraphQLArgument, GraphQLBoolean, GraphQLEnumType,
+                    GraphQLEnumValue, GraphQLField, GraphQLFloat, GraphQLID,
+                    GraphQLInputObjectField, GraphQLInputObjectType,
+                    GraphQLInt, GraphQLInterfaceType, GraphQLList,
+                    GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                    GraphQLSchema, GraphQLString, GraphQLUnionType,
+                    is_input_type, is_output_type)
+from ..type.directives import DirectiveLocation, GraphQLDirective
+from ..type.introspection import (TypeKind, __Directive, __DirectiveLocation,
+                                  __EnumValue, __Field, __InputValue, __Schema,
+                                  __Type, __TypeKind)
+from .value_from_ast import value_from_ast
+
+
+def _false(*_):
+    return False
+
+
+def _none(*_):
+    return None
+
+
+def no_execution(*args):
+    raise Exception('Client Schema cannot be used for execution.')
+
+
+def build_client_schema(introspection):
+    schema_introspection = introspection['__schema']
+
+    type_introspection_map = {t['name']: t for t in schema_introspection['types']}
+
+    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,
+
+    }
+
+    def get_type(type_ref):
+        kind = type_ref.get('kind')
+
+        if kind == TypeKind.LIST:
+            item_ref = type_ref.get('ofType')
+
+            if not item_ref:
+                raise Exception('Decorated type deeper than introspection query.')
+
+            return GraphQLList(get_type(item_ref))
+
+        elif kind == TypeKind.NON_NULL:
+            nullable_ref = type_ref.get('ofType')
+            if not nullable_ref:
+                raise Exception('Decorated type deeper than introspection query.')
+
+            return GraphQLNonNull(get_type(nullable_ref))
+
+        return get_named_type(type_ref['name'])
+
+    def get_named_type(type_name):
+        if type_name in type_def_cache:
+            return type_def_cache[type_name]
+
+        type_introspection = type_introspection_map.get(type_name)
+        if not type_introspection:
+            raise Exception(
+                'Invalid or incomplete schema, unknown type: {}. Ensure that a full introspection query '
+                'is used in order to build a client schema.'.format(type_name)
+            )
+
+        type_def = type_def_cache[type_name] = build_type(type_introspection)
+        return type_def
+
+    def get_input_type(type_ref):
+        input_type = get_type(type_ref)
+        assert is_input_type(input_type), 'Introspection must provide input type for arguments.'
+        return input_type
+
+    def get_output_type(type_ref):
+        output_type = get_type(type_ref)
+        assert is_output_type(output_type), 'Introspection must provide output type for fields.'
+        return output_type
+
+    def get_object_type(type_ref):
+        object_type = get_type(type_ref)
+        assert isinstance(object_type, GraphQLObjectType), 'Introspection must provide object type for possibleTypes.'
+        return object_type
+
+    def get_interface_type(type_ref):
+        interface_type = get_type(type_ref)
+        assert isinstance(interface_type, GraphQLInterfaceType), \
+            'Introspection must provide interface type for interfaces.'
+        return interface_type
+
+    def build_type(type):
+        type_kind = type.get('kind')
+        handler = type_builders.get(type_kind)
+        if not handler:
+            raise Exception(
+                'Invalid or incomplete schema, unknown kind: {}. Ensure that a full introspection query '
+                'is used in order to build a client schema.'.format(type_kind)
+            )
+
+        return handler(type)
+
+    def build_scalar_def(scalar_introspection):
+        return GraphQLScalarType(
+            name=scalar_introspection['name'],
+            description=scalar_introspection.get('description'),
+            serialize=_none,
+            parse_value=_false,
+            parse_literal=_false
+        )
+
+    def build_object_def(object_introspection):
+        return GraphQLObjectType(
+            name=object_introspection['name'],
+            description=object_introspection.get('description'),
+            interfaces=[get_interface_type(i) for i in object_introspection.get('interfaces', [])],
+            fields=lambda: build_field_def_map(object_introspection)
+        )
+
+    def build_interface_def(interface_introspection):
+        return GraphQLInterfaceType(
+            name=interface_introspection['name'],
+            description=interface_introspection.get('description'),
+            fields=lambda: build_field_def_map(interface_introspection),
+            resolve_type=no_execution
+        )
+
+    def build_union_def(union_introspection):
+        return GraphQLUnionType(
+            name=union_introspection['name'],
+            description=union_introspection.get('description'),
+            types=[get_object_type(t) for t in union_introspection.get('possibleTypes', [])],
+            resolve_type=no_execution
+        )
+
+    def build_enum_def(enum_introspection):
+        return GraphQLEnumType(
+            name=enum_introspection['name'],
+            description=enum_introspection.get('description'),
+            values=OrderedDict([(value_introspection['name'],
+                                 GraphQLEnumValue(description=value_introspection.get('description'),
+                                                  deprecation_reason=value_introspection.get('deprecationReason')))
+                                for value_introspection in enum_introspection.get('enumValues', [])
+                                ])
+        )
+
+    def build_input_object_def(input_object_introspection):
+        return GraphQLInputObjectType(
+            name=input_object_introspection['name'],
+            description=input_object_introspection.get('description'),
+            fields=lambda: build_input_value_def_map(
+                input_object_introspection.get('inputFields'), GraphQLInputObjectField
+            )
+        )
+
+    type_builders = {
+        TypeKind.SCALAR: build_scalar_def,
+        TypeKind.OBJECT: build_object_def,
+        TypeKind.INTERFACE: build_interface_def,
+        TypeKind.UNION: build_union_def,
+        TypeKind.ENUM: build_enum_def,
+        TypeKind.INPUT_OBJECT: build_input_object_def
+    }
+
+    def build_field_def_map(type_introspection):
+        return OrderedDict([
+            (f['name'], GraphQLField(
+                type=get_output_type(f['type']),
+                description=f.get('description'),
+                resolver=no_execution,
+                deprecation_reason=f.get('deprecationReason'),
+                args=build_input_value_def_map(f.get('args'), GraphQLArgument)))
+            for f in type_introspection.get('fields', [])
+        ])
+
+    def build_default_value(f):
+        default_value = f.get('defaultValue')
+        if default_value is None:
+            return None
+
+        return value_from_ast(parse_value(default_value), get_input_type(f['type']))
+
+    def build_input_value_def_map(input_value_introspection, argument_type):
+        return OrderedDict([
+            (f['name'], build_input_value(f, argument_type)) for f in input_value_introspection
+        ])
+
+    def build_input_value(input_value_introspection, argument_type):
+        input_value = argument_type(
+            description=input_value_introspection['description'],
+            type=get_input_type(input_value_introspection['type']),
+            default_value=build_default_value(input_value_introspection)
+        )
+        return input_value
+
+    def build_directive(directive_introspection):
+        # Support deprecated `on****` fields for building `locations`, as this
+        # is used by GraphiQL which may need to support outdated servers.
+        locations = list(directive_introspection.get('locations', []))
+        if not locations:
+            locations = []
+            if directive_introspection.get('onField', False):
+                locations += list(DirectiveLocation.FIELD_LOCATIONS)
+            if directive_introspection.get('onOperation', False):
+                locations += list(DirectiveLocation.OPERATION_LOCATIONS)
+            if directive_introspection.get('onFragment', False):
+                locations += list(DirectiveLocation.FRAGMENT_LOCATIONS)
+
+        return GraphQLDirective(
+            name=directive_introspection['name'],
+            description=directive_introspection.get('description'),
+            # TODO: {} ?
+            args=build_input_value_def_map(directive_introspection.get('args', {}), GraphQLArgument),
+            locations=locations
+        )
+
+    # 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_named_type(type_introspection_name) for type_introspection_name in type_introspection_map.keys()]
+
+    query_type = get_object_type(schema_introspection['queryType'])
+    mutation_type = get_object_type(
+        schema_introspection['mutationType']) if schema_introspection.get('mutationType') else None
+    subscription_type = get_object_type(schema_introspection['subscriptionType']) if \
+        schema_introspection.get('subscriptionType') else None
+
+    directives = [build_directive(d) for d in schema_introspection['directives']] \
+        if schema_introspection['directives'] else []
+
+    return GraphQLSchema(
+        query=query_type,
+        mutation=mutation_type,
+        subscription=subscription_type,
+        directives=directives,
+        types=types
+    )

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

@@ -0,0 +1,9 @@
+import itertools
+
+from ..language.ast import Document
+
+
+def concat_ast(asts):
+    return Document(definitions=list(itertools.chain.from_iterable(
+        document.definitions for document in asts
+    )))