dycw-utilities 0.168.3__tar.gz → 0.168.4__tar.gz

{dycw_utilities-0.168.3 → dycw_utilities-0.168.4}/PKG-INFO

@@ -1,22 +1,22 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.168.3
+Version: 0.168.4
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: atomicwrites<1.5,>=1.4.1
 Requires-Dist: typing-extensions<4.16,>=4.15.0
 Requires-Dist: tzlocal<5.4,>=5.3.1
-Requires-Dist: whenever<0.10,>=0.9.0
+Requires-Dist: whenever<0.10,>=0.9.2
 Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.141,>=6.140.2; extra == 'test'
+Requires-Dist: hypothesis<6.141,>=6.140.3; extra == 'test'
 Requires-Dist: pytest-asyncio<1.3,>=1.2.0; extra == 'test'
 Requires-Dist: pytest-cov<7.1,>=7.0.0; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
-Requires-Dist: pytest-lazy-fixtures<1.4,>=1.3.4; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures<1.5,>=1.4.0; extra == 'test'
 Requires-Dist: pytest-randomly<4.1,>=4.0.1; extra == 'test'
 Requires-Dist: pytest-regressions<2.9,>=2.8.3; extra == 'test'
 Requires-Dist: pytest-repeat<0.10,>=0.9.4; extra == 'test'

{dycw_utilities-0.168.3 → dycw_utilities-0.168.4}/pyproject.toml

@@ -31,10 +31,10 @@ core = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.9.0, <0.10",
+  "whenever >=0.9.2, <0.10",
 ]
 cryptography = [
-  "cryptography >=46.0.1, <46.1",
+  "cryptography >=46.0.2, <46.1",
 ]
 cvxpy = [
   "cvxpy >=1.7.3, <1.8",
@@ -52,7 +52,7 @@ dev = [
   "pytest-timeout >=2.4.0, <2.5",
 ]
 fastapi = [
-  "fastapi >=0.117.1, <0.118",
+  "fastapi >=0.118.0, <0.119",
 ]
 fastapi-test = [
   "httpx",
@@ -71,7 +71,7 @@ http-test = [
   "orjson",
 ]
 hypothesis = [
-  "hypothesis >=6.140.2, <6.141",
+  "hypothesis >=6.140.3, <6.141",
 ]
 hypothesis-test = [
   "libcst",
@@ -124,7 +124,7 @@ orjson-test = [
   "polars",
 ]
 polars = [
-  "polars >=1.33.1, <1.34",
+  "polars >=1.34.0, <1.35",
 ]
 polars-ols = [
   "polars-ols >=0.3.5, <0.4",
@@ -198,7 +198,7 @@ sklearn = [
   "scikit-learn >=1.7.2, <1.8",
 ]
 slack-sdk = [
-  "slack-sdk >=3.36.0, <3.37",
+  "slack-sdk >=3.37.0, <3.38",
 ]
 slack-sdk-test = [
   "aiohttp",
@@ -227,9 +227,6 @@ statsmodels = [
 testbook = [
   "testbook >=0.4.2, <0.5",
 ]
-typed-settings = [
-  "typed-settings >=25.0.0, <25.1",
-]
 tzdata = [
   "tzdata >=2025.2, <2025.3",
 ]
@@ -244,12 +241,12 @@ dependencies = [
   "atomicwrites >=1.4.1, <1.5",
   "typing-extensions >=4.15.0, <4.16",
   "tzlocal >=5.3.1, <5.4",
-  "whenever >=0.9.0, <0.10",
+  "whenever >=0.9.2, <0.10",
 ]
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.168.3"
+version = "0.168.4"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -261,12 +258,12 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >=2.1.1, <2.2",
-  "hypothesis >=6.140.2, <6.141",
+  "hypothesis >=6.140.3, <6.141",
   "pytest >=8.4.2, <8.5",
   "pytest-asyncio >=1.2.0, <1.3",
   "pytest-cov >=7.0.0, <7.1",
   "pytest-instafail >=0.5.0, <0.6",
-  "pytest-lazy-fixtures >=1.3.4, <1.4",
+  "pytest-lazy-fixtures >=1.4.0, <1.5",
   "pytest-randomly >=4.0.1, <4.1",
   "pytest-regressions >=2.8.3, <2.9",
   "pytest-repeat >=0.9.4, <0.10",
@@ -282,7 +279,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.168.3"
+current_version = "0.168.4"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -486,7 +483,6 @@ select = [
   "S101",  # assert
   "SLF001",  # private-member-access
 ]
-"src/tests/test_typed_settings.py" = ["I002"]  # missing-required-import
 "src/tests/test_typing_funcs/no_future.py" = ["I002"]  # missing-required-import
 
 [tool.ruff.lint.flake8-tidy-imports]

{dycw_utilities-0.168.3 → dycw_utilities-0.168.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.168.3"
+__version__ = "0.168.4"

dycw_utilities-0.168.3/src/tests/test_typed_settings.py

@@ -1,321 +0,0 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-from ipaddress import IPv4Address, IPv6Address
-from pathlib import Path
-from typing import Any, ClassVar, Self, assert_never, override
-from uuid import UUID
-
-import typed_settings
-from hypothesis import given
-from hypothesis.strategies import (
-    DataObject,
-    SearchStrategy,
-    booleans,
-    data,
-    integers,
-    ip_addresses,
-    sampled_from,
-    tuples,
-    uuids,
-)
-from pytest import mark, param, raises
-from typed_settings import EnvLoader, FileLoader, TomlFormat
-from whenever import (
-    Date,
-    DateDelta,
-    DateTimeDelta,
-    MonthDay,
-    PlainDateTime,
-    Time,
-    TimeDelta,
-    YearMonth,
-    ZonedDateTime,
-)
-
-from utilities.hypothesis import (
-    date_deltas,
-    date_time_deltas,
-    dates,
-    month_days,
-    paths,
-    plain_date_times,
-    temp_paths,
-    text_ascii,
-    time_deltas,
-    times,
-    year_months,
-    zoned_date_times,
-)
-from utilities.os import temp_environ
-from utilities.re import extract_group
-from utilities.sentinel import Sentinel, sentinel
-from utilities.text import strip_and_dedent
-from utilities.typed_settings import (
-    ExtendedTSConverter,
-    LoadSettingsError,
-    load_settings,
-)
-
-app_names = text_ascii(min_size=1).map(str.lower)
-
-
-@dataclass(kw_only=True, slots=True)
-class _Case[T]:
-    cls: type[T]
-    strategy: SearchStrategy[T]
-    serialize: Callable[[T], str]
-
-
-class TestExtendedTSConverter:
-    cases: ClassVar[list[_Case]] = [
-        _Case(cls=Date, strategy=dates(), serialize=str),
-        _Case(cls=DateDelta, strategy=date_deltas(parsable=True), serialize=str),
-        _Case(
-            cls=DateTimeDelta, strategy=date_time_deltas(parsable=True), serialize=str
-        ),
-        _Case(cls=IPv4Address, strategy=ip_addresses(v=4), serialize=str),
-        _Case(cls=IPv6Address, strategy=ip_addresses(v=6), serialize=str),
-        _Case(cls=MonthDay, strategy=month_days(), serialize=str),
-        _Case(cls=PlainDateTime, strategy=plain_date_times(), serialize=str),
-        _Case(cls=Time, strategy=times(), serialize=str),
-        _Case(cls=TimeDelta, strategy=time_deltas(), serialize=str),
-        _Case(cls=UUID, strategy=uuids(), serialize=str),
-        _Case(cls=YearMonth, strategy=year_months(), serialize=str),
-        _Case(cls=ZonedDateTime, strategy=zoned_date_times(), serialize=str),
-    ]
-
-    @given(data=data())
-    @mark.parametrize(("cls", "strategy"), [param(c.cls, c.strategy) for c in cases])
-    def test_default(
-        self, *, data: DataObject, cls: type[Any], strategy: SearchStrategy[Any]
-    ) -> None:
-        default = data.draw(strategy)
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
-
-        loaded = typed_settings.load_settings(
-            Settings, loaders=[], converter=ExtendedTSConverter()
-        )
-        assert loaded.value == default
-
-    @given(data=data(), root=temp_paths(), app_name=app_names)
-    @mark.parametrize(
-        ("cls", "strategy", "serialize"),
-        [param(c.cls, c.strategy, c.serialize) for c in cases],
-    )
-    def test_loaded(
-        self,
-        *,
-        data: DataObject,
-        root: Path,
-        app_name: str,
-        cls: type[Any],
-        strategy: SearchStrategy[Any],
-        serialize: Callable[[Any], str],
-    ) -> None:
-        default, value = data.draw(tuples(strategy, strategy))
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: cls = default  # pyright: ignore[reportInvalidTypeForm]
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '{serialize(value)}'
-            """)
-        )
-        loaded = typed_settings.load_settings(
-            Settings,
-            loaders=[
-                FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-            ],
-            converter=ExtendedTSConverter(),
-        )
-        assert loaded.value == value
-
-    @given(
-        root=temp_paths(),
-        app_name=app_names,
-        env_name=text_ascii(min_size=1).map(lambda text: f"TEST_{text}".upper()),
-        env_value=text_ascii(min_size=1),
-    )
-    def test_path_env_var(
-        self, *, root: str, app_name: str, env_name: str, env_value: str
-    ) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: Path
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '${env_name}'
-            """)
-        )
-        with temp_environ({env_name: env_value}):
-            settings = typed_settings.load_settings(
-                Settings,
-                loaders=[
-                    FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-                ],
-                converter=ExtendedTSConverter(resolve_paths=False),
-            )
-        expected = Path(env_value)
-        assert settings.value == expected
-
-    @given(root=temp_paths(), app_name=app_names, path=paths(), resolve=booleans())
-    def test_path_resolution(
-        self, *, root: str, app_name: str, path: Path, resolve: bool
-    ) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            value: Path
-
-        file = Path(root, "file.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                value = '{path!s}'
-            """)
-        )
-        settings = typed_settings.load_settings(
-            Settings,
-            loaders=[
-                FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=[file])
-            ],
-            converter=ExtendedTSConverter(resolve_paths=resolve),
-        )
-        match resolve:
-            case True:
-                expected = Path.cwd().joinpath(path)
-            case False:
-                expected = Path(path)
-            case never:
-                assert_never(never)
-        assert settings.value == expected
-
-
-class TestLoadSettings:
-    @given(root=temp_paths(), date_time=zoned_date_times(), app_name=app_names)
-    def test_main(self, *, root: Path, date_time: ZonedDateTime, app_name: str) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            date_time: ZonedDateTime
-
-        file = root.joinpath("settings.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                date_time = {str(date_time)!r}
-            """)
-        )
-        settings = load_settings(Settings, app_name, start_dir=root)
-        assert settings.date_time == date_time
-
-    @given(
-        prefix=app_names.map(lambda text: f"TEST_{text}".upper()),
-        date_time=zoned_date_times(),
-        app_name=app_names,
-    )
-    def test_loaders(
-        self, *, prefix: str, date_time: ZonedDateTime, app_name: str
-    ) -> None:
-        key = f"{prefix}__DATE_TIME"
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            date_time: ZonedDateTime
-
-        with temp_environ({key: str(date_time)}):
-            settings = load_settings(
-                Settings, app_name, loaders=[EnvLoader(prefix=f"{prefix}__")]
-            )
-        assert settings.date_time == date_time
-
-    @given(root=temp_paths(), app_name=app_names)
-    def test_converter_simple(self, *, root: Path, app_name: str) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            sentinel: Sentinel
-
-        file = root.joinpath("settings.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                sentinel = 'sentinel'
-            """)
-        )
-
-        def convert(text: str, /) -> Sentinel:
-            if text == "sentinel":
-                return sentinel
-            raise ValueError
-
-        settings = load_settings(
-            Settings, app_name, start_dir=root, converters=[(Sentinel, convert)]
-        )
-        assert settings.sentinel is sentinel
-
-    @given(data=data(), root=temp_paths(), n=integers(), app_name=app_names)
-    def test_converter_dataclass(
-        self, *, data: DataObject, root: Path, n: int, app_name: str
-    ) -> None:
-        @dataclass(repr=False, frozen=True, kw_only=True, slots=True)
-        class Left:
-            x: int
-
-            @override
-            def __str__(self) -> str:
-                return f"left{self.x}"
-
-            @classmethod
-            def parse(cls, text: str, /) -> Self:
-                x = extract_group(r"^left(.+?)$", text)
-                return cls(x=int(x))
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Right:
-            y: int
-
-            @override
-            def __str__(self) -> str:
-                return f"right{self.y}"
-
-            @classmethod
-            def parse(cls, text: str, /) -> Self:
-                y = extract_group(r"^right(.+?)$", text)
-                return cls(y=int(y))
-
-        value = data.draw(sampled_from([Left(x=n), Right(y=n)]))
-
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings:
-            inner: Left | Right
-
-        file = root.joinpath("settings.toml")
-        _ = file.write_text(
-            strip_and_dedent(f"""
-                [{app_name}]
-                inner = {str(value)!r}
-            """)
-        )
-        settings = load_settings(
-            Settings,
-            app_name,
-            start_dir=root,
-            converters=[(Left, Left.parse), (Right, Right.parse)],
-        )
-        assert settings.inner == value
-
-    @mark.parametrize("app_name", [param("app_"), param("app1"), param("app__name")])
-    def test_error(self, *, app_name: str) -> None:
-        @dataclass(frozen=True, kw_only=True, slots=True)
-        class Settings: ...
-
-        with raises(LoadSettingsError, match=r"Invalid app name; got '.+'"):
-            _ = load_settings(Settings, app_name)

dycw_utilities-0.168.3/src/utilities/typed_settings.py

@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from functools import partial
-from ipaddress import IPv4Address, IPv6Address
-from os import environ
-from pathlib import Path
-from re import search
-from typing import TYPE_CHECKING, Any, assert_never, override
-from uuid import UUID
-
-import typed_settings
-from typed_settings import EnvLoader, FileLoader, find
-from typed_settings.converters import TSConverter
-from typed_settings.loaders import TomlFormat
-from whenever import (
-    Date,
-    DateDelta,
-    DateTimeDelta,
-    MonthDay,
-    PlainDateTime,
-    Time,
-    TimeDelta,
-    YearMonth,
-    ZonedDateTime,
-)
-
-from utilities.iterables import always_iterable
-from utilities.pathlib import to_path
-from utilities.string import substitute_environ
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable
-
-    from typed_settings.loaders import Loader
-    from typed_settings.processors import Processor
-
-    from utilities.types import MaybeCallablePathLike, MaybeIterable, PathLike
-
-
-type _ConverterItem = tuple[type[Any], Callable[..., Any]]
-
-
-##
-
-
-class ExtendedTSConverter(TSConverter):
-    """An extension of the TSConverter for custom types."""
-
-    @override
-    def __init__(
-        self,
-        *,
-        resolve_paths: bool = True,
-        strlist_sep: str | Callable[[str], list] | None = ":",
-        extra: Iterable[_ConverterItem] = (),
-    ) -> None:
-        super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
-        cases: list[_ConverterItem] = [
-            (Date, Date.parse_iso),
-            (DateDelta, DateDelta.parse_iso),
-            (DateTimeDelta, DateTimeDelta.parse_iso),
-            (IPv4Address, IPv4Address),
-            (IPv6Address, IPv6Address),
-            (MonthDay, MonthDay.parse_iso),
-            (Path, partial(_parse_path, resolve=resolve_paths, pwd=Path.cwd())),
-            (PlainDateTime, PlainDateTime.parse_iso),
-            (Time, Time.parse_iso),
-            (TimeDelta, TimeDelta.parse_iso),
-            (UUID, UUID),
-            (YearMonth, YearMonth.parse_iso),
-            (ZonedDateTime, ZonedDateTime.parse_iso),
-            *extra,
-        ]
-        extras = {cls: _make_converter(cls, func) for cls, func in cases}
-        self.scalar_converters |= extras
-
-
-def _make_converter[T](
-    cls: type[T], parser: Callable[[str], T], /
-) -> Callable[[Any, type[Any]], Any]:
-    def hook(value: T | str, _: type[T] = cls, /) -> Any:
-        if not isinstance(value, (cls, str)):  # pragma: no cover
-            msg = f"Invalid type {type(value).__name__!r}; expected '{cls.__name__}' or 'str'"
-            raise TypeError(msg)
-        if isinstance(value, str):
-            return parser(value)
-        return value
-
-    return hook
-
-
-def _parse_path(
-    path: str, /, *, resolve: bool = False, pwd: MaybeCallablePathLike = Path.cwd
-) -> Path:
-    path = substitute_environ(path, **environ)
-    match resolve:
-        case True:
-            return to_path(pwd).joinpath(path).resolve()
-        case False:
-            return Path(path)
-        case never:
-            assert_never(never)
-
-
-##
-
-
-_BASE_DIR: Path = Path()
-
-
-def load_settings[T](
-    cls: type[T],
-    app_name: str,
-    /,
-    *,
-    filenames: MaybeIterable[str] = "settings.toml",
-    start_dir: PathLike | None = None,
-    loaders: MaybeIterable[Loader] | None = None,
-    processors: MaybeIterable[Processor] = (),
-    converters: Iterable[_ConverterItem] = (),
-    base_dir: Path = _BASE_DIR,
-) -> T:
-    if not search(r"^[A-Za-z]+(?:_[A-Za-z]+)*$", app_name):
-        raise LoadSettingsError(appname=app_name)
-    filenames_use = list(always_iterable(filenames))
-    start_dir_use = None if start_dir is None else Path(start_dir)
-    files = [find(filename, start_dir=start_dir_use) for filename in filenames_use]
-    file_loader = FileLoader(formats={"*.toml": TomlFormat(app_name)}, files=files)
-    env_loader = EnvLoader(f"{app_name.upper()}__", nested_delimiter="__")
-    loaders_use: list[Loader] = [file_loader, env_loader]
-    if loaders is not None:
-        loaders_use.extend(always_iterable(loaders))
-    return typed_settings.load_settings(
-        cls,
-        loaders_use,
-        processors=list(always_iterable(processors)),
-        converter=ExtendedTSConverter(extra=converters),
-        base_dir=base_dir,
-    )
-
-
-@dataclass(kw_only=True, slots=True)
-class LoadSettingsError(Exception):
-    appname: str
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid app name; got {self.appname!r}"
-
-
-__all__ = ["ExtendedTSConverter", "LoadSettingsError", "load_settings"]