graphql-python / graphene-mongo / 394

pending completion

Build # 394

Build Type

Pull #156

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/8d2a35aa75aba00c7001ceba12a5e3a085d894df">8d2a35aa7<a href="https://github.com/graphql-python/graphene-mongo/commit/8d2a35aa75aba00c7001ceba12a5e3a085d894df">">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/ff387fec3a233e8bd6b43d79fd18c4f6f33c0d48">ff387fec3</a>">ff387fec3</a><a href="https://github.com/graphql-python/graphene-mongo/commit/8d2a35aa75aba00c7001ceba12a5e3a085d894df"> into 7ca0925bd">7ca0925bd</a>

Pull Request Pull Request #156: Feat retrieving queried fields only

Run Details

120 of 120 new or added lines in 3 files covered. (100.0%)

562 of 590 relevant lines covered (95.25%)

2.84 hits per line

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

96.47

/graphene_mongo/converter.py

import graphene
import mongoengine
import uuid

from graphene.types.json import JSONString
from graphene.utils.str_converters import to_snake_case
from mongoengine.base import get_document
from . import advanced_types
from .utils import import_single_dispatch, get_field_description, get_query_fields
from concurrent.futures import ThreadPoolExecutor, as_completed

singledispatch = import_single_dispatch()


class MongoEngineConversionError(Exception):
    pass


@singledispatch
def convert_mongoengine_field(field, registry=None):
    raise MongoEngineConversionError(
        "Don't know how to convert the MongoEngine field %s (%s)"
        % (field, field.__class__)
    )


@convert_mongoengine_field.register(mongoengine.EmailField)
@convert_mongoengine_field.register(mongoengine.StringField)
@convert_mongoengine_field.register(mongoengine.URLField)
def convert_field_to_string(field, registry=None):
    return graphene.String(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.UUIDField)
@convert_mongoengine_field.register(mongoengine.ObjectIdField)
def convert_field_to_id(field, registry=None):
    return graphene.ID(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.IntField)
@convert_mongoengine_field.register(mongoengine.LongField)
@convert_mongoengine_field.register(mongoengine.SequenceField)
def convert_field_to_int(field, registry=None):
    return graphene.Int(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.BooleanField)
def convert_field_to_boolean(field, registry=None):
    return graphene.Boolean(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.DecimalField)
@convert_mongoengine_field.register(mongoengine.FloatField)
def convert_field_to_float(field, registry=None):
    return graphene.Float(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.DateTimeField)
def convert_field_to_datetime(field, registry=None):
    return graphene.DateTime(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.DictField)
@convert_mongoengine_field.register(mongoengine.MapField)
def convert_field_to_jsonstring(field, registry=None):
    return JSONString(
        description=get_field_description(field, registry), required=field.required
    )


@convert_mongoengine_field.register(mongoengine.PointField)
def convert_point_to_field(field, registry=None):
    return graphene.Field(advanced_types.PointFieldType)


@convert_mongoengine_field.register(mongoengine.PolygonField)
def convert_polygon_to_field(field, registry=None):
    return graphene.Field(advanced_types.PolygonFieldType)


@convert_mongoengine_field.register(mongoengine.MultiPolygonField)
def convert_multipolygon_to_field(field, register=None):
    return graphene.Field(advanced_types.MultiPolygonFieldType)


@convert_mongoengine_field.register(mongoengine.FileField)
def convert_file_to_field(field, registry=None):
    return graphene.Field(advanced_types.FileFieldType)


@convert_mongoengine_field.register(mongoengine.ListField)
@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentListField)
def convert_field_to_list(field, registry=None):
    base_type = convert_mongoengine_field(field.field, registry=registry)
    if isinstance(base_type, graphene.Field):
        if isinstance(field.field, mongoengine.GenericReferenceField):
            def get_reference_objects(*args, **kwargs):
                if args[0][1]:
                    document = get_document(args[0][0])
                    document_field = mongoengine.ReferenceField(document)
                    document_field = convert_mongoengine_field(document_field, registry)
                    document_field_type = document_field.get_type().type._meta.name
                    only_fields = [to_snake_case(i) for i in get_query_fields(args[0][3][0])[document_field_type].keys()]
                    return document.objects().no_dereference().only(*only_fields).filter(pk__in=args[0][1])
                else:
                    return []

            def reference_resolver(root, *args, **kwargs):
                choice_to_resolve = dict()
                to_resolve = getattr(root, field.name or field.db_name)
                for each in to_resolve:
                    if each['_cls'] not in choice_to_resolve:
                        choice_to_resolve[each['_cls']] = list()
                    choice_to_resolve[each['_cls']].append(each["_ref"].id)

                pool = ThreadPoolExecutor(5)
                futures = list()
                for model, object_id_list in choice_to_resolve.items():
                    futures.append(pool.submit(get_reference_objects, (model, object_id_list, registry, args)))
                result = list()
                for x in as_completed(futures):
                    result += x.result()
                to_resolve_object_ids = [each["_ref"].id for each in to_resolve]
                result_to_resolve_object_ids = [each.id for each in result]
                ordered_result = list()
                for each in to_resolve_object_ids:
                    ordered_result.append(result[result_to_resolve_object_ids.index(each)])
                return ordered_result

            return graphene.List(
                base_type._type,
                description=get_field_description(field, registry),
                required=field.required,
                resolver=reference_resolver
            )
        return graphene.List(
            base_type._type,
            description=get_field_description(field, registry),
            required=field.required
        )
    if isinstance(base_type, (graphene.Dynamic)):
        base_type = base_type.get_type()
        if base_type is None:
            return
        base_type = base_type._type

    if graphene.is_node(base_type):
        return base_type._meta.connection_field_class(base_type)

    # Non-relationship field
    relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)
    if not isinstance(base_type, (graphene.List, graphene.NonNull)) and not isinstance(
            field.field, relations
    ):
        base_type = type(base_type)

    return graphene.List(
        base_type,
        description=get_field_description(field, registry),
        required=field.required,
    )


@convert_mongoengine_field.register(mongoengine.GenericEmbeddedDocumentField)
@convert_mongoengine_field.register(mongoengine.GenericReferenceField)
def convert_field_to_union(field, registry=None):
    _types = []
    for choice in field.choices:
        if isinstance(field, mongoengine.GenericReferenceField):
            _field = mongoengine.ReferenceField(get_document(choice))
        elif isinstance(field, mongoengine.GenericEmbeddedDocumentField):
            _field = mongoengine.EmbeddedDocumentField(choice)

        _field = convert_mongoengine_field(_field, registry)
        _type = _field.get_type()
        if _type:
            _types.append(_type.type)
        else:
            # TODO: Register type auto-matically here.
            pass

    if len(_types) == 0:
        return None

    # XXX: Use uuid to avoid duplicate name
    name = "{}_{}_union_{}".format(
        field._owner_document.__name__,
        field.db_field,
        str(uuid.uuid1()).replace("-", ""),
    )
    Meta = type("Meta", (object,), {"types": tuple(_types)})
    _union = type(name, (graphene.Union,), {"Meta": Meta})

    def reference_resolver(root, *args, **kwargs):
        dereferenced = getattr(root, field.name or field.db_name)
        document = get_document(dereferenced["_cls"])
        document_field = mongoengine.ReferenceField(document)
        document_field = convert_mongoengine_field(document_field, registry)
        document_field_type = document_field.get_type().type._meta.name
        only_fields = [to_snake_case(i) for i in get_query_fields(args[0])[document_field_type].keys()]
        return document.objects().no_dereference().only(*only_fields).get(pk=dereferenced["_ref"].id)

    if isinstance(field, mongoengine.GenericReferenceField):
        return graphene.Field(_union, resolver=reference_resolver,
                              description=get_field_description(field, registry))

    return graphene.Field(_union)


@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentField)
@convert_mongoengine_field.register(mongoengine.ReferenceField)
@convert_mongoengine_field.register(mongoengine.CachedReferenceField)
def convert_field_to_dynamic(field, registry=None):
    model = field.document_type

    def reference_resolver(root, *args, **kwargs):
        document = getattr(root, field.name or field.db_name)
        if document:
            only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]
            return field.document_type.objects().no_dereference().only(*only_fields).get(pk=document.id)
        return None

    def cached_reference_resolver(root, *args, **kwargs):
        only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]
        return field.document_type.objects().no_dereference().only(*only_fields).get(
            pk=getattr(root, field.name or field.db_name))

    def dynamic_type():
        _type = registry.get_type_for_model(model)
        if not _type:
            return None
        elif isinstance(field, mongoengine.ReferenceField):
            return graphene.Field(_type, resolver=reference_resolver,
                                  description=get_field_description(field, registry))
        elif isinstance(field, mongoengine.CachedReferenceField):
            return graphene.Field(_type, resolver=cached_reference_resolver,
                                  description=get_field_description(field, registry))
        return graphene.Field(_type,
                              description=get_field_description(field, registry))

    return graphene.Dynamic(dynamic_type)


@convert_mongoengine_field.register(mongoengine.LazyReferenceField)
def convert_lazy_field_to_dynamic(field, registry=None):
    model = field.document_type

    def lazy_resolver(root, *args, **kwargs):
        document = getattr(root, field.name or field.db_name)
        only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]
        return document.document_type.objects().no_dereference().only(*only_fields).get(pk=document.pk)

    def dynamic_type():
        _type = registry.get_type_for_model(model)
        if not _type:
            return None
        return graphene.Field(
            _type,
            resolver=lazy_resolver,
            description=get_field_description(field, registry),
        )

    return graphene.Dynamic(dynamic_type)

1	import graphene	3✔
2	import mongoengine	3✔
3	import uuid	3✔
4
5	from graphene.types.json import JSONString	3✔
6	from graphene.utils.str_converters import to_snake_case	3✔
7	from mongoengine.base import get_document	3✔
8	from . import advanced_types	3✔
9	from .utils import import_single_dispatch, get_field_description, get_query_fields	3✔
10	from concurrent.futures import ThreadPoolExecutor, as_completed	3✔
11
12	singledispatch = import_single_dispatch()	3✔
13
14
15	class MongoEngineConversionError(Exception):	3✔
16	pass	3✔
17
18
19	@singledispatch	3✔
20	def convert_mongoengine_field(field, registry=None):	3✔
21	raise MongoEngineConversionError(	3✔
22	"Don't know how to convert the MongoEngine field %s (%s)"
23	% (field, field.__class__)
24	)
25
26
27	@convert_mongoengine_field.register(mongoengine.EmailField)	3✔
28	@convert_mongoengine_field.register(mongoengine.StringField)	3✔
29	@convert_mongoengine_field.register(mongoengine.URLField)	3✔
30	def convert_field_to_string(field, registry=None):	3✔
31	return graphene.String(	3✔
32	description=get_field_description(field, registry), required=field.required
33	)
34
35
36	@convert_mongoengine_field.register(mongoengine.UUIDField)	3✔
37	@convert_mongoengine_field.register(mongoengine.ObjectIdField)	3✔
38	def convert_field_to_id(field, registry=None):	3✔
39	return graphene.ID(	3✔
40	description=get_field_description(field, registry), required=field.required
41	)
42
43
44	@convert_mongoengine_field.register(mongoengine.IntField)	3✔
45	@convert_mongoengine_field.register(mongoengine.LongField)	3✔
46	@convert_mongoengine_field.register(mongoengine.SequenceField)	3✔
47	def convert_field_to_int(field, registry=None):	3✔
48	return graphene.Int(	3✔
49	description=get_field_description(field, registry), required=field.required
50	)
51
52
53	@convert_mongoengine_field.register(mongoengine.BooleanField)	3✔
54	def convert_field_to_boolean(field, registry=None):	3✔
55	return graphene.Boolean(	3✔
56	description=get_field_description(field, registry), required=field.required
57	)
58
59
60	@convert_mongoengine_field.register(mongoengine.DecimalField)	3✔
61	@convert_mongoengine_field.register(mongoengine.FloatField)	3✔
62	def convert_field_to_float(field, registry=None):	3✔
63	return graphene.Float(	3✔
64	description=get_field_description(field, registry), required=field.required
65	)
66
67
68	@convert_mongoengine_field.register(mongoengine.DateTimeField)	3✔
69	def convert_field_to_datetime(field, registry=None):	3✔
70	return graphene.DateTime(	3✔
71	description=get_field_description(field, registry), required=field.required
72	)
73
74
75	@convert_mongoengine_field.register(mongoengine.DictField)	3✔
76	@convert_mongoengine_field.register(mongoengine.MapField)	3✔
77	def convert_field_to_jsonstring(field, registry=None):	3✔
78	return JSONString(	3✔
79	description=get_field_description(field, registry), required=field.required
80	)
81
82
83	@convert_mongoengine_field.register(mongoengine.PointField)	3✔
84	def convert_point_to_field(field, registry=None):	3✔
85	return graphene.Field(advanced_types.PointFieldType)	3✔
86
87
88	@convert_mongoengine_field.register(mongoengine.PolygonField)	3✔
89	def convert_polygon_to_field(field, registry=None):	3✔
90	return graphene.Field(advanced_types.PolygonFieldType)	3✔
91
92
93	@convert_mongoengine_field.register(mongoengine.MultiPolygonField)	3✔
94	def convert_multipolygon_to_field(field, register=None):	3✔
95	return graphene.Field(advanced_types.MultiPolygonFieldType)	3✔
96
97
98	@convert_mongoengine_field.register(mongoengine.FileField)	3✔
99	def convert_file_to_field(field, registry=None):	3✔
100	return graphene.Field(advanced_types.FileFieldType)	3✔
101
102
103	@convert_mongoengine_field.register(mongoengine.ListField)	3✔
104	@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentListField)	3✔
105	def convert_field_to_list(field, registry=None):	3✔
106	base_type = convert_mongoengine_field(field.field, registry=registry)	3✔
107	if isinstance(base_type, graphene.Field):	3✔
108	if isinstance(field.field, mongoengine.GenericReferenceField):	3✔
109	def get_reference_objects(args, *kwargs):	3✔
110	if args[0][1]:	3✔
111	document = get_document(args[0][0])	3✔
112	document_field = mongoengine.ReferenceField(document)	3✔
113	document_field = convert_mongoengine_field(document_field, registry)	3✔
114	document_field_type = document_field.get_type().type._meta.name	3✔
115	only_fields = [to_snake_case(i) for i in get_query_fields(args[0][3][0])[document_field_type].keys()]	3✔
116	return document.objects().no_dereference().only(*only_fields).filter(pk__in=args[0][1])	3✔
117	else:
118	return []	×
119
120	def reference_resolver(root, args, *kwargs):	3✔
121	choice_to_resolve = dict()	3✔
122	to_resolve = getattr(root, field.name or field.db_name)	3✔
123	for each in to_resolve:	3✔
124	if each['_cls'] not in choice_to_resolve:	3✔
125	choice_to_resolve[each['_cls']] = list()	3✔
126	choice_to_resolve[each['_cls']].append(each["_ref"].id)	3✔
127
128	pool = ThreadPoolExecutor(5)	3✔
129	futures = list()	3✔
130	for model, object_id_list in choice_to_resolve.items():	3✔
131	futures.append(pool.submit(get_reference_objects, (model, object_id_list, registry, args)))	3✔
132	result = list()	3✔
133	for x in as_completed(futures):	3✔
134	result += x.result()	3✔
135	to_resolve_object_ids = [each["_ref"].id for each in to_resolve]	3✔
136	result_to_resolve_object_ids = [each.id for each in result]	3✔
137	ordered_result = list()	3✔
138	for each in to_resolve_object_ids:	3✔
139	ordered_result.append(result[result_to_resolve_object_ids.index(each)])	3✔
140	return ordered_result	3✔
141
142	return graphene.List(	3✔
143	base_type._type,
144	description=get_field_description(field, registry),
145	required=field.required,
146	resolver=reference_resolver
147	)
148	return graphene.List(	×
149	base_type._type,
150	description=get_field_description(field, registry),
151	required=field.required
152	)
153	if isinstance(base_type, (graphene.Dynamic)):	3✔
154	base_type = base_type.get_type()	3✔
155	if base_type is None:	3✔
156	return	3✔
157	base_type = base_type._type	3✔
158
159	if graphene.is_node(base_type):	3✔
160	return base_type._meta.connection_field_class(base_type)	3✔
161
162	# Non-relationship field
163	relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)	3✔
164	if not isinstance(base_type, (graphene.List, graphene.NonNull)) and not isinstance(	3✔
165	field.field, relations
166	):
167	base_type = type(base_type)	3✔
168
169	return graphene.List(	3✔
170	base_type,
171	description=get_field_description(field, registry),
172	required=field.required,
173	)
174
175
176	@convert_mongoengine_field.register(mongoengine.GenericEmbeddedDocumentField)	3✔
177	@convert_mongoengine_field.register(mongoengine.GenericReferenceField)	3✔
178	def convert_field_to_union(field, registry=None):	3✔
179	_types = []	3✔
180	for choice in field.choices:	3✔
181	if isinstance(field, mongoengine.GenericReferenceField):	3✔
182	_field = mongoengine.ReferenceField(get_document(choice))	3✔
183	elif isinstance(field, mongoengine.GenericEmbeddedDocumentField):	3✔
184	_field = mongoengine.EmbeddedDocumentField(choice)	3✔
185
186	_field = convert_mongoengine_field(_field, registry)	3✔
187	_type = _field.get_type()	3✔
188	if _type:	3✔
189	_types.append(_type.type)	3✔
190	else:
191	# TODO: Register type auto-matically here.
192	pass	×
193
194	if len(_types) == 0:	3✔
195	return None	3✔
196
197	# XXX: Use uuid to avoid duplicate name
198	name = "{}_{}_union_{}".format(	3✔
199	field._owner_document.__name__,
200	field.db_field,
201	str(uuid.uuid1()).replace("-", ""),
202	)
203	Meta = type("Meta", (object,), {"types": tuple(_types)})	3✔
204	_union = type(name, (graphene.Union,), {"Meta": Meta})	3✔
205
206	def reference_resolver(root, args, *kwargs):	3✔
207	dereferenced = getattr(root, field.name or field.db_name)	3✔
208	document = get_document(dereferenced["_cls"])	3✔
209	document_field = mongoengine.ReferenceField(document)	3✔
210	document_field = convert_mongoengine_field(document_field, registry)	3✔
211	document_field_type = document_field.get_type().type._meta.name	3✔
212	only_fields = [to_snake_case(i) for i in get_query_fields(args[0])[document_field_type].keys()]	3✔
213	return document.objects().no_dereference().only(*only_fields).get(pk=dereferenced["_ref"].id)	3✔
214
215	if isinstance(field, mongoengine.GenericReferenceField):	3✔
216	return graphene.Field(_union, resolver=reference_resolver,	3✔
217	description=get_field_description(field, registry))
218
219	return graphene.Field(_union)	3✔
220
221
222	@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentField)	3✔
223	@convert_mongoengine_field.register(mongoengine.ReferenceField)	3✔
224	@convert_mongoengine_field.register(mongoengine.CachedReferenceField)	3✔
225	def convert_field_to_dynamic(field, registry=None):	3✔
226	model = field.document_type	3✔
227
228	def reference_resolver(root, args, *kwargs):	3✔
229	document = getattr(root, field.name or field.db_name)	3✔
230	if document:	3✔
231	only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]	3✔
232	return field.document_type.objects().no_dereference().only(*only_fields).get(pk=document.id)	3✔
233	return None	3✔
234
235	def cached_reference_resolver(root, args, *kwargs):	3✔
236	only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]	×
237	return field.document_type.objects().no_dereference().only(*only_fields).get(	×
238	pk=getattr(root, field.name or field.db_name))
239
240	def dynamic_type():	3✔
241	_type = registry.get_type_for_model(model)	3✔
242	if not _type:	3✔
243	return None	3✔
244	elif isinstance(field, mongoengine.ReferenceField):	3✔
245	return graphene.Field(_type, resolver=reference_resolver,	3✔
246	description=get_field_description(field, registry))
247	elif isinstance(field, mongoengine.CachedReferenceField):	3✔
248	return graphene.Field(_type, resolver=cached_reference_resolver,	×
249	description=get_field_description(field, registry))
250	return graphene.Field(_type,	3✔
251	description=get_field_description(field, registry))
252
253	return graphene.Dynamic(dynamic_type)	3✔
254
255
256	@convert_mongoengine_field.register(mongoengine.LazyReferenceField)	3✔
257	def convert_lazy_field_to_dynamic(field, registry=None):	3✔
258	model = field.document_type	3✔
259
260	def lazy_resolver(root, args, *kwargs):	3✔
261	document = getattr(root, field.name or field.db_name)	3✔
262	only_fields = [to_snake_case(i) for i in get_query_fields(args[0]).keys()]	3✔
263	return document.document_type.objects().no_dereference().only(*only_fields).get(pk=document.pk)	3✔
264
265	def dynamic_type():	3✔
266	_type = registry.get_type_for_model(model)	3✔
267	if not _type:	3✔
268	return None	3✔
269	return graphene.Field(	3✔
270	_type,
271	resolver=lazy_resolver,
272	description=get_field_description(field, registry),
273	)
274
275	return graphene.Dynamic(dynamic_type)	3✔

graphql-python / graphene-mongo / 394

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