graphql-python / graphene-mongo / 483

pending completion

Build # 483

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/3f2c4c821340793173645776e22974957e6b22ca">3f2c4c821">&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/3f2c4c821340793173645776e22974957e6b22ca">3f2c4c821</a><a href="https://github.com/graphql-python/graphene-mongo/commit/3f2c4c821340793173645776e22974957e6b22ca">&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/&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/3f2c4c821340793173645776e22974957e6b22ca&quot;&gt;3f2c4c821&lt;/a&gt;&lt;a href=&quot;https... (continued)

Pull Request Pull Request #172: Support graphene v3

Run Details

54 of 54 new or added lines in 3 files covered. (100.0%)

773 of 951 relevant lines covered (81.28%)

1.63 hits per line

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

75.18

/graphene_mongo/utils.py

from __future__ import unicode_literals

import inspect
from collections import OrderedDict

import mongoengine
from graphene import Node
from graphene.utils.trim_docstring import trim_docstring
# from graphql.utils.ast_to_dict import ast_to_dict
from graphql import FieldNode
from graphql_relay.connection.arrayconnection import offset_to_cursor


def get_model_fields(model, excluding=None):
    excluding = excluding or []
    attributes = dict()
    for attr_name, attr in model._fields.items():
        if attr_name in excluding:
            continue
        attributes[attr_name] = attr
    return OrderedDict(sorted(attributes.items()))


def get_model_reference_fields(model, excluding=None):
    excluding = excluding or []
    attributes = dict()
    for attr_name, attr in model._fields.items():
        if attr_name in excluding or not isinstance(
                attr,
                (mongoengine.fields.ReferenceField, mongoengine.fields.LazyReferenceField),
        ):
            continue
        attributes[attr_name] = attr
    return attributes


def is_valid_mongoengine_model(model):
    return inspect.isclass(model) and (
            issubclass(model, mongoengine.Document)
            or issubclass(model, mongoengine.EmbeddedDocument)
    )


def import_single_dispatch():
    try:
        from functools import singledispatch
    except ImportError:
        singledispatch = None

    if not singledispatch:
        try:
            from singledispatch import singledispatch
        except ImportError:
            pass

    if not singledispatch:
        raise Exception(
            "It seems your python version does not include "
            "functools.singledispatch. Please install the 'singledispatch' "
            "package. More information here: "
            "https://pypi.python.org/pypi/singledispatch"
        )

    return singledispatch


# noqa
def get_type_for_document(schema, document):
    types = schema.types.values()
    for _type in types:
        type_document = hasattr(_type, "_meta") and getattr(
            _type._meta, "document", None
        )
        if document == type_document:
            return _type


def get_field_description(field, registry=None):
    """
    Common metadata includes verbose_name and help_text.

    http://docs.mongoengine.org/apireference.html#fields
    """
    parts = []
    if hasattr(field, "document_type"):
        doc = trim_docstring(field.document_type.__doc__)
        if doc:
            parts.append(doc)
    if hasattr(field, "verbose_name"):
        parts.append(field.verbose_name.title())
    if hasattr(field, "help_text"):
        parts.append(field.help_text)
    if field.db_field != field.name:
        name_format = "(%s)" if parts else "%s"
        parts.append(name_format % field.db_field)

    return "\n".join(parts)


def get_node_from_global_id(node, info, global_id):
    try:
        for interface in node._meta.interfaces:
            if issubclass(interface, Node):
                return interface.get_node_from_global_id(info, global_id)
    except AttributeError:
        return Node.get_node_from_global_id(info, global_id)


def collect_query_fields(node, fragments):
    """Recursively collects fields from the AST

    Args:
        node (dict): A node in the AST
        fragments (dict): Fragment definitions

    Returns:
        A dict mapping each field found, along with their sub fields.
        {
            'name': {},
            'image': {
                        'id': {},
                        'name': {},
                        'description': {}
                    },
            'slug': {}
        }
    """

    field = {}
    selection_set = None
    if type(node) == dict:
        selection_set = node.get('selection_set')
    else:
        selection_set = node.selection_set
    if selection_set:
        for leaf in selection_set.selections:
            if leaf.kind == 'field':
                field.update({
                    leaf.name.value: collect_query_fields(leaf, fragments)
                })
            elif leaf.kind == 'fragment_spread':
                field.update(collect_query_fields(fragments[leaf['name']['value']],
                                                  fragments))
            elif leaf.kind == 'inline_fragment':
                field.update({
                    leaf.type_condition.name.value: collect_query_fields(leaf, fragments)
                })

    return field


def get_query_fields(info):
    """A convenience function to call collect_query_fields with info

    Args:
        info (ResolveInfo)

    Returns:
        dict: Returned from collect_query_fields
    """

    fragments = {}
    node = ast_to_dict(info.field_nodes[0])

    for name, value in info.fragments.items():
        fragments[name] = ast_to_dict(value)

    query = collect_query_fields(node, fragments)
    if "edges" in query:
        return query["edges"]["node"].keys()
    return query


def ast_to_dict(node, include_loc=False):
    if isinstance(node, FieldNode):
        d = {"kind": node.__class__.__name__}
        if hasattr(node, "keys"):
            for field in node.keys:
                d[field] = ast_to_dict(getattr(node, field), include_loc)

        if include_loc and hasattr(node, "loc") and node.loc:
            d["loc"] = {"start": node.loc.start, "end": node.loc.end}

        return d

    elif isinstance(node, list):
        return [ast_to_dict(item, include_loc) for item in node]

    return node


def find_skip_and_limit(first, last, after, before, count):
    reverse = False
    skip = 0
    limit = None
    if first is not None and after is not None:
        skip = after + 1
        limit = first
    elif first is not None and before is not None:
        if first >= before:
            limit = before - 1
        else:
            limit = first
    elif first is not None:
        skip = 0
        limit = first
    elif last is not None and before is not None:
        reverse = False
        if last >= before:
            limit = before
        else:
            limit = last
            skip = before - last
    elif last is not None and after is not None:
        reverse = True
        if last + after < count:
            limit = last
        else:
            limit = count - after - 1
    elif last is not None:
        skip = 0
        limit = last
        reverse = True
    elif after is not None:
        skip = after + 1
    elif before is not None:
        limit = before
    return skip, limit, reverse


def connection_from_iterables(edges, start_offset, has_previous_page, has_next_page, connection_type,
                              edge_type,
                              pageinfo_type):
    edges_items = [
        edge_type(
            node=node,
            cursor=offset_to_cursor((0 if start_offset is None else start_offset) + i)
        )
        for i, node in enumerate(edges)
    ]

    first_edge_cursor = edges_items[0].cursor if edges_items else None
    last_edge_cursor = edges_items[-1].cursor if edges_items else None

    return connection_type(
        edges=edges_items,
        page_info=pageinfo_type(
            start_cursor=first_edge_cursor,
            end_cursor=last_edge_cursor,
            has_previous_page=has_previous_page,
            has_next_page=has_next_page
        )
    )

1	from __future__ import unicode_literals	2✔
2
3	import inspect	2✔
4	from collections import OrderedDict	2✔
5
6	import mongoengine	2✔
7	from graphene import Node	2✔
8	from graphene.utils.trim_docstring import trim_docstring	2✔
9	# from graphql.utils.ast_to_dict import ast_to_dict
10	from graphql import FieldNode	2✔
11	from graphql_relay.connection.arrayconnection import offset_to_cursor	2✔
12
13
14	def get_model_fields(model, excluding=None):	2✔
15	excluding = excluding or []	2✔
16	attributes = dict()	2✔
17	for attr_name, attr in model._fields.items():	2✔
18	if attr_name in excluding:	2✔
19	continue	2✔
20	attributes[attr_name] = attr	2✔
21	return OrderedDict(sorted(attributes.items()))	2✔
22
23
24	def get_model_reference_fields(model, excluding=None):	2✔
25	excluding = excluding or []	2✔
26	attributes = dict()	2✔
27	for attr_name, attr in model._fields.items():	2✔
28	if attr_name in excluding or not isinstance(	2✔
29	attr,
30	(mongoengine.fields.ReferenceField, mongoengine.fields.LazyReferenceField),
31	):
32	continue	2✔
33	attributes[attr_name] = attr	2✔
34	return attributes	2✔
35
36
37	def is_valid_mongoengine_model(model):	2✔
38	return inspect.isclass(model) and (	2✔
39	issubclass(model, mongoengine.Document)
40	or issubclass(model, mongoengine.EmbeddedDocument)
41	)
42
43
44	def import_single_dispatch():	2✔
45	try:	2✔
46	from functools import singledispatch	2✔
47	except ImportError:	×
48	singledispatch = None	×
49
50	if not singledispatch:	2✔
51	try:	×
52	from singledispatch import singledispatch	×
53	except ImportError:	×
54	pass	×
55
56	if not singledispatch:	2✔
57	raise Exception(	×
58	"It seems your python version does not include "
59	"functools.singledispatch. Please install the 'singledispatch' "
60	"package. More information here: "
61	"https://pypi.python.org/pypi/singledispatch"
62	)
63
64	return singledispatch	2✔
65
66
67	# noqa
68	def get_type_for_document(schema, document):	2✔
69	types = schema.types.values()	×
70	for _type in types:	×
71	type_document = hasattr(_type, "_meta") and getattr(	×
72	_type._meta, "document", None
73	)
74	if document == type_document:	×
75	return _type	×
76
77
78	def get_field_description(field, registry=None):	2✔
79	"""
80	Common metadata includes verbose_name and help_text.
81
82	http://docs.mongoengine.org/apireference.html#fields
83	"""
84	parts = []	2✔
85	if hasattr(field, "document_type"):	2✔
86	doc = trim_docstring(field.document_type.__doc__)	2✔
87	if doc:	2✔
88	parts.append(doc)	2✔
89	if hasattr(field, "verbose_name"):	2✔
90	parts.append(field.verbose_name.title())	2✔
91	if hasattr(field, "help_text"):	2✔
92	parts.append(field.help_text)	2✔
93	if field.db_field != field.name:	2✔
94	name_format = "(%s)" if parts else "%s"	2✔
95	parts.append(name_format % field.db_field)	2✔
96
97	return "\n".join(parts)	2✔
98
99
100	def get_node_from_global_id(node, info, global_id):	2✔
101	try:	×
102	for interface in node._meta.interfaces:	×
103	if issubclass(interface, Node):	×
104	return interface.get_node_from_global_id(info, global_id)	×
105	except AttributeError:	×
106	return Node.get_node_from_global_id(info, global_id)	×
107
108
109	def collect_query_fields(node, fragments):	2✔
110	"""Recursively collects fields from the AST
111
112	Args:
113	node (dict): A node in the AST
114	fragments (dict): Fragment definitions
115
116	Returns:
117	A dict mapping each field found, along with their sub fields.
118	{
119	'name': {},
120	'image': {
121	'id': {},
122	'name': {},
123	'description': {}
124	},
125	'slug': {}
126	}
127	"""
128
129	field = {}	2✔
130	selection_set = None	2✔
131	if type(node) == dict:	2✔
132	selection_set = node.get('selection_set')	2✔
133	else:
134	selection_set = node.selection_set	2✔
135	if selection_set:	2✔
136	for leaf in selection_set.selections:	2✔
137	if leaf.kind == 'field':	2✔
138	field.update({	2✔
139	leaf.name.value: collect_query_fields(leaf, fragments)
140	})
141	elif leaf.kind == 'fragment_spread':	2✔
142	field.update(collect_query_fields(fragments[leaf['name']['value']],	×
143	fragments))
144	elif leaf.kind == 'inline_fragment':	2✔
145	field.update({	2✔
146	leaf.type_condition.name.value: collect_query_fields(leaf, fragments)
147	})
148
149	return field	2✔
150
151
152	def get_query_fields(info):	2✔
153	"""A convenience function to call collect_query_fields with info
154
155	Args:
156	info (ResolveInfo)
157
158	Returns:
159	dict: Returned from collect_query_fields
160	"""
161
162	fragments = {}	2✔
163	node = ast_to_dict(info.field_nodes[0])	2✔
164
165	for name, value in info.fragments.items():	2✔
166	fragments[name] = ast_to_dict(value)	×
167
168	query = collect_query_fields(node, fragments)	2✔
169	if "edges" in query:	2✔
170	return query["edges"]["node"].keys()	2✔
171	return query	2✔
172
173
174	def ast_to_dict(node, include_loc=False):	2✔
175	if isinstance(node, FieldNode):	2✔
176	d = {"kind": node.__class__.__name__}	2✔
177	if hasattr(node, "keys"):	2✔
178	for field in node.keys:	2✔
179	d[field] = ast_to_dict(getattr(node, field), include_loc)	2✔
180
181	if include_loc and hasattr(node, "loc") and node.loc:	2✔
182	d["loc"] = {"start": node.loc.start, "end": node.loc.end}	×
183
184	return d	2✔
185
186	elif isinstance(node, list):	2✔
187	return [ast_to_dict(item, include_loc) for item in node]	2✔
188
189	return node	2✔
190
191
192	def find_skip_and_limit(first, last, after, before, count):	2✔
193	reverse = False	2✔
194	skip = 0	2✔
195	limit = None	2✔
196	if first is not None and after is not None:	2✔
197	skip = after + 1	×
198	limit = first	×
199	elif first is not None and before is not None:	2✔
200	if first >= before:	×
201	limit = before - 1	×
202	else:
203	limit = first	×
204	elif first is not None:	2✔
205	skip = 0	2✔
206	limit = first	2✔
207	elif last is not None and before is not None:	2✔
208	reverse = False	×
209	if last >= before:	×
210	limit = before	×
211	else:
212	limit = last	×
213	skip = before - last	×
214	elif last is not None and after is not None:	2✔
215	reverse = True	×
216	if last + after < count:	×
217	limit = last	×
218	else:
219	limit = count - after - 1	×
220	elif last is not None:	2✔
221	skip = 0	2✔
222	limit = last	2✔
223	reverse = True	2✔
224	elif after is not None:	2✔
225	skip = after + 1	2✔
226	elif before is not None:	2✔
227	limit = before	2✔
228	return skip, limit, reverse	2✔
229
230
231	def connection_from_iterables(edges, start_offset, has_previous_page, has_next_page, connection_type,	2✔
232	edge_type,
233	pageinfo_type):
234	edges_items = [	2✔
235	edge_type(
236	node=node,
237	cursor=offset_to_cursor((0 if start_offset is None else start_offset) + i)
238	)
239	for i, node in enumerate(edges)
240	]
241
242	first_edge_cursor = edges_items[0].cursor if edges_items else None	2✔
243	last_edge_cursor = edges_items[-1].cursor if edges_items else None	2✔
244
245	return connection_type(	2✔
246	edges=edges_items,
247	page_info=pageinfo_type(
248	start_cursor=first_edge_cursor,
249	end_cursor=last_edge_cursor,
250	has_previous_page=has_previous_page,
251	has_next_page=has_next_page
252	)
253	)

graphql-python / graphene-mongo / 483

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