datamodel-code-generator 0.27.2__py3-none-any.whl → 0.27.3__py3-none-any.whl

datamodel_code_generator/parser/graphql.py

@@ -2,20 +2,13 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
-    DefaultDict,
-    Dict,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     Sequence,
-    Set,
-    Tuple,
-    Type,
-    Union,
 )
 from urllib.parse import ParseResult
 
@@ -41,13 +34,16 @@ from datamodel_code_generator.types import DataTypeManager, StrictTypes, Types
 
 try:
     import graphql
-except ImportError:  # pragma: no cover
-    raise Exception(
-        "Please run `$pip install 'datamodel-code-generator[graphql]`' to generate data-model from a GraphQL schema."
-    )
+except ImportError as exc:  # pragma: no cover
+    msg = "Please run `$pip install 'datamodel-code-generator[graphql]`' to generate data-model from a GraphQL schema."
+    raise Exception(msg) from exc  # noqa: TRY002
+
 
 from datamodel_code_generator.format import DatetimeClassType
 
+if TYPE_CHECKING:
+    from collections import defaultdict
+
 graphql_resolver = graphql.type.introspection.TypeResolvers()
 
 
@@ -57,26 +53,24 @@ def build_graphql_schema(schema_str: str) -> graphql.GraphQLSchema:
     return graphql.lexicographic_sort_schema(schema)
 
 
-@snooper_to_methods(max_variable_length=None)
+@snooper_to_methods()
 class GraphQLParser(Parser):
     # raw graphql schema as `graphql-core` object
     raw_obj: graphql.GraphQLSchema
     # all processed graphql objects
     # mapper from an object name (unique) to an object
-    all_graphql_objects: Dict[str, graphql.GraphQLNamedType]
+    all_graphql_objects: dict[str, graphql.GraphQLNamedType]
     # a reference for each object
     # mapper from an object name to his reference
-    references: Dict[str, Reference] = {}
+    references: dict[str, Reference] = {}  # noqa: RUF012
     # mapper from graphql type to all objects with this type
     # `graphql.type.introspection.TypeKind` -- an enum with all supported types
     # `graphql.GraphQLNamedType` -- base type for each graphql object
     # see `graphql-core` for more details
-    support_graphql_types: Dict[
-        graphql.type.introspection.TypeKind, List[graphql.GraphQLNamedType]
-    ]
+    support_graphql_types: dict[graphql.type.introspection.TypeKind, list[graphql.GraphQLNamedType]]
     # graphql types order for render
     # may be as a parameter in the future
-    parse_order: List[graphql.type.introspection.TypeKind] = [
+    parse_order: list[graphql.type.introspection.TypeKind] = [  # noqa: RUF012
         graphql.type.introspection.TypeKind.SCALAR,
         graphql.type.introspection.TypeKind.ENUM,
         graphql.type.introspection.TypeKind.INTERFACE,
@@ -85,79 +79,79 @@ class GraphQLParser(Parser):
         graphql.type.introspection.TypeKind.UNION,
     ]
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
-        source: Union[str, Path, ParseResult],
+        source: str | Path | ParseResult,
         *,
-        data_model_type: Type[DataModel] = pydantic_model.BaseModel,
-        data_model_root_type: Type[DataModel] = pydantic_model.CustomRootType,
-        data_model_scalar_type: Type[DataModel] = DataTypeScalar,
-        data_model_union_type: Type[DataModel] = DataTypeUnion,
-        data_type_manager_type: Type[DataTypeManager] = pydantic_model.DataTypeManager,
-        data_model_field_type: Type[DataModelFieldBase] = pydantic_model.DataModelField,
-        base_class: Optional[str] = None,
-        additional_imports: Optional[List[str]] = None,
-        custom_template_dir: Optional[Path] = None,
-        extra_template_data: Optional[DefaultDict[str, Dict[str, Any]]] = None,
+        data_model_type: type[DataModel] = pydantic_model.BaseModel,
+        data_model_root_type: type[DataModel] = pydantic_model.CustomRootType,
+        data_model_scalar_type: type[DataModel] = DataTypeScalar,
+        data_model_union_type: type[DataModel] = DataTypeUnion,
+        data_type_manager_type: type[DataTypeManager] = pydantic_model.DataTypeManager,
+        data_model_field_type: type[DataModelFieldBase] = pydantic_model.DataModelField,
+        base_class: str | None = None,
+        additional_imports: list[str] | None = None,
+        custom_template_dir: Path | None = None,
+        extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
         target_python_version: PythonVersion = PythonVersion.PY_38,
-        dump_resolve_reference_action: Optional[Callable[[Iterable[str]], str]] = None,
+        dump_resolve_reference_action: Callable[[Iterable[str]], str] | None = None,
         validation: bool = False,
         field_constraints: bool = False,
         snake_case_field: bool = False,
         strip_default_none: bool = False,
-        aliases: Optional[Mapping[str, str]] = None,
+        aliases: Mapping[str, str] | None = None,
         allow_population_by_field_name: bool = False,
         apply_default_values_for_required_fields: bool = False,
         allow_extra_fields: bool = False,
         force_optional_for_required_fields: bool = False,
-        class_name: Optional[str] = None,
+        class_name: str | None = None,
         use_standard_collections: bool = False,
-        base_path: Optional[Path] = None,
+        base_path: Path | None = None,
         use_schema_description: bool = False,
         use_field_description: bool = False,
         use_default_kwarg: bool = False,
         reuse_model: bool = False,
-        encoding: str = 'utf-8',
-        enum_field_as_literal: Optional[LiteralType] = None,
+        encoding: str = "utf-8",
+        enum_field_as_literal: LiteralType | None = None,
         set_default_enum_member: bool = False,
         use_subclass_enum: bool = False,
         strict_nullable: bool = False,
         use_generic_container_types: bool = False,
         enable_faux_immutability: bool = False,
-        remote_text_cache: Optional[DefaultPutDict[str, str]] = None,
+        remote_text_cache: DefaultPutDict[str, str] | None = None,
         disable_appending_item_suffix: bool = False,
-        strict_types: Optional[Sequence[StrictTypes]] = None,
-        empty_enum_field_name: Optional[str] = None,
-        custom_class_name_generator: Optional[Callable[[str], str]] = None,
-        field_extra_keys: Optional[Set[str]] = None,
+        strict_types: Sequence[StrictTypes] | None = None,
+        empty_enum_field_name: str | None = None,
+        custom_class_name_generator: Callable[[str], str] | None = None,
+        field_extra_keys: set[str] | None = None,
         field_include_all_keys: bool = False,
-        field_extra_keys_without_x_prefix: Optional[Set[str]] = None,
-        wrap_string_literal: Optional[bool] = None,
+        field_extra_keys_without_x_prefix: set[str] | None = None,
+        wrap_string_literal: bool | None = None,
         use_title_as_name: bool = False,
         use_operation_id_as_name: bool = False,
         use_unique_items_as_set: bool = False,
-        http_headers: Optional[Sequence[Tuple[str, str]]] = None,
+        http_headers: Sequence[tuple[str, str]] | None = None,
         http_ignore_tls: bool = False,
         use_annotated: bool = False,
         use_non_positive_negative_number_constrained_types: bool = False,
-        original_field_name_delimiter: Optional[str] = None,
+        original_field_name_delimiter: str | None = None,
         use_double_quotes: bool = False,
         use_union_operator: bool = False,
         allow_responses_without_content: bool = False,
         collapse_root_models: bool = False,
-        special_field_name_prefix: Optional[str] = None,
+        special_field_name_prefix: str | None = None,
         remove_special_field_name_prefix: bool = False,
         capitalise_enum_members: bool = False,
         keep_model_order: bool = False,
         use_one_literal_as_default: bool = False,
-        known_third_party: Optional[List[str]] = None,
-        custom_formatters: Optional[List[str]] = None,
-        custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        known_third_party: list[str] | None = None,
+        custom_formatters: list[str] | None = None,
+        custom_formatters_kwargs: dict[str, Any] | None = None,
         use_pendulum: bool = False,
-        http_query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+        http_query_parameters: Sequence[tuple[str, str]] | None = None,
         treat_dots_as_module: bool = False,
         use_exact_imports: bool = False,
-        default_field_extras: Optional[Dict[str, Any]] = None,
+        default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
@@ -241,7 +235,7 @@ class GraphQLParser(Parser):
         self.use_standard_collections = use_standard_collections
         self.use_union_operator = use_union_operator
 
-    def _get_context_source_path_parts(self) -> Iterator[Tuple[Source, List[str]]]:
+    def _get_context_source_path_parts(self) -> Iterator[tuple[Source, list[str]]]:
         # TODO (denisart): Temporarily this method duplicates
         # the method `datamodel_code_generator.parser.jsonschema.JsonSchemaParser._get_context_source_path_parts`.
 
@@ -250,8 +244,7 @@ class GraphQLParser(Parser):
         ):  # pragma: no cover
             self.current_source_path = Path()
             self.model_resolver.after_load_files = {
-                self.base_path.joinpath(s.path).resolve().as_posix()
-                for s in self.iter_source
+                self.base_path.joinpath(s.path).resolve().as_posix() for s in self.iter_source
             }
 
         for source in self.iter_source:
@@ -266,12 +259,12 @@ class GraphQLParser(Parser):
             ), self.model_resolver.current_root_context(path_parts):
                 yield source, path_parts
 
-    def _resolve_types(self, paths: List[str], schema: graphql.GraphQLSchema) -> None:
+    def _resolve_types(self, paths: list[str], schema: graphql.GraphQLSchema) -> None:
         for type_name, type_ in schema.type_map.items():
-            if type_name.startswith('__'):
+            if type_name.startswith("__"):
                 continue
 
-            if type_name in ['Query', 'Mutation']:
+            if type_name in {"Query", "Mutation"}:
                 continue
 
             resolved_type = graphql_resolver.kind(type_, None)
@@ -280,7 +273,7 @@ class GraphQLParser(Parser):
                 self.all_graphql_objects[type_.name] = type_
                 # TODO: need a special method for each graph type
                 self.references[type_.name] = Reference(
-                    path=f'{str(*paths)}/{resolved_type.value}/{type_.name}',
+                    path=f"{paths!s}/{resolved_type.value}/{type_.name}",
                     name=type_.name,
                     original_name=type_.name,
                 )
@@ -289,7 +282,7 @@ class GraphQLParser(Parser):
 
     def _typename_field(self, name: str) -> DataModelFieldBase:
         return self.data_model_field_type(
-            name='typename__',
+            name="typename__",
             data_type=DataType(
                 literals=[name],
                 use_union_operator=self.use_union_operator,
@@ -298,24 +291,23 @@ class GraphQLParser(Parser):
             default=name,
             use_annotated=self.use_annotated,
             required=False,
-            alias='__typename',
+            alias="__typename",
             use_one_literal_as_default=True,
             has_default=True,
         )
 
-    def _get_default(
+    def _get_default(  # noqa: PLR6301
         self,
-        field: Union[graphql.GraphQLField, graphql.GraphQLInputField],
+        field: graphql.GraphQLField | graphql.GraphQLInputField,
         final_data_type: DataType,
-        required: bool,
+        required: bool,  # noqa: FBT001
     ) -> Any:
         if isinstance(field, graphql.GraphQLInputField):  # pragma: no cover
             if field.default_value == graphql.pyutils.Undefined:  # pragma: no cover
                 return None
             return field.default_value
-        if required is False:
-            if final_data_type.is_list:
-                return None
+        if required is False and final_data_type.is_list:
+            return None
 
         return None
 
@@ -331,15 +323,11 @@ class GraphQLParser(Parser):
         )
 
     def parse_enum(self, enum_object: graphql.GraphQLEnumType) -> None:
-        enum_fields: List[DataModelFieldBase] = []
-        exclude_field_names: Set[str] = set()
+        enum_fields: list[DataModelFieldBase] = []
+        exclude_field_names: set[str] = set()
 
         for value_name, value in enum_object.values.items():
-            default = (
-                f"'{value_name.translate(escape_characters)}'"
-                if isinstance(value_name, str)
-                else value_name
-            )
+            default = f"'{value_name.translate(escape_characters)}'" if isinstance(value_name, str) else value_name
 
             field_name = self.model_resolver.get_valid_field_name(
                 value_name, excludes=exclude_field_names, model_type=ModelType.ENUM
@@ -373,8 +361,8 @@ class GraphQLParser(Parser):
     def parse_field(
         self,
         field_name: str,
-        alias: Optional[str],
-        field: Union[graphql.GraphQLField, graphql.GraphQLInputField],
+        alias: str | None,
+        field: graphql.GraphQLField | graphql.GraphQLInputField,
     ) -> DataModelFieldBase:
         final_data_type = DataType(
             is_optional=True,
@@ -399,23 +387,17 @@ class GraphQLParser(Parser):
             elif graphql.is_non_null_type(obj):  # pragma: no cover
                 data_type.is_optional = False
 
-            obj = obj.of_type  # pyright: ignore [reportAttributeAccessIssue]
+            obj = obj.of_type  # pyright: ignore[reportAttributeAccessIssue]
 
-        data_type.type = obj.name  # pyright: ignore [reportAttributeAccessIssue]
+        data_type.type = obj.name  # pyright: ignore[reportAttributeAccessIssue]
 
-        required = (not self.force_optional_for_required_fields) and (
-            not final_data_type.is_optional
-        )
+        required = (not self.force_optional_for_required_fields) and (not final_data_type.is_optional)
 
         default = self._get_default(field, final_data_type, required)
-        extras = (
-            {}
-            if self.default_field_extras is None
-            else self.default_field_extras.copy()
-        )
+        extras = {} if self.default_field_extras is None else self.default_field_extras.copy()
 
         if field.description is not None:  # pragma: no cover
-            extras['description'] = field.description
+            extras["description"] = field.description
 
         return self.data_model_field_type(
             name=field_name,
@@ -434,14 +416,10 @@ class GraphQLParser(Parser):
 
     def parse_object_like(
         self,
-        obj: Union[
-            graphql.GraphQLInterfaceType,
-            graphql.GraphQLObjectType,
-            graphql.GraphQLInputObjectType,
-        ],
+        obj: graphql.GraphQLInterfaceType | graphql.GraphQLObjectType | graphql.GraphQLInputObjectType,
     ) -> None:
         fields = []
-        exclude_field_names: Set[str] = set()
+        exclude_field_names: set[str] = set()
 
         for field_name, field in obj.fields.items():
             field_name_, alias = self.model_resolver.get_valid_field_name_and_alias(
@@ -455,8 +433,8 @@ class GraphQLParser(Parser):
         fields.append(self._typename_field(obj.name))
 
         base_classes = []
-        if hasattr(obj, 'interfaces'):  # pragma: no cover
-            base_classes = [self.references[i.name] for i in obj.interfaces]  # pyright: ignore [reportAttributeAccessIssue]
+        if hasattr(obj, "interfaces"):  # pragma: no cover
+            base_classes = [self.references[i.name] for i in obj.interfaces]  # pyright: ignore[reportAttributeAccessIssue]
 
         data_model_type = self.data_model_type(
             reference=self.references[obj.name],
@@ -471,26 +449,17 @@ class GraphQLParser(Parser):
         )
         self.results.append(data_model_type)
 
-    def parse_interface(
-        self, interface_graphql_object: graphql.GraphQLInterfaceType
-    ) -> None:
+    def parse_interface(self, interface_graphql_object: graphql.GraphQLInterfaceType) -> None:
         self.parse_object_like(interface_graphql_object)
 
     def parse_object(self, graphql_object: graphql.GraphQLObjectType) -> None:
         self.parse_object_like(graphql_object)
 
-    def parse_input_object(
-        self, input_graphql_object: graphql.GraphQLInputObjectType
-    ) -> None:
+    def parse_input_object(self, input_graphql_object: graphql.GraphQLInputObjectType) -> None:
         self.parse_object_like(input_graphql_object)  # pragma: no cover
 
     def parse_union(self, union_object: graphql.GraphQLUnionType) -> None:
-        fields = []
-
-        for type_ in union_object.types:
-            fields.append(
-                self.data_model_field_type(name=type_.name, data_type=DataType())
-            )
+        fields = [self.data_model_field_type(name=type_.name, data_type=DataType()) for type_ in union_object.types]
 
         data_model_type = self.data_model_union_type(
             reference=self.references[union_object.name],
@@ -505,7 +474,7 @@ class GraphQLParser(Parser):
 
     def parse_raw(self) -> None:
         self.all_graphql_objects = {}
-        self.references: Dict[str, Reference] = {}
+        self.references: dict[str, Reference] = {}
 
         self.support_graphql_types = {
             graphql.type.introspection.TypeKind.SCALAR: [],
@@ -517,7 +486,7 @@ class GraphQLParser(Parser):
         }
 
         # may be as a parameter in the future (??)
-        _mapper_from_graphql_type_to_parser_method = {
+        mapper_from_graphql_type_to_parser_method = {
             graphql.type.introspection.TypeKind.SCALAR: self.parse_scalar,
             graphql.type.introspection.TypeKind.ENUM: self.parse_enum,
             graphql.type.introspection.TypeKind.INTERFACE: self.parse_interface,
@@ -534,5 +503,5 @@ class GraphQLParser(Parser):
 
             for next_type in self.parse_order:
                 for obj in self.support_graphql_types[next_type]:
-                    parser_ = _mapper_from_graphql_type_to_parser_method[next_type]
-                    parser_(obj)  # type: ignore
+                    parser_ = mapper_from_graphql_type_to_parser_method[next_type]
+                    parser_(obj)