dycw-utilities 0.162.11__tar.gz → 0.163.0__tar.gz

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/PKG-INFO

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

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/pyproject.toml

@@ -72,8 +72,8 @@ hypothesis = [
 ]
 hypothesis-test = [
   "libcst",
-  "pathvalidate",
   "numpy",
+  "pathvalidate",
   "pytest-rerunfailures",
 ]
 inflect = [
@@ -135,7 +135,6 @@ pottery = [
 ]
 pottery-test = [
   "orjson",
-  "pytest-rerunfailures",
 ]
 pqdm = [
   "pqdm >=0.2.0, <0.3",
@@ -162,8 +161,8 @@ pytest-regressions-test = [
 ]
 pytest-test = [
   "orjson",
-  "pytest-rng",
   "pytest-rerunfailures",
+  "pytest-rng",
 ]
 redis = [
   "redis >=6.4.0, <6.5",
@@ -217,6 +216,9 @@ typed-settings = [
 tzdata = [
   "tzdata >=2025.2, <2025.3",
 ]
+whenever-test = [
+  "pathvalidate",
+]
 
 # project
 [project]
@@ -230,7 +232,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.162.11"
+version = "0.163.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -263,7 +265,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.162.11"
+current_version = "0.163.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/conftest.py

@@ -7,11 +7,12 @@ from typing import TYPE_CHECKING
 
 from hypothesis import HealthCheck
 from pytest import fixture, mark, param, skip
+from whenever import PlainDateTime
 
 from utilities.contextlib import enhanced_context_manager
 from utilities.platform import IS_LINUX, IS_MAC, IS_NOT_LINUX, IS_WINDOWS
 from utilities.re import ExtractGroupError, extract_group
-from utilities.whenever import MINUTE, get_now, parse_plain_local
+from utilities.whenever import MINUTE, get_now_local_plain
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator, Sequence
@@ -170,11 +171,14 @@ async def test_async_postgres_engine() -> AsyncEngine:
 
 
 def _is_to_drop(table: str, /) -> bool:
+    now = get_now_local_plain()
     try:
-        datetime_str = extract_group(r"^(\d{8}T\d{6})_", table)
+        text = extract_group(r"^(\d{8}T\d{2,})_", table)
     except ExtractGroupError:
         return True
-    return (get_now() - parse_plain_local(datetime_str)) >= MINUTE
+    date_time = PlainDateTime.parse_common_iso(text)
+    age = now.difference(date_time, ignore_dst=True)
+    return age >= MINUTE
 
 
 def _select_tables() -> TextClause:

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_contextlib.py

@@ -153,7 +153,7 @@ class TestEnhancedContextManager:
     def test_multiprocessing_sigterm(
         self, *, tmp_path: Path, target: Callable[..., None]
     ) -> None:
-        sleep = 0.5
+        sleep = 1.0
         marker = tmp_path.joinpath("marker")
         proc = Process(target=target, args=(marker,), kwargs={"sleep": 4 * sleep})
         proc.start()

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_hypothesis.py

@@ -40,6 +40,7 @@ from whenever import (
 
 from utilities.functions import ensure_int
 from utilities.hypothesis import (
+    _LINUX_DISALLOW_TIME_ZONES,
     Shape,
     _Draw2DefaultGeneratedSentinelError,
     _Draw2InputResolvedToSentinelError,
@@ -1192,8 +1193,7 @@ class TestZoneInfos:
         time_zone = data.draw(zone_infos())
         assert isinstance(time_zone, ZoneInfo)
         if IS_LINUX:
-            _ = assume(time_zone.key not in {"Etc/UTC", "localtime"})
-        assert time_zone.key not in {"Etc/UTC", "localtime"}
+            assert time_zone.key not in _LINUX_DISALLOW_TIME_ZONES
         _ = get_now(time_zone)
 
 

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_logging.py

@@ -31,7 +31,7 @@ from utilities.logging import (
 from utilities.text import unique_str
 from utilities.types import LogLevel
 from utilities.typing import get_args
-from utilities.whenever import get_now, to_local_plain
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -101,7 +101,7 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 1
-        assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.1\__.+?\.txt$", p.name))
 
         for _ in range(2):
             await sleep(1)
@@ -112,9 +112,7 @@ class TestComputeRolloverActions:
             actions.do()
             files = list(tmp_path.iterdir())
             assert len(files) == 1
-            assert any(
-                p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
-            )
+            assert any(p for p in files if search(r"^log\.1\__.+?__.+?\.txt$", p.name))
 
     async def test_multiple_backups(self, *, tmp_path: Path) -> None:
         tmp_path.joinpath("log.txt").touch()
@@ -125,7 +123,7 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 1
-        assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.1\__.+\.txt$", p.name))
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
@@ -135,10 +133,8 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 2
-        assert any(
-            p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
-        )
-        assert any(p for p in files if search(r"^log\.2\__[\dT]+\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.1\__.+?__.+?\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.2\__.+?\.txt$", p.name))
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
@@ -148,13 +144,9 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 3
-        assert any(
-            p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
-        )
-        assert any(
-            p for p in files if search(r"^log\.2\__[\dT]+__[\dT]+\.txt$", p.name)
-        )
-        assert all(p for p in files if search(r"^log\.3\__[\dT]+\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.1\__.+?__.+?\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.2\__.+?__.+?\.txt$", p.name))
+        assert all(p for p in files if search(r"^log\.3\__.+?\.txt$", p.name))
 
         for _ in range(2):
             await sleep(1)
@@ -165,15 +157,9 @@ class TestComputeRolloverActions:
             actions.do()
             files = list(tmp_path.iterdir())
             assert len(files) == 3
-            assert any(
-                p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(
-                p for p in files if search(r"^log\.2\__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert all(
-                p for p in files if search(r"^log\.3\__[\dT]+__[\dT]+\.txt$", p.name)
-            )
+            assert any(p for p in files if search(r"^log\.1\__.+?__.+?\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.2\__.+?__.+?\.txt$", p.name))
+            assert all(p for p in files if search(r"^log\.3\__.+?__.+?\.txt$", p.name))
 
     async def test_deleting_old_files(self, *, tmp_path: Path) -> None:
         tmp_path.joinpath("log.txt").touch()
@@ -184,11 +170,11 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 1
-        assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
+        assert any(p for p in files if search(r"^log\.1\__.+?\.txt$", p.name))
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
-        now = to_local_plain(get_now())
+        now = format_compact(get_now_local(), path=True)
         tmp_path.joinpath(f"log.99__{now}__{now}.txt").touch()
         actions = _compute_rollover_actions(tmp_path, "log", ".txt")
         assert len(actions.deletions) == 2
@@ -196,9 +182,7 @@ class TestComputeRolloverActions:
         actions.do()
         files = list(tmp_path.iterdir())
         assert len(files) == 1
-        assert any(
-            p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
-        )
+        assert any(p for p in files if search(r"^log\.1\__.+?__.+?\.txt$", p.name))
 
 
 class TestGetFormatStr:
@@ -278,7 +262,7 @@ class TestRotatingLogFile:
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
-        path = Path(f"log.{index}__{to_local_plain(end)}.txt")
+        path = Path(f"log.{index}__{format_compact(end, path=True)}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -294,7 +278,9 @@ class TestRotatingLogFile:
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
         start, end = datetimes
-        path = Path(f"log.{index}__{to_local_plain(start)}__{to_local_plain(end)}.txt")
+        path = Path(
+            f"log.{index}__{format_compact(start, path=True)}__{format_compact(end, path=True)}.txt"
+        )
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
@@ -324,7 +310,9 @@ class TestRotatingLogFile:
         file = _RotatingLogFile(
             directory=root, stem="log", suffix=".txt", index=index, end=end
         )
-        assert file.path == root.joinpath(f"log.{index}__{to_local_plain(end)}.txt")
+        assert file.path == root.joinpath(
+            f"log.{index}__{format_compact(end, path=True)}.txt"
+        )
 
     @given(
         root=temp_paths(),
@@ -339,7 +327,7 @@ class TestRotatingLogFile:
             directory=root, stem="log", suffix=".txt", index=index, start=start, end=end
         )
         assert file.path == root.joinpath(
-            f"log.{index}__{to_local_plain(start)}__{to_local_plain(end)}.txt"
+            f"log.{index}__{format_compact(start, path=True)}__{format_compact(end, path=True)}.txt"
         )
 
 
@@ -393,46 +381,34 @@ class TestSizeAndTimeRotatingFileHandler:
                 assert any(p for p in files if search(r"^log\.txt$", p.name))
                 if cycle == 2:
                     assert any(
-                        p for p in files if search(r"^log\.1__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.1__.+?\.txt$", p.name)
                     )
                 elif cycle == 3:
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name)
                     )
                     assert any(
-                        p for p in files if search(r"^log\.2__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.2__.+?\.txt$", p.name)
                     )
                 elif cycle == 4:
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name)
                     )
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.2__.+?__.+?\.txt$", p.name)
                     )
                     assert any(
-                        p for p in files if search(r"^log\.3__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.3__.+?\.txt$", p.name)
                     )
                 elif cycle >= 5:
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name)
                     )
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.2__.+?__.+?\.txt$", p.name)
                     )
                     assert any(
-                        p
-                        for p in files
-                        if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
+                        p for p in files if search(r"^log\.3__.+?__.+?\.txt$", p.name)
                     )
                 await sleep(0.1)
 
@@ -463,7 +439,7 @@ class TestSizeAndTimeRotatingFileHandler:
             files = list(tmp_path.iterdir())
             assert len(files) == 2
             assert any(p for p in files if search(r"^log\.txt$", p.name))
-            assert any(p for p in files if search(r"^log\.1__[\dT]+\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.1__.+?\.txt$", p.name))
 
         await sleep(1.1)
         for i in range(4, 6):
@@ -471,10 +447,8 @@ class TestSizeAndTimeRotatingFileHandler:
             files = list(tmp_path.iterdir())
             assert len(files) == 3
             assert any(p for p in files if search(r"^log\.txt$", p.name))
-            assert any(
-                p for p in files if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(p for p in files if search(r"^log\.2__[\dT]+\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.2__.+?\.txt$", p.name))
 
         await sleep(1.1)
         for i in range(6, 8):
@@ -482,13 +456,9 @@ class TestSizeAndTimeRotatingFileHandler:
             files = list(tmp_path.iterdir())
             assert len(files) == 4
             assert any(p for p in files if search(r"^log\.txt$", p.name))
-            assert any(
-                p for p in files if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(
-                p for p in files if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(p for p in files if search(r"^log\.3__[\dT]+\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.2__.+?__.+?\.txt$", p.name))
+            assert any(p for p in files if search(r"^log\.3__.+?\.txt$", p.name))
 
         for _ in range(2):
             await sleep(1.1)
@@ -498,13 +468,13 @@ class TestSizeAndTimeRotatingFileHandler:
                 assert len(files) == 4
                 assert any(p for p in files if search(r"^log\.txt$", p.name))
                 assert any(
-                    p for p in files if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                    p for p in files if search(r"^log\.1__.+?__.+?\.txt$", p.name)
                 )
                 assert any(
-                    p for p in files if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
+                    p for p in files if search(r"^log\.2__.+?__.+?\.txt$", p.name)
                 )
                 assert any(
-                    p for p in files if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
+                    p for p in files if search(r"^log\.3__.+?__.+?\.txt$", p.name)
                 )
 
     @mark.parametrize("max_bytes", [param(0), param(1)])

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_pyinstrument.py

@@ -16,4 +16,4 @@ class TestProfile:
             sleep(1e-3)
 
         (file,) = tmp_path.iterdir()
-        assert search(r"^profile__[\dT]+\.html$", file.name)
+        assert search(r"^profile__.+?\.html$", file.name)

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_sqlalchemy.py

@@ -90,7 +90,7 @@ from utilities.sqlalchemy import (
 )
 from utilities.text import strip_and_dedent
 from utilities.typing import get_args
-from utilities.whenever import MILLISECOND, get_now, to_local_plain
+from utilities.whenever import MILLISECOND, format_compact, get_now_local_plain
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -101,7 +101,7 @@ if TYPE_CHECKING:
 def _table_names() -> str:
     """Generate at unique string."""
     key = str(uuid4()).replace("-", "")
-    return f"{to_local_plain(get_now())}_{key}"
+    return f"{format_compact(get_now_local_plain())}_{key}"
 
 
 class TestCheckConnect:

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_traceback.py

@@ -19,7 +19,7 @@ from utilities.traceback import (
     make_except_hook,
 )
 from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import SECOND, get_now, to_local_plain
+from utilities.whenever import SECOND, format_compact, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -106,7 +106,7 @@ class TestMakeExceptHook:
             exc_type, exc_val, traceback = exc_info()
             hook(exc_type, exc_val, traceback)
         path = one(tmp_path.iterdir())
-        assert search(r"^[\dT]+\.txt$", path.name)
+        assert search(r"^.+?\.txt$", path.name)
 
     def test_non_error(self) -> None:
         hook = make_except_hook()
@@ -116,7 +116,9 @@ class TestMakeExceptHook:
 
     def test_purge(self, *, tmp_path: Path) -> None:
         now = get_now()
-        path = tmp_path.joinpath(to_local_plain(now - 2 * SECOND)).with_suffix(".txt")
+        path = tmp_path.joinpath(
+            format_compact(now - 2 * SECOND, path=True)
+        ).with_suffix(".txt")
         path.touch()
         assert len(list(tmp_path.iterdir())) == 1
         _make_except_hook_purge(tmp_path, SECOND)

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/tests/test_whenever.py

@@ -9,6 +9,7 @@ from zoneinfo import ZoneInfo
 
 from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import DataObject, data, integers, none, sampled_from
+from pathvalidate import validate_filepath
 from pytest import mark, param, raises
 from whenever import (
     Date,
@@ -39,6 +40,7 @@ from utilities.hypothesis import (
     zoned_date_times_2000,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.types import TIME_ZONES
 from utilities.tzdata import HongKong, Tokyo, USCentral, USEastern
 from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
 from utilities.whenever import (
@@ -55,6 +57,7 @@ from utilities.whenever import (
     MINUTE,
     MONTH,
     NOW_LOCAL,
+    NOW_LOCAL_PLAIN,
     NOW_PLAIN,
     NOW_UTC,
     SECOND,
@@ -115,19 +118,18 @@ from utilities.whenever import (
     from_timestamp_nanos,
     get_now,
     get_now_local,
+    get_now_local_plain,
     get_now_plain,
     get_today,
     get_today_local,
     mean_datetime,
     min_max_date,
-    parse_plain_local,
     round_date_or_date_time,
     sub_year_month,
     to_date,
     to_date_time_delta,
     to_days,
     to_hours,
-    to_local_plain,
     to_microseconds,
     to_milliseconds,
     to_minutes,
@@ -158,6 +160,7 @@ if TYPE_CHECKING:
         MaybeCallableDateLike,
         MaybeCallableZonedDateTimeLike,
         TimeOrDateTimeDelta,
+        TimeZone,
     )
 
 
@@ -354,24 +357,46 @@ class TestFormatCompact:
         expected = time.round()
         assert parsed == expected
 
-    @given(datetime=plain_date_times())
-    def test_plain_datetime(self, *, datetime: PlainDateTime) -> None:
-        result = format_compact(datetime)
+    @given(date_time=plain_date_times())
+    def test_plain_date_time(self, *, date_time: PlainDateTime) -> None:
+        result = format_compact(date_time)
         assert isinstance(result, str)
         parsed = PlainDateTime.parse_common_iso(result)
         assert parsed.nanosecond == 0
-        expected = datetime.round()
+        expected = date_time.round()
         assert parsed == expected
 
-    @given(datetime=zoned_date_times())
-    def test_zoned_datetime(self, *, datetime: ZonedDateTime) -> None:
-        result = format_compact(datetime)
+    @given(date_time=zoned_date_times(time_zone=zone_infos()))
+    def test_zoned_date_time(self, *, date_time: ZonedDateTime) -> None:
+        result = format_compact(date_time)
         assert isinstance(result, str)
-        parsed = ZonedDateTime.parse_common_iso(result)
+        parsed = to_zoned_date_time(result)
         assert parsed.nanosecond == 0
-        expected = datetime.round()
+        expected = date_time.round()
         assert parsed == expected
 
+    @mark.parametrize(
+        ("time_zone", "suffix"),
+        [
+            param("America/Argentina/Buenos_Aires", "America~Argentina~Buenos_Aires"),
+            param("Asia/Hong_Kong", "Asia~Hong_Kong"),
+            param("Etc/GMT", "Etc~GMT"),
+            param("Etc/GMT+1", "Etc~GMT+1"),
+            param("Etc/GMT-1", "Etc~GMT-1"),
+        ],
+    )
+    def test_zoned_date_time_path(self, *, time_zone: TimeZone, suffix: str) -> None:
+        assert time_zone in TIME_ZONES
+        date_time = ZonedDateTime(
+            2000, 1, 2, 12, 34, 56, nanosecond=123456789, tz=time_zone
+        )
+        ser = format_compact(date_time, path=True)
+        validate_filepath(ser)
+        expected = f"20000102T123456[{suffix}]"
+        assert ser == expected
+        result = to_zoned_date_time(ser)
+        assert result.exact_eq(date_time.round())
+
 
 class TestFromTimeStamp:
     @given(
@@ -427,6 +452,15 @@ class TestGetNowLocal:
         assert NOW_LOCAL.tz == LOCAL_TIME_ZONE_NAME
 
 
+class TestGetNowLocalPlain:
+    def test_function(self) -> None:
+        now = get_now_local_plain()
+        assert isinstance(now, PlainDateTime)
+
+    def test_constant(self) -> None:
+        assert isinstance(NOW_LOCAL_PLAIN, PlainDateTime)
+
+
 class TestGetNowPlain:
     @given(time_zone=zone_infos())
     def test_function(self, *, time_zone: ZoneInfo) -> None:
@@ -968,15 +1002,6 @@ class TestToHours:
             _ = to_hours(delta)
 
 
-class TestToLocalPlainAndParsePlainLocal:
-    @given(date_time=zoned_date_times())
-    def test_main(self, *, date_time: ZonedDateTime) -> None:
-        text = to_local_plain(date_time)
-        assert isinstance(text, str)
-        parsed = parse_plain_local(text)
-        assert abs(parsed - date_time) <= SECOND
-
-
 class TestToMicroseconds:
     @given(days=integers())
     def test_date_delta(self, *, days: int) -> None:
@@ -1399,9 +1424,13 @@ class TestToZonedDateTime:
         expected = date_time.to_tz(time_zone.key)
         assert result.exact_eq(expected)
 
-    @given(date_time=zoned_date_times(), time_zone=zone_infos())
-    def test_str(self, *, date_time: ZonedDateTime, time_zone: ZoneInfo) -> None:
-        result = to_zoned_date_time(date_time.format_common_iso(), time_zone=time_zone)
+    @given(data=data(), date_time=zoned_date_times(), time_zone=zone_infos())
+    def test_str(
+        self, *, data: DataObject, date_time: ZonedDateTime, time_zone: ZoneInfo
+    ) -> None:
+        text = date_time.format_common_iso()
+        text_use = data.draw(sampled_from([text, text.replace("/", "_")]))
+        result = to_zoned_date_time(text_use, time_zone=time_zone)
         expected = date_time.to_tz(time_zone.key)
         assert result.exact_eq(expected)
 

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.162.11"
+__version__ = "0.163.0"

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/utilities/fpdf2.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, override
 from fpdf import FPDF
 from fpdf.enums import XPos, YPos
 
-from utilities.whenever import get_now, to_local_plain
+from utilities.whenever import format_compact, get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -47,7 +47,7 @@ def yield_pdf(*, header: str | None = None) -> Iterator[_BasePDF]:
         def footer(self) -> None:
             self.set_y(-15)
             self.set_font(family="Helvetica", style="I", size=8)
-            page_no, now = (self.page_no(), to_local_plain(get_now()))
+            page_no, now = (self.page_no(), format_compact(get_now_local()))
             text = f"page {page_no}/{{}}; {now}"
             _ = self.cell(
                 w=0,

{dycw_utilities-0.162.11 → dycw_utilities-0.163.0}/src/utilities/hypothesis.py

@@ -115,7 +115,7 @@ if TYPE_CHECKING:
     from sqlalchemy import URL
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.types import Number, TimeZoneLike
+    from utilities.types import Number, TimeZone, TimeZoneLike
 
 
 type MaybeSearchStrategy[_T] = _T | SearchStrategy[_T]
@@ -1484,12 +1484,17 @@ def zone_infos(draw: DrawFn, /) -> ZoneInfo:
     """Strategy for generating time-zones."""
     time_zone = draw(timezones())
     if IS_LINUX:  # skipif-not-linux
-        _ = assume(time_zone.key not in {"Etc/UTC", "localtime"})
+        _ = assume(time_zone.key not in _LINUX_DISALLOW_TIME_ZONES)
     with assume_does_not_raise(TimeZoneNotFoundError):
         _ = get_now(time_zone)
     return time_zone
 
 
+_LINUX_DISALLOW_TIME_ZONES: set[TimeZone | Literal["localtime"]] = {
+    "Etc/UTC",
+    "localtime",
+}
+
 ##