fix: black format errors

Author: mak626

graphene_pydantic/converters.py

@@ -10,7 +10,20 @@
 from types import UnionType
 
 import graphene
-from graphene import (Boolean, Enum, Field, Float, ID, InputField, Int, JSONString, List, String, UUID, Union)
+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
@@ -24,6 +37,7 @@
 
 try:
     from bson import ObjectId
+
     BSON_OBJECT_ID_SUPPORTED = True
 except ImportError:
     BSON_OBJECT_ID_SUPPORTED = False
@@ -74,7 +88,9 @@ def convert_pydantic_input_field(
         ),
     )
     field_kwargs.setdefault("required", field.is_required())
-    field_kwargs.setdefault("default_value", None if field.default is PydanticUndefined else field.default)
+    field_kwargs.setdefault(
+        "default_value", None if field.default is 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
@@ -292,13 +308,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__", [])
@@ -315,7 +331,7 @@ 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:

graphene_pydantic/inputobjecttype.py

@@ -20,11 +20,11 @@ class PydanticInputObjectTypeOptions(InputObjectTypeOptions):
 
 
 def construct_fields(
-        obj_type: T.Type["PydanticInputObjectType"],
-        model: T.Type[pydantic.BaseModel],
-        registry: Registry,
-        only_fields: T.Tuple[str, ...],
-        exclude_fields: T.Tuple[str, ...],
+    obj_type: T.Type["PydanticInputObjectType"],
+    model: T.Type[pydantic.BaseModel],
+    registry: Registry,
+    only_fields: T.Tuple[str, ...],
+    exclude_fields: T.Tuple[str, ...],
 ) -> T.Dict[str, InputField]:
     """
     Construct all the fields for a PydanticInputObjectType.
@@ -45,7 +45,6 @@ def construct_fields(
 
     fields = {}
     for name, field in fields_to_convert:
-
         # Graphql does not accept union as input. Refer https://github.com/graphql/graphql-spec/issues/488
         if isinstance(getattr(field, "annotation", None), UnionType):
             union_types = field.annotation.__args__
@@ -71,15 +70,15 @@ class PydanticInputObjectType(graphene.InputObjectType):
 
     @classmethod
     def __init_subclass_with_meta__(
-            cls,
-            model: type = None,
-            registry: Registry = None,
-            skip_registry: bool = False,
-            only_fields: T.Tuple[str, ...] = (),
-            exclude_fields: T.Tuple[str, ...] = (),
-            id=None,
-            _meta=None,
-            **options,
+        cls,
+        model: type = None,
+        registry: Registry = None,
+        skip_registry: bool = False,
+        only_fields: T.Tuple[str, ...] = (),
+        exclude_fields: T.Tuple[str, ...] = (),
+        id=None,
+        _meta=None,
+        **options,
     ):
         assert model and issubclass(
             model, pydantic.BaseModel

graphene_pydantic/objecttype.py

@@ -20,11 +20,11 @@ class PydanticObjectTypeOptions(ObjectTypeOptions):
 
 
 def construct_fields(
-        obj_type: T.Type["PydanticObjectType"],
-        model: T.Type[pydantic.BaseModel],
-        registry: Registry,
-        only_fields: T.Tuple[str, ...],
-        exclude_fields: T.Tuple[str, ...],
+    obj_type: T.Type["PydanticObjectType"],
+    model: T.Type[pydantic.BaseModel],
+    registry: Registry,
+    only_fields: T.Tuple[str, ...],
+    exclude_fields: T.Tuple[str, ...],
 ) -> T.Dict[str, graphene.Field]:
     """
     Construct all the fields for a PydanticObjectType.
@@ -61,16 +61,16 @@ class PydanticObjectType(graphene.ObjectType):
 
     @classmethod
     def __init_subclass_with_meta__(
-            cls,
-            model: type = None,
-            registry: Registry = None,
-            skip_registry: bool = False,
-            only_fields: T.Tuple[str, ...] = (),
-            exclude_fields: T.Tuple[str, ...] = (),
-            interfaces=(),
-            id=None,
-            _meta=None,
-            **options,
+        cls,
+        model: type = None,
+        registry: Registry = None,
+        skip_registry: bool = False,
+        only_fields: T.Tuple[str, ...] = (),
+        exclude_fields: T.Tuple[str, ...] = (),
+        interfaces=(),
+        id=None,
+        _meta=None,
+        **options,
     ):
         assert model and issubclass(
             model, pydantic.BaseModel

tests/test_converters.py

@@ -89,7 +89,6 @@ def test_literal():
         assert field.default_value == 3
         assert field.type.of_type.__name__.startswith("UnionOf")
 
-
     def test_literal_singleton():
         field = _convert_field_from_spec("attr", (T.Literal["literal1"], "literal1"))
         assert issubclass(field.type.of_type, graphene.String)
@@ -165,7 +164,9 @@ class Meta:
 
 def test_unresolved_placeholders():
     # no errors should be raised here -- instead a placeholder is created
-    field = _convert_field_from_spec("attr", (create_model("Model", size=(int, ...)), None))
+    field = _convert_field_from_spec(
+        "attr", (create_model("Model", size=(int, ...)), None)
+    )
     assert type(field.type.of_type) is Placeholder
     assert any(
         isinstance(x, Placeholder)

tests/test_graphene.py

@@ -75,7 +75,10 @@ def test_query():
 
     assert result.errors is None
     assert result.data is not None
-    assert TypeAdapter(List[FooBar]).validate_python(result.data["listFooBars"]) == foo_bars
+    assert (
+        TypeAdapter(List[FooBar]).validate_python(result.data["listFooBars"])
+        == foo_bars
+    )
 
 
 def test_query_with_match():
@@ -95,7 +98,10 @@ def test_query_with_match():
 
     assert result.errors is None
     assert result.data is not None
-    assert TypeAdapter(List[FooBar]).validate_python(result.data["listFooBars"]) == foo_bars
+    assert (
+        TypeAdapter(List[FooBar]).validate_python(result.data["listFooBars"])
+        == foo_bars
+    )
 
 
 def test_mutation():
@@ -120,4 +126,6 @@ def test_mutation():
     assert result.errors is None
     assert result.data is not None
     assert foo_bars[0] == new_foo_bar
-    assert TypeAdapter(FooBar).validate_python(result.data["createFooBar"]) == new_foo_bar
+    assert (
+        TypeAdapter(FooBar).validate_python(result.data["createFooBar"]) == new_foo_bar
+    )