wandb 0.19.1rc1__py3-none-musllinux_1_2_aarch64.whl

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/asyncio.py

@@ -0,0 +1,53 @@
+from __future__ import absolute_import
+
+from asyncio import Future, get_event_loop, iscoroutine, wait
+
+from wandb_promise import Promise
+
+try:
+    from asyncio import ensure_future
+except ImportError:
+    # ensure_future is only implemented in Python 3.4.4+
+    def ensure_future(coro_or_future, loop=None):
+        """Wrap a coroutine or an awaitable in a future.
+
+        If the argument is a Future, it is returned directly.
+        """
+        if isinstance(coro_or_future, Future):
+            if loop is not None and loop is not coro_or_future._loop:
+                raise ValueError('loop argument must agree with Future')
+            return coro_or_future
+        elif iscoroutine(coro_or_future):
+            if loop is None:
+                loop = get_event_loop()
+            task = loop.create_task(coro_or_future)
+            if task._source_traceback:
+                del task._source_traceback[-1]
+            return task
+        else:
+            raise TypeError('A Future, a coroutine or an awaitable is required')
+
+
+class AsyncioExecutor(object):
+
+    def __init__(self, loop=None):
+        if loop is None:
+            loop = get_event_loop()
+        self.loop = loop
+        self.futures = []
+
+    def wait_until_finished(self):
+        # if there are futures to wait for
+        while self.futures:
+            # wait for the futures to finish
+            futures = self.futures
+            self.futures = []
+            self.loop.run_until_complete(wait(futures))
+
+    def execute(self, fn, *args, **kwargs):
+        result = fn(*args, **kwargs)
+        if isinstance(result, Future) or iscoroutine(result):
+            future = ensure_future(result, loop=self.loop)
+            self.futures.append(future)
+            return Promise.resolve(future)
+        return result

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/gevent.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import
+
+import gevent
+from wandb_promise import Promise
+
+from .utils import process
+
+
+class GeventExecutor(object):
+
+    def __init__(self):
+        self.jobs = []
+
+    def wait_until_finished(self):
+        [j.join() for j in self.jobs]
+        # gevent.joinall(self.jobs)
+
+    def execute(self, fn, *args, **kwargs):
+        promise = Promise()
+        job = gevent.spawn(process, promise, fn, args, kwargs)
+        self.jobs.append(job)
+        return promise

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/process.py

@@ -0,0 +1,32 @@
+from multiprocessing import Process, Queue
+
+from wandb_promise import Promise
+
+from .utils import process
+
+
+def queue_process(q):
+    promise, fn, args, kwargs = q.get()
+    process(promise, fn, args, kwargs)
+
+
+class ProcessExecutor(object):
+
+    def __init__(self):
+        self.processes = []
+        self.q = Queue()
+
+    def wait_until_finished(self):
+        for _process in self.processes:
+            _process.join()
+        self.q.close()
+        self.q.join_thread()
+
+    def execute(self, fn, *args, **kwargs):
+        promise = Promise()
+
+        self.q.put([promise, fn, args, kwargs], False)
+        _process = Process(target=queue_process, args=(self.q))
+        _process.start()
+        self.processes.append(_process)
+        return promise

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/sync.py

@@ -0,0 +1,7 @@
+class SyncExecutor(object):
+
+    def wait_until_finished(self):
+        pass
+
+    def execute(self, fn, *args, **kwargs):
+        return fn(*args, **kwargs)

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/thread.py

@@ -0,0 +1,35 @@
+from multiprocessing.pool import ThreadPool
+from threading import Thread
+
+from wandb_promise import Promise
+
+from .utils import process
+
+
+class ThreadExecutor(object):
+
+    pool = None
+
+    def __init__(self, pool=False):
+        self.threads = []
+        if pool:
+            self.execute = self.execute_in_pool
+            self.pool = ThreadPool(processes=pool)
+        else:
+            self.execute = self.execute_in_thread
+
+    def wait_until_finished(self):
+        for thread in self.threads:
+            thread.join()
+
+    def execute_in_thread(self, fn, *args, **kwargs):
+        promise = Promise()
+        thread = Thread(target=process, args=(promise, fn, args, kwargs))
+        thread.start()
+        self.threads.append(thread)
+        return promise
+
+    def execute_in_pool(self, fn, *args, **kwargs):
+        promise = Promise()
+        self.pool.map(lambda input: process(*input), [(promise, fn, args, kwargs)])
+        return promise

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/utils.py

@@ -0,0 +1,6 @@
+def process(p, f, args, kwargs):
+    try:
+        val = f(*args, **kwargs)
+        p.do_resolve(val)
+    except Exception as e:
+        p.do_reject(e)

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/executor.py

@@ -0,0 +1,66 @@
+from wandb_promise import Promise
+
+from ...type import GraphQLSchema
+from ..base import ExecutionContext, ExecutionResult, get_operation_root_type
+from ..executors.sync import SyncExecutor
+from ..middleware import MiddlewareManager
+from .fragment import Fragment
+
+
+def execute(schema, document_ast, root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None,
+            return_promise=False, middleware=None):
+    assert schema, 'Must provide schema'
+    assert isinstance(schema, GraphQLSchema), (
+        'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
+        'not multiple versions of GraphQL installed in your node_modules directory.'
+    )
+    if middleware:
+        if not isinstance(middleware, MiddlewareManager):
+            middleware = MiddlewareManager(*middleware)
+        assert isinstance(middleware, MiddlewareManager), (
+            'middlewares have to be an instance'
+            ' of MiddlewareManager. Received "{}".'.format(middleware)
+        )
+
+    if executor is None:
+        executor = SyncExecutor()
+
+    context = ExecutionContext(
+        schema,
+        document_ast,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        executor,
+        middleware
+    )
+
+    def executor(resolve, reject):
+        return resolve(execute_operation(context, context.operation, root_value))
+
+    def on_rejected(error):
+        context.errors.append(error)
+        return None
+
+    def on_resolve(data):
+        if not context.errors:
+            return ExecutionResult(data=data)
+        return ExecutionResult(data=data, errors=context.errors)
+
+    promise = Promise(executor).catch(on_rejected).then(on_resolve)
+    if return_promise:
+        return promise
+    context.executor.wait_until_finished()
+    return promise.get()
+
+
+def execute_operation(exe_context, operation, root_value):
+    type = get_operation_root_type(exe_context.schema, operation)
+    execute_serially = operation.operation == 'mutation'
+
+    fragment = Fragment(type=type, field_asts=[operation], context=exe_context)
+    if execute_serially:
+        return fragment.resolve_serially(root_value)
+    return fragment.resolve(root_value)

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/fragment.py

@@ -0,0 +1,252 @@
+import functools
+
+from wandb_promise import Promise, is_thenable, promise_for_dict
+
+from ...pyutils.cached_property import cached_property
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
+from ...type import (GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+                     GraphQLObjectType, GraphQLUnionType)
+from ..base import ResolveInfo, Undefined, collect_fields, get_field_def
+from ..values import get_argument_values
+from ...error import GraphQLError
+try:
+    from itertools import izip as zip
+except:
+    pass
+
+
+def get_base_type(type):
+    if isinstance(type, (GraphQLList, GraphQLNonNull)):
+        return get_base_type(type.of_type)
+    return type
+
+
+def get_subfield_asts(context, return_type, field_asts):
+    subfield_asts = DefaultOrderedDict(list)
+    visited_fragment_names = set()
+    for field_ast in field_asts:
+        selection_set = field_ast.selection_set
+        if selection_set:
+            subfield_asts = collect_fields(
+                context, return_type, selection_set,
+                subfield_asts, visited_fragment_names
+            )
+    return subfield_asts
+
+
+def get_resolvers(context, type, field_asts):
+    from .resolver import field_resolver
+    subfield_asts = get_subfield_asts(context, type, field_asts)
+
+    for response_name, field_asts in subfield_asts.items():
+        field_ast = field_asts[0]
+        field_name = field_ast.name.value
+        field_def = get_field_def(context and context.schema, type, field_name)
+        if not field_def:
+            continue
+        field_base_type = get_base_type(field_def.type)
+        field_fragment = None
+        info = ResolveInfo(
+            field_name,
+            field_asts,
+            field_base_type,
+            parent_type=type,
+            schema=context and context.schema,
+            fragments=context and context.fragments,
+            root_value=context and context.root_value,
+            operation=context and context.operation,
+            variable_values=context and context.variable_values,
+        )
+        if isinstance(field_base_type, GraphQLObjectType):
+            field_fragment = Fragment(
+                type=field_base_type,
+                field_asts=field_asts,
+                info=info,
+                context=context
+            )
+        elif isinstance(field_base_type, (GraphQLInterfaceType, GraphQLUnionType)):
+            field_fragment = AbstractFragment(
+                abstract_type=field_base_type,
+                field_asts=field_asts,
+                info=info,
+                context=context
+            )
+        resolver = field_resolver(field_def, exe_context=context, info=info, fragment=field_fragment)
+        args = get_argument_values(
+            field_def.args,
+            field_ast.arguments,
+            context and context.variable_values
+        )
+        yield (response_name, Field(resolver, args, context and context.context_value, info))
+
+
+class Field(object):
+    __slots__ = ('fn', 'args', 'context', 'info')
+
+    def __init__(self, fn, args, context, info):
+        self.fn = fn
+        self.args = args
+        self.context = context
+        self.info = info
+
+    def execute(self, root):
+        return self.fn(root, self.args, self.context, self.info)
+
+
+class Fragment(object):
+
+    def __init__(self, type, field_asts, context=None, info=None):
+        self.type = type
+        self.field_asts = field_asts
+        self.context = context
+        self.info = info
+
+    @cached_property
+    def partial_resolvers(self):
+        return list(get_resolvers(
+            self.context,
+            self.type,
+            self.field_asts
+        ))
+
+    @cached_property
+    def fragment_container(self):
+        try:
+            fields = next(zip(*self.partial_resolvers))
+        except StopIteration:
+            fields = tuple()
+
+        class FragmentInstance(dict):
+            # def __init__(self):
+                # self.fields = fields
+            # _fields = ('c','b','a')
+            set = dict.__setitem__
+            # def set(self, name, value):
+            #     self[name] = value
+
+            def __iter__(self):
+                return iter(fields)
+
+        return FragmentInstance
+
+    def have_type(self, root):
+        return not self.type.is_type_of or self.type.is_type_of(root, self.context.context_value, self.info)
+
+    def resolve(self, root):
+        if root and not self.have_type(root):
+            raise GraphQLError(
+                u'Expected value of type "{}" but got: {}.'.format(self.type, type(root).__name__),
+                self.info.field_asts
+            )
+
+        contains_promise = False
+
+        final_results = self.fragment_container()
+        # return OrderedDict(
+        #     ((field_name, field_resolver(root, field_args, context, info))
+        #         for field_name, field_resolver, field_args, context, info in self.partial_resolvers)
+        # )
+        for response_name, field_resolver in self.partial_resolvers:
+
+            result = field_resolver.execute(root)
+            if result is Undefined:
+                continue
+
+            if not contains_promise and is_thenable(result):
+                contains_promise = True
+
+            final_results[response_name] = result
+
+        if not contains_promise:
+            return final_results
+
+        return promise_for_dict(final_results)
+        # return {
+        #     field_name: field_resolver(root, field_args, context, info)
+        #     for field_name, field_resolver, field_args, context, info in self.partial_resolvers
+        # }
+
+    def resolve_serially(self, root):
+        def execute_field_callback(results, resolver):
+            response_name, field_resolver = resolver
+
+            result = field_resolver.execute(root)
+
+            if result is Undefined:
+                return results
+
+            if is_thenable(result):
+                def collect_result(resolved_result):
+                    results[response_name] = resolved_result
+                    return results
+
+                return result.then(collect_result)
+
+            results[response_name] = result
+            return results
+
+        def execute_field(prev_promise, resolver):
+            return prev_promise.then(lambda results: execute_field_callback(results, resolver))
+
+        return functools.reduce(execute_field, self.partial_resolvers, Promise.resolve(self.fragment_container()))
+
+    def __eq__(self, other):
+        return isinstance(other, Fragment) and (
+            other.type == self.type and
+            other.field_asts == self.field_asts and
+            other.context == self.context and
+            other.info == self.info
+        )
+
+
+class AbstractFragment(object):
+
+    def __init__(self, abstract_type, field_asts, context=None, info=None):
+        self.abstract_type = abstract_type
+        self.field_asts = field_asts
+        self.context = context
+        self.info = info
+        self._fragments = {}
+
+    @cached_property
+    def possible_types(self):
+        return self.context.schema.get_possible_types(self.abstract_type)
+
+    @cached_property
+    def possible_types_with_is_type_of(self):
+        return [
+            (type, type.is_type_of) for type in self.possible_types if callable(type.is_type_of)
+        ]
+
+    def get_fragment(self, type):
+        if isinstance(type, str):
+            type = self.context.schema.get_type(type)
+
+        if type not in self._fragments:
+            assert type in self.possible_types, (
+                'Runtime Object type "{}" is not a possible type for "{}".'
+            ).format(type, self.abstract_type)
+            self._fragments[type] = Fragment(
+                type,
+                self.field_asts,
+                self.context,
+                self.info
+            )
+
+        return self._fragments[type]
+
+    def resolve_type(self, result):
+        return_type = self.abstract_type
+        context = self.context.context_value
+
+        if return_type.resolve_type:
+            return return_type.resolve_type(result, context, self.info)
+
+        for type, is_type_of in self.possible_types_with_is_type_of:
+            if is_type_of(result, context, self.info):
+                return type
+
+    def resolve(self, root):
+        _type = self.resolve_type(root)
+        fragment = self.get_fragment(_type)
+        return fragment.resolve(root)

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/resolver.py

@@ -0,0 +1,151 @@
+import sys
+from collections.abc import Iterable
+from functools import partial
+
+from wandb_promise import Promise, is_thenable
+
+from ...error import GraphQLError, GraphQLLocatedError
+from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
+                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                     GraphQLUnionType)
+from ..base import default_resolve_fn
+from ...execution import executor
+from .utils import imap, normal_map
+
+
+def on_complete_resolver(on_error, __func, exe_context, info, __resolver, *args, **kwargs):
+    try:
+        result = __resolver(*args, **kwargs)
+        if isinstance(result, Exception):
+            return on_error(result)
+        # return Promise.resolve(result).then(__func).catch(on_error)
+        if is_thenable(result):
+            # TODO: Remove this, if a promise is resolved with an Exception,
+            # it should raise by default. This is fixing an old behavior
+            # in the Promise package
+            def on_resolve(value):
+                if isinstance(value, Exception):
+                    return on_error(value)
+                return value
+            return result.then(on_resolve).then(__func).catch(on_error)
+        return __func(result)
+    except Exception as e:
+        return on_error(e)
+
+
+def complete_list_value(inner_resolver, exe_context, info, on_error, result):
+    if result is None:
+        return None
+
+    assert isinstance(result, Iterable), \
+        ('User Error: expected iterable, but did not find one ' +
+         'for field {}.{}.').format(info.parent_type, info.field_name)
+
+    completed_results = normal_map(inner_resolver, result)
+
+    if not any(imap(is_thenable, completed_results)):
+        return completed_results
+
+    return Promise.all(completed_results).catch(on_error)
+
+
+def complete_nonnull_value(exe_context, info, result):
+    if result is None:
+        raise GraphQLError(
+            'Cannot return null for non-nullable field {}.{}.'.format(info.parent_type, info.field_name),
+            info.field_asts
+        )
+    return result
+
+
+def complete_leaf_value(serialize, result):
+    if result is None:
+        return None
+    return serialize(result)
+
+
+def complete_object_value(fragment_resolve, exe_context, on_error, result):
+    if result is None:
+        return None
+
+    result = fragment_resolve(result)
+    if is_thenable(result):
+        return result.catch(on_error)
+    return result
+
+
+def field_resolver(field, fragment=None, exe_context=None, info=None):
+    # resolver = exe_context.get_field_resolver(field.resolver or default_resolve_fn)
+    resolver = field.resolver or default_resolve_fn
+    if exe_context:
+        # We decorate the resolver with the middleware
+        resolver = exe_context.get_field_resolver(resolver)
+    return type_resolver(field.type, resolver,
+                         fragment, exe_context, info, catch_error=True)
+
+
+def type_resolver(return_type, resolver, fragment=None, exe_context=None, info=None, catch_error=False):
+    if isinstance(return_type, GraphQLNonNull):
+        return type_resolver_non_null(return_type, resolver, fragment, exe_context, info)
+
+    if isinstance(return_type, (GraphQLScalarType, GraphQLEnumType)):
+        return type_resolver_leaf(return_type, resolver, exe_context, info, catch_error)
+
+    if isinstance(return_type, (GraphQLList)):
+        return type_resolver_list(return_type, resolver, fragment, exe_context, info, catch_error)
+
+    if isinstance(return_type, (GraphQLObjectType)):
+        assert fragment and fragment.type == return_type, 'Fragment and return_type dont match'
+        return type_resolver_fragment(return_type, resolver, fragment, exe_context, info, catch_error)
+
+    if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
+        assert fragment, 'You need to pass a fragment to resolve a Interface or Union'
+        return type_resolver_fragment(return_type, resolver, fragment, exe_context, info, catch_error)
+
+    raise Exception("The resolver have to be created for a fragment")
+
+
+def on_error(exe_context, info, catch_error, e):
+    error = e
+    if not isinstance(e, (GraphQLLocatedError, GraphQLError)):
+        error = GraphQLLocatedError(info.field_asts, original_error=e)
+    if catch_error:
+        exe_context.errors.append(error)
+        executor.logger.exception("An error occurred while resolving field {}.{}".format(
+            info.parent_type.name, info.field_name
+        ))
+        error.stack = sys.exc_info()[2]
+        return None
+    raise error
+
+
+def type_resolver_fragment(return_type, resolver, fragment, exe_context, info, catch_error):
+    on_complete_type_error = partial(on_error, exe_context, info, catch_error)
+    complete_object_value_resolve = partial(
+        complete_object_value,
+        fragment.resolve,
+        exe_context,
+        on_complete_type_error)
+    on_resolve_error = partial(on_error, exe_context, info, catch_error)
+    return partial(on_complete_resolver, on_resolve_error, complete_object_value_resolve, exe_context, info, resolver)
+
+
+def type_resolver_non_null(return_type, resolver, fragment, exe_context, info):  # no catch_error
+    resolver = type_resolver(return_type.of_type, resolver, fragment, exe_context, info)
+    nonnull_complete = partial(complete_nonnull_value, exe_context, info)
+    on_resolve_error = partial(on_error, exe_context, info, False)
+    return partial(on_complete_resolver, on_resolve_error, nonnull_complete, exe_context, info, resolver)
+
+
+def type_resolver_leaf(return_type, resolver, exe_context, info, catch_error):
+    leaf_complete = partial(complete_leaf_value, return_type.serialize)
+    on_resolve_error = partial(on_error, exe_context, info, catch_error)
+    return partial(on_complete_resolver, on_resolve_error, leaf_complete, exe_context, info, resolver)
+
+
+def type_resolver_list(return_type, resolver, fragment, exe_context, info, catch_error):
+    item_type = return_type.of_type
+    inner_resolver = type_resolver(item_type, lambda item: item, fragment, exe_context, info, catch_error=True)
+    on_resolve_error = partial(on_error, exe_context, info, catch_error)
+    list_complete = partial(complete_list_value, inner_resolver, exe_context, info, on_resolve_error)
+    return partial(on_complete_resolver, on_resolve_error, list_complete, exe_context, info, resolver)

wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/utils.py

@@ -0,0 +1,7 @@
+try:
+    from itertools import imap
+    normal_map = map
+except:
+    def normal_map(func, iter):
+        return list(map(func, iter))
+    imap = map