graphql-python / graphene-mongo / 412

pending completion

Build # 412

Build Type

Pull #158

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/a3b6d5af5d05074d131d6e4aa5c0377f48ad5d62">a3b6d5af5">&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/a3b6d5af5d05074d131d6e4aa5c0377f48ad5d62">a3b6d5af5</a><a href="https://github.com/graphql-python/graphene-mongo/commit/a3b6d5af5d05074d131d6e4aa5c0377f48ad5d62">&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/a3b6d5af5d05074d131d6e4aa5c0377f48ad5d62&quot;&gt;a3b6d5af5&lt;/a&gt;&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/a3b6d5af5d05074d131d6e4aa5c0377f48ad5d62&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/graphql-python/graphene-mongo/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; hr... (continued)

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

Run Details

600 of 600 new or added lines in 7 files covered. (100.0%)

580 of 616 relevant lines covered (94.16%)

4.68 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	5✔
2	import mongoengine	5✔
3
4	from collections import OrderedDict	5✔
5	from graphene.relay import Connection, Node	5✔
6	from graphene.types.objecttype import ObjectType, ObjectTypeOptions	5✔
7	from graphene.types.utils import yank_fields_from_attrs	5✔
8	from graphene.utils.str_converters import to_snake_case	5✔
9
10	from graphene_mongo import MongoengineConnectionField	5✔
11	from .converter import convert_mongoengine_field	5✔
12	from .registry import Registry, get_global_registry	5✔
13	from .utils import get_model_fields, is_valid_mongoengine_model, get_query_fields	5✔
14
15
16	def construct_fields(model, registry, only_fields, exclude_fields):	5✔
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)	5✔
29	fields = OrderedDict()	5✔
30	self_referenced = OrderedDict()	5✔
31	for name, field in _model_fields.items():	5✔
32	is_not_in_only = only_fields and name not in only_fields	5✔
33	is_excluded = name in exclude_fields	5✔
34	if is_not_in_only or is_excluded:	5✔
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	5✔
38	if isinstance(field, mongoengine.ListField):	5✔
39	if not field.field:	5✔
40	continue	×
41	# Take care of list of self-reference.
42	document_type_obj = field.field.__dict__.get("document_type_obj", None)	5✔
43	if (	5✔
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	5✔
49	continue	5✔
50	converted = convert_mongoengine_field(field, registry)	5✔
51	if not converted:	5✔
52	continue	5✔
53	fields[name] = converted	5✔
54
55	return fields, self_referenced	5✔
56
57
58	def construct_self_referenced_fields(self_referenced, registry):	5✔
59	fields = OrderedDict()	5✔
60	for name, field in self_referenced.items():	5✔
61	converted = convert_mongoengine_field(field, registry)	5✔
62	if not converted:	5✔
63	continue	×
64	fields[name] = converted	5✔
65
66	return fields	5✔
67
68
69	class MongoengineObjectTypeOptions(ObjectTypeOptions):	5✔
70
71	model = None	5✔
72	registry = None # type: Registry	5✔
73	connection = None	5✔
74	filter_fields = ()	5✔
75	order_by = None	5✔
76
77
78	class MongoengineObjectType(ObjectType):	5✔
79	@classmethod	5✔
80	def __init_subclass_with_meta__(	5✔
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), (	5✔
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:	5✔
104	registry = get_global_registry()	5✔
105
106	assert isinstance(registry, Registry), (	5✔
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(	5✔
111	model, registry, only_fields, exclude_fields
112	)
113	mongoengine_fields = yank_fields_from_attrs(	5✔
114	converted_fields, _as=graphene.Field
115	)
116	if use_connection is None and interfaces:	5✔
117	use_connection = any(	5✔
118	(issubclass(interface, Node) for interface in interfaces)
119	)
120
121	if use_connection and not connection:	5✔
122	# We create the connection automatically
123	if not connection_class:	5✔
124	connection_class = Connection	5✔
125
126	connection = connection_class.create_type(	5✔
127	"{}Connection".format(cls.__name__), node=cls
128	)
129
130	if connection is not None:	5✔
131	assert issubclass(connection, Connection), (	5✔
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:	5✔
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	5✔
143
144	if _meta:	5✔
145	assert isinstance(_meta, MongoengineObjectTypeOptions), (	5✔
146	"_meta must be an instance of MongoengineObjectTypeOptions, "
147	"received {}"
148	).format(_meta.__class__)
149	else:
150	_meta = MongoengineObjectTypeOptions(cls)	5✔
151
152	_meta.model = model	5✔
153	_meta.registry = registry	5✔
154	_meta.fields = mongoengine_fields	5✔
155	_meta.filter_fields = filter_fields	5✔
156	_meta.connection = connection	5✔
157	_meta.connection_field_class = connection_field_class	5✔
158	# Save them for later
159	_meta.only_fields = only_fields	5✔
160	_meta.exclude_fields = exclude_fields	5✔
161	_meta.order_by = order_by	5✔
162
163	super(MongoengineObjectType, cls).__init_subclass_with_meta__(	5✔
164	_meta=_meta, interfaces=interfaces, **options
165	)
166
167	if not skip_registry:	5✔
168	registry.register(cls)	5✔
169	# Notes: Take care list of self-reference fields.
170	converted_fields = construct_self_referenced_fields(	5✔
171	self_referenced, registry
172	)
173	if converted_fields:	5✔
174	mongoengine_fields = yank_fields_from_attrs(	5✔
175	converted_fields, _as=graphene.Field
176	)
177	cls._meta.fields.update(mongoengine_fields)	5✔
178	registry.register(cls)	5✔
179
180	@classmethod	5✔
181	def rescan_fields(cls):	1✔
182	"""Attempts to rescan fields and will insert any not converted initially"""
183
184	converted_fields, self_referenced = construct_fields(	5✔
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(	5✔
192	converted_fields, _as=graphene.Field
193	)
194
195	# The initial scan should take precedence
196	for field in mongoengine_fields:	5✔
197	if field not in cls._meta.fields:	5✔
198	cls._meta.fields.update({field: mongoengine_fields[field]})	5✔
199	# Self-referenced fields can't change between scans!
200
201	@classmethod	5✔
202	def is_type_of(cls, root, info):	1✔
203	if isinstance(root, cls):	5✔
204	return True	×
205	# XXX: Take care FileField
206	if isinstance(root, mongoengine.GridFSProxy):	5✔
207	return True	×
208	if not is_valid_mongoengine_model(type(root)):	5✔
209	raise Exception(('Received incompatible instance "{}".').format(root))	×
210	return isinstance(root, cls._meta.model)	5✔
211
212	@classmethod	5✔
213	def get_node(cls, info, id):	1✔
214	only_fields = list()	5✔
215	for field in cls._meta.only_fields:	5✔
216	if field in cls._meta.model._fields_ordered:	×
217	only_fields.append(field)	×
218	for field in get_query_fields(info):	5✔
219	if to_snake_case(field) in cls._meta.model._fields_ordered:	5✔
220	only_fields.append(to_snake_case(field))	5✔
221	only_fields = list(set(only_fields))	5✔
222	return cls._meta.model.objects.no_dereference().only(*only_fields).get(pk=id)	5✔
223
224	def resolve_id(self, info):	5✔
225	return str(self.id)	5✔

graphql-python / graphene-mongo / 412

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