dycw-utilities 0.146.2__py3-none-any.whl → 0.178.1__py3-none-any.whl

utilities/eventkit.py

@@ -1,388 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from functools import wraps
-from inspect import iscoroutinefunction
-from typing import TYPE_CHECKING, Any, Self, assert_never, cast, override
-
-from eventkit import (
-    Constant,
-    Count,
-    DropWhile,
-    Enumerate,
-    Event,
-    Filter,
-    Fork,
-    Iterate,
-    Map,
-    Pack,
-    Partial,
-    PartialRight,
-    Pluck,
-    Skip,
-    Star,
-    Take,
-    TakeUntil,
-    TakeWhile,
-    Timestamp,
-)
-
-from utilities.functions import apply_decorators
-from utilities.iterables import always_iterable
-from utilities.logging import get_logger
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from utilities.types import Coro, LoggerOrName, MaybeCoro, MaybeIterable, TypeLike
-
-
-##
-
-
-def add_listener[E: Event, F: Callable](
-    event: E,
-    listener: Callable[..., MaybeCoro[None]],
-    /,
-    *,
-    error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
-    ignore: TypeLike[BaseException] | None = None,
-    logger: LoggerOrName | None = None,
-    decorators: MaybeIterable[Callable[[F], F]] | None = None,
-    done: Callable[..., MaybeCoro[None]] | None = None,
-    keep_ref: bool = False,
-) -> E:
-    """Connect a listener to an event."""
-    lifted = lift_listener(
-        listener,
-        event,
-        error=error,
-        ignore=ignore,
-        logger=logger,
-        decorators=decorators,
-    )
-    return cast("E", event.connect(lifted, done=done, keep_ref=keep_ref))
-
-
-##
-
-
-@dataclass(repr=False, kw_only=True)
-class LiftedEvent[F: Callable[..., MaybeCoro[None]]]:
-    """A lifted version of `Event`."""
-
-    event: Event
-
-    def name(self) -> str:
-        return self.event.name()  # pragma: no cover
-
-    def done(self) -> bool:
-        return self.event.done()  # pragma: no cover
-
-    def set_done(self) -> None:
-        self.event.set_done()  # pragma: no cover
-
-    def value(self) -> Any:
-        return self.event.value()  # pragma: no cover
-
-    def connect[F2: Callable](
-        self,
-        listener: F,
-        /,
-        *,
-        error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
-        ignore: TypeLike[BaseException] | None = None,
-        logger: LoggerOrName | None = None,
-        decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
-        done: Callable[..., MaybeCoro[None]] | None = None,
-        keep_ref: bool = False,
-    ) -> Event:
-        return add_listener(
-            self.event,
-            listener,
-            error=error,
-            ignore=ignore,
-            logger=logger,
-            decorators=decorators,
-            done=done,
-            keep_ref=keep_ref,
-        )
-
-    def disconnect(
-        self, listener: Any, /, *, error: Any = None, done: Any = None
-    ) -> Any:
-        return self.event.disconnect(  # pragma: no cover
-            listener, error=error, done=done
-        )
-
-    def disconnect_obj(self, obj: Any, /) -> None:
-        self.event.disconnect_obj(obj)  # pragma: no cover
-
-    def emit(self, *args: Any) -> None:
-        self.event.emit(*args)  # pragma: no cover
-
-    def emit_threadsafe(self, *args: Any) -> None:
-        self.event.emit_threadsafe(*args)  # pragma: no cover
-
-    def clear(self) -> None:
-        self.event.clear()  # pragma: no cover
-
-    def run(self) -> list[Any]:
-        return self.event.run()  # pragma: no cover
-
-    def pipe(self, *targets: Event) -> Event:
-        return self.event.pipe(*targets)  # pragma: no cover
-
-    def fork(self, *targets: Event) -> Fork:
-        return self.event.fork(*targets)  # pragma: no cover
-
-    def set_source(self, source: Any, /) -> None:
-        self.event.set_source(source)  # pragma: no cover
-
-    def _onFinalize(self, ref: Any) -> None:  # noqa: N802
-        self.event._onFinalize(ref)  # noqa: SLF001 # pragma: no cover
-
-    async def aiter(self, *, skip_to_last: bool = False, tuples: bool = False) -> Any:
-        async for i in self.event.aiter(  # pragma: no cover
-            skip_to_last=skip_to_last, tuples=tuples
-        ):
-            yield i
-
-    __iadd__ = connect
-    __isub__ = disconnect
-    __call__ = emit
-    __or__ = pipe
-
-    @override
-    def __repr__(self) -> str:
-        return self.event.__repr__()  # pragma: no cover
-
-    def __len__(self) -> int:
-        return self.event.__len__()  # pragma: no cover
-
-    def __bool__(self) -> bool:
-        return self.event.__bool__()  # pragma: no cover
-
-    def __getitem__(self, fork_targets: Any, /) -> Fork:
-        return self.event.__getitem__(fork_targets)  # pragma: no cover
-
-    def __await__(self) -> Any:
-        return self.event.__await__()  # pragma: no cover
-
-    __aiter__ = aiter
-
-    def __contains__(self, c: Any, /) -> bool:
-        return self.event.__contains__(c)  # pragma: no cover
-
-    @override
-    def __reduce__(self) -> Any:
-        return self.event.__reduce__()  # pragma: no cover
-
-    def filter(self, *, predicate: Any = bool) -> Filter:
-        return self.event.filter(predicate=predicate)  # pragma: no cover
-
-    def skip(self, *, count: int = 1) -> Skip:
-        return self.event.skip(count=count)  # pragma: no cover
-
-    def take(self, *, count: int = 1) -> Take:
-        return self.event.take(count=count)  # pragma: no cover
-
-    def takewhile(self, *, predicate: Any = bool) -> TakeWhile:
-        return self.event.takewhile(predicate=predicate)  # pragma: no cover
-
-    def dropwhile(self, *, predicate: Any = lambda x: not x) -> DropWhile:  # pyright: ignore[reportUnknownLambdaType]
-        return self.event.dropwhile(predicate=predicate)  # pragma: no cover
-
-    def takeuntil(self, notifier: Event, /) -> TakeUntil:
-        return self.event.takeuntil(notifier)  # pragma: no cover
-
-    def constant(self, constant: Any, /) -> Constant:
-        return self.event.constant(constant)  # pragma: no cover
-
-    def iterate(self, it: Any, /) -> Iterate:
-        return self.event.iterate(it)  # pragma: no cover
-
-    def count(self, *, start: int = 0, step: int = 1) -> Count:
-        return self.event.count(start=start, step=step)  # pragma: no cover
-
-    def enumerate(self, *, start: int = 0, step: int = 1) -> Enumerate:
-        return self.event.enumerate(start=start, step=step)  # pragma: no cover
-
-    def timestamp(self) -> Timestamp:
-        return self.event.timestamp()  # pragma: no cover
-
-    def partial(self, *left_args: Any) -> Partial:
-        return self.event.partial(*left_args)  # pragma: no cover
-
-    def partial_right(self, *right_args: Any) -> PartialRight:
-        return self.event.partial_right(*right_args)  # pragma: no cover
-
-    def star(self) -> Star:
-        return self.event.star()  # pragma: no cover
-
-    def pack(self) -> Pack:
-        return self.event.pack()  # pragma: no cover
-
-    def pluck(self, *selections: int | str) -> Pluck:
-        return self.event.pluck(*selections)  # pragma: no cover
-
-    def map(
-        self,
-        func: Any,
-        /,
-        *,
-        timeout: float | None = None,
-        ordered: bool = True,
-        task_limit: int | None = None,
-    ) -> Map:
-        return self.event.map(  # pragma: no cover
-            func, timeout=timeout, ordered=ordered, task_limit=task_limit
-        )
-
-
-##
-
-
-class TypedEvent[F: Callable[..., MaybeCoro[None]]](Event):
-    """A typed version of `Event`."""
-
-    @override
-    def connect[F2: Callable](
-        self,
-        listener: F,
-        error: Callable[[Self, BaseException], MaybeCoro[None]] | None = None,
-        done: Callable[[Self], MaybeCoro[None]] | None = None,
-        keep_ref: bool = False,
-        *,
-        ignore: TypeLike[BaseException] | None = None,
-        logger: LoggerOrName | None = None,
-        decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
-    ) -> Self:
-        lifted = lift_listener(
-            listener,
-            self,
-            error=cast(
-                "Callable[[Event, BaseException], MaybeCoro[None]] | None", error
-            ),
-            ignore=ignore,
-            logger=logger,
-            decorators=decorators,
-        )
-        return cast(
-            "Self", super().connect(lifted, error=error, done=done, keep_ref=keep_ref)
-        )
-
-
-##
-
-
-def lift_listener[F1: Callable[..., MaybeCoro[None]], F2: Callable](
-    listener: F1,
-    event: Event,
-    /,
-    *,
-    error: Callable[[Event, BaseException], MaybeCoro[None]] | None = None,
-    ignore: TypeLike[BaseException] | None = None,
-    logger: LoggerOrName | None = None,
-    decorators: MaybeIterable[Callable[[F2], F2]] | None = None,
-) -> F1:
-    match error, bool(iscoroutinefunction(listener)):
-        case None, False:
-            listener_typed = cast("Callable[..., None]", listener)
-
-            @wraps(listener)
-            def listener_no_error_sync(*args: Any, **kwargs: Any) -> None:
-                try:
-                    listener_typed(*args, **kwargs)
-                except Exception as exc:  # noqa: BLE001
-                    if (ignore is not None) and isinstance(exc, ignore):
-                        return
-                    get_logger(logger=logger).exception("")
-
-            lifted = listener_no_error_sync
-
-        case None, True:
-            listener_typed = cast("Callable[..., Coro[None]]", listener)
-
-            @wraps(listener)
-            async def listener_no_error_async(*args: Any, **kwargs: Any) -> None:
-                try:
-                    await listener_typed(*args, **kwargs)
-                except Exception as exc:  # noqa: BLE001
-                    if (ignore is not None) and isinstance(exc, ignore):
-                        return
-                    get_logger(logger=logger).exception("")
-
-            lifted = listener_no_error_async
-        case _, _:
-            match bool(iscoroutinefunction(listener)), bool(iscoroutinefunction(error)):
-                case False, False:
-                    listener_typed = cast("Callable[..., None]", listener)
-                    error_typed = cast("Callable[[Event, Exception], None]", error)
-
-                    @wraps(listener)
-                    def listener_have_error_sync(*args: Any, **kwargs: Any) -> None:
-                        try:
-                            listener_typed(*args, **kwargs)
-                        except Exception as exc:  # noqa: BLE001
-                            if (ignore is not None) and isinstance(exc, ignore):
-                                return
-                            error_typed(event, exc)
-
-                    lifted = listener_have_error_sync
-                case False, True:
-                    listener_typed = cast("Callable[..., None]", listener)
-                    error_typed = cast(
-                        "Callable[[Event, Exception], Coro[None]]", error
-                    )
-                    raise LiftListenerError(listener=listener_typed, error=error_typed)
-                case True, _:
-                    listener_typed = cast("Callable[..., Coro[None]]", listener)
-
-                    @wraps(listener)
-                    async def listener_have_error_async(
-                        *args: Any, **kwargs: Any
-                    ) -> None:
-                        try:
-                            await listener_typed(*args, **kwargs)
-                        except Exception as exc:  # noqa: BLE001
-                            if (ignore is not None) and isinstance(exc, ignore):
-                                return None
-                            if iscoroutinefunction(error):
-                                error_typed = cast(
-                                    "Callable[[Event, Exception], Coro[None]]", error
-                                )
-                                return await error_typed(event, exc)
-                            error_typed = cast(
-                                "Callable[[Event, Exception], None]", error
-                            )
-                            error_typed(event, exc)
-
-                    lifted = listener_have_error_async
-                case _ as never:
-                    assert_never(never)
-        case _ as never:
-            assert_never(never)
-
-    if decorators is not None:
-        lifted = apply_decorators(lifted, *always_iterable(decorators))
-    return cast("F1", lifted)
-
-
-@dataclass(kw_only=True, slots=True)
-class LiftListenerError(Exception):
-    listener: Callable[..., None]
-    error: Callable[[Event, Exception], Coro[None]]
-
-    @override
-    def __str__(self) -> str:
-        return f"Synchronous listener {self.listener} cannot be paired with an asynchronous error handler {self.error}"
-
-
-__all__ = [
-    "LiftListenerError",
-    "LiftedEvent",
-    "TypedEvent",
-    "add_listener",
-    "lift_listener",
-]

utilities/period.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Self, TypedDict, overload, override
-from zoneinfo import ZoneInfo
-
-from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
-
-from utilities.dataclasses import replace_non_sentinel
-from utilities.functions import get_class_name
-from utilities.sentinel import Sentinel, sentinel
-from utilities.whenever import format_compact
-from utilities.zoneinfo import get_time_zone_name
-
-if TYPE_CHECKING:
-    from utilities.types import TimeZoneLike
-
-
-class _PeriodAsDict[T: (Date, ZonedDateTime)](TypedDict):
-    start: T
-    end: T
-
-
-@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
-class DatePeriod:
-    """A period of dates."""
-
-    start: Date
-    end: Date
-
-    def __post_init__(self) -> None:
-        if self.start > self.end:
-            raise _PeriodInvalidError(start=self.start, end=self.end)
-
-    def __add__(self, other: DateDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start + other, end=self.end + other)
-
-    def __contains__(self, other: Date, /) -> bool:
-        """Check if a date/datetime lies in the period."""
-        return self.start <= other <= self.end
-
-    @override
-    def __repr__(self) -> str:
-        cls = get_class_name(self)
-        return f"{cls}({self.start}, {self.end})"
-
-    def __sub__(self, other: DateDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start - other, end=self.end - other)
-
-    @property
-    def delta(self) -> DateDelta:
-        """The delta of the period."""
-        return self.end - self.start
-
-    def format_compact(self) -> str:
-        """Format the period in a compact fashion."""
-        fc, start, end = format_compact, self.start, self.end
-        if self.start == self.end:
-            return f"{fc(start)}="
-        if self.start.year_month() == self.end.year_month():
-            return f"{fc(start)}-{fc(end, fmt='%d')}"
-        if self.start.year == self.end.year:
-            return f"{fc(start)}-{fc(end, fmt='%m%d')}"
-        return f"{fc(start)}-{fc(end)}"
-
-    def replace(
-        self, *, start: Date | Sentinel = sentinel, end: Date | Sentinel = sentinel
-    ) -> Self:
-        """Replace elements of the period."""
-        return replace_non_sentinel(self, start=start, end=end)
-
-    def to_dict(self) -> _PeriodAsDict[Date]:
-        """Convert the period to a dictionary."""
-        return _PeriodAsDict(start=self.start, end=self.end)
-
-
-@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
-class ZonedDateTimePeriod:
-    """A period of time."""
-
-    start: ZonedDateTime
-    end: ZonedDateTime
-
-    def __post_init__(self) -> None:
-        if self.start > self.end:
-            raise _PeriodInvalidError(start=self.start, end=self.end)
-        if self.start.tz != self.end.tz:
-            raise _PeriodTimeZoneError(
-                start=ZoneInfo(self.start.tz), end=ZoneInfo(self.end.tz)
-            )
-
-    def __add__(self, other: TimeDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start + other, end=self.end + other)
-
-    def __contains__(self, other: ZonedDateTime, /) -> bool:
-        """Check if a date/datetime lies in the period."""
-        return self.start <= other <= self.end
-
-    @override
-    def __repr__(self) -> str:
-        cls = get_class_name(self)
-        return f"{cls}({self.start.to_plain()}, {self.end.to_plain()}[{self.time_zone.key}])"
-
-    def __sub__(self, other: TimeDelta, /) -> Self:
-        """Offset the period."""
-        return self.replace(start=self.start - other, end=self.end - other)
-
-    @property
-    def delta(self) -> TimeDelta:
-        """The duration of the period."""
-        return self.end - self.start
-
-    @overload
-    def exact_eq(self, period: ZonedDateTimePeriod, /) -> bool: ...
-    @overload
-    def exact_eq(self, start: ZonedDateTime, end: ZonedDateTime, /) -> bool: ...
-    @overload
-    def exact_eq(
-        self, start: PlainDateTime, end: PlainDateTime, time_zone: ZoneInfo, /
-    ) -> bool: ...
-    def exact_eq(self, *args: Any) -> bool:
-        """Check if a period is exactly equal to another."""
-        if (len(args) == 1) and isinstance(args[0], ZonedDateTimePeriod):
-            return self.start.exact_eq(args[0].start) and self.end.exact_eq(args[0].end)
-        if (
-            (len(args) == 2)
-            and isinstance(args[0], ZonedDateTime)
-            and isinstance(args[1], ZonedDateTime)
-        ):
-            return self.exact_eq(ZonedDateTimePeriod(args[0], args[1]))
-        if (
-            (len(args) == 3)
-            and isinstance(args[0], PlainDateTime)
-            and isinstance(args[1], PlainDateTime)
-            and isinstance(args[2], ZoneInfo)
-        ):
-            return self.exact_eq(
-                ZonedDateTimePeriod(
-                    args[0].assume_tz(args[2].key), args[1].assume_tz(args[2].key)
-                )
-            )
-        raise _PeriodExactEqArgumentsError(args=args)
-
-    def format_compact(self) -> str:
-        """Format the period in a compact fashion."""
-        fc, start, end = format_compact, self.start, self.end
-        if start == end:
-            if end.second != 0:
-                return f"{fc(start)}="
-            if end.minute != 0:
-                return f"{fc(start, fmt='%Y%m%dT%H%M')}="
-            return f"{fc(start, fmt='%Y%m%dT%H')}="
-        if start.date() == end.date():
-            if end.second != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%H%M%S')}"
-            if end.minute != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%H%M')}"
-            return f"{fc(start.to_plain())}-{fc(end, fmt='%H')}"
-        if start.date().year_month() == end.date().year_month():
-            if end.second != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H%M%S')}"
-            if end.minute != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H%M')}"
-            return f"{fc(start.to_plain())}-{fc(end, fmt='%dT%H')}"
-        if start.year == end.year:
-            if end.second != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H%M%S')}"
-            if end.minute != 0:
-                return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H%M')}"
-            return f"{fc(start.to_plain())}-{fc(end, fmt='%m%dT%H')}"
-        if end.second != 0:
-            return f"{fc(start.to_plain())}-{fc(end)}"
-        if end.minute != 0:
-            return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H%M')}"
-        return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H')}"
-
-    def replace(
-        self,
-        *,
-        start: ZonedDateTime | Sentinel = sentinel,
-        end: ZonedDateTime | Sentinel = sentinel,
-    ) -> Self:
-        """Replace elements of the period."""
-        return replace_non_sentinel(self, start=start, end=end)
-
-    @property
-    def time_zone(self) -> ZoneInfo:
-        """The time zone of the period."""
-        return ZoneInfo(self.start.tz)
-
-    def to_dict(self) -> _PeriodAsDict[ZonedDateTime]:
-        """Convert the period to a dictionary."""
-        return _PeriodAsDict(start=self.start, end=self.end)
-
-    def to_tz(self, time_zone: TimeZoneLike, /) -> Self:
-        """Convert the time zone."""
-        tz = get_time_zone_name(time_zone)
-        return self.replace(start=self.start.to_tz(tz), end=self.end.to_tz(tz))
-
-
-@dataclass(kw_only=True, slots=True)
-class PeriodError(Exception): ...
-
-
-@dataclass(kw_only=True, slots=True)
-class _PeriodInvalidError[T: (Date, ZonedDateTime)](PeriodError):
-    start: T
-    end: T
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid period; got {self.start} > {self.end}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _PeriodTimeZoneError(PeriodError):
-    start: ZoneInfo
-    end: ZoneInfo
-
-    @override
-    def __str__(self) -> str:
-        return f"Period must contain exactly one time zone; got {self.start} and {self.end}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _PeriodExactEqArgumentsError(PeriodError):
-    args: tuple[Any, ...]
-
-    @override
-    def __str__(self) -> str:
-        return f"Invalid arguments; got {self.args}"
-
-
-__all__ = ["DatePeriod", "PeriodError", "ZonedDateTimePeriod"]