Set up automated testing on CircleCI

Author: Rami Chowdhury

.circleci/config.yml

@@ -1,14 +1,8 @@
-version: 2
+version: 2.1
 jobs:
   build:
     docker:
-      - image: circleci/python:3.7
+      - image: themattrix/tox
     steps:
       - checkout
-      - run:
-          name: Install Tox
-          command: pip install tox
-      - run:
-          name: Tests with Tox
-          command: tox
-
+      - run: tox

.pre-commit-config.yaml

@@ -28,4 +28,3 @@ repos:
     hooks:
       - id: black
         language_version: python3.7
-

README.md

@@ -1,4 +1,5 @@
-# ![Graphene Logo](http://graphene-python.org/favicon.png) Graphene-Pydantic [![Build Status](https://travis-ci.org/graphql-python/graphene-pydantic.svg?branch=master)](https://circle-ci.org/graphql-python/graphene-sqlalchemy) [![PyPI version](https://badge.fury.io/py/graphene-pydantic.svg)](https://badge.fury.io/py/graphene-pydantic) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphene-sqlalchemy/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphene-sqlalchemy?branch=master)
+# ![Graphene Logo](http://graphene-python.org/favicon.png) graphene-pydantic [![Build status](https://circleci.com/gh/upsidetravel/graphene-pydantic-2.svg?style=svg)](https://circleci.com/gh/upsidetravel/graphene-pydantic-2) [![PyPI version](https://badge.fury.io/py/graphene-pydantic.svg)](https://badge.fury.io/py/graphene-pydantic) [![Coverage Status](https://coveralls.io/repos/upsidetravel/graphene-pydantic/badge.svg?branch=master&service=github)](https://coveralls.io/github/upsidetravel/graphene-pydantic?branch=master)
+
 
 
 A [Pydantic](https://pydantic-docs.helpmanual.io/) integration for [Graphene](http://graphene-python.org/).

graphene_pydantic/converters.py

@@ -5,10 +5,23 @@
 import enum
 import inspect
 
-from graphene import Field, Boolean, Dynamic, Enum, Float, Int, List, String, UUID, Union
+from graphene import (
+    Field,
+    Boolean,
+    Dynamic,
+    Enum,
+    Float,
+    Int,
+    List,
+    String,
+    UUID,
+    Union,
+)
 from graphene.types.base import BaseType
+
 try:
     from graphene.types.decimal import Decimal as GrapheneDecimal
+
     DECIMAL_SUPPORTED = True
 except ImportError:
     # graphene 2.1.5+ is required for Decimals
@@ -24,21 +37,21 @@ class ConversionError(TypeError):
     pass
 
 
-# Placeholder for NoneType, so that we can easily reference it later
-TYPE_NONE = type(None)
-
-
 def get_attr_resolver(attr_name: str) -> T.Callable:
     """
     Return a helper function that resolves a field with the given name by
     looking it up as an attribute of the type we're trying to resolve it on.
     """
+
     def _get_field(root, _info):
         return getattr(root, attr_name, None)
+
     return _get_field
 
 
-def convert_pydantic_field(field: fields.Field, registry: Registry, **field_kwargs) -> Field:
+def convert_pydantic_field(
+    field: fields.Field, registry: Registry, **field_kwargs
+) -> Field:
     """
     Convert a Pydantic model field into a Graphene type field that we can add
     to the generated Graphene data model type.
@@ -58,7 +71,9 @@ def convert_pydantic_field(field: fields.Field, registry: Registry, **field_kwar
     return Field(resolver=get_attr_resolver(field.name), **field_kwargs)
 
 
-def to_graphene_type(type_: T.Type, field: fields.Field, registry: Registry = None) -> BaseType:  # noqa: C901
+def to_graphene_type(
+    type_: T.Type, field: fields.Field, registry: Registry = None
+) -> BaseType:  # noqa: C901
     """
     Map a native Python type to a Graphene-supported Field type, where possible.
     """
@@ -83,7 +98,7 @@ def to_graphene_type(type_: T.Type, field: fields.Field, registry: Registry = No
     elif type_ in (tuple, list, set):
         # TODO: do Sets really belong here?
         return List
-    elif hasattr(type_, '__origin__'):
+    elif hasattr(type_, "__origin__"):
         return convert_generic_type(type_, field, registry)
     elif issubclass(type_, enum.Enum):
         return Enum.from_enum(type_)
@@ -98,7 +113,9 @@ def to_graphene_type(type_: T.Type, field: fields.Field, registry: Registry = No
         )
 
 
-def convert_pydantic_type(type_: T.Type, field: fields.Field, registry: Registry = None) -> BaseType:  # noqa: C901
+def convert_pydantic_type(
+    type_: T.Type, field: fields.Field, registry: Registry = None
+) -> BaseType:  # noqa: C901
     """
     Convert a Pydantic type to a Graphene Field type, including not just the
     native Python type but any additional metadata (e.g. shape) that Pydantic
@@ -107,7 +124,12 @@ def convert_pydantic_type(type_: T.Type, field: fields.Field, registry: Registry
     graphene_type = to_graphene_type(type_, field, registry)
     if field.shape == fields.Shape.SINGLETON:
         return graphene_type
-    elif field.shape in (fields.Shape.LIST, fields.Shape.TUPLE, fields.Shape.SEQUENCE, fields.Shape.SET):
+    elif field.shape in (
+        fields.Shape.LIST,
+        fields.Shape.TUPLE,
+        fields.Shape.SEQUENCE,
+        fields.Shape.SET,
+    ):
         # TODO: _should_ Sets remain here?
         return List(graphene_type)
     elif field.shape == fields.Shape.MAPPING:
@@ -142,16 +164,20 @@ def convert_union_type(type_, field, registry=None):
     wrapped_types = type_.__args__
     # NOTE: a typing.Optional decomposes to a Union[None, T], so we can return
     # the Graphene type for T; Pydantic will have already parsed it as optional
-    if len(wrapped_types) == 2 and TYPE_NONE in wrapped_types:
-        native_type = next(x for x in wrapped_types if x != TYPE_NONE)
+    if len(wrapped_types) == 2 and type(None) in wrapped_types:
+        native_type = next(x for x in wrapped_types if x != type(None))  # noqa: E721
         graphene_type = to_graphene_type(native_type, field, registry)
         return graphene_type
     else:
         # Otherwise, we use a little metaprogramming -- create our own unique
         # subclass of graphene.Union that knows its constituent Graphene types
-        graphene_types = tuple(to_graphene_type(x, field, registry) for x in wrapped_types)
-        internal_meta = type("Meta", (), {'types': graphene_types})
+        graphene_types = tuple(
+            to_graphene_type(x, field, registry) for x in wrapped_types
+        )
+        internal_meta = type("Meta", (), {"types": graphene_types})
 
         union_class_name = "".join(x.__name__ for x in wrapped_types)
-        union_class = type(f"Union_{union_class_name}", (Union,), {'Meta': internal_meta})
+        union_class = type(
+            f"Union_{union_class_name}", (Union,), {"Meta": internal_meta}
+        )
         return union_class

graphene_pydantic/registry.py

@@ -23,7 +23,9 @@ def __init__(self):
     def register(self, obj_type):
         assert_is_pydantic_object_type(obj_type)
 
-        assert obj_type._meta.registry == self, "Can't register models linked to another Registry"
+        assert (
+            obj_type._meta.registry == self
+        ), "Can't register models linked to another Registry"
         self._registry[obj_type._meta.model] = obj_type
 
     def get_type_for_model(self, model):
@@ -49,9 +51,7 @@ def register_enum(self, py_enum, graphene_enum):
         if not isinstance(py_enum, PyEnum):
             raise TypeError(f"Expected Python Enum, but got: {py_enum!r}")
         if not isinstance(graphene_enum, type(Enum)):
-            raise TypeError(
-                f"Expected Graphene Enum, but got: {graphene_enum!r}"
-            )
+            raise TypeError(f"Expected Graphene Enum, but got: {graphene_enum!r}")
 
         self._registry_enums[py_enum] = graphene_enum
 

graphene_pydantic/types.py

@@ -33,10 +33,7 @@ def construct_fields(
     """
     fields = {}
     for name, field in model.__fields__.items():
-        converted = convert_pydantic_field(
-            field,
-            registry,
-        )
+        converted = convert_pydantic_field(field, registry)
         registry.register_orm_field(obj_type, name, field)
         fields[name] = converted
     return fields

tests/test_converters.py

@@ -0,0 +1,23 @@
+import graphene
+from pydantic import BaseModel, create_model
+
+
+from graphene_pydantic.types import PydanticObjectType
+from graphene_pydantic.converters import convert_pydantic_field
+from graphene_pydantic.registry import get_global_registry
+
+
+def _get_field_from_spec(name, type_spec_or_default):
+    kwargs = {name: type_spec_or_default}
+    m = create_model('model', **kwargs)
+    return m.__fields__[name]
+
+
+def test_convert_string():
+    field = convert_pydantic_field(
+        _get_field_from_spec('prop', (str, ...)),
+        get_global_registry())
+    assert field is not None
+    assert isinstance(field, graphene.Field)
+    assert isinstance(field.type, graphene.NonNull)  # ... means required
+    assert field.type.of_type == graphene.String

tox.ini

@@ -5,8 +5,12 @@ skipsdist = true
 [testenv]
 deps =
     .[test]
+    mypy
+    black
 commands =
-    pytest graphene_pydantic --cov-report=term-missing --cov=graphene_pydantic {posargs}
+    pytest tests/ --cov-report=term-missing --cov=graphene_pydantic {posargs}
+    mypy --ignore-missing-imports --no-strict-optional -m graphene_pydantic
+    black --check graphene_pydantic
 
 [testenv:pre-commit]
 basepython=python3.7