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

datamodel_code_generator/model/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from copy import deepcopy
@@ -7,16 +9,12 @@ from typing import (
     TYPE_CHECKING,
     Any,
     ClassVar,
-    DefaultDict,
     Dict,
-    FrozenSet,
     Iterator,
-    List,
     Optional,
     Set,
     Tuple,
     TypeVar,
-    Union,
 )
 from warnings import warn
 
@@ -42,18 +40,18 @@ from datamodel_code_generator.types import (
 )
 from datamodel_code_generator.util import PYDANTIC_V2, ConfigDict, cached_property
 
-TEMPLATE_DIR: Path = Path(__file__).parents[0] / 'template'
+TEMPLATE_DIR: Path = Path(__file__).parents[0] / "template"
 
-ALL_MODEL: str = '#all#'
+ALL_MODEL: str = "#all#"
 
-ConstraintsBaseT = TypeVar('ConstraintsBaseT', bound='ConstraintsBase')
+ConstraintsBaseT = TypeVar("ConstraintsBaseT", bound="ConstraintsBase")
 
 
 class ConstraintsBase(_BaseModel):
-    unique_items: Optional[bool] = Field(None, alias='uniqueItems')
-    _exclude_fields: ClassVar[Set[str]] = {'has_constraints'}
+    unique_items: Optional[bool] = Field(None, alias="uniqueItems")  # noqa: UP045
+    _exclude_fields: ClassVar[Set[str]] = {"has_constraints"}  # noqa: UP006
     if PYDANTIC_V2:
-        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
+        model_config = ConfigDict(  # pyright: ignore[reportAssignmentType]
             arbitrary_types_allowed=True, ignored_types=(cached_property,)
         )
     else:
@@ -67,61 +65,51 @@ class ConstraintsBase(_BaseModel):
         return any(v is not None for v in self.dict().values())
 
     @staticmethod
-    def merge_constraints(
-        a: ConstraintsBaseT, b: ConstraintsBaseT
-    ) -> Optional[ConstraintsBaseT]:
+    def merge_constraints(a: ConstraintsBaseT, b: ConstraintsBaseT) -> ConstraintsBaseT | None:
         constraints_class = None
         if isinstance(a, ConstraintsBase):  # pragma: no cover
-            root_type_field_constraints = {
-                k: v for k, v in a.dict(by_alias=True).items() if v is not None
-            }
+            root_type_field_constraints = {k: v for k, v in a.dict(by_alias=True).items() if v is not None}
             constraints_class = a.__class__
         else:
             root_type_field_constraints = {}  # pragma: no cover
 
         if isinstance(b, ConstraintsBase):  # pragma: no cover
-            model_field_constraints = {
-                k: v for k, v in b.dict(by_alias=True).items() if v is not None
-            }
+            model_field_constraints = {k: v for k, v in b.dict(by_alias=True).items() if v is not None}
             constraints_class = constraints_class or b.__class__
         else:
             model_field_constraints = {}
 
-        if constraints_class is None or not issubclass(
-            constraints_class, ConstraintsBase
-        ):  # pragma: no cover
+        if constraints_class is None or not issubclass(constraints_class, ConstraintsBase):  # pragma: no cover
             return None
 
-        return constraints_class.parse_obj(
-            {
-                **root_type_field_constraints,
-                **model_field_constraints,
-            }
-        )
+        return constraints_class.parse_obj({
+            **root_type_field_constraints,
+            **model_field_constraints,
+        })
 
 
 class DataModelFieldBase(_BaseModel):
-    name: Optional[str] = None
-    default: Optional[Any] = None
+    name: Optional[str] = None  # noqa: UP045
+    default: Optional[Any] = None  # noqa: UP045
     required: bool = False
-    alias: Optional[str] = None
+    alias: Optional[str] = None  # noqa: UP045
     data_type: DataType
     constraints: Any = None
     strip_default_none: bool = False
-    nullable: Optional[bool] = None
-    parent: Optional[Any] = None
-    extras: Dict[str, Any] = {}
+    nullable: Optional[bool] = None  # noqa: UP045
+    parent: Optional[Any] = None  # noqa: UP045
+    extras: Dict[str, Any] = {}  # noqa: RUF012, UP006
     use_annotated: bool = False
     has_default: bool = False
     use_field_description: bool = False
     const: bool = False
-    original_name: Optional[str] = None
+    original_name: Optional[str] = None  # noqa: UP045
     use_default_kwarg: bool = False
     use_one_literal_as_default: bool = False
-    _exclude_fields: ClassVar[Set[str]] = {'parent'}
-    _pass_fields: ClassVar[Set[str]] = {'parent', 'data_type'}
+    _exclude_fields: ClassVar[Set[str]] = {"parent"}  # noqa: UP006
+    _pass_fields: ClassVar[Set[str]] = {"parent", "data_type"}  # noqa: UP006
     can_have_extra_keys: ClassVar[bool] = True
-    type_has_null: Optional[bool] = None
+    type_has_null: Optional[bool] = None  # noqa: UP045
 
     if not TYPE_CHECKING:
 
@@ -132,46 +120,39 @@ class DataModelFieldBase(_BaseModel):
             self.process_const()
 
     def process_const(self) -> None:
-        if 'const' not in self.extras:
-            return None
-        self.default = self.extras['const']
+        if "const" not in self.extras:
+            return
+        self.default = self.extras["const"]
         self.const = True
         self.required = False
         self.nullable = False
 
     @property
-    def type_hint(self) -> str:
+    def type_hint(self) -> str:  # noqa: PLR0911
         type_hint = self.data_type.type_hint
 
         if not type_hint:
             return NONE
-        elif self.has_default_factory:
-            return type_hint
-        elif self.data_type.is_optional and self.data_type.type != ANY:
+        if self.has_default_factory or (self.data_type.is_optional and self.data_type.type != ANY):
             return type_hint
-        elif self.nullable is not None:
+        if self.nullable is not None:
             if self.nullable:
                 return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
-        elif self.required:
+        if self.required:
             if self.type_has_null:
                 return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
-        elif self.fall_back_to_nullable:
+        if self.fall_back_to_nullable:
             return get_optional_type(type_hint, self.data_type.use_union_operator)
-        else:
-            return type_hint
+        return type_hint
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         type_hint = self.type_hint
         has_union = not self.data_type.use_union_operator and UNION_PREFIX in type_hint
-        imports: List[Union[Tuple[Import], Iterator[Import]]] = [
-            iter(
-                i
-                for i in self.data_type.all_imports
-                if not (not has_union and i == IMPORT_UNION)
-            )
+        imports: list[tuple[Import] | Iterator[Import]] = [
+            iter(i for i in self.data_type.all_imports if not (not has_union and i == IMPORT_UNION))
         ]
 
         if self.fall_back_to_nullable:
@@ -179,39 +160,34 @@ class DataModelFieldBase(_BaseModel):
                 self.nullable or (self.nullable is None and not self.required)
             ) and not self.data_type.use_union_operator:
                 imports.append((IMPORT_OPTIONAL,))
-        else:
-            if (
-                self.nullable and not self.data_type.use_union_operator
-            ):  # pragma: no cover
-                imports.append((IMPORT_OPTIONAL,))
+        elif self.nullable and not self.data_type.use_union_operator:  # pragma: no cover
+            imports.append((IMPORT_OPTIONAL,))
         if self.use_annotated and self.annotated:
             import_annotated = (
-                IMPORT_ANNOTATED
-                if self.data_type.python_version.has_annotated_type
-                else IMPORT_ANNOTATED_BACKPORT
+                IMPORT_ANNOTATED if self.data_type.python_version.has_annotated_type else IMPORT_ANNOTATED_BACKPORT
             )
             imports.append((import_annotated,))
         return chain_as_tuple(*imports)
 
     @property
-    def docstring(self) -> Optional[str]:
+    def docstring(self) -> str | None:
         if self.use_field_description:
-            description = self.extras.get('description', None)
+            description = self.extras.get("description", None)
             if description is not None:
-                return f'{description}'
+                return f"{description}"
         return None
 
     @property
-    def unresolved_types(self) -> FrozenSet[str]:
+    def unresolved_types(self) -> frozenset[str]:
         return self.data_type.unresolved_types
 
     @property
-    def field(self) -> Optional[str]:
+    def field(self) -> str | None:
         """for backwards compatibility"""
         return None
 
     @property
-    def method(self) -> Optional[str]:
+    def method(self) -> str | None:
         return None
 
     @property
@@ -219,12 +195,12 @@ class DataModelFieldBase(_BaseModel):
         return repr(self.default)
 
     @property
-    def annotated(self) -> Optional[str]:
+    def annotated(self) -> str | None:
         return None
 
     @property
     def has_default_factory(self) -> bool:
-        return 'default_factory' in self.extras
+        return "default_factory" in self.extras
 
     @property
     def fall_back_to_nullable(self) -> bool:
@@ -234,22 +210,22 @@ class DataModelFieldBase(_BaseModel):
 @lru_cache
 def get_template(template_file_path: Path) -> Template:
     loader = FileSystemLoader(str(TEMPLATE_DIR / template_file_path.parent))
-    environment: Environment = Environment(loader=loader)
+    environment: Environment = Environment(loader=loader)  # noqa: S701
     return environment.get_template(template_file_path.name)
 
 
-def get_module_path(name: str, file_path: Optional[Path]) -> List[str]:
+def get_module_path(name: str, file_path: Path | None) -> list[str]:
     if file_path:
         return [
             *file_path.parts[:-1],
             file_path.stem,
-            *name.split('.')[:-1],
+            *name.split(".")[:-1],
         ]
-    return name.split('.')[:-1]
+    return name.split(".")[:-1]
 
 
-def get_module_name(name: str, file_path: Optional[Path]) -> str:
-    return '.'.join(get_module_path(name, file_path))
+def get_module_name(name: str, file_path: Path | None) -> str:
+    return ".".join(get_module_path(name, file_path))
 
 
 class TemplateBase(ABC):
@@ -280,43 +256,42 @@ UNDEFINED: Any = object()
 
 
 class DataModel(TemplateBase, Nullable, ABC):
-    TEMPLATE_FILE_PATH: ClassVar[str] = ''
-    BASE_CLASS: ClassVar[str] = ''
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = ()
+    TEMPLATE_FILE_PATH: ClassVar[str] = ""
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = ()  # noqa: UP006
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         *,
         reference: Reference,
-        fields: List[DataModelFieldBase],
-        decorators: Optional[List[str]] = None,
-        base_classes: Optional[List[Reference]] = None,
-        custom_base_class: Optional[str] = None,
-        custom_template_dir: Optional[Path] = None,
-        extra_template_data: Optional[DefaultDict[str, Dict[str, Any]]] = None,
-        methods: Optional[List[str]] = None,
-        path: Optional[Path] = None,
-        description: Optional[str] = None,
+        fields: list[DataModelFieldBase],
+        decorators: list[str] | None = None,
+        base_classes: list[Reference] | None = None,
+        custom_base_class: str | None = None,
+        custom_template_dir: Path | None = None,
+        extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
+        methods: list[str] | None = None,
+        path: Path | None = None,
+        description: str | None = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
         if not self.TEMPLATE_FILE_PATH:
-            raise Exception('TEMPLATE_FILE_PATH is undefined')
+            msg = "TEMPLATE_FILE_PATH is undefined"
+            raise Exception(msg)  # noqa: TRY002
 
-        self._custom_template_dir: Optional[Path] = custom_template_dir
-        self.decorators: List[str] = decorators or []
-        self._additional_imports: List[Import] = []
+        self._custom_template_dir: Path | None = custom_template_dir
+        self.decorators: list[str] = decorators or []
+        self._additional_imports: list[Import] = []
         self.custom_base_class = custom_base_class
         if base_classes:
-            self.base_classes: List[BaseClassDataType] = [
-                BaseClassDataType(reference=b) for b in base_classes
-            ]
+            self.base_classes: list[BaseClassDataType] = [BaseClassDataType(reference=b) for b in base_classes]
         else:
             self.set_base_class()
 
-        self.file_path: Optional[Path] = path
+        self.file_path: Path | None = path
         self.reference: Reference = reference
 
         self.reference.source = self
@@ -324,9 +299,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         self.extra_template_data = (
             # The supplied defaultdict will either create a new entry,
             # or already contain a predefined entry for this type
-            extra_template_data[self.name]
-            if extra_template_data is not None
-            else defaultdict(dict)
+            extra_template_data[self.name] if extra_template_data is not None else defaultdict(dict)
         )
 
         self.fields = self._validate_fields(fields) if fields else []
@@ -342,7 +315,7 @@ class DataModel(TemplateBase, Nullable, ABC):
                 # end up inadvertently sharing state (such as "base_class_kwargs")
                 self.extra_template_data.update(deepcopy(all_model_extra_template_data))
 
-        self.methods: List[str] = methods or []
+        self.methods: list[str] = methods or []
 
         self.description = description
         for field in self.fields:
@@ -352,18 +325,15 @@ class DataModel(TemplateBase, Nullable, ABC):
         self.default: Any = default
         self._nullable: bool = nullable
 
-    def _validate_fields(
-        self, fields: List[DataModelFieldBase]
-    ) -> List[DataModelFieldBase]:
-        names: Set[str] = set()
-        unique_fields: List[DataModelFieldBase] = []
+    def _validate_fields(self, fields: list[DataModelFieldBase]) -> list[DataModelFieldBase]:
+        names: set[str] = set()
+        unique_fields: list[DataModelFieldBase] = []
         for field in fields:
             if field.name:
                 if field.name in names:
-                    warn(f'Field name `{field.name}` is duplicated on {self.name}')
+                    warn(f"Field name `{field.name}` is duplicated on {self.name}", stacklevel=2)
                     continue
-                else:
-                    names.add(field.name)
+                names.add(field.name)
             unique_fields.append(field)
         return unique_fields
 
@@ -371,7 +341,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         base_class = self.custom_base_class or self.BASE_CLASS
         if not base_class:
             self.base_classes = []
-            return None
+            return
         base_class_import = Import.from_full_path(base_class)
         self._additional_imports.append(base_class_import)
         self.base_classes = [BaseClassDataType.from_import(base_class_import)]
@@ -386,14 +356,14 @@ class DataModel(TemplateBase, Nullable, ABC):
         return template_file_path
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         return chain_as_tuple(
             (i for f in self.fields for i in f.imports),
             self._additional_imports,
         )
 
     @property
-    def reference_classes(self) -> FrozenSet[str]:
+    def reference_classes(self) -> frozenset[str]:
         return frozenset(
             {r.reference.path for r in self.base_classes if r.reference}
             | {t for f in self.fields for t in f.unresolved_types}
@@ -405,16 +375,16 @@ class DataModel(TemplateBase, Nullable, ABC):
 
     @property
     def duplicate_name(self) -> str:
-        return self.reference.duplicate_name or ''
+        return self.reference.duplicate_name or ""
 
     @property
     def base_class(self) -> str:
-        return ', '.join(b.type_hint for b in self.base_classes)
+        return ", ".join(b.type_hint for b in self.base_classes)
 
     @staticmethod
     def _get_class_name(name: str) -> str:
-        if '.' in name:
-            return name.rsplit('.', 1)[-1]
+        if "." in name:
+            return name.rsplit(".", 1)[-1]
         return name
 
     @property
@@ -423,10 +393,8 @@ class DataModel(TemplateBase, Nullable, ABC):
 
     @class_name.setter
     def class_name(self, class_name: str) -> None:
-        if '.' in self.reference.name:
-            self.reference.name = (
-                f'{self.reference.name.rsplit(".", 1)[0]}.{class_name}'
-            )
+        if "." in self.reference.name:
+            self.reference.name = f"{self.reference.name.rsplit('.', 1)[0]}.{class_name}"
         else:
             self.reference.name = class_name
 
@@ -435,7 +403,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         return self._get_class_name(self.duplicate_name)
 
     @property
-    def module_path(self) -> List[str]:
+    def module_path(self) -> list[str]:
         return get_module_path(self.name, self.file_path)
 
     @property
@@ -456,8 +424,8 @@ class DataModel(TemplateBase, Nullable, ABC):
     def path(self) -> str:
         return self.reference.path
 
-    def render(self, *, class_name: Optional[str] = None) -> str:
-        response = self._render(
+    def render(self, *, class_name: str | None = None) -> str:
+        return self._render(
             class_name=class_name or self.class_name,
             fields=self.fields,
             decorators=self.decorators,
@@ -467,4 +435,3 @@ class DataModel(TemplateBase, Nullable, ABC):
             keyword_only=self.keyword_only,
             **self.extra_template_data,
         )
-        return response

datamodel_code_generator/model/dataclass.py

@@ -1,10 +1,9 @@
-from pathlib import Path
+from __future__ import annotations
+
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
-    DefaultDict,
-    Dict,
-    List,
     Optional,
     Sequence,
     Set,
@@ -22,37 +21,42 @@ from datamodel_code_generator.imports import (
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
 from datamodel_code_generator.model.imports import IMPORT_DATACLASS, IMPORT_FIELD
-from datamodel_code_generator.model.pydantic.base_model import Constraints
 from datamodel_code_generator.model.types import DataTypeManager as _DataTypeManager
 from datamodel_code_generator.model.types import type_map_factory
-from datamodel_code_generator.reference import Reference
 from datamodel_code_generator.types import DataType, StrictTypes, Types, chain_as_tuple
 
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
+from datamodel_code_generator.model.pydantic.base_model import Constraints  # noqa: TC001
+
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
     return bool(field.field) or not (
-        field.required
-        or (field.represented_default == 'None' and field.strip_default_none)
+        field.required or (field.represented_default == "None" and field.strip_default_none)
     )
 
 
 class DataClass(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'dataclass.jinja2'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_DATACLASS,)
+    TEMPLATE_FILE_PATH: ClassVar[str] = "dataclass.jinja2"
+    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_DATACLASS,)  # noqa: UP006
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         *,
         reference: Reference,
-        fields: List[DataModelFieldBase],
-        decorators: Optional[List[str]] = None,
-        base_classes: Optional[List[Reference]] = None,
-        custom_base_class: Optional[str] = None,
-        custom_template_dir: Optional[Path] = None,
-        extra_template_data: Optional[DefaultDict[str, Dict[str, Any]]] = None,
-        methods: Optional[List[str]] = None,
-        path: Optional[Path] = None,
-        description: Optional[str] = None,
+        fields: list[DataModelFieldBase],
+        decorators: list[str] | None = None,
+        base_classes: list[Reference] | None = None,
+        custom_base_class: str | None = None,
+        custom_template_dir: Path | None = None,
+        extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
+        methods: list[str] | None = None,
+        path: Path | None = None,
+        description: str | None = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
@@ -75,21 +79,21 @@ class DataClass(DataModel):
 
 
 class DataModelField(DataModelFieldBase):
-    _FIELD_KEYS: ClassVar[Set[str]] = {
-        'default_factory',
-        'init',
-        'repr',
-        'hash',
-        'compare',
-        'metadata',
-        'kw_only',
+    _FIELD_KEYS: ClassVar[Set[str]] = {  # noqa: UP006
+        "default_factory",
+        "init",
+        "repr",
+        "hash",
+        "compare",
+        "metadata",
+        "kw_only",
     }
-    constraints: Optional[Constraints] = None
+    constraints: Optional[Constraints] = None  # noqa: UP045
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         field = self.field
-        if field and field.startswith('field('):
+        if field and field.startswith("field("):
             return chain_as_tuple(super().imports, (IMPORT_FIELD,))
         return super().imports
 
@@ -99,60 +103,55 @@ class DataModelField(DataModelFieldBase):
         }
 
     @property
-    def field(self) -> Optional[str]:
+    def field(self) -> str | None:
         """for backwards compatibility"""
         result = str(self)
-        if result == '':
+        if not result:
             return None
-
         return result
 
     def __str__(self) -> str:
-        data: Dict[str, Any] = {
-            k: v for k, v in self.extras.items() if k in self._FIELD_KEYS
-        }
+        data: dict[str, Any] = {k: v for k, v in self.extras.items() if k in self._FIELD_KEYS}
 
         if self.default != UNDEFINED and self.default is not None:
-            data['default'] = self.default
+            data["default"] = self.default
 
         if self.required:
             data = {
                 k: v
                 for k, v in data.items()
                 if k
-                not in (
-                    'default',
-                    'default_factory',
-                )
+                not in {
+                    "default",
+                    "default_factory",
+                }
             }
 
         if not data:
-            return ''
+            return ""
 
-        if len(data) == 1 and 'default' in data:
-            default = data['default']
+        if len(data) == 1 and "default" in data:
+            default = data["default"]
 
             if isinstance(default, (list, dict)):
-                return f'field(default_factory=lambda :{repr(default)})'
+                return f"field(default_factory=lambda :{default!r})"
             return repr(default)
-        kwargs = [
-            f'{k}={v if k == "default_factory" else repr(v)}' for k, v in data.items()
-        ]
-        return f'field({", ".join(kwargs)})'
+        kwargs = [f"{k}={v if k == 'default_factory' else repr(v)}" for k, v in data.items()]
+        return f"field({', '.join(kwargs)})"
 
 
 class DataTypeManager(_DataTypeManager):
-    def __init__(
+    def __init__(  # noqa: PLR0913, PLR0917
         self,
         python_version: PythonVersion = PythonVersion.PY_38,
-        use_standard_collections: bool = False,
-        use_generic_container_types: bool = False,
-        strict_types: Optional[Sequence[StrictTypes]] = None,
-        use_non_positive_negative_number_constrained_types: bool = False,
-        use_union_operator: bool = False,
-        use_pendulum: bool = False,
+        use_standard_collections: bool = False,  # noqa: FBT001, FBT002
+        use_generic_container_types: bool = False,  # noqa: FBT001, FBT002
+        strict_types: Sequence[StrictTypes] | None = None,
+        use_non_positive_negative_number_constrained_types: bool = False,  # noqa: FBT001, FBT002
+        use_union_operator: bool = False,  # noqa: FBT001, FBT002
+        use_pendulum: bool = False,  # noqa: FBT001, FBT002
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
-    ):
+    ) -> None:
         super().__init__(
             python_version,
             use_standard_collections,
@@ -175,7 +174,7 @@ class DataTypeManager(_DataTypeManager):
             else {}
         )
 
-        self.type_map: Dict[Types, DataType] = {
+        self.type_map: dict[Types, DataType] = {
             **type_map_factory(self.data_type),
             **datetime_map,
         }