dycw-utilities 0.166.30__py3-none-any.whl → 0.185.8__py3-none-any.whl

dycw_utilities-0.185.8.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.3
+Name: dycw-utilities
+Version: 0.185.8
+Summary: Miscellaneous Python utilities
+Author: Derek Wan
+Author-email: Derek Wan <d.wan@icloud.com>
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: tzdata>=2025.3
+Requires-Dist: tzlocal>=5.3.1
+Requires-Dist: whenever>=0.9.5
+Requires-Dist: coloredlogs>=15.0.1 ; extra == 'logging'
+Requires-Dist: dycw-pytest-only>=2.1.1 ; extra == 'test'
+Requires-Dist: hypothesis>=6.150.2 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.3.0 ; extra == 'test'
+Requires-Dist: pytest-cov>=7.0.0 ; extra == 'test'
+Requires-Dist: pytest-instafail>=0.5.0 ; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures>=1.4.0 ; extra == 'test'
+Requires-Dist: pytest-randomly>=4.0.1 ; extra == 'test'
+Requires-Dist: pytest-regressions>=2.9.1 ; extra == 'test'
+Requires-Dist: pytest-repeat>=0.9.4 ; extra == 'test'
+Requires-Dist: pytest-rerunfailures>=16.1 ; extra == 'test'
+Requires-Dist: pytest-rng>=1.0.0 ; extra == 'test'
+Requires-Dist: pytest-timeout>=2.4.0 ; extra == 'test'
+Requires-Dist: pytest-xdist>=3.8.0 ; extra == 'test'
+Requires-Dist: pytest>=9.0.2 ; extra == 'test'
+Requires-Python: >=3.12
+Provides-Extra: logging
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+# `python-utilities`
+
+Miscellaneous Python utilities

dycw_utilities-0.185.8.dist-info/RECORD

@@ -0,0 +1,90 @@
+utilities/__init__.py,sha256=f2LepwDrbt4lGZTQGsx6vT40UOEvW-BOkI7_SrElAds,60
+utilities/altair.py,sha256=248uNvy7JkhGbmgn2yj0Um2Cd2kfEDCRMvUEKTxJjto,9032
+utilities/asyncio.py,sha256=QX_RSCUEK6gMIbrVkJnR_ZjrXUW5hkWpvSXFDyBUz1s,16294
+utilities/atools.py,sha256=Fi2gt4ylGJrwzzMvun1lV41NsoGFm2voHcp9yili9gc,2503
+utilities/cachetools.py,sha256=p7aedtT0QahEU5DpR7xtliIApoS0hsDSdwMKmBF74pw,2820
+utilities/click.py,sha256=fFPqQmCaB2bwcHG62X5c0smEyjoSqmBaJ0bodeaRF9Q,19205
+utilities/concurrent.py,sha256=nzOPz2G21VKrpttgIE9RvbK0ngssS7vbbrauFcNNM3g,2856
+utilities/constants.py,sha256=I7xXM7bFu2gsuG_a1zRMR_T7ZfPKo9-NCczo8X7eNHE,10965
+utilities/contextlib.py,sha256=qBDWE9g5w_6By04X90CbfWWxnuX2xi8XGeptr8BpBIA,7482
+utilities/contextvars.py,sha256=nuSzAoco5HqdfRIVKtsdXnUxFxeBoj8XI0-I71qses4,500
+utilities/core.py,sha256=ehfrNF-Knl3FA1Ekd9LGJ2bvQzfpRv41uxbTry5FeCE,74792
+utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
+utilities/dataclasses.py,sha256=XwAjYxdCnDQvtB34rnq79ZuKGgybl2qXVkYZU8CN03k,28917
+utilities/docker.py,sha256=jqE1RIHLI6lkoJoaBaFID2juJFDeTlfsm3AOVY8qXAc,10660
+utilities/enum.py,sha256=yrQQhFQCbfSF7oLu1Bz258CHn8na3ZK5F2FjvvAztU4,5776
+utilities/errors.py,sha256=ceCdBp4WgvbRB0EpANFeLYFEYmvDerUsepDsFOiL3Oc,1040
+utilities/fastapi.py,sha256=GLeM8pwFYPEn8LrBcSARxvpSmiqbjJY84rN5YreQRzk,1455
+utilities/fpdf2.py,sha256=S5vrKFv-L5LP6tImcbngYtTa7OJJ4PNToCBrEV7-Dbw,1892
+utilities/functions.py,sha256=QYfRRoRoJv7SgxKc4OdM9trubRqLbHGSb9mNGSpg_jc,15362
+utilities/functools.py,sha256=I00ru2gQPakZw2SHVeKIKXfTv741655s6HI0lUoE0D4,1552
+utilities/hashlib.py,sha256=SVTgtguur0P4elppvzOBbLEjVM3Pea0eWB61yg2ilxo,309
+utilities/http.py,sha256=WcahTcKYRtZ04WXQoWt5EGCgFPcyHD3EJdlMfxvDt-0,946
+utilities/hypothesis.py,sha256=Er8cA3K-4KwPLjRzzm6j-HTmkn5YXB6UweF3lOnaiIE,47160
+utilities/importlib.py,sha256=SkVVtIjVC7bjJ36doXnmnmFiYe5tLbip4YAfYJj8Ycg,892
+utilities/inflect.py,sha256=v7YkOWSu8NAmVghPcf4F3YBZQoJCS47_DLf9jbfWIs0,581
+utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
+utilities/iterables.py,sha256=CDWPzYG_7fJHdcMZWYy1lI8-0oC6oEDdo3doBdzNjiE,27958
+utilities/jinja2.py,sha256=nuGVbVEtvFzvcd9x1WRmN0OCDwGC_0-UOowzv3AQrqw,4567
+utilities/jupyter.py,sha256=LQYq7oNw-eiY3xnAz-nEj6DFj0HXtq4a0n26qbDuTpE,2939
+utilities/libcst.py,sha256=tcwn1yqwBd1O7TNRiD3Z2I7A__jem_F3CS1mmqBpAz4,5611
+utilities/lightweight_charts.py,sha256=-rfCKBcJAfPTH6E-2podk33ag8gxLThUxWOdcE_s4KM,2660
+utilities/logging.py,sha256=puR5c2L8XD0L19M7QxyBlvXj8a-lIaCyxt1FZ1fP54E,18789
+utilities/math.py,sha256=-exzVZaKuOfPeMAZ24-5lVGD0tqbqjxcN1_hv8AytDY,26011
+utilities/memory_profiler.py,sha256=XzN56jDCa5aqXS_DxEjb_K4L6aIWh_5zyKi6OhcIxw0,853
+utilities/modules.py,sha256=iuvLluJya-hvl1Q25-Jk3dLgx2Es3ck4SjJiEkAlVTs,3195
+utilities/more_itertools.py,sha256=dv2WQlKGXo34kFs1GvKjhXmRdJV3ljaKrLDC_1B83YQ,10834
+utilities/numpy.py,sha256=i95XC2enKNC8ug1jkncLuq33Eqk3JBvXGHvROai1wIY,26148
+utilities/operator.py,sha256=kI3VQSpH4gM68DunmC0Ir2mDiyP_BGUphcWFV1ckBm4,3601
+utilities/optuna.py,sha256=C-fhWYiXHVPo1l8QctYkFJ4DyhbSrGorzP1dJb_qvd8,1933
+utilities/orjson.py,sha256=0GWskBRlvRojMpKeJYe1Mkc0gqZy-vt0qNRQ-aMbo7U,42025
+utilities/os.py,sha256=fJ97L-YgC2swNu44GMWHn9qMSCsyT0jQKDzZZAXXTgQ,781
+utilities/packaging.py,sha256=ws9OIfyUMx130EK-u5ZVfQI6EOdkekeCRGLcoZt2VmQ,4293
+utilities/parse.py,sha256=BMg75FXTftmLWYqye2iMjjS-H12I16KNg3tlppJ5n98,18195
+utilities/pathlib.py,sha256=ZnEKDiKaaEAxUQ6gnE43OUwK3DM4enYeOClChCd7qV4,6101
+utilities/platform.py,sha256=picjLyUsWMphI6rDzpSjCX8J9lpEFz9J43o-19TM52s,900
+utilities/polars.py,sha256=WJ-Yj25adOT2e3VpXhOUvy_h5cz8yLQajWU5slWEUH4,87400
+utilities/polars_ols.py,sha256=LNTFNLPuYW7fcAHymlbnams_DhitToblYvib3mhKbwI,5615
+utilities/postgres.py,sha256=RQXBIaS54pObS0EFXJQAJ-Hl2H6fbilG7g20hOpt57A,12571
+utilities/pottery.py,sha256=QJvT8I0A-7v5OdK7DSU7hzc2yKTJ9-wIhUNBkE62rlY,4015
+utilities/pqdm.py,sha256=XcL7yZJ8TZOPOX9aQQOGhA_QdM6CI7QFOJde_R9eons,3059
+utilities/psutil.py,sha256=yQIR1M7AtjNWaqGlAAHlAVv0OqsS6PwGBBUqCq9gohg,2054
+utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utilities/pydantic.py,sha256=8wLNW3Hjor6xSJktILSRNfe4hyxSg5Xl-keWbBQ9qUk,656
+utilities/pydantic_settings.py,sha256=UM5G5RAnfI4OApziM15Cqg2hqamNm1NnU12MclRjPX4,7564
+utilities/pydantic_settings_sops.py,sha256=r7QhDHPfDMyexmi2krV0eIOl4Bco0MZxqyStapQyXPk,2307
+utilities/pyinstrument.py,sha256=HtVYVNe7jJ2NuNvv4GyrDsx6lrLRa7BI7UtBWnypIwU,831
+utilities/pytest.py,sha256=WkINIzo45omF2HDXbAFTDeMxDLs3iU2xtM1_Dcqe9TE,8339
+utilities/pytest_plugins/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+utilities/pytest_plugins/pytest_randomly.py,sha256=B1qYVlExGOxTywq2r1SMi5o7btHLk2PNdY_b1p98dkE,409
+utilities/pytest_plugins/pytest_regressions.py,sha256=p_omAAZCkiWLxydLS6LK-hIYn3GRbn-0IrcSpf36q4k,1649
+utilities/pytest_regressions.py,sha256=T-T_2ZCDFm_nxyaEZy1zAw9-HGSAHRnPAH-TIZLTPNc,4910
+utilities/random.py,sha256=DhBzzHoW0RS0rdfWaG0Ws9_Lw_p_doeHnlW9_7W0Pqs,4096
+utilities/redis.py,sha256=mQuKx-cbSq5o2w-ITryiOXAv4YdHHHLrvd_qt0GMUJU,30346
+utilities/reprlib.py,sha256=LYcIh5FbvRwL6ZPP-p1c34taQreBqDWipN5LP66yk4Y,1285
+utilities/scipy.py,sha256=wZJM7fEgBAkLSYYvSmsg5ac-QuwAI0BGqHVetw1_Hb0,947
+utilities/shellingham.py,sha256=lV_cAZHdUK3CC_NKQZuyZSepngr7u8CZZnph3galvaE,1712
+utilities/shelve.py,sha256=4OzjQI6kGuUbJciqf535rwnao-_IBv66gsT6tRGiUt0,759
+utilities/shutil.py,sha256=knJ7hx42FtIfGByxQZMcOSgQCDlaSony325g505ps3A,480
+utilities/slack_sdk.py,sha256=zBM6NpxK3iIoWL-18UVxRavBbRked3PC7mrCUuvkAoY,2297
+utilities/sqlalchemy.py,sha256=riSz1iod_TkUDuJlhgPz-DBn8zl1kWV8G83lgd_DNL0,37300
+utilities/sqlalchemy_polars.py,sha256=jdEb9e6MR6PBbwFThLbMM7q0MeUqoqshChyeje6ia-0,13290
+utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
+utilities/subprocess.py,sha256=PjXK6Do5-uUMyIw1xLSa_DhvgzfmcRUHAVK6HkDqWxg,70961
+utilities/tabulate.py,sha256=9lsjeMxb9lv2-dkHgl85Eln4Pu1RsWweylbxe5CNkAM,912
+utilities/testbook.py,sha256=-A4hC0wNzBdT-biXSZpCI6dOgAilmSJOMArxS4Rhdag,1328
+utilities/text.py,sha256=g4j7IkzArw1hJtSV0k8tqjYvOmvqjjYH369uYC3O9-Y,11817
+utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
+utilities/throttle.py,sha256=fAfsMMiMm0WRL_MnY2A-_slbhlcmuXij7JwDBzR_kaw,4994
+utilities/time.py,sha256=oVvbpGFjgavzGn5Y8CevryQJR9uithmtyBMbPI-YcC8,376
+utilities/timer.py,sha256=a9evZ_Ob8lMz9M6kWizFedVYmHO27bmvUa4m1kAKEKk,3119
+utilities/traceback.py,sha256=wJWAT-8PVu4xwZ5f3OHUUF3o34YwTvQw74S_wkTGvXM,9519
+utilities/types.py,sha256=n0TDfKJTzElnh2df7QdlSIcIGPzSSS0FJyRrcIDGRLc,19539
+utilities/typing.py,sha256=zECFvJbzmUvzg3hn3CNnhtRr_AvGYypgYdiIQRZa2gU,25366
+utilities/uuid.py,sha256=0jVYfTrh1mIrNHi8PNvwLne_DVn7XBmT5P3g7YcBTOQ,1573
+utilities/version.py,sha256=YBhzHz-WpfXLByZr2eEisWsOyFOOfiYYtU3fxf4uDRA,9775
+utilities/whenever.py,sha256=VJaQINRKJwFCVd9Q4zSkG_HvezbdaGxJNcgV6A-lS1Y,57445
+dycw_utilities-0.185.8.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+dycw_utilities-0.185.8.dist-info/entry_points.txt,sha256=cOGtKeJI0KXLSV7MJ8Dhc2G8jPgDcBDm53MVNJU4ycI,136
+dycw_utilities-0.185.8.dist-info/METADATA,sha256=Vf6EyD1EdCdKQLTzuWcvK3SGTF9kdIkSU_0DPqrhzhU,1281
+dycw_utilities-0.185.8.dist-info/RECORD,,

{dycw_utilities-0.166.30.dist-info → dycw_utilities-0.185.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: uv 0.9.26
 Root-Is-Purelib: true
 Tag: py3-none-any

{dycw_utilities-0.166.30.dist-info → dycw_utilities-0.185.8.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [pytest11]
 pytest-randomly = utilities.pytest_plugins.pytest_randomly
 pytest-regressions = utilities.pytest_plugins.pytest_regressions
+

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.166.30"
+__version__ = "0.185.8"

utilities/altair.py

@@ -23,10 +23,13 @@ from altair import (
 )
 from altair.utils.schemapi import Undefined
 
-from utilities.atomicwrites import writer
+from utilities.core import (
+    TemporaryDirectory,
+    always_iterable,
+    write_bytes,
+    yield_write_path,
+)
 from utilities.functions import ensure_bytes, ensure_number
-from utilities.iterables import always_iterable
-from utilities.tempfile import TemporaryDirectory
 
 if TYPE_CHECKING:
     from polars import DataFrame
@@ -94,7 +97,8 @@ def plot_dataframes(
     # lines
     selection = selection_point(bind="legend", fields=[var_name], nearest=False)
     lines = [
-        chart.mark_line(interpolate=interpolate)
+        chart
+        .mark_line(interpolate=interpolate)
         .encode(
             x=x_use,
             y=Y(value_name).scale(zero=False),
@@ -124,7 +128,8 @@ def plot_dataframes(
     else:
         tooltip_format_use = Undefined
     rules = [
-        chart.transform_pivot(var_name, value=value_name, groupby=[x_use])
+        chart
+        .transform_pivot(var_name, value=value_name, groupby=[x_use])
         .mark_rule(color="gray")
         .encode(
             x=x_use,
@@ -143,7 +148,9 @@ def plot_dataframes(
     ]
     zoom = selection_interval(bind="scales", encodings=["x"])
     chart = (
-        vconcat(*layers).add_params(zoom).resolve_scale(color="independent", x="shared")
+        vconcat_charts(*layers)
+        .add_params(zoom)
+        .resolve_scale(color="independent", x="shared")
     )
     if title is not None:
         chart = chart.properties(title=title)
@@ -227,7 +234,8 @@ def plot_intraday_dataframe(
     )
 
     data4 = (
-        data3.group_by("_date_index")
+        data3
+        .group_by("_date_index")
         .agg(
             col(f"_{datetime}_index").min().alias(f"{datetime}_index_min"),
             (col(f"_{datetime}_index").max() + 1).alias(f"{datetime}_index_max"),
@@ -264,7 +272,7 @@ def save_chart(
     chart: _ChartLike, path: PathLike, /, *, overwrite: bool = False
 ) -> None:
     """Atomically save a chart to disk."""
-    with writer(path, overwrite=overwrite) as temp:
+    with yield_write_path(path, overwrite=overwrite) as temp:
         chart.save(temp, format="png")
 
 
@@ -282,8 +290,7 @@ def save_charts_as_pdf(
         for chart, temp_path in zip(charts, temp_paths, strict=True):
             save_chart(chart, temp_path)
         data = ensure_bytes(convert(*temp_paths))
-    with writer(path, overwrite=overwrite) as temp:
-        _ = temp.write_bytes(data)
+    write_bytes(path, data, overwrite=overwrite)
 
 
 ##

utilities/asyncio.py

@@ -10,7 +10,6 @@ from asyncio import (
     Task,
     TaskGroup,
     create_subprocess_shell,
-    sleep,
 )
 from contextlib import (
     AbstractAsyncContextManager,
@@ -36,15 +35,12 @@ from typing import (
     override,
 )
 
-from utilities.functions import ensure_int, ensure_not_none
-from utilities.os import is_pytest
-from utilities.random import SYSTEM_RANDOM
-from utilities.reprlib import get_repr
-from utilities.sentinel import Sentinel, sentinel
+from utilities.constants import SYSTEM_RANDOM, Sentinel, sentinel
+from utilities.core import get_now, is_pytest, repr_
+from utilities.functions import ensure_int, ensure_not_none, in_seconds
 from utilities.shelve import yield_shelf
 from utilities.text import to_bool
-from utilities.warnings import suppress_warnings
-from utilities.whenever import get_now, round_date_or_date_time, to_nanoseconds
+from utilities.whenever import round_date_or_date_time
 
 if TYPE_CHECKING:
     from asyncio import _CoroutineLike
@@ -69,8 +65,8 @@ if TYPE_CHECKING:
 
     from utilities.shelve import _Flag
     from utilities.types import (
-        Coro,
         Delta,
+        Duration,
         MaybeCallableBoolLike,
         MaybeType,
         PathLike,
@@ -229,7 +225,7 @@ class EnhancedTaskGroup(TaskGroup):
 
     _max_tasks: int | None
     _semaphore: Semaphore | None
-    _timeout: Delta | None
+    _timeout: Duration | None
     _error: MaybeType[BaseException]
     _debug: MaybeCallableBoolLike
     _stack: AsyncExitStack
@@ -240,7 +236,7 @@ class EnhancedTaskGroup(TaskGroup):
         self,
         *,
         max_tasks: int | None = None,
-        timeout: Delta | None = None,
+        timeout: Duration | None = None,
         error: MaybeType[BaseException] = TimeoutError,
         debug: MaybeCallableBoolLike = False,
     ) -> None:
@@ -342,7 +338,7 @@ class EnhancedTaskGroup(TaskGroup):
             return await coroutine
 
     async def _wrap_with_timeout[T](self, coroutine: _CoroutineLike[T], /) -> T:
-        async with timeout_td(self._timeout, error=self._error):
+        async with timeout(self._timeout, error=self._error):
             return await coroutine
 
 
@@ -367,20 +363,6 @@ def chain_async[T](*iterables: Iterable[T] | AsyncIterable[T]) -> AsyncIterator[
 ##
 
 
-def get_coroutine_name(func: Callable[[], Coro[Any]], /) -> str:
-    """Get the name of a coroutine, and then dispose of it gracefully."""
-    coro = func()
-    name = coro.__name__
-    with suppress_warnings(
-        message="coroutine '.*' was never awaited", category=RuntimeWarning
-    ):
-        del coro
-    return name
-
-
-##
-
-
 async def get_items[T](queue: Queue[T], /, *, max_size: int | None = None) -> list[T]:
     """Get items from a queue; if empty then wait."""
     try:
@@ -436,7 +418,7 @@ class OneAsyncError[T](Exception):
 class OneAsyncEmptyError[T](OneAsyncError[T]):
     @override
     def __str__(self) -> str:
-        return f"Iterable(s) {get_repr(self.iterables)} must not be empty"
+        return f"Iterable(s) {repr_(self.iterables)} must not be empty"
 
 
 @dataclass(kw_only=True, slots=True)
@@ -446,7 +428,7 @@ class OneAsyncNonUniqueError[T](OneAsyncError):
 
     @override
     def __str__(self) -> str:
-        return f"Iterable(s) {get_repr(self.iterables)} must contain exactly one item; got {self.first}, {self.second} and perhaps more"
+        return f"Iterable(s) {repr_(self.iterables)} must contain exactly one item; got {self.first}, {self.second} and perhaps more"
 
 
 ##
@@ -467,31 +449,29 @@ def put_items_nowait[T](items: Iterable[T], queue: Queue[T], /) -> None:
 ##
 
 
-async def sleep_max(
-    sleep: Delta | None = None, /, *, random: Random = SYSTEM_RANDOM
-) -> None:
-    """Sleep which accepts deltas."""
-    if sleep is None:
-        return
-    await asyncio.sleep(random.uniform(0.0, to_nanoseconds(sleep) / 1e9))
+async def sleep(duration: Duration | None = None, /) -> None:
+    """Sleep which accepts durations."""
+    if duration is not None:
+        await asyncio.sleep(in_seconds(duration))
 
 
 ##
 
 
-async def sleep_rounded(delta: Delta, /) -> None:
-    """Sleep until a rounded time."""
-    await sleep_until(round_date_or_date_time(get_now(), delta, mode="ceil"))
+async def sleep_max(
+    duration: Duration | None = None, /, *, random: Random = SYSTEM_RANDOM
+) -> None:
+    """Sleep up to a maximum duration."""
+    if duration is not None:
+        await sleep(random.uniform(0.0, in_seconds(duration)))
 
 
 ##
 
 
-async def sleep_td(delta: Delta | None = None, /) -> None:
-    """Sleep which accepts deltas."""
-    if delta is None:
-        return
-    await sleep(to_nanoseconds(delta) / 1e9)
+async def sleep_rounded(delta: Delta, /) -> None:
+    """Sleep until a rounded time."""
+    await sleep_until(round_date_or_date_time(get_now(), delta, mode="ceil"))
 
 
 ##
@@ -499,7 +479,7 @@ async def sleep_td(delta: Delta | None = None, /) -> None:
 
 async def sleep_until(datetime: ZonedDateTime, /) -> None:
     """Sleep until a given time."""
-    await sleep_td(datetime - get_now())
+    await sleep(datetime - get_now())
 
 
 ##
@@ -513,27 +493,21 @@ class StreamCommandOutput:
 
     @property
     def return_code(self) -> int:
-        return ensure_int(self.process.returncode)  # skipif-not-windows
+        return ensure_int(self.process.returncode)
 
 
 async def stream_command(cmd: str, /) -> StreamCommandOutput:
     """Run a shell command asynchronously and stream its output in real time."""
-    process = await create_subprocess_shell(  # skipif-not-windows
-        cmd, stdout=PIPE, stderr=PIPE
-    )
-    proc_stdout = ensure_not_none(  # skipif-not-windows
-        process.stdout, desc="process.stdout"
-    )
-    proc_stderr = ensure_not_none(  # skipif-not-windows
-        process.stderr, desc="process.stderr"
-    )
-    ret_stdout = StringIO()  # skipif-not-windows
-    ret_stderr = StringIO()  # skipif-not-windows
-    async with TaskGroup() as tg:  # skipif-not-windows
+    process = await create_subprocess_shell(cmd, stdout=PIPE, stderr=PIPE)
+    proc_stdout = ensure_not_none(process.stdout, desc="process.stdout")
+    proc_stderr = ensure_not_none(process.stderr, desc="process.stderr")
+    ret_stdout = StringIO()
+    ret_stderr = StringIO()
+    async with TaskGroup() as tg:
         _ = tg.create_task(_stream_one(proc_stdout, stdout, ret_stdout))
         _ = tg.create_task(_stream_one(proc_stderr, stderr, ret_stderr))
-    _ = await process.wait()  # skipif-not-windows
-    return StreamCommandOutput(  # skipif-not-windows
+    _ = await process.wait()
+    return StreamCommandOutput(
         process=process, stdout=ret_stdout.getvalue(), stderr=ret_stderr.getvalue()
     )
 
@@ -542,7 +516,7 @@ async def _stream_one(
     input_: StreamReader, out_stream: TextIO, ret_stream: StringIO, /
 ) -> None:
     """Asynchronously read from a stream and write to the target output stream."""
-    while True:  # skipif-not-windows
+    while True:
         line = await input_.readline()
         if not line:
             break
@@ -556,16 +530,21 @@ async def _stream_one(
 
 
 @asynccontextmanager
-async def timeout_td(
-    timeout: Delta | None = None, /, *, error: MaybeType[BaseException] = TimeoutError
+async def timeout(
+    duration: Duration | None = None,
+    /,
+    *,
+    error: MaybeType[BaseException] = TimeoutError,
 ) -> AsyncIterator[None]:
-    """Timeout context manager which accepts deltas."""
-    timeout_use = None if timeout is None else (to_nanoseconds(timeout) / 1e9)
-    try:
-        async with asyncio.timeout(timeout_use):
-            yield
-    except TimeoutError:
-        raise error from None
+    """Timeout context manager which accepts durations."""
+    if duration is None:
+        yield
+    else:
+        try:
+            async with asyncio.timeout(in_seconds(duration)):
+                yield
+        except TimeoutError:
+            raise error from None
 
 
 ##
@@ -605,17 +584,16 @@ __all__ = [
     "OneAsyncNonUniqueError",
     "StreamCommandOutput",
     "chain_async",
-    "get_coroutine_name",
     "get_items",
     "get_items_nowait",
     "one_async",
     "put_items",
     "put_items_nowait",
+    "sleep",
     "sleep_max",
     "sleep_rounded",
-    "sleep_td",
     "sleep_until",
     "stream_command",
-    "timeout_td",
+    "timeout",
     "yield_locked_shelf",
 ]

utilities/atools.py

@@ -6,21 +6,21 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast, overload
 
 import atools
-from whenever import TimeDelta
 
-from utilities.types import Coro, PathLike
+from utilities.functions import in_seconds
+from utilities.types import Coro, Duration, PathLike
 
 if TYPE_CHECKING:
     from atools._memoize_decorator import Keygen, Pickler
 
 
-type _Key[**P, T] = tuple[Callable[P, Coro[T]], TimeDelta]
+type _Key[**P, T] = tuple[Callable[P, Coro[T]], Duration]
 _MEMOIZED_FUNCS: dict[_Key, Callable[..., Coro[Any]]] = {}
 
 
 async def call_memoized[**P, T](
     func: Callable[P, Coro[T]],
-    refresh: TimeDelta | None = None,
+    refresh: Duration | None = None,
     /,
     *args: P.args,
     **kwargs: P.kwargs,
@@ -33,7 +33,7 @@ async def call_memoized[**P, T](
     try:
         memoized_func = _MEMOIZED_FUNCS[key]
     except KeyError:
-        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=refresh.in_seconds())(
+        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=in_seconds(refresh))(
             func
         )
     return await memoized_func(*args, **kwargs)
@@ -48,7 +48,7 @@ def memoize[F: Callable[..., Coro[Any]]](
     /,
     *,
     db_path: PathLike | None = None,
-    duration: float | TimeDelta | None = None,
+    duration: Duration | None = None,
     keygen: Keygen | None = None,
     pickler: Pickler | None = None,
     size: int | None = None,
@@ -59,7 +59,7 @@ def memoize[F: Callable[..., Coro[Any]]](
     /,
     *,
     db_path: PathLike | None = None,
-    duration: float | TimeDelta | None = None,
+    duration: Duration | None = None,
     keygen: Keygen | None = None,
     pickler: Pickler | None = None,
     size: int | None = None,
@@ -69,7 +69,7 @@ def memoize[F: Callable[..., Coro[Any]]](
     /,
     *,
     db_path: PathLike | None = None,
-    duration: float | TimeDelta | None = None,
+    duration: Duration | None = None,
     keygen: Keygen | None = None,
     pickler: Pickler | None = None,
     size: int | None = None,
@@ -87,9 +87,7 @@ def memoize[F: Callable[..., Coro[Any]]](
         return cast("Callable[[F], F]", result)
     return atools.memoize(
         db_path=None if db_path is None else Path(db_path),
-        duration=duration.py_timedelta()
-        if isinstance(duration, TimeDelta)
-        else duration,
+        duration=None if duration is None else in_seconds(duration),
         keygen=keygen,
         pickler=pickler,
         size=size,

utilities/cachetools.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 from collections.abc import Callable, Hashable, Iterable, Iterator, MutableSet
 from math import inf
 from time import monotonic
-from typing import TYPE_CHECKING, Any, override
+from typing import TYPE_CHECKING, Any, cast, override
 
 import cachetools
 from cachetools.func import ttl_cache
 
+from utilities.functions import in_seconds
+
 if TYPE_CHECKING:
-    from whenever import TimeDelta
+    from utilities.types import Duration
 
 
 class TTLCache[K: Hashable, V](cachetools.TTLCache[K, V]):
@@ -19,13 +21,13 @@ class TTLCache[K: Hashable, V](cachetools.TTLCache[K, V]):
         self,
         *,
         max_size: int | None = None,
-        max_duration: TimeDelta | None = None,
+        max_duration: Duration | None = None,
         timer: Callable[[], float] = monotonic,
         get_size_of: Callable[[Any], int] | None = None,
     ) -> None:
         super().__init__(
             maxsize=inf if max_size is None else max_size,
-            ttl=inf if max_duration is None else max_duration.in_seconds(),
+            ttl=inf if max_duration is None else in_seconds(max_duration),
             timer=timer,
             getsizeof=get_size_of,
         )
@@ -46,7 +48,7 @@ class TTLSet[T: Hashable](MutableSet[T]):
         /,
         *,
         max_size: int | None = None,
-        max_duration: TimeDelta | None = None,
+        max_duration: Duration | None = None,
         timer: Callable[[], float] = monotonic,
         get_size_of: Callable[[Any], int] | None = None,
     ) -> None:
@@ -95,16 +97,19 @@ class TTLSet[T: Hashable](MutableSet[T]):
 def cache[F: Callable](
     *,
     max_size: int | None = None,
-    max_duration: TimeDelta | None = None,
+    max_duration: Duration | None = None,
     timer: Callable[[], float] = monotonic,
     typed_: bool = False,
 ) -> Callable[[F], F]:
     """Decorate a function with `max_size` and/or `ttl` settings."""
-    return ttl_cache(
-        maxsize=inf if max_size is None else max_size,
-        ttl=inf if max_duration is None else max_duration.in_seconds(),
-        timer=timer,
-        typed=typed_,
+    return cast(
+        "F",
+        ttl_cache(
+            maxsize=max_size,
+            ttl=inf if max_duration is None else in_seconds(max_duration),
+            timer=timer,
+            typed=typed_,
+        ),
     )