graphql-python / graphene-mongo / 396

pending completion

Build # 396

Build Type

Pull #156

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/graphql-python/graphene-mongo/commit/<a class=hub.com/graphql-python/graphene-mongo/commit/18c7332475d929e8db6177b84ad3e3edc18a0e71">18c733247<a href="https://github.com/graphql-python/graphene-mongo/commit/18c7332475d929e8db6177b84ad3e3edc18a0e71">">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/e85a612f11574dc509c4a3ae7abf221704790d3f">e85a612f1</a>">e85a612f1</a><a href="https://github.com/graphql-python/graphene-mongo/commit/18c7332475d929e8db6177b84ad3e3edc18a0e71"> into 7ca0925bd">7ca0925bd</a>

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

Run Details

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

569 of 596 relevant lines covered (95.47%)

2.85 hits per line

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

92.86

/graphene_mongo/types.py

import graphene
import mongoengine

from collections import OrderedDict
from graphene.relay import Connection, Node
from graphene.types.objecttype import ObjectType, ObjectTypeOptions
from graphene.types.utils import yank_fields_from_attrs
from graphene.utils.str_converters import to_snake_case

from graphene_mongo import MongoengineConnectionField
from .converter import convert_mongoengine_field
from .registry import Registry, get_global_registry
from .utils import get_model_fields, is_valid_mongoengine_model, get_query_fields


def construct_fields(model, registry, only_fields, exclude_fields):
    """
    Args:
        model (mongoengine.Document):
        registry (graphene_mongo.registry.Registry):
        only_fields ([str]):
        exclude_fields ([str]):

    Returns:
        (OrderedDict, OrderedDict): converted fields and self reference fields.

    """
    _model_fields = get_model_fields(model)
    fields = OrderedDict()
    self_referenced = OrderedDict()
    for name, field in _model_fields.items():
        is_not_in_only = only_fields and name not in only_fields
        is_excluded = name in exclude_fields
        if is_not_in_only or is_excluded:
            # We skip this field if we specify only_fields and is not
            # in there. Or when we exclude this field in exclude_fields
            continue
        if isinstance(field, mongoengine.ListField):
            if not field.field:
                continue
            # Take care of list of self-reference.
            document_type_obj = field.field.__dict__.get("document_type_obj", None)
            if (
                document_type_obj == model._class_name
                or isinstance(document_type_obj, model)
                or document_type_obj == model
            ):
                self_referenced[name] = field
                continue
        converted = convert_mongoengine_field(field, registry)
        if not converted:
            continue
        fields[name] = converted

    return fields, self_referenced


def construct_self_referenced_fields(self_referenced, registry):
    fields = OrderedDict()
    for name, field in self_referenced.items():
        converted = convert_mongoengine_field(field, registry)
        if not converted:
            continue
        fields[name] = converted

    return fields


class MongoengineObjectTypeOptions(ObjectTypeOptions):

    model = None
    registry = None  # type: Registry
    connection = None
    filter_fields = ()
    order_by = None


class MongoengineObjectType(ObjectType):
    @classmethod
    def __init_subclass_with_meta__(
        cls,
        model=None,
        registry=None,
        skip_registry=False,
        only_fields=(),
        exclude_fields=(),
        filter_fields=None,
        connection=None,
        connection_class=None,
        use_connection=None,
        connection_field_class=None,
        interfaces=(),
        _meta=None,
        order_by=None,
        **options
    ):

        assert is_valid_mongoengine_model(model), (
            "The attribute model in {}.Meta must be a valid Mongoengine Model. "
            'Received "{}" instead.'
        ).format(cls.__name__, type(model))

        if not registry:
            registry = get_global_registry()

        assert isinstance(registry, Registry), (
            "The attribute registry in {}.Meta needs to be an instance of "
            'Registry, received "{}".'
        ).format(cls.__name__, registry)
        converted_fields, self_referenced = construct_fields(
            model, registry, only_fields, exclude_fields
        )
        mongoengine_fields = yank_fields_from_attrs(
            converted_fields, _as=graphene.Field
        )
        if use_connection is None and interfaces:
            use_connection = any(
                (issubclass(interface, Node) for interface in interfaces)
            )

        if use_connection and not connection:
            # We create the connection automatically
            if not connection_class:
                connection_class = Connection

            connection = connection_class.create_type(
                "{}Connection".format(cls.__name__), node=cls
            )

        if connection is not None:
            assert issubclass(connection, Connection), (
                "The attribute connection in {}.Meta must be of type Connection. "
                'Received "{}" instead.'
            ).format(cls.__name__, type(connection))

        if connection_field_class is not None:
            assert issubclass(connection_field_class, graphene.ConnectionField), (
                "The attribute connection_field_class in {}.Meta must be of type graphene.ConnectionField. "
                'Received "{}" instead.'
            ).format(cls.__name__, type(connection_field_class))
        else:
            connection_field_class = MongoengineConnectionField

        if _meta:
            assert isinstance(_meta, MongoengineObjectTypeOptions), (
                "_meta must be an instance of MongoengineObjectTypeOptions, "
                "received {}"
            ).format(_meta.__class__)
        else:
            _meta = MongoengineObjectTypeOptions(cls)

        _meta.model = model
        _meta.registry = registry
        _meta.fields = mongoengine_fields
        _meta.filter_fields = filter_fields
        _meta.connection = connection
        _meta.connection_field_class = connection_field_class
        # Save them for later
        _meta.only_fields = only_fields
        _meta.exclude_fields = exclude_fields
        _meta.order_by = order_by

        super(MongoengineObjectType, cls).__init_subclass_with_meta__(
            _meta=_meta, interfaces=interfaces, **options
        )

        if not skip_registry:
            registry.register(cls)
            # Notes: Take care list of self-reference fields.
            converted_fields = construct_self_referenced_fields(
                self_referenced, registry
            )
            if converted_fields:
                mongoengine_fields = yank_fields_from_attrs(
                    converted_fields, _as=graphene.Field
                )
                cls._meta.fields.update(mongoengine_fields)
                registry.register(cls)

    @classmethod
    def rescan_fields(cls):
        """Attempts to rescan fields and will insert any not converted initially"""

        converted_fields, self_referenced = construct_fields(
            cls._meta.model,
            cls._meta.registry,
            cls._meta.only_fields,
            cls._meta.exclude_fields,
        )

        mongoengine_fields = yank_fields_from_attrs(
            converted_fields, _as=graphene.Field
        )

        # The initial scan should take precedence
        for field in mongoengine_fields:
            if field not in cls._meta.fields:
                cls._meta.fields.update({field: mongoengine_fields[field]})
        # Self-referenced fields can't change between scans!

    @classmethod
    def is_type_of(cls, root, info):
        if isinstance(root, cls):
            return True
        # XXX: Take care FileField
        if isinstance(root, mongoengine.GridFSProxy):
            return True
        if not is_valid_mongoengine_model(type(root)):
            raise Exception(('Received incompatible instance "{}".').format(root))
        return isinstance(root, cls._meta.model)

    @classmethod
    def get_node(cls, info, id):
        only_fields = list()
        for field in cls._meta.only_fields:
            if field in cls._meta.model._fields_ordered:
                only_fields.append(field)
        for field in get_query_fields(info):
            if to_snake_case(field) in cls._meta.model._fields_ordered:
                only_fields.append(to_snake_case(field))
        only_fields = list(set(only_fields))
        return cls._meta.model.objects.no_dereference().only(*only_fields).get(pk=id)

    def resolve_id(self, info):
        return str(self.id)

1	import graphene	3✔
2	import mongoengine	3✔
3
4	from collections import OrderedDict	3✔
5	from graphene.relay import Connection, Node	3✔
6	from graphene.types.objecttype import ObjectType, ObjectTypeOptions	3✔
7	from graphene.types.utils import yank_fields_from_attrs	3✔
8	from graphene.utils.str_converters import to_snake_case	3✔
9
10	from graphene_mongo import MongoengineConnectionField	3✔
11	from .converter import convert_mongoengine_field	3✔
12	from .registry import Registry, get_global_registry	3✔
13	from .utils import get_model_fields, is_valid_mongoengine_model, get_query_fields	3✔
14
15
16	def construct_fields(model, registry, only_fields, exclude_fields):	3✔
17	"""
18	Args:
19	model (mongoengine.Document):
20	registry (graphene_mongo.registry.Registry):
21	only_fields ([str]):
22	exclude_fields ([str]):
23
24	Returns:
25	(OrderedDict, OrderedDict): converted fields and self reference fields.
26
27	"""
28	_model_fields = get_model_fields(model)	3✔
29	fields = OrderedDict()	3✔
30	self_referenced = OrderedDict()	3✔
31	for name, field in _model_fields.items():	3✔
32	is_not_in_only = only_fields and name not in only_fields	3✔
33	is_excluded = name in exclude_fields	3✔
34	if is_not_in_only or is_excluded:	3✔
35	# We skip this field if we specify only_fields and is not
36	# in there. Or when we exclude this field in exclude_fields
37	continue	3✔
38	if isinstance(field, mongoengine.ListField):	3✔
39	if not field.field:	3✔
40	continue	×
41	# Take care of list of self-reference.
42	document_type_obj = field.field.__dict__.get("document_type_obj", None)	3✔
43	if (	3✔
44	document_type_obj == model._class_name
45	or isinstance(document_type_obj, model)
46	or document_type_obj == model
47	):
48	self_referenced[name] = field	3✔
49	continue	3✔
50	converted = convert_mongoengine_field(field, registry)	3✔
51	if not converted:	3✔
52	continue	3✔
53	fields[name] = converted	3✔
54
55	return fields, self_referenced	3✔
56
57
58	def construct_self_referenced_fields(self_referenced, registry):	3✔
59	fields = OrderedDict()	3✔
60	for name, field in self_referenced.items():	3✔
61	converted = convert_mongoengine_field(field, registry)	3✔
62	if not converted:	3✔
63	continue	×
64	fields[name] = converted	3✔
65
66	return fields	3✔
67
68
69	class MongoengineObjectTypeOptions(ObjectTypeOptions):	3✔
70
71	model = None	3✔
72	registry = None # type: Registry	3✔
73	connection = None	3✔
74	filter_fields = ()	3✔
75	order_by = None	3✔
76
77
78	class MongoengineObjectType(ObjectType):	3✔
79	@classmethod	3✔
80	def __init_subclass_with_meta__(	3✔
81	cls,
82	model=None,
83	registry=None,
84	skip_registry=False,
85	only_fields=(),
86	exclude_fields=(),
87	filter_fields=None,
88	connection=None,
89	connection_class=None,
90	use_connection=None,
91	connection_field_class=None,
92	interfaces=(),
93	_meta=None,
94	order_by=None,
95	**options
96	):
97
98	assert is_valid_mongoengine_model(model), (	3✔
99	"The attribute model in {}.Meta must be a valid Mongoengine Model. "
100	'Received "{}" instead.'
101	).format(cls.__name__, type(model))
102
103	if not registry:	3✔
104	registry = get_global_registry()	3✔
105
106	assert isinstance(registry, Registry), (	3✔
107	"The attribute registry in {}.Meta needs to be an instance of "
108	'Registry, received "{}".'
109	).format(cls.__name__, registry)
110	converted_fields, self_referenced = construct_fields(	3✔
111	model, registry, only_fields, exclude_fields
112	)
113	mongoengine_fields = yank_fields_from_attrs(	3✔
114	converted_fields, _as=graphene.Field
115	)
116	if use_connection is None and interfaces:	3✔
117	use_connection = any(	3✔
118	(issubclass(interface, Node) for interface in interfaces)
119	)
120
121	if use_connection and not connection:	3✔
122	# We create the connection automatically
123	if not connection_class:	3✔
124	connection_class = Connection	3✔
125
126	connection = connection_class.create_type(	3✔
127	"{}Connection".format(cls.__name__), node=cls
128	)
129
130	if connection is not None:	3✔
131	assert issubclass(connection, Connection), (	3✔
132	"The attribute connection in {}.Meta must be of type Connection. "
133	'Received "{}" instead.'
134	).format(cls.__name__, type(connection))
135
136	if connection_field_class is not None:	3✔
137	assert issubclass(connection_field_class, graphene.ConnectionField), (	×
138	"The attribute connection_field_class in {}.Meta must be of type graphene.ConnectionField. "
139	'Received "{}" instead.'
140	).format(cls.__name__, type(connection_field_class))
141	else:
142	connection_field_class = MongoengineConnectionField	3✔
143
144	if _meta:	3✔
145	assert isinstance(_meta, MongoengineObjectTypeOptions), (	3✔
146	"_meta must be an instance of MongoengineObjectTypeOptions, "
147	"received {}"
148	).format(_meta.__class__)
149	else:
150	_meta = MongoengineObjectTypeOptions(cls)	3✔
151
152	_meta.model = model	3✔
153	_meta.registry = registry	3✔
154	_meta.fields = mongoengine_fields	3✔
155	_meta.filter_fields = filter_fields	3✔
156	_meta.connection = connection	3✔
157	_meta.connection_field_class = connection_field_class	3✔
158	# Save them for later
159	_meta.only_fields = only_fields	3✔
160	_meta.exclude_fields = exclude_fields	3✔
161	_meta.order_by = order_by	3✔
162
163	super(MongoengineObjectType, cls).__init_subclass_with_meta__(	3✔
164	_meta=_meta, interfaces=interfaces, **options
165	)
166
167	if not skip_registry:	3✔
168	registry.register(cls)	3✔
169	# Notes: Take care list of self-reference fields.
170	converted_fields = construct_self_referenced_fields(	3✔
171	self_referenced, registry
172	)
173	if converted_fields:	3✔
174	mongoengine_fields = yank_fields_from_attrs(	3✔
175	converted_fields, _as=graphene.Field
176	)
177	cls._meta.fields.update(mongoengine_fields)	3✔
178	registry.register(cls)	3✔
179
180	@classmethod	3✔
181	def rescan_fields(cls):
182	"""Attempts to rescan fields and will insert any not converted initially"""
183
184	converted_fields, self_referenced = construct_fields(	3✔
185	cls._meta.model,
186	cls._meta.registry,
187	cls._meta.only_fields,
188	cls._meta.exclude_fields,
189	)
190
191	mongoengine_fields = yank_fields_from_attrs(	3✔
192	converted_fields, _as=graphene.Field
193	)
194
195	# The initial scan should take precedence
196	for field in mongoengine_fields:	3✔
197	if field not in cls._meta.fields:	3✔
198	cls._meta.fields.update({field: mongoengine_fields[field]})	3✔
199	# Self-referenced fields can't change between scans!
200
201	@classmethod	3✔
202	def is_type_of(cls, root, info):
203	if isinstance(root, cls):	3✔
204	return True	×
205	# XXX: Take care FileField
206	if isinstance(root, mongoengine.GridFSProxy):	3✔
207	return True	×
208	if not is_valid_mongoengine_model(type(root)):	3✔
209	raise Exception(('Received incompatible instance "{}".').format(root))	×
210	return isinstance(root, cls._meta.model)	3✔
211
212	@classmethod	3✔
213	def get_node(cls, info, id):
214	only_fields = list()	3✔
215	for field in cls._meta.only_fields:	3✔
216	if field in cls._meta.model._fields_ordered:	×
217	only_fields.append(field)	×
218	for field in get_query_fields(info):	3✔
219	if to_snake_case(field) in cls._meta.model._fields_ordered:	3✔
220	only_fields.append(to_snake_case(field))	3✔
221	only_fields = list(set(only_fields))	3✔
222	return cls._meta.model.objects.no_dereference().only(*only_fields).get(pk=id)	3✔
223
224	def resolve_id(self, info):	3✔
225	return str(self.id)	3✔

graphql-python / graphene-mongo / 396

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