graphql-python / graphene-mongo / 462

pending completion

Build # 462

Build Type

Pull #166

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/146867146761288a49185c8e96599ebcf7e9b814">146867146<a href="https://github.com/graphql-python/graphene-mongo/commit/146867146761288a49185c8e96599ebcf7e9b814">">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/5db17de11f87b6791a152f928429c42ab89cf9d3">5db17de11</a>">5db17de11</a><a href="https://github.com/graphql-python/graphene-mongo/commit/146867146761288a49185c8e96599ebcf7e9b814"> into 9c2f8a8df">9c2f8a8df</a>

Pull Request Pull Request #166: Support point field in args

Run Details

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

726 of 882 relevant lines covered (82.31%)

4.1 hits per line

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

77.1

/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, LazyReference
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, required=field.required)


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


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


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


@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()
                filter_args = list()
                if document_field_type._meta.filter_fields:
                    for key, values in document_field_type._meta.filter_fields.items():
                        for each in values:
                            filter_args.append(key + "__" + each)
                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 + tuple(filter_args):
                        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])
                    to_resolve_object_ids = list()
                    for each in to_resolve:
                        if isinstance(each, LazyReference):
                            to_resolve_object_ids.append(each.pk)
                            model = each.document_type._class_name
                            if model not in choice_to_resolve:
                                choice_to_resolve[model] = list()
                            choice_to_resolve[model].append(each.pk)
                        else:
                            to_resolve_object_ids.append(each["_ref"].id)
                            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()
                    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
            filter_args = list()
            if _type._meta.filter_fields:
                for key, values in _type._meta.filter_fields.items():
                    for each in values:
                        filter_args.append(key + "__" + each)
            querying_types = list(get_query_fields(args[0]).keys())
            if _type.__name__ in querying_types:
                queried_fields = list()
                for each in get_query_fields(args[0])[_type._meta.name].keys():
                    item = to_snake_case(each)
                    if item in document._fields_ordered + tuple(filter_args):
                        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

    def lazy_reference_resolver(root, *args, **kwargs):
        document = getattr(root, field.name or field.db_name)
        if document:
            queried_fields = list()
            document_field_type = registry.get_type_for_model(document.document_type)
            querying_types = list(get_query_fields(args[0]).keys())
            filter_args = list()
            if document_field_type._meta.filter_fields:
                for key, values in document_field_type._meta.filter_fields.items():
                    for each in values:
                        filter_args.append(key + "__" + each)
            if document_field_type._meta.name in querying_types:
                for each in get_query_fields(args[0])[document_field_type._meta.name].keys():
                    item = to_snake_case(each)
                    if item in document.document_type._fields_ordered + tuple(filter_args):
                        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 document.document_type()
        return None

    if isinstance(field, mongoengine.GenericLazyReferenceField):
        field_resolver = None
        required = False
        if field.db_field is not None:
            required = field.required
            resolver_function = getattr(registry.get_type_for_model(field.owner_document), "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 lazy_reference_resolver,
                              description=get_field_description(field, registry), required=required)

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

graphql-python / graphene-mongo / 462

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