graphql-python / graphene-mongo / 491

pending completion

Build # 491

Build Type

Pull #172

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/graphql-python/graphene-mongo/commit/<a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/1cb2d222deaf03af6e67b8569e428b8f8e430c15">1cb2d222d">&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/</a><a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/graphql-python/graphene-mongo/commit/1cb2d222deaf03af6e67b8569e428b8f8e430c15">1cb2d222d</a><a href="https://github.com/graphql-python/graphene-mongo/commit/1cb2d222deaf03af6e67b8569e428b8f8e430c15">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/graphql-python/graphene-mongo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/graphql-python/graphene-mongo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/graphql-python/graphene-mongo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/graphql-python/graphene-mongo/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/graphql-python/graphene-mongo/commit/1cb2d222deaf03af6e67b8569e428b8f8e430c15&quot;&gt;1cb2d222d&lt;/a&gt;&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/1cb2d222deaf03af6e67b8569e428b8f8e430c15&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #172: Support graphene v3

Run Details

60 of 60 new or added lines in 5 files covered. (100.0%)

780 of 964 relevant lines covered (80.91%)

1.62 hits per line

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

76.39

/graphene_mongo/converter.py

import sys

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, description=get_field_description(field, registry),
                          required=field.required)


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


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


@convert_mongoengine_field.register(mongoengine.FileField)
def convert_file_to_field(field, registry=None):
    return graphene.Field(advanced_types.FileFieldType, description=get_field_description(field, registry),
                          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)


if sys.version_info > (3, 5):
    @convert_mongoengine_field.register(mongoengine.EnumField)
    def convert_field_to_enum(field, registry=None):
        if not registry.check_enum_already_exist(field._enum_cls):
            registry.register_enum(field._enum_cls)
        _type = registry.get_type_for_enum(field._enum_cls)
        return graphene.Field(_type,
                              description=get_field_description(field, registry), required=field.required)

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

graphql-python / graphene-mongo / 491

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