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

utilities/hypothesis.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import builtins
+import datetime as dt
 from contextlib import contextmanager
 from dataclasses import dataclass
 from enum import Enum, auto
@@ -31,6 +32,7 @@ from hypothesis.strategies import (
     sampled_from,
     sets,
     text,
+    timezones,
     uuids,
 )
 from hypothesis.utils.conventions import not_set
@@ -38,46 +40,53 @@ from whenever import (
     Date,
     DateDelta,
     DateTimeDelta,
+    MonthDay,
     PlainDateTime,
     RepeatedTime,
     SkippedTime,
     Time,
     TimeDelta,
     TimeZoneNotFoundError,
+    YearMonth,
     ZonedDateTime,
 )
 
-from utilities.functions import ensure_int, ensure_str
+from utilities.functions import ensure_int, ensure_str, max_nullable, min_nullable
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
+    MAX_INT8,
+    MAX_INT16,
     MAX_INT32,
     MAX_INT64,
+    MAX_UINT8,
+    MAX_UINT16,
     MAX_UINT32,
     MAX_UINT64,
     MIN_FLOAT32,
     MIN_FLOAT64,
+    MIN_INT8,
+    MIN_INT16,
     MIN_INT32,
     MIN_INT64,
+    MIN_UINT8,
+    MIN_UINT16,
     MIN_UINT32,
     MIN_UINT64,
     is_zero,
 )
 from utilities.os import get_env_var
-from utilities.pathlib import temp_cwd
-from utilities.platform import IS_WINDOWS
-from utilities.sentinel import Sentinel, sentinel
+from utilities.pathlib import module_path, temp_cwd
+from utilities.permissions import Permissions
+from utilities.platform import IS_LINUX
+from utilities.sentinel import Sentinel, is_sentinel, sentinel
 from utilities.tempfile import TEMP_DIR, TemporaryDirectory
-from utilities.types import DateTimeRoundUnit
-from utilities.typing import get_literal_elements
 from utilities.version import Version
 from utilities.whenever import (
     DATE_DELTA_MAX,
     DATE_DELTA_MIN,
     DATE_DELTA_PARSABLE_MAX,
     DATE_DELTA_PARSABLE_MIN,
-    DATE_MAX,
-    DATE_MIN,
     DATE_TIME_DELTA_MAX,
     DATE_TIME_DELTA_MIN,
     DATE_TIME_DELTA_PARSABLE_MAX,
@@ -85,31 +94,29 @@ from utilities.whenever import (
     DATE_TWO_DIGIT_YEAR_MAX,
     DATE_TWO_DIGIT_YEAR_MIN,
     DAY,
-    MONTH_MAX,
-    MONTH_MIN,
-    PLAIN_DATE_TIME_MAX,
-    PLAIN_DATE_TIME_MIN,
     TIME_DELTA_MAX,
     TIME_DELTA_MIN,
-    TIME_MAX,
-    TIME_MIN,
-    Freq,
-    Month,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
+    get_now,
     to_date_time_delta,
     to_days,
-    to_nanos,
+    to_nanoseconds,
 )
-from utilities.zoneinfo import UTC, ensure_time_zone
+from utilities.zoneinfo import UTC, to_zone_info
 
 if TYPE_CHECKING:
-    import datetime as dt
     from collections.abc import Collection, Hashable, Iterable, Iterator
+    from zoneinfo import ZoneInfo
 
     from hypothesis.database import ExampleDatabase
+    from libcst import Import, ImportFrom
     from numpy.random import RandomState
+    from sqlalchemy import URL
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.types import Number, TimeZoneLike
+    from utilities.types import Number, TimeZone, TimeZoneLike
 
 
 type MaybeSearchStrategy[_T] = _T | SearchStrategy[_T]
@@ -184,14 +191,14 @@ def date_deltas(
             min_value_ = DATE_DELTA_MIN
         case DateDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = DATE_DELTA_MAX
         case DateDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     min_days = to_days(min_value_)
     max_days = to_days(max_value_)
@@ -205,6 +212,26 @@ def date_deltas(
 ##
 
 
+@composite
+def date_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Date | None] = None,
+    max_value: MaybeSearchStrategy[Date | None] = None,
+    two_digit: MaybeSearchStrategy[bool] = False,
+) -> DatePeriod:
+    """Strategy for generating date periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    two_digit_ = draw2(draw, two_digit)
+    strategy = dates(min_value=min_value_, max_value=max_value_, two_digit=two_digit_)
+    start, end = draw(pairs(strategy, sorted=True))
+    return DatePeriod(start, end)
+
+
+##
+
+
 @composite
 def date_time_deltas(
     draw: DrawFn,
@@ -213,6 +240,7 @@ def date_time_deltas(
     min_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
     max_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
     parsable: MaybeSearchStrategy[bool] = False,
+    nativable: MaybeSearchStrategy[bool] = False,
 ) -> DateTimeDelta:
     """Strategy for generating date deltas."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
@@ -221,20 +249,26 @@ def date_time_deltas(
             min_value_ = DATE_TIME_DELTA_MIN
         case DateTimeDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = DATE_TIME_DELTA_MAX
         case DateTimeDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
-    min_nanos, max_nanos = map(to_nanos, [min_value_, max_value_])
+    min_nanos, max_nanos = map(to_nanoseconds, [min_value_, max_value_])
     if draw2(draw, parsable):
-        min_nanos = max(min_nanos, to_nanos(DATE_TIME_DELTA_PARSABLE_MIN))
-        max_nanos = min(max_nanos, to_nanos(DATE_TIME_DELTA_PARSABLE_MAX))
-    nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
+        min_nanos = max(min_nanos, to_nanoseconds(DATE_TIME_DELTA_PARSABLE_MIN))
+        max_nanos = min(max_nanos, to_nanoseconds(DATE_TIME_DELTA_PARSABLE_MAX))
+    if draw2(draw, nativable):
+        min_micros, _ = divmod(min_nanos, 1000)
+        max_micros, _ = divmod(max_nanos, 1000)
+        micros = draw(integers(min_value=min_micros + 1, max_value=max_micros))
+        nanos = 1000 * micros
+    else:
+        nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
     return to_date_time_delta(nanos)
 
 
@@ -254,17 +288,17 @@ def dates(
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
-            min_value_ = DATE_MIN
+            min_value_ = Date.MIN
         case Date():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
-            max_value_ = DATE_MAX
+            max_value_ = Date.MAX
         case Date():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     if draw2(draw, two_digit):
         min_value_ = max(min_value_, DATE_TWO_DIGIT_YEAR_MIN)
@@ -333,21 +367,21 @@ def draw2[T](
             return value
         case None, SearchStrategy(), False:
             value2 = draw(default)
-            if isinstance(value2, Sentinel):
+            if is_sentinel(value2):
                 raise _Draw2DefaultGeneratedSentinelError
             return value2
         case Sentinel(), None, _:
             raise _Draw2InputResolvedToSentinelError
         case Sentinel(), SearchStrategy(), True:
             value2 = draw(default)
-            if isinstance(value2, Sentinel):
+            if is_sentinel(value2):
                 raise _Draw2DefaultGeneratedSentinelError
             return value2
         case Sentinel(), SearchStrategy(), False:
             raise _Draw2InputResolvedToSentinelError
         case _, _, _:
             return value
-        case _ as never:
+        case never:
             assert_never(never)
 
 
@@ -377,16 +411,27 @@ def float32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[float] = MIN_FLOAT32,
-    max_value: MaybeSearchStrategy[float] = MAX_FLOAT32,
+    min_value: MaybeSearchStrategy[float | None] = None,
+    max_value: MaybeSearchStrategy[float | None] = None,
+    exclude_min: MaybeSearchStrategy[bool] = False,
+    exclude_max: MaybeSearchStrategy[bool] = False,
 ) -> float:
     """Strategy for generating float32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_FLOAT32)
-    max_value_ = min(max_value_, MAX_FLOAT32)
+    min_value_ = max_nullable([min_value_, MIN_FLOAT32])
+    max_value_ = min_nullable([max_value_, MAX_FLOAT32])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
-    return draw(floats(min_value_, max_value_, width=32))
+    exclude_min_, exclude_max_ = [draw2(draw, e) for e in [exclude_min, exclude_max]]
+    return draw(
+        floats(
+            min_value_,
+            max_value_,
+            width=32,
+            exclude_min=exclude_min_,
+            exclude_max=exclude_max_,
+        )
+    )
 
 
 @composite
@@ -394,16 +439,27 @@ def float64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[float] = MIN_FLOAT64,
-    max_value: MaybeSearchStrategy[float] = MAX_FLOAT64,
+    min_value: MaybeSearchStrategy[float | None] = None,
+    max_value: MaybeSearchStrategy[float | None] = None,
+    exclude_min: MaybeSearchStrategy[bool] = False,
+    exclude_max: MaybeSearchStrategy[bool] = False,
 ) -> float:
     """Strategy for generating float64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_FLOAT64)
-    max_value_ = min(max_value_, MAX_FLOAT64)
+    min_value_ = max_nullable([min_value_, MIN_FLOAT64])
+    max_value_ = min_nullable([max_value_, MAX_FLOAT64])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
-    return draw(floats(min_value_, max_value_, width=64))
+    exclude_min_, exclude_max_ = [draw2(draw, e) for e in [exclude_min, exclude_max]]
+    return draw(
+        floats(
+            min_value_,
+            max_value_,
+            width=64,
+            exclude_min=exclude_min_,
+            exclude_max=exclude_max_,
+        )
+    )
 
 
 ##
@@ -495,38 +551,6 @@ def floats_extra(
 ##
 
 
-@composite
-def freqs(
-    draw: DrawFn, /, *, unit: MaybeSearchStrategy[DateTimeRoundUnit | None] = None
-) -> Freq:
-    unit_ = draw2(draw, unit, _freq_units())
-    match unit_:
-        case "day":
-            return Freq(unit=unit_)
-        case "hour":
-            return Freq(unit=unit_, increment=draw(_freq_increments(24)))
-        case "minute" | "second":
-            return Freq(unit=unit_, increment=draw(_freq_increments(60)))
-        case "millisecond" | "microsecond" | "nanosecond":
-            return Freq(unit=unit_, increment=draw(_freq_increments(1000)))
-        case _ as never:
-            assert_never(never)
-
-
-@composite
-def _freq_units(draw: DrawFn, /) -> DateTimeRoundUnit:
-    return draw(sampled_from(get_literal_elements(DateTimeRoundUnit)))
-
-
-@composite
-def _freq_increments(draw: DrawFn, n: int, /) -> int:
-    divisors = [i for i in range(1, n) if n % i == 0]
-    return draw(sampled_from(divisors))
-
-
-##
-
-
 @composite
 def git_repos(draw: DrawFn, /) -> Path:
     path = draw(temp_paths())
@@ -555,6 +579,59 @@ def hashables() -> SearchStrategy[Hashable]:
 ##
 
 
+@composite
+def import_froms(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> ImportFrom:
+    """Strategy for generating import-froms."""
+    from utilities.libcst import generate_import_from
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = module_path(path)
+    name = draw(text_ascii(min_size=1))
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import_from(module, name, asname=asname)
+
+
+##
+
+
+@composite
+def imports(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Import:
+    """Strategy for generating imports."""
+    from utilities.libcst import generate_import
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = module_path(path)
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import(module, asname=asname)
+
+
+##
+
+
 @composite
 def int_arrays(
     draw: DrawFn,
@@ -584,18 +661,48 @@ def int_arrays(
 ##
 
 
+@composite
+def int8s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating int8s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_INT8])
+    max_value_ = min_nullable([max_value_, MAX_INT8])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
+@composite
+def int16s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating int16s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_INT16])
+    max_value_ = min_nullable([max_value_, MAX_INT16])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
 @composite
 def int32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_INT32,
-    max_value: MaybeSearchStrategy[int] = MAX_INT32,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating int32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_INT32)
-    max_value_ = min(max_value_, MAX_INT32)
+    min_value_ = max_nullable([min_value_, MIN_INT32])
+    max_value_ = min_nullable([max_value_, MAX_INT32])
     return draw(integers(min_value_, max_value_))
 
 
@@ -604,13 +711,13 @@ def int64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_INT64,
-    max_value: MaybeSearchStrategy[int] = MAX_INT64,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating int64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_INT64)
-    max_value_ = min(max_value_, MAX_INT64)
+    min_value_ = max_nullable([min_value_, MIN_INT64])
+    max_value_ = min_nullable([max_value_, MAX_INT64])
     return draw(integers(min_value_, max_value_))
 
 
@@ -641,47 +748,32 @@ def lists_fixed_length[T](
 
 
 @composite
-def months(
+def month_days(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[Month | None] = None,
-    max_value: MaybeSearchStrategy[Month | None] = None,
-    two_digit: MaybeSearchStrategy[bool] = False,
-) -> Month:
-    """Strategy for generating months."""
+    min_value: MaybeSearchStrategy[MonthDay | None] = None,
+    max_value: MaybeSearchStrategy[MonthDay | None] = None,
+) -> MonthDay:
+    """Strategy for generating month-days."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
-            min_value_ = MONTH_MIN
-        case Month():
+            min_value_ = MonthDay.MIN
+        case MonthDay():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
-            max_value_ = MONTH_MAX
-        case Month():
+            max_value_ = MonthDay.MAX
+        case MonthDay():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
-    min_date, max_date = [m.to_date() for m in [min_value_, max_value_]]
-    date = draw(dates(min_value=min_date, max_value=max_date, two_digit=two_digit))
-    return Month.from_date(date)
-
-
-##
-
-
-@composite
-def namespace_mixins(draw: DrawFn, /) -> type:
-    """Strategy for generating task namespace mixins."""
-    path = draw(temp_paths())
-
-    class NamespaceMixin:
-        task_namespace = path.name
-
-    return NamespaceMixin
+    min_date, max_date = [m.in_year(2000) for m in [min_value_, max_value_]]
+    date = draw(dates(min_value=min_date, max_value=max_date))
+    return date.month_day()
 
 
 ##
@@ -746,18 +838,67 @@ def _pairs_map[T](elements: list[T], /) -> tuple[T, T]:
 ##
 
 
-def paths() -> SearchStrategy[Path]:
+@composite
+def paths(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Path:
     """Strategy for generating `Path`s."""
-    reserved = {"AUX", "NUL"}
-    strategy = text_ascii(min_size=1, max_size=10).filter(lambda x: x not in reserved)
-    return lists(strategy, max_size=10).map(lambda parts: Path(*parts))
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    min_depth_ = max_nullable([min_depth_, 0])
+    max_depth_ = min_nullable([max_depth_, 10])
+    parts = draw(lists(_path_parts(), min_size=min_depth_, max_size=max_depth_))
+    return Path(*parts)
+
+
+@composite
+def _path_parts(draw: DrawFn, /) -> str:
+    part = draw(text_ascii(min_size=1, max_size=10))
+    reserved = {"AUX", "NUL", "nuL", "pRn"}
+    _ = assume(part not in reserved)
+    return part
+
+
+##
+
+
+@composite
+def permissions(
+    draw: DrawFn,
+    /,
+    *,
+    user_read: MaybeSearchStrategy[bool | None] = None,
+    user_write: MaybeSearchStrategy[bool | None] = None,
+    user_execute: MaybeSearchStrategy[bool | None] = None,
+    group_read: MaybeSearchStrategy[bool | None] = None,
+    group_write: MaybeSearchStrategy[bool | None] = None,
+    group_execute: MaybeSearchStrategy[bool | None] = None,
+    others_read: MaybeSearchStrategy[bool | None] = None,
+    others_write: MaybeSearchStrategy[bool | None] = None,
+    others_execute: MaybeSearchStrategy[bool | None] = None,
+) -> Permissions:
+    """Strategy for generating `Permissions`."""
+    return Permissions(
+        user_read=draw2(draw, user_read, booleans()),
+        user_write=draw2(draw, user_write, booleans()),
+        user_execute=draw2(draw, user_execute, booleans()),
+        group_read=draw2(draw, group_read, booleans()),
+        group_write=draw2(draw, group_write, booleans()),
+        group_execute=draw2(draw, group_execute, booleans()),
+        others_read=draw2(draw, others_read, booleans()),
+        others_write=draw2(draw, others_write, booleans()),
+        others_execute=draw2(draw, others_execute, booleans()),
+    )
 
 
 ##
 
 
 @composite
-def plain_datetimes(
+def plain_date_times(
     draw: DrawFn,
     /,
     *,
@@ -768,17 +909,17 @@ def plain_datetimes(
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
-            min_value_ = PLAIN_DATE_TIME_MIN
+            min_value_ = PlainDateTime.MIN
         case PlainDateTime():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
-            max_value_ = PLAIN_DATE_TIME_MAX
+            max_value_ = PlainDateTime.MAX
         case PlainDateTime():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     py_datetime = draw(
         datetimes(
@@ -791,6 +932,46 @@ def plain_datetimes(
 ##
 
 
+@composite
+def py_datetimes(
+    draw: DrawFn, /, *, zoned: MaybeSearchStrategy[bool | None] = None
+) -> dt.datetime:
+    """Strategy for generating standard library datetimes."""
+    zoned_ = draw2(draw, zoned, booleans())
+    timezones = just(UTC) if zoned_ else none()
+    return draw(
+        hypothesis.strategies.datetimes(
+            min_value=dt.datetime(2000, 1, 1),  # noqa: DTZ001
+            max_value=dt.datetime(2000, 12, 31),  # noqa: DTZ001
+            timezones=timezones,
+        )
+    )
+
+
+##
+
+
+def quadruples[T](
+    strategy: SearchStrategy[T],
+    /,
+    *,
+    unique: MaybeSearchStrategy[bool] = False,
+    sorted: MaybeSearchStrategy[bool] = False,  # noqa: A002
+) -> SearchStrategy[tuple[T, T, T, T]]:
+    """Strategy for generating quadruples of elements."""
+    return lists_fixed_length(strategy, 4, unique=unique, sorted=sorted).map(
+        _quadruples_map
+    )
+
+
+def _quadruples_map[T](elements: list[T], /) -> tuple[T, T, T, T]:
+    first, second, third, fourth = elements
+    return first, second, third, fourth
+
+
+##
+
+
 @composite
 def random_states(
     draw: DrawFn, /, *, seed: MaybeSearchStrategy[int | None] = None
@@ -798,7 +979,7 @@ def random_states(
     """Strategy for generating `numpy` random states."""
     from numpy.random import RandomState
 
-    seed_ = draw2(draw, seed, integers(0, MAX_UINT32))
+    seed_ = draw2(draw, seed, uint32s())
     return RandomState(seed=seed_)
 
 
@@ -845,7 +1026,7 @@ def setup_hypothesis_profiles(
                     return 100
                 case Profile.ci:
                     return 1000
-                case _ as never:
+                case never:
                     assert_never(never)
 
         @property
@@ -855,11 +1036,11 @@ def setup_hypothesis_profiles(
                     return Verbosity.quiet
                 case Profile.ci:
                     return Verbosity.verbose
-                case _ as never:
+                case never:
                     assert_never(never)
 
     phases = {Phase.explicit, Phase.reuse, Phase.generate, Phase.target}
-    if "HYPOTHESIS_NO_SHRINK" not in environ:
+    if "HYPOTHESIS_NO_SHRINK" not in environ:  # pragma: no cover
         phases.add(Phase.shrink)
     for profile in Profile:
         try:
@@ -980,9 +1161,7 @@ def temp_dirs(draw: DrawFn, /) -> TemporaryDirectory:
     """Search strategy for temporary directories."""
     _TEMP_DIR_HYPOTHESIS.mkdir(exist_ok=True)
     uuid = draw(uuids())
-    return TemporaryDirectory(
-        prefix=f"{uuid}__", dir=_TEMP_DIR_HYPOTHESIS, ignore_cleanup_errors=IS_WINDOWS
-    )
+    return TemporaryDirectory(prefix=f"{uuid}__", dir=_TEMP_DIR_HYPOTHESIS)
 
 
 ##
@@ -1112,14 +1291,14 @@ def time_deltas(
             min_value_ = TIME_DELTA_MIN
         case TimeDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = TIME_DELTA_MAX
         case TimeDelta():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     py_time = draw(
         hypothesis.strategies.timedeltas(
@@ -1132,6 +1311,24 @@ def time_deltas(
 ##
 
 
+@composite
+def time_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Time | None] = None,
+    max_value: MaybeSearchStrategy[Time | None] = None,
+) -> TimePeriod:
+    """Strategy for generating time periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    strategy = times(min_value=min_value_, max_value=max_value_)
+    start, end = draw(pairs(strategy, sorted=True))
+    return TimePeriod(start, end)
+
+
+##
+
+
 @composite
 def times(
     draw: DrawFn,
@@ -1144,17 +1341,17 @@ def times(
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
         case None:
-            min_value_ = TIME_MIN
+            min_value_ = Time.MIN
         case Time():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
-            max_value_ = TIME_MAX
+            max_value_ = Time.MAX
         case Time():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     py_time = draw(
         hypothesis.strategies.times(
@@ -1188,18 +1385,48 @@ def _triples_map[T](elements: list[T], /) -> tuple[T, T, T]:
 ##
 
 
+@composite
+def uint8s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating uint8s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_UINT8])
+    max_value_ = min_nullable([max_value_, MAX_UINT8])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
+@composite
+def uint16s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating uint16s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_UINT16])
+    max_value_ = min_nullable([max_value_, MAX_UINT16])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
 @composite
 def uint32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT32,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT32,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT32)
-    max_value_ = min(max_value_, MAX_UINT32)
+    min_value_ = max_nullable([min_value_, MIN_UINT32])
+    max_value_ = min_nullable([max_value_, MAX_UINT32])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
@@ -1208,19 +1435,54 @@ def uint64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT64,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT64,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT64)
-    max_value_ = min(max_value_, MAX_UINT64)
+    min_value_ = max_nullable([min_value_, MIN_UINT64])
+    max_value_ = min_nullable([max_value_, MAX_UINT64])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
 ##
 
 
+@composite
+def urls(
+    draw: DrawFn,
+    /,
+    *,
+    all_: MaybeSearchStrategy[bool] = False,
+    username: MaybeSearchStrategy[bool] = False,
+    password: MaybeSearchStrategy[bool] = False,
+    host: MaybeSearchStrategy[bool] = False,
+    port: MaybeSearchStrategy[bool] = False,
+    database: MaybeSearchStrategy[bool] = False,
+) -> URL:
+    from sqlalchemy import URL
+
+    have_all, have_username, have_password, have_host, have_port, have_database = [
+        draw2(draw, b) for b in [all_, username, password, host, port, database]
+    ]
+    username_use = draw(text_ascii(min_size=1)) if have_all or have_username else None
+    password_use = draw(text_ascii(min_size=1)) if have_all or have_password else None
+    host_use = draw(text_ascii(min_size=1)) if have_all or have_host else None
+    port_use = draw(integers(min_value=1)) if have_all or have_port else None
+    database_use = draw(text_ascii(min_size=1)) if have_all or have_database else None
+    return URL.create(
+        drivername="sqlite",
+        username=username_use,
+        password=password_use,
+        host=host_use,
+        port=port_use,
+        database=database_use,
+    )
+
+
+##
+
+
 @composite
 def versions(draw: DrawFn, /, *, suffix: MaybeSearchStrategy[bool] = False) -> Version:
     """Strategy for generating versions."""
@@ -1234,7 +1496,81 @@ def versions(draw: DrawFn, /, *, suffix: MaybeSearchStrategy[bool] = False) -> V
 
 
 @composite
-def zoned_datetimes(
+def year_months(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[YearMonth | None] = None,
+    max_value: MaybeSearchStrategy[YearMonth | None] = None,
+    two_digit: MaybeSearchStrategy[bool] = False,
+) -> YearMonth:
+    """Strategy for generating months."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = YearMonth.MIN
+        case YearMonth():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = YearMonth.MAX
+        case YearMonth():
+            ...
+        case never:
+            assert_never(never)
+    min_date, max_date = [m.on_day(1) for m in [min_value_, max_value_]]
+    date = draw(dates(min_value=min_date, max_value=max_date, two_digit=two_digit))
+    return date.year_month()
+
+
+##
+
+
+@composite
+def zone_infos(draw: DrawFn, /) -> ZoneInfo:
+    """Strategy for generating time-zones."""
+    time_zone = draw(timezones())
+    if IS_LINUX:  # skipif-not-linux
+        _ = assume(time_zone.key not in _LINUX_DISALLOW_TIME_ZONES)
+    with assume_does_not_raise(TimeZoneNotFoundError):
+        _ = get_now(time_zone)
+    return time_zone
+
+
+_LINUX_DISALLOW_TIME_ZONES: set[TimeZone | Literal["localtime"]] = {
+    "Etc/UTC",
+    "localtime",
+}
+
+##
+
+
+@composite
+def zoned_date_time_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
+) -> ZonedDateTimePeriod:
+    """Strategy for generating zoned date-time periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    time_zone_: TimeZoneLike = draw2(draw, time_zone)
+    strategy = zoned_date_times(
+        min_value=min_value_, max_value=max_value_, time_zone=time_zone_
+    )
+    start, end = draw(pairs(strategy, sorted=True))
+    return ZonedDateTimePeriod(start, end)
+
+
+##
+
+
+@composite
+def zoned_date_times(
     draw: DrawFn,
     /,
     *,
@@ -1242,16 +1578,16 @@ def zoned_datetimes(
     max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
     time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
 ) -> ZonedDateTime:
-    """Strategy for generating zoned datetimes."""
+    """Strategy for generating zoned date-times."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    time_zone_ = ensure_time_zone(draw2(draw, time_zone))
+    time_zone_ = to_zone_info(draw2(draw, time_zone))
     match min_value_:
         case None | PlainDateTime():
             ...
         case ZonedDateTime():
             with assume_does_not_raise(ValueError):
                 min_value_ = min_value_.to_tz(time_zone_.key).to_plain()
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None | PlainDateTime():
@@ -1259,22 +1595,26 @@ def zoned_datetimes(
         case ZonedDateTime():
             with assume_does_not_raise(ValueError):
                 max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
-        case _ as never:
+        case never:
             assert_never(never)
-    plain = draw(plain_datetimes(min_value=min_value_, max_value=max_value_))
+    plain = draw(plain_date_times(min_value=min_value_, max_value=max_value_))
     with (
         assume_does_not_raise(RepeatedTime),
         assume_does_not_raise(SkippedTime),
-        assume_does_not_raise(TimeZoneNotFoundError),
-        assume_does_not_raise(ValueError, match="Resulting datetime is out of range"),
+        assume_does_not_raise(ValueError, match=r"Resulting time is out of range"),
     ):
         zoned = plain.assume_tz(time_zone_.key, disambiguate="raise")
-    with assume_does_not_raise(OverflowError, match="date value out of range"):
-        if not ((DATE_MIN + DAY) <= zoned.date() <= (DATE_MAX - DAY)):
+    with assume_does_not_raise(OverflowError, match=r"date value out of range"):
+        if not ((Date.MIN + DAY) <= zoned.date() <= (Date.MAX - DAY)):
             _ = zoned.py_datetime()
     return zoned
 
 
+zoned_date_times_2000 = zoned_date_times(
+    min_value=ZonedDateTime(2000, 1, 1, tz=UTC.key),
+    max_value=ZonedDateTime(2000, 12, 31, tz=UTC.key),
+)
+
 __all__ = [
     "Draw2Error",
     "MaybeSearchStrategy",
@@ -1282,6 +1622,7 @@ __all__ = [
     "assume_does_not_raise",
     "bool_arrays",
     "date_deltas",
+    "date_periods",
     "date_time_deltas",
     "dates",
     "draw2",
@@ -1289,19 +1630,24 @@ __all__ = [
     "float64s",
     "float_arrays",
     "floats_extra",
-    "freqs",
     "git_repos",
     "hashables",
+    "import_froms",
+    "imports",
+    "int8s",
+    "int16s",
     "int32s",
     "int64s",
     "int_arrays",
     "lists_fixed_length",
-    "months",
-    "namespace_mixins",
+    "month_days",
     "numbers",
     "pairs",
     "paths",
-    "plain_datetimes",
+    "permissions",
+    "plain_date_times",
+    "py_datetimes",
+    "quadruples",
     "random_states",
     "sentinels",
     "sets_fixed_length",
@@ -1317,10 +1663,18 @@ __all__ = [
     "text_digits",
     "text_printable",
     "time_deltas",
+    "time_periods",
     "times",
     "triples",
+    "uint8s",
+    "uint16s",
     "uint32s",
     "uint64s",
+    "urls",
     "versions",
-    "zoned_datetimes",
+    "year_months",
+    "zone_infos",
+    "zoned_date_time_periods",
+    "zoned_date_times",
+    "zoned_date_times_2000",
 ]