graphql-python / graphene-mongo / 425

pending completion

Build # 425

Build Type

Pull #160

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/3906d58769f36864f93d300f471ca5ae450f4459">3906d5876<a href="https://github.com/graphql-python/graphene-mongo/commit/3906d58769f36864f93d300f471ca5ae450f4459">">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/ed4b1a171187b0acb739cff56fb4f90f17fc31c0">ed4b1a171</a>">ed4b1a171</a><a href="https://github.com/graphql-python/graphene-mongo/commit/3906d58769f36864f93d300f471ca5ae450f4459"> into 5d0813372">5d0813372</a>

Pull Request Pull Request #160: Feat retrieving queried fields only - Improvements & Bug fix to #156 pull request

Run Details

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

608 of 652 relevant lines covered (93.25%)

3.73 hits per line

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

92.92

/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 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
        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=(),
        required_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.required_fields = required_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):
        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)

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

graphql-python / graphene-mongo / 425

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