dycw-utilities 0.146.8__tar.gz → 0.147.0__tar.gz

{dycw_utilities-0.146.8 → dycw_utilities-0.147.0}/PKG-INFO

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

{dycw_utilities-0.146.8 → dycw_utilities-0.147.0}/pyproject.toml

@@ -7,7 +7,6 @@ requires = ["hatchling"]
 
 # dependency groups
 [dependency-groups]
-aiolimiter = ["aiolimiter >= 1.2.1, < 1.3"]
 altair = ["altair >= 5.5.0, < 5.6"]
 altair-test = [
   "polars",
@@ -64,7 +63,6 @@ pottery = ["pottery >= 3.0.1, < 3.1"]
 pottery-test = ["orjson", "pytest-rerunfailures"]
 pqdm = ["pqdm >= 0.2.0, < 0.3"]
 psutil = ["psutil >= 7.0.0, < 7.1"]
-pydantic = ["pydantic >= 2.11.4, < 2.12"]
 pyinstrument = ["pyinstrument >= 5.0.3, < 5.1"]
 pytest = [
   "pudb >= 2025.1, < 2025.2",
@@ -77,7 +75,6 @@ pytest = [
 pytest-regressions = ["pytest-regressions >= 2.8.1, < 2.9"]
 pytest-regressions-test = ["orjson", "polars"]
 pytest-test = ["orjson", "pytest-rng", "pytest-rerunfailures"]
-python-dotenv = ["python-dotenv >= 1.1.1, < 1.2"]
 redis = ["redis >= 6.2.0, < 6.3", "orjson"]
 redis-test = ["pytest-rerunfailures"]
 reprlib-test = ["rich"]
@@ -90,7 +87,6 @@ sqlalchemy-polars = ["sqlalchemy", "polars"]
 sqlalchemy-polars-test = ["aiosqlite", "asyncpg", "greenlet"]
 sqlalchemy-test = ["aiosqlite", "asyncpg", "greenlet"]
 statsmodels = ["statsmodels >= 0.14.4, < 0.15"]
-streamlit = ["streamlit >= 1.46.0, < 1.47"]
 typed-settings = ["typed-settings >= 24.6.0, < 24.7"]
 tzdata = ["tzdata >= 2025.2, < 2025.3"]
 
@@ -106,7 +102,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.146.8"
+version = "0.147.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -139,7 +135,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.146.8"
+current_version = "0.147.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.146.8 → dycw_utilities-0.147.0}/src/tests/test_whenever.py

@@ -65,8 +65,6 @@ from utilities.whenever import (
     ToNanosecondsError,
     ToPyTimeDeltaError,
     WheneverLogRecord,
-    _MinMaxDateMaxDateError,
-    _MinMaxDateMinDateError,
     _MinMaxDatePeriodError,
     _RoundDateOrDateTimeDateTimeIntraDayWithWeekdayError,
     _RoundDateOrDateTimeDateWithIntradayDeltaError,
@@ -464,20 +462,6 @@ class TestMinMaxDate:
         if (min_date_use is not None) and (max_date_use is not None):
             assert min_date_use <= max_date_use
 
-    @given(date=dates(min_value=TODAY_UTC + DAY))
-    def test_error_min_date(self, *, date: Date) -> None:
-        with raises(
-            _MinMaxDateMinDateError, match="Min date must be at most today; got .* > .*"
-        ):
-            _ = min_max_date(min_date=date)
-
-    @given(date=dates(min_value=TODAY_UTC + DAY))
-    def test_error_max_date(self, *, date: Date) -> None:
-        with raises(
-            _MinMaxDateMaxDateError, match="Max date must be at most today; got .* > .*"
-        ):
-            _ = min_max_date(max_date=date)
-
     @given(dates=pairs(dates(max_value=TODAY_UTC), unique=True, sorted=True))
     def test_error_period(self, *, dates: tuple[Date, Date]) -> None:
         with raises(

{dycw_utilities-0.146.8 → dycw_utilities-0.147.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.146.8"
+__version__ = "0.147.0"

{dycw_utilities-0.146.8 → dycw_utilities-0.147.0}/src/utilities/whenever.py

@@ -316,20 +316,16 @@ def min_max_date(
     max_age: DateDelta | None = None,
     time_zone: TimeZoneLike = UTC,
 ) -> tuple[Date | None, Date | None]:
-    """Ucompute the min/max date given a combination of dates/ages."""
+    """Compute the min/max date given a combination of dates/ages."""
     today = get_today(time_zone=time_zone)
     min_parts: list[Date] = []
     if min_date is not None:
-        if min_date > today:
-            raise _MinMaxDateMinDateError(min_date=min_date, today=today)
         min_parts.append(min_date)
     if max_age is not None:
         min_parts.append(today - max_age)
     min_date_use = max(min_parts, default=None)
     max_parts: list[Date] = []
     if max_date is not None:
-        if max_date > today:
-            raise _MinMaxDateMaxDateError(max_date=max_date, today=today)
         max_parts.append(max_date)
     if min_age is not None:
         max_parts.append(today - min_age)
@@ -344,34 +340,13 @@ def min_max_date(
 
 
 @dataclass(kw_only=True, slots=True)
-class MinMaxDateError(Exception): ...
-
-
-@dataclass(kw_only=True, slots=True)
-class _MinMaxDateMinDateError(MinMaxDateError):
+class MinMaxDateError(Exception):
     min_date: Date
-    today: Date
-
-    @override
-    def __str__(self) -> str:
-        return f"Min date must be at most today; got {self.min_date} > {self.today}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _MinMaxDateMaxDateError(MinMaxDateError):
     max_date: Date
-    today: Date
-
-    @override
-    def __str__(self) -> str:
-        return f"Max date must be at most today; got {self.max_date} > {self.today}"
 
 
 @dataclass(kw_only=True, slots=True)
 class _MinMaxDatePeriodError(MinMaxDateError):
-    min_date: Date
-    max_date: Date
-
     @override
     def __str__(self) -> str:
         return (

dycw_utilities-0.146.8/src/tests/test_aiolimiter.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from asyncio import sleep
-from typing import ClassVar
-
-from utilities.aiolimiter import get_async_limiter
-from utilities.text import unique_str
-from utilities.timer import Timer
-from utilities.whenever import SECOND
-
-
-class TestGetAsyncLimiter:
-    async def test_main(self) -> None:
-        counter = 0
-
-        async def increment() -> None:
-            nonlocal counter
-            counter += 1
-            await sleep(0.01)
-
-        name = unique_str()
-        with Timer() as timer:
-            for _ in range(2):
-                async with get_async_limiter(name, rate=0.5):
-                    await increment()
-        assert timer >= 0.48 * SECOND
-
-    shared: ClassVar[str] = unique_str()
-
-    async def test_shared1(self) -> None:
-        async with get_async_limiter(self.shared):
-            await sleep(0.01)
-
-    async def test_shared2(self) -> None:
-        async with get_async_limiter(self.shared):
-            await sleep(0.01)
-
-    async def test_shared3(self) -> None:
-        async with get_async_limiter(self.shared):
-            await sleep(0.01)

dycw_utilities-0.146.8/src/tests/test_pydantic.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from hypothesis import given
-from hypothesis.strategies import integers
-from pydantic import BaseModel
-from pytest import raises
-
-from utilities.hypothesis import temp_paths
-from utilities.pydantic import HashableBaseModel, LoadModelError, load_model, save_model
-from utilities.pytest import skipif_windows
-
-
-class TestHashableBaseModel:
-    @given(x=integers())
-    def test_main(self, *, x: int) -> None:
-        class Example(HashableBaseModel):
-            x: int
-
-        example = Example(x=x)
-        assert isinstance(hash(example), int)
-
-
-class TestSaveAndLoadModel:
-    @given(x=integers(), root=temp_paths())
-    def test_main(self, *, x: int, root: Path) -> None:
-        path = Path(root, "model.json")
-
-        class Example(BaseModel):
-            x: int
-
-        example = Example(x=x)
-        save_model(example, path)
-        loaded = load_model(Example, path)
-        assert loaded == example
-
-    @skipif_windows
-    def test_load_model_error_dir(self, *, tmp_path: Path) -> None:
-        path = tmp_path.joinpath("dir")
-        path.mkdir()
-
-        class Example(BaseModel):
-            x: int
-
-        with raises(
-            LoadModelError,
-            match=r"Unable to load .*; path '.*' must not be a directory\.",
-        ):
-            _ = load_model(Example, path)
-
-    def test_load_model_error_file(self, *, tmp_path: Path) -> None:
-        class Example(BaseModel):
-            x: int
-
-        with raises(LoadModelError, match=r"Unable to load .*; path '.*' must exist\."):
-            _ = load_model(Example, tmp_path.joinpath("model.json"))

dycw_utilities-0.146.8/src/tests/test_python_dotenv.py

@@ -1,125 +0,0 @@
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from re import DOTALL
-from typing import TYPE_CHECKING
-
-from hypothesis import given
-from hypothesis.strategies import DataObject, booleans, data, integers, sampled_from
-from pytest import raises
-
-from utilities.errors import ImpossibleCaseError
-from utilities.hypothesis import git_repos, settings_with_reduced_examples, text_ascii
-from utilities.os import temp_environ
-from utilities.python_dotenv import (
-    _LoadSettingsDuplicateKeysError,
-    _LoadSettingsFileNotFoundError,
-    _LoadSettingsMissingKeysError,
-    load_settings,
-)
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-class TestLoadSettings:
-    @given(
-        data=data(),
-        root=git_repos(),
-        key_file=sampled_from(["key", "KEY"]),
-        value_file=text_ascii(),
-        use_env=booleans(),
-    )
-    @settings_with_reduced_examples()
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        root: Path,
-        key_file: str,
-        value_file: str,
-        use_env: bool,
-    ) -> None:
-        _ = root.joinpath(".env").write_text(f"{key_file} = {value_file}\n")
-
-        @dataclass(kw_only=True, slots=True)
-        class SettingsLower:
-            key: str
-
-        @dataclass(kw_only=True, slots=True)
-        class SettingsUpper:
-            KEY: str
-
-        SettingsUse = data.draw(sampled_from([SettingsLower, SettingsUpper]))  # noqa: N806
-        if use_env:
-            key_env = data.draw(sampled_from(["key", "KEY"]))
-            value_env = data.draw(text_ascii())
-            with temp_environ({key_env: value_env}):
-                settings = load_settings(SettingsUse, path=root)
-            exp_value = value_env
-        else:
-            settings = load_settings(SettingsUse, path=root)
-            exp_value = value_file
-
-        if SettingsUse is SettingsLower:
-            expected = SettingsLower(key=exp_value)
-        elif SettingsUse is SettingsUpper:
-            expected = SettingsUpper(KEY=exp_value)
-        else:
-            raise ImpossibleCaseError(case=[f"{SettingsUse=}"])
-        assert settings == expected
-
-    @given(root=git_repos(), value=text_ascii())
-    @settings_with_reduced_examples()
-    def test_file_extra_key(self, *, root: Path, value: str) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            key: str
-
-        _ = root.joinpath(".env").write_text(f"key = {value}\nother = {value}\n")
-        settings = load_settings(Settings, path=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:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            KEY: str
-
-        with raises(_LoadSettingsFileNotFoundError, match=r"Path '.*' must exist"):
-            _ = load_settings(Settings, path=root)
-
-    @given(root=git_repos(), value=integers())
-    @settings_with_reduced_examples()
-    def test_error_duplicate_keys(self, *, root: Path, value: int) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            key: str
-
-        _ = root.joinpath(".env").write_text(f"key = {value}\nKEY = {value}\n")
-        with raises(
-            _LoadSettingsDuplicateKeysError,
-            match=re.compile(
-                r"Mapping .* keys must not contain duplicates \(modulo case\); got .*",
-                flags=DOTALL,
-            ),
-        ):
-            _ = load_settings(Settings, path=root)
-
-    @given(root=git_repos())
-    @settings_with_reduced_examples()
-    def test_error_missing_keys(self, *, root: Path) -> None:
-        @dataclass(kw_only=True, slots=True)
-        class Settings:
-            key: str
-
-        root.joinpath(".env").touch()
-
-        with raises(
-            _LoadSettingsMissingKeysError,
-            match=r"Unable to load '.*'; missing value\(s\) for 'key'",
-        ):
-            _ = load_settings(Settings, path=root)

dycw_utilities-0.146.8/src/tests/test_streamlit.py

@@ -1,6 +0,0 @@
-from __future__ import annotations
-
-
-class TestStreamlit:
-    def test_main(self) -> None:
-        assert True

dycw_utilities-0.146.8/src/utilities/aiolimiter.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from asyncio import get_running_loop
-from typing import TYPE_CHECKING
-
-from aiolimiter import AsyncLimiter
-
-if TYPE_CHECKING:
-    from collections.abc import Hashable
-
-_LIMITERS: dict[tuple[int, Hashable], AsyncLimiter] = {}
-
-
-def get_async_limiter(key: Hashable, /, *, rate: float = 1.0) -> AsyncLimiter:
-    """Get a loop-aware rate limiter."""
-    id_ = id(get_running_loop())
-    full = (id_, key)
-    try:
-        return _LIMITERS[full]
-    except KeyError:
-        limiter = _LIMITERS[full] = AsyncLimiter(1.0, time_period=rate)
-        return limiter
-
-
-__all__ = ["get_async_limiter"]

dycw_utilities-0.146.8/src/utilities/pydantic.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import TYPE_CHECKING, override
-
-from pydantic import BaseModel
-
-from utilities.atomicwrites import writer
-
-if TYPE_CHECKING:
-    from utilities.types import PathLike
-
-
-class HashableBaseModel(BaseModel):
-    """Subclass of BaseModel which is hashable."""
-
-    @override
-    def __hash__(self) -> int:
-        return hash((type(self), *self.__dict__.values()))
-
-
-def load_model[T: BaseModel](model: type[T], path: PathLike, /) -> T:
-    path = Path(path)
-    try:
-        return model.model_validate_json(path.read_text())
-    except FileNotFoundError:
-        raise _LoadModelFileNotFoundError(model=model, path=path) from None
-    except IsADirectoryError:  # skipif-not-windows
-        raise _LoadModelIsADirectoryError(model=model, path=path) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class LoadModelError(Exception):
-    model: type[BaseModel]
-    path: Path
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadModelFileNotFoundError(LoadModelError):
-    @override
-    def __str__(self) -> str:
-        return f"Unable to load {self.model}; path {str(self.path)!r} must exist."
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadModelIsADirectoryError(LoadModelError):
-    @override
-    def __str__(self) -> str:
-        return f"Unable to load {self.model}; path {str(self.path)!r} must not be a directory."  # skipif-not-windows
-
-
-def save_model(model: BaseModel, path: PathLike, /, *, overwrite: bool = False) -> None:
-    with writer(path, overwrite=overwrite) as temp:
-        _ = temp.write_text(model.model_dump_json())
-
-
-__all__ = ["HashableBaseModel", "LoadModelError", "load_model", "save_model"]

dycw_utilities-0.146.8/src/utilities/python_dotenv.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from os import environ
-from pathlib import Path
-from typing import TYPE_CHECKING, override
-
-from dotenv import dotenv_values
-
-from utilities.dataclasses import _ParseDataClassMissingValuesError, parse_dataclass
-from utilities.iterables import MergeStrMappingsError, merge_str_mappings
-from utilities.pathlib import get_root
-from utilities.reprlib import get_repr
-from utilities.types import Dataclass
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-    from collections.abc import Set as AbstractSet
-
-    from utilities.types import MaybeCallablePathLike, ParseObjectExtra, StrMapping
-
-
-def load_settings[T: Dataclass](
-    cls: type[T],
-    /,
-    *,
-    path: MaybeCallablePathLike | None = Path.cwd,
-    globalns: StrMapping | None = None,
-    localns: StrMapping | None = None,
-    warn_name_errors: bool = False,
-    head: bool = False,
-    case_sensitive: bool = False,
-    extra_parsers: ParseObjectExtra | None = None,
-) -> T:
-    """Load a set of settings from the `.env` file."""
-    path = get_root(path=path).joinpath(".env")
-    if not path.exists():
-        raise _LoadSettingsFileNotFoundError(path=path) from None
-    maybe_values_dotenv = dotenv_values(path)
-    try:
-        maybe_values: Mapping[str, str | None] = merge_str_mappings(
-            maybe_values_dotenv, environ, case_sensitive=case_sensitive
-        )
-    except MergeStrMappingsError as error:
-        raise _LoadSettingsDuplicateKeysError(
-            path=path,
-            values=error.mapping,
-            counts=error.counts,
-            case_sensitive=case_sensitive,
-        ) from None
-    values = {k: v for k, v in maybe_values.items() if v is not None}
-    try:
-        return parse_dataclass(
-            values,
-            cls,
-            globalns=globalns,
-            localns=localns,
-            warn_name_errors=warn_name_errors,
-            head=head,
-            case_sensitive=case_sensitive,
-            allow_extra_keys=True,
-            extra_parsers=extra_parsers,
-        )
-    except _ParseDataClassMissingValuesError as error:
-        raise _LoadSettingsMissingKeysError(path=path, fields=error.fields) from None
-
-
-@dataclass(kw_only=True, slots=True)
-class LoadSettingsError(Exception):
-    path: Path
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsDuplicateKeysError(LoadSettingsError):
-    values: StrMapping
-    counts: Mapping[str, int]
-    case_sensitive: bool = False
-
-    @override
-    def __str__(self) -> str:
-        return f"Mapping {get_repr(dict(self.values))} keys must not contain duplicates (modulo case); got {get_repr(self.counts)}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsFileNotFoundError(LoadSettingsError):
-    @override
-    def __str__(self) -> str:
-        return f"Path {str(self.path)!r} must exist"
-
-
-@dataclass(kw_only=True, slots=True)
-class _LoadSettingsMissingKeysError(LoadSettingsError):
-    fields: AbstractSet[str]
-
-    @override
-    def __str__(self) -> str:
-        desc = ", ".join(map(repr, sorted(self.fields)))
-        return f"Unable to load {str(self.path)!r}; missing value(s) for {desc}"
-
-
-__all__ = ["LoadSettingsError", "load_settings"]

dycw_utilities-0.146.8/src/utilities/streamlit.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-from hmac import compare_digest
-from typing import TYPE_CHECKING, Literal
-
-from streamlit import (
-    button,
-    empty,
-    error,
-    form,
-    form_submit_button,
-    markdown,
-    secrets,
-    session_state,
-    stop,
-    text_input,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from streamlit.elements.lib.utils import Key
-    from streamlit.runtime.state import WidgetArgs, WidgetCallback, WidgetKwargs
-
-
-def centered_button(
-    label: str,
-    /,
-    *,
-    key: Key | None = None,
-    help: str | None = None,  # noqa: A002
-    on_click: WidgetCallback | None = None,
-    args: WidgetArgs | None = None,
-    kwargs: WidgetKwargs | None = None,
-    type: Literal["primary", "secondary"] = "secondary",  # noqa: A002
-    disabled: bool = False,
-    use_container_width: bool = False,
-) -> bool:
-    """Create a centered button."""
-    style = r"<style>.row-widget.stButton {text-align: center;}</style>"
-    _ = markdown(style, unsafe_allow_html=True)
-    with empty():
-        return button(
-            label,
-            key=key,
-            help=help,
-            on_click=on_click,
-            args=args,
-            kwargs=kwargs,
-            type=type,
-            disabled=disabled,
-            use_container_width=use_container_width,
-        )
-
-
-_USERNAME = "username"
-_PASSWORD = "password"  # noqa: S105
-_PASSWORD_CORRECT = "password_correct"  # noqa: S105
-
-
-def ensure_logged_in(
-    *,
-    skip: bool = False,
-    before_form: Callable[..., None] | None = None,
-    after_form: Callable[..., None] | None = None,
-) -> None:
-    """Ensure the user is logged in."""
-    if not (skip or _check_password(before_form=before_form, after_form=after_form)):
-        stop()
-
-
-def _check_password(
-    *,
-    before_form: Callable[..., None] | None = None,
-    after_form: Callable[..., None] | None = None,
-) -> bool:
-    """Return `True` if the user had a correct password."""
-    if session_state.get("password_correct", False):
-        return True
-    if before_form is not None:
-        before_form()
-    with form("Credentials"):
-        _ = text_input("Username", key=_USERNAME)
-        _ = text_input("Password", type="password", key=_PASSWORD)
-        _ = form_submit_button("Log in", on_click=_password_entered)
-    if after_form is not None:
-        after_form()
-    if _PASSWORD_CORRECT in session_state:
-        _ = error("Username/password combination invalid or incorrect")
-    return False
-
-
-def _password_entered() -> None:
-    """Check whether a password entered by the user is correct."""
-    if (session_state[_USERNAME] in secrets["passwords"]) and compare_digest(
-        session_state[_PASSWORD], secrets.passwords[session_state[_USERNAME]]
-    ):
-        session_state[_PASSWORD_CORRECT] = True
-        del session_state[_PASSWORD]
-        del session_state[_USERNAME]
-    else:
-        session_state[_PASSWORD_CORRECT] = False
-
-
-__all__ = ["ensure_logged_in"]