Merge branch 'main' into feature/feat-conveters

# Conflicts:
#	graphene_pydantic/converters.py
#	poetry.lock

Author: mak626

.github/workflows/tests.yaml

@@ -6,27 +6,24 @@ jobs:
     name: lint
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@master
-    - uses: actions/setup-python@v2
-      with:
-        python-version: 3.8
-    - uses: pre-commit/action@v2.0.0
-  pytest:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - uses: pre-commit/action@v3.0.0
+  tests:
     name: pytest
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
         os: [ubuntu-latest, macos-latest, windows-latest]
     steps:
-      - uses: actions/checkout@master
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-      - name: Ensure poetry
-        uses: abatilo/actions-poetry@v2.1.2
-      - name: Install dependencies
-        run: poetry install
-      - name: Run matrix of tests with Tox
-        run: poetry run tox
+      - uses: abatilo/actions-poetry@v2
+      - run: poetry install
+      - run: poetry run nox --non-interactive

.pre-commit-config.yaml

@@ -1,24 +1,25 @@
-default_language_version:
-    python: python3.8
 fail_fast: true
 repos:
-  - repo: git://github.com/pre-commit/pre-commit-hooks
-    rev: v2.1.0
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.0.0
     hooks:
-    - id: check-merge-conflict
-    - id: check-yaml
-    - id: debug-statements
-    - id: end-of-file-fixer
-      exclude: ^docs/.*$
-    - id: trailing-whitespace
-      exclude: README.md
-    - id: flake8
+      - id: check-merge-conflict
+      - id: check-yaml
+      - id: debug-statements
+      - id: end-of-file-fixer
+        exclude: ^docs/.*$
+      - id: trailing-whitespace
+        exclude: README.md
+  - repo: https://github.com/pycqa/flake8
+    rev: "6.1.0"
+    hooks:
+      - id: flake8
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.812
+    rev: v1.4.1
     hooks:
       - id: mypy
         args: [--ignore-missing-imports, --no-strict-optional]
-  - repo: https://github.com/python/black
-    rev: 20.8b1
+  - repo: https://github.com/psf/black
+    rev: 23.7.0
     hooks:
       - id: black

CONTRIBUTING.md

@@ -1,17 +1,26 @@
 # Contributing Guide
 
 You will need:
-- Python 3.6 or higher
+- Python 3.7 or higher
 
 ## Getting started
 
-To get your development environment set up, run:
+To get your development environment set up, create and activate a virtual
+environment, and install poetry:
+
+```
+pipx install poetry
+# or with conda
+conda install poetry
+```
+
+Then install dependencies with poetry:
 
 ```sh
-pip install -e .[dev]
+poetry install
 ```
 
-in an activated virtual environment. This will install the repo version of
+This will install the repo version of
 `graphene-pydantic` and then install the development dependencies. Once that
 has completed, you can start developing.
 

graphene_pydantic/converters.py

@@ -23,7 +23,7 @@
     JSONString,
     ID
 )
-
+import graphene
 from graphene.types.base import BaseType
 from graphene.types.datetime import Date, DateTime, Time
 from pydantic import BaseModel
@@ -35,6 +35,8 @@
 
 from pydantic import fields
 
+GRAPHENE2 = graphene.VERSION[0] < 3
+
 SHAPE_SINGLETON = (fields.SHAPE_SINGLETON,)
 SHAPE_SEQUENTIAL = (
     fields.SHAPE_LIST,
@@ -51,6 +53,7 @@
 else:
     SHAPE_MAPPING = T.cast(T.Tuple, (fields.SHAPE_MAPPING,))
 
+
 try:
     from graphene.types.decimal import Decimal as GrapheneDecimal
 
@@ -59,6 +62,7 @@
     # 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)
 
 
@@ -79,19 +83,19 @@ 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: 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.
     """
     declared_type = getattr(field, "type_", None)
     field_kwargs.setdefault(
-        "type_",
+        "type" if GRAPHENE2 else "type_",
         convert_pydantic_type(
             declared_type, field, registry, parent_type=parent_type, model=model
         ),
@@ -108,25 +112,27 @@ def convert_pydantic_input_field(
 
 
 def convert_pydantic_field(
-        field: ModelField,
-        registry: Registry,
-        parent_type: T.Type = None,
-        model: T.Type[BaseModel] = None,
-        **field_kwargs,
+    field: ModelField,
+    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)
     field_kwargs.setdefault(
-        "type",
+        "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("required", not field.allow_none)
     field_kwargs.setdefault("default_value", field.default)
+    if field.has_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
@@ -138,15 +144,21 @@ def convert_pydantic_field(
     if field_type is None:
         raise ValueError("No field type could be determined.")
 
-    return Field(field_type, resolver=get_attr_resolver(field.name), **field_kwargs)
+    resolver_function = getattr(parent_type, "resolve_" + field.name, None)
+    if resolver_function and callable(resolver_function):
+        field_resolver = resolver_function
+    else:
+        field_resolver = get_attr_resolver(field.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: ModelField,
+    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
@@ -166,11 +178,11 @@ def convert_pydantic_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: ModelField,
+    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,
@@ -204,8 +216,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()`
@@ -240,20 +252,36 @@ def find_graphene_type(
         )
     elif issubclass(type_, enum.Enum):
         return Enum.from_enum(type_)
-    elif issubclass(type_, str):
+    elif issubclass(type_, (str, bytes)):
         return String
+    elif issubclass(type_, datetime.datetime):
+        return DateTime
+    elif issubclass(type_, datetime.date):
+        return Date
+    elif issubclass(type_, datetime.time):
+        return Time
+    elif issubclass(type_, bool):
+        return Boolean
+    elif issubclass(type_, float):
+        return Float
+    elif issubclass(type_, decimal.Decimal):
+        return GrapheneDecimal if DECIMAL_SUPPORTED else Float
+    elif issubclass(type_, int):
+        return Int
+    elif issubclass(type_, (tuple, list, set)):
+        return List
     else:
         raise ConversionError(
             f"Don't know how to convert the Pydantic field {field!r} ({field.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: ModelField,
+    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
@@ -274,19 +302,15 @@ def convert_generic_python_type(
         return convert_literal_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,
-            )
-            or issubclass(origin, collections.abc.Sequence)
-    ):
+    elif origin in (
+        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__", [])
         if not inner_types:  # pragma: no cover  # this really should be impossible
@@ -302,19 +326,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")
     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: ModelField,
+    registry: Registry,
+    parent_type: T.Type = None,
+    model: T.Type[BaseModel] = None,
 ):
     """
     Convert an annotated Python Union type into a Graphene Union.
@@ -343,11 +367,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: ModelField,
+    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.