graphql-python / graphene-mongo / 426

pending completion

Build # 426

Build Type

Pull #157

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/9f4324afc1e4f003b216f0a538e15063352d8581">9f4324afc<a href="https://github.com/graphql-python/graphene-mongo/commit/9f4324afc1e4f003b216f0a538e15063352d8581">">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/1ff79aa385b1a4a9ede8aee98cf9ac34dcc5ecd0">1ff79aa38</a>">1ff79aa38</a><a href="https://github.com/graphql-python/graphene-mongo/commit/9f4324afc1e4f003b216f0a538e15063352d8581"> into 5d0813372">5d0813372</a>

Pull Request Pull Request #157: Feat pagination performance

Run Details

189 of 189 new or added lines in 5 files covered. (100.0%)

676 of 744 relevant lines covered (90.86%)

3.63 hits per line

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

76.19

/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_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 = {}

    if node.get('selection_set'):
        for leaf in node['selection_set']['selections']:
            if leaf['kind'] == 'Field':
                field.update({
                    leaf['name']['value']: collect_query_fields(leaf, fragments)
                })
            elif leaf['kind'] == 'FragmentSpread':
                field.update(collect_query_fields(fragments[leaf['name']['value']],
                                                  fragments))
            elif leaf['kind'] == 'InlineFragment':
                field.update({
                    leaf["type_condition"]["name"]['value']: collect_query_fields(leaf, fragments)
                })
                pass

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

graphql-python / graphene-mongo / 426

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