Removed unnecessary files.

graphene/generators/__init__.py

@@ -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,
-    )

graphene/generators/utils.py

@@ -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

graphene/types/enum.py

@@ -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

graphene/types/typemap.py

@@ -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)

graphene/utils/as_field.py

@@ -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))

graphene/utils/copy_fields.py

@@ -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)

graphene/utils/get_fields.py

@@ -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)

graphene/utils/get_graphql_type.py

@@ -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))

graphene/utils/is_base_type.py

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

graphene/utils/is_graphene_type.py

@@ -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
-    ))

graphene/utils/tests/test_get_fields.py

@@ -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,
-    ]

graphene/utils/tests/test_get_graphql_type.py

@@ -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)

graphene/utils/tests/test_is_graphene_type.py

@@ -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)