dycw-utilities 0.127.1__py3-none-any.whl → 0.129.0__py3-none-any.whl

{dycw_utilities-0.127.1.dist-info → dycw_utilities-0.129.0.dist-info}/METADATA

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

{dycw_utilities-0.127.1.dist-info → dycw_utilities-0.129.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-utilities/__init__.py,sha256=X-YBx01AtGeh8rblelYCi8ZH6Md1qNjdGUJTtLYqEdE,60
+utilities/__init__.py,sha256=SLPkIGR28QU6Zy5OKMEX-IvxA2c0MLdH8FuPAUwRzrc,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
-utilities/asyncio.py,sha256=wKxwNnxdWxsiy5U0b1F3UgpWRHlPKM0y_OcmURzqxR8,51396
+utilities/asyncio.py,sha256=OIQ4JddpQw8tSubzwDR0WyqQ-uE-L5DdbwuTqRQK5MQ,38202
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=IYMuFSFGSKyuQmqD6v5IUtDlz8PPw0Sr87Cub_gRU3M,1168
 utilities/cachetools.py,sha256=C1zqOg7BYz0IfQFK8e3qaDDgEZxDpo47F15RTfJM37Q,2910
@@ -11,26 +11,25 @@ utilities/contextvars.py,sha256=RsSGGrbQqqZ67rOydnM7WWIsM2lIE31UHJLejnHJPWY,505
 utilities/cryptography.py,sha256=_CiK_K6c_-uQuUhsUNjNjTL-nqxAh4_1zTfS11Xe120,972
 utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
 utilities/dataclasses.py,sha256=iiC1wpGXWhaocIikzwBt8bbLWyImoUlOlcDZJGejaIg,33011
-utilities/datetime.py,sha256=uYoaOi_C1YtNXGfTN9xlTrW62Re2b1_4Skuv14_MeYQ,38985
+utilities/datetime.py,sha256=aiPh2OZK2g9gn4yEeSO0lODOmvx8U_rGn6XeSzyk4VY,38738
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=nC7ZYtxxDBMfrTHtT_MByBfup_wfGQFRo3eDt-0ZPe8,1045
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
-utilities/fastapi.py,sha256=LG1-Q8RDi7wsyVN6v74qptPYX8WGXPkFOQFniMvtzjc,2439
+utilities/fastapi.py,sha256=gZrXYxKAc7ZEAL_tDmkcbqebkm-KfMCY0X8r-1HF5dI,2962
 utilities/fpdf2.py,sha256=y1NGXR5chWqLXWpewGV3hlRGMr_5yV1lVRkPBhPEgJI,1843
 utilities/functions.py,sha256=jgt592voaHNtX56qX0SRvFveVCRmSIxCZmqvpLZCnY8,27305
 utilities/functools.py,sha256=WrpHt7NLNWSUn9A1Q_ZIWlNaYZOEI4IFKyBG9HO3BC4,1643
 utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
-utilities/git.py,sha256=wpt5dZ5Oi5931pN24_VLZYaQOvmR0OcQuVtgHzFUN1k,2359
 utilities/hashlib.py,sha256=SVTgtguur0P4elppvzOBbLEjVM3Pea0eWB61yg2ilxo,309
 utilities/http.py,sha256=WcahTcKYRtZ04WXQoWt5EGCgFPcyHD3EJdlMfxvDt-0,946
-utilities/hypothesis.py,sha256=snJ35u9-dXKn3Unac4IPW2V4JtRUg5B7SsDBrQHIx9g,44834
+utilities/hypothesis.py,sha256=UnUMJmeqwJuK7uyUqw_i3opUYzVKud4RMG0RMOSRBQY,44463
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
 utilities/iterables.py,sha256=mDqw2_0MUVp-P8FklgcaVTi2TXduH0MxbhTDzzhSBho,44915
 utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
 utilities/libcst.py,sha256=Jto5ppzRzsxn4AD32IS8n0lbgLYXwsVJB6EY8giNZyY,4974
 utilities/lightweight_charts.py,sha256=0xNfcsrgFI0R9xL25LtSm-W5yhfBI93qQNT6HyaXAhg,2769
-utilities/logging.py,sha256=gwo3pusPjnWO1ollrtn1VKYyRAQJTue4SkCbMeNvec4,25715
+utilities/logging.py,sha256=a99gX9oQUe_Oxs5rDtTwUVuOwhRyeO_GfoFNKVaEny0,25641
 utilities/loguru.py,sha256=MEMQVWrdECxk1e3FxGzmOf21vWT9j8CAir98SEXFKPA,3809
 utilities/luigi.py,sha256=fpH9MbxJDuo6-k9iCXRayFRtiVbUtibCJKugf7ygpv0,5988
 utilities/math.py,sha256=-mQgbah-dPJwOEWf3SonrFoVZ2AVxMgpeQ3dfVa-oJA,26764
@@ -43,7 +42,7 @@ utilities/optuna.py,sha256=loyJGWTzljgdJaoLhP09PT8Jz6o_pwBOwehY33lHkhw,1923
 utilities/orjson.py,sha256=AvPFxzJdxC-3PBID3cqdiMyN8FeC7aW9QUgGwbvKuAM,36948
 utilities/os.py,sha256=D_FyyT-6TtqiN9KSS7c9g1fnUtgxmyMtzAjmYLkk46A,3587
 utilities/parse.py,sha256=vsZ2jf_ceSI_Kta9titixufysJaVXh0Whjz1T4awJZw,18938
-utilities/pathlib.py,sha256=31WPMXdLIyXgYOMMl_HOI2wlo66MGSE-cgeelk-Lias,1410
+utilities/pathlib.py,sha256=0cQpqmZs-Pe2693xZwGFApq-B9mADqhX-pclf_5iLco,3041
 utilities/period.py,sha256=o4wXYEXVlFomop4-Ra4L0yRP4i99NZFjIe_fa7NdZck,11024
 utilities/pickle.py,sha256=Bhvd7cZl-zQKQDFjUerqGuSKlHvnW1K2QXeU5UZibtg,657
 utilities/platform.py,sha256=48IOKx1IC6ZJXWG-b56ZQptITcNFhWRjELW72o2dGTA,2398
@@ -54,21 +53,21 @@ utilities/pqdm.py,sha256=foRytQybmOQ05pjt5LF7ANyzrIa--4ScDE3T2wd31a4,3118
 utilities/psutil.py,sha256=RtbLKOoIJhqrJmEoHDBVeSD-KPzshtS0FtRXBP9_w2s,3751
 utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utilities/pydantic.py,sha256=f6qtR5mO2YMuyvNmbaEj5YeD9eGA4YYfb7Bjzh9jUs0,1845
-utilities/pyinstrument.py,sha256=OJFDh4o1CWIa4aYPYURdQjgap_nvP45KUsCEe94rQHY,829
+utilities/pyinstrument.py,sha256=O2dngLsmUUnpMtW1eN3OiM0rGQNBIlXSvZmym_jAsvU,904
 utilities/pyrsistent.py,sha256=wVOVIe_68AAaa-lUE9y-TEzDawVp1uEIc_zfoDgr5ww,2287
 utilities/pytest.py,sha256=KoHSwJbIY2CHtFUlUr_gnEk7z1DVTaldl8RDQ4tDkG4,7837
-utilities/pytest_regressions.py,sha256=-SVT9647Dg6-JcdsiaDKXe3NdOmmrvGevLKWwGjxq3c,5088
-utilities/python_dotenv.py,sha256=iWcnpXbH7S6RoXHiLlGgyuH6udCupAcPd_gQ0eAenQ0,3190
+utilities/pytest_regressions.py,sha256=YI55B7EtLjhz7zPJZ6NK9bWrxrKCKabWZJe1cwcbA5o,5082
+utilities/python_dotenv.py,sha256=edXsvHZhZnYeqfMfrsRRpj7_9eJI6uizh3xLx8Q9B3w,3228
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
-utilities/redis.py,sha256=EZgqWeoGpvN-BfCQL93F3rYlfB4U_zhzHCBuZpDmKpo,37157
+utilities/redis.py,sha256=7Sc-G43VXVzFQU7MHKyI1y3u7My3oT1UoWXPGcKM_-0,36008
 utilities/reprlib.py,sha256=ssYTcBW-TeRh3fhCJv57sopTZHF5FrPyyUg9yp5XBlo,3953
 utilities/scipy.py,sha256=X6ROnHwiUhAmPhM0jkfEh0-Fd9iRvwiqtCQMOLmOQF8,945
 utilities/sentinel.py,sha256=3jIwgpMekWgDAxPDA_hXMP2St43cPhciKN3LWiZ7kv0,1248
 utilities/shelve.py,sha256=HZsMwK4tcIfg3sh0gApx4-yjQnrY4o3V3ZRimvRhoW0,738
-utilities/slack_sdk.py,sha256=jqQyiYSKseZNdg2lCkvPzrAows9p7kVDDjvEnatioKo,5702
+utilities/slack_sdk.py,sha256=ltmzv68aa73CJGqTDvt8L9vDm22YU9iOCo3NCiNd3vA,4347
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
-utilities/sqlalchemy.py,sha256=XTZmNKXD9SUbZ7V1xNNxok-0Ej0Cf4ya5pjuIeH-kdg,39388
+utilities/sqlalchemy.py,sha256=I81qR7JtS-q1sLnw42p7L0FC0imT98gJHGte_KOjpAA,37890
 utilities/sqlalchemy_polars.py,sha256=s7hQNep2O5DTgIRXyN_JRQma7a4DAtNd25tshaZW8iw,15490
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/streamlit.py,sha256=U9PJBaKP1IdSykKhPZhIzSPTZsmLsnwbEPZWzNhJPKk,2955
@@ -80,17 +79,17 @@ utilities/text.py,sha256=ymBFlP_cA8OgNnZRVNs7FAh7OG8HxE6YkiLEMZv5g_A,11297
 utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=Rkc49KSpHuC8s7vUxGO9DU55U9I6yDKnchsQqrUCVBs,4075
 utilities/traceback.py,sha256=Jg7HS3AwQ-W-msdwHp22_PSHZcR54PbmsSf115B6TSM,27435
-utilities/types.py,sha256=2f1DqTZTMRlpCPWPd9-rh_uwmRPv9UdBoi_Bfv7Ccmo,18374
+utilities/types.py,sha256=gP04CcCOyFrG7BgblVCsrrChiuO2x842NDVW-GF7odo,18370
 utilities/typing.py,sha256=H6ysJkI830aRwLsMKz0SZIw4cpcsm7d6KhQOwr-SDh0,13817
 utilities/tzdata.py,sha256=yCf70NICwAeazN3_JcXhWvRqCy06XJNQ42j7r6gw3HY,1217
 utilities/tzlocal.py,sha256=3upDNFBvGh1l9njmLR2z2S6K6VxQSb7QizYGUbAH3JU,960
 utilities/uuid.py,sha256=jJTFxz-CWgltqNuzmythB7iEQ-Q1mCwPevUfKthZT3c,611
-utilities/version.py,sha256=QFuyEeQA6jI0ruBEcmhqG36f-etg1AEiD1drBBqhQrs,5358
+utilities/version.py,sha256=ufhJMmI6KPs1-3wBI71aj5wCukd3sP_m11usLe88DNA,5117
 utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=jS31ZAY5OMxFxLja_Yo5Fidi87Pd-GoVZ7Vi_teqVDA,16743
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-5j7IQ9nb7gR43rdgA7ms05im-XuqhAk9EJnQBXxCoQ,1874
-dycw_utilities-0.127.1.dist-info/METADATA,sha256=f5sCvR07FCJWNnW1cZFk3qz78HANmQJ3RNl-qnuG_0Q,12803
-dycw_utilities-0.127.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.127.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.127.1.dist-info/RECORD,,
+dycw_utilities-0.129.0.dist-info/METADATA,sha256=FRizi23CYGCVbYnOw9jcaTlerh4kCxHwLLm-Tpi-XR4,12803
+dycw_utilities-0.129.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.129.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.129.0.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.127.1"
+__version__ = "0.129.0"

utilities/asyncio.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-import datetime as dt
-from abc import ABC, abstractmethod
 from asyncio import (
-    CancelledError,
     Event,
     Lock,
     PriorityQueue,
@@ -19,7 +16,7 @@ from asyncio import (
     sleep,
     timeout,
 )
-from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping
+from collections.abc import Callable, Iterable, Iterator
 from contextlib import (
     AbstractAsyncContextManager,
     AsyncExitStack,
@@ -37,7 +34,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    NoReturn,
     Self,
     TextIO,
     TypeVar,
@@ -50,27 +46,19 @@ from typing_extensions import deprecated
 
 from utilities.dataclasses import replace_non_sentinel
 from utilities.datetime import (
-    MINUTE,
     SECOND,
     datetime_duration_to_float,
-    datetime_duration_to_timedelta,
     get_now,
     round_datetime,
 )
-from utilities.errors import ImpossibleCaseError, repr_error
-from utilities.functions import ensure_int, ensure_not_none, get_class_name
+from utilities.errors import repr_error
+from utilities.functions import ensure_int, ensure_not_none
 from utilities.random import SYSTEM_RANDOM
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import (
-    Coroutine1,
-    DurationOrEveryDuration,
-    MaybeCallableEvent,
-    MaybeType,
-    THashable,
-    TSupportsRichComparison,
-)
+from utilities.types import MaybeCallableEvent, THashable, TSupportsRichComparison
 
 if TYPE_CHECKING:
+    import datetime as dt
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
     from collections import deque
@@ -319,346 +307,6 @@ class EnhancedTaskGroup(TaskGroup):
 ##
 
 
-@dataclass(kw_only=True, unsafe_hash=True)
-class InfiniteLooper(ABC, Generic[THashable]):
-    """An infinite loop which can throw exceptions by setting events."""
-
-    sleep_core: DurationOrEveryDuration = field(default=SECOND, repr=False)
-    sleep_restart: DurationOrEveryDuration = field(default=MINUTE, repr=False)
-    duration: Duration | None = field(default=None, repr=False)
-    logger: str | None = field(default=None, repr=False)
-    _await_upon_aenter: bool = field(default=True, init=False, repr=False)
-    _depth: int = field(default=0, init=False, repr=False)
-    _events: Mapping[THashable | None, Event] = field(
-        default_factory=dict, init=False, repr=False, hash=False
-    )
-    _stack: AsyncExitStack = field(
-        default_factory=AsyncExitStack, init=False, repr=False
-    )
-    _task: Task[None] | None = field(default=None, init=False, repr=False)
-
-    def __post_init__(self) -> None:
-        self._events = {
-            event: Event() for event, _ in self._yield_events_and_exceptions()
-        }
-
-    async def __aenter__(self) -> Self:
-        """Context manager entry."""
-        if self._depth == 0:
-            self._task = create_task(self._run_looper())
-            if self._await_upon_aenter:
-                with suppress(CancelledError):
-                    await self._task
-            _ = await self._stack.__aenter__()
-        self._depth += 1
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None = None,
-        exc_value: BaseException | None = None,
-        traceback: TracebackType | None = None,
-    ) -> None:
-        """Context manager exit."""
-        _ = (exc_type, exc_value, traceback)
-        self._depth = max(self._depth - 1, 0)
-        if (self._depth == 0) and (self._task is not None):
-            with suppress(CancelledError):
-                await self._task
-            self._task = None
-            try:
-                await self._teardown()
-            except Exception as error:  # noqa: BLE001
-                self._error_upon_teardown(error)
-            _ = await self._stack.__aexit__(exc_type, exc_value, traceback)
-
-    async def stop(self) -> None:
-        """Stop the service."""
-        if self._task is None:
-            raise ImpossibleCaseError(case=[f"{self._task=}"])  # pragma: no cover
-        with suppress(CancelledError):
-            _ = self._task.cancel()
-
-    async def _run_looper(self) -> None:
-        """Run the looper."""
-        match self.duration:
-            case None:
-                await self._run_looper_without_timeout()
-            case int() | float() | dt.timedelta() as duration:
-                try:
-                    async with timeout_dur(duration=duration):
-                        return await self._run_looper_without_timeout()
-                except TimeoutError:
-                    await self.stop()
-            case _ as never:
-                assert_never(never)
-        return None
-
-    async def _run_looper_without_timeout(self) -> None:
-        """Run the looper without a timeout."""
-        coroutines = list(self._yield_coroutines())
-        loopers = list(self._yield_loopers())
-        if (len(coroutines) == 0) and (len(loopers) == 0):
-            return await self._run_looper_by_itself()
-        return await self._run_looper_with_others(coroutines, loopers)
-
-    async def _run_looper_by_itself(self) -> None:
-        """Run the looper by itself."""
-        whitelisted = tuple(self._yield_whitelisted_errors())
-        blacklisted = tuple(self._yield_blacklisted_errors())
-        while True:
-            try:
-                self._reset_events()
-                try:
-                    await self._initialize()
-                except Exception as error:  # noqa: BLE001
-                    self._error_upon_initialize(error)
-                    await self._run_sleep(self.sleep_restart)
-                else:
-                    while True:
-                        try:
-                            event = next(
-                                key
-                                for (key, value) in self._events.items()
-                                if value.is_set()
-                            )
-                        except StopIteration:
-                            await self._core()
-                            await self._run_sleep(self.sleep_core)
-                        else:
-                            self._raise_error(event)
-            except InfiniteLooperError:
-                raise
-            except BaseException as error1:
-                match error1:
-                    case Exception():
-                        if isinstance(error1, blacklisted):
-                            raise
-                    case BaseException():
-                        if not isinstance(error1, whitelisted):
-                            raise
-                    case _ as never:
-                        assert_never(never)
-                self._error_upon_core(error1)
-                try:
-                    await self._teardown()
-                except BaseException as error2:  # noqa: BLE001
-                    self._error_upon_teardown(error2)
-                finally:
-                    await self._run_sleep(self.sleep_restart)
-
-    async def _run_looper_with_others(
-        self,
-        coroutines: Iterable[Callable[[], Coroutine1[None]]],
-        loopers: Iterable[InfiniteLooper[Any]],
-        /,
-    ) -> None:
-        """Run multiple loopers."""
-        while True:
-            self._reset_events()
-            try:
-                async with TaskGroup() as tg, AsyncExitStack() as stack:
-                    _ = tg.create_task(self._run_looper_by_itself())
-                    _ = [tg.create_task(c()) for c in coroutines]
-                    _ = [
-                        tg.create_task(stack.enter_async_context(lo)) for lo in loopers
-                    ]
-            except ExceptionGroup as error:
-                self._error_group_upon_others(error)
-                await self._run_sleep(self.sleep_restart)
-
-    async def _initialize(self) -> None:
-        """Initialize the loop."""
-
-    async def _core(self) -> None:
-        """Run the core part of the loop."""
-
-    async def _teardown(self) -> None:
-        """Tear down the loop."""
-
-    def _error_upon_initialize(self, error: Exception, /) -> None:
-        """Handle any errors upon initializing the looper."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r whilst initializing; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_upon_core(self, error: BaseException, /) -> None:
-        """Handle any errors upon running the core function."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_upon_teardown(self, error: BaseException, /) -> None:
-        """Handle any errors upon tearing down the looper."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r whilst tearing down; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_group_upon_others(self, group: ExceptionGroup, /) -> None:
-        """Handle any errors upon running the core function."""
-        if self.logger is not None:
-            errors = group.exceptions
-            n = len(errors)
-            msgs = [f"{get_class_name(self)!r} encountered {n} error(s):"]
-            msgs.extend(
-                f"- Error #{i}/{n}: {repr_error(e)}"
-                for i, e in enumerate(errors, start=1)
-            )
-            msgs.append(f"Sleeping {self._sleep_restart_desc}...")
-            getLogger(name=self.logger).error("\n".join(msgs))
-
-    def _raise_error(self, event: THashable | None, /) -> NoReturn:
-        """Raise the error corresponding to given event."""
-        mapping = dict(self._yield_events_and_exceptions())
-        error = mapping.get(event, InfiniteLooperError)
-        raise error
-
-    def _reset_events(self) -> None:
-        """Reset the events."""
-        self._events = {
-            event: Event() for event, _ in self._yield_events_and_exceptions()
-        }
-
-    async def _run_sleep(self, sleep: DurationOrEveryDuration, /) -> None:
-        """Sleep until the next part of the loop."""
-        match sleep:
-            case int() | float() | dt.timedelta() as duration:
-                await sleep_dur(duration=duration)
-            case "every", (int() | float() | dt.timedelta()) as duration:
-                await sleep_until_rounded(duration)
-            case _ as never:
-                assert_never(never)
-
-    @property
-    def _sleep_restart_desc(self) -> str:
-        """Get a description of the sleep until restart."""
-        match self.sleep_restart:
-            case int() | float() | dt.timedelta() as duration:
-                timedelta = datetime_duration_to_timedelta(duration)
-                return f"for {timedelta}"
-            case "every", (int() | float() | dt.timedelta()) as duration:
-                timedelta = datetime_duration_to_timedelta(duration)
-                return f"until next {timedelta}"
-            case _ as never:
-                assert_never(never)
-
-    def _set_event(self, *, event: THashable | None = None) -> None:
-        """Set the given event."""
-        try:
-            event_obj = self._events[event]
-        except KeyError:
-            raise _InfiniteLooperNoSuchEventError(looper=self, event=event) from None
-        event_obj.set()
-
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[THashable | None, MaybeType[Exception]]]:
-        """Yield the events & exceptions."""
-        yield (None, _InfiniteLooperDefaultEventError(looper=self))
-
-    def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
-        """Yield any other coroutines which must also be run."""
-        yield from []
-
-    def _yield_loopers(self) -> Iterator[InfiniteLooper[Any]]:
-        """Yield any other loopers which must also be run."""
-        yield from []
-
-    def _yield_blacklisted_errors(self) -> Iterator[type[Exception]]:
-        """Yield any exceptions which the looper ought to catch terminate upon."""
-        yield from []
-
-    def _yield_whitelisted_errors(self) -> Iterator[type[BaseException]]:
-        """Yield any exceptions which the looper ought to catch and allow running."""
-        yield from []
-
-
-@dataclass(kw_only=True, slots=True)
-class InfiniteLooperError(Exception):
-    looper: InfiniteLooper[Any]
-
-
-@dataclass(kw_only=True, slots=True)
-class _InfiniteLooperNoSuchEventError(InfiniteLooperError):
-    event: Hashable
-
-    @override
-    def __str__(self) -> str:
-        return f"{get_class_name(self.looper)!r} does not have an event {self.event!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _InfiniteLooperDefaultEventError(InfiniteLooperError):
-    @override
-    def __str__(self) -> str:
-        return f"{get_class_name(self.looper)!r} default event error"
-
-
-##
-
-
-@dataclass(kw_only=True)
-class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
-    """An infinite loop which processes a queue."""
-
-    _await_upon_aenter: bool = field(default=False, init=False, repr=False)
-    _queue: EnhancedQueue[_T] = field(
-        default_factory=EnhancedQueue, init=False, repr=False
-    )
-
-    def __len__(self) -> int:
-        return self._queue.qsize()
-
-    @override
-    async def _core(self) -> None:
-        """Run the core part of the loop."""
-        if self.empty():
-            return
-        await self._process_queue()
-
-    @abstractmethod
-    async def _process_queue(self) -> None:
-        """Process the queue."""
-
-    def empty(self) -> bool:
-        """Check if the queue is empty."""
-        return self._queue.empty()
-
-    def put_left_nowait(self, *items: _T) -> None:
-        """Put items into the queue at the start without blocking."""
-        self._queue.put_left_nowait(*items)  # pragma: no cover
-
-    def put_right_nowait(self, *items: _T) -> None:
-        """Put items into the queue at the end without blocking."""
-        self._queue.put_right_nowait(*items)  # pragma: no cover
-
-    def qsize(self) -> int:
-        """Get the number of items in the queue."""
-        return self._queue.qsize()
-
-    async def run_until_empty(self, *, stop: bool = False) -> None:
-        """Run until the queue is empty."""
-        while not self.empty():
-            await self._process_queue()
-        if stop:
-            await self.stop()
-
-
-##
-
-
 @dataclass(kw_only=True, slots=True)
 class LooperError(Exception): ...
 
@@ -1415,9 +1063,6 @@ async def timeout_dur(
 __all__ = [
     "EnhancedQueue",
     "EnhancedTaskGroup",
-    "InfiniteLooper",
-    "InfiniteLooperError",
-    "InfiniteQueueLooper",
     "Looper",
     "LooperError",
     "StreamCommandOutput",

utilities/datetime.py

@@ -509,14 +509,6 @@ def get_datetime(*, datetime: MaybeCallableDateTime) -> dt.datetime: ...
 def get_datetime(*, datetime: None) -> None: ...
 @overload
 def get_datetime(*, datetime: Sentinel) -> Sentinel: ...
-@overload
-def get_datetime(
-    *, datetime: MaybeCallableDateTime | Sentinel
-) -> dt.datetime | Sentinel: ...
-@overload
-def get_datetime(
-    *, datetime: MaybeCallableDateTime | None | Sentinel = sentinel
-) -> dt.datetime | None | Sentinel: ...
 def get_datetime(
     *, datetime: MaybeCallableDateTime | None | Sentinel = sentinel
 ) -> dt.datetime | None | Sentinel:

utilities/fastapi.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
+from asyncio import Task, create_task
 from dataclasses import InitVar, dataclass, field
-from typing import TYPE_CHECKING, Any, Literal, override
+from typing import TYPE_CHECKING, Any, Literal, Self, override
 
 from fastapi import FastAPI
 from uvicorn import Config, Server
 
-from utilities.asyncio import InfiniteLooper
+from utilities.asyncio import Looper
 from utilities.datetime import SECOND, datetime_duration_to_float
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     from utilities.types import Duration
 
 
@@ -36,7 +39,7 @@ class _PingerReceiverApp(FastAPI):
 
 
 @dataclass(kw_only=True)
-class PingReceiver(InfiniteLooper):
+class PingReceiver(Looper[None]):
     """A ping receiver."""
 
     host: InitVar[str] = _LOCALHOST
@@ -44,12 +47,31 @@ class PingReceiver(InfiniteLooper):
     _app: _PingerReceiverApp = field(
         default_factory=_PingerReceiverApp, init=False, repr=False
     )
-    _await_upon_aenter: bool = field(default=False, init=False, repr=False)
     _server: Server = field(init=False, repr=False)
+    _server_task: Task[None] | None = field(default=None, init=False, repr=False)
 
+    @override
     def __post_init__(self, host: str, port: int, /) -> None:
+        super().__post_init__()  # skipif-ci
         self._server = Server(Config(self._app, host=host, port=port))  # skipif-ci
 
+    @override
+    async def __aenter__(self) -> Self:
+        _ = await super().__aenter__()  # skipif-ci
+        async with self._lock:  # skipif-ci
+            self._server_task = create_task(self._server.serve())
+        return self  # skipif-ci
+
+    @override
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        await super().__aexit__(exc_type, exc_value, traceback)  # skipif-ci
+        await self._server.shutdown()  # skipif-ci
+
     @classmethod
     async def ping(
         cls, port: int, /, *, host: str = _LOCALHOST, timeout: Duration = _TIMEOUT
@@ -66,13 +88,5 @@ class PingReceiver(InfiniteLooper):
             return False
         return response.text if response.status_code == 200 else False  # skipif-ci
 
-    @override
-    async def _initialize(self) -> None:
-        await self._server.serve()  # skipif-ci
-
-    @override
-    async def _teardown(self) -> None:
-        await self._server.shutdown()  # skipif-ci
-
 
 __all__ = ["PingReceiver"]

utilities/hypothesis.py

@@ -506,13 +506,7 @@ def floats_extra(
 
 
 @composite
-def git_repos(
-    draw: DrawFn,
-    /,
-    *,
-    branch: MaybeSearchStrategy[str | None] = None,
-    remote: MaybeSearchStrategy[str | None] = None,
-) -> Path:
+def git_repos(draw: DrawFn, /) -> Path:
     path = draw(temp_paths())
     with temp_cwd(path):
         _ = check_call(["git", "init", "-b", "master"])
@@ -525,10 +519,6 @@ def git_repos(
         _ = check_call(["git", "commit", "-m", "add"])
         _ = check_call(["git", "rm", file_str])
         _ = check_call(["git", "commit", "-m", "rm"])
-        if (branch_ := draw2(draw, branch)) is not None:
-            _ = check_call(["git", "checkout", "-b", branch_])
-        if (remote_ := draw2(draw, remote)) is not None:
-            _ = check_call(["git", "remote", "add", "origin", remote_])
     return path
 
 

utilities/logging.py

@@ -46,9 +46,8 @@ from utilities.datetime import (
     serialize_compact,
 )
 from utilities.errors import ImpossibleCaseError
-from utilities.git import get_repo_root
 from utilities.iterables import OneEmptyError, always_iterable, one
-from utilities.pathlib import ensure_suffix, resolve_path
+from utilities.pathlib import ensure_suffix, get_path, get_root
 from utilities.reprlib import (
     RICH_EXPAND_ALL,
     RICH_INDENT_SIZE,
@@ -68,9 +67,9 @@ if TYPE_CHECKING:
     from utilities.types import (
         LoggerOrName,
         LogLevel,
+        MaybeCallablePathLike,
         MaybeIterable,
         PathLike,
-        PathLikeOrCallable,
     )
     from utilities.version import MaybeCallableVersionLike
 
@@ -383,10 +382,10 @@ class StandaloneFileHandler(Handler):
 
     @override
     def __init__(
-        self, *, level: int = NOTSET, path: PathLikeOrCallable | None = None
+        self, *, level: int = NOTSET, path: MaybeCallablePathLike | None = None
     ) -> None:
         super().__init__(level=level)
-        self._path = path
+        self._path = get_path(path=path)
 
     @override
     def emit(self, record: LogRecord) -> None:
@@ -394,10 +393,8 @@ class StandaloneFileHandler(Handler):
         from utilities.tzlocal import get_now_local
 
         try:
-            path = (
-                resolve_path(path=self._path)
-                .joinpath(serialize_compact(get_now_local()))
-                .with_suffix(".txt")
+            path = self._path.joinpath(serialize_compact(get_now_local())).with_suffix(
+                ".txt"
             )
             formatted = self.format(record)
             with writer(path, overwrite=True) as temp, temp.open(mode="w") as fh:
@@ -473,7 +470,7 @@ class FilterForKeyError(Exception):
 
 def get_default_logging_path() -> Path:
     """Get the logging default path."""
-    return get_repo_root().joinpath(".logs")
+    return get_root().joinpath(".logs")
 
 
 ##
@@ -520,7 +517,7 @@ def setup_logging(
     console_level: LogLevel | None = "INFO",
     console_filters: Iterable[_FilterType] | None = None,
     console_fmt: str = "❯ {_zoned_datetime_str} | {name}:{funcName}:{lineno} | {message}",  # noqa: RUF001
-    files_dir: PathLikeOrCallable | None = get_default_logging_path,
+    files_dir: MaybeCallablePathLike | None = get_default_logging_path,
     files_when: _When = "D",
     files_interval: int = 1,
     files_backup_count: int = 10,
@@ -616,7 +613,7 @@ def setup_logging(
         logger_use.addHandler(console_high_and_exc_handler)
 
     # debug & info
-    directory = resolve_path(path=files_dir)  # skipif-ci-and-windows
+    directory = get_path(path=files_dir)  # skipif-ci-and-windows
     levels: list[LogLevel] = ["DEBUG", "INFO"]  # skipif-ci-and-windows
     for level, (subpath, files_or_plain_formatter) in product(  # skipif-ci-and-windows
         levels, [(Path(), files_formatter), (Path("plain"), plain_formatter)]

utilities/pathlib.py

@@ -1,15 +1,21 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
+from collections.abc import Callable
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass
 from itertools import chain
 from os import chdir
 from pathlib import Path
-from typing import TYPE_CHECKING
+from re import IGNORECASE, search
+from subprocess import PIPE, CalledProcessError, check_output
+from typing import TYPE_CHECKING, assert_never, overload, override
+
+from utilities.sentinel import Sentinel, sentinel
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
 
-    from utilities.types import PathLike, PathLikeOrCallable
+    from utilities.types import MaybeCallablePathLike, PathLike
 
 PWD = Path.cwd()
 
@@ -25,20 +31,73 @@ def ensure_suffix(path: PathLike, suffix: str, /) -> Path:
     return path.with_name(name)
 
 
-def list_dir(path: PathLike, /) -> Sequence[Path]:
-    """List the contents of a directory."""
-    return sorted(Path(path).iterdir())
+##
 
 
-def resolve_path(*, path: PathLikeOrCallable | None = None) -> Path:
-    """Resolve for a path."""
+@overload
+def get_path(*, path: MaybeCallablePathLike | None) -> Path: ...
+@overload
+def get_path(*, path: Sentinel) -> Sentinel: ...
+def get_path(
+    *, path: MaybeCallablePathLike | None | Sentinel = sentinel
+) -> Path | None | Sentinel:
+    """Get the path."""
     match path:
+        case Path() | Sentinel():
+            return path
+        case str():
+            return Path(path)
         case None:
             return Path.cwd()
-        case Path() | str():
-            return Path(path)
-        case _:
-            return Path(path())
+        case Callable() as func:
+            return get_path(path=func())
+        case _ as never:
+            assert_never(never)
+
+
+##
+
+
+def get_root(*, path: MaybeCallablePathLike | None = None) -> Path:
+    """Get the root of a path."""
+    path = get_path(path=path)
+    try:
+        output = check_output(
+            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=path, text=True
+        )
+    except CalledProcessError as error:
+        # newer versions of git report "Not a git repository", whilst older
+        # versions report "not a git repository"
+        if not search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
+            raise  # pragma: no cover
+    else:
+        return Path(output.strip("\n"))
+    all_paths = list(chain([path], path.parents))
+    with suppress(StopIteration):
+        return next(
+            p for p in all_paths if any(p_i.name == ".envrc" for p_i in p.iterdir())
+        )
+    raise GetRootError(path=path)
+
+
+@dataclass(kw_only=True, slots=True)
+class GetRootError(Exception):
+    path: PathLike
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to determine root from {str(self.path)!r}"
+
+
+##
+
+
+def list_dir(path: PathLike, /) -> Sequence[Path]:
+    """List the contents of a directory."""
+    return sorted(Path(path).iterdir())
+
+
+##
 
 
 @contextmanager
@@ -52,4 +111,4 @@ def temp_cwd(path: PathLike, /) -> Iterator[None]:
         chdir(prev)
 
 
-__all__ = ["ensure_suffix", "list_dir", "resolve_path", "temp_cwd"]
+__all__ = ["PWD", "ensure_suffix", "get_path", "list_dir", "temp_cwd"]

utilities/pyinstrument.py

@@ -7,23 +7,25 @@ from typing import TYPE_CHECKING
 from pyinstrument.profiler import Profiler
 
 from utilities.datetime import serialize_compact
-from utilities.pathlib import PWD
+from utilities.pathlib import get_path
 from utilities.tzlocal import get_now_local
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from utilities.types import PathLike
+    from utilities.types import MaybeCallablePathLike
 
 
 @contextmanager
-def profile(*, path: PathLike = PWD) -> Iterator[None]:
+def profile(*, path: MaybeCallablePathLike | None = Path.cwd) -> Iterator[None]:
     """Profile the contents of a block."""
     from utilities.atomicwrites import writer
 
     with Profiler() as profiler:
         yield
-    filename = Path(path, f"profile__{serialize_compact(get_now_local())}.html")
+    filename = get_path(path=path).joinpath(
+        f"profile__{serialize_compact(get_now_local())}.html"
+    )
     with writer(filename) as temp, temp.open(mode="w") as fh:
         _ = fh.write(profiler.output_html())
 

utilities/pytest_regressions.py

@@ -10,8 +10,8 @@ from pytest import fixture
 from pytest_regressions.file_regression import FileRegressionFixture
 
 from utilities.functions import ensure_str
-from utilities.git import get_repo_root
 from utilities.operator import is_equal
+from utilities.pathlib import get_root
 from utilities.pytest import node_id_to_path
 
 if TYPE_CHECKING:
@@ -153,7 +153,7 @@ def polars_regression(
 
 def _get_path(request: FixtureRequest, /) -> Path:
     tail = node_id_to_path(request.node.nodeid, head=_PATH_TESTS)
-    return get_repo_root().joinpath(_PATH_TESTS, "regressions", tail)
+    return get_root().joinpath(_PATH_TESTS, "regressions", tail)
 
 
 __all__ = [

utilities/python_dotenv.py

@@ -2,29 +2,33 @@ 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.git import get_repo_root
 from utilities.iterables import MergeStrMappingsError, merge_str_mappings
-from utilities.pathlib import PWD
+from utilities.pathlib import get_root
 from utilities.reprlib import get_repr
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
     from collections.abc import Set as AbstractSet
-    from pathlib import Path
 
-    from utilities.types import ParseObjectExtra, PathLike, StrMapping, TDataclass
+    from utilities.types import (
+        MaybeCallablePathLike,
+        ParseObjectExtra,
+        StrMapping,
+        TDataclass,
+    )
 
 
 def load_settings(
     cls: type[TDataclass],
     /,
     *,
-    cwd: PathLike = PWD,
+    path: MaybeCallablePathLike | None = Path.cwd,
     globalns: StrMapping | None = None,
     localns: StrMapping | None = None,
     warn_name_errors: bool = False,
@@ -33,7 +37,7 @@ def load_settings(
     extra_parsers: ParseObjectExtra | None = None,
 ) -> TDataclass:
     """Load a set of settings from the `.env` file."""
-    path = get_repo_root(cwd=cwd).joinpath(".env")
+    path = get_root(path=path).joinpath(".env")
     if not path.exists():
         raise _LoadSettingsFileNotFoundError(path=path) from None
     maybe_values_dotenv = dotenv_values(path)

utilities/redis.py

@@ -23,9 +23,8 @@ from typing import (
 )
 
 from redis.asyncio import Redis
-from redis.typing import EncodableT
 
-from utilities.asyncio import EnhancedQueue, InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import EnhancedQueue, Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import (
     MILLISECOND,
@@ -34,7 +33,7 @@ from utilities.datetime import (
     datetime_duration_to_timedelta,
 )
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_int, get_class_name, identity
+from utilities.functions import ensure_int, identity
 from utilities.iterables import always_iterable, one
 from utilities.orjson import deserialize, serialize
 
@@ -51,10 +50,10 @@ if TYPE_CHECKING:
 
     from redis.asyncio import ConnectionPool
     from redis.asyncio.client import PubSub
-    from redis.typing import ResponseT
+    from redis.typing import EncodableT, ResponseT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import Duration, MaybeType, TypeLike
+    from utilities.types import Duration, TypeLike
 
 
 _K = TypeVar("_K")
@@ -620,42 +619,6 @@ class PublishError(Exception):
 ##
 
 
-@dataclass(kw_only=True)
-class Publisher(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
-    """Publish a set of messages to Redis."""
-
-    redis: Redis
-    serializer: Callable[[Any], EncodableT] | None = None
-    timeout: Duration = _PUBLISH_TIMEOUT
-
-    @override
-    async def _process_queue(self) -> None:
-        for item in self._queue.get_all_nowait():  # skipif-ci-and-not-linux
-            channel, data = item
-            _ = await publish(
-                self.redis,
-                channel,
-                data,
-                serializer=self.serializer,
-                timeout=self.timeout,
-            )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, PublisherError)  # skipif-ci-and-not-linux
-
-
-@dataclass(kw_only=True)
-class PublisherError(Exception):
-    publisher: Publisher
-
-    @override
-    def __str__(self) -> str:
-        return f"Error running {get_class_name(self.publisher)!r}"  # skipif-ci-and-not-linux
-
-
 @dataclass(kw_only=True)
 class PublishService(Looper[tuple[str, _T]]):
     """Service to publish items to Redis."""
@@ -1095,8 +1058,6 @@ def _deserialize(
 __all__ = [
     "PublishService",
     "PublishServiceMixin",
-    "Publisher",
-    "PublisherError",
     "RedisHashMapKey",
     "RedisKey",
     "SubscribeService",

utilities/slack_sdk.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Self, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -27,53 +27,10 @@ _TIMEOUT: Duration = MINUTE
 ##
 
 
-_SLEEP: Duration = SECOND
-
-
 async def _send_adapter(url: str, text: str, /) -> None:
     await send_to_slack(url, text)  # pragma: no cover
 
 
-@dataclass(init=False, unsafe_hash=True)
-class SlackHandler(Handler, InfiniteQueueLooper[None, str]):
-    """Handler for sending messages to Slack."""
-
-    @override
-    def __init__(
-        self,
-        url: str,
-        /,
-        *,
-        level: int = NOTSET,
-        sleep_core: Duration = _SLEEP,
-        sleep_restart: Duration = _SLEEP,
-        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        timeout: Duration = _TIMEOUT,
-    ) -> None:
-        InfiniteQueueLooper.__init__(self)  # InfiniteQueueLooper first
-        InfiniteQueueLooper.__post_init__(self)
-        Handler.__init__(self, level=level)  # Handler next
-        self.url = url
-        self.sender = sender
-        self.timeout = timeout
-        self.sleep_core = sleep_core
-        self.sleep_restart = sleep_restart
-
-    @override
-    def emit(self, record: LogRecord) -> None:
-        try:
-            self.put_right_nowait(self.format(record))
-        except Exception:  # noqa: BLE001  # pragma: no cover
-            self.handleError(record)
-
-    @override
-    async def _process_queue(self) -> None:
-        messages = self._queue.get_all_nowait()
-        text = "\n".join(messages)
-        async with timeout_dur(duration=self.timeout):
-            await self.sender(self.url, text)
-
-
 @dataclass(init=False, unsafe_hash=True)
 class SlackHandlerService(Handler, Looper[str]):
     """Service to send messages to Slack."""
@@ -187,4 +144,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerService", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandlerService", "send_to_slack"]

utilities/sqlalchemy.py

@@ -57,7 +57,7 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import SECOND
 from utilities.functions import (
@@ -82,13 +82,7 @@ from utilities.iterables import (
 )
 from utilities.reprlib import get_repr
 from utilities.text import snake_case
-from utilities.types import (
-    Duration,
-    MaybeIterable,
-    MaybeType,
-    StrMapping,
-    TupleOrStrMapping,
-)
+from utilities.types import Duration, MaybeIterable, StrMapping, TupleOrStrMapping
 
 _T = TypeVar("_T")
 type _EngineOrConnectionOrAsync = Engine | Connection | AsyncEngine | AsyncConnection
@@ -610,52 +604,6 @@ class TablenameMixin:
 ##
 
 
-@dataclass(kw_only=True)
-class Upserter(InfiniteQueueLooper[None, _InsertItem]):
-    """Upsert a set of items to a database."""
-
-    engine: AsyncEngine
-    snake: bool = False
-    selected_or_all: _SelectedOrAll = "selected"
-    chunk_size_frac: float = CHUNK_SIZE_FRAC
-    assume_tables_exist: bool = False
-    timeout_create: Duration | None = None
-    error_create: type[Exception] = TimeoutError
-    timeout_insert: Duration | None = None
-    error_insert: type[Exception] = TimeoutError
-
-    @override
-    async def _process_queue(self) -> None:
-        items = self._queue.get_all_nowait()
-        await upsert_items(
-            self.engine,
-            *items,
-            snake=self.snake,
-            selected_or_all=self.selected_or_all,
-            chunk_size_frac=self.chunk_size_frac,
-            assume_tables_exist=self.assume_tables_exist,
-            timeout_create=self.timeout_create,
-            error_create=self.error_create,
-            timeout_insert=self.timeout_insert,
-            error_insert=self.error_insert,
-        )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, UpserterError)
-
-
-@dataclass(kw_only=True)
-class UpserterError(Exception):
-    upserter: Upserter
-
-    @override
-    def __str__(self) -> str:
-        return f"Error running {get_class_name(self.upserter)!r}"
-
-
 @dataclass(kw_only=True)
 class UpsertService(Looper[_InsertItem]):
     """Service to upsert items to a database."""
@@ -1202,8 +1150,6 @@ __all__ = [
     "UpsertItemsError",
     "UpsertService",
     "UpsertServiceMixin",
-    "Upserter",
-    "UpserterError",
     "check_engine",
     "columnwise_max",
     "columnwise_min",

utilities/types.py

@@ -241,8 +241,8 @@ type SerializeObjectExtra = Mapping[Any, Callable[[Any], str]]
 
 
 # pathlib
+type MaybeCallablePathLike = MaybeCallable[PathLike]
 type PathLike = MaybeStr[Path]
-type PathLikeOrCallable = PathLike | Callable[[], PathLike]
 
 
 # random
@@ -282,6 +282,7 @@ __all__ = [
     "MaybeCallableDate",
     "MaybeCallableDateTime",
     "MaybeCallableEvent",
+    "MaybeCallablePathLike",
     "MaybeCoroutine1",
     "MaybeIterable",
     "MaybeIterableHashable",
@@ -293,7 +294,6 @@ __all__ = [
     "Parallelism",
     "ParseObjectExtra",
     "PathLike",
-    "PathLikeOrCallable",
     "RoundMode",
     "Seed",
     "SerializeObjectExtra",

utilities/version.py

@@ -137,14 +137,6 @@ def get_version(*, version: MaybeCallableVersionLike) -> Version: ...
 def get_version(*, version: None) -> None: ...
 @overload
 def get_version(*, version: Sentinel) -> Sentinel: ...
-@overload
-def get_version(
-    *, version: MaybeCallableVersionLike | Sentinel
-) -> Version | Sentinel: ...
-@overload
-def get_version(
-    *, version: MaybeCallableVersionLike | None | Sentinel = sentinel
-) -> Version | None | Sentinel: ...
 def get_version(
     *, version: MaybeCallableVersionLike | None | Sentinel = sentinel
 ) -> Version | None | Sentinel:

utilities/git.py

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-from re import IGNORECASE, search
-from subprocess import PIPE, CalledProcessError, check_call, check_output
-from typing import TYPE_CHECKING, override
-
-from utilities.pathlib import PWD
-
-if TYPE_CHECKING:
-    from utilities.types import PathLike
-
-
-def fetch_all_tags(*, cwd: PathLike = PWD) -> None:
-    """Fetch the tags."""
-    _ = check_call(["git", "fetch", "--all", "--tags"], cwd=cwd)
-
-
-##
-
-
-def get_branch_name(*, cwd: PathLike = PWD) -> str:
-    """Get the current branch name."""
-    output = check_output(
-        _GIT_REV_PARSE_ABBREV_REV_HEAD, stderr=PIPE, cwd=cwd, text=True
-    )
-    return output.strip("\n")
-
-
-_GIT_REV_PARSE_ABBREV_REV_HEAD = ["git", "rev-parse", "--abbrev-ref", "HEAD"]
-
-
-##
-
-
-def get_ref_tags(ref: str, /, *, cwd: PathLike = PWD) -> list[str]:
-    """Get the tags of a reference."""
-    output = check_output([*_GIT_TAG_POINTS_AT, ref], stderr=PIPE, cwd=cwd, text=True)
-    return output.strip("\n").splitlines()
-
-
-_GIT_TAG_POINTS_AT = ["git", "tag", "--points-at"]
-
-
-##
-
-
-def get_repo_name(*, cwd: PathLike = PWD) -> str:
-    """Get the repo name."""
-    output = check_output(_GIT_REMOTE_GET_URL_ORIGIN, stderr=PIPE, cwd=cwd, text=True)
-    return Path(output.strip("\n")).stem  # not valid_path
-
-
-_GIT_REMOTE_GET_URL_ORIGIN = ["git", "remote", "get-url", "origin"]
-
-
-##
-
-
-def get_repo_root(*, cwd: PathLike = PWD) -> Path:
-    """Get the repo root."""
-    try:
-        output = check_output(
-            ["git", "rev-parse", "--show-toplevel"], stderr=PIPE, cwd=cwd, text=True
-        )
-    except CalledProcessError as error:
-        # newer versions of git report "Not a git repository", whilst older
-        # versions report "not a git repository"
-        if search("fatal: not a git repository", error.stderr, flags=IGNORECASE):
-            raise GetRepoRootError(cwd=cwd) from error
-        raise  # pragma: no cover
-    else:
-        return Path(output.strip("\n"))
-
-
-@dataclass(kw_only=True, slots=True)
-class GetRepoRootError(Exception):
-    cwd: PathLike
-
-    @override
-    def __str__(self) -> str:
-        return f"Path is not part of a `git` repository: {self.cwd}"
-
-
-__all__ = [
-    "GetRepoRootError",
-    "fetch_all_tags",
-    "get_branch_name",
-    "get_ref_tags",
-    "get_repo_name",
-    "get_repo_root",
-]