graphql-python / graphene-mongo / 451

pending completion

Build # 451

Build Type

Pull #163

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/graphql-python/graphene-mongo/commit/<a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed">71aeab9d7">&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/</a><a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed">71aeab9d7</a><a href="https://github.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed">&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/graphql-python/graphene-mongo/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed&amp;quot;&amp;gt;71aeab9d7&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04715efeed&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/graphql-python/graphene-mongo/commit/71aeab9d727274b5f9427e1dd44fbf04&amp;lt;/a&amp;gt;715efeed&amp;quot;&amp;gt</a>;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.c... (continued)

Pull Request Pull Request #163: Bug fix in paginating through list of embedded document / list of generic embedded document

Run Details

18 of 18 new or added lines in 1 file covered. (100.0%)

712 of 845 relevant lines covered (84.26%)

4.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.35

/graphene_mongo/fields.py

from __future__ import absolute_import

from collections import OrderedDict
from functools import partial, reduce

import graphene
import mongoengine
from bson import DBRef
from graphene import Context
from graphene.types.utils import get_type
from graphene.utils.str_converters import to_snake_case
from graphql import ResolveInfo
from promise import Promise
from graphql_relay import from_global_id
from graphene.relay import ConnectionField
from graphene.types.argument import to_arguments
from graphene.types.dynamic import Dynamic
from graphene.types.structures import Structure
from graphql_relay.connection.arrayconnection import cursor_to_offset
from mongoengine import QuerySet

from .advanced_types import (
    FileFieldType,
    PointFieldType,
    MultiPolygonFieldType,
    PolygonFieldType,
)
from .converter import convert_mongoengine_field, MongoEngineConversionError
from .registry import get_global_registry
from .utils import get_model_reference_fields, get_query_fields, find_skip_and_limit, \
    connection_from_iterables


class MongoengineConnectionField(ConnectionField):
    def __init__(self, type, *args, **kwargs):
        get_queryset = kwargs.pop("get_queryset", None)
        if get_queryset:
            assert callable(
                get_queryset
            ), "Attribute `get_queryset` on {} must be callable.".format(self)
        self._get_queryset = get_queryset
        super(MongoengineConnectionField, self).__init__(type, *args, **kwargs)

    @property
    def type(self):
        from .types import MongoengineObjectType

        _type = super(ConnectionField, self).type
        assert issubclass(
            _type, MongoengineObjectType
        ), "MongoengineConnectionField only accepts MongoengineObjectType types"
        assert _type._meta.connection, "The type {} doesn't have a connection".format(
            _type.__name__
        )
        return _type._meta.connection

    @property
    def node_type(self):
        return self.type._meta.node

    @property
    def model(self):
        return self.node_type._meta.model

    @property
    def order_by(self):
        return self.node_type._meta.order_by

    @property
    def required_fields(self):
        return tuple(set(self.node_type._meta.required_fields + self.node_type._meta.only_fields))

    @property
    def registry(self):
        return getattr(self.node_type._meta, "registry", get_global_registry())

    @property
    def args(self):
        return to_arguments(
            self._base_args or OrderedDict(),
            dict(dict(self.field_args, **self.reference_args), **self.filter_args),
        )

    @args.setter
    def args(self, args):
        self._base_args = args

    def _field_args(self, items):
        def is_filterable(k):
            """
            Remove complex columns from input args at this moment.

            Args:
                k (str): field name.
            Returns:
                bool
            """

            if not hasattr(self.model, k):
                return False
            if isinstance(getattr(self.model, k), property):
                return False
            try:
                converted = convert_mongoengine_field(
                    getattr(self.model, k), self.registry
                )
            except MongoEngineConversionError:
                return False
            if isinstance(converted, (ConnectionField, Dynamic)):
                return False
            if callable(getattr(converted, "type", None)) and isinstance(
                    converted.type(),
                    (
                            FileFieldType,
                            PointFieldType,
                            MultiPolygonFieldType,
                            graphene.Union,
                            PolygonFieldType,
                    ),
            ):
                return False
            if getattr(converted, "type", None) and getattr(converted.type, "_of_type", None) and issubclass(
                    (get_type(converted.type.of_type)), graphene.Union):
                return False
            if isinstance(converted, (graphene.List)) and issubclass(
                    getattr(converted, "_of_type", None), graphene.Union
            ):
                return False
            return True

        def get_filter_type(_type):
            """
            Returns the scalar type.
            """
            if isinstance(_type, Structure):
                return get_filter_type(_type.of_type)
            return _type()

        return {k: get_filter_type(v.type) for k, v in items if is_filterable(k)}

    @property
    def field_args(self):
        return self._field_args(self.fields.items())

    @property
    def filter_args(self):
        filter_args = dict()
        if self._type._meta.filter_fields:
            for field, filter_collection in self._type._meta.filter_fields.items():
                for each in filter_collection:
                    filter_type = getattr(
                        graphene,
                        str(self._type._meta.fields[field].type).replace("!", ""),
                    )

                    # handle special cases
                    advanced_filter_types = {
                        "in": graphene.List(filter_type),
                        "nin": graphene.List(filter_type),
                        "all": graphene.List(filter_type),
                    }

                    filter_type = advanced_filter_types.get(each, filter_type)
                    filter_args[field + "__" + each] = graphene.Argument(
                        type=filter_type
                    )

        return filter_args

    @property
    def reference_args(self):
        def get_reference_field(r, kv):
            field = kv[1]
            mongo_field = getattr(self.model, kv[0], None)
            if isinstance(
                    mongo_field,
                    (mongoengine.LazyReferenceField, mongoengine.ReferenceField),
            ):
                field = convert_mongoengine_field(mongo_field, self.registry)
            if callable(getattr(field, "get_type", None)):
                _type = field.get_type()
                if _type:
                    node = _type.type._meta if hasattr(_type.type, "_meta") else _type.type._of_type._meta
                    if "id" in node.fields and not issubclass(
                            node.model, (mongoengine.EmbeddedDocument,)
                    ):
                        r.update({kv[0]: node.fields["id"]._type.of_type()})

            return r

        return reduce(get_reference_field, self.fields.items(), {})

    @property
    def fields(self):
        self._type = get_type(self._type)
        return self._type._meta.fields

    def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):
        if args:
            reference_fields = get_model_reference_fields(self.model)
            hydrated_references = {}
            for arg_name, arg in args.copy().items():
                if arg_name in reference_fields and not isinstance(arg,
                                                                   mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
                    try:
                        reference_obj = reference_fields[arg_name].document_type(pk=from_global_id(arg)[1])
                    except TypeError:
                        reference_obj = reference_fields[arg_name].document_type(pk=arg)
                    hydrated_references[arg_name] = reference_obj
                elif arg_name == "id":
                    hydrated_references["id"] = from_global_id(args.pop("id", None))[1]
            args.update(hydrated_references)

        if self._get_queryset:
            queryset_or_filters = self._get_queryset(model, info, **args)
            if isinstance(queryset_or_filters, mongoengine.QuerySet):
                return queryset_or_filters
            else:
                args.update(queryset_or_filters)
        if limit is not None:
            if reversed:
                order_by = ""
                if self.order_by:
                    order_by = self.order_by + ",-pk"
                else:
                    order_by = "-pk"
                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
                    skip if skip else 0).limit(limit)
            else:
                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
                    skip if skip else 0).limit(limit)
        elif skip is not None:
            if reversed:
                order_by = ""
                if self.order_by:
                    order_by = self.order_by + ",-pk"
                else:
                    order_by = "-pk"
                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
                    skip)
            else:
                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
                    skip)
        return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by)

    def default_resolver(self, _root, info, required_fields=list(), **args):
        args = args or {}
        if _root is not None:
            field_name = to_snake_case(info.field_name)
            if field_name in _root._fields_ordered and not (isinstance(_root._fields[field_name].field,
                                                                       mongoengine.EmbeddedDocumentField) or
                                                            isinstance(_root._fields[field_name].field,
                                                                       mongoengine.GenericEmbeddedDocumentField)):
                if getattr(_root, field_name, []) is not None:
                    args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]

        _id = args.pop('id', None)

        if _id is not None:
            args['pk'] = from_global_id(_id)[-1]
        iterables = []
        list_length = 0
        skip = 0
        count = 0
        limit = None
        reverse = False
        first = args.pop("first", None)
        after = cursor_to_offset(args.pop("after", None))
        last = args.pop("last", None)
        before = cursor_to_offset(args.pop("before", None))
        if callable(getattr(self.model, "objects", None)):
            if "pk__in" in args and args["pk__in"]:
                count = len(args["pk__in"])
                skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,
                                                           count=count)
                if limit:
                    if reverse:
                        args["pk__in"] = args["pk__in"][::-1][skip:skip + limit]
                    else:
                        args["pk__in"] = args["pk__in"][skip:skip + limit]
                elif skip:
                    args["pk__in"] = args["pk__in"][skip:]
                iterables = self.get_queryset(self.model, info, required_fields, **args)
                list_length = len(iterables)
                if isinstance(info, ResolveInfo):
                    if not info.context:
                        info.context = Context()
                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
            elif _root is None:
                count = self.get_queryset(self.model, info, required_fields, **args).count()
                if count != 0:
                    skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last, before=before,
                                                               count=count)
                    iterables = self.get_queryset(self.model, info, required_fields, skip, limit, reverse, **args)
                    list_length = len(iterables)
                    if isinstance(info, ResolveInfo):
                        if not info.context:
                            info.context = Context()
                        info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)

        elif _root is not None:
            field_name = to_snake_case(info.field_name)
            items = getattr(_root, field_name, [])
            count = len(items)
            skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,
                                                       count=count)
            if limit:
                if reverse:
                    items = items[::-1][skip:skip + limit]
                else:
                    items = items[skip:skip + limit]
            elif skip:
                items = items[skip:]
            iterables = items
            list_length = len(iterables)
        has_next_page = True if (0 if limit is None else limit) + (0 if skip is None else skip) < count else False
        has_previous_page = True if skip else False
        if reverse:
            iterables = list(iterables)
            iterables.reverse()
            skip = limit
        connection = connection_from_iterables(edges=iterables, start_offset=skip,
                                               has_previous_page=has_previous_page,
                                               has_next_page=has_next_page,
                                               connection_type=self.type,
                                               edge_type=self.type.Edge,
                                               pageinfo_type=graphene.PageInfo)

        connection.iterable = iterables
        connection.list_length = list_length
        return connection

    def chained_resolver(self, resolver, is_partial, root, info, **args):
        required_fields = list()
        for field in self.required_fields:
            if field in self.model._fields_ordered:
                required_fields.append(field)
        for field in get_query_fields(info):
            if to_snake_case(field) in self.model._fields_ordered:
                required_fields.append(to_snake_case(field))
        if not bool(args) or not is_partial:
            if isinstance(self.model, mongoengine.Document) or isinstance(self.model,
                                                                          mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
                args_copy = args.copy()
                for arg_name, arg in args.copy().items():
                    if arg_name not in self.model._fields_ordered + tuple(self.filter_args.keys()):
                        args_copy.pop(arg_name)
                if isinstance(info, ResolveInfo):
                    if not info.context:
                        info.context = Context()
                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)
            # XXX: Filter nested args
            resolved = resolver(root, info, **args)
            if resolved is not None:
                if isinstance(resolved, list):
                    if resolved == list():
                        return resolved
                    elif not isinstance(resolved[0], DBRef):
                        return resolved
                elif isinstance(resolved, QuerySet):
                    args.update(resolved._query)
                    args_copy = args.copy()
                    for arg_name, arg in args.copy().items():
                        if arg_name not in self.model._fields_ordered + ('first', 'last', 'before', 'after') + tuple(
                                self.filter_args.keys()):
                            args_copy.pop(arg_name)
                    return self.default_resolver(root, info, required_fields, **args_copy)
                else:
                    return resolved
        return self.default_resolver(root, info, required_fields, **args)

    @classmethod
    def connection_resolver(cls, resolver, connection_type, root, info, **args):
        iterable = resolver(root, info, **args)
        if isinstance(connection_type, graphene.NonNull):
            connection_type = connection_type.of_type
        on_resolve = partial(cls.resolve_connection, connection_type, args)
        if Promise.is_thenable(iterable):
            return Promise.resolve(iterable).then(on_resolve)
        return on_resolve(iterable)

    def get_resolver(self, parent_resolver):
        super_resolver = self.resolver or parent_resolver
        resolver = partial(
            self.chained_resolver, super_resolver, isinstance(super_resolver, partial)
        )
        return partial(self.connection_resolver, resolver, self.type)

1	from __future__ import absolute_import	5✔
2
3	from collections import OrderedDict	5✔
4	from functools import partial, reduce	5✔
5
6	import graphene	5✔
7	import mongoengine	5✔
8	from bson import DBRef	5✔
9	from graphene import Context	5✔
10	from graphene.types.utils import get_type	5✔
11	from graphene.utils.str_converters import to_snake_case	5✔
12	from graphql import ResolveInfo	5✔
13	from promise import Promise	5✔
14	from graphql_relay import from_global_id	5✔
15	from graphene.relay import ConnectionField	5✔
16	from graphene.types.argument import to_arguments	5✔
17	from graphene.types.dynamic import Dynamic	5✔
18	from graphene.types.structures import Structure	5✔
19	from graphql_relay.connection.arrayconnection import cursor_to_offset	5✔
20	from mongoengine import QuerySet	5✔
21
22	from .advanced_types import (	5✔
23	FileFieldType,
24	PointFieldType,
25	MultiPolygonFieldType,
26	PolygonFieldType,
27	)
28	from .converter import convert_mongoengine_field, MongoEngineConversionError	5✔
29	from .registry import get_global_registry	5✔
30	from .utils import get_model_reference_fields, get_query_fields, find_skip_and_limit, \	5✔
31	connection_from_iterables
32
33
34	class MongoengineConnectionField(ConnectionField):	5✔
35	def __init__(self, type, args, *kwargs):	5✔
36	get_queryset = kwargs.pop("get_queryset", None)	5✔
37	if get_queryset:	5✔
38	assert callable(	5✔
39	get_queryset
40	), "Attribute `get_queryset` on {} must be callable.".format(self)
41	self._get_queryset = get_queryset	5✔
42	super(MongoengineConnectionField, self).__init__(type, args, *kwargs)	5✔
43
44	@property	5✔
45	def type(self):	1✔
46	from .types import MongoengineObjectType	5✔
47
48	_type = super(ConnectionField, self).type	5✔
49	assert issubclass(	5✔
50	_type, MongoengineObjectType
51	), "MongoengineConnectionField only accepts MongoengineObjectType types"
52	assert _type._meta.connection, "The type {} doesn't have a connection".format(	5✔
53	_type.__name__
54	)
55	return _type._meta.connection	5✔
56
57	@property	5✔
58	def node_type(self):	1✔
59	return self.type._meta.node	5✔
60
61	@property	5✔
62	def model(self):	1✔
63	return self.node_type._meta.model	5✔
64
65	@property	5✔
66	def order_by(self):	1✔
67	return self.node_type._meta.order_by	5✔
68
69	@property	5✔
70	def required_fields(self):	1✔
71	return tuple(set(self.node_type._meta.required_fields + self.node_type._meta.only_fields))	5✔
72
73	@property	5✔
74	def registry(self):	1✔
75	return getattr(self.node_type._meta, "registry", get_global_registry())	5✔
76
77	@property	5✔
78	def args(self):	1✔
79	return to_arguments(	5✔
80	self._base_args or OrderedDict(),
81	dict(dict(self.field_args, self.reference_args), self.filter_args),
82	)
83
84	@args.setter	5✔
85	def args(self, args):	1✔
86	self._base_args = args	5✔
87
88	def _field_args(self, items):	5✔
89	def is_filterable(k):	5✔
90	"""
91	Remove complex columns from input args at this moment.
92
93	Args:
94	k (str): field name.
95	Returns:
96	bool
97	"""
98
99	if not hasattr(self.model, k):	5✔
100	return False	5✔
101	if isinstance(getattr(self.model, k), property):	5✔
102	return False	5✔
103	try:	5✔
104	converted = convert_mongoengine_field(	5✔
105	getattr(self.model, k), self.registry
106	)
107	except MongoEngineConversionError:	5✔
108	return False	5✔
109	if isinstance(converted, (ConnectionField, Dynamic)):	5✔
110	return False	5✔
111	if callable(getattr(converted, "type", None)) and isinstance(	5✔
112	converted.type(),
113	(
114	FileFieldType,
115	PointFieldType,
116	MultiPolygonFieldType,
117	graphene.Union,
118	PolygonFieldType,
119	),
120	):
121	return False	5✔
122	if getattr(converted, "type", None) and getattr(converted.type, "_of_type", None) and issubclass(	5✔
123	(get_type(converted.type.of_type)), graphene.Union):
124	return False	5✔
125	if isinstance(converted, (graphene.List)) and issubclass(	5✔
126	getattr(converted, "_of_type", None), graphene.Union
127	):
128	return False	5✔
129	return True	5✔
130
131	def get_filter_type(_type):	5✔
132	"""
133	Returns the scalar type.
134	"""
135	if isinstance(_type, Structure):	5✔
136	return get_filter_type(_type.of_type)	5✔
137	return _type()	5✔
138
139	return {k: get_filter_type(v.type) for k, v in items if is_filterable(k)}	5✔
140
141	@property	5✔
142	def field_args(self):	1✔
143	return self._field_args(self.fields.items())	5✔
144
145	@property	5✔
146	def filter_args(self):	1✔
147	filter_args = dict()	5✔
148	if self._type._meta.filter_fields:	5✔
149	for field, filter_collection in self._type._meta.filter_fields.items():	5✔
150	for each in filter_collection:	5✔
151	filter_type = getattr(	5✔
152	graphene,
153	str(self._type._meta.fields[field].type).replace("!", ""),
154	)
155
156	# handle special cases
157	advanced_filter_types = {	5✔
158	"in": graphene.List(filter_type),
159	"nin": graphene.List(filter_type),
160	"all": graphene.List(filter_type),
161	}
162
163	filter_type = advanced_filter_types.get(each, filter_type)	5✔
164	filter_args[field + "__" + each] = graphene.Argument(	5✔
165	type=filter_type
166	)
167
168	return filter_args	5✔
169
170	@property	5✔
171	def reference_args(self):	1✔
172	def get_reference_field(r, kv):	5✔
173	field = kv[1]	5✔
174	mongo_field = getattr(self.model, kv[0], None)	5✔
175	if isinstance(	5✔
176	mongo_field,
177	(mongoengine.LazyReferenceField, mongoengine.ReferenceField),
178	):
179	field = convert_mongoengine_field(mongo_field, self.registry)	5✔
180	if callable(getattr(field, "get_type", None)):	5✔
181	_type = field.get_type()	5✔
182	if _type:	5✔
183	node = _type.type._meta if hasattr(_type.type, "_meta") else _type.type._of_type._meta	5✔
184	if "id" in node.fields and not issubclass(	5✔
185	node.model, (mongoengine.EmbeddedDocument,)
186	):
187	r.update({kv[0]: node.fields["id"]._type.of_type()})	5✔
188
189	return r	5✔
190
191	return reduce(get_reference_field, self.fields.items(), {})	5✔
192
193	@property	5✔
194	def fields(self):	1✔
195	self._type = get_type(self._type)	5✔
196	return self._type._meta.fields	5✔
197
198	def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):	5✔
199	if args:	5✔
200	reference_fields = get_model_reference_fields(self.model)	5✔
201	hydrated_references = {}	5✔
202	for arg_name, arg in args.copy().items():	5✔
203	if arg_name in reference_fields and not isinstance(arg,	5✔
204	mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
205	try:	5✔
206	reference_obj = reference_fields[arg_name].document_type(pk=from_global_id(arg)[1])	5✔
207	except TypeError:	×
208	reference_obj = reference_fields[arg_name].document_type(pk=arg)	×
209	hydrated_references[arg_name] = reference_obj	5✔
210	elif arg_name == "id":	5✔
211	hydrated_references["id"] = from_global_id(args.pop("id", None))[1]	×
212	args.update(hydrated_references)	5✔
213
214	if self._get_queryset:	5✔
215	queryset_or_filters = self._get_queryset(model, info, **args)	5✔
216	if isinstance(queryset_or_filters, mongoengine.QuerySet):	5✔
217	return queryset_or_filters	5✔
218	else:
219	args.update(queryset_or_filters)	5✔
220	if limit is not None:	5✔
221	if reversed:	5✔
222	order_by = ""	5✔
223	if self.order_by:	5✔
224	order_by = self.order_by + ",-pk"	×
225	else:
226	order_by = "-pk"	5✔
227	return model.objects(*args).no_dereference().only(required_fields).order_by(order_by).skip(	5✔
228	skip if skip else 0).limit(limit)
229	else:
230	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by).skip(	5✔
231	skip if skip else 0).limit(limit)
232	elif skip is not None:	5✔
233	if reversed:	5✔
234	order_by = ""	×
235	if self.order_by:	×
236	order_by = self.order_by + ",-pk"	×
237	else:
238	order_by = "-pk"	×
239	return model.objects(*args).no_dereference().only(required_fields).order_by(order_by).skip(	×
240	skip)
241	else:
242	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by).skip(	5✔
243	skip)
244	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by)	5✔
245
246	def default_resolver(self, _root, info, required_fields=list(), **args):	5✔
247	args = args or {}	5✔
248	if _root is not None:	5✔
249	field_name = to_snake_case(info.field_name)	5✔
250	if field_name in _root._fields_ordered and not (isinstance(_root._fields[field_name].field,	5✔
251	mongoengine.EmbeddedDocumentField) or
252	isinstance(_root._fields[field_name].field,
253	mongoengine.GenericEmbeddedDocumentField)):
254	if getattr(_root, field_name, []) is not None:	5✔
255	args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]	5✔
256
257	_id = args.pop('id', None)	5✔
258
259	if _id is not None:	5✔
260	args['pk'] = from_global_id(_id)[-1]	5✔
261	iterables = []	5✔
262	list_length = 0	5✔
263	skip = 0	5✔
264	count = 0	5✔
265	limit = None	5✔
266	reverse = False	5✔
267	first = args.pop("first", None)	5✔
268	after = cursor_to_offset(args.pop("after", None))	5✔
269	last = args.pop("last", None)	5✔
270	before = cursor_to_offset(args.pop("before", None))	5✔
271	if callable(getattr(self.model, "objects", None)):	5✔
272	if "pk__in" in args and args["pk__in"]:	5✔
273	count = len(args["pk__in"])	5✔
274	skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,	5✔
275	count=count)
276	if limit:	5✔
277	if reverse:	5✔
278	args["pk__in"] = args["pk__in"][::-1][skip:skip + limit]	×
279	else:
280	args["pk__in"] = args["pk__in"][skip:skip + limit]	5✔
281	elif skip:	5✔
282	args["pk__in"] = args["pk__in"][skip:]	×
283	iterables = self.get_queryset(self.model, info, required_fields, **args)	5✔
284	list_length = len(iterables)	5✔
285	if isinstance(info, ResolveInfo):	5✔
286	if not info.context:	5✔
287	info.context = Context()	5✔
288	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)	5✔
289	elif _root is None:	5✔
290	count = self.get_queryset(self.model, info, required_fields, **args).count()	5✔
291	if count != 0:	5✔
292	skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last, before=before,	5✔
293	count=count)
294	iterables = self.get_queryset(self.model, info, required_fields, skip, limit, reverse, **args)	5✔
295	list_length = len(iterables)	5✔
296	if isinstance(info, ResolveInfo):	5✔
297	if not info.context:	5✔
298	info.context = Context()	5✔
299	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)	5✔
300
301	elif _root is not None:	5✔
302	field_name = to_snake_case(info.field_name)	×
303	items = getattr(_root, field_name, [])	×
304	count = len(items)	×
305	skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,	×
306	count=count)
307	if limit:	×
308	if reverse:	×
309	items = items[::-1][skip:skip + limit]	×
310	else:
311	items = items[skip:skip + limit]	×
312	elif skip:	×
313	items = items[skip:]	×
314	iterables = items	×
315	list_length = len(iterables)	×
316	has_next_page = True if (0 if limit is None else limit) + (0 if skip is None else skip) < count else False	5✔
317	has_previous_page = True if skip else False	5✔
318	if reverse:	5✔
319	iterables = list(iterables)	5✔
320	iterables.reverse()	5✔
321	skip = limit	5✔
322	connection = connection_from_iterables(edges=iterables, start_offset=skip,	5✔
323	has_previous_page=has_previous_page,
324	has_next_page=has_next_page,
325	connection_type=self.type,
326	edge_type=self.type.Edge,
327	pageinfo_type=graphene.PageInfo)
328
329	connection.iterable = iterables	5✔
330	connection.list_length = list_length	5✔
331	return connection	5✔
332
333	def chained_resolver(self, resolver, is_partial, root, info, **args):	5✔
334	required_fields = list()	5✔
335	for field in self.required_fields:	5✔
336	if field in self.model._fields_ordered:	×
337	required_fields.append(field)	×
338	for field in get_query_fields(info):	5✔
339	if to_snake_case(field) in self.model._fields_ordered:	5✔
340	required_fields.append(to_snake_case(field))	5✔
341	if not bool(args) or not is_partial:	5✔
342	if isinstance(self.model, mongoengine.Document) or isinstance(self.model,	5✔
343	mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
344	args_copy = args.copy()	5✔
345	for arg_name, arg in args.copy().items():	5✔
346	if arg_name not in self.model._fields_ordered + tuple(self.filter_args.keys()):	5✔
347	args_copy.pop(arg_name)	5✔
348	if isinstance(info, ResolveInfo):	5✔
349	if not info.context:	5✔
350	info.context = Context()	5✔
351	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)	5✔
352	# XXX: Filter nested args
353	resolved = resolver(root, info, **args)	5✔
354	if resolved is not None:	5✔
355	if isinstance(resolved, list):	5✔
356	if resolved == list():	5✔
357	return resolved	5✔
358	elif not isinstance(resolved[0], DBRef):	5✔
359	return resolved	5✔
360	elif isinstance(resolved, QuerySet):	5✔
361	args.update(resolved._query)	×
362	args_copy = args.copy()	×
363	for arg_name, arg in args.copy().items():	×
364	if arg_name not in self.model._fields_ordered + ('first', 'last', 'before', 'after') + tuple(	×
365	self.filter_args.keys()):
366	args_copy.pop(arg_name)	×
367	return self.default_resolver(root, info, required_fields, **args_copy)	×
368	else:
369	return resolved	5✔
370	return self.default_resolver(root, info, required_fields, **args)	5✔
371
372	@classmethod	5✔
373	def connection_resolver(cls, resolver, connection_type, root, info, **args):	1✔
374	iterable = resolver(root, info, **args)	5✔
375	if isinstance(connection_type, graphene.NonNull):	5✔
376	connection_type = connection_type.of_type	×
377	on_resolve = partial(cls.resolve_connection, connection_type, args)	5✔
378	if Promise.is_thenable(iterable):	5✔
379	return Promise.resolve(iterable).then(on_resolve)	5✔
380	return on_resolve(iterable)	5✔
381
382	def get_resolver(self, parent_resolver):	5✔
383	super_resolver = self.resolver or parent_resolver	5✔
384	resolver = partial(	5✔
385	self.chained_resolver, super_resolver, isinstance(super_resolver, partial)
386	)
387	return partial(self.connection_resolver, resolver, self.type)	5✔

graphql-python / graphene-mongo / 451

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous