graphql-python / graphene-mongo / 493

pending completion

Build # 493

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/<a class="double-link" href="https://git"><a class=hub.com/graphql-python/graphene-mongo/commit/84bfe6874d3df1bfd42790120690040b6ac9e07e">84bfe6874">&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/84bfe6874d3df1bfd42790120690040b6ac9e07e">84bfe6874</a><a href="https://github.com/graphql-python/graphene-mongo/commit/84bfe6874d3df1bfd42790120690040b6ac9e07e">&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/84bfe6874d3df1bfd42790120690040b6ac9e07e&quot;&gt;84bfe6874&lt;/a&gt;&lt;a href=&quot;https://github.com/graphql-python/graphene-mongo/commit/84bfe6874d3df1bfd42790120690040b6ac9e07e&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #172: Support graphene v3

Run Details

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

780 of 964 relevant lines covered (80.91%)

1.62 hits per line

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

79.29

/graphene_mongo/fields.py

from __future__ import absolute_import

from collections import OrderedDict
from functools import partial, reduce

import graphene
import mongoengine
from bson import DBRef
from graphene import Context
from graphene.types.utils import get_type
from graphene.utils.str_converters import to_snake_case
from graphql import GraphQLResolveInfo
from mongoengine.base import get_document
from promise import Promise
from graphql_relay import from_global_id
from graphene.relay import ConnectionField
from graphene.types.argument import to_arguments
from graphene.types.dynamic import Dynamic
from graphene.types.structures import Structure
from graphql_relay.connection.arrayconnection import cursor_to_offset
from mongoengine import QuerySet

from .advanced_types import (
    FileFieldType,
    PointFieldType,
    MultiPolygonFieldType,
    PolygonFieldType, PointFieldInputType,
)
from .converter import convert_mongoengine_field, MongoEngineConversionError
from .registry import get_global_registry
from .utils import get_model_reference_fields, get_query_fields, find_skip_and_limit, \
    connection_from_iterables


class MongoengineConnectionField(ConnectionField):
    def __init__(self, type, *args, **kwargs):
        get_queryset = kwargs.pop("get_queryset", None)
        if get_queryset:
            assert callable(
                get_queryset
            ), "Attribute `get_queryset` on {} must be callable.".format(self)
        self._get_queryset = get_queryset
        super(MongoengineConnectionField, self).__init__(type, *args, **kwargs)

    @property
    def type(self):
        from .types import MongoengineObjectType

        _type = super(ConnectionField, self).type
        assert issubclass(
            _type, MongoengineObjectType
        ), "MongoengineConnectionField only accepts MongoengineObjectType types"
        assert _type._meta.connection, "The type {} doesn't have a connection".format(
            _type.__name__
        )
        return _type._meta.connection

    @property
    def node_type(self):
        return self.type._meta.node

    @property
    def model(self):
        return self.node_type._meta.model

    @property
    def order_by(self):
        return self.node_type._meta.order_by

    @property
    def required_fields(self):
        return tuple(set(self.node_type._meta.required_fields + self.node_type._meta.only_fields))

    @property
    def registry(self):
        return getattr(self.node_type._meta, "registry", get_global_registry())

    @property
    def args(self):
        return to_arguments(
            self._base_args or OrderedDict(),
            dict(dict(dict(self.field_args, **self.advance_args), **self.filter_args), **self.extended_args),
        )

    @args.setter
    def args(self, args):
        self._base_args = args

    def _field_args(self, items):
        def is_filterable(k):
            """
            Remove complex columns from input args at this moment.

            Args:
                k (str): field name.
            Returns:
                bool
            """
            if hasattr(self.fields[k].type, '_sdl'):
                return False
            if not hasattr(self.model, k):
                return False
            if isinstance(getattr(self.model, k), property):
                return False
            try:
                converted = convert_mongoengine_field(
                    getattr(self.model, k), self.registry
                )
            except MongoEngineConversionError:
                return False
            if isinstance(converted, (ConnectionField, Dynamic)):
                return False
            if callable(getattr(converted, "type", None)) and isinstance(
                    converted.type(),
                    (
                            FileFieldType,
                            PointFieldType,
                            MultiPolygonFieldType,
                            graphene.Union,
                            PolygonFieldType,
                    ),
            ):
                return False
            if getattr(converted, "type", None) and getattr(converted.type, "_of_type", None) and issubclass(
                    (get_type(converted.type.of_type)), graphene.Union):
                return False
            if isinstance(converted, (graphene.List)) and issubclass(
                    getattr(converted, "_of_type", None), graphene.Union
            ):
                return False
            return True

        def get_filter_type(_type):
            """
            Returns the scalar type.
            """
            if isinstance(_type, Structure):
                return get_filter_type(_type.of_type)
            return _type()

        return {k: get_filter_type(v.type) for k, v in items if is_filterable(k)}

    @property
    def field_args(self):
        return self._field_args(self.fields.items())

    @property
    def filter_args(self):
        filter_args = dict()
        if self._type._meta.filter_fields:
            for field, filter_collection in self._type._meta.filter_fields.items():
                for each in filter_collection:
                    if str(self._type._meta.fields[field].type) == 'PointFieldType':
                        if each == 'max_distance':
                            filter_type = graphene.Int
                        else:
                            filter_type = PointFieldInputType
                    else:
                        filter_type = getattr(
                            graphene,
                            str(self._type._meta.fields[field].type).replace("!", ""),
                        )
                    # handle special cases
                    advanced_filter_types = {
                        "in": graphene.List(filter_type),
                        "nin": graphene.List(filter_type),
                        "all": graphene.List(filter_type),
                    }
                    filter_type = advanced_filter_types.get(each, filter_type)
                    filter_args[field + "__" + each] = graphene.Argument(
                        type_=filter_type
                    )
        return filter_args

    @property
    def advance_args(self):
        def get_advance_field(r, kv):
            field = kv[1]
            mongo_field = getattr(self.model, kv[0], None)
            if isinstance(mongo_field, mongoengine.PointField):
                r.update({kv[0]: graphene.Argument(PointFieldInputType)})
                return r
            if isinstance(
                    mongo_field,
                    (mongoengine.LazyReferenceField, mongoengine.ReferenceField, mongoengine.GenericReferenceField),
            ):
                r.update({kv[0]: graphene.ID()})
                return r
            if isinstance(mongo_field, mongoengine.GenericReferenceField):
                r.update({kv[0]: graphene.ID()})
                return r
            if callable(getattr(field, "get_type", None)):
                _type = field.get_type()
                if _type:
                    node = _type.type._meta if hasattr(_type.type, "_meta") else _type.type._of_type._meta
                    if "id" in node.fields and not issubclass(
                            node.model, (mongoengine.EmbeddedDocument,)
                    ):
                        r.update({kv[0]: node.fields["id"]._type.of_type()})

            return r

        return reduce(get_advance_field, self.fields.items(), {})

    @property
    def extended_args(self):
        args = OrderedDict()
        for k, each in self.fields.items():
            if hasattr(each.type, '_sdl'):
                args.update({k: graphene.ID()})
        return args

    @property
    def fields(self):
        self._type = get_type(self._type)
        return self._type._meta.fields

    def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):
        if args:
            reference_fields = get_model_reference_fields(self.model)
            hydrated_references = {}
            for arg_name, arg in args.copy().items():
                if arg_name in reference_fields and not isinstance(arg,
                                                                   mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
                    try:
                        reference_obj = reference_fields[arg_name].document_type(pk=from_global_id(arg)[1])
                    except TypeError:
                        reference_obj = reference_fields[arg_name].document_type(pk=arg)
                    hydrated_references[arg_name] = reference_obj
                elif arg_name in self.model._fields_ordered and isinstance(getattr(self.model, arg_name),
                                                                           mongoengine.fields.GenericReferenceField):
                    try:
                        reference_obj = get_document(self.registry._registry_string_map[from_global_id(arg)[0]])(
                            pk=from_global_id(arg)[1])
                    except TypeError:
                        reference_obj = get_document(arg["_cls"])(
                            pk=arg["_ref"].id)
                    hydrated_references[arg_name] = reference_obj
                elif '__near' in arg_name and isinstance(getattr(self.model, arg_name.split('__')[0]),
                                                         mongoengine.fields.PointField):
                    location = args.pop(arg_name, None)
                    hydrated_references[arg_name] = location["coordinates"]
                    if (arg_name.split('__')[0] + "__max_distance") not in args:
                        hydrated_references[arg_name.split('__')[0] + "__max_distance"] = 10000
                elif arg_name == "id":
                    hydrated_references["id"] = from_global_id(args.pop("id", None))[1]
            args.update(hydrated_references)

        if self._get_queryset:
            queryset_or_filters = self._get_queryset(model, info, **args)
            if isinstance(queryset_or_filters, mongoengine.QuerySet):
                return queryset_or_filters
            else:
                args.update(queryset_or_filters)
        if limit is not None:
            if reversed:
                if self.order_by:
                    order_by = self.order_by + ",-pk"
                else:
                    order_by = "-pk"
                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
                    skip if skip else 0).limit(limit)
            else:
                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
                    skip if skip else 0).limit(limit)
        elif skip is not None:
            if reversed:
                if self.order_by:
                    order_by = self.order_by + ",-pk"
                else:
                    order_by = "-pk"
                return model.objects(**args).no_dereference().only(*required_fields).order_by(order_by).skip(
                    skip)
            else:
                return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by).skip(
                    skip)
        return model.objects(**args).no_dereference().only(*required_fields).order_by(self.order_by)

    def default_resolver(self, _root, info, required_fields=list(), **args):
        args = args or {}
        for key, value in dict(args).items():
            if value is None:
                del args[key]
        if _root is not None:
            field_name = to_snake_case(info.field_name)
            if not hasattr(_root, "_fields_ordered"):
                if getattr(_root, field_name, []) is not None:
                    args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]
            elif field_name in _root._fields_ordered and not (isinstance(_root._fields[field_name].field,
                                                                         mongoengine.EmbeddedDocumentField) or
                                                              isinstance(_root._fields[field_name].field,
                                                                         mongoengine.GenericEmbeddedDocumentField)):
                if getattr(_root, field_name, []) is not None:
                    args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]

        _id = args.pop('id', None)

        if _id is not None:
            args['pk'] = from_global_id(_id)[-1]
        iterables = []
        list_length = 0
        skip = 0
        count = 0
        limit = None
        reverse = False
        first = args.pop("first", None)
        after = args.pop("after", None)
        if after:
            after = cursor_to_offset(after)
        last = args.pop("last", None)
        before = args.pop("before", None)
        if before:
            before = cursor_to_offset(before)
        if callable(getattr(self.model, "objects", None)):
            if "pk__in" in args and args["pk__in"]:
                count = len(args["pk__in"])
                skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,
                                                           count=count)
                if limit:
                    if reverse:
                        args["pk__in"] = args["pk__in"][::-1][skip:skip + limit]
                    else:
                        args["pk__in"] = args["pk__in"][skip:skip + limit]
                elif skip:
                    args["pk__in"] = args["pk__in"][skip:]
                iterables = self.get_queryset(self.model, info, required_fields, **args)
                list_length = len(iterables)
                if isinstance(info, GraphQLResolveInfo):
                    if not info.context:
                        info = info._replace(context=Context())
                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)
            elif _root is None or args:
                count = self.get_queryset(self.model, info, required_fields, **args).count()
                if count != 0:
                    skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last, before=before,
                                                               count=count)
                    iterables = self.get_queryset(self.model, info, required_fields, skip, limit, reverse, **args)
                    list_length = len(iterables)
                    if isinstance(info, GraphQLResolveInfo):
                        if not info.context:
                            info = info._replace(context=Context())
                        info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)

        elif _root is not None:
            field_name = to_snake_case(info.field_name)
            items = getattr(_root, field_name, [])
            count = len(items)
            skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,
                                                       count=count)
            if limit:
                if reverse:
                    items = items[::-1][skip:skip + limit]
                else:
                    items = items[skip:skip + limit]
            elif skip:
                items = items[skip:]
            iterables = items
            list_length = len(iterables)
        has_next_page = True if (0 if limit is None else limit) + (0 if skip is None else skip) < count else False
        has_previous_page = True if skip else False
        if reverse:
            iterables = list(iterables)
            iterables.reverse()
            skip = limit
        connection = connection_from_iterables(edges=iterables, start_offset=skip,
                                               has_previous_page=has_previous_page,
                                               has_next_page=has_next_page,
                                               connection_type=self.type,
                                               edge_type=self.type.Edge,
                                               pageinfo_type=graphene.PageInfo)

        connection.iterable = iterables
        connection.list_length = list_length
        return connection

    def chained_resolver(self, resolver, is_partial, root, info, **args):
        for key, value in dict(args).items():
            if value is None:
                del args[key]
        required_fields = list()
        for field in self.required_fields:
            if field in self.model._fields_ordered:
                required_fields.append(field)
        for field in get_query_fields(info):
            if to_snake_case(field) in self.model._fields_ordered:
                required_fields.append(to_snake_case(field))
        args_copy = args.copy()
        if not bool(args) or not is_partial:
            if isinstance(self.model, mongoengine.Document) or isinstance(self.model,
                                                                          mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
                for arg_name, arg in args.copy().items():
                    if arg_name not in self.model._fields_ordered + tuple(self.filter_args.keys()):
                        args_copy.pop(arg_name)
                if isinstance(info, GraphQLResolveInfo):
                    if not info.context:
                        info = info._replace(context=Context())
                    info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)

            # XXX: Filter nested args
            resolved = resolver(root, info, **args)
            if resolved is not None:
                if isinstance(resolved, list):
                    if resolved == list():
                        return resolved
                    elif not isinstance(resolved[0], DBRef):
                        return resolved
                    else:
                        return self.default_resolver(root, info, required_fields, **args_copy)
                elif isinstance(resolved, QuerySet):
                    args.update(resolved._query)
                    args_copy = args.copy()
                    for arg_name, arg in args.copy().items():
                        if arg_name not in self.model._fields_ordered + ('first', 'last', 'before', 'after') + tuple(
                                self.filter_args.keys()):
                            args_copy.pop(arg_name)
                            if arg_name == '_id' and isinstance(arg, dict):
                                operation = list(arg.keys())[0]
                                args_copy['pk' + operation.replace('$', '__')] = arg[operation]
                            if '.' in arg_name:
                                operation = list(arg.keys())[0]
                                args_copy[arg_name.replace('.', '__') + operation.replace('$', '__')] = arg[operation]
                        else:
                            operations = ["$lte", "$gte", "$ne", "$in"]
                            if isinstance(arg, dict) and any(op in arg for op in operations):
                                operation = list(arg.keys())[0]
                                args_copy[arg_name + operation.replace('$', '__')] = arg[operation]
                                del args_copy[arg_name]
                    return self.default_resolver(root, info, required_fields, **args_copy)
                elif isinstance(resolved, Promise):
                    return resolved.value
                else:
                    return resolved
        return self.default_resolver(root, info, required_fields, **args)

    @classmethod
    def connection_resolver(cls, resolver, connection_type, root, info, **args):
        iterable = resolver(root, info, **args)
        if isinstance(connection_type, graphene.NonNull):
            connection_type = connection_type.of_type
        on_resolve = partial(cls.resolve_connection, connection_type, args)
        if Promise.is_thenable(iterable):
            return Promise.resolve(iterable).then(on_resolve)
        return on_resolve(iterable)

    def get_resolver(self, parent_resolver):
        super_resolver = self.resolver or parent_resolver
        resolver = partial(
            self.chained_resolver, super_resolver, isinstance(super_resolver, partial)
        )
        return partial(self.connection_resolver, resolver, self.type)

1	from __future__ import absolute_import	2✔
2
3	from collections import OrderedDict	2✔
4	from functools import partial, reduce	2✔
5
6	import graphene	2✔
7	import mongoengine	2✔
8	from bson import DBRef	2✔
9	from graphene import Context	2✔
10	from graphene.types.utils import get_type	2✔
11	from graphene.utils.str_converters import to_snake_case	2✔
12	from graphql import GraphQLResolveInfo	2✔
13	from mongoengine.base import get_document	2✔
14	from promise import Promise	2✔
15	from graphql_relay import from_global_id	2✔
16	from graphene.relay import ConnectionField	2✔
17	from graphene.types.argument import to_arguments	2✔
18	from graphene.types.dynamic import Dynamic	2✔
19	from graphene.types.structures import Structure	2✔
20	from graphql_relay.connection.arrayconnection import cursor_to_offset	2✔
21	from mongoengine import QuerySet	2✔
22
23	from .advanced_types import (	2✔
24	FileFieldType,
25	PointFieldType,
26	MultiPolygonFieldType,
27	PolygonFieldType, PointFieldInputType,
28	)
29	from .converter import convert_mongoengine_field, MongoEngineConversionError	2✔
30	from .registry import get_global_registry	2✔
31	from .utils import get_model_reference_fields, get_query_fields, find_skip_and_limit, \	2✔
32	connection_from_iterables
33
34
35	class MongoengineConnectionField(ConnectionField):	2✔
36	def __init__(self, type, args, *kwargs):	2✔
37	get_queryset = kwargs.pop("get_queryset", None)	2✔
38	if get_queryset:	2✔
39	assert callable(	2✔
40	get_queryset
41	), "Attribute `get_queryset` on {} must be callable.".format(self)
42	self._get_queryset = get_queryset	2✔
43	super(MongoengineConnectionField, self).__init__(type, args, *kwargs)	2✔
44
45	@property	2✔
46	def type(self):	1✔
47	from .types import MongoengineObjectType	2✔
48
49	_type = super(ConnectionField, self).type	2✔
50	assert issubclass(	2✔
51	_type, MongoengineObjectType
52	), "MongoengineConnectionField only accepts MongoengineObjectType types"
53	assert _type._meta.connection, "The type {} doesn't have a connection".format(	2✔
54	_type.__name__
55	)
56	return _type._meta.connection	2✔
57
58	@property	2✔
59	def node_type(self):	1✔
60	return self.type._meta.node	2✔
61
62	@property	2✔
63	def model(self):	1✔
64	return self.node_type._meta.model	2✔
65
66	@property	2✔
67	def order_by(self):	1✔
68	return self.node_type._meta.order_by	2✔
69
70	@property	2✔
71	def required_fields(self):	1✔
72	return tuple(set(self.node_type._meta.required_fields + self.node_type._meta.only_fields))	2✔
73
74	@property	2✔
75	def registry(self):	1✔
76	return getattr(self.node_type._meta, "registry", get_global_registry())	2✔
77
78	@property	2✔
79	def args(self):	1✔
80	return to_arguments(	2✔
81	self._base_args or OrderedDict(),
82	dict(dict(dict(self.field_args, self.advance_args), self.filter_args), **self.extended_args),
83	)
84
85	@args.setter	2✔
86	def args(self, args):	1✔
87	self._base_args = args	2✔
88
89	def _field_args(self, items):	2✔
90	def is_filterable(k):	2✔
91	"""
92	Remove complex columns from input args at this moment.
93
94	Args:
95	k (str): field name.
96	Returns:
97	bool
98	"""
99	if hasattr(self.fields[k].type, '_sdl'):	2✔
100	return False	×
101	if not hasattr(self.model, k):	2✔
102	return False	2✔
103	if isinstance(getattr(self.model, k), property):	2✔
104	return False	2✔
105	try:	2✔
106	converted = convert_mongoengine_field(	2✔
107	getattr(self.model, k), self.registry
108	)
109	except MongoEngineConversionError:	2✔
110	return False	2✔
111	if isinstance(converted, (ConnectionField, Dynamic)):	2✔
112	return False	2✔
113	if callable(getattr(converted, "type", None)) and isinstance(	2✔
114	converted.type(),
115	(
116	FileFieldType,
117	PointFieldType,
118	MultiPolygonFieldType,
119	graphene.Union,
120	PolygonFieldType,
121	),
122	):
123	return False	2✔
124	if getattr(converted, "type", None) and getattr(converted.type, "_of_type", None) and issubclass(	2✔
125	(get_type(converted.type.of_type)), graphene.Union):
126	return False	2✔
127	if isinstance(converted, (graphene.List)) and issubclass(	2✔
128	getattr(converted, "_of_type", None), graphene.Union
129	):
130	return False	2✔
131	return True	2✔
132
133	def get_filter_type(_type):	2✔
134	"""
135	Returns the scalar type.
136	"""
137	if isinstance(_type, Structure):	2✔
138	return get_filter_type(_type.of_type)	2✔
139	return _type()	2✔
140
141	return {k: get_filter_type(v.type) for k, v in items if is_filterable(k)}	2✔
142
143	@property	2✔
144	def field_args(self):	1✔
145	return self._field_args(self.fields.items())	2✔
146
147	@property	2✔
148	def filter_args(self):	1✔
149	filter_args = dict()	2✔
150	if self._type._meta.filter_fields:	2✔
151	for field, filter_collection in self._type._meta.filter_fields.items():	2✔
152	for each in filter_collection:	2✔
153	if str(self._type._meta.fields[field].type) == 'PointFieldType':	2✔
154	if each == 'max_distance':	×
155	filter_type = graphene.Int	×
156	else:
157	filter_type = PointFieldInputType	×
158	else:
159	filter_type = getattr(	2✔
160	graphene,
161	str(self._type._meta.fields[field].type).replace("!", ""),
162	)
163	# handle special cases
164	advanced_filter_types = {	2✔
165	"in": graphene.List(filter_type),
166	"nin": graphene.List(filter_type),
167	"all": graphene.List(filter_type),
168	}
169	filter_type = advanced_filter_types.get(each, filter_type)	2✔
170	filter_args[field + "__" + each] = graphene.Argument(	2✔
171	type_=filter_type
172	)
173	return filter_args	2✔
174
175	@property	2✔
176	def advance_args(self):	1✔
177	def get_advance_field(r, kv):	2✔
178	field = kv[1]	2✔
179	mongo_field = getattr(self.model, kv[0], None)	2✔
180	if isinstance(mongo_field, mongoengine.PointField):	2✔
181	r.update({kv[0]: graphene.Argument(PointFieldInputType)})	2✔
182	return r	2✔
183	if isinstance(	2✔
184	mongo_field,
185	(mongoengine.LazyReferenceField, mongoengine.ReferenceField, mongoengine.GenericReferenceField),
186	):
187	r.update({kv[0]: graphene.ID()})	2✔
188	return r	2✔
189	if isinstance(mongo_field, mongoengine.GenericReferenceField):	2✔
190	r.update({kv[0]: graphene.ID()})	×
191	return r	×
192	if callable(getattr(field, "get_type", None)):	2✔
193	_type = field.get_type()	2✔
194	if _type:	2✔
195	node = _type.type._meta if hasattr(_type.type, "_meta") else _type.type._of_type._meta	2✔
196	if "id" in node.fields and not issubclass(	2✔
197	node.model, (mongoengine.EmbeddedDocument,)
198	):
199	r.update({kv[0]: node.fields["id"]._type.of_type()})	×
200
201	return r	2✔
202
203	return reduce(get_advance_field, self.fields.items(), {})	2✔
204
205	@property	2✔
206	def extended_args(self):	1✔
207	args = OrderedDict()	2✔
208	for k, each in self.fields.items():	2✔
209	if hasattr(each.type, '_sdl'):	2✔
210	args.update({k: graphene.ID()})	×
211	return args	2✔
212
213	@property	2✔
214	def fields(self):	1✔
215	self._type = get_type(self._type)	2✔
216	return self._type._meta.fields	2✔
217
218	def get_queryset(self, model, info, required_fields=list(), skip=None, limit=None, reversed=False, **args):	2✔
219	if args:	2✔
220	reference_fields = get_model_reference_fields(self.model)	2✔
221	hydrated_references = {}	2✔
222	for arg_name, arg in args.copy().items():	2✔
223	if arg_name in reference_fields and not isinstance(arg,	2✔
224	mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
225	try:	2✔
226	reference_obj = reference_fields[arg_name].document_type(pk=from_global_id(arg)[1])	2✔
227	except TypeError:	×
228	reference_obj = reference_fields[arg_name].document_type(pk=arg)	×
229	hydrated_references[arg_name] = reference_obj	2✔
230	elif arg_name in self.model._fields_ordered and isinstance(getattr(self.model, arg_name),	2✔
231	mongoengine.fields.GenericReferenceField):
232	try:	×
233	reference_obj = get_document(self.registry._registry_string_map[from_global_id(arg)[0]])(	×
234	pk=from_global_id(arg)[1])
235	except TypeError:	×
236	reference_obj = get_document(arg["_cls"])(	×
237	pk=arg["_ref"].id)
238	hydrated_references[arg_name] = reference_obj	×
239	elif '__near' in arg_name and isinstance(getattr(self.model, arg_name.split('__')[0]),	2✔
240	mongoengine.fields.PointField):
241	location = args.pop(arg_name, None)	×
242	hydrated_references[arg_name] = location["coordinates"]	×
243	if (arg_name.split('__')[0] + "__max_distance") not in args:	×
244	hydrated_references[arg_name.split('__')[0] + "__max_distance"] = 10000	×
245	elif arg_name == "id":	2✔
246	hydrated_references["id"] = from_global_id(args.pop("id", None))[1]	×
247	args.update(hydrated_references)	2✔
248
249	if self._get_queryset:	2✔
250	queryset_or_filters = self._get_queryset(model, info, **args)	2✔
251	if isinstance(queryset_or_filters, mongoengine.QuerySet):	2✔
252	return queryset_or_filters	2✔
253	else:
254	args.update(queryset_or_filters)	2✔
255	if limit is not None:	2✔
256	if reversed:	2✔
257	if self.order_by:	2✔
258	order_by = self.order_by + ",-pk"	×
259	else:
260	order_by = "-pk"	2✔
261	return model.objects(*args).no_dereference().only(required_fields).order_by(order_by).skip(	2✔
262	skip if skip else 0).limit(limit)
263	else:
264	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by).skip(	2✔
265	skip if skip else 0).limit(limit)
266	elif skip is not None:	2✔
267	if reversed:	2✔
268	if self.order_by:	×
269	order_by = self.order_by + ",-pk"	×
270	else:
271	order_by = "-pk"	×
272	return model.objects(*args).no_dereference().only(required_fields).order_by(order_by).skip(	×
273	skip)
274	else:
275	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by).skip(	2✔
276	skip)
277	return model.objects(*args).no_dereference().only(required_fields).order_by(self.order_by)	2✔
278
279	def default_resolver(self, _root, info, required_fields=list(), **args):	2✔
280	args = args or {}	2✔
281	for key, value in dict(args).items():	2✔
282	if value is None:	2✔
283	del args[key]	×
284	if _root is not None:	2✔
285	field_name = to_snake_case(info.field_name)	2✔
286	if not hasattr(_root, "_fields_ordered"):	2✔
287	if getattr(_root, field_name, []) is not None:	×
288	args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]	×
289	elif field_name in _root._fields_ordered and not (isinstance(_root._fields[field_name].field,	2✔
290	mongoengine.EmbeddedDocumentField) or
291	isinstance(_root._fields[field_name].field,
292	mongoengine.GenericEmbeddedDocumentField)):
293	if getattr(_root, field_name, []) is not None:	2✔
294	args["pk__in"] = [r.id for r in getattr(_root, field_name, [])]	2✔
295
296	_id = args.pop('id', None)	2✔
297
298	if _id is not None:	2✔
299	args['pk'] = from_global_id(_id)[-1]	2✔
300	iterables = []	2✔
301	list_length = 0	2✔
302	skip = 0	2✔
303	count = 0	2✔
304	limit = None	2✔
305	reverse = False	2✔
306	first = args.pop("first", None)	2✔
307	after = args.pop("after", None)	2✔
308	if after:	2✔
309	after = cursor_to_offset(after)	2✔
310	last = args.pop("last", None)	2✔
311	before = args.pop("before", None)	2✔
312	if before:	2✔
313	before = cursor_to_offset(before)	2✔
314	if callable(getattr(self.model, "objects", None)):	2✔
315	if "pk__in" in args and args["pk__in"]:	2✔
316	count = len(args["pk__in"])	2✔
317	skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,	2✔
318	count=count)
319	if limit:	2✔
320	if reverse:	2✔
321	args["pk__in"] = args["pk__in"][::-1][skip:skip + limit]	×
322	else:
323	args["pk__in"] = args["pk__in"][skip:skip + limit]	2✔
324	elif skip:	2✔
325	args["pk__in"] = args["pk__in"][skip:]	×
326	iterables = self.get_queryset(self.model, info, required_fields, **args)	2✔
327	list_length = len(iterables)	2✔
328	if isinstance(info, GraphQLResolveInfo):	2✔
329	if not info.context:	2✔
330	info = info._replace(context=Context())	2✔
331	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)	2✔
332	elif _root is None or args:	2✔
333	count = self.get_queryset(self.model, info, required_fields, **args).count()	2✔
334	if count != 0:	2✔
335	skip, limit, reverse = find_skip_and_limit(first=first, after=after, last=last, before=before,	2✔
336	count=count)
337	iterables = self.get_queryset(self.model, info, required_fields, skip, limit, reverse, **args)	2✔
338	list_length = len(iterables)	2✔
339	if isinstance(info, GraphQLResolveInfo):	2✔
340	if not info.context:	2✔
341	info = info._replace(context=Context())	2✔
342	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args)	2✔
343
344	elif _root is not None:	2✔
345	field_name = to_snake_case(info.field_name)	×
346	items = getattr(_root, field_name, [])	×
347	count = len(items)	×
348	skip, limit, reverse = find_skip_and_limit(first=first, last=last, after=after, before=before,	×
349	count=count)
350	if limit:	×
351	if reverse:	×
352	items = items[::-1][skip:skip + limit]	×
353	else:
354	items = items[skip:skip + limit]	×
355	elif skip:	×
356	items = items[skip:]	×
357	iterables = items	×
358	list_length = len(iterables)	×
359	has_next_page = True if (0 if limit is None else limit) + (0 if skip is None else skip) < count else False	2✔
360	has_previous_page = True if skip else False	2✔
361	if reverse:	2✔
362	iterables = list(iterables)	2✔
363	iterables.reverse()	2✔
364	skip = limit	2✔
365	connection = connection_from_iterables(edges=iterables, start_offset=skip,	2✔
366	has_previous_page=has_previous_page,
367	has_next_page=has_next_page,
368	connection_type=self.type,
369	edge_type=self.type.Edge,
370	pageinfo_type=graphene.PageInfo)
371
372	connection.iterable = iterables	2✔
373	connection.list_length = list_length	2✔
374	return connection	2✔
375
376	def chained_resolver(self, resolver, is_partial, root, info, **args):	2✔
377	for key, value in dict(args).items():	2✔
378	if value is None:	2✔
379	del args[key]	2✔
380	required_fields = list()	2✔
381	for field in self.required_fields:	2✔
382	if field in self.model._fields_ordered:	×
383	required_fields.append(field)	×
384	for field in get_query_fields(info):	2✔
385	if to_snake_case(field) in self.model._fields_ordered:	2✔
386	required_fields.append(to_snake_case(field))	2✔
387	args_copy = args.copy()	2✔
388	if not bool(args) or not is_partial:	2✔
389	if isinstance(self.model, mongoengine.Document) or isinstance(self.model,	2✔
390	mongoengine.base.metaclasses.TopLevelDocumentMetaclass):
391	for arg_name, arg in args.copy().items():	2✔
392	if arg_name not in self.model._fields_ordered + tuple(self.filter_args.keys()):	2✔
393	args_copy.pop(arg_name)	2✔
394	if isinstance(info, GraphQLResolveInfo):	2✔
395	if not info.context:	2✔
396	info = info._replace(context=Context())	2✔
397	info.context.queryset = self.get_queryset(self.model, info, required_fields, **args_copy)	2✔
398
399	# XXX: Filter nested args
400	resolved = resolver(root, info, **args)	2✔
401	if resolved is not None:	2✔
402	if isinstance(resolved, list):	2✔
403	if resolved == list():	2✔
404	return resolved	2✔
405	elif not isinstance(resolved[0], DBRef):	2✔
406	return resolved	2✔
407	else:
408	return self.default_resolver(root, info, required_fields, **args_copy)	2✔
409	elif isinstance(resolved, QuerySet):	2✔
410	args.update(resolved._query)	×
411	args_copy = args.copy()	×
412	for arg_name, arg in args.copy().items():	×
413	if arg_name not in self.model._fields_ordered + ('first', 'last', 'before', 'after') + tuple(	×
414	self.filter_args.keys()):
415	args_copy.pop(arg_name)	×
416	if arg_name == '_id' and isinstance(arg, dict):	×
417	operation = list(arg.keys())[0]	×
418	args_copy['pk' + operation.replace('$', '__')] = arg[operation]	×
419	if '.' in arg_name:	×
420	operation = list(arg.keys())[0]	×
421	args_copy[arg_name.replace('.', '__') + operation.replace('$', '__')] = arg[operation]	×
422	else:
423	operations = ["$lte", "$gte", "$ne", "$in"]	×
424	if isinstance(arg, dict) and any(op in arg for op in operations):	×
425	operation = list(arg.keys())[0]	×
426	args_copy[arg_name + operation.replace('$', '__')] = arg[operation]	×
427	del args_copy[arg_name]	×
428	return self.default_resolver(root, info, required_fields, **args_copy)	×
429	elif isinstance(resolved, Promise):	2✔
430	return resolved.value	2✔
431	else:
432	return resolved	×
433	return self.default_resolver(root, info, required_fields, **args)	2✔
434
435	@classmethod	2✔
436	def connection_resolver(cls, resolver, connection_type, root, info, **args):	1✔
437	iterable = resolver(root, info, **args)	2✔
438	if isinstance(connection_type, graphene.NonNull):	2✔
439	connection_type = connection_type.of_type	×
440	on_resolve = partial(cls.resolve_connection, connection_type, args)	2✔
441	if Promise.is_thenable(iterable):	2✔
442	return Promise.resolve(iterable).then(on_resolve)	×
443	return on_resolve(iterable)	2✔
444
445	def get_resolver(self, parent_resolver):	2✔
446	super_resolver = self.resolver or parent_resolver	2✔
447	resolver = partial(	2✔
448	self.chained_resolver, super_resolver, isinstance(super_resolver, partial)
449	)
450	return partial(self.connection_resolver, resolver, self.type)	2✔

graphql-python / graphene-mongo / 493

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