dycw-utilities 0.110.7__tar.gz → 0.111.0__tar.gz

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.110.7
+Version: 0.111.0
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.110.7"
+version = "0.111.0"
 
 [project.optional-dependencies]
 test = [
@@ -337,7 +337,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.110.7"
+current_version = "0.111.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/tests/test_datetime.py

@@ -107,10 +107,8 @@ from utilities.datetime import (
     get_today_local,
     get_today_tokyo,
     get_years,
-    is_instance_date_not_datetime,
     is_integral_timedelta,
     is_local_datetime,
-    is_subclass_date_not_datetime,
     is_weekday,
     is_zero_time,
     is_zoned_datetime,
@@ -751,16 +749,6 @@ class TestGetToday:
         assert isinstance(today, dt.date)
 
 
-class TestIsInstanceDateNotDateTime:
-    @given(date=dates())
-    def test_date(self, *, date: dt.date) -> None:
-        assert is_instance_date_not_datetime(date)
-
-    @given(datetime=datetimes())
-    def test_datetime(self, *, datetime: dt.datetime) -> None:
-        assert not is_instance_date_not_datetime(datetime)
-
-
 class TestIsIntegralTimeDelta:
     @given(n=integers())
     def test_integral(self, *, n: int) -> None:
@@ -794,13 +782,6 @@ class TestIsLocalDateTime:
         assert result is expected
 
 
-class TestIsSubClassDateNotDateTime:
-    @given(case=sampled_from([(dt.date, True), (dt.datetime, False)]))
-    def test_date(self, *, case: tuple[type[Any], bool]) -> None:
-        type_, expected = case
-        assert is_subclass_date_not_datetime(type_) is expected
-
-
 class TestIsWeekday:
     @given(date=dates())
     def test_main(self, *, date: dt.date) -> None:

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/tests/test_functions.py

@@ -12,7 +12,6 @@ from typing import TYPE_CHECKING, Any, ClassVar, ParamSpec, TypeVar, cast
 from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
-    SearchStrategy,
     booleans,
     builds,
     data,
@@ -74,7 +73,6 @@ from utilities.functions import (
     is_dataclass_class,
     is_dataclass_instance,
     is_hashable,
-    is_instance_not_bool_int,
     is_iterable_of,
     is_none,
     is_not_none,
@@ -83,7 +81,6 @@ from utilities.functions import (
     is_sized,
     is_sized_not_str,
     is_string_mapping,
-    is_subclass_not_bool_int,
     is_tuple,
     is_tuple_or_str_mapping,
     make_isinstance,
@@ -622,39 +619,6 @@ class TestIsHashable:
         assert is_hashable(obj) is expected
 
 
-class TestIsInstanceNotIntBool:
-    @given(
-        data=data(),
-        case=sampled_from([
-            (booleans(), bool, True),
-            (booleans(), int, False),
-            (integers(), bool, False),
-            (integers(), int, True),
-            (booleans(), (bool, int), True),
-            (integers(), (bool, int), True),
-        ]),
-    )
-    def test_main(
-        self, *, data: DataObject, case: tuple[SearchStrategy[Any], type[Any], bool]
-    ) -> None:
-        strategy, type_, expected = case
-        value = data.draw(strategy)
-        assert is_instance_not_bool_int(value, type_) is expected
-
-    @given(bool_=booleans())
-    def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
-        class MyInt(int): ...
-
-        assert not is_instance_not_bool_int(bool_, MyInt)
-
-    @given(int_=integers())
-    def test_int_value_vs_custom_int(self, *, int_: int) -> None:
-        class MyInt(int): ...
-
-        assert not is_instance_not_bool_int(int_, MyInt)
-        assert is_instance_not_bool_int(MyInt(int_), MyInt)
-
-
 class TestIsIterableOf:
     @given(
         case=sampled_from([
@@ -775,31 +739,6 @@ class TestIsStringMapping:
         assert result is expected
 
 
-class TestIsSubclassNotBoolInt:
-    @given(
-        case=sampled_from([
-            (bool, bool, True),
-            (bool, int, False),
-            (int, bool, False),
-            (int, int, True),
-            (bool, (bool, int), True),
-            (int, (bool, int), True),
-        ])
-    )
-    def test_main(self, *, case: tuple[type[Any], type[Any], bool]) -> None:
-        child, parent, expected = case
-        assert is_subclass_not_bool_int(child, parent) is expected
-
-    def test_custom_int(self) -> None:
-        class MyInt(int): ...
-
-        assert not is_subclass_not_bool_int(bool, MyInt)
-        assert not is_subclass_not_bool_int(MyInt, bool)
-        assert not is_subclass_not_bool_int(int, MyInt)
-        assert is_subclass_not_bool_int(MyInt, int)
-        assert is_subclass_not_bool_int(MyInt, MyInt)
-
-
 class TestIsTuple:
     @given(case=sampled_from([(None, False), ((1, 2, 3), True), ([1, 2, 3], False)]))
     def test_main(self, *, case: tuple[Any, bool]) -> None:

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/tests/test_orjson.py

@@ -23,7 +23,7 @@ from hypothesis.strategies import (
 )
 from orjson import JSONDecodeError
 from polars import Object, String, UInt64
-from pytest import approx, mark, raises
+from pytest import approx, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from tests.test_operator import (
@@ -147,7 +147,6 @@ class TestGetLogRecords:
         ),
         root=temp_paths(),
     )
-    @mark.flaky
     def test_dataframe(
         self, *, root: Path, items: Sequence[tuple[LogLevel, str, StrMapping]]
     ) -> None:
@@ -205,7 +204,6 @@ class TestGetLogRecords:
         min_log_file_line_num=integers() | none(),
         max_log_file_line_num=integers() | none(),
     )
-    @mark.flaky
     def test_filter(
         self,
         *,

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/tests/test_typing.py

@@ -4,12 +4,25 @@ import datetime as dt
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from random import Random
 from types import NoneType
 from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Self
 from uuid import UUID
 
 from hypothesis import given
-from hypothesis.strategies import DataObject, data, just, none, sampled_from
+from hypothesis.strategies import (
+    DataObject,
+    SearchStrategy,
+    booleans,
+    data,
+    dates,
+    datetimes,
+    floats,
+    integers,
+    just,
+    none,
+    sampled_from,
+)
 from pytest import mark, param, raises
 
 from tests.test_typing_funcs.no_future import (
@@ -39,14 +52,21 @@ from tests.test_typing_funcs.with_future import (
     TrueOrFalseFutureTypeLit,
 )
 from utilities.sentinel import Sentinel
-from utilities.types import LogLevel, Parallelism
+from utilities.types import Duration, LogLevel, Number, Parallelism, Seed
 from utilities.typing import (
+    _GetTypeClassesTupleError,
+    _GetTypeClassesTypeError,
+    _GetUnionTypeClassesInternalTypeError,
+    _GetUnionTypeClassesUnionTypeError,
     contains_self,
     get_args,
     get_literal_elements,
+    get_type_classes,
     get_type_hints,
+    get_union_type_classes,
     is_dict_type,
     is_frozenset_type,
+    is_instance_gen,
     is_list_type,
     is_literal_type,
     is_mapping_type,
@@ -55,6 +75,7 @@ from utilities.typing import (
     is_optional_type,
     is_sequence_type,
     is_set_type,
+    is_subclass_gen,
     is_tuple_type,
     is_union_type,
 )
@@ -114,6 +135,38 @@ class TestGetLiteralElements:
         assert result == expected
 
 
+class TestGetTypeClasses:
+    @given(
+        case=sampled_from([
+            (int, (int,)),
+            ((int, float), (int, float)),
+            (Duration, (int, float, dt.timedelta)),
+            (Number, (int, float)),
+            (Seed, (int, float, str, bytes, bytearray, Random)),
+            ((int, Number), (int, int, float)),
+            ((int, (Number,)), (int, int, float)),
+        ])
+    )
+    def test_main(self, *, case: tuple[Any, tuple[type[Any], ...]]) -> None:
+        obj, expected = case
+        result = get_type_classes(obj)
+        assert result == expected
+
+    def test_error_type(self) -> None:
+        with raises(
+            _GetTypeClassesTypeError,
+            match="Object must be a type, tuple or Union type; got None",
+        ):
+            _ = get_type_classes(None)
+
+    def test_error_tuple(self) -> None:
+        with raises(
+            _GetTypeClassesTupleError,
+            match="Tuple must contain types, tuples or Union types only; got None",
+        ):
+            _ = get_type_classes((None,))
+
+
 class TestGetTypeHints:
     @given(data=data())
     def test_date(self, *, data: DataObject) -> None:
@@ -335,6 +388,34 @@ class TestGetTypeHints:
             _ = get_type_hints(Outer, warn_name_errors=True)
 
 
+class TestGetUnionTypeClasses:
+    @given(
+        case=sampled_from([
+            (Duration, (int, float, dt.timedelta)),
+            (Number, (int, float)),
+            (Seed, (int, float, str, bytes, bytearray, Random)),
+        ])
+    )
+    def test_main(self, *, case: tuple[Any, tuple[type[Any], ...]]) -> None:
+        obj, expected = case
+        result = get_union_type_classes(obj)
+        assert result == expected
+
+    def test_error_union_type(self) -> None:
+        with raises(
+            _GetUnionTypeClassesUnionTypeError,
+            match="Object must be a Union type; got None",
+        ):
+            _ = get_union_type_classes(None)
+
+    def test_error_interal_type(self) -> None:
+        with raises(
+            _GetUnionTypeClassesInternalTypeError,
+            match=r"Union type must contain types only; got typing\.Literal\[True\]",
+        ):
+            _ = get_union_type_classes(Literal[True] | None)
+
+
 class TestIsAnnotationOfType:
     @mark.parametrize(
         ("func", "obj", "expected"),
@@ -406,6 +487,46 @@ class TestIsAnnotationOfType:
         assert func(obj) is expected
 
 
+class TestIsInstanceGen:
+    @given(
+        data=data(),
+        case=sampled_from([
+            (booleans(), bool, True),
+            (booleans(), int, False),
+            (integers(), bool, False),
+            (integers(), int, True),
+            (booleans(), (bool, int), True),
+            (integers(), (bool, int), True),
+            (dates(), dt.date, True),
+            (dates(), dt.datetime, False),
+            (datetimes(), dt.date, False),
+            (datetimes(), dt.datetime, True),
+            (booleans(), Number, False),
+            (integers(), Number, True),
+            (floats(), Number, True),
+        ]),
+    )
+    def test_main(
+        self, *, data: DataObject, case: tuple[SearchStrategy[Any], Any, bool]
+    ) -> None:
+        strategy, type_, expected = case
+        value = data.draw(strategy)
+        assert is_instance_gen(value, type_) is expected
+
+    @given(bool_=booleans())
+    def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_gen(bool_, MyInt)
+
+    @given(int_=integers())
+    def test_int_value_vs_custom_int(self, *, int_: int) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_gen(int_, MyInt)
+        assert is_instance_gen(MyInt(int_), MyInt)
+
+
 class TestIsNamedTuple:
     def test_main(self) -> None:
         class Example(NamedTuple):
@@ -421,3 +542,35 @@ class TestIsNamedTuple:
 
         assert not is_namedtuple_class(Example)
         assert not is_namedtuple_instance(Example(x=0))
+
+
+class TestIsSubclassGen:
+    @given(
+        case=sampled_from([
+            (bool, bool, True),
+            (bool, int, False),
+            (int, bool, False),
+            (int, int, True),
+            (bool, (bool, int), True),
+            (int, (bool, int), True),
+            (dt.date, dt.date, True),
+            (dt.date, dt.datetime, False),
+            (dt.datetime, dt.date, False),
+            (dt.datetime, dt.datetime, True),
+            (bool, Number, False),
+            (int, Number, True),
+            (float, Number, True),
+        ])
+    )
+    def test_main(self, *, case: tuple[type[Any], Any, bool]) -> None:
+        child, parent, expected = case
+        assert is_subclass_gen(child, parent) is expected
+
+    def test_custom_int(self) -> None:
+        class MyInt(int): ...
+
+        assert not is_subclass_gen(bool, MyInt)
+        assert not is_subclass_gen(MyInt, bool)
+        assert not is_subclass_gen(int, MyInt)
+        assert is_subclass_gen(MyInt, int)
+        assert is_subclass_gen(MyInt, MyInt)

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.7"
+__version__ = "0.111.0"

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/datetime.py

@@ -22,6 +22,7 @@ from utilities.math import SafeRoundError, round_, safe_round
 from utilities.platform import SYSTEM
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import MaybeStr
+from utilities.typing import is_instance_gen
 from utilities.zoneinfo import (
     UTC,
     HongKong,
@@ -140,9 +141,9 @@ def are_equal_dates_or_datetimes(
     x: DateOrDateTime, y: DateOrDateTime, /, *, strict: bool = False
 ) -> bool:
     """Check if x == y for dates/datetimes."""
-    if is_instance_date_not_datetime(x) and is_instance_date_not_datetime(y):
+    if is_instance_gen(x, dt.date) and is_instance_gen(y, dt.date):
         return x == y
-    if isinstance(x, dt.datetime) and isinstance(y, dt.datetime):
+    if is_instance_gen(x, dt.datetime) and is_instance_gen(y, dt.datetime):
         return are_equal_datetimes(x, y, strict=strict)
     raise AreEqualDatesOrDateTimesError(x=x, y=y)
 
@@ -210,7 +211,7 @@ def are_equal_months(x: DateOrMonth, y: DateOrMonth, /) -> bool:
 
 def check_date_not_datetime(date: dt.date, /) -> None:
     """Check if a date is not a datetime."""
-    if not is_instance_date_not_datetime(date):
+    if not is_instance_gen(date, dt.date):
         raise CheckDateNotDateTimeError(date=date)
 
 
@@ -604,14 +605,6 @@ YEAR = get_years(n=1)
 ##
 
 
-def is_instance_date_not_datetime(obj: Any, /) -> TypeGuard[dt.date]:
-    """Check if an object is a date, and not a datetime."""
-    return isinstance(obj, dt.date) and not isinstance(obj, dt.datetime)
-
-
-##
-
-
 def is_integral_timedelta(timedelta: dt.timedelta, /) -> bool:
     """Check if a timedelta is integral."""
     return (timedelta.seconds == 0) and (timedelta.microseconds == 0)
@@ -628,14 +621,6 @@ def is_local_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
 ##
 
 
-def is_subclass_date_not_datetime(cls: type[Any], /) -> TypeGuard[type[dt.date]]:
-    """Check if a class is a date, and not a datetime."""
-    return issubclass(cls, dt.date) and not issubclass(cls, dt.datetime)
-
-
-##
-
-
 _FRIDAY = 5
 
 
@@ -1359,10 +1344,8 @@ __all__ = [
     "get_today_local",
     "get_today_tokyo",
     "get_years",
-    "is_instance_date_not_datetime",
     "is_integral_timedelta",
     "is_local_datetime",
-    "is_subclass_date_not_datetime",
     "is_weekday",
     "is_zero_time",
     "is_zoned_datetime",

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/functions.py

@@ -22,7 +22,6 @@ from typing import (
     Literal,
     TypeGuard,
     TypeVar,
-    assert_never,
     cast,
     overload,
     override,
@@ -660,28 +659,6 @@ def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
 ##
 
 
-def is_instance_not_bool_int(
-    obj: Any, class_or_tuple: TypeLike[Any], /
-) -> TypeGuard[int]:
-    """Check if an instance relationship holds, except bool<int."""
-    match class_or_tuple:
-        case type() as type_:
-            return _is_instance_not_bool_int(obj, type_)
-        case tuple() as types:
-            return any(_is_instance_not_bool_int(obj, p) for p in types)
-        case _ as never:
-            assert_never(never)
-
-
-def _is_instance_not_bool_int(obj: Any, type_: type[Any], /) -> bool:
-    return isinstance(obj, type_) and not (
-        isinstance(obj, bool) and issubclass(type_, int) and not issubclass(type_, bool)
-    )
-
-
-##
-
-
 @overload
 def is_iterable_of(obj: Any, cls: type[_T], /) -> TypeGuard[Iterable[_T]]: ...
 @overload
@@ -796,28 +773,6 @@ def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
 ##
 
 
-def is_subclass_not_bool_int(cls: type[Any], class_or_tuple: TypeLike[Any], /) -> bool:
-    """Check if a subclass relationship holds, except bool<int."""
-    match class_or_tuple:
-        case type() as parent:
-            return _is_subclass_int_not_bool_one(cls, parent)
-        case tuple() as parents:
-            return any(_is_subclass_int_not_bool_one(cls, p) for p in parents)
-        case _ as never:
-            assert_never(never)
-
-
-def _is_subclass_int_not_bool_one(cls: type[Any], parent: type[Any], /) -> bool:
-    return issubclass(cls, parent) and not (
-        issubclass(cls, bool)
-        and issubclass(parent, int)
-        and not issubclass(parent, bool)
-    )
-
-
-##
-
-
 def is_tuple(obj: Any, /) -> TypeGuard[tuple[Any, ...]]:
     """Check if an object is a tuple or string mapping."""
     return make_isinstance(tuple)(obj)
@@ -1075,7 +1030,6 @@ __all__ = [
     "is_dataclass_class",
     "is_dataclass_instance",
     "is_hashable",
-    "is_instance_not_bool_int",
     "is_iterable_of",
     "is_none",
     "is_not_none",
@@ -1083,7 +1037,6 @@ __all__ = [
     "is_sized",
     "is_sized_not_str",
     "is_string_mapping",
-    "is_subclass_not_bool_int",
     "is_tuple",
     "is_tuple_or_str_mapping",
     "make_isinstance",

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/orjson.py

@@ -692,6 +692,7 @@ _LOG_RECORD_DEFAULT_ATTRS = {
     "exc_text",
     "filename",
     "funcName",
+    "getMessage",
     "levelname",
     "levelno",
     "lineno",

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/parse.py

@@ -9,12 +9,7 @@ from re import DOTALL
 from types import NoneType
 from typing import TYPE_CHECKING, Any, override
 
-from utilities.datetime import (
-    is_instance_date_not_datetime,
-    is_subclass_date_not_datetime,
-)
 from utilities.enum import ParseEnumError, parse_enum
-from utilities.functions import is_subclass_not_bool_int
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one, one_str
 from utilities.math import ParseNumberError, parse_number
 from utilities.re import ExtractGroupError, extract_group
@@ -36,10 +31,12 @@ from utilities.typing import (
     get_args,
     is_dict_type,
     is_frozenset_type,
+    is_instance_gen,
     is_list_type,
     is_literal_type,
     is_optional_type,
     is_set_type,
+    is_subclass_gen,
     is_tuple_type,
     is_union_type,
 )
@@ -169,12 +166,12 @@ def _parse_object_type(
             raise _ParseObjectParseError(type_=cls, text=text) from None
     if issubclass(cls, str):
         return text
-    if issubclass(cls, bool):
+    if is_subclass_gen(cls, bool):
         try:
             return parse_bool(text)
         except ParseBoolError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_not_bool_int(cls, int):
+    if is_subclass_gen(cls, int):
         try:
             return int(text)
         except ValueError:
@@ -201,14 +198,14 @@ def _parse_object_type(
             return parse_version(text)
         except ParseVersionError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_date_not_datetime(cls):
+    if is_subclass_gen(cls, dt.date):
         from utilities.whenever import ParseDateError, parse_date
 
         try:
             return parse_date(text)
         except ParseDateError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if issubclass(cls, dt.datetime):
+    if is_subclass_gen(cls, dt.datetime):
         from utilities.whenever import ParseDateTimeError, parse_datetime
 
         try:
@@ -473,11 +470,11 @@ def serialize_object(
         obj, bool | int | float | str | Path | Sentinel | Version
     ):
         return str(obj)
-    if is_instance_date_not_datetime(obj):
+    if is_instance_gen(obj, dt.date):
         from utilities.whenever import serialize_date
 
         return serialize_date(obj)
-    if isinstance(obj, dt.datetime):
+    if is_instance_gen(obj, dt.datetime):
         from utilities.whenever import serialize_datetime
 
         return serialize_datetime(obj)

{dycw_utilities-0.110.7 → dycw_utilities-0.111.0}/src/utilities/period.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import datetime as dt
 from dataclasses import dataclass, field
 from functools import cached_property
+from itertools import permutations
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -15,10 +16,11 @@ from typing import (
     override,
 )
 
-from utilities.datetime import ZERO_TIME, is_instance_date_not_datetime
+from utilities.datetime import ZERO_TIME
 from utilities.functions import get_class_name
 from utilities.iterables import OneUniqueNonUniqueError, always_iterable, one_unique
 from utilities.sentinel import Sentinel, sentinel
+from utilities.typing import is_instance_gen
 from utilities.whenever import (
     serialize_date,
     serialize_local_datetime,
@@ -32,6 +34,7 @@ if TYPE_CHECKING:
     from utilities.iterables import MaybeIterable
     from utilities.types import DateOrDateTime
 
+
 type _DateOrDateTime = Literal["date", "datetime"]
 _TPeriod = TypeVar("_TPeriod", dt.date, dt.datetime)
 
@@ -54,9 +57,11 @@ class Period(Generic[_TPeriod]):
     max_duration: dt.timedelta | None = field(default=None, repr=False, kw_only=True)
 
     def __post_init__(self) -> None:
-        if is_instance_date_not_datetime(
-            self.start
-        ) is not is_instance_date_not_datetime(self.end):
+        if any(
+            is_instance_gen(left, cls) is not is_instance_gen(right, cls)
+            for left, right in permutations([self.start, self.end], 2)
+            for cls in [dt.date, dt.datetime]
+        ):
             raise _PeriodDateAndDateTimeMixedError(start=self.start, end=self.end)
         for date in [self.start, self.end]:
             if isinstance(date, dt.datetime):
@@ -166,7 +171,7 @@ class Period(Generic[_TPeriod]):
     @cached_property
     def kind(self) -> _DateOrDateTime:
         """The kind of the period."""
-        return "date" if is_instance_date_not_datetime(self.start) else "datetime"
+        return "date" if is_instance_gen(self.start, dt.date) else "datetime"
 
     def replace(
         self,