graphql-python / graphene-mongo / 468

pending completion

Build # 468

Build Type

Pull #161

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/49480c50219f9293b3d75b6c3816f84afed2246f">49480c502<a href="https://github.com/graphql-python/graphene-mongo/commit/49480c50219f9293b3d75b6c3816f84afed2246f">&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/49480c50219f9293b3d75b6c3816f84afed2246f&quot;&gt;49480c502&lt;/a&gt;&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/49480c50219f9293b3d75b6c3816f84afed2246f&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/49480c50219f9293b3d75b6c3816f84a&lt;/a&gt;fed2246f&quot;&gt;&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/graphql-python/graphene-mongo/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/f9145b545542a0ac78e33b7dde5e5581fb42d3fc">f9145b545</a><a href="https://github.com/graphql-python/graphene-mongo/commit/49480c50219f9293b3d75b6c3816f84afed2246f">&amp;quot;&amp;gt;f9145b545&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;f9145b545&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/graphql-python/graphene-mongo/commit/49480c50219f9293b3d75b6c3816f84afed22&lt;/a&gt;46f&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/d1b8ace82">d1b8ace82">d1b8ace82</a>

Pull Request Pull Request #161: Feat support inputs and interfaces

Run Details

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

732 of 865 relevant lines covered (84.62%)

4.21 hits per line

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

93.7

/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.inputobjecttype import InputObjectType, InputObjectTypeOptions
from graphene.types.interface import Interface, InterfaceOptions
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, get_inputs_registry
from .utils import get_model_fields, is_valid_mongoengine_model, get_query_fields


def construct_fields(model, registry, only_fields, exclude_fields, non_required_fields):
    """
    Args:
        model (mongoengine.Document):
        registry (.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 required_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
        else:
            if name in non_required_fields and 'required' in converted.kwargs:
                converted.kwargs['required'] = False
        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


def create_graphene_generic_class(object_type, option_type):
    class MongoengineGenericObjectTypeOptions(option_type):

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

    class GrapheneMongoengineGenericType(object_type):
        @classmethod
        def __init_subclass_with_meta__(
            cls,
            model=None,
            registry=None,
            skip_registry=False,
            only_fields=(),
            required_fields=(),
            exclude_fields=(),
            non_required_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:
                # input objects shall be registred in a separated registry
                if issubclass(cls, InputObjectType):
                    registry = get_inputs_registry()
                else:
                    registry = get_global_registry()

            assert isinstance(registry, Registry), (
                "The attribute registry in {}.Meta needs to be an instance of "
                'Registry({}), received "{}".'
            ).format(object_type, cls.__name__, registry)
            converted_fields, self_referenced = construct_fields(
                model, registry, only_fields, exclude_fields, non_required_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, MongoengineGenericObjectTypeOptions), (
                    "_meta must be an instance of MongoengineGenericObjectTypeOptions, "
                    "received {}"
                ).format(_meta.__class__)
            else:
                _meta = MongoengineGenericObjectTypeOptions(option_type)

            _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.required_fields = required_fields
            _meta.exclude_fields = exclude_fields
            _meta.non_required_fields = non_required_fields
            _meta.order_by = order_by

            super(GrapheneMongoengineGenericType, 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,
                cls._meta.non_required_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):
            required_fields = list()
            for field in cls._meta.required_fields:
                if field in cls._meta.model._fields_ordered:
                    required_fields.append(field)
            for field in get_query_fields(info):
                if to_snake_case(field) in cls._meta.model._fields_ordered:
                    required_fields.append(to_snake_case(field))
            required_fields = list(set(required_fields))
            return cls._meta.model.objects.no_dereference().only(*required_fields).get(pk=id)

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

    return GrapheneMongoengineGenericType, MongoengineGenericObjectTypeOptions


MongoengineObjectType, MongoengineObjectTypeOptions = create_graphene_generic_class(ObjectType, ObjectTypeOptions)
MongoengineInterfaceType, MongoengineInterfaceTypeOptions = create_graphene_generic_class(Interface, InterfaceOptions)
MongoengineInputType, MongoengineInputTypeOptions = create_graphene_generic_class(InputObjectType, InputObjectTypeOptions)

GrapheneMongoengineObjectTypes = (MongoengineObjectType, MongoengineInputType, MongoengineInterfaceType)

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

graphql-python / graphene-mongo / 468

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