graphql-python/graphene
1
1
Fork 0
mirror of https://github.com/graphql-python/graphene.git synced 2025-02-08 23:50:38 +03:00
Code Issues Packages Projects Releases Wiki Activity

Removed unnecessary files.

Browse Source
This commit is contained in:
Syrus Akbary 2016-08-13 23:05:43 -07:00
parent 7804f10732
commit 3f3bb113ce
14 changed files with 6 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
graphene/generators/__init__.py
View File

@ -1,59 +0,0 @@
from .definitions import (
GrapheneInterfaceType,
GrapheneObjectType,
GrapheneScalarType,
GrapheneEnumType,
GrapheneInputObjectType
)
from .utils import values_from_enum
def generate_interface(interface):
return GrapheneInterfaceType(
graphene_type=interface,
name=interface._meta.name or interface.__name__,
resolve_type=interface.resolve_type,
description=interface._meta.description or interface.__doc__,
fields=interface._meta.get_fields,
)
def generate_objecttype(objecttype):
return GrapheneObjectType(
graphene_type=objecttype,
name=objecttype._meta.name or objecttype.__name__,
description=objecttype._meta.description or objecttype.__doc__,
fields=objecttype._meta.get_fields,
is_type_of=objecttype.is_type_of,
interfaces=objecttype._meta.get_interfaces
)
def generate_scalar(scalar):
return GrapheneScalarType(
graphene_type=scalar,
name=scalar._meta.name or scalar.__name__,
description=scalar._meta.description or scalar.__doc__,
serialize=getattr(scalar, 'serialize', None),
parse_value=getattr(scalar, 'parse_value', None),
parse_literal=getattr(scalar, 'parse_literal', None),
)
def generate_enum(enum):
return GrapheneEnumType(
graphene_type=enum,
values=values_from_enum(enum._meta.enum),
name=enum._meta.name or enum.__name__,
description=enum._meta.description or enum.__doc__,
)
def generate_inputobjecttype(inputobjecttype):
return GrapheneInputObjectType(
graphene_type=inputobjecttype,
name=inputobjecttype._meta.name or inputobjecttype.__name__,
description=inputobjecttype._meta.description or inputobjecttype.__doc__,
fields=inputobjecttype._meta.get_fields,
)

15
graphene/generators/utils.py
View File

@ -1,15 +0,0 @@
from collections import OrderedDict
from graphql.type import GraphQLEnumValue
def values_from_enum(enum):
_values = OrderedDict()
for name, value in enum.__members__.items():
_values[name] = GraphQLEnumValue(
name=name,
value=value.value,
description=getattr(value, 'description', None),
deprecation_reason=getattr(value, 'deprecation_reason', None)
)
return _values

0
graphene/generators/definitions.py → graphene/types/definitions.py
View File

1
graphene/types/enum.py
View File

@ -2,7 +2,6 @@ from collections import OrderedDict
import six
from ..generators import generate_enum
from ..utils.is_base_type import is_base_type
from .options import Options
from .unmountedtype import UnmountedType

12
graphene/types/typemap.py
View File

@ -74,7 +74,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_scalar(cls, map, type):
from ..generators.definitions import GrapheneScalarType
from .definitions import GrapheneScalarType
_scalars = {
String: GraphQLString,
Int: GraphQLInt,
@ -98,7 +98,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_enum(cls, map, type):
from ..generators.definitions import GrapheneEnumType
from .definitions import GrapheneEnumType
values = OrderedDict()
for name, value in type._meta.enum.__members__.items():
values[name] = GraphQLEnumValue(
@ -117,7 +117,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_objecttype(cls, map, type):
from ..generators.definitions import GrapheneObjectType
from .definitions import GrapheneObjectType
map[type._meta.name] = GrapheneObjectType(
graphene_type=type,
name=type._meta.name,
@ -137,7 +137,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_interface(cls, map, type):
from ..generators.definitions import GrapheneInterfaceType
from .definitions import GrapheneInterfaceType
map[type._meta.name] = GrapheneInterfaceType(
graphene_type=type,
name=type._meta.name,
@ -151,7 +151,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_inputobjecttype(cls, map, type):
from ..generators.definitions import GrapheneInputObjectType
from .definitions import GrapheneInputObjectType
map[type._meta.name] = GrapheneInputObjectType(
graphene_type=type,
name=type._meta.name,
@ -163,7 +163,7 @@ class TypeMap(GraphQLTypeMap):
@classmethod
def construct_union(cls, map, type):
from ..generators.definitions import GrapheneUnionType
from .definitions import GrapheneUnionType
types = []
for i in type._meta.types:
map = cls.construct_objecttype(map, i)

10
graphene/utils/as_field.py
View File

@ -1,10 +0,0 @@
from ..types.field import Field
from ..types.unmountedtype import UnmountedType
def as_field(value):
if isinstance(value, UnmountedType):
return value.as_field()
elif isinstance(value, Field):
return value
raise Exception("{} is not a field".format(value))

16
graphene/utils/copy_fields.py
View File

@ -1,16 +0,0 @@
from collections import OrderedDict
from ..types.field import Field, InputField
def copy_fields(like, fields, **extra):
_fields = []
for attname, field in fields.items():
if isinstance(field, (Field, InputField)):
copy_and_extend = field.copy_and_extend
else:
copy_and_extend = like.copy_and_extend
field = copy_and_extend(field, attname=getattr(field, 'attname', None) or attname, **extra)
_fields.append(field)
return OrderedDict((f.name, f) for f in _fields)

80
graphene/utils/get_fields.py
View File

@ -1,80 +0,0 @@
from collections import OrderedDict
from ..types.field import Field, InputField
from ..types.unmountedtype import UnmountedType
from .get_graphql_type import get_graphql_type
from .is_graphene_type import is_graphene_type
def unmounted_field_in_type(unmounted_field, type):
'''
Mount the UnmountedType dinamically as Field or InputField
depending on where mounted in.
ObjectType -> Field
InputObjectType -> InputField
'''
from ..types.inputobjecttype import InputObjectType
from ..types.objecttype import ObjectType
from ..types.interface import Interface
if issubclass(type, (ObjectType, Interface)):
return unmounted_field.as_field()
elif issubclass(type, (InputObjectType)):
return unmounted_field.as_inputfield()
raise Exception('Unmounted field "{}" cannot be mounted in {}'.format(self.get_type(), type))
def get_fields_from_attrs(in_type, attrs):
for attname, value in list(attrs.items()):
if isinstance(value, (Field, InputField)):
yield attname, value
elif isinstance(value, UnmountedType):
yield attname, unmounted_field_in_type(value, in_type)
def get_fields_from_bases_and_types(bases, types):
fields = set()
for _class in bases:
if not is_graphene_type(_class):
continue
_fields = _class._meta.get_fields()
if callable(_fields):
_fields = _fields()
for default_attname, field in _fields.items():
attname = getattr(field, 'attname', default_attname)
if attname in fields:
continue
fields.add(attname)
yield attname, field
for grapqhl_type in types:
for attname, field in get_graphql_type(grapqhl_type).get_fields().items():
if attname in fields:
continue
fields.add(attname)
yield attname, field
def get_fields(in_type, attrs, bases, graphql_types=()):
fields = []
extended_fields = list(get_fields_from_bases_and_types(bases, graphql_types))
local_fields = list(get_fields_from_attrs(in_type, attrs))
# We asume the extended fields are already sorted, so we only
# have to sort the local fields, that are get from attrs
# and could be unordered as is a dict and not OrderedDict
local_fields = sorted(local_fields, key=lambda kv: kv[1])
field_names = set(f[0] for f in local_fields)
for name, extended_field in extended_fields:
if name in field_names:
continue
fields.append((name, extended_field))
field_names.add(name)
fields.extend(local_fields)
return OrderedDict(fields)

12
graphene/utils/get_graphql_type.py
View File

@ -1,12 +0,0 @@
from graphql.type.definition import is_type
from .is_graphene_type import is_graphene_type
def get_graphql_type(_type):
if is_type(_type):
return _type
elif is_graphene_type(_type):
return _type._meta.graphql_type
raise Exception("Cannot get GraphQL type of {}.".format(_type))

2
graphene/utils/is_base_type.py
View File

@ -1,2 +0,0 @@
def is_base_type(bases, _type):
return any(b for b in bases if isinstance(b, _type))

19
graphene/utils/is_graphene_type.py
View File

@ -1,19 +0,0 @@
import inspect
def is_graphene_type(_type):
from ..types.objecttype import ObjectType
from ..types.mutation import Mutation
from ..types.inputobjecttype import InputObjectType
from ..types.interface import Interface
from ..types.scalars import Scalar
from ..types.enum import Enum
return inspect.isclass(_type) and hasattr(_type, '_meta') and issubclass(_type, (
Interface,
ObjectType,
InputObjectType,
Scalar,
Mutation,
Enum
))

42
graphene/utils/tests/test_get_fields.py
View File

@ -1,42 +0,0 @@
from collections import OrderedDict
from graphql import (GraphQLField, GraphQLFloat, GraphQLInt,
GraphQLInterfaceType, GraphQLString)
from ...types import Argument, Field, ObjectType, String
from ..get_fields import get_fields_from_attrs, get_fields_from_bases_and_types
def test_get_fields_from_attrs():
attrs = OrderedDict((
('field_string', Field(String)),
('string', String()),
('other', None),
('argument', Argument(String)),
('graphql_field', GraphQLField(GraphQLString)),
))
extracted_fields = OrderedDict(get_fields_from_attrs(ObjectType, attrs))
assert [f for f in extracted_fields.keys()] == ['field_string', 'string']
def test_get_fields_from_types():
int_base = GraphQLInterfaceType('IntInterface', fields=OrderedDict([
('int', GraphQLField(GraphQLInt)),
('num', GraphQLField(GraphQLInt)),
('extra', GraphQLField(GraphQLInt))
]))
float_base = GraphQLInterfaceType('FloatInterface', fields=OrderedDict([
('float', GraphQLField(GraphQLFloat)),
('num', GraphQLField(GraphQLFloat)),
('extra', GraphQLField(GraphQLFloat))
]))
_types = (int_base, float_base)
base_fields = OrderedDict(get_fields_from_bases_and_types((), _types))
assert [f for f in base_fields.keys()] == ['int', 'num', 'extra', 'float']
assert [f.type for f in base_fields.values()] == [
GraphQLInt,
GraphQLInt,
GraphQLInt,
GraphQLFloat,
]

38
graphene/utils/tests/test_get_graphql_type.py
View File

@ -1,38 +0,0 @@
import pytest
from graphene.types import ObjectType
from graphql import GraphQLField, GraphQLObjectType, GraphQLString
from graphql.type.definition import is_type
from ..get_graphql_type import get_graphql_type
MyGraphQLType = GraphQLObjectType('MyGraphQLType', fields={
'field': GraphQLField(GraphQLString)
})
def test_get_graphql_type_graphene():
class MyGrapheneType(ObjectType):
pass
assert is_type(get_graphql_type(MyGrapheneType))
def test_get_graphql_type_custom_graphene_type():
class MyGrapheneType(ObjectType):
class Meta:
graphql_type = MyGraphQLType
assert get_graphql_type(MyGrapheneType) == MyGraphQLType
def test_get_graphql_type_graphql_type():
assert get_graphql_type(MyGraphQLType) == MyGraphQLType
def test_get_graphql_type_unknown_type():
with pytest.raises(Exception) as excinfo:
get_graphql_type(object)
assert "Cannot get GraphQL type" in str(excinfo.value)

23
graphene/utils/tests/test_is_graphene_type.py
View File

@ -1,23 +0,0 @@
from graphene.types import ObjectType
from graphql import GraphQLField, GraphQLObjectType, GraphQLString
from ..is_graphene_type import is_graphene_type
def test_is_graphene_type_objecttype():
class MyObjectType(ObjectType):
pass
assert is_graphene_type(MyObjectType)
def test_is_graphene_type_graphqltype():
MyGraphQLType = GraphQLObjectType('MyGraphQLType', fields={
'field': GraphQLField(GraphQLString)
})
assert not is_graphene_type(MyGraphQLType)
def test_is_graphene_type_other():
MyObject = object()
assert not is_graphene_type(MyObject)