wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/graphql-core-1.1/wandb_graphql/type/schema.py

@@ -0,0 +1,100 @@
+from collections.abc import Iterable
+
+from .definition import GraphQLObjectType
+from .directives import GraphQLDirective, specified_directives
+from .introspection import IntrospectionSchema
+from .typemap import GraphQLTypeMap
+
+
+class GraphQLSchema(object):
+    """Schema Definition
+
+    A Schema is created by supplying the root types of each type of operation, query and mutation (optional).
+    A schema definition is then supplied to the validator and executor.
+
+    Example:
+
+        MyAppSchema = GraphQLSchema(
+            query=MyAppQueryRootType,
+            mutation=MyAppMutationRootType,
+        )
+
+    Note: If an array of `directives` are provided to GraphQLSchema, that will be
+    the exact list of directives represented and allowed. If `directives` is not
+    provided then a default set of the specified directives (e.g. @include and
+    @skip) will be used. If you wish to provide *additional* directives to these
+    specified directives, you must explicitly declare them. Example:
+
+      MyAppSchema = GraphQLSchema(
+          ...
+          directives=specified_directives.extend([MyCustomerDirective]),
+      )
+    """
+    __slots__ = '_query', '_mutation', '_subscription', '_type_map', '_directives', '_implementations', '_possible_type_map'
+
+    def __init__(self, query, mutation=None, subscription=None, directives=None, types=None):
+        assert isinstance(query, GraphQLObjectType), 'Schema query must be Object Type but got: {}.'.format(query)
+        if mutation:
+            assert isinstance(mutation, GraphQLObjectType), \
+                'Schema mutation must be Object Type but got: {}.'.format(mutation)
+
+        if subscription:
+            assert isinstance(subscription, GraphQLObjectType), \
+                'Schema subscription must be Object Type but got: {}.'.format(subscription)
+
+        if types:
+            assert isinstance(types, Iterable), \
+                'Schema types must be iterable if provided but got: {}.'.format(types)
+
+        self._query = query
+        self._mutation = mutation
+        self._subscription = subscription
+        if directives is None:
+            directives = specified_directives
+
+        assert all(isinstance(d, GraphQLDirective) for d in directives), \
+            'Schema directives must be List[GraphQLDirective] if provided but got: {}.'.format(
+                directives
+        )
+        self._directives = directives
+
+        initial_types = [
+            query,
+            mutation,
+            subscription,
+            IntrospectionSchema
+        ]
+        if types:
+            initial_types += types
+        self._type_map = GraphQLTypeMap(initial_types)
+
+    def get_query_type(self):
+        return self._query
+
+    def get_mutation_type(self):
+        return self._mutation
+
+    def get_subscription_type(self):
+        return self._subscription
+
+    def get_type_map(self):
+        return self._type_map
+
+    def get_type(self, name):
+        return self._type_map.get(name)
+
+    def get_directives(self):
+        return self._directives
+
+    def get_directive(self, name):
+        for directive in self.get_directives():
+            if directive.name == name:
+                return directive
+
+        return None
+
+    def get_possible_types(self, abstract_type):
+        return self._type_map.get_possible_types(abstract_type)
+
+    def is_possible_type(self, abstract_type, possible_type):
+        return self._type_map.is_possible_type(abstract_type, possible_type)

wandb/vendor/graphql-core-1.1/wandb_graphql/type/typemap.py

@@ -0,0 +1,145 @@
+from collections import OrderedDict, defaultdict
+from collections.abc import Sequence
+from functools import reduce
+
+from ..utils.type_comparators import is_equal_type, is_type_sub_type_of
+from .definition import (GraphQLArgument, GraphQLField,
+                         GraphQLInputObjectField, GraphQLInputObjectType,
+                         GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                         GraphQLObjectType, GraphQLUnionType, is_input_type,
+                         is_output_type)
+
+
+class GraphQLTypeMap(OrderedDict):
+
+    def __init__(self, types):
+        super(GraphQLTypeMap, self).__init__()
+        self.update(reduce(self.reducer, types, OrderedDict()))
+        self._possible_type_map = defaultdict(set)
+
+        # Keep track of all implementations by interface name.
+        self._implementations = {}
+        for gql_type in self.values():
+            if isinstance(gql_type, GraphQLObjectType):
+                for interface in gql_type.interfaces:
+                    self._implementations.setdefault(interface.name, []).append(gql_type)
+
+        # Enforce correct interface implementations.
+        for type in self.values():
+            if isinstance(type, GraphQLObjectType):
+                for interface in type.interfaces:
+                    self.assert_object_implements_interface(self, type, interface)
+
+    def get_possible_types(self, abstract_type):
+        if isinstance(abstract_type, GraphQLUnionType):
+            return abstract_type.types
+        assert isinstance(abstract_type, GraphQLInterfaceType)
+        return self._implementations.get(abstract_type.name, None)
+
+    def is_possible_type(self, abstract_type, possible_type):
+        possible_types = self.get_possible_types(abstract_type)
+        assert isinstance(possible_types, Sequence), (
+            'Could not find possible implementing types for ${} in ' +
+            'schema. Check that schema.types is defined and is an array of' +
+            'all possible types in the schema.'
+            ).format(abstract_type)
+
+        if not self._possible_type_map[abstract_type.name]:
+            self._possible_type_map[abstract_type.name].update([p.name for p in possible_types])
+
+        return possible_type.name in self._possible_type_map[abstract_type.name]
+
+    @classmethod
+    def reducer(cls, map, type):
+        if not type:
+            return map
+
+        if isinstance(type, GraphQLList) or isinstance(type, GraphQLNonNull):
+            return cls.reducer(map, type.of_type)
+
+        if type.name in map:
+            assert map[type.name] == type, (
+                'Schema must contain unique named types but contains multiple types named "{}".'
+            ).format(type.name)
+
+            return map
+
+        map[type.name] = type
+
+        reduced_map = map
+
+        if isinstance(type, (GraphQLUnionType)):
+            for t in type.types:
+                reduced_map = cls.reducer(reduced_map, t)
+
+        if isinstance(type, GraphQLObjectType):
+            for t in type.interfaces:
+                reduced_map = cls.reducer(reduced_map, t)
+
+        if isinstance(type, (GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType)):
+            field_map = type.fields
+            type_is_input = isinstance(type, GraphQLInputObjectType)
+            for field_name, field in field_map.items():
+                if type_is_input:
+                    assert isinstance(field, GraphQLInputObjectField), (
+                        '{}.{} must be an instance of GraphQLInputObjectField.'.format(type, field_name)
+                    )
+                    assert is_input_type(field.type), (
+                        '{}.{} field type must be Input Type but got: {}.'.format(type, field_name, field.type)
+                    )
+                else:
+                    assert isinstance(field, (GraphQLField, GraphQLField)), (
+                        '{}.{} must be an instance of GraphQLField.'.format(type, field_name)
+                    )
+                    assert is_output_type(field.type), (
+                        '{}.{} field type must be Output Type but got: {}.'.format(type, field_name, field.type)
+                    )
+                    for arg_name, arg in field.args.items():
+                        assert isinstance(arg, (GraphQLArgument, GraphQLArgument)), (
+                            '{}.{}({}:) argument must be an instance of GraphQLArgument.'.format(type, field_name, arg_name)
+                        )
+                        assert is_input_type(arg.type), (
+                            '{}.{}({}:) argument type must be Input Type but got: {}.'.format(type, field_name, arg_name,
+                                                                                              arg.type)
+                        )
+                        reduced_map = cls.reducer(reduced_map, arg.type)
+
+                reduced_map = cls.reducer(reduced_map, getattr(field, 'type', None))
+
+        return reduced_map
+
+    @classmethod
+    def assert_object_implements_interface(cls, schema, object, interface):
+        object_field_map = object.fields
+        interface_field_map = interface.fields
+
+        for field_name, interface_field in interface_field_map.items():
+            object_field = object_field_map.get(field_name)
+
+            assert object_field, '"{}" expects field "{}" but "{}" does not provide it.'.format(
+                interface, field_name, object
+            )
+
+            assert is_type_sub_type_of(schema, object_field.type, interface_field.type), (
+                '{}.{} expects type "{}" but {}.{} provides type "{}".'
+            ).format(interface, field_name, interface_field.type, object, field_name, object_field.type)
+
+            for arg_name, interface_arg in interface_field.args.items():
+                object_arg = object_field.args.get(arg_name)
+
+                assert object_arg, (
+                    '{}.{} expects argument "{}" but {}.{} does not provide it.'
+                ).format(interface, field_name, arg_name, object, field_name)
+
+                assert is_equal_type(interface_arg.type, object_arg.type), (
+                    '{}.{}({}:) expects type "{}" but {}.{}({}:) provides type "{}".'
+                ).format(interface, field_name, arg_name, interface_arg.type, object, field_name, arg_name, object_arg.type)
+
+            for arg_name, object_arg in object_field.args.items():
+                interface_arg = interface_field.args.get(arg_name)
+                if not interface_arg:
+                    assert not isinstance(object_arg.type, GraphQLNonNull), (
+                        '{}.{}({}:) is of required type '
+                        '"{}" but is not also provided by the '
+                        'interface {}.{}.'
+                    ).format(object, field_name, arg_name, object_arg.type, interface, field_name)

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

@@ -0,0 +1,9 @@
+import re
+
+NAME_PATTERN = r'^[_a-zA-Z][_a-zA-Z0-9]*$'
+COMPILED_NAME_PATTERN = re.compile(NAME_PATTERN)
+
+
+def assert_valid_name(name):
+    '''Helper to assert that provided names are valid.'''
+    assert COMPILED_NAME_PATTERN.match(name), 'Names must match /{}/ but "{}" does not.'.format(NAME_PATTERN, name)

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

@@ -0,0 +1,65 @@
+import json
+import re
+import sys
+
+from ..language import ast
+from ..type.definition import (GraphQLEnumType, GraphQLInputObjectType,
+                               GraphQLList, GraphQLNonNull)
+from ..type.scalars import GraphQLFloat
+
+
+def ast_from_value(value, type=None):
+    if isinstance(type, GraphQLNonNull):
+        return ast_from_value(value, type.of_type)
+
+    if value is None:
+        return None
+
+    if isinstance(value, list):
+        item_type = type.of_type if isinstance(type, GraphQLList) else None
+        return ast.ListValue([ast_from_value(item, item_type) for item in value])
+
+    elif isinstance(type, GraphQLList):
+        return ast_from_value(value, type.of_type)
+
+    if isinstance(value, bool):
+        return ast.BooleanValue(value)
+
+    if isinstance(value, (int, float)):
+        string_num = str(value)
+        int_value = int(value)
+        is_int_value = string_num.isdigit()
+
+        if is_int_value or (int_value == value and value < sys.maxsize):
+            if type == GraphQLFloat:
+                return ast.FloatValue(str(float(value)))
+
+            return ast.IntValue(str(int(value)))
+
+        return ast.FloatValue(string_num)
+
+    if isinstance(value, str):
+        if isinstance(type, GraphQLEnumType) and re.match(r'^[_a-zA-Z][_a-zA-Z0-9]*$', value):
+            return ast.EnumValue(value)
+
+        return ast.StringValue(json.dumps(value)[1:-1])
+
+    assert isinstance(value, dict)
+
+    fields = []
+    is_graph_ql_input_object_type = isinstance(type, GraphQLInputObjectType)
+
+    for field_name, field_value in value.items():
+        field_type = None
+        if is_graph_ql_input_object_type:
+            field_def = type.fields.get(field_name)
+            field_type = field_def and field_def.type
+
+        field_value = ast_from_value(field_value, field_type)
+        if field_value:
+            fields.append(ast.ObjectField(
+                ast.Name(field_name),
+                field_value
+            ))
+
+    return ast.ObjectValue(fields)

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

@@ -0,0 +1,49 @@
+from ..language.ast import Node
+from ..language.parser import Loc
+
+
+def ast_to_code(ast, indent=0):
+    """
+    Converts an ast into a python code representation of the AST.
+    """
+    code = []
+
+    def append(line):
+        code.append(('    ' * indent) + line)
+
+    if isinstance(ast, Node):
+        append('ast.{}('.format(ast.__class__.__name__))
+        indent += 1
+        for i, k in enumerate(ast._fields, 1):
+            v = getattr(ast, k)
+            append('{}={},'.format(
+                k,
+                ast_to_code(v, indent),
+            ))
+        if ast.loc:
+            append('loc={}'.format(ast_to_code(ast.loc, indent)))
+
+        indent -= 1
+        append(')')
+
+    elif isinstance(ast, Loc):
+        append('loc({}, {})'.format(ast.start, ast.end))
+
+    elif isinstance(ast, list):
+        if ast:
+            append('[')
+            indent += 1
+
+            for i, it in enumerate(ast, 1):
+                is_last = i == len(ast)
+                append(ast_to_code(it, indent) + (',' if not is_last else ''))
+
+            indent -= 1
+            append(']')
+        else:
+            append('[]')
+
+    else:
+        append(repr(ast))
+
+    return '\n'.join(code).strip()

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

@@ -0,0 +1,24 @@
+from ..language.ast import Node
+
+
+def ast_to_dict(node, include_loc=False):
+    if isinstance(node, Node):
+        d = {
+            'kind': node.__class__.__name__
+        }
+        if hasattr(node, '_fields'):
+            for field in node._fields:
+                d[field] = ast_to_dict(getattr(node, field), include_loc)
+
+        if include_loc and hasattr(node, 'loc') and node.loc:
+            d['loc'] = {
+                'start': node.loc.start,
+                'end': node.loc.end
+            }
+
+        return d
+
+    elif isinstance(node, list):
+        return [ast_to_dict(item, include_loc) for item in node]
+
+    return node

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

@@ -0,0 +1,75 @@
+"""
+    Base GraphQL utilities
+    isort:skip_file
+"""
+
+# The GraphQL query recommended for a full schema introspection.
+from .introspection_query import introspection_query
+
+# Gets the target Operation from a Document
+from .get_operation_ast import get_operation_ast
+
+# Build a GraphQLSchema from an introspection result.
+from .build_client_schema import build_client_schema
+
+# Build a GraphQLSchema from a parsed GraphQL Schema language AST.
+from .build_ast_schema import build_ast_schema
+
+# Extends an existing GraphQLSchema from a parsed GraphQL Schema language AST.
+from .extend_schema import extend_schema
+
+# Print a GraphQLSchema to GraphQL Schema language.
+from .schema_printer import print_schema, print_introspection_schema
+
+# Create a GraphQLType from a GraphQL language AST.
+from .type_from_ast import type_from_ast
+
+# Create a JavaScript value from a GraphQL language AST.
+from .value_from_ast import value_from_ast
+
+# Create a GraphQL language AST from a JavaScript value.
+from .ast_from_value import ast_from_value
+
+# A helper to use within recursive-descent visitors which need to be aware of
+# the GraphQL type system.
+from .type_info import TypeInfo
+
+# Determine if JavaScript values adhere to a GraphQL type.
+from .is_valid_value import is_valid_value
+
+# Determine if AST values adhere to a GraphQL type.
+from .is_valid_literal_value import is_valid_literal_value
+
+# Concatenates multiple AST together.
+from .concat_ast import concat_ast
+
+# Comparators for types
+from .type_comparators import (
+    is_equal_type,
+    is_type_sub_type_of,
+    do_types_overlap
+)
+
+# Asserts that a string is a valid GraphQL name
+from .assert_valid_name import assert_valid_name
+
+__all__ = [
+    'introspection_query',
+    'get_operation_ast',
+    'build_client_schema',
+    'build_ast_schema',
+    'extend_schema',
+    'print_introspection_schema',
+    'print_schema',
+    'type_from_ast',
+    'value_from_ast',
+    'ast_from_value',
+    'TypeInfo',
+    'is_valid_value',
+    'is_valid_literal_value',
+    'concat_ast',
+    'do_types_overlap',
+    'is_equal_type',
+    'is_type_sub_type_of',
+    'assert_valid_name',
+]