feat: added support for v2

deprecated: pydantic v1

Author: mak626

graphene_pydantic/converters.py

@@ -2,58 +2,26 @@
 import collections.abc
 import datetime
 import decimal
-import inspect
 import enum
+import inspect
 import sys
 import typing as T
 import uuid
-from bson import ObjectId
 
-from graphene import (
-    UUID,
-    Boolean,
-    Enum,
-    Field,
-    Float,
-    InputField,
-    Int,
-    List,
-    String,
-    Union,
-    JSONString,
-    ID
-)
 import graphene
+from bson import ObjectId
+from graphene import (Boolean, Enum, Field, Float, ID, InputField, Int, JSONString, List, String, UUID, Union)
 from graphene.types.base import BaseType
 from graphene.types.datetime import Date, DateTime, Time
 from pydantic import BaseModel
-from pydantic.fields import ModelField
-from pydantic.typing import evaluate_forwardref
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
 
 from .registry import Registry
 from .util import construct_union_class_name
 
-from pydantic import fields
-
 GRAPHENE2 = graphene.VERSION[0] < 3
 
-SHAPE_SINGLETON = (fields.SHAPE_SINGLETON,)
-SHAPE_SEQUENTIAL = (
-    fields.SHAPE_LIST,
-    fields.SHAPE_TUPLE,
-    fields.SHAPE_TUPLE_ELLIPSIS,
-    fields.SHAPE_SEQUENCE,
-    fields.SHAPE_SET,
-)
-
-if hasattr(fields, "SHAPE_DICT"):
-    SHAPE_MAPPING = T.cast(
-        T.Tuple, (fields.SHAPE_MAPPING, fields.SHAPE_DICT, fields.SHAPE_DEFAULTDICT)
-    )
-else:
-    SHAPE_MAPPING = T.cast(T.Tuple, (fields.SHAPE_MAPPING,))
-
-
 try:
     from graphene.types.decimal import Decimal as GrapheneDecimal
 
@@ -62,7 +30,6 @@
     # graphene 2.1.5+ is required for Decimals
     DECIMAL_SUPPORTED = False
 
-
 NONE_TYPE = None.__class__  # need to do this because mypy complains about type(None)
 
 
@@ -83,82 +50,89 @@ def _get_field(root, _info):
 
 
 def convert_pydantic_input_field(
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
-    **field_kwargs,
+        field: FieldInfo,
+        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.
     """
-    declared_type = getattr(field, "type_", None)
+    declared_type = getattr(field, "annotation", None)
     field_kwargs.setdefault(
         "type" if GRAPHENE2 else "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)
+    field_kwargs.setdefault("required", field.is_required())
+    field_kwargs.setdefault("default_value", None if PydanticUndefined else 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.field_info.description)
+    field_kwargs.setdefault("description", field.description)
 
     return InputField(**field_kwargs)
 
 
 def convert_pydantic_field(
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
-    **field_kwargs,
+        name: str,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
+        **field_kwargs,
 ) -> Field:
     """
     Convert a Pydantic model field into a Graphene type field that we can add
     to the generated Graphene data model type.
     """
-    declared_type = getattr(field, "type_", None)
+    declared_type = getattr(field, "annotation", None)
     field_kwargs.setdefault(
         "type" if GRAPHENE2 else "type_",
         convert_pydantic_type(
             declared_type, field, registry, parent_type=parent_type, model=model
         ),
     )
-    field_kwargs.setdefault("required", not field.allow_none)
-    field_kwargs.setdefault("default_value", field.default)
-    if field.has_alias:
+    field_kwargs.setdefault(
+        "required",
+        field.is_required() or (
+                type(field.default) is not PydanticUndefined and
+                getattr(declared_type, '_name', '') != 'Optional'
+        )
+    )
+    field_kwargs.setdefault("default_value", None if type(field.default) is PydanticUndefined else field.default)
+    if field.alias:
         field_kwargs.setdefault("name", field.alias)
     # 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.field_info.description)
+    field_kwargs.setdefault("description", field.description)
 
     # Handle Graphene 2 and 3
     field_type = field_kwargs.pop("type", field_kwargs.pop("type_", None))
     if field_type is None:
         raise ValueError("No field type could be determined.")
 
-    resolver_function = getattr(parent_type, "resolve_" + field.name, None)
+    resolver_function = getattr(parent_type, "resolve_" + name, None)
     if resolver_function and callable(resolver_function):
         field_resolver = resolver_function
     else:
-        field_resolver = get_attr_resolver(field.name)
+        field_resolver = get_attr_resolver(name)
 
     return Field(field_type, resolver=field_resolver, **field_kwargs)
 
 
 def convert_pydantic_type(
-    type_: T.Type,
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
+        type_: T.Type,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
     """
     Convert a Pydantic type to a Graphene Field type, including not just the
@@ -168,21 +142,23 @@ def convert_pydantic_type(
     graphene_type = find_graphene_type(
         type_, field, registry, parent_type=parent_type, model=model
     )
-    if field.shape in SHAPE_SINGLETON:
-        return graphene_type
-    elif field.shape in SHAPE_SEQUENTIAL:
-        # TODO: _should_ Sets remain here?
+    field_type = getattr(field.annotation, '__origin__', None)
+
+    # TODO: _should_ Sets remain here?
+    if field_type in [list, set, tuple]:  # SHAPE_SEQUENTIAL
         return List(graphene_type)
-    elif field.shape in SHAPE_MAPPING:
+    if field_type == map:  # SHAPE_MAPPING
         raise ConversionError("Don't know how to handle mappings in Graphene.")
 
+    return graphene_type
+
 
 def find_graphene_type(
-    type_: T.Type,
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
+        type_: T.Type,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
     """
     Map a native Python type to a Graphene-supported Field type, where possible,
@@ -216,8 +192,8 @@ def find_graphene_type(
     elif registry and registry.get_type_for_model(type_):
         return registry.get_type_for_model(type_)
     elif registry and (
-        isinstance(type_, BaseModel)
-        or (inspect.isclass(type_) and issubclass(type_, BaseModel))
+            isinstance(type_, BaseModel)
+            or (inspect.isclass(type_) and issubclass(type_, BaseModel))
     ):
         # If it's a Pydantic model that hasn't yet been wrapped with a ObjectType,
         # we can put a placeholder in and request that `resolve_placeholders()`
@@ -238,12 +214,12 @@ def find_graphene_type(
         if not sibling:
             raise ConversionError(
                 "Don't know how to convert the Pydantic field "
-                f"{field!r} ({field.type_}), could not resolve "
+                f"{field!r} ({field.annotation}), could not resolve "
                 "the forward reference. Did you call `resolve_placeholders()`? "
                 "See the README for more on forward references."
             )
         module_ns = sys.modules[sibling.__module__].__dict__
-        resolved = evaluate_forwardref(type_, module_ns, None)
+        resolved = T.cast(T.Any, type_)._evaluate(type_, module_ns, None)
         # TODO: make this behavior optional. maybe this is a place for the TypeOptions to play a role?
         if registry:
             registry.add_placeholder_for_model(resolved)
@@ -277,11 +253,11 @@ def find_graphene_type(
 
 
 def convert_generic_python_type(
-    type_: T.Type,
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
+        type_: T.Type,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
 ) -> BaseType:  # noqa: C901
     """
     Convert annotated Python generic types into the most appropriate Graphene
@@ -303,13 +279,13 @@ def convert_generic_python_type(
             type_, field, registry, parent_type=parent_type, model=model
         )
     elif origin in (
-        T.Tuple,
-        T.List,
-        T.Set,
-        T.Collection,
-        T.Iterable,
-        list,
-        set,
+            T.Tuple,
+            T.List,
+            T.Set,
+            T.Collection,
+            T.Iterable,
+            list,
+            set,
     ) or issubclass(origin, collections.abc.Sequence):
         # TODO: find a better way of divining that the origin is sequence-like
         inner_types = getattr(type_, "__args__", [])
@@ -326,19 +302,19 @@ def convert_generic_python_type(
             )
         )
     elif origin in (T.Dict, T.Mapping, collections.OrderedDict, dict) or issubclass(
-        origin, collections.abc.Mapping
+            origin, collections.abc.Mapping
     ):
-        raise ConversionError("Don't know how to handle mappings in Graphene")
+        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: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
+        type_: T.Type,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
 ):
     """
     Convert an annotated Python Union type into a Graphene Union.
@@ -367,11 +343,11 @@ def convert_union_type(
 
 
 def convert_literal_type(
-    type_: T.Type,
-    field: ModelField,
-    registry: Registry,
-    parent_type: T.Type = None,
-    model: T.Type[BaseModel] = None,
+        type_: T.Type,
+        field: FieldInfo,
+        registry: Registry,
+        parent_type: T.Type = None,
+        model: T.Type[BaseModel] = None,
 ):
     """
     Convert an annotated Python Literal type into a Graphene Scalar or Union of Scalars.