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

datamodel_code_generator/types.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from abc import ABC, abstractmethod
 from enum import Enum, auto
@@ -9,7 +11,6 @@ from typing import (
     Callable,
     ClassVar,
     Dict,
-    FrozenSet,
     Iterable,
     Iterator,
     List,
@@ -17,8 +18,6 @@ from typing import (
     Pattern,
     Sequence,
     Set,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
@@ -52,50 +51,53 @@ from datamodel_code_generator.util import (
     runtime_checkable,
 )
 
+if TYPE_CHECKING:
+    import builtins
+
 if PYDANTIC_V2:
     from pydantic import GetCoreSchemaHandler
     from pydantic_core import core_schema
 
-T = TypeVar('T')
-
-OPTIONAL = 'Optional'
-OPTIONAL_PREFIX = f'{OPTIONAL}['
-
-UNION = 'Union'
-UNION_PREFIX = f'{UNION}['
-UNION_DELIMITER = ', '
-UNION_PATTERN: Pattern[str] = re.compile(r'\s*,\s*')
-UNION_OPERATOR_DELIMITER = ' | '
-UNION_OPERATOR_PATTERN: Pattern[str] = re.compile(r'\s*\|\s*')
-NONE = 'None'
-ANY = 'Any'
-LITERAL = 'Literal'
-SEQUENCE = 'Sequence'
-FROZEN_SET = 'FrozenSet'
-MAPPING = 'Mapping'
-DICT = 'Dict'
-SET = 'Set'
-LIST = 'List'
-STANDARD_DICT = 'dict'
-STANDARD_LIST = 'list'
-STANDARD_SET = 'set'
-STR = 'str'
-
-NOT_REQUIRED = 'NotRequired'
-NOT_REQUIRED_PREFIX = f'{NOT_REQUIRED}['
+T = TypeVar("T")
+
+OPTIONAL = "Optional"
+OPTIONAL_PREFIX = f"{OPTIONAL}["
+
+UNION = "Union"
+UNION_PREFIX = f"{UNION}["
+UNION_DELIMITER = ", "
+UNION_PATTERN: Pattern[str] = re.compile(r"\s*,\s*")
+UNION_OPERATOR_DELIMITER = " | "
+UNION_OPERATOR_PATTERN: Pattern[str] = re.compile(r"\s*\|\s*")
+NONE = "None"
+ANY = "Any"
+LITERAL = "Literal"
+SEQUENCE = "Sequence"
+FROZEN_SET = "FrozenSet"
+MAPPING = "Mapping"
+DICT = "Dict"
+SET = "Set"
+LIST = "List"
+STANDARD_DICT = "dict"
+STANDARD_LIST = "list"
+STANDARD_SET = "set"
+STR = "str"
+
+NOT_REQUIRED = "NotRequired"
+NOT_REQUIRED_PREFIX = f"{NOT_REQUIRED}["
 
 
 class StrictTypes(Enum):
-    str = 'str'
-    bytes = 'bytes'
-    int = 'int'
-    float = 'float'
-    bool = 'bool'
+    str = "str"
+    bytes = "bytes"
+    int = "int"
+    float = "float"
+    bool = "bool"
 
 
 class UnionIntFloat:
-    def __init__(self, value: Union[int, float]) -> None:
-        self.value: Union[int, float] = value
+    def __init__(self, value: float) -> None:
+        self.value: int | float = value
 
     def __int__(self) -> int:
         return int(self.value)
@@ -107,41 +109,41 @@ class UnionIntFloat:
         return str(self.value)
 
     @classmethod
-    def __get_validators__(cls) -> Iterator[Callable[[Any], Any]]:
+    def __get_validators__(cls) -> Iterator[Callable[[Any], Any]]:  # noqa: PLW3201
         yield cls.validate
 
     @classmethod
-    def __get_pydantic_core_schema__(
-        cls, _source_type: Any, _handler: 'GetCoreSchemaHandler'
-    ) -> 'core_schema.CoreSchema':
-        from_int_schema = core_schema.chain_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
+    def __get_pydantic_core_schema__(  # noqa: PLW3201
+        cls, _source_type: Any, _handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        from_int_schema = core_schema.chain_schema(  # pyright: ignore[reportPossiblyUnboundVariable]
             [
-                core_schema.union_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
-                    [core_schema.int_schema(), core_schema.float_schema()]  # pyright: ignore [reportPossiblyUnboundVariable]
+                core_schema.union_schema(  # pyright: ignore[reportPossiblyUnboundVariable]
+                    [core_schema.int_schema(), core_schema.float_schema()]  # pyright: ignore[reportPossiblyUnboundVariable]
                 ),
-                core_schema.no_info_plain_validator_function(cls.validate),  # pyright: ignore [reportPossiblyUnboundVariable]
+                core_schema.no_info_plain_validator_function(cls.validate),  # pyright: ignore[reportPossiblyUnboundVariable]
             ]
         )
 
-        return core_schema.json_or_python_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
+        return core_schema.json_or_python_schema(  # pyright: ignore[reportPossiblyUnboundVariable]
             json_schema=from_int_schema,
-            python_schema=core_schema.union_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
+            python_schema=core_schema.union_schema(  # pyright: ignore[reportPossiblyUnboundVariable]
                 [
                     # check if it's an instance first before doing any further work
-                    core_schema.is_instance_schema(UnionIntFloat),  # pyright: ignore [reportPossiblyUnboundVariable]
+                    core_schema.is_instance_schema(UnionIntFloat),  # pyright: ignore[reportPossiblyUnboundVariable]
                     from_int_schema,
                 ]
             ),
-            serialization=core_schema.plain_serializer_function_ser_schema(  # pyright: ignore [reportPossiblyUnboundVariable]
+            serialization=core_schema.plain_serializer_function_ser_schema(  # pyright: ignore[reportPossiblyUnboundVariable]
                 lambda instance: instance.value
             ),
         )
 
     @classmethod
-    def validate(cls, v: Any) -> 'UnionIntFloat':
+    def validate(cls, v: Any) -> UnionIntFloat:
         if isinstance(v, UnionIntFloat):
             return v
-        elif not isinstance(v, (int, float)):  # pragma: no cover
+        if not isinstance(v, (int, float)):  # pragma: no cover
             try:
                 int(v)
                 return cls(v)
@@ -153,69 +155,63 @@ class UnionIntFloat:
             except (TypeError, ValueError):
                 pass
 
-            raise TypeError(f'{v} is not int or float')
+            msg = f"{v} is not int or float"
+            raise TypeError(msg)
         return cls(v)
 
 
-def chain_as_tuple(*iterables: Iterable[T]) -> Tuple[T, ...]:
+def chain_as_tuple(*iterables: Iterable[T]) -> tuple[T, ...]:
     return tuple(chain(*iterables))
 
 
 @lru_cache
-def _remove_none_from_type(
-    type_: str, split_pattern: Pattern[str], delimiter: str
-) -> List[str]:
-    types: List[str] = []
-    split_type: str = ''
+def _remove_none_from_type(type_: str, split_pattern: Pattern[str], delimiter: str) -> list[str]:
+    types: list[str] = []
+    split_type: str = ""
     inner_count: int = 0
     for part in re.split(split_pattern, type_):
         if part == NONE:
             continue
-        inner_count += part.count('[') - part.count(']')
+        inner_count += part.count("[") - part.count("]")
         if split_type:
             split_type += delimiter
         if inner_count == 0:
             if split_type:
-                types.append(f'{split_type}{part}')
+                types.append(f"{split_type}{part}")
             else:
                 types.append(part)
-            split_type = ''
+            split_type = ""
             continue
-        else:
-            split_type += part
+        split_type += part
     return types
 
 
-def _remove_none_from_union(type_: str, use_union_operator: bool) -> str:
+def _remove_none_from_union(type_: str, use_union_operator: bool) -> str:  # noqa: FBT001
     if use_union_operator:
-        if not re.match(r'^\w+ | ', type_):
+        if not re.match(r"^\w+ | ", type_):
             return type_
         return UNION_OPERATOR_DELIMITER.join(
-            _remove_none_from_type(
-                type_, UNION_OPERATOR_PATTERN, UNION_OPERATOR_DELIMITER
-            )
+            _remove_none_from_type(type_, UNION_OPERATOR_PATTERN, UNION_OPERATOR_DELIMITER)
         )
 
     if not type_.startswith(UNION_PREFIX):
         return type_
-    inner_types = _remove_none_from_type(
-        type_[len(UNION_PREFIX) :][:-1], UNION_PATTERN, UNION_DELIMITER
-    )
+    inner_types = _remove_none_from_type(type_[len(UNION_PREFIX) :][:-1], UNION_PATTERN, UNION_DELIMITER)
 
     if len(inner_types) == 1:
         return inner_types[0]
-    return f'{UNION_PREFIX}{UNION_DELIMITER.join(inner_types)}]'
+    return f"{UNION_PREFIX}{UNION_DELIMITER.join(inner_types)}]"
 
 
 @lru_cache
-def get_optional_type(type_: str, use_union_operator: bool) -> str:
+def get_optional_type(type_: str, use_union_operator: bool) -> str:  # noqa: FBT001
     type_ = _remove_none_from_union(type_, use_union_operator)
 
     if not type_ or type_ == NONE:
         return NONE
     if use_union_operator:
-        return f'{type_} | {NONE}'
-    return f'{OPTIONAL_PREFIX}{type_}]'
+        return f"{type_} | {NONE}"
+    return f"{OPTIONAL_PREFIX}{type_}]"
 
 
 @runtime_checkable
@@ -236,9 +232,9 @@ class DataType(_BaseModel):
     if PYDANTIC_V2:
         # TODO[pydantic]: The following keys were removed: `copy_on_model_validation`.
         # Check https://docs.pydantic.dev/dev-v2/migration/#changes-to-config for more information.
-        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
-            extra='forbid',
-            revalidate_instances='never',
+        model_config = ConfigDict(  # pyright: ignore[reportAssignmentType]
+            extra="forbid",
+            revalidate_instances="never",
         )
     else:
         if not TYPE_CHECKING:
@@ -248,41 +244,37 @@ class DataType(_BaseModel):
                 cls.update_forward_refs()
 
         class Config:
-            extra = 'forbid'
-            copy_on_model_validation = (
-                False
-                if version.parse(pydantic.VERSION) < version.parse('1.9.2')
-                else 'none'
-            )
+            extra = "forbid"
+            copy_on_model_validation = False if version.parse(pydantic.VERSION) < version.parse("1.9.2") else "none"
 
-    type: Optional[str] = None
-    reference: Optional[Reference] = None
-    data_types: List['DataType'] = []
+    type: Optional[str] = None  # noqa: UP045
+    reference: Optional[Reference] = None  # noqa: UP045
+    data_types: List[DataType] = []  # noqa: RUF012, UP006
     is_func: bool = False
-    kwargs: Optional[Dict[str, Any]] = None
-    import_: Optional[Import] = None
+    kwargs: Optional[Dict[str, Any]] = None  # noqa: UP006, UP045
+    import_: Optional[Import] = None  # noqa: UP045
     python_version: PythonVersion = PythonVersion.PY_38
     is_optional: bool = False
     is_dict: bool = False
     is_list: bool = False
     is_set: bool = False
     is_custom_type: bool = False
-    literals: List[Union[StrictBool, StrictInt, StrictStr]] = []
+    literals: List[Union[StrictBool, StrictInt, StrictStr]] = []  # noqa: RUF012, UP006, UP007
     use_standard_collections: bool = False
     use_generic_container: bool = False
     use_union_operator: bool = False
-    alias: Optional[str] = None
-    parent: Optional[Any] = None
-    children: List[Any] = []
+    alias: Optional[str] = None  # noqa: UP045
+    parent: Optional[Any] = None  # noqa: UP045
+    children: List[Any] = []  # noqa: RUF012, UP006
     strict: bool = False
-    dict_key: Optional['DataType'] = None
+    dict_key: Optional[DataType] = None  # noqa: UP045
 
-    _exclude_fields: ClassVar[Set[str]] = {'parent', 'children'}
-    _pass_fields: ClassVar[Set[str]] = {'parent', 'children', 'data_types', 'reference'}
+    _exclude_fields: ClassVar[Set[str]] = {"parent", "children"}  # noqa: UP006
+    _pass_fields: ClassVar[Set[str]] = {"parent", "children", "data_types", "reference"}  # noqa: UP006
 
     @classmethod
-    def from_import(
-        cls: Type['DataTypeT'],
+    def from_import(  # noqa: PLR0913
+        cls: builtins.type[DataTypeT],
         import_: Import,
         *,
         is_optional: bool = False,
@@ -291,8 +283,8 @@ class DataType(_BaseModel):
         is_set: bool = False,
         is_custom_type: bool = False,
         strict: bool = False,
-        kwargs: Optional[Dict[str, Any]] = None,
-    ) -> 'DataTypeT':
+        kwargs: dict[str, Any] | None = None,
+    ) -> DataTypeT:
         return cls(
             type=import_.import_,
             import_=import_,
@@ -300,34 +292,25 @@ class DataType(_BaseModel):
             is_dict=is_dict,
             is_list=is_list,
             is_set=is_set,
-            is_func=True if kwargs else False,
+            is_func=bool(kwargs),
             is_custom_type=is_custom_type,
             strict=strict,
             kwargs=kwargs,
         )
 
     @property
-    def unresolved_types(self) -> FrozenSet[str]:
+    def unresolved_types(self) -> frozenset[str]:
         return frozenset(
-            {
-                t.reference.path
-                for data_types in self.data_types
-                for t in data_types.all_data_types
-                if t.reference
-            }
+            {t.reference.path for data_types in self.data_types for t in data_types.all_data_types if t.reference}
             | ({self.reference.path} if self.reference else set())
         )
 
-    def replace_reference(self, reference: Optional[Reference]) -> None:
+    def replace_reference(self, reference: Reference | None) -> None:
         if not self.reference:  # pragma: no cover
-            raise Exception(
-                f"`{self.__class__.__name__}.replace_reference()` can't be called"
-                f' when `reference` field is empty.'
-            )
+            msg = f"`{self.__class__.__name__}.replace_reference()` can't be called when `reference` field is empty."
+            raise Exception(msg)  # noqa: TRY002
         self_id = id(self)
-        self.reference.children = [
-            c for c in self.reference.children if id(c) != self_id
-        ]
+        self.reference.children = [c for c in self.reference.children if id(c) != self_id]
         self.reference = reference
         if reference:
             reference.children.append(self)
@@ -336,7 +319,7 @@ class DataType(_BaseModel):
         self.replace_reference(None)
 
     @property
-    def module_name(self) -> Optional[str]:
+    def module_name(self) -> str | None:
         if self.reference and isinstance(self.reference.source, Modular):
             return self.reference.source.module_name
         return None  # pragma: no cover
@@ -345,11 +328,11 @@ class DataType(_BaseModel):
     def full_name(self) -> str:
         module_name = self.module_name
         if module_name:
-            return f'{module_name}.{self.reference.short_name}'  # type: ignore
-        return self.reference.short_name  # type: ignore
+            return f"{module_name}.{self.reference.short_name if self.reference else ''}"
+        return self.reference.short_name if self.reference else ""
 
     @property
-    def all_data_types(self) -> Iterator['DataType']:
+    def all_data_types(self) -> Iterator[DataType]:
         for data_type in self.data_types:
             yield from data_type.all_data_types
         yield self
@@ -367,14 +350,12 @@ class DataType(_BaseModel):
             yield self.import_
 
         # Define required imports based on type features and conditions
-        imports: Tuple[Tuple[bool, Import], ...] = (
+        imports: tuple[tuple[bool, Import], ...] = (
             (self.is_optional and not self.use_union_operator, IMPORT_OPTIONAL),
             (len(self.data_types) > 1 and not self.use_union_operator, IMPORT_UNION),
             (
                 bool(self.literals),
-                IMPORT_LITERAL
-                if self.python_version.has_literal_type
-                else IMPORT_LITERAL_BACKPORT,
+                IMPORT_LITERAL if self.python_version.has_literal_type else IMPORT_LITERAL_BACKPORT,
             ),
         )
 
@@ -418,11 +399,7 @@ class DataType(_BaseModel):
             if type_.type == ANY and type_.is_optional:
                 if any(t for t in self.data_types if t.type != ANY):  # pragma: no cover
                     self.is_optional = True
-                    self.data_types = [
-                        t
-                        for t in self.data_types
-                        if not (t.type == ANY and t.is_optional)
-                    ]
+                    self.data_types = [t for t in self.data_types if not (t.type == ANY and t.is_optional)]
                 break  # pragma: no cover
 
         for data_type in self.data_types:
@@ -433,23 +410,21 @@ class DataType(_BaseModel):
             self.reference.children.append(self)
 
     @property
-    def type_hint(self) -> str:
-        type_: Optional[str] = self.alias or self.type
+    def type_hint(self) -> str:  # noqa: PLR0912, PLR0915
+        type_: str | None = self.alias or self.type
         if not type_:
             if self.is_union:
-                data_types: List[str] = []
+                data_types: list[str] = []
                 for data_type in self.data_types:
                     data_type_type = data_type.type_hint
                     if data_type_type in data_types:  # pragma: no cover
                         continue
 
-                    if NONE == data_type_type:
+                    if data_type_type == NONE:
                         self.is_optional = True
                         continue
 
-                    non_optional_data_type_type = _remove_none_from_union(
-                        data_type_type, self.use_union_operator
-                    )
+                    non_optional_data_type_type = _remove_none_from_union(data_type_type, self.use_union_operator)
 
                     if non_optional_data_type_type != data_type_type:
                         self.is_optional = True
@@ -457,22 +432,19 @@ class DataType(_BaseModel):
                     data_types.append(non_optional_data_type_type)
                 if len(data_types) == 1:
                     type_ = data_types[0]
+                elif self.use_union_operator:
+                    type_ = UNION_OPERATOR_DELIMITER.join(data_types)
                 else:
-                    if self.use_union_operator:
-                        type_ = UNION_OPERATOR_DELIMITER.join(data_types)
-                    else:
-                        type_ = f'{UNION_PREFIX}{UNION_DELIMITER.join(data_types)}]'
+                    type_ = f"{UNION_PREFIX}{UNION_DELIMITER.join(data_types)}]"
             elif len(self.data_types) == 1:
                 type_ = self.data_types[0].type_hint
             elif self.literals:
-                type_ = f'{LITERAL}[{", ".join(repr(literal) for literal in self.literals)}]'
+                type_ = f"{LITERAL}[{', '.join(repr(literal) for literal in self.literals)}]"
+            elif self.reference:
+                type_ = self.reference.short_name
             else:
-                if self.reference:
-                    type_ = self.reference.short_name
-                else:
-                    # TODO support strict Any
-                    # type_ = 'Any'
-                    type_ = ''
+                # TODO support strict Any
+                type_ = ""
         if self.reference:
             source = self.reference.source
             if isinstance(source, Nullable) and source.nullable:
@@ -486,7 +458,7 @@ class DataType(_BaseModel):
                 list_ = STANDARD_LIST
             else:
                 list_ = LIST
-            type_ = f'{list_}[{type_}]' if type_ else list_
+            type_ = f"{list_}[{type_}]" if type_ else list_
         elif self.is_set:
             if self.use_generic_container:
                 set_ = FROZEN_SET
@@ -494,7 +466,7 @@ class DataType(_BaseModel):
                 set_ = STANDARD_SET
             else:
                 set_ = SET
-            type_ = f'{set_}[{type_}]' if type_ else set_
+            type_ = f"{set_}[{type_}]" if type_ else set_
         elif self.is_dict:
             if self.use_generic_container:
                 dict_ = MAPPING
@@ -504,16 +476,16 @@ class DataType(_BaseModel):
                 dict_ = DICT
             if self.dict_key or type_:
                 key = self.dict_key.type_hint if self.dict_key else STR
-                type_ = f'{dict_}[{key}, {type_ or ANY}]'
+                type_ = f"{dict_}[{key}, {type_ or ANY}]"
             else:  # pragma: no cover
                 type_ = dict_
         if self.is_optional and type_ != ANY:
             return get_optional_type(type_, self.use_union_operator)
-        elif self.is_func:
+        if self.is_func:
             if self.kwargs:
-                kwargs: str = ', '.join(f'{k}={v}' for k, v in self.kwargs.items())
-                return f'{type_}({kwargs})'
-            return f'{type_}()'
+                kwargs: str = ", ".join(f"{k}={v}" for k, v in self.kwargs.items())
+                return f"{type_}({kwargs})"
+            return f"{type_}()"
         return type_
 
     @property
@@ -523,7 +495,7 @@ class DataType(_BaseModel):
 
 DataType.model_rebuild()
 
-DataTypeT = TypeVar('DataTypeT', bound=DataType)
+DataTypeT = TypeVar("DataTypeT", bound=DataType)
 
 
 class EmptyDataType(DataType):
@@ -568,16 +540,16 @@ class Types(Enum):
 
 
 class DataTypeManager(ABC):
-    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,
-        target_datetime_class: Optional[DatetimeClassType] = None,
+        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 | None = None,
     ) -> None:
         self.python_version = python_version
         self.use_standard_collections: bool = use_standard_collections
@@ -588,23 +560,20 @@ class DataTypeManager(ABC):
         )
         self.use_union_operator: bool = use_union_operator
         self.use_pendulum: bool = use_pendulum
-        self.target_datetime_class: DatetimeClassType = (
-            target_datetime_class or DatetimeClassType.Datetime
-        )
+        self.target_datetime_class: DatetimeClassType = target_datetime_class or DatetimeClassType.Datetime
 
-        if (
-            use_generic_container_types and python_version == PythonVersion.PY_36
-        ):  # pragma: no cover
-            raise Exception(
-                'use_generic_container_types can not be used with target_python_version 3.6.\n'
-                ' The version will be not supported in a future version'
+        if use_generic_container_types and python_version == PythonVersion.PY_36:  # pragma: no cover
+            msg = (
+                "use_generic_container_types can not be used with target_python_version 3.6.\n"
+                " The version will be not supported in a future version"
             )
+            raise Exception(msg)  # noqa: TRY002
 
         if TYPE_CHECKING:
-            self.data_type: Type[DataType]
+            self.data_type: type[DataType]
         else:
-            self.data_type: Type[DataType] = create_model(
-                'ContextDataType',
+            self.data_type: type[DataType] = create_model(
+                "ContextDataType",
                 python_version=(PythonVersion, python_version),
                 use_standard_collections=(bool, use_standard_collections),
                 use_generic_container=(bool, use_generic_container_types),
@@ -616,15 +585,11 @@ class DataTypeManager(ABC):
     def get_data_type(self, types: Types, **kwargs: Any) -> DataType:
         raise NotImplementedError
 
-    def get_data_type_from_full_path(
-        self, full_path: str, is_custom_type: bool
-    ) -> DataType:
-        return self.data_type.from_import(
-            Import.from_full_path(full_path), is_custom_type=is_custom_type
-        )
+    def get_data_type_from_full_path(self, full_path: str, is_custom_type: bool) -> DataType:  # noqa: FBT001
+        return self.data_type.from_import(Import.from_full_path(full_path), is_custom_type=is_custom_type)
 
     def get_data_type_from_value(self, value: Any) -> DataType:
-        type_: Optional[Types] = None
+        type_: Types | None = None
         if isinstance(value, str):
             type_ = Types.string
         elif isinstance(value, bool):