Refactored inputobjectype and objecttype to share converters and registry.

Refactored Registry to be generic.
Added convert_pydantic_input_field.
Removed unused model param in Registry.register_object_field().

Author: excessdenied

graphene_pydantic/__init__.py

@@ -1,4 +1,4 @@
-from .inputobjecttype.types import PydanticInputObjectType
-from .objecttype.types import PydanticObjectType
+from .inputobjecttype import PydanticInputObjectType
+from .objecttype import PydanticObjectType
 
 __all__ = ["PydanticObjectType", "PydanticInputObjectType"]

graphene_pydantic/objecttype/converters.py renamed to graphene_pydantic/converters.py

@@ -7,14 +7,25 @@
 import typing as T
 import uuid
 
-from graphene import UUID, Boolean, Enum, Field, Float, Int, List, String, Union
+from graphene import (
+    UUID,
+    Boolean,
+    Enum,
+    Field,
+    Float,
+    InputField,
+    Int,
+    List,
+    String,
+    Union,
+)
 from graphene.types.base import BaseType
 from graphene.types.datetime import Date, DateTime, Time
 from pydantic import BaseModel
-from pydantic.fields import Field as PydanticField
+from pydantic.fields import ModelField
 
-from ..util import construct_union_class_name
 from .registry import Registry
+from .util import construct_union_class_name
 
 try:
     # Pydantic pre-1.0
@@ -72,8 +83,38 @@ def _get_field(root, _info):
     return _get_field
 
 
+def convert_pydantic_input_field(
+    field: ModelField,
+    registry: Registry,
+    parent_type: T.Type = None,
+    model: T.Type[BaseModel] = None,
+    **field_kwargs,
+) -> InputField:
+    """
+    Convert a Pydantic model field into a Graphene type field that we can add
+    to the generated Graphene data model type.
+    """
+    print("convert_pydantic_input_field", type(field))
+    declared_type = getattr(field, "type_", None)
+    field_kwargs.setdefault(
+        "type",
+        convert_pydantic_type(
+            declared_type, field, registry, parent_type=parent_type, model=model
+        ),
+    )
+    field_kwargs.setdefault("required", field.required)
+    field_kwargs.setdefault("default_value", field.default)
+    # TODO: find a better way to get a field's description. Some ideas include:
+    # - hunt down the description from the field's schema, or the schema
+    #   from the field's base model
+    # - maybe even (Sphinx-style) parse attribute documentation
+    field_kwargs.setdefault("description", field.__doc__)
+
+    return InputField(**field_kwargs)
+
+
 def convert_pydantic_field(
-    field: PydanticField,
+    field: ModelField,
     registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
@@ -83,6 +124,7 @@ def convert_pydantic_field(
     Convert a Pydantic model field into a Graphene type field that we can add
     to the generated Graphene data model type.
     """
+    print("convert_pydantic_field", type(field))
     declared_type = getattr(field, "type_", None)
     field_kwargs.setdefault(
         "type",
@@ -103,8 +145,8 @@ def convert_pydantic_field(
 
 def convert_pydantic_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -127,8 +169,8 @@ def convert_pydantic_type(
 
 def find_graphene_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -200,8 +242,8 @@ def find_graphene_type(
 
 def convert_generic_python_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
@@ -253,8 +295,8 @@ def convert_generic_python_type(
 
 def convert_union_type(
     type_: T.Type,
-    field: PydanticField,
-    registry: Registry = None,
+    field: ModelField,
+    registry: Registry,
     parent_type: T.Type = None,
     model: T.Type[BaseModel] = None,
 ):

graphene_pydantic/inputobjecttype/types.py renamed to graphene_pydantic/inputobjecttype.py

@@ -2,10 +2,11 @@
 
 import graphene
 import pydantic
+from graphene import InputField
 from graphene.types.inputobjecttype import InputObjectTypeOptions
 from graphene.types.utils import yank_fields_from_attrs
 
-from .converters import convert_pydantic_field
+from .converters import convert_pydantic_input_field
 from .registry import Placeholder, Registry, get_global_registry
 
 
@@ -23,7 +24,7 @@ def construct_fields(
     registry: Registry,
     only_fields: T.Tuple[str, ...],
     exclude_fields: T.Tuple[str, ...],
-) -> T.Dict[str, graphene.Field]:
+) -> T.Dict[str, graphene.InputField]:
     """
     Construct all the fields for a PydanticInputObjectType.
 
@@ -43,10 +44,10 @@ def construct_fields(
 
     fields = {}
     for name, field in fields_to_convert:
-        converted = convert_pydantic_field(
+        converted = convert_pydantic_input_field(
             field, registry, parent_type=obj_type, model=model
         )
-        registry.register_object_field(obj_type, name, field, model=model)
+        registry.register_object_field(obj_type, name, field)
         fields[name] = converted
     return fields
 
@@ -83,7 +84,7 @@ def __init_subclass_with_meta__(
             )
 
         if not registry:
-            registry = get_global_registry()
+            registry = get_global_registry(PydanticInputObjectType)
 
         pydantic_fields = yank_fields_from_attrs(
             construct_fields(
@@ -93,7 +94,7 @@ def __init_subclass_with_meta__(
                 only_fields=only_fields,
                 exclude_fields=exclude_fields,
             ),
-            _as=graphene.Field,
+            _as=graphene.InputField,
             sort=False,
         )