graphql-python / graphene-mongo / 441

pending completion

Build # 441

Build Type

Pull #160

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/2a74cfb75d247f0ca9262c07f66674672f6b6ceb">2a74cfb75<a href="https://github.com/graphql-python/graphene-mongo/commit/2a74cfb75d247f0ca9262c07f66674672f6b6ceb">">Merge </a><a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/28cd0fdd2e83d2cbeac831b8acd068be23161552">28cd0fdd2</a>">28cd0fdd2</a><a href="https://github.com/graphql-python/graphene-mongo/commit/2a74cfb75d247f0ca9262c07f66674672f6b6ceb"> into 5d0813372">5d0813372</a>

Pull Request Pull Request #160: Feat retrieving queried fields only - Improvements & Bug fix to #156 pull request

Run Details

167 of 167 new or added lines in 4 files covered. (100.0%)

641 of 731 relevant lines covered (87.69%)

3.51 hits per line

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

98.32

/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 connection_from_list_slice

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_node_from_global_id, get_query_fields


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(), **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 isinstance(arg, str):
                    reference_obj = get_node_from_global_id(
                        reference_fields[arg_name], info, args.pop(arg_name)
                    )
                    hydrated_references[arg_name] = reference_obj
            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)

        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:
                if getattr(_root, field_name, []) is not None:
                    args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]

        connection_args = {
            "first": args.pop("first", None),
            "last": args.pop("last", None),
            "before": args.pop("before", None),
            "after": args.pop("after", None),
        }

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

        if _id is not None:
            args['pk'] = from_global_id(_id)[-1]

        if callable(getattr(self.model, "objects", None)):
            iterables = self.get_queryset(self.model, info, required_fields, **args)
            if isinstance(info, ResolveInfo):
                if not info.context:
                    info.context = Context()
                info.context.queryset = iterables
            list_length = iterables.count()
        else:
            iterables = []
            list_length = 0

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

graphql-python / graphene-mongo / 441

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