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

utilities/version.py

@@ -2,23 +2,152 @@ from __future__ import annotations
 
 import re
 from collections.abc import Callable
+from contextlib import suppress
 from dataclasses import dataclass, field, replace
 from functools import total_ordering
 from typing import Any, Self, assert_never, overload, override
 
-from utilities.sentinel import Sentinel
+from utilities.constants import Sentinel
 from utilities.types import MaybeCallable, MaybeStr
 
-type VersionLike = MaybeStr[Version]
-type MaybeCallableVersionLike = MaybeCallable[VersionLike]
+type Version2Like = MaybeStr[Version2]
+type Version3Like = MaybeStr[Version3]
+type Version2Or3 = Version2 | Version3
+type MaybeCallableVersion3Like = MaybeCallable[Version3Like]
 
 
 ##
 
 
+_PARSE_VERSION2_PATTERN = re.compile(r"^(\d+)\.(\d+)(?!\.\d)(?:-(\w+))?")
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+@total_ordering
+class Version2:
+    """A version identifier."""
+
+    major: int = 0
+    minor: int = 1
+    suffix: str | None = field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        if (self.major == 0) and (self.minor == 0):
+            raise _Version2ZeroError(major=self.major, minor=self.minor)
+        if self.major < 0:
+            raise _Version2NegativeMajorVersionError(major=self.major)
+        if self.minor < 0:
+            raise _Version2NegativeMinorVersionError(minor=self.minor)
+        if (self.suffix is not None) and (len(self.suffix) == 0):
+            raise _Version2EmptySuffixError(suffix=self.suffix)
+
+    def __le__(self, other: Any, /) -> bool:
+        if not isinstance(other, type(self)):
+            return NotImplemented
+        self_as_tuple = (
+            self.major,
+            self.minor,
+            "" if self.suffix is None else self.suffix,
+        )
+        other_as_tuple = (
+            other.major,
+            other.minor,
+            "" if other.suffix is None else other.suffix,
+        )
+        return self_as_tuple <= other_as_tuple
+
+    @override
+    def __repr__(self) -> str:
+        version = f"{self.major}.{self.minor}"
+        if self.suffix is not None:
+            version = f"{version}-{self.suffix}"
+        return version
+
+    @classmethod
+    def parse(cls, text: str, /) -> Self:
+        """Parse a string into a Version2 object."""
+        try:
+            ((major, minor, suffix),) = _PARSE_VERSION2_PATTERN.findall(text)
+        except ValueError:
+            raise _Version2ParseError(text=text) from None
+        return cls(int(major), int(minor), suffix=None if suffix == "" else suffix)
+
+    def bump_major(self) -> Self:
+        """Bump the major component."""
+        return type(self)(self.major + 1, 0)
+
+    def bump_minor(self) -> Self:
+        """Bump the minor component."""
+        return type(self)(self.major, self.minor + 1)
+
+    def version3(self, *, patch: int = 0) -> Version3:
+        """Convert to a Version3 object."""
+        return Version3(self.major, self.minor, patch, suffix=self.suffix)
+
+    def with_suffix(self, *, suffix: str | None = None) -> Self:
+        """Replace the suffix."""
+        return replace(self, suffix=suffix)
+
+
+@dataclass(kw_only=True, slots=True)
+class Version2Error(Exception): ...
+
+
+@dataclass(kw_only=True, slots=True)
+class _Version2ZeroError(Version2Error):
+    major: int
+    minor: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Version must be greater than zero; got {self.major}.{self.minor}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _Version2NegativeMajorVersionError(Version2Error):
+    major: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Major version must be non-negative; got {self.major}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _Version2NegativeMinorVersionError(Version2Error):
+    minor: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Minor version must be non-negative; got {self.minor}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _Version2EmptySuffixError(Version2Error):
+    suffix: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Suffix must be non-empty; got {self.suffix!r}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _Version2ParseError(Version2Error):
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse version; got {self.text!r}"
+
+
+##
+
+
+_PARSE_VERSION3_PATTERN = re.compile(r"^(\d+)\.(\d+)\.(\d+)(?:-(\w+))?")
+
+
 @dataclass(repr=False, frozen=True, slots=True)
 @total_ordering
-class Version:
+class Version3:
     """A version identifier."""
 
     major: int = 0
@@ -28,17 +157,17 @@ class Version:
 
     def __post_init__(self) -> None:
         if (self.major == 0) and (self.minor == 0) and (self.patch == 0):
-            raise _VersionZeroError(
+            raise _Version3ZeroError(
                 major=self.major, minor=self.minor, patch=self.patch
             )
         if self.major < 0:
-            raise _VersionNegativeMajorVersionError(major=self.major)
+            raise _Version3NegativeMajorVersionError(major=self.major)
         if self.minor < 0:
-            raise _VersionNegativeMinorVersionError(minor=self.minor)
+            raise _Version3NegativeMinorVersionError(minor=self.minor)
         if self.patch < 0:
-            raise _VersionNegativePatchVersionError(patch=self.patch)
+            raise _Version3NegativePatchVersionError(patch=self.patch)
         if (self.suffix is not None) and (len(self.suffix) == 0):
-            raise _VersionEmptySuffixError(suffix=self.suffix)
+            raise _Version3EmptySuffixError(suffix=self.suffix)
 
     def __le__(self, other: Any, /) -> bool:
         if not isinstance(other, type(self)):
@@ -64,25 +193,45 @@ class Version:
             version = f"{version}-{self.suffix}"
         return version
 
+    @classmethod
+    def parse(cls, text: str, /) -> Self:
+        """Parse a string into a Version3 object."""
+        try:
+            ((major, minor, patch, suffix),) = _PARSE_VERSION3_PATTERN.findall(text)
+        except ValueError:
+            raise _Version3ParseError(text=text) from None
+        return cls(
+            int(major), int(minor), int(patch), suffix=None if suffix == "" else suffix
+        )
+
     def bump_major(self) -> Self:
+        """Bump the major component."""
         return type(self)(self.major + 1, 0, 0)
 
     def bump_minor(self) -> Self:
+        """Bump the minor component."""
         return type(self)(self.major, self.minor + 1, 0)
 
     def bump_patch(self) -> Self:
+        """Bump the patch component."""
         return type(self)(self.major, self.minor, self.patch + 1)
 
+    @property
+    def version2(self) -> Version2:
+        """Return the major/minor components only."""
+        return Version2(self.major, self.minor, suffix=self.suffix)
+
     def with_suffix(self, *, suffix: str | None = None) -> Self:
+        """Replace the suffix."""
         return replace(self, suffix=suffix)
 
 
 @dataclass(kw_only=True, slots=True)
-class VersionError(Exception): ...
+class Version3Error(Exception): ...
 
 
 @dataclass(kw_only=True, slots=True)
-class _VersionZeroError(VersionError):
+class _Version3ZeroError(Version3Error):
     major: int
     minor: int
     patch: int
@@ -93,7 +242,7 @@ class _VersionZeroError(VersionError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _VersionNegativeMajorVersionError(VersionError):
+class _Version3NegativeMajorVersionError(Version3Error):
     major: int
 
     @override
@@ -102,7 +251,7 @@ class _VersionNegativeMajorVersionError(VersionError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _VersionNegativeMinorVersionError(VersionError):
+class _Version3NegativeMinorVersionError(Version3Error):
     minor: int
 
     @override
@@ -111,7 +260,7 @@ class _VersionNegativeMinorVersionError(VersionError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _VersionNegativePatchVersionError(VersionError):
+class _Version3NegativePatchVersionError(Version3Error):
     patch: int
 
     @override
@@ -120,7 +269,7 @@ class _VersionNegativePatchVersionError(VersionError):
 
 
 @dataclass(kw_only=True, slots=True)
-class _VersionEmptySuffixError(VersionError):
+class _Version3EmptySuffixError(Version3Error):
     suffix: str
 
     @override
@@ -128,63 +277,71 @@ class _VersionEmptySuffixError(VersionError):
         return f"Suffix must be non-empty; got {self.suffix!r}"
 
 
-##
+@dataclass(kw_only=True, slots=True)
+class _Version3ParseError(Version3Error):
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse version; got {self.text!r}"
 
 
-def parse_version(version: str, /) -> Version:
-    """Parse a string into a version object."""
-    try:
-        ((major, minor, patch, suffix),) = _PARSE_VERSION_PATTERN.findall(version)
-    except ValueError:
-        raise ParseVersionError(version=version) from None
-    return Version(
-        int(major), int(minor), int(patch), suffix=None if suffix == "" else suffix
-    )
+##
 
 
-_PARSE_VERSION_PATTERN = re.compile(r"^(\d+)\.(\d+)\.(\d+)(?:-(\w+))?")
+def parse_version_2_or_3(text: str, /) -> Version2Or3:
+    """Parse a string into a Version2 or Version3 object."""
+    with suppress(_Version3ParseError):
+        return Version3.parse(text)
+    with suppress(_Version2ParseError):
+        return Version2.parse(text)
+    raise ParseVersion2Or3Error(text=text)
 
 
 @dataclass(kw_only=True, slots=True)
-class ParseVersionError(Exception):
-    version: str
+class ParseVersion2Or3Error(Exception):
+    text: str
 
     @override
     def __str__(self) -> str:
-        return f"Invalid version string: {self.version!r}"
+        return f"Unable to parse Version2 or Version3; got {self.text!r}"
 
 
 ##
 
 
 @overload
-def to_version(version: MaybeCallableVersionLike, /) -> Version: ...
+def to_version3(version: MaybeCallableVersion3Like, /) -> Version3: ...
 @overload
-def to_version(version: None, /) -> None: ...
+def to_version3(version: None, /) -> None: ...
 @overload
-def to_version(version: Sentinel, /) -> Sentinel: ...
-def to_version(
-    version: MaybeCallableVersionLike | None | Sentinel, /
-) -> Version | None | Sentinel:
+def to_version3(version: Sentinel, /) -> Sentinel: ...
+def to_version3(
+    version: MaybeCallableVersion3Like | None | Sentinel, /
+) -> Version3 | None | Sentinel:
     """Convert to a version."""
     match version:
-        case Version() | None | Sentinel():
+        case Version3() | None | Sentinel():
             return version
         case str():
-            return parse_version(version)
+            return Version3.parse(version)
         case Callable() as func:
-            return to_version(func())
+            return to_version3(func())
         case never:
             assert_never(never)
 
 
 ##
 __all__ = [
-    "MaybeCallableVersionLike",
-    "ParseVersionError",
-    "Version",
-    "VersionError",
-    "VersionLike",
-    "parse_version",
-    "to_version",
+    "MaybeCallableVersion3Like",
+    "ParseVersion2Or3Error",
+    "Version2",
+    "Version2Error",
+    "Version2Like",
+    "Version2Or3",
+    "Version3",
+    "Version3Error",
+    "Version3Like",
+    "parse_version_2_or_3",
+    "to_version3",
 ]

utilities/whenever.py

@@ -32,13 +32,18 @@ from whenever import (
     ZonedDateTime,
 )
 
-from utilities.dataclasses import replace_non_sentinel
+from utilities.constants import LOCAL_TIME_ZONE_NAME, UTC, Sentinel, sentinel
+from utilities.core import (
+    get_now,
+    get_now_local,
+    get_time,
+    get_today,
+    replace_non_sentinel,
+    to_time_zone_name,
+)
 from utilities.functions import get_class_name
 from utilities.math import sign
 from utilities.platform import get_strftime
-from utilities.sentinel import Sentinel, sentinel
-from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
-from utilities.zoneinfo import UTC, to_time_zone_name
 
 if TYPE_CHECKING:
     from utilities.types import (
@@ -53,13 +58,6 @@ if TYPE_CHECKING:
     )
 
 
-# bounds
-
-
-ZONED_DATE_TIME_MIN = PlainDateTime.MIN.assume_tz(UTC.key)
-ZONED_DATE_TIME_MAX = PlainDateTime.MAX.assume_tz(UTC.key)
-
-
 DATE_TIME_DELTA_MIN = DateTimeDelta(
     weeks=-521722,
     days=-5,
@@ -80,10 +78,6 @@ DATE_TIME_DELTA_MAX = DateTimeDelta(
     microseconds=999,
     nanoseconds=999,
 )
-DATE_DELTA_MIN = DATE_TIME_DELTA_MIN.date_part()
-DATE_DELTA_MAX = DATE_TIME_DELTA_MAX.date_part()
-TIME_DELTA_MIN = TimeDelta(hours=-87831216)
-TIME_DELTA_MAX = TimeDelta(hours=87831216)
 
 
 DATE_TIME_DELTA_PARSABLE_MIN = DateTimeDelta(
@@ -115,22 +109,6 @@ DATE_TWO_DIGIT_YEAR_MAX = Date(DATE_TWO_DIGIT_YEAR_MIN.year + 99, 12, 31)
 ## common constants
 
 
-ZERO_DAYS = DateDelta()
-ZERO_TIME = TimeDelta()
-MICROSECOND = TimeDelta(microseconds=1)
-MILLISECOND = TimeDelta(milliseconds=1)
-SECOND = TimeDelta(seconds=1)
-MINUTE = TimeDelta(minutes=1)
-HOUR = TimeDelta(hours=1)
-DAY = DateDelta(days=1)
-WEEK = DateDelta(weeks=1)
-MONTH = DateDelta(months=1)
-YEAR = DateDelta(years=1)
-
-
-##
-
-
 def add_year_month(x: YearMonth, /, *, years: int = 0, months: int = 0) -> YearMonth:
     """Add to a year-month."""
     y = x.on_day(1) + DateDelta(years=years, months=months)
@@ -258,6 +236,7 @@ def datetime_utc(
     month: int,
     day: int,
     /,
+    *,
     hour: int = 0,
     minute: int = 0,
     second: int = 0,
@@ -360,79 +339,6 @@ def from_timestamp_nanos(i: int, /, *, time_zone: TimeZoneLike = UTC) -> ZonedDa
 ##
 
 
-def get_now(time_zone: TimeZoneLike = UTC, /) -> ZonedDateTime:
-    """Get the current zoned date-time."""
-    return ZonedDateTime.now(to_time_zone_name(time_zone))
-
-
-NOW_UTC = get_now(UTC)
-
-
-def get_now_local() -> ZonedDateTime:
-    """Get the current zoned date-time in the local time-zone."""
-    return get_now(LOCAL_TIME_ZONE)
-
-
-NOW_LOCAL = get_now_local()
-
-
-def get_now_plain(time_zone: TimeZoneLike = UTC, /) -> PlainDateTime:
-    """Get the current plain date-time."""
-    return get_now(time_zone).to_plain()
-
-
-NOW_PLAIN = get_now_plain()
-
-
-def get_now_local_plain() -> PlainDateTime:
-    """Get the current plain date-time in the local time-zone."""
-    return get_now_local().to_plain()
-
-
-NOW_LOCAL_PLAIN = get_now_local_plain()
-
-
-##
-
-
-def get_time(time_zone: TimeZoneLike = UTC, /) -> Time:
-    """Get the current time."""
-    return get_now(time_zone).time()
-
-
-TIME_UTC = get_time(UTC)
-
-
-def get_time_local() -> Time:
-    """Get the current time in the local time-zone."""
-    return get_time(LOCAL_TIME_ZONE)
-
-
-TIME_LOCAL = get_time_local()
-
-
-##
-
-
-def get_today(time_zone: TimeZoneLike = UTC, /) -> Date:
-    """Get the current, timezone-aware local date."""
-    return get_now(time_zone).date()
-
-
-TODAY_UTC = get_today(UTC)
-
-
-def get_today_local() -> Date:
-    """Get the current, timezone-aware local date."""
-    return get_today(LOCAL_TIME_ZONE)
-
-
-TODAY_LOCAL = get_today_local()
-
-
-##
-
-
 def is_weekend(
     date_time: ZonedDateTime,
     /,
@@ -618,7 +524,7 @@ def _round_datetime_decompose(delta: Delta, /) -> tuple[int, _RoundDateOrDateTim
         if (0 < hours < 24) and (24 % hours == 0):
             return hours, "H"
         raise _RoundDateOrDateTimeIncrementError(
-            duration=delta, increment=hours, divisor=24
+            delta=delta, increment=hours, divisor=24
         )
     try:
         minutes = to_minutes(delta)
@@ -628,7 +534,7 @@ def _round_datetime_decompose(delta: Delta, /) -> tuple[int, _RoundDateOrDateTim
         if (0 < minutes < 60) and (60 % minutes == 0):
             return minutes, "M"
         raise _RoundDateOrDateTimeIncrementError(
-            duration=delta, increment=minutes, divisor=60
+            delta=delta, increment=minutes, divisor=60
         )
     try:
         seconds = to_seconds(delta)
@@ -638,7 +544,7 @@ def _round_datetime_decompose(delta: Delta, /) -> tuple[int, _RoundDateOrDateTim
         if (0 < seconds < 60) and (60 % seconds == 0):
             return seconds, "S"
         raise _RoundDateOrDateTimeIncrementError(
-            duration=delta, increment=seconds, divisor=60
+            delta=delta, increment=seconds, divisor=60
         )
     try:
         milliseconds = to_milliseconds(delta)
@@ -648,7 +554,7 @@ def _round_datetime_decompose(delta: Delta, /) -> tuple[int, _RoundDateOrDateTim
         if (0 < milliseconds < 1000) and (1000 % milliseconds == 0):
             return milliseconds, "ms"
         raise _RoundDateOrDateTimeIncrementError(
-            duration=delta, increment=milliseconds, divisor=1000
+            delta=delta, increment=milliseconds, divisor=1000
         )
     try:
         microseconds = to_microseconds(delta)
@@ -658,16 +564,16 @@ def _round_datetime_decompose(delta: Delta, /) -> tuple[int, _RoundDateOrDateTim
         if (0 < microseconds < 1000) and (1000 % microseconds == 0):
             return microseconds, "us"
         raise _RoundDateOrDateTimeIncrementError(
-            duration=delta, increment=microseconds, divisor=1000
+            delta=delta, increment=microseconds, divisor=1000
         )
     try:
         nanoseconds = to_nanoseconds(delta)
     except ToNanosecondsError:
-        raise _RoundDateOrDateTimeInvalidDurationError(duration=delta) from None
+        raise _RoundDateOrDateTimeInvalidDeltaError(delta=delta) from None
     if (0 < nanoseconds < 1000) and (1000 % nanoseconds == 0):
         return nanoseconds, "ns"
     raise _RoundDateOrDateTimeIncrementError(
-        duration=delta, increment=nanoseconds, divisor=1000
+        delta=delta, increment=nanoseconds, divisor=1000
     )
 
 
@@ -787,22 +693,22 @@ class RoundDateOrDateTimeError(Exception): ...
 
 @dataclass(kw_only=True, slots=True)
 class _RoundDateOrDateTimeIncrementError(RoundDateOrDateTimeError):
-    duration: Delta
+    delta: Delta
     increment: int
     divisor: int
 
     @override
     def __str__(self) -> str:
-        return f"Duration {self.duration} increment must be a proper divisor of {self.divisor}; got {self.increment}"
+        return f"Delta {self.delta} increment must be a proper divisor of {self.divisor}; got {self.increment}"
 
 
 @dataclass(kw_only=True, slots=True)
-class _RoundDateOrDateTimeInvalidDurationError(RoundDateOrDateTimeError):
-    duration: Delta
+class _RoundDateOrDateTimeInvalidDeltaError(RoundDateOrDateTimeError):
+    delta: Delta
 
     @override
     def __str__(self) -> str:
-        return f"Duration must be valid; got {self.duration}"
+        return f"Delta must be valid; got {self.delta}"
 
 
 @dataclass(kw_only=True, slots=True)
@@ -1997,38 +1903,12 @@ class _ZonedDateTimePeriodExactEqError(ZonedDateTimePeriodError):
 
 
 __all__ = [
-    "DATE_DELTA_MAX",
-    "DATE_DELTA_MIN",
     "DATE_DELTA_PARSABLE_MAX",
     "DATE_DELTA_PARSABLE_MIN",
-    "DATE_TIME_DELTA_MAX",
-    "DATE_TIME_DELTA_MIN",
     "DATE_TIME_DELTA_PARSABLE_MAX",
     "DATE_TIME_DELTA_PARSABLE_MIN",
     "DATE_TWO_DIGIT_YEAR_MAX",
     "DATE_TWO_DIGIT_YEAR_MIN",
-    "DAY",
-    "HOUR",
-    "MICROSECOND",
-    "MILLISECOND",
-    "MINUTE",
-    "MONTH",
-    "NOW_LOCAL",
-    "NOW_LOCAL_PLAIN",
-    "NOW_PLAIN",
-    "SECOND",
-    "TIME_DELTA_MAX",
-    "TIME_DELTA_MIN",
-    "TIME_LOCAL",
-    "TIME_UTC",
-    "TODAY_LOCAL",
-    "TODAY_UTC",
-    "WEEK",
-    "YEAR",
-    "ZERO_DAYS",
-    "ZERO_TIME",
-    "ZONED_DATE_TIME_MAX",
-    "ZONED_DATE_TIME_MIN",
     "DatePeriod",
     "DatePeriodError",
     "MeanDateTimeError",
@@ -2055,14 +1935,6 @@ __all__ = [
     "from_timestamp",
     "from_timestamp_millis",
     "from_timestamp_nanos",
-    "get_now",
-    "get_now_local",
-    "get_now_local_plain",
-    "get_now_plain",
-    "get_time",
-    "get_time_local",
-    "get_today",
-    "get_today_local",
     "is_weekend",
     "mean_datetime",
     "min_max_date",

dycw_utilities-0.175.17.dist-info/METADATA

@@ -1,34 +0,0 @@
-Metadata-Version: 2.3
-Name: dycw-utilities
-Version: 0.175.17
-Summary: Miscellaneous Python utilities
-Author: Derek Wan
-Author-email: Derek Wan <d.wan@icloud.com>
-Requires-Dist: atomicwrites>=1.4.1,<1.5
-Requires-Dist: typing-extensions>=4.15.0,<4.16
-Requires-Dist: tzlocal>=5.3.1,<5.4
-Requires-Dist: whenever>=0.9.4,<0.10
-Requires-Dist: coloredlogs>=15.0.1,<15.1 ; extra == 'logging'
-Requires-Dist: dycw-pytest-only>=2.1.1,<2.2 ; extra == 'test'
-Requires-Dist: hypothesis>=6.148.8,<6.149 ; extra == 'test'
-Requires-Dist: pytest>=9.0.2,<9.1 ; extra == 'test'
-Requires-Dist: pytest-asyncio>=1.3.0,<1.4 ; extra == 'test'
-Requires-Dist: pytest-cov>=7.0.0,<7.1 ; extra == 'test'
-Requires-Dist: pytest-instafail>=0.5.0,<0.6 ; extra == 'test'
-Requires-Dist: pytest-lazy-fixtures>=1.4.0,<1.5 ; extra == 'test'
-Requires-Dist: pytest-randomly>=4.0.1,<4.1 ; extra == 'test'
-Requires-Dist: pytest-regressions>=2.8.3,<2.9 ; extra == 'test'
-Requires-Dist: pytest-repeat>=0.9.4,<0.10 ; extra == 'test'
-Requires-Dist: pytest-rerunfailures>=16.1,<16.2 ; extra == 'test'
-Requires-Dist: pytest-rng>=1.0.0,<1.1 ; extra == 'test'
-Requires-Dist: pytest-timeout>=2.4.0,<2.5 ; extra == 'test'
-Requires-Dist: pytest-xdist>=3.8.0,<3.9 ; extra == 'test'
-Requires-Dist: testbook>=0.4.2,<0.5 ; extra == 'test'
-Requires-Python: >=3.12
-Provides-Extra: logging
-Provides-Extra: test
-Description-Content-Type: text/markdown
-
-# `python-utilities`
-
-Miscellaneous Python utilities