dycw-utilities 0.108.4__tar.gz → 0.109.0__tar.gz

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/PKG-INFO

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

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/pyproject.toml

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

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_dataclasses.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from re import DOTALL
 from types import NoneType
-from typing import Any, Literal, cast, override
+from typing import Any, cast, override
 
 from hypothesis import given
 from hypothesis.strategies import (
@@ -40,6 +40,8 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureStr,
     DataClassFutureTypeLiteral,
     DataClassFutureTypeLiteralNullable,
+    TrueOrFalseFutureLit,
+    TrueOrFalseFutureTypeLit,
 )
 from utilities.dataclasses import (
     YieldFieldsError,
@@ -67,8 +69,6 @@ from utilities.sentinel import sentinel
 from utilities.types import Dataclass, StrMapping
 from utilities.typing import get_args, is_list_type, is_literal_type, is_optional_type
 
-TruthLit = Literal["true", "false"]  # in 3.12, use type TruthLit = ...
-
 
 class TestDataClassRepr:
     def test_overriding_repr(self) -> None:
@@ -462,21 +462,23 @@ class TestYieldFields:
         assert get_args(result.type_) == (int,)
 
     def test_class_future_literal(self) -> None:
-        result = one(yield_fields(DataClassFutureLiteral))
-        expected = _YieldFieldsClass(name="truth", type_=TruthLit, kw_only=True)
+        result = one(yield_fields(DataClassFutureLiteral, globalns=globals()))
+        expected = _YieldFieldsClass(
+            name="truth", type_=TrueOrFalseFutureLit, kw_only=True
+        )
         assert result == expected
         assert is_literal_type(result.type_)
         assert get_args(result.type_) == ("true", "false")
 
     def test_class_future_literal_nullable(self) -> None:
-        result = one(yield_fields(DataClassFutureLiteralNullable))
+        result = one(yield_fields(DataClassFutureLiteralNullable, globalns=globals()))
         expected = _YieldFieldsClass(
-            name="truth", type_=TruthLit | None, default=None, kw_only=True
+            name="truth", type_=TrueOrFalseFutureLit | None, default=None, kw_only=True
         )
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (Literal["true", "false"],)
+        assert args == (TrueOrFalseFutureLit,)
         arg = one(args)
         assert get_args(arg) == ("true", "false")
 
@@ -491,8 +493,14 @@ class TestYieldFields:
         assert result.type_ is DataClassFutureNestedOuterFirstInner
 
     def test_class_future_type_literal(self) -> None:
-        result = one(yield_fields(DataClassFutureTypeLiteral, globalns=globals()))
-        expected = _YieldFieldsClass(name="truth", type_=TruthLit, kw_only=True)
+        result = one(
+            yield_fields(
+                DataClassFutureTypeLiteral, globalns=globals(), localns=locals()
+            )
+        )
+        expected = _YieldFieldsClass(
+            name="truth", type_=TrueOrFalseFutureTypeLit, kw_only=True
+        )
         assert result == expected
         assert is_literal_type(result.type_)
         assert get_args(result.type_) == ("true", "false")
@@ -502,12 +510,15 @@ class TestYieldFields:
             yield_fields(DataClassFutureTypeLiteralNullable, globalns=globals())
         )
         expected = _YieldFieldsClass(
-            name="truth", type_=TruthLit | None, default=None, kw_only=True
+            name="truth",
+            type_=TrueOrFalseFutureTypeLit | None,
+            default=None,
+            kw_only=True,
         )
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (Literal["true", "false"],)
+        assert args == (TrueOrFalseFutureTypeLit,)
         arg = one(args)
         assert get_args(arg) == ("true", "false")
 

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_operator.py

@@ -43,6 +43,8 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureNestedInnerFirstOuter,
     DataClassFutureNestedOuterFirstOuter,
     DataClassFutureNone,
+    DataClassFutureTypeLiteral,
+    DataClassFutureTypeLiteralNullable,
 )
 from utilities.hypothesis import (
     assume_does_not_raise,
@@ -76,6 +78,8 @@ def base_objects(
     dataclass_literal_nullable: bool = False,
     dataclass_nested: bool = False,
     dataclass_none: bool = False,
+    dataclass_type_literal: bool = False,
+    dataclass_type_literal_nullable: bool = False,
     enum: bool = False,
     exception_class: bool = False,
     exception_instance: bool = False,
@@ -132,6 +136,15 @@ def base_objects(
         )
     if dataclass_none:
         base |= builds(DataClassFutureNone)
+    if dataclass_type_literal:
+        base |= builds(
+            DataClassFutureTypeLiteral, truth=sampled_from(["true", "false"])
+        )
+    if dataclass_type_literal_nullable:
+        base |= builds(
+            DataClassFutureTypeLiteralNullable,
+            truth=sampled_from(["true", "false"]) | none(),
+        )
     if enum:
         base |= sampled_from(TruthEnum)
     if exception_class:
@@ -151,6 +164,8 @@ def make_objects(
     dataclass_literal_nullable: bool = False,
     dataclass_nested: bool = False,
     dataclass_none: bool = False,
+    dataclass_type_literal: bool = False,
+    dataclass_type_literal_nullable: bool = False,
     enum: bool = False,
     exception_class: bool = False,
     exception_instance: bool = False,
@@ -173,6 +188,8 @@ def make_objects(
         dataclass_literal_nullable=dataclass_literal_nullable,
         dataclass_nested=dataclass_nested,
         dataclass_none=dataclass_none,
+        dataclass_type_literal=dataclass_type_literal,
+        dataclass_type_literal_nullable=dataclass_type_literal_nullable,
         enum=enum,
         exception_class=exception_class,
         exception_instance=exception_instance,
@@ -272,6 +289,8 @@ class TestIsEqual:
             dataclass_literal_nullable=True,
             dataclass_nested=True,
             dataclass_none=True,
+            dataclass_type_literal=True,
+            dataclass_type_literal_nullable=True,
             enum=True,
             sub_frozenset=True,
             sub_list=True,
@@ -287,12 +306,15 @@ class TestIsEqual:
         objs=pairs(
             make_objects(
                 dataclass_custom_equality=True,
+                dataclass_default_in_init_child=True,
                 dataclass_int=True,
                 dataclass_int_default=True,
                 dataclass_literal=True,
                 dataclass_literal_nullable=True,
                 dataclass_nested=True,
                 dataclass_none=True,
+                dataclass_type_literal=True,
+                dataclass_type_literal_nullable=True,
                 enum=True,
                 sub_frozenset=True,
                 sub_list=True,

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_orjson.py

@@ -48,6 +48,8 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureNestedOuterFirstInner,
     DataClassFutureNestedOuterFirstOuter,
     DataClassFutureNone,
+    DataClassFutureTypeLiteral,
+    DataClassFutureTypeLiteralNullable,
 )
 from utilities.datetime import MINUTE, SECOND, get_now, get_now_local
 from utilities.functions import is_sequence_of
@@ -435,12 +437,15 @@ class TestSerializeAndDeserialize:
     @given(
         obj=make_objects(
             dataclass_custom_equality=True,
+            dataclass_default_in_init_child=False,
             dataclass_int=True,
             dataclass_int_default=True,
             dataclass_literal=True,
             dataclass_literal_nullable=True,
             dataclass_nested=True,
             dataclass_none=True,
+            dataclass_type_literal=True,
+            dataclass_type_literal_nullable=True,
             enum=True,
             exception_class=True,
             exception_instance=True,
@@ -467,6 +472,8 @@ class TestSerializeAndDeserialize:
                 DataClassFutureNestedOuterFirstInner,
                 DataClassFutureNestedOuterFirstOuter,
                 DataClassFutureNone,
+                DataClassFutureTypeLiteral,
+                DataClassFutureTypeLiteralNullable,
                 SubFrozenSet,
                 SubList,
                 SubSet,
@@ -559,6 +566,19 @@ class TestSerializeAndDeserialize:
         result = deserialize(ser, objects={DataClassFutureNone})
         assert is_equal(result, obj)
 
+    @given(obj=make_objects(dataclass_type_literal=True))
+    def test_dataclass_type_literal(self, *, obj: Any) -> None:
+        result = deserialize(serialize(obj), objects={DataClassFutureTypeLiteral})
+        assert is_equal(result, obj)
+
+    @given(obj=make_objects(dataclass_type_literal_nullable=True))
+    def test_dataclass_type_literal_nullable(self, *, obj: Any) -> None:
+        result = deserialize(
+            serialize(obj), objects={DataClassFutureTypeLiteralNullable}
+        )
+        with assume_does_not_raise(IsEqualError):
+            assert is_equal(result, obj)
+
     @given(obj=builds(DataClassFutureNone))
     def test_dataclass_no_objects_error(self, *, obj: DataClassFutureNone) -> None:
         ser = serialize(obj)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_parse.py

@@ -12,6 +12,10 @@ from hypothesis.strategies import booleans, dates, floats, integers, sampled_fro
 from pytest import raises
 
 from tests.test_operator import TruthEnum
+from tests.test_typing_funcs.with_future import (
+    TrueOrFalseFutureLit,
+    TrueOrFalseFutureTypeLit,
+)
 from utilities.functions import ensure_path
 from utilities.hypothesis import (
     local_datetimes,
@@ -72,7 +76,7 @@ class TestParseText:
 
     @given(truth=sampled_from(["true", "false"]))
     def test_literal(self, *, truth: Literal["true", "false"]) -> None:
-        result = parse_text(Literal["true", "false"], truth)
+        result = parse_text(TrueOrFalseFutureLit, truth)
         assert result == truth
 
     def test_nullable_int_none(self) -> None:
@@ -131,6 +135,11 @@ class TestParseText:
         result = parse_text(dt.timedelta, text)
         assert result == timedelta
 
+    @given(truth=sampled_from(["true", "false"]))
+    def test_type_literal(self, *, truth: Literal["true", "false"]) -> None:
+        result = parse_text(TrueOrFalseFutureTypeLit, truth)
+        assert result == truth
+
     @given(version=versions())
     def test_version(self, *, version: Version) -> None:
         text = str(version)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_polars.py

@@ -102,8 +102,6 @@ from utilities.polars import (
     _InsertBetweenMissingColumnsError,
     _InsertBetweenNonConsecutiveError,
     _yield_struct_series_element_remove_nulls,
-    _YieldRowsAsDataClassesColumnsSuperSetError,
-    _YieldRowsAsDataClassesWrongTypeError,
     append_dataclass,
     are_frames_equal,
     ceil_datetime,
@@ -138,7 +136,6 @@ from utilities.polars import (
     touch,
     unique_element,
     week_num,
-    yield_rows_as_dataclasses,
     yield_struct_series_dataclasses,
     yield_struct_series_elements,
     zoned_datetime,
@@ -161,9 +158,6 @@ if TYPE_CHECKING:
     from utilities.types import MaybeType, StrMapping, WeekDay
 
 
-TruthLit = Literal["true", "false"]  # in 3.12, use type TruthLit = ...
-
-
 class TestAppendDataClass:
     @given(
         data=fixed_dictionaries({
@@ -1809,184 +1803,6 @@ class TestWeekNum:
         assert_series_equal(result, expected)
 
 
-class TestYieldRowsAsDataclasses:
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_main(self, *, check_types: Literal["none", "first", "all"]) -> None:
-        df = DataFrame(data=[(1,), (2,), (3,)], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: int
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-        expected = [Row(x=1), Row(x=2), Row(x=3)]
-        assert result == expected
-
-    def test_none(self) -> None:
-        df = DataFrame(data=[(1,), (2,), (3,)], schema={"x": int}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: str
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types="none"))
-        expected = [Row(x=cast("Any", 1)), Row(x=cast("Any", 2)), Row(x=cast("Any", 3))]
-        assert result == expected
-
-    def test_first(self) -> None:
-        df = DataFrame(data=[(1,), (None,), (None,)], schema={"x": int}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: int
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types="first"))
-        expected = [Row(x=1), Row(x=cast("Any", None)), Row(x=cast("Any", None))]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_missing_columns_for_fields_with_defaults(
-        self, *, check_types: Literal["none", "first", "all"]
-    ) -> None:
-        df = DataFrame(data=[(1,), (2,), (3,)], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: int
-            y: int | None = None
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-        expected = [Row(x=1), Row(x=2), Row(x=3)]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_literal(self, *, check_types: Literal["none", "first", "all"]) -> None:
-        df = DataFrame(
-            data=[("true",), ("false",), ("true",)], schema={"x": String}, orient="row"
-        )
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: Literal["true", "false"]
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-        expected = [Row(x="true"), Row(x="false"), Row(x="true")]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_literal_nullable(
-        self, *, check_types: Literal["none", "first", "all"]
-    ) -> None:
-        df = DataFrame(
-            data=[("true",), ("false",), (None,)], schema={"x": String}, orient="row"
-        )
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: Literal["true", "false"] | None = None
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-        expected = [Row(x="true"), Row(x="false"), Row()]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_literal_type(
-        self, *, check_types: Literal["none", "first", "all"]
-    ) -> None:
-        df = DataFrame(
-            data=[("true",), ("false",), ("true",)], schema={"x": String}, orient="row"
-        )
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: TruthLit
-
-        result = list(
-            yield_rows_as_dataclasses(
-                df, Row, check_types=check_types, globalns=globals()
-            )
-        )
-        expected = [Row(x="true"), Row(x="false"), Row(x="true")]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_literal_type_nullable(
-        self, *, check_types: Literal["none", "first", "all"]
-    ) -> None:
-        df = DataFrame(
-            data=[("true",), ("false",), (None,)], schema={"x": String}, orient="row"
-        )
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: TruthLit | None = None
-
-        result = list(
-            yield_rows_as_dataclasses(
-                df, Row, globalns=globals(), check_types=check_types
-            )
-        )
-        expected = [Row(x="true"), Row(x="false"), Row()]
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_empty(self, *, check_types: Literal["none", "first", "all"]) -> None:
-        df = DataFrame(data=[], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: int
-
-        result = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-        expected = []
-        assert result == expected
-
-    @given(check_types=sampled_from(["none", "first", "all"]))
-    def test_error_superset(
-        self, *, check_types: Literal["none", "first", "all"]
-    ) -> None:
-        df = DataFrame(data=[(1,), (2,), (3,)], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            y: int
-
-        with raises(
-            _YieldRowsAsDataClassesColumnsSuperSetError,
-            match="DataFrame columns .* must be a superset of dataclass fields .*; dataclass had extra fields .*",
-        ):
-            _ = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-
-    @given(check_types=sampled_from(["first", "all"]))
-    def test_error_first_or_all_wrong_type(
-        self, *, check_types: Literal["first", "all"]
-    ) -> None:
-        df = DataFrame(data=[(1,), (2,), (3,)], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: str
-
-        with raises(
-            _YieldRowsAsDataClassesWrongTypeError,
-            match='wrong value type for field "x" - should be "str" instead of value "1" of type "int"',
-        ):
-            _ = list(yield_rows_as_dataclasses(df, Row, check_types=check_types))
-
-    def test_error_all_wrong_type(self) -> None:
-        df = DataFrame(data=[(1,), (None,), (3,)], schema={"x": Int64}, orient="row")
-
-        @dataclass(kw_only=True, slots=True)
-        class Row:
-            x: int
-
-        with raises(
-            _YieldRowsAsDataClassesWrongTypeError,
-            match='wrong value type for field "x" - should be "int" instead of value "None" of type "NoneType"',
-        ):
-            _ = list(yield_rows_as_dataclasses(df, Row, check_types="all"))
-
-
 class TestYieldStructSeriesDataclasses:
     def test_main(self) -> None:
         @dataclass(kw_only=True, slots=True)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_python_dotenv.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 from re import DOTALL
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from hypothesis import given
 from hypothesis.strategies import DataObject, booleans, data, integers, sampled_from
@@ -87,6 +87,22 @@ class TestLoadSettings:
         expected = Settings(key=value)
         assert settings == expected
 
+    @given(root=git_repos(), value=sampled_from(["true", "false"]))
+    @settings_with_reduced_examples()
+    def test_literal_value(
+        self, *, root: Path, value: Literal["true", "false"]
+    ) -> None:
+        @dataclass(kw_only=True, slots=True)
+        class Settings:
+            key: Literal["true", "false"]
+
+        with root.joinpath(".env").open(mode="w") as fh:
+            _ = fh.write(f"key = {value}\n")
+
+        settings = load_settings(Settings, cwd=root)
+        expected = Settings(key=value)
+        assert settings == expected
+
     @given(root=git_repos())
     @settings_with_reduced_examples()
     def test_error_file_not_found(self, *, root: Path) -> None:

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_typing.py

@@ -33,7 +33,10 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureSentinel,
     DataClassFutureStr,
     DataClassFutureTimeDelta,
+    DataClassFutureTypeLiteral,
     DataClassFutureUUID,
+    TrueOrFalseFutureLit,
+    TrueOrFalseFutureTypeLit,
 )
 from utilities.sentinel import Sentinel
 from utilities.types import LogLevel, Parallelism
@@ -163,6 +166,18 @@ class TestGetTypeHints:
         expected = {"ints": list[int]}
         assert hints == expected
 
+    @given(data=data())
+    def test_literal(self, *, data: DataObject) -> None:
+        @dataclass(kw_only=True, slots=True)
+        class Example:
+            truth: TrueOrFalseFutureLit
+
+        cls = data.draw(sampled_from([Example, DataClassFutureLiteral]))
+        localns = data.draw(just(locals()) | none())
+        hints = get_type_hints(cls, globalns=globals(), localns=localns)
+        expected = {"truth": TrueOrFalseFutureLit}
+        assert hints == expected
+
     def test_nested_local(self) -> None:
         @dataclass(kw_only=True, slots=True)
         class Outer:
@@ -200,19 +215,6 @@ class TestGetTypeHints:
         expected = {"inner": DataClassFutureNestedOuterFirstInner}
         assert hints == expected
 
-    @given(data=data())
-    def test_literal(self, *, data: DataObject) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Example:
-            truth: Literal["true", "false"]
-
-        cls = data.draw(sampled_from([Example, DataClassFutureLiteral]))
-        globalns = data.draw(just(globals()) | none())
-        localns = data.draw(just(locals()) | none())
-        hints = get_type_hints(cls, globalns=globalns, localns=localns)
-        expected = {"truth": Literal["true", "false"]}
-        assert hints == expected
-
     @given(data=data())
     def test_none(self, *, data: DataObject) -> None:
         @dataclass(kw_only=True, slots=True)
@@ -278,6 +280,18 @@ class TestGetTypeHints:
         expected = {"timedelta": dt.timedelta}
         assert hints == expected
 
+    @given(data=data())
+    def test_type_literal(self, *, data: DataObject) -> None:
+        @dataclass(kw_only=True, slots=True)
+        class Example:
+            truth: TrueOrFalseFutureTypeLit
+
+        cls = data.draw(sampled_from([Example, DataClassFutureTypeLiteral]))
+        localns = data.draw(just(locals()) | none())
+        hints = get_type_hints(cls, globalns=globals(), localns=localns)
+        expected = {"truth": TrueOrFalseFutureTypeLit}
+        assert hints == expected
+
     @given(data=data())
     def test_uuid(self, *, data: DataObject) -> None:
         @dataclass(kw_only=True, slots=True)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_typing_funcs/no_future.py

@@ -1,4 +1,8 @@
 from dataclasses import dataclass
+from typing import Literal
+
+TrueOrFalseNoFutureLit = Literal["true", "false"]
+type TrueOrFalseNoFutureTypeLit = Literal["true", "false"]
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/tests/test_typing_funcs/with_future.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, override
+from typing import TYPE_CHECKING, Literal, override
 
 if TYPE_CHECKING:
     import datetime as dt
     from pathlib import Path
-    from typing import Literal
     from uuid import UUID
 
     from utilities.sentinel import Sentinel
 
 
-type TruthLit = Literal["true", "false"]
+TrueOrFalseFutureLit = Literal["true", "false"]
+type TrueOrFalseFutureTypeLit = Literal["true", "false"]
 
 
 @dataclass(order=True, kw_only=True)
@@ -71,12 +71,12 @@ class DataClassFutureListIntsDefault:
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureLiteral:
-    truth: Literal["true", "false"]
+    truth: TrueOrFalseFutureLit
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureLiteralNullable:
-    truth: Literal["true", "false"] | None = None
+    truth: TrueOrFalseFutureLit | None = None
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
@@ -131,12 +131,12 @@ class DataClassFutureTimeDelta:
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureTypeLiteral:
-    truth: TruthLit
+    truth: TrueOrFalseFutureTypeLit
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)
 class DataClassFutureTypeLiteralNullable:
-    truth: TruthLit | None = None
+    truth: TrueOrFalseFutureTypeLit | None = None
 
 
 @dataclass(order=True, unsafe_hash=True, kw_only=True)

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.108.4"
+__version__ = "0.109.0"

{dycw_utilities-0.108.4 → dycw_utilities-0.109.0}/src/utilities/parse.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 from types import NoneType
-from typing import Any, get_args, override
+from typing import Any, override
 
 from utilities.datetime import is_subclass_date_not_datetime
 from utilities.enum import ParseEnumError, parse_enum
@@ -14,7 +14,7 @@ from utilities.functions import is_subclass_int_not_bool
 from utilities.iterables import one, one_str
 from utilities.sentinel import ParseSentinelError, Sentinel, parse_sentinel
 from utilities.text import ParseBoolError, ParseNoneError, parse_bool, parse_none
-from utilities.typing import is_literal_type, is_optional_type
+from utilities.typing import get_args, is_literal_type, is_optional_type
 from utilities.version import ParseVersionError, Version, parse_version