wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/graphql-core-1.1/wandb_graphql/language/printer.py

@@ -0,0 +1,193 @@
+import json
+
+from .visitor import Visitor, visit
+
+__all__ = ['print_ast']
+
+
+def print_ast(ast):
+    return visit(ast, PrintingVisitor())
+
+
+class PrintingVisitor(Visitor):
+    __slots__ = ()
+
+    def leave_Name(self, node, *args):
+        return node.value
+
+    def leave_Variable(self, node, *args):
+        return '$' + node.name
+
+    def leave_Document(self, node, *args):
+        return join(node.definitions, '\n\n') + '\n'
+
+    def leave_OperationDefinition(self, node, *args):
+        name = node.name
+        selection_set = node.selection_set
+        op = node.operation
+        var_defs = wrap('(', join(node.variable_definitions, ', '), ')')
+        directives = join(node.directives, ' ')
+
+        if not name and not directives and not var_defs and op == 'query':
+            return selection_set
+
+        return join([op, join([name, var_defs]), directives, selection_set], ' ')
+
+    def leave_VariableDefinition(self, node, *args):
+        return node.variable + ': ' + node.type + wrap(' = ', node.default_value)
+
+    def leave_SelectionSet(self, node, *args):
+        return block(node.selections)
+
+    def leave_Field(self, node, *args):
+        return join([
+            wrap('', node.alias, ': ') + node.name + wrap('(', join(node.arguments, ', '), ')'),
+            join(node.directives, ' '),
+            node.selection_set
+        ], ' ')
+
+    def leave_Argument(self, node, *args):
+        return node.name + ': ' + node.value
+
+    # Fragments
+
+    def leave_FragmentSpread(self, node, *args):
+        return '...' + node.name + wrap(' ', join(node.directives, ' '))
+
+    def leave_InlineFragment(self, node, *args):
+        return join([
+            '...',
+            wrap('on ', node.type_condition),
+            join(node.directives, ''),
+            node.selection_set
+        ], ' ')
+
+    def leave_FragmentDefinition(self, node, *args):
+        return ('fragment {} on {} '.format(node.name, node.type_condition) +
+                wrap('', join(node.directives, ' '), ' ') +
+                node.selection_set)
+
+    # Value
+
+    def leave_IntValue(self, node, *args):
+        return node.value
+
+    def leave_FloatValue(self, node, *args):
+        return node.value
+
+    def leave_StringValue(self, node, *args):
+        return json.dumps(node.value)
+
+    def leave_BooleanValue(self, node, *args):
+        return json.dumps(node.value)
+
+    def leave_EnumValue(self, node, *args):
+        return node.value
+
+    def leave_ListValue(self, node, *args):
+        return '[' + join(node.values, ', ') + ']'
+
+    def leave_ObjectValue(self, node, *args):
+        return '{' + join(node.fields, ', ') + '}'
+
+    def leave_ObjectField(self, node, *args):
+        return node.name + ': ' + node.value
+
+    # Directive
+
+    def leave_Directive(self, node, *args):
+        return '@' + node.name + wrap('(', join(node.arguments, ', '), ')')
+
+    # Type
+
+    def leave_NamedType(self, node, *args):
+        return node.name
+
+    def leave_ListType(self, node, *args):
+        return '[' + node.type + ']'
+
+    def leave_NonNullType(self, node, *args):
+        return node.type + '!'
+
+    # Type Definitions:
+
+    def leave_SchemaDefinition(self, node, *args):
+        return join([
+            'schema',
+            join(node.directives, ' '),
+            block(node.operation_types),
+            ], ' ')
+
+    def leave_OperationTypeDefinition(self, node, *args):
+        return '{}: {}'.format(node.operation, node.type)
+
+    def leave_ScalarTypeDefinition(self, node, *args):
+        return 'scalar ' + node.name + wrap(' ', join(node.directives, ' '))
+
+    def leave_ObjectTypeDefinition(self, node, *args):
+        return join([
+            'type',
+            node.name,
+            wrap('implements ', join(node.interfaces, ', ')),
+            join(node.directives, ' '),
+            block(node.fields)
+        ], ' ')
+
+    def leave_FieldDefinition(self, node, *args):
+        return (
+            node.name +
+            wrap('(', join(node.arguments, ', '), ')') +
+            ': ' +
+            node.type +
+            wrap(' ', join(node.directives, ' '))
+        )
+
+    def leave_InputValueDefinition(self, node, *args):
+        return node.name + ': ' + node.type + wrap(' = ', node.default_value) + wrap(' ', join(node.directives, ' '))
+
+    def leave_InterfaceTypeDefinition(self, node, *args):
+        return 'interface ' + node.name + wrap(' ', join(node.directives, ' ')) + ' ' + block(node.fields)
+
+    def leave_UnionTypeDefinition(self, node, *args):
+        return 'union ' + node.name + wrap(' ', join(node.directives, ' ')) + ' = ' + join(node.types, ' | ')
+
+    def leave_EnumTypeDefinition(self, node, *args):
+        return 'enum ' + node.name + wrap(' ', join(node.directives, ' ')) + ' ' + block(node.values)
+
+    def leave_EnumValueDefinition(self, node, *args):
+        return node.name + wrap(' ', join(node.directives, ' '))
+
+    def leave_InputObjectTypeDefinition(self, node, *args):
+        return 'input ' + node.name + wrap(' ', join(node.directives, ' ')) + ' ' + block(node.fields)
+
+    def leave_TypeExtensionDefinition(self, node, *args):
+        return 'extend ' + node.definition
+
+    def leave_DirectiveDefinition(self, node, *args):
+        return 'directive @{}{} on {}'.format(node.name, wrap(
+            '(', join(node.arguments, ', '), ')'), ' | '.join(node.locations))
+
+
+def join(maybe_list, separator=''):
+    if maybe_list:
+        return separator.join(filter(None, maybe_list))
+    return ''
+
+
+def block(_list):
+    '''Given a list, print each item on its own line, wrapped in an indented "{ }" block.'''
+    if _list:
+        return indent('{\n' + join(_list, '\n')) + '\n}'
+    return '{}'
+
+
+def wrap(start, maybe_str, end=''):
+    if maybe_str:
+        return start + maybe_str + end
+    return ''
+
+
+def indent(maybe_str):
+    if maybe_str:
+        return maybe_str.replace('\n', '\n  ')
+    return maybe_str

wandb/vendor/graphql-core-1.1/wandb_graphql/language/source.py

@@ -0,0 +1,18 @@
+__all__ = ['Source']
+
+
+class Source(object):
+    __slots__ = 'body', 'name'
+
+    def __init__(self, body, name='GraphQL'):
+        self.body = body
+        self.name = name
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, Source) and
+                self.body == other.body and
+                self.name == other.name
+            )
+        )

wandb/vendor/graphql-core-1.1/wandb_graphql/language/visitor.py

@@ -0,0 +1,222 @@
+from copy import copy
+
+from . import ast
+from .visitor_meta import QUERY_DOCUMENT_KEYS, VisitorMeta
+
+
+class Falsey(object):
+
+    def __nonzero__(self):
+        return False
+
+    def __bool__(self):
+        return False
+
+
+BREAK = object()
+REMOVE = Falsey()
+
+
+class Stack(object):
+    __slots__ = 'in_array', 'index', 'keys', 'edits', 'prev'
+
+    def __init__(self, in_array, index, keys, edits, prev):
+        self.in_array = in_array
+        self.index = index
+        self.keys = keys
+        self.edits = edits
+        self.prev = prev
+
+
+def visit(root, visitor, key_map=None):
+    visitor_keys = key_map or QUERY_DOCUMENT_KEYS
+
+    stack = None
+    in_array = isinstance(root, list)
+    keys = [root]
+    index = -1
+    edits = []
+    parent = None
+    path = []
+    ancestors = []
+    new_root = root
+    leave = visitor.leave
+    enter = visitor.enter
+    path_pop = path.pop
+    ancestors_pop = ancestors.pop
+    path_append = path.append
+    ancestors_append = ancestors.append
+
+    while True:
+        index += 1
+        is_leaving = index == len(keys)
+        is_edited = is_leaving and edits
+        if is_leaving:
+            key = path_pop() if ancestors else None
+            node = parent
+            parent = ancestors_pop() if ancestors else None
+
+            if is_edited:
+                if in_array:
+                    node = list(node)
+
+                else:
+                    node = copy(node)
+                edit_offset = 0
+                for edit_key, edit_value in edits:
+                    if in_array:
+                        edit_key -= edit_offset
+
+                    if in_array and edit_value is REMOVE:
+                        node.pop(edit_key)
+                        edit_offset += 1
+
+                    else:
+                        if isinstance(node, list):
+                            node[edit_key] = edit_value
+
+                        else:
+                            setattr(node, edit_key, edit_value)
+
+            index = stack.index
+            keys = stack.keys
+            edits = stack.edits
+            in_array = stack.in_array
+            stack = stack.prev
+
+        else:
+            if parent:
+                key = index if in_array else keys[index]
+                if isinstance(parent, list):
+                    node = parent[key]
+
+                else:
+                    node = getattr(parent, key, None)
+
+            else:
+                key = None
+                node = new_root
+
+            if node is REMOVE or node is None:
+                continue
+
+            if parent:
+                path_append(key)
+
+        result = None
+
+        if not isinstance(node, list):
+            assert isinstance(node, ast.Node), 'Invalid AST Node: ' + repr(node)
+
+            if is_leaving:
+                result = leave(node, key, parent, path, ancestors)
+
+            else:
+                result = enter(node, key, parent, path, ancestors)
+
+            if result is BREAK:
+                break
+
+            if result is False:
+                if not is_leaving:
+                    path_pop()
+                    continue
+
+            elif result is not None:
+                edits.append((key, result))
+                if not is_leaving:
+                    if isinstance(result, ast.Node):
+                        node = result
+
+                    else:
+                        path_pop()
+                        continue
+
+        if result is None and is_edited:
+            edits.append((key, node))
+
+        if not is_leaving:
+            stack = Stack(in_array, index, keys, edits, stack)
+            in_array = isinstance(node, list)
+            keys = node if in_array else visitor_keys.get(type(node), None) or []
+            index = -1
+            edits = []
+
+            if parent:
+                ancestors_append(parent)
+
+            parent = node
+
+        if not stack:
+            break
+
+    if edits:
+        new_root = edits[-1][1]
+
+    return new_root
+
+
+class Visitor(metaclass=VisitorMeta):
+    __slots__ = ()
+
+    def enter(self, node, key, parent, path, ancestors):
+        method = self._get_enter_handler(type(node))
+        if method:
+            return method(self, node, key, parent, path, ancestors)
+
+    def leave(self, node, key, parent, path, ancestors):
+        method = self._get_leave_handler(type(node))
+        if method:
+            return method(self, node, key, parent, path, ancestors)
+
+
+class ParallelVisitor(Visitor):
+    __slots__ = 'skipping', 'visitors'
+
+    def __init__(self, visitors):
+        self.visitors = visitors
+        self.skipping = [None] * len(visitors)
+
+    def enter(self, node, key, parent, path, ancestors):
+        for i, visitor in enumerate(self.visitors):
+            if not self.skipping[i]:
+                result = visitor.enter(node, key, parent, path, ancestors)
+                if result is False:
+                    self.skipping[i] = node
+                elif result is BREAK:
+                    self.skipping[i] = BREAK
+                elif result is not None:
+                    return result
+
+    def leave(self, node, key, parent, path, ancestors):
+        for i, visitor in enumerate(self.visitors):
+            if not self.skipping[i]:
+                result = visitor.leave(node, key, parent, path, ancestors)
+                if result is BREAK:
+                    self.skipping[i] = BREAK
+                elif result is not None and result is not False:
+                    return result
+            elif self.skipping[i] == node:
+                self.skipping[i] = REMOVE
+
+
+class TypeInfoVisitor(Visitor):
+    __slots__ = 'visitor', 'type_info'
+
+    def __init__(self, type_info, visitor):
+        self.type_info = type_info
+        self.visitor = visitor
+
+    def enter(self, node, key, parent, path, ancestors):
+        self.type_info.enter(node)
+        result = self.visitor.enter(node, key, parent, path, ancestors)
+        if result is not None:
+            self.type_info.leave(node)
+            if isinstance(result, ast.Node):
+                self.type_info.enter(result)
+        return result
+
+    def leave(self, node, key, parent, path, ancestors):
+        result = self.visitor.leave(node, key, parent, path, ancestors)
+        self.type_info.leave(node)
+        return result

wandb/vendor/graphql-core-1.1/wandb_graphql/language/visitor_meta.py

@@ -0,0 +1,82 @@
+from . import ast
+
+QUERY_DOCUMENT_KEYS = {
+    ast.Name: (),
+
+    ast.Document: ('definitions',),
+    ast.OperationDefinition: ('name', 'variable_definitions', 'directives', 'selection_set'),
+    ast.VariableDefinition: ('variable', 'type', 'default_value'),
+    ast.Variable: ('name',),
+    ast.SelectionSet: ('selections',),
+    ast.Field: ('alias', 'name', 'arguments', 'directives', 'selection_set'),
+    ast.Argument: ('name', 'value'),
+
+    ast.FragmentSpread: ('name', 'directives'),
+    ast.InlineFragment: ('type_condition', 'directives', 'selection_set'),
+    ast.FragmentDefinition: ('name', 'type_condition', 'directives', 'selection_set'),
+
+    ast.IntValue: (),
+    ast.FloatValue: (),
+    ast.StringValue: (),
+    ast.BooleanValue: (),
+    ast.EnumValue: (),
+    ast.ListValue: ('values',),
+    ast.ObjectValue: ('fields',),
+    ast.ObjectField: ('name', 'value'),
+
+    ast.Directive: ('name', 'arguments'),
+
+    ast.NamedType: ('name',),
+    ast.ListType: ('type',),
+    ast.NonNullType: ('type',),
+
+    ast.SchemaDefinition: ('directives', 'operation_types',),
+    ast.OperationTypeDefinition: ('type',),
+
+    ast.ScalarTypeDefinition: ('name', 'directives',),
+    ast.ObjectTypeDefinition: ('name', 'interfaces', 'directives', 'fields'),
+    ast.FieldDefinition: ('name', 'arguments', 'directives', 'type'),
+    ast.InputValueDefinition: ('name', 'type', 'directives', 'default_value'),
+    ast.InterfaceTypeDefinition: ('name', 'directives', 'fields'),
+    ast.UnionTypeDefinition: ('name', 'directives', 'types'),
+    ast.EnumTypeDefinition: ('name', 'directives', 'values'),
+    ast.EnumValueDefinition: ('name', 'directives',),
+    ast.InputObjectTypeDefinition: ('name', 'directives', 'fields'),
+
+    ast.TypeExtensionDefinition: ('definition',),
+
+    ast.DirectiveDefinition: ('name', 'arguments', 'locations'),
+}
+
+AST_KIND_TO_TYPE = {c.__name__: c for c in QUERY_DOCUMENT_KEYS.keys()}
+
+
+class VisitorMeta(type):
+
+    def __new__(cls, name, bases, attrs):
+        enter_handlers = {}
+        leave_handlers = {}
+
+        for base in bases:
+            if hasattr(base, '_enter_handlers'):
+                enter_handlers.update(base._enter_handlers)
+
+            if hasattr(base, '_leave_handlers'):
+                leave_handlers.update(base._leave_handlers)
+
+        for attr, val in attrs.items():
+            if attr.startswith('enter_'):
+                ast_kind = attr[6:]
+                ast_type = AST_KIND_TO_TYPE.get(ast_kind)
+                enter_handlers[ast_type] = val
+
+            elif attr.startswith('leave_'):
+                ast_kind = attr[6:]
+                ast_type = AST_KIND_TO_TYPE.get(ast_kind)
+                leave_handlers[ast_type] = val
+
+        attrs['_enter_handlers'] = enter_handlers
+        attrs['_leave_handlers'] = leave_handlers
+        attrs['_get_enter_handler'] = enter_handlers.get
+        attrs['_get_leave_handler'] = leave_handlers.get
+        return super(VisitorMeta, cls).__new__(cls, name, bases, attrs)

wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/cached_property.py

@@ -0,0 +1,17 @@
+class cached_property(object):
+    """ A property that is only computed once per instance and then replaces
+        itself with an ordinary attribute. Deleting the attribute resets the
+        property.
+
+        Source: https://github.com/bottlepy/bottle/commit/fa7733e075da0d790d809aa3d2f53071897e6f76
+        """
+
+    def __init__(self, func):
+        self.__doc__ = getattr(func, '__doc__')
+        self.func = func
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self
+        value = obj.__dict__[self.func.__name__] = self.func(obj)
+        return value

wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/contain_subset.py

@@ -0,0 +1,28 @@
+obj = (dict, list, tuple)
+
+
+def contain_subset(expected, actual):
+    t_actual = type(actual)
+    t_expected = type(expected)
+    actual_is_dict = issubclass(t_actual, dict)
+    expected_is_dict = issubclass(t_expected, dict)
+    both_dicts = actual_is_dict and expected_is_dict
+    if not(both_dicts) and not(issubclass(t_actual, t_expected) or issubclass(t_expected, t_actual)):
+        return False
+    if not isinstance(expected, obj) or expected is None:
+        return expected == actual
+    if expected and not actual:
+        return False
+    if isinstance(expected, list):
+        aa = actual[:]
+        return all([any([contain_subset(exp, act) for act in aa]) for exp in expected])
+    for key in expected.keys():
+        eo = expected[key]
+        ao = actual.get(key)
+        if isinstance(eo, obj) and eo is not None and ao is not None:
+            if not contain_subset(eo, ao):
+                return False
+            continue
+        if ao != eo:
+            return False
+    return True

wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/default_ordered_dict.py

@@ -0,0 +1,40 @@
+import copy
+from collections import OrderedDict
+
+
+class DefaultOrderedDict(OrderedDict):
+    __slots__ = 'default_factory',
+
+    # Source: http://stackoverflow.com/a/6190500/562769
+    def __init__(self, default_factory=None, *a, **kw):
+        if default_factory is not None and not callable(default_factory):
+            raise TypeError('first argument must be callable')
+
+        OrderedDict.__init__(self, *a, **kw)
+        self.default_factory = default_factory
+
+    def __missing__(self, key):
+        if self.default_factory is None:
+            raise KeyError(key)
+        self[key] = value = self.default_factory()
+        return value
+
+    def __reduce__(self):
+        if self.default_factory is None:
+            args = tuple()
+        else:
+            args = self.default_factory,
+        return type(self), args, None, None, iter(self.items())
+
+    def copy(self):
+        return self.__copy__()
+
+    def __copy__(self):
+        return type(self)(self.default_factory, self)
+
+    def __deepcopy__(self, memo):
+        return self.__class__(self.default_factory, copy.deepcopy(list(self.items())))
+
+    def __repr__(self):
+        return 'DefaultOrderedDict(%s, %s)' % (self.default_factory,
+                                               OrderedDict.__repr__(self)[19:-1])

wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/ordereddict.py

@@ -0,0 +1,8 @@
+try:
+    # Try to load the Cython performant OrderedDict (C)
+    # as is more performant than collections.OrderedDict (Python)
+    from cyordereddict import OrderedDict
+except ImportError:
+    from collections import OrderedDict
+
+__all__ = ['OrderedDict']

wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/pair_set.py

@@ -0,0 +1,43 @@
+class PairSet(object):
+    __slots__ = '_data',
+
+    def __init__(self):
+        self._data = {}
+
+    def __contains__(self, item):
+        return self.has(item[0], item[1], item[2])
+
+    def __str__(self):
+        return str(self._data)
+
+    def __repr__(self):
+        return str(self._data)
+
+    def has(self, a, b, are_mutually_exclusive):
+        first = self._data.get(a)
+        result = first and first.get(b)
+        if result is None:
+            return False
+
+        # are_mutually_exclusive being false is a superset of being true,
+        # hence if we want to know if this PairSet "has" these two with no
+        # exclusivity, we have to ensure it was added as such.
+        if not are_mutually_exclusive:
+            return not result
+
+        return True
+
+    def add(self, a, b, are_mutually_exclusive):
+        _pair_set_add(self._data, a, b, are_mutually_exclusive)
+        _pair_set_add(self._data, b, a, are_mutually_exclusive)
+        return self
+
+
+def _pair_set_add(data, a, b, are_mutually_exclusive):
+    sub_dict = data.get(a)
+
+    if not sub_dict:
+        sub_dict = {}
+        data[a] = sub_dict
+
+    sub_dict[b] = are_mutually_exclusive