graphql-python / graphene-mongo / 431

pending completion

Build # 431

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/5597e8cc96de7a8e3cbec08d196d8b8b9fde2fd5">5597e8cc9<a href="https://github.com/graphql-python/graphene-mongo/commit/5597e8cc96de7a8e3cbec08d196d8b8b9fde2fd5">">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/20255ab1ce7c5355501ecae262421993e5636dcb">20255ab1c</a>">20255ab1c</a><a href="https://github.com/graphql-python/graphene-mongo/commit/5597e8cc96de7a8e3cbec08d196d8b8b9fde2fd5"> into 5d0813372">5d0813372</a>

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

Run Details

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

628 of 678 relevant lines covered (92.63%)

3.71 hits per line

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

90.3

/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):
                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
                queried_fields = list()
                for each in get_query_fields(args[0][3][0])[document_field_type._meta.name].keys():
                    item = to_snake_case(each)
                    if item in document._fields_ordered:
                        queried_fields.append(item)
                return document.objects().no_dereference().only(
                    *set(list(document_field_type._meta.required_fields) + queried_fields)).filter(pk__in=args[0][1])

            def get_non_querying_object(*args, **kwargs):
                model = get_document(args[0][0])
                return [model(pk=each) for each in args[0][1]]

            def reference_resolver(root, *args, **kwargs):
                to_resolve = getattr(root, field.name or field.db_name)
                if to_resolve:
                    choice_to_resolve = dict()
                    querying_union_types = list(get_query_fields(args[0]).keys())
                    if '__typename' in querying_union_types:
                        querying_union_types.remove('__typename')
                    to_resolve_models = list()
                    for each in querying_union_types:
                        to_resolve_models.append(registry._registry_string_map[each])
                    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():
                        if model in to_resolve_models:
                            futures.append(pool.submit(get_reference_objects, (model, object_id_list, registry, args)))
                        else:
                            futures.append(
                                pool.submit(get_non_querying_object, (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_object_ids = list()
                    for each in result:
                        result_object_ids.append(each.id)
                    ordered_result = list()
                    for each in to_resolve_object_ids:
                        ordered_result.append(result[result_object_ids.index(each)])
                    return ordered_result
                return None

            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):
        de_referenced = getattr(root, field.name or field.db_name)
        if de_referenced:
            document = get_document(de_referenced["_cls"])
            document_field = mongoengine.ReferenceField(document)
            document_field = convert_mongoengine_field(document_field, registry)
            _type = document_field.get_type().type
            querying_types = list(get_query_fields(args[0]).keys())
            _type = document_field.get_type().type
            if _type.__name__ in querying_types:
                queried_fields = list()
                for each in get_query_fields(args[0]).keys():
                    item = to_snake_case(each)
                    if item in document._fields_ordered:
                        queried_fields.append(item)
                return document.objects().no_dereference().only(*list(
                    set(list(_type._meta.required_fields) + queried_fields))).get(
                    pk=de_referenced["_ref"].id)
            return document
        return None

    if isinstance(field, mongoengine.GenericReferenceField):
        field_resolver = None
        required = False
        if field.db_field is not None:
            required = field.required
            resolver_function = getattr(_union, "resolve_" + field.db_field, None)
            if resolver_function and callable(resolver_function):
                field_resolver = resolver_function
        return graphene.Field(_union, resolver=field_resolver if field_resolver else reference_resolver,
                              description=get_field_description(field, registry), required=required)

    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:
            queried_fields = list()
            for each in get_query_fields(args[0]).keys():
                item = to_snake_case(each)
                if item in field.document_type._fields_ordered:
                    queried_fields.append(item)
            _type = registry.get_type_for_model(field.document_type)
            return field.document_type.objects().no_dereference().only(
                *(set(list(_type._meta.required_fields) + queried_fields))).get(
                pk=document.id)
        return None

    def cached_reference_resolver(root, *args, **kwargs):
        if field:
            queried_fields = list()
            for each in get_query_fields(args[0]).keys():
                item = to_snake_case(each)
                if item in field.document_type._fields_ordered:
                    queried_fields.append(item)
            _type = registry.get_type_for_model(field.document_type)
            return field.document_type.objects().no_dereference().only(
                *(set(
                    list(_type._meta.required_fields) + queried_fields))).get(
                pk=getattr(root, field.name or field.db_name))
        return None

    def dynamic_type():
        _type = registry.get_type_for_model(model)
        if not _type:
            return None
        if isinstance(field, mongoengine.EmbeddedDocumentField):
            return graphene.Field(_type,
                                  description=get_field_description(field, registry))
        field_resolver = None
        required = False
        if field.db_field is not None:
            required = field.required
            resolver_function = getattr(_type, "resolve_" + field.db_field, None)
            if resolver_function and callable(resolver_function):
                field_resolver = resolver_function
        if isinstance(field, mongoengine.ReferenceField):
            return graphene.Field(_type, resolver=field_resolver if field_resolver else reference_resolver,
                                  description=get_field_description(field, registry), required=required)
        else:
            return graphene.Field(_type, resolver=field_resolver if field_resolver else cached_reference_resolver,
                                  description=get_field_description(field, registry), required=required)

    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)
        if document:
            queried_fields = list()
            for each in get_query_fields(args[0]).keys():
                item = to_snake_case(each)
                if item in document.document_type._fields_ordered:
                    queried_fields.append(item)
            _type = registry.get_type_for_model(document.document_type)
            return document.document_type.objects().no_dereference().only(
                *(set((list(_type._meta.required_fields) + queried_fields)))).get(
                pk=document.pk)
        return None

    def dynamic_type():
        _type = registry.get_type_for_model(model)
        if not _type:
            return None
        field_resolver = None
        required = False
        if field.db_field is not None:
            required = field.required
            resolver_function = getattr(_type, "resolve_" + field.db_field, None)
            if resolver_function and callable(resolver_function):
                field_resolver = resolver_function
        return graphene.Field(
            _type,
            resolver=field_resolver if field_resolver else lazy_resolver,
            description=get_field_description(field, registry), required=required,
        )

    return graphene.Dynamic(dynamic_type)

1	import graphene	4✔
2	import mongoengine	4✔
3	import uuid	4✔
4
5	from graphene.types.json import JSONString	4✔
6	from graphene.utils.str_converters import to_snake_case	4✔
7	from mongoengine.base import get_document	4✔
8	from . import advanced_types	4✔
9	from .utils import import_single_dispatch, get_field_description, get_query_fields	4✔
10	from concurrent.futures import ThreadPoolExecutor, as_completed	4✔
11
12	singledispatch = import_single_dispatch()	4✔
13
14
15	class MongoEngineConversionError(Exception):	4✔
16	pass	4✔
17
18
19	@singledispatch	4✔
20	def convert_mongoengine_field(field, registry=None):	4✔
21	raise MongoEngineConversionError(	4✔
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)	4✔
28	@convert_mongoengine_field.register(mongoengine.StringField)	4✔
29	@convert_mongoengine_field.register(mongoengine.URLField)	4✔
30	def convert_field_to_string(field, registry=None):	4✔
31	return graphene.String(	4✔
32	description=get_field_description(field, registry), required=field.required
33	)
34
35
36	@convert_mongoengine_field.register(mongoengine.UUIDField)	4✔
37	@convert_mongoengine_field.register(mongoengine.ObjectIdField)	4✔
38	def convert_field_to_id(field, registry=None):	4✔
39	return graphene.ID(	4✔
40	description=get_field_description(field, registry), required=field.required
41	)
42
43
44	@convert_mongoengine_field.register(mongoengine.IntField)	4✔
45	@convert_mongoengine_field.register(mongoengine.LongField)	4✔
46	@convert_mongoengine_field.register(mongoengine.SequenceField)	4✔
47	def convert_field_to_int(field, registry=None):	4✔
48	return graphene.Int(	4✔
49	description=get_field_description(field, registry), required=field.required
50	)
51
52
53	@convert_mongoengine_field.register(mongoengine.BooleanField)	4✔
54	def convert_field_to_boolean(field, registry=None):	4✔
55	return graphene.Boolean(	4✔
56	description=get_field_description(field, registry), required=field.required
57	)
58
59
60	@convert_mongoengine_field.register(mongoengine.DecimalField)	4✔
61	@convert_mongoengine_field.register(mongoengine.FloatField)	4✔
62	def convert_field_to_float(field, registry=None):	4✔
63	return graphene.Float(	4✔
64	description=get_field_description(field, registry), required=field.required
65	)
66
67
68	@convert_mongoengine_field.register(mongoengine.DateTimeField)	4✔
69	def convert_field_to_datetime(field, registry=None):	4✔
70	return graphene.DateTime(	4✔
71	description=get_field_description(field, registry), required=field.required
72	)
73
74
75	@convert_mongoengine_field.register(mongoengine.DictField)	4✔
76	@convert_mongoengine_field.register(mongoengine.MapField)	4✔
77	def convert_field_to_jsonstring(field, registry=None):	4✔
78	return JSONString(	4✔
79	description=get_field_description(field, registry), required=field.required
80	)
81
82
83	@convert_mongoengine_field.register(mongoengine.PointField)	4✔
84	def convert_point_to_field(field, registry=None):	4✔
85	return graphene.Field(advanced_types.PointFieldType)	4✔
86
87
88	@convert_mongoengine_field.register(mongoengine.PolygonField)	4✔
89	def convert_polygon_to_field(field, registry=None):	4✔
90	return graphene.Field(advanced_types.PolygonFieldType)	4✔
91
92
93	@convert_mongoengine_field.register(mongoengine.MultiPolygonField)	4✔
94	def convert_multipolygon_to_field(field, register=None):	4✔
95	return graphene.Field(advanced_types.MultiPolygonFieldType)	4✔
96
97
98	@convert_mongoengine_field.register(mongoengine.FileField)	4✔
99	def convert_file_to_field(field, registry=None):	4✔
100	return graphene.Field(advanced_types.FileFieldType)	4✔
101
102
103	@convert_mongoengine_field.register(mongoengine.ListField)	4✔
104	@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentListField)	4✔
105	def convert_field_to_list(field, registry=None):	4✔
106	base_type = convert_mongoengine_field(field.field, registry=registry)	4✔
107	if isinstance(base_type, graphene.Field):	4✔
108	if isinstance(field.field, mongoengine.GenericReferenceField):	4✔
109	def get_reference_objects(args, *kwargs):	4✔
110	document = get_document(args[0][0])	4✔
111	document_field = mongoengine.ReferenceField(document)	4✔
112	document_field = convert_mongoengine_field(document_field, registry)	4✔
113	document_field_type = document_field.get_type().type	4✔
114	queried_fields = list()	4✔
115	for each in get_query_fields(args[0][3][0])[document_field_type._meta.name].keys():	4✔
116	item = to_snake_case(each)	4✔
117	if item in document._fields_ordered:	4✔
118	queried_fields.append(item)	4✔
119	return document.objects().no_dereference().only(	4✔
120	*set(list(document_field_type._meta.required_fields) + queried_fields)).filter(pk__in=args[0][1])
121
122	def get_non_querying_object(args, *kwargs):	4✔
123	model = get_document(args[0][0])	×
124	return [model(pk=each) for each in args[0][1]]	×
125
126	def reference_resolver(root, args, *kwargs):	4✔
127	to_resolve = getattr(root, field.name or field.db_name)	4✔
128	if to_resolve:	4✔
129	choice_to_resolve = dict()	4✔
130	querying_union_types = list(get_query_fields(args[0]).keys())	4✔
131	if '__typename' in querying_union_types:	4✔
132	querying_union_types.remove('__typename')	4✔
133	to_resolve_models = list()	4✔
134	for each in querying_union_types:	4✔
135	to_resolve_models.append(registry._registry_string_map[each])	4✔
136	for each in to_resolve:	4✔
137	if each['_cls'] not in choice_to_resolve:	4✔
138	choice_to_resolve[each['_cls']] = list()	4✔
139	choice_to_resolve[each['_cls']].append(each["_ref"].id)	4✔
140	pool = ThreadPoolExecutor(5)	4✔
141	futures = list()	4✔
142	for model, object_id_list in choice_to_resolve.items():	4✔
143	if model in to_resolve_models:	4✔
144	futures.append(pool.submit(get_reference_objects, (model, object_id_list, registry, args)))	4✔
145	else:
146	futures.append(	×
147	pool.submit(get_non_querying_object, (model, object_id_list, registry, args)))
148	result = list()	4✔
149	for x in as_completed(futures):	4✔
150	result += x.result()	4✔
151	to_resolve_object_ids = [each["_ref"].id for each in to_resolve]	4✔
152	result_object_ids = list()	4✔
153	for each in result:	4✔
154	result_object_ids.append(each.id)	4✔
155	ordered_result = list()	4✔
156	for each in to_resolve_object_ids:	4✔
157	ordered_result.append(result[result_object_ids.index(each)])	4✔
158	return ordered_result	4✔
159	return None	×
160
161	return graphene.List(	4✔
162	base_type._type,
163	description=get_field_description(field, registry),
164	required=field.required,
165	resolver=reference_resolver
166	)
167	return graphene.List(	×
168	base_type._type,
169	description=get_field_description(field, registry),
170	required=field.required
171	)
172	if isinstance(base_type, (graphene.Dynamic)):	4✔
173	base_type = base_type.get_type()	4✔
174	if base_type is None:	4✔
175	return	4✔
176	base_type = base_type._type	4✔
177
178	if graphene.is_node(base_type):	4✔
179	return base_type._meta.connection_field_class(base_type)	4✔
180
181	# Non-relationship field
182	relations = (mongoengine.ReferenceField, mongoengine.EmbeddedDocumentField)	4✔
183	if not isinstance(base_type, (graphene.List, graphene.NonNull)) and not isinstance(	4✔
184	field.field, relations
185	):
186	base_type = type(base_type)	4✔
187
188	return graphene.List(	4✔
189	base_type,
190	description=get_field_description(field, registry),
191	required=field.required,
192	)
193
194
195	@convert_mongoengine_field.register(mongoengine.GenericEmbeddedDocumentField)	4✔
196	@convert_mongoengine_field.register(mongoengine.GenericReferenceField)	4✔
197	def convert_field_to_union(field, registry=None):	4✔
198	_types = []	4✔
199	for choice in field.choices:	4✔
200	if isinstance(field, mongoengine.GenericReferenceField):	4✔
201	_field = mongoengine.ReferenceField(get_document(choice))	4✔
202	elif isinstance(field, mongoengine.GenericEmbeddedDocumentField):	4✔
203	_field = mongoengine.EmbeddedDocumentField(choice)	4✔
204
205	_field = convert_mongoengine_field(_field, registry)	4✔
206	_type = _field.get_type()	4✔
207	if _type:	4✔
208	_types.append(_type.type)	4✔
209	else:
210	# TODO: Register type auto-matically here.
211	pass	×
212
213	if len(_types) == 0:	4✔
214	return None	4✔
215
216	# XXX: Use uuid to avoid duplicate name
217	name = "{}_{}_union_{}".format(	4✔
218	field._owner_document.__name__,
219	field.db_field,
220	str(uuid.uuid1()).replace("-", ""),
221	)
222	Meta = type("Meta", (object,), {"types": tuple(_types)})	4✔
223	_union = type(name, (graphene.Union,), {"Meta": Meta})	4✔
224
225	def reference_resolver(root, args, *kwargs):	4✔
226	de_referenced = getattr(root, field.name or field.db_name)	4✔
227	if de_referenced:	4✔
228	document = get_document(de_referenced["_cls"])	4✔
229	document_field = mongoengine.ReferenceField(document)	4✔
230	document_field = convert_mongoengine_field(document_field, registry)	4✔
231	_type = document_field.get_type().type	4✔
232	querying_types = list(get_query_fields(args[0]).keys())	4✔
233	_type = document_field.get_type().type	4✔
234	if _type.__name__ in querying_types:	4✔
235	queried_fields = list()	4✔
236	for each in get_query_fields(args[0]).keys():	4✔
237	item = to_snake_case(each)	4✔
238	if item in document._fields_ordered:	4✔
239	queried_fields.append(item)	×
240	return document.objects().no_dereference().only(*list(	4✔
241	set(list(_type._meta.required_fields) + queried_fields))).get(
242	pk=de_referenced["_ref"].id)
243	return document	×
244	return None	×
245
246	if isinstance(field, mongoengine.GenericReferenceField):	4✔
247	field_resolver = None	4✔
248	required = False	4✔
249	if field.db_field is not None:	4✔
250	required = field.required	4✔
251	resolver_function = getattr(_union, "resolve_" + field.db_field, None)	4✔
252	if resolver_function and callable(resolver_function):	4✔
253	field_resolver = resolver_function	×
254	return graphene.Field(_union, resolver=field_resolver if field_resolver else reference_resolver,	4✔
255	description=get_field_description(field, registry), required=required)
256
257	return graphene.Field(_union)	4✔
258
259
260	@convert_mongoengine_field.register(mongoengine.EmbeddedDocumentField)	4✔
261	@convert_mongoengine_field.register(mongoengine.ReferenceField)	4✔
262	@convert_mongoengine_field.register(mongoengine.CachedReferenceField)	4✔
263	def convert_field_to_dynamic(field, registry=None):	4✔
264	model = field.document_type	4✔
265
266	def reference_resolver(root, args, *kwargs):	4✔
267	document = getattr(root, field.name or field.db_name)	4✔
268	if document:	4✔
269	queried_fields = list()	4✔
270	for each in get_query_fields(args[0]).keys():	4✔
271	item = to_snake_case(each)	4✔
272	if item in field.document_type._fields_ordered:	4✔
273	queried_fields.append(item)	4✔
274	_type = registry.get_type_for_model(field.document_type)	4✔
275	return field.document_type.objects().no_dereference().only(	4✔
276	*(set(list(_type._meta.required_fields) + queried_fields))).get(
277	pk=document.id)
278	return None	4✔
279
280	def cached_reference_resolver(root, args, *kwargs):	4✔
281	if field:	×
282	queried_fields = list()	×
283	for each in get_query_fields(args[0]).keys():	×
284	item = to_snake_case(each)	×
285	if item in field.document_type._fields_ordered:	×
286	queried_fields.append(item)	×
287	_type = registry.get_type_for_model(field.document_type)	×
288	return field.document_type.objects().no_dereference().only(	×
289	*(set(
290	list(_type._meta.required_fields) + queried_fields))).get(
291	pk=getattr(root, field.name or field.db_name))
292	return None	×
293
294	def dynamic_type():	4✔
295	_type = registry.get_type_for_model(model)	4✔
296	if not _type:	4✔
297	return None	4✔
298	if isinstance(field, mongoengine.EmbeddedDocumentField):	4✔
299	return graphene.Field(_type,	4✔
300	description=get_field_description(field, registry))
301	field_resolver = None	4✔
302	required = False	4✔
303	if field.db_field is not None:	4✔
304	required = field.required	4✔
305	resolver_function = getattr(_type, "resolve_" + field.db_field, None)	4✔
306	if resolver_function and callable(resolver_function):	4✔
307	field_resolver = resolver_function	×
308	if isinstance(field, mongoengine.ReferenceField):	4✔
309	return graphene.Field(_type, resolver=field_resolver if field_resolver else reference_resolver,	4✔
310	description=get_field_description(field, registry), required=required)
311	else:
312	return graphene.Field(_type, resolver=field_resolver if field_resolver else cached_reference_resolver,	×
313	description=get_field_description(field, registry), required=required)
314
315	return graphene.Dynamic(dynamic_type)	4✔
316
317
318	@convert_mongoengine_field.register(mongoengine.LazyReferenceField)	4✔
319	def convert_lazy_field_to_dynamic(field, registry=None):	4✔
320	model = field.document_type	4✔
321
322	def lazy_resolver(root, args, *kwargs):	4✔
323	document = getattr(root, field.name or field.db_name)	4✔
324	if document:	4✔
325	queried_fields = list()	4✔
326	for each in get_query_fields(args[0]).keys():	4✔
327	item = to_snake_case(each)	4✔
328	if item in document.document_type._fields_ordered:	4✔
329	queried_fields.append(item)	4✔
330	_type = registry.get_type_for_model(document.document_type)	4✔
331	return document.document_type.objects().no_dereference().only(	4✔
332	*(set((list(_type._meta.required_fields) + queried_fields)))).get(
333	pk=document.pk)
334	return None	×
335
336	def dynamic_type():	4✔
337	_type = registry.get_type_for_model(model)	4✔
338	if not _type:	4✔
339	return None	4✔
340	field_resolver = None	4✔
341	required = False	4✔
342	if field.db_field is not None:	4✔
343	required = field.required	4✔
344	resolver_function = getattr(_type, "resolve_" + field.db_field, None)	4✔
345	if resolver_function and callable(resolver_function):	4✔
346	field_resolver = resolver_function	×
347	return graphene.Field(	4✔
348	_type,
349	resolver=field_resolver if field_resolver else lazy_resolver,
350	description=get_field_description(field, registry), required=required,
351	)
352
353	return graphene.Dynamic(dynamic_type)	4✔

graphql-python / graphene-mongo / 431

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