Updated readme, removed unsupported input unions.

Author: excessdenied

README.md

@@ -15,13 +15,13 @@ pip install "graphene-pydantic"
 Here is a simple Pydantic model:
 
 ```python
+import uuid
 import pydantic
 
 class PersonModel(pydantic.BaseModel):
     id: uuid.UUID
     first_name: str
     last_name: str
-
 ```
 
 To create a GraphQL schema for it you simply have to write the following:
@@ -33,32 +33,81 @@ from graphene_pydantic import PydanticObjectType
 class Person(PydanticObjectType):
     class Meta:
         model = PersonModel
-        # only return specified fields
-        only_fields = ("name",)
         # exclude specified fields
         exclude_fields = ("id",)
 
 class Query(graphene.ObjectType):
     people = graphene.List(Person)
 
-    def resolve_people(self, info):
-        return get_people()  # function returning `PersonModel`s
+    @staticmethod
+    def resolve_people(parent, info):
+        # fetch actual PersonModels here
+        return [PersonModel(id=uuid.uuid4(), first_name="Beth", last_name="Smith")]
 
 schema = graphene.Schema(query=Query)
 ```
 
 Then you can simply query the schema:
 
 ```python
-query = '''
+query = """
     query {
       people {
         firstName,
         lastName
       }
     }
-'''
+"""
 result = schema.execute(query)
+print(result.data['people'][0])
+```
+
+### Input Object Types
+
+You can also create input object types from Pydantic models for mutations and queries:
+
+```python
+from graphene_pydantic import PydanticInputObjectType
+
+class PersonInput(PydanticInputObjectType):
+    class Meta:
+        model = PersonModel
+        # exclude specified fields
+        exclude_fields = ("id",)
+
+class CreatePerson(graphene.Mutation):
+    class Arguments:
+        person = PersonInput()
+
+    Output = Person
+
+    @staticmethod
+    def mutate(parent, info, person):
+        personModel = PersonModel(id=uuid.uuid4(), first_name=person.first_name, last_name=person.last_name)
+        # save PersonModel here
+        return person
+
+class Mutation(graphene.ObjectType):
+    createPerson = CreatePerson.Field()
+
+schema = graphene.Schema(mutation=Mutation)
+```
+
+Then execute with the input:
+
+```python
+mutation = '''
+mutation {
+    createPerson(person: {
+        firstName: "Jerry",
+        lastName: "Smith"
+    }) {
+        firstName
+    }
+}
+'''
+result = schema.execute(mutation)
+print(result.data['createPerson']['firstName'])
 ```
 
 ### Forward declarations and circular references
@@ -210,3 +259,7 @@ If a field on a model is a Union between a class and a subclass (as in our examp
 Python 3.6's typing will not preserve the Union and throws away the annotation for the subclass.
 See [this issue](https://github.com/upsidetravel/graphene-pydantic/issues/11) for more details.
 The solution at present is to use Python 3.7.
+
+##### Unions don't work in Input Object Types
+
+GraphQL currently only supports unions for object types. See [this RFC](https://github.com/graphql/graphql-spec/blob/master/rfcs/InputUnion.md) for the progress on supporting input unions.

graphene_pydantic/inputobjecttype/converters.py

@@ -195,7 +195,7 @@ def convert_generic_python_type(
 ) -> BaseType:  # noqa: C901
     """
     Convert annotated Python generic types into the most appropriate Graphene
-    Field type -- e.g. turn `typing.Union` into a Graphene Union.
+    Field type -- e.g. turn `typing.List` into a Graphene List.
     """
     origin = type_.__origin__
     if not origin:  # pragma: no cover  # this really should be impossible
@@ -204,11 +204,7 @@ def convert_generic_python_type(
     # NOTE: This is a little clumsy, but working with generic types is; it's hard to
     # decide whether the origin type is a subtype of, say, T.Iterable since typical
     # Python functions like `isinstance()` don't work
-    if origin == T.Union:
-        return convert_union_type(
-            type_, field, registry, parent_type=parent_type, model=model
-        )
-    elif origin in (
+    if origin in (
         T.Tuple,
         T.List,
         T.Set,
@@ -237,36 +233,3 @@ def convert_generic_python_type(
         raise ConversionError("Don't know how to handle mappings in Graphene")
     else:
         raise ConversionError(f"Don't know how to handle {type_} (generic: {origin})")
-
-
-def convert_union_type(
-    type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
-):
-    """
-    Convert an annotated Python Union type into a Graphene Union.
-    """
-    inner_types = type_.__args__
-    # We use a little metaprogramming -- create our own unique
-    # subclass of graphene.Union that knows its constituent Graphene types
-    parent_types = tuple(
-        find_graphene_type(x, field, registry, parent_type=parent_type, model=model)
-        for x in inner_types
-        if x != NONE_TYPE
-    )
-
-    # This is effectively a typing.Optional[T], which decomposes into a
-    # typing.Union[None, T] -- we can return the Graphene type for T directly
-    # since Pydantic will have already parsed it as optional
-    if len(parent_types) == 1:
-        return parent_types[0]
-
-    internal_meta_cls = type("Meta", (), {"types": parent_types})
-
-    union_cls = type(
-        construct_union_class_name(inner_types), (Union,), {"Meta": internal_meta_cls}
-    )
-    return union_cls