First working version class types

Author: syrusakbary

graphene/core/classtypes/__init__.py

@@ -0,0 +1,109 @@
+from collections import OrderedDict
+import inspect
+import six
+
+from ..exceptions import SkipField
+from .options import Options
+
+
+class ClassTypeMeta(type):
+    options_class = Options
+
+    def __new__(mcs, name, bases, attrs):
+        super_new = super(ClassTypeMeta, mcs).__new__
+
+        module = attrs.pop('__module__', None)
+        doc = attrs.pop('__doc__', None)
+        new_class = super_new(mcs, name, bases, {
+            '__module__': module,
+            '__doc__': doc
+        })
+        attr_meta = attrs.pop('Meta', None)
+        if not attr_meta:
+            meta = getattr(new_class, 'Meta', None)
+        else:
+            meta = attr_meta
+
+        new_class.add_to_class('_meta', new_class.get_options(meta))
+
+        return mcs.construct(new_class, bases, attrs)
+
+    def get_options(cls, meta):
+        return cls.options_class(meta)
+
+    def add_to_class(cls, name, value):
+        # We should call the contribute_to_class method only if it's bound
+        if not inspect.isclass(value) and hasattr(
+                value, 'contribute_to_class'):
+            value.contribute_to_class(cls, name)
+        else:
+            setattr(cls, name, value)
+
+    def construct(cls, bases, attrs):
+        # Add all attributes to the class.
+        for obj_name, obj in attrs.items():
+            cls.add_to_class(obj_name, obj)
+        return cls
+
+
+class ClassType(six.with_metaclass(ClassTypeMeta)):
+    @classmethod
+    def internal_type(cls, schema):
+        raise NotImplementedError("Function internal_type not implemented in type {}".format(cls))
+
+
+class FieldsOptions(Options):
+    def __init__(self, *args, **kwargs):
+        super(FieldsOptions, self).__init__(*args, **kwargs)
+        self.local_fields = []
+
+    def add_field(self, field):
+        self.local_fields.append(field)
+
+    @property
+    def fields(self):
+        return sorted(self.local_fields)
+
+    @property
+    def fields_map(self):
+        return OrderedDict([(f.attname, f) for f in self.fields])
+
+
+class FieldsClassTypeMeta(ClassTypeMeta):
+    options_class = FieldsOptions
+
+
+class FieldsClassType(six.with_metaclass(FieldsClassTypeMeta, ClassType)):
+    @classmethod
+    def fields_internal_types(cls, schema):
+        fields = []
+        for field in cls._meta.fields:
+            try:
+                fields.append((field.name, schema.T(field)))
+            except SkipField:
+                continue
+
+        return OrderedDict(fields)
+
+# class NamedClassType(ClassType):
+#     pass
+
+
+# class UnionType(NamedClassType):
+#     class Meta:
+#         abstract = True
+
+
+# class ObjectType(NamedClassType):
+#     class Meta:
+#         abstract = True
+
+
+# class InputObjectType(NamedClassType):
+#     class Meta:
+#         abstract = True
+
+
+# class Mutation(ObjectType):
+#     class Meta:
+#         abstract = True

graphene/core/classtypes/base.py

@@ -0,0 +1,24 @@
+from functools import partial
+
+from graphql.core.type import GraphQLInputObjectType
+
+from .base import FieldsClassType
+
+
+class InputObjectType(FieldsClassType):
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args, **kwargs):
+        raise Exception("An InputObjectType cannot be initialized")
+
+    @classmethod
+    def internal_type(cls, schema):
+        if cls._meta.abstract:
+            raise Exception("Abstract InputObjectTypes don't have a specific type.")
+
+        return GraphQLInputObjectType(
+            cls._meta.type_name,
+            description=cls._meta.description,
+            fields=partial(cls.fields_internal_types, schema),
+        )

graphene/core/classtypes/inputobjecttype.py

@@ -0,0 +1,54 @@
+import six
+from functools import partial
+
+from graphql.core.type import GraphQLInterfaceType
+
+from .base import FieldsClassTypeMeta
+from .objecttype import ObjectType, ObjectTypeMeta
+
+
+class InterfaceMeta(ObjectTypeMeta):
+    def construct(cls, bases, attrs):
+        if cls._meta.abstract or Interface in bases:
+            # Return Interface type
+            cls = FieldsClassTypeMeta.construct(cls, bases, attrs)
+            setattr(cls._meta, 'interface', True)
+            return cls
+        else:
+            # Return ObjectType class with all the inherited interfaces
+            cls = super(InterfaceMeta, cls).construct(bases, attrs)
+            for interface in bases:
+                is_interface = issubclass(interface, Interface) and getattr(interface._meta, 'interface', False)
+                if not is_interface:
+                    continue
+                cls._meta.interfaces.append(interface)
+            return cls
+
+
+class Interface(six.with_metaclass(InterfaceMeta, ObjectType)):
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args, **kwargs):
+        if self._meta.interface:
+            raise Exception("An interface cannot be initialized")
+        return super(Interface, self).__init__(*args, **kwargs)
+
+    @classmethod
+    def _resolve_type(cls, schema, instance, *args):
+        return schema.T(instance.__class__)
+
+    @classmethod
+    def internal_type(cls, schema):
+        if cls._meta.abstract:
+            raise Exception("Abstract Interfaces don't have a specific type.")
+
+        if not cls._meta.interface:
+            return super(Interface, cls).internal_type(schema)
+
+        return GraphQLInterfaceType(
+            cls._meta.type_name,
+            description=cls._meta.description,
+            resolve_type=partial(cls._resolve_type, schema),
+            fields=partial(cls.fields_internal_types, schema)
+        )

graphene/core/classtypes/interface.py

@@ -0,0 +1,30 @@
+import six
+
+from ..types.argument import ArgumentsGroup
+from .objecttype import ObjectType, ObjectTypeMeta
+
+
+class MutationMeta(ObjectTypeMeta):
+    def construct(cls, bases, attrs):
+        input_class = attrs.pop('Input', None)
+        if input_class:
+            items = dict(vars(input_class))
+            items.pop('__dict__', None)
+            items.pop('__doc__', None)
+            items.pop('__module__', None)
+            items.pop('__weakref__', None)
+            cls.add_to_class('arguments', cls.construct_arguments(items))
+        cls = super(MutationMeta, cls).construct(bases, attrs)
+        return cls
+
+    def construct_arguments(cls, items):
+        return ArgumentsGroup(**items)
+
+
+class Mutation(six.with_metaclass(MutationMeta, ObjectType)):
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def get_arguments(cls):
+        return cls.arguments

graphene/core/classtypes/mutation.py

@@ -0,0 +1,99 @@
+import six
+from functools import partial
+
+from graphql.core.type import GraphQLObjectType
+
+from graphene import signals
+from .base import FieldsOptions, FieldsClassType, FieldsClassTypeMeta
+from .uniontype import UnionType
+
+
+def is_objecttype(cls):
+    if not issubclass(cls, ObjectType):
+        return False
+    return not cls._meta.interface
+
+
+class ObjectTypeOptions(FieldsOptions):
+    def __init__(self, *args, **kwargs):
+        super(ObjectTypeOptions, self).__init__(*args, **kwargs)
+        self.interface = False
+        self.interfaces = []
+
+
+class ObjectTypeMeta(FieldsClassTypeMeta):
+    def construct(cls, bases, attrs):
+        cls = super(ObjectTypeMeta, cls).construct(bases, attrs)
+        if not cls._meta.abstract:
+            union_types = list(filter(is_objecttype, bases))
+            if len(union_types) > 1:
+                meta_attrs = dict(cls._meta.original_attrs, types=union_types)
+                Meta = type('Meta', (object, ), meta_attrs)
+                attrs['Meta'] = Meta
+                attrs['__module__'] = cls.__module__
+                attrs['__doc__'] = cls.__doc__
+                return type(cls.__name__, (UnionType, ), attrs)
+        return cls
+
+    options_class = ObjectTypeOptions
+
+
+class ObjectType(six.with_metaclass(ObjectTypeMeta, FieldsClassType)):
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args, **kwargs):
+        signals.pre_init.send(self.__class__, args=args, kwargs=kwargs)
+        self._root = kwargs.pop('_root', None)
+        args_len = len(args)
+        fields = self._meta.fields
+        if args_len > len(fields):
+            # Daft, but matches old exception sans the err msg.
+            raise IndexError("Number of args exceeds number of fields")
+        fields_iter = iter(fields)
+
+        if not kwargs:
+            for val, field in zip(args, fields_iter):
+                setattr(self, field.attname, val)
+        else:
+            for val, field in zip(args, fields_iter):
+                setattr(self, field.attname, val)
+                kwargs.pop(field.attname, None)
+
+        for field in fields_iter:
+            try:
+                val = kwargs.pop(field.attname)
+                setattr(self, field.attname, val)
+            except KeyError:
+                pass
+
+        if kwargs:
+            for prop in list(kwargs):
+                try:
+                    if isinstance(getattr(self.__class__, prop), property):
+                        setattr(self, prop, kwargs.pop(prop))
+                except AttributeError:
+                    pass
+            if kwargs:
+                raise TypeError(
+                    "'%s' is an invalid keyword argument for this function" %
+                    list(kwargs)[0])
+
+        signals.post_init.send(self.__class__, instance=self)
+
+    @classmethod
+    def internal_type(cls, schema):
+        if cls._meta.abstract:
+            raise Exception("Abstract ObjectTypes don't have a specific type.")
+
+        return GraphQLObjectType(
+            cls._meta.type_name,
+            description=cls._meta.description,
+            interfaces=[schema.T(i) for i in cls._meta.interfaces],
+            fields=partial(cls.fields_internal_types, schema),
+            is_type_of=getattr(cls, 'is_type_of', None)
+        )
+
+    @classmethod
+    def wrap(cls, instance, args, info):
+        return cls(_root=instance)

graphene/core/classtypes/objecttype.py

@@ -0,0 +1,47 @@
+class Options(object):
+    def __init__(self, meta=None, **defaults):
+        self.meta = meta
+        self.abstract = False
+        for name, value in defaults.items():
+            setattr(self, name, value)
+        self.valid_attrs = list(defaults.keys()) + ['type_name', 'description', 'abstract']
+
+    def contribute_to_class(self, cls, name):
+        cls._meta = self
+        self.parent = cls
+        # First, construct the default values for these options.
+        self.object_name = cls.__name__
+        self.type_name = self.object_name
+
+        self.description = cls.__doc__
+        # Store the original user-defined values for each option,
+        # for use when serializing the model definition
+        self.original_attrs = {}
+
+        # Next, apply any overridden values from 'class Meta'.
+        if self.meta:
+            meta_attrs = self.meta.__dict__.copy()
+            for name in self.meta.__dict__:
+                # Ignore any private attributes that Django doesn't care about.
+                # NOTE: We can't modify a dictionary's contents while looping
+                # over it, so we loop over the *original* dictionary instead.
+                if name.startswith('_'):
+                    del meta_attrs[name]
+            for attr_name in self.valid_attrs:
+                if attr_name in meta_attrs:
+                    setattr(self, attr_name, meta_attrs.pop(attr_name))
+                    self.original_attrs[attr_name] = getattr(self, attr_name)
+                elif hasattr(self.meta, attr_name):
+                    setattr(self, attr_name, getattr(self.meta, attr_name))
+                    self.original_attrs[attr_name] = getattr(self, attr_name)
+
+            del self.valid_attrs
+
+            # Any leftover attributes must be invalid.
+            if meta_attrs != {}:
+                raise TypeError(
+                    "'class Meta' got invalid attribute(s): %s" %
+                    ','.join(
+                        meta_attrs.keys()))
+
+        del self.meta

graphene/core/classtypes/options.py

@@ -0,0 +1,21 @@
+from graphql.core.type import GraphQLScalarType
+
+from .base import ClassType
+from ..types.base import MountedType
+
+
+class Scalar(ClassType, MountedType):
+
+    @classmethod
+    def internal_type(cls, schema):
+        serialize = getattr(cls, 'serialize')
+        parse_literal = getattr(cls, 'parse_literal')
+        parse_value = getattr(cls, 'parse_value')
+
+        return GraphQLScalarType(
+            name=cls._meta.type_name,
+            description=cls._meta.description,
+            serialize=serialize,
+            parse_value=parse_value,
+            parse_literal=parse_literal
+        )