graphql-python / gql / 225

pending completion

Build # 225

Build Type

push

travis-ci

Committed by

Cito

Commit Message

Use GraphQL-core version 3 instead of version 2

Also made some of the tests more robust.

Run Details

36 of 36 new or added lines in 8 files covered. (100.0%)

591 of 595 relevant lines covered (99.33%)

0.99 hits per line

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

97.92

/gql/dsl.py

from functools import partial

import six
from graphql import (
    ArgumentNode,
    DocumentNode,
    EnumValueNode,
    FieldNode,
    GraphQLEnumType,
    GraphQLInputField,
    GraphQLInputObjectType,
    GraphQLList,
    GraphQLNonNull,
    ListValueNode,
    NameNode,
    ObjectFieldNode,
    ObjectValueNode,
    OperationDefinitionNode,
    OperationType,
    SelectionSetNode,
    ast_from_value,
    print_ast,
)
from graphql.pyutils import FrozenList

from .utils import to_camel_case

if six.PY3:
    from collections.abc import Iterable
else:
    from collections import Iterable


class DSLSchema(object):
    def __init__(self, client):
        self.client = client

    @property
    def schema(self):
        return self.client.schema

    def __getattr__(self, name):
        type_def = self.schema.get_type(name)
        return DSLType(type_def)

    def query(self, *args, **kwargs):
        return self.execute(query(*args, **kwargs))

    def mutate(self, *args, **kwargs):
        return self.query(*args, operation="mutation", **kwargs)

    def execute(self, document):
        return self.client.execute(document)


class DSLType(object):
    def __init__(self, type_):
        self.type = type_

    def __getattr__(self, name):
        formatted_name, field_def = self.get_field(name)
        return DSLField(formatted_name, field_def)

    def get_field(self, name):
        camel_cased_name = to_camel_case(name)

        if name in self.type.fields:
            return name, self.type.fields[name]

        if camel_cased_name in self.type.fields:
            return camel_cased_name, self.type.fields[camel_cased_name]

        raise KeyError(
            "Field {} does not exist in type {}.".format(name, self.type.name)
        )


def selections(*fields):
    for _field in fields:
        yield selection_field(_field).ast


class DSLField(object):
    def __init__(self, name, field):
        self.field = field
        self.ast_field = FieldNode(name=NameNode(value=name), arguments=FrozenList())
        self.selection_set = None

    def select(self, *fields):
        selection_set = self.ast_field.selection_set
        added_selections = selections(*fields)
        if selection_set:
            selection_set.selections = FrozenList(
                selection_set.selections + added_selections
            )
        else:
            self.ast_field.selection_set = SelectionSetNode(
                selections=FrozenList(added_selections)
            )
        return self

    def __call__(self, **kwargs):
        return self.args(**kwargs)

    def alias(self, alias):
        self.ast_field.alias = NameNode(value=alias)
        return self

    def args(self, **kwargs):
        added_args = []
        for name, value in kwargs.items():
            arg = self.field.args.get(name)
            arg_type_serializer = get_arg_serializer(arg.type)
            serialized_value = arg_type_serializer(value)
            added_args.append(
                ArgumentNode(name=NameNode(value=name), value=serialized_value)
            )
        ast_field = self.ast_field
        ast_field.arguments = FrozenList(ast_field.arguments + added_args)
        return self

    @property
    def ast(self):
        return self.ast_field

    def __str__(self):
        return print_ast(self.ast_field)


def selection_field(field):
    if isinstance(field, DSLField):
        return field

    raise Exception('Received incompatible query field: "{}".'.format(field))


def query(*fields, **kwargs):
    if "operation" not in kwargs:
        kwargs["operation"] = "query"
    return DocumentNode(
        definitions=[
            OperationDefinitionNode(
                operation=OperationType(kwargs["operation"]),
                selection_set=SelectionSetNode(
                    selections=FrozenList(selections(*fields))
                ),
            )
        ]
    )


def serialize_list(serializer, list_values):
    assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(
        repr(list_values)
    )
    return ListValueNode(values=FrozenList(serializer(v) for v in list_values))


def get_arg_serializer(arg_type):
    if isinstance(arg_type, GraphQLNonNull):
        return get_arg_serializer(arg_type.of_type)
    if isinstance(arg_type, GraphQLInputField):
        return get_arg_serializer(arg_type.type)
    if isinstance(arg_type, GraphQLInputObjectType):
        serializers = {k: get_arg_serializer(v) for k, v in arg_type.fields.items()}
        return lambda value: ObjectValueNode(
            fields=FrozenList(
                ObjectFieldNode(name=NameNode(value=k), value=serializers[k](v))
                for k, v in value.items()
            )
        )
    if isinstance(arg_type, GraphQLList):
        inner_serializer = get_arg_serializer(arg_type.of_type)
        return partial(serialize_list, inner_serializer)
    if isinstance(arg_type, GraphQLEnumType):
        return lambda value: EnumValueNode(value=arg_type.serialize(value))
    return lambda value: ast_from_value(arg_type.serialize(value), arg_type)

1	from functools import partial	1✔
2
3	import six	1✔
4	from graphql import (	1✔
5	ArgumentNode,
6	DocumentNode,
7	EnumValueNode,
8	FieldNode,
9	GraphQLEnumType,
10	GraphQLInputField,
11	GraphQLInputObjectType,
12	GraphQLList,
13	GraphQLNonNull,
14	ListValueNode,
15	NameNode,
16	ObjectFieldNode,
17	ObjectValueNode,
18	OperationDefinitionNode,
19	OperationType,
20	SelectionSetNode,
21	ast_from_value,
22	print_ast,
23	)
24	from graphql.pyutils import FrozenList	1✔
25
26	from .utils import to_camel_case	1✔
27
28	if six.PY3:	1✔
29	from collections.abc import Iterable	1✔
30	else:
31	from collections import Iterable	×
32
33
34	class DSLSchema(object):	1✔
35	def __init__(self, client):	1✔
36	self.client = client	1✔
37
38	@property	1✔
39	def schema(self):	1✔
40	return self.client.schema	1✔
41
42	def __getattr__(self, name):	1✔
43	type_def = self.schema.get_type(name)	1✔
44	return DSLType(type_def)	1✔
45
46	def query(self, args, *kwargs):	1✔
47	return self.execute(query(args, *kwargs))	1✔
48
49	def mutate(self, args, *kwargs):	1✔
50	return self.query(args, operation="mutation", *kwargs)	1✔
51
52	def execute(self, document):	1✔
53	return self.client.execute(document)	1✔
54
55
56	class DSLType(object):	1✔
57	def __init__(self, type_):	1✔
58	self.type = type_	1✔
59
60	def __getattr__(self, name):	1✔
61	formatted_name, field_def = self.get_field(name)	1✔
62	return DSLField(formatted_name, field_def)	1✔
63
64	def get_field(self, name):	1✔
65	camel_cased_name = to_camel_case(name)	1✔
66
67	if name in self.type.fields:	1✔
68	return name, self.type.fields[name]	1✔
69
70	if camel_cased_name in self.type.fields:	1✔
71	return camel_cased_name, self.type.fields[camel_cased_name]	1✔
72
73	raise KeyError(	1✔
74	"Field {} does not exist in type {}.".format(name, self.type.name)
75	)
76
77
78	def selections(*fields):	1✔
79	for _field in fields:	1✔
80	yield selection_field(_field).ast	1✔
81
82
83	class DSLField(object):	1✔
84	def __init__(self, name, field):	1✔
85	self.field = field	1✔
86	self.ast_field = FieldNode(name=NameNode(value=name), arguments=FrozenList())	1✔
87	self.selection_set = None	1✔
88
89	def select(self, *fields):	1✔
90	selection_set = self.ast_field.selection_set	1✔
91	added_selections = selections(*fields)	1✔
92	if selection_set:	1✔
93	selection_set.selections = FrozenList(	×
94	selection_set.selections + added_selections
95	)
96	else:
97	self.ast_field.selection_set = SelectionSetNode(	1✔
98	selections=FrozenList(added_selections)
99	)
100	return self	1✔
101
102	def __call__(self, **kwargs):	1✔
103	return self.args(**kwargs)	1✔
104
105	def alias(self, alias):	1✔
106	self.ast_field.alias = NameNode(value=alias)	1✔
107	return self	1✔
108
109	def args(self, **kwargs):	1✔
110	added_args = []	1✔
111	for name, value in kwargs.items():	1✔
112	arg = self.field.args.get(name)	1✔
113	arg_type_serializer = get_arg_serializer(arg.type)	1✔
114	serialized_value = arg_type_serializer(value)	1✔
115	added_args.append(	1✔
116	ArgumentNode(name=NameNode(value=name), value=serialized_value)
117	)
118	ast_field = self.ast_field	1✔
119	ast_field.arguments = FrozenList(ast_field.arguments + added_args)	1✔
120	return self	1✔
121
122	@property	1✔
123	def ast(self):	1✔
124	return self.ast_field	1✔
125
126	def __str__(self):	1✔
127	return print_ast(self.ast_field)	1✔
128
129
130	def selection_field(field):	1✔
131	if isinstance(field, DSLField):	1✔
132	return field	1✔
133
134	raise Exception('Received incompatible query field: "{}".'.format(field))	1✔
135
136
137	def query(fields, *kwargs):	1✔
138	if "operation" not in kwargs:	1✔
139	kwargs["operation"] = "query"	1✔
140	return DocumentNode(	1✔
141	definitions=[
142	OperationDefinitionNode(
143	operation=OperationType(kwargs["operation"]),
144	selection_set=SelectionSetNode(
145	selections=FrozenList(selections(*fields))
146	),
147	)
148	]
149	)
150
151
152	def serialize_list(serializer, list_values):	1✔
153	assert isinstance(list_values, Iterable), 'Expected iterable, received "{}"'.format(	1✔
154	repr(list_values)
155	)
156	return ListValueNode(values=FrozenList(serializer(v) for v in list_values))	1✔
157
158
159	def get_arg_serializer(arg_type):	1✔
160	if isinstance(arg_type, GraphQLNonNull):	1✔
161	return get_arg_serializer(arg_type.of_type)	1✔
162	if isinstance(arg_type, GraphQLInputField):	1✔
163	return get_arg_serializer(arg_type.type)	1✔
164	if isinstance(arg_type, GraphQLInputObjectType):	1✔
165	serializers = {k: get_arg_serializer(v) for k, v in arg_type.fields.items()}	1✔
166	return lambda value: ObjectValueNode(	1✔
167	fields=FrozenList(
168	ObjectFieldNode(name=NameNode(value=k), value=serializers[k](v))
169	for k, v in value.items()
170	)
171	)
172	if isinstance(arg_type, GraphQLList):	1✔
173	inner_serializer = get_arg_serializer(arg_type.of_type)	1✔
174	return partial(serialize_list, inner_serializer)	1✔
175	if isinstance(arg_type, GraphQLEnumType):	1✔
176	return lambda value: EnumValueNode(value=arg_type.serialize(value))	1✔
177	return lambda value: ast_from_value(arg_type.serialize(value), arg_type)	1✔

graphql-python / gql / 225

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