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

utilities/hypothesis.py

@@ -4,26 +4,16 @@ import builtins
 import datetime as dt
 from contextlib import contextmanager
 from dataclasses import dataclass
-from datetime import timezone
 from enum import Enum, auto
-from functools import partial
 from math import ceil, floor, inf, isclose, isfinite, nan
 from os import environ
 from pathlib import Path
 from re import search
 from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, printable
 from subprocess import check_call
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Literal,
-    TypeVar,
-    assert_never,
-    cast,
-    overload,
-    override,
-)
+from typing import TYPE_CHECKING, Any, Literal, assert_never, cast, overload, override
 
+import hypothesis.strategies
 from hypothesis import HealthCheck, Phase, Verbosity, assume, settings
 from hypothesis.errors import InvalidArgument
 from hypothesis.strategies import (
@@ -33,7 +23,6 @@ from hypothesis.strategies import (
     booleans,
     characters,
     composite,
-    dates,
     datetimes,
     floats,
     integers,
@@ -43,67 +32,93 @@ from hypothesis.strategies import (
     sampled_from,
     sets,
     text,
-    timedeltas,
+    timezones,
     uuids,
 )
 from hypothesis.utils.conventions import not_set
-
-from utilities.datetime import (
-    DATETIME_MAX_NAIVE,
-    DATETIME_MAX_UTC,
-    DATETIME_MIN_NAIVE,
-    DATETIME_MIN_UTC,
-    DAY,
-    MAX_DATE_TWO_DIGIT_YEAR,
-    MAX_MONTH,
-    MIN_DATE_TWO_DIGIT_YEAR,
-    MIN_MONTH,
-    Month,
-    date_duration_to_int,
-    date_duration_to_timedelta,
-    date_to_month,
-    datetime_duration_to_float,
-    datetime_duration_to_timedelta,
-    round_datetime,
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    MonthDay,
+    PlainDateTime,
+    RepeatedTime,
+    SkippedTime,
+    Time,
+    TimeDelta,
+    TimeZoneNotFoundError,
+    YearMonth,
+    ZonedDateTime,
 )
+
 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.version import Version
-from utilities.zoneinfo import UTC
+from utilities.whenever import (
+    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,
+    TIME_DELTA_MAX,
+    TIME_DELTA_MIN,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
+    get_now,
+    to_date_time_delta,
+    to_days,
+    to_nanoseconds,
+)
+from utilities.zoneinfo import UTC, to_zone_info
 
 if TYPE_CHECKING:
-    from collections.abc import Collection, Hashable, Iterable, Iterator, Sequence
+    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.ext.asyncio import AsyncEngine
+    from sqlalchemy import URL
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.sqlalchemy import Dialect, TableOrORMInstOrClass
-    from utilities.types import Duration, Number, RoundMode
+    from utilities.types import Number, TimeZone, TimeZoneLike
 
 
-_T = TypeVar("_T")
 type MaybeSearchStrategy[_T] = _T | SearchStrategy[_T]
 type Shape = int | tuple[int, ...]
 
@@ -161,175 +176,184 @@ def bool_arrays(
 
 
 @composite
-def date_durations(
+def date_deltas(
     draw: DrawFn,
     /,
     *,
-    min_int: MaybeSearchStrategy[int | None] = None,
-    max_int: MaybeSearchStrategy[int | None] = None,
-    min_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    max_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    two_way: bool = False,
-) -> Duration:
-    """Strategy for generating datetime durations."""
-    min_int_, max_int_ = [draw2(draw, v) for v in [min_int, max_int]]
-    min_timedelta_, max_timedelta_ = [
-        draw2(draw, v) for v in [min_timedelta, max_timedelta]
-    ]
-    min_parts: Sequence[dt.timedelta | None] = [dt.timedelta.min, min_timedelta_]
-    if min_int_ is not None:
-        with assume_does_not_raise(OverflowError):
-            min_parts.append(date_duration_to_timedelta(min_int_))
-    if two_way:
-        from utilities.whenever import MIN_SERIALIZABLE_TIMEDELTA
-
-        min_parts.append(MIN_SERIALIZABLE_TIMEDELTA)
-    min_timedelta_use = max_nullable(min_parts)
-    max_parts: Sequence[dt.timedelta | None] = [dt.timedelta.max, max_timedelta_]
-    if max_int_ is not None:
-        with assume_does_not_raise(OverflowError):
-            max_parts.append(date_duration_to_timedelta(max_int_))
-    if two_way:
-        from utilities.whenever import MAX_SERIALIZABLE_TIMEDELTA
-
-        max_parts.append(MAX_SERIALIZABLE_TIMEDELTA)
-    max_timedelta_use = min_nullable(max_parts)
-    _ = assume(min_timedelta_use <= max_timedelta_use)
-    st_timedeltas = (
-        timedeltas(min_value=min_timedelta_use, max_value=max_timedelta_use)
-        .map(_round_timedelta)
-        .filter(
-            partial(
-                _is_between_timedelta, min_=min_timedelta_use, max_=max_timedelta_use
-            )
-        )
-    )
-    st_integers = st_timedeltas.map(date_duration_to_int)
-    st_floats = st_integers.map(float)
-    return draw(st_integers | st_floats | st_timedeltas)
+    min_value: MaybeSearchStrategy[DateDelta | None] = None,
+    max_value: MaybeSearchStrategy[DateDelta | None] = None,
+    parsable: MaybeSearchStrategy[bool] = False,
+) -> DateDelta:
+    """Strategy for generating date deltas."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = DATE_DELTA_MIN
+        case DateDelta():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_DELTA_MAX
+        case DateDelta():
+            ...
+        case never:
+            assert_never(never)
+    min_days = to_days(min_value_)
+    max_days = to_days(max_value_)
+    if draw2(draw, parsable):
+        min_days = max(min_days, to_days(DATE_DELTA_PARSABLE_MIN))
+        max_days = min(max_days, to_days(DATE_DELTA_PARSABLE_MAX))
+    days = draw(integers(min_value=min_days, max_value=max_days))
+    return DateDelta(days=days)
 
 
-def _round_timedelta(timedelta: dt.timedelta, /) -> dt.timedelta:
-    return dt.timedelta(days=timedelta.days)
+##
 
 
-def _is_between_timedelta(
-    timedelta: dt.timedelta, /, *, min_: dt.timedelta, max_: dt.timedelta
-) -> bool:
-    return min_ <= timedelta <= max_
+@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 dates_two_digit_year(
+def date_time_deltas(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[dt.date] = MIN_DATE_TWO_DIGIT_YEAR,
-    max_value: MaybeSearchStrategy[dt.date] = MAX_DATE_TWO_DIGIT_YEAR,
-) -> dt.date:
-    """Strategy for generating dates with valid 2 digit years."""
+    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]]
-    min_value_ = max(min_value_, MIN_DATE_TWO_DIGIT_YEAR)
-    max_value_ = min(max_value_, MAX_DATE_TWO_DIGIT_YEAR)
-    return draw(dates(min_value=min_value_, max_value=max_value_))
+    match min_value_:
+        case None:
+            min_value_ = DATE_TIME_DELTA_MIN
+        case DateTimeDelta():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_TIME_DELTA_MAX
+        case DateTimeDelta():
+            ...
+        case never:
+            assert_never(never)
+    min_nanos, max_nanos = map(to_nanoseconds, [min_value_, max_value_])
+    if draw2(draw, parsable):
+        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)
 
 
 ##
 
 
 @composite
-def datetime_durations(
+def dates(
     draw: DrawFn,
     /,
     *,
-    min_number: MaybeSearchStrategy[Number | None] = None,
-    max_number: MaybeSearchStrategy[Number | None] = None,
-    min_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    max_timedelta: MaybeSearchStrategy[dt.timedelta | None] = None,
-    two_way: bool = False,
-) -> Duration:
-    """Strategy for generating datetime durations."""
-    min_number_, max_number_ = [draw2(draw, v) for v in [min_number, max_number]]
-    min_timedelta_, max_timedelta_ = [
-        draw2(draw, v) for v in [min_timedelta, max_timedelta]
-    ]
-    min_parts = [min_timedelta_, dt.timedelta.min]
-    if min_number_ is not None:
-        with assume_does_not_raise(OverflowError):
-            min_parts.append(datetime_duration_to_timedelta(min_number_))
-    if two_way:
-        from utilities.whenever import MIN_SERIALIZABLE_TIMEDELTA
-
-        min_parts.append(MIN_SERIALIZABLE_TIMEDELTA)
-    min_timedelta_use = max_nullable(min_parts)
-    max_parts = [max_timedelta_, dt.timedelta.max]
-    if max_number_ is not None:
-        with assume_does_not_raise(OverflowError):
-            max_parts.append(datetime_duration_to_timedelta(max_number_))
-    if two_way:
-        from utilities.whenever import MAX_SERIALIZABLE_TIMEDELTA
-
-        max_parts.append(MAX_SERIALIZABLE_TIMEDELTA)
-    max_timedelta_use = min_nullable(max_parts)
-    _ = assume(min_timedelta_use <= max_timedelta_use)
-    min_float_use, max_float_use = map(
-        datetime_duration_to_float, [min_timedelta_use, max_timedelta_use]
-    )
-    _ = assume(min_float_use <= max_float_use)
-    st_numbers = numbers(min_value=min_float_use, max_value=max_float_use)
-    st_timedeltas = timedeltas(min_value=min_timedelta_use, max_value=max_timedelta_use)
-    return draw(st_numbers | st_timedeltas)
+    min_value: MaybeSearchStrategy[Date | None] = None,
+    max_value: MaybeSearchStrategy[Date | None] = None,
+    two_digit: MaybeSearchStrategy[bool] = False,
+) -> Date:
+    """Strategy for generating dates."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = Date.MIN
+        case Date():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = Date.MAX
+        case Date():
+            ...
+        case never:
+            assert_never(never)
+    if draw2(draw, two_digit):
+        min_value_ = max(min_value_, DATE_TWO_DIGIT_YEAR_MIN)
+        max_value_ = min(max_value_, DATE_TWO_DIGIT_YEAR_MAX)
+    min_date, max_date = [d.py_date() for d in [min_value_, max_value_]]
+    py_date = draw(hypothesis.strategies.dates(min_value=min_date, max_value=max_date))
+    return Date.from_py_date(py_date)
 
 
 ##
 
 
 @overload
-def draw2(
+def draw2[T](
     data_or_draw: DataObject | DrawFn,
-    maybe_strategy: MaybeSearchStrategy[_T],
+    maybe_strategy: MaybeSearchStrategy[T],
     /,
     *,
     sentinel: bool = False,
-) -> _T: ...
+) -> T: ...
 @overload
-def draw2(
+def draw2[T](
     data_or_draw: DataObject | DrawFn,
-    maybe_strategy: MaybeSearchStrategy[_T | None | Sentinel],
-    default: SearchStrategy[_T | None],
+    maybe_strategy: MaybeSearchStrategy[T | None | Sentinel],
+    default: SearchStrategy[T | None],
     /,
     *,
     sentinel: Literal[True],
-) -> _T | None: ...
+) -> T | None: ...
 @overload
-def draw2(
+def draw2[T](
     data_or_draw: DataObject | DrawFn,
-    maybe_strategy: MaybeSearchStrategy[_T | None],
-    default: SearchStrategy[_T],
+    maybe_strategy: MaybeSearchStrategy[T | None],
+    default: SearchStrategy[T],
     /,
     *,
     sentinel: Literal[False] = False,
-) -> _T: ...
+) -> T: ...
 @overload
-def draw2(
+def draw2[T](
     data_or_draw: DataObject | DrawFn,
-    maybe_strategy: MaybeSearchStrategy[_T | None | Sentinel],
-    default: SearchStrategy[_T] | None = None,
+    maybe_strategy: MaybeSearchStrategy[T | None | Sentinel],
+    default: SearchStrategy[T] | None = None,
     /,
     *,
     sentinel: bool = False,
-) -> _T | None: ...
-def draw2(
+) -> T | None: ...
+def draw2[T](
     data_or_draw: DataObject | DrawFn,
-    maybe_strategy: MaybeSearchStrategy[_T | None | Sentinel],
-    default: SearchStrategy[_T | None] | None = None,
+    maybe_strategy: MaybeSearchStrategy[T | None | Sentinel],
+    default: SearchStrategy[T | None] | None = None,
     /,
     *,
     sentinel: bool = False,
-) -> _T | None:
+) -> T | None:
     """Draw an element from a strategy, unless you require it to be non-nullable."""
     draw = data_or_draw.draw if isinstance(data_or_draw, DataObject) else data_or_draw
     if isinstance(maybe_strategy, SearchStrategy):
@@ -343,21 +367,21 @@ def draw2(
             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)
 
 
@@ -387,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
@@ -404,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_,
+        )
+    )
 
 
 ##
@@ -533,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,
@@ -562,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_))
 
 
@@ -582,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_))
 
 
@@ -596,15 +725,15 @@ def int64s(
 
 
 @composite
-def lists_fixed_length(
+def lists_fixed_length[T](
     draw: DrawFn,
-    strategy: SearchStrategy[_T],
+    strategy: SearchStrategy[T],
     size: MaybeSearchStrategy[int],
     /,
     *,
     unique: MaybeSearchStrategy[bool] = False,
     sorted: MaybeSearchStrategy[bool] = False,  # noqa: A002
-) -> list[_T]:
+) -> list[T]:
     """Strategy for generating lists of a fixed length."""
     size_ = draw2(draw, size)
     elements = draw(
@@ -619,243 +748,32 @@ def lists_fixed_length(
 
 
 @composite
-def min_and_max_datetimes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.datetime | None] = None,
-    max_value: MaybeSearchStrategy[dt.datetime | None] = None,
-    time_zone: MaybeSearchStrategy[ZoneInfo | timezone] = UTC,
-    round_: RoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-    valid: bool = False,
-) -> tuple[dt.datetime, dt.datetime]:
-    """Strategy for generating min/max datetimes."""
-    match min_value, max_value:
-        case None, None:
-            return draw(
-                pairs(
-                    zoned_datetimes(
-                        time_zone=time_zone,
-                        round_=round_,
-                        timedelta=timedelta,
-                        rel_tol=rel_tol,
-                        abs_tol=abs_tol,
-                        valid=valid,
-                    ),
-                    sorted=True,
-                )
-            )
-        case None, dt.datetime():
-            min_value_ = draw(
-                zoned_datetimes(
-                    max_value=max_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value_, max_value
-        case dt.datetime(), None:
-            max_value_ = draw(
-                zoned_datetimes(
-                    min_value=min_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value, max_value_
-        case dt.datetime(), dt.datetime():
-            _ = assume(min_value <= max_value)
-            return min_value, max_value
-        case _, _:
-            strategy = zoned_datetimes(
-                time_zone=time_zone,
-                round_=round_,
-                timedelta=timedelta,
-                rel_tol=rel_tol,
-                abs_tol=abs_tol,
-                valid=valid,
-            )
-            min_value_ = draw2(draw, min_value, strategy)
-            max_value_ = draw2(draw, max_value, strategy)
-            _ = assume(min_value_ <= max_value_)
-            return min_value_, max_value_
-        case _ as never:
-            assert_never(never)
-
-
-##
-
-
-@composite
-def min_and_maybe_max_datetimes(
+def month_days(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[dt.datetime | None] = None,
-    max_value: MaybeSearchStrategy[dt.datetime | None | Sentinel] = sentinel,
-    time_zone: MaybeSearchStrategy[ZoneInfo | timezone] = UTC,
-    round_: RoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-    valid: bool = False,
-) -> tuple[dt.datetime, dt.datetime | None]:
-    match min_value, max_value:
-        case None, Sentinel():
-            min_value_, max_value_ = draw(
-                pairs(
-                    zoned_datetimes(
-                        time_zone=time_zone,
-                        round_=round_,
-                        timedelta=timedelta,
-                        rel_tol=rel_tol,
-                        abs_tol=abs_tol,
-                        valid=valid,
-                    ),
-                    sorted=True,
-                )
-            )
-            return min_value_, draw(just(max_value_) | none())
-        case None, None:
-            min_value_ = draw(
-                zoned_datetimes(
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value_, None
-        case None, dt.datetime():
-            min_value_ = draw(
-                zoned_datetimes(
-                    max_value=max_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value_, max_value
-        case dt.datetime(), Sentinel():
-            max_value_ = draw(
-                zoned_datetimes(
-                    min_value=min_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-                | none()
-            )
-            return min_value, max_value_
-        case dt.datetime(), None:
-            return min_value, None
-        case dt.datetime(), dt.datetime():
-            _ = assume(min_value <= max_value)
-            return min_value, max_value
-        case _, _:
-            strategy = zoned_datetimes(
-                time_zone=time_zone,
-                round_=round_,
-                timedelta=timedelta,
-                rel_tol=rel_tol,
-                abs_tol=abs_tol,
-                valid=valid,
-            )
-            min_value_ = draw2(draw, min_value, strategy)
-            max_value_ = draw2(draw, max_value, strategy | none(), sentinel=True)
-            _ = assume((max_value_ is None) or (min_value_ <= max_value_))
-            return min_value_, max_value_
-        case _ as never:
+    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_ = MonthDay.MIN
+        case MonthDay():
+            ...
+        case never:
             assert_never(never)
-
-
-##
-
-
-@composite
-def min_and_maybe_max_sizes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[int | None] = None,
-    max_value: MaybeSearchStrategy[int | None | Sentinel] = sentinel,
-) -> tuple[int, int | None]:
-    match min_value, max_value:
-        case None, Sentinel():
-            min_value_, max_value_ = draw(pairs(integers(min_value=0), sorted=True))
-            return min_value_, draw(just(max_value_) | none())
-        case None, None:
-            min_value_ = draw(integers(min_value=0))
-            return min_value_, None
-        case None, int():
-            min_value_ = draw(integers(0, max_value))
-            return min_value_, max_value
-        case int(), Sentinel():
-            max_value_ = draw(integers(min_value=min_value) | none())
-            return min_value, max_value_
-        case int(), None:
-            return min_value, None
-        case int(), int():
-            _ = assume(min_value <= max_value)
-            return min_value, max_value
-        case _, _:
-            strategy = integers(min_value=0)
-            min_value_ = draw2(draw, min_value, strategy)
-            max_value_ = draw2(draw, max_value, strategy | none(), sentinel=True)
-            _ = assume((max_value_ is None) or (min_value_ <= max_value_))
-            return min_value_, max_value_
-        case _ as never:
+    match max_value_:
+        case None:
+            max_value_ = MonthDay.MAX
+        case MonthDay():
+            ...
+        case never:
             assert_never(never)
-
-
-##
-
-
-@composite
-def months(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[Month] = MIN_MONTH,
-    max_value: MaybeSearchStrategy[Month] = MAX_MONTH,
-) -> Month:
-    """Strategy for generating datetimes with the UTC timezone."""
-    min_value_, max_value_ = [draw2(draw, v).to_date() for v in [min_value, max_value]]
-    date = draw(dates(min_value=min_value_, max_value=max_value_))
-    return date_to_month(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()
 
 
 ##
@@ -901,18 +819,18 @@ def numbers(
 ##
 
 
-def pairs(
-    strategy: SearchStrategy[_T],
+def pairs[T](
+    strategy: SearchStrategy[T],
     /,
     *,
     unique: MaybeSearchStrategy[bool] = False,
     sorted: MaybeSearchStrategy[bool] = False,  # noqa: A002
-) -> SearchStrategy[tuple[_T, _T]]:
+) -> SearchStrategy[tuple[T, T]]:
     """Strategy for generating pairs of elements."""
     return lists_fixed_length(strategy, 2, unique=unique, sorted=sorted).map(_pairs_map)
 
 
-def _pairs_map(elements: list[_T], /) -> tuple[_T, _T]:
+def _pairs_map[T](elements: list[T], /) -> tuple[T, T]:
     first, second = elements
     return first, second
 
@@ -920,48 +838,135 @@ def _pairs_map(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 = {"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 plain_datetimes(
+def permissions(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_NAIVE,
-    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_NAIVE,
-    round_: RoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-) -> dt.datetime:
+    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_date_times(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | None] = None,
+) -> PlainDateTime:
     """Strategy for generating plain datetimes."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    datetime = draw(datetimes(min_value=min_value_, max_value=max_value_))
-    if round_ is not None:
-        if timedelta is None:
-            raise PlainDateTimesError(round_=round_)
-        datetime = round_datetime(
-            datetime, timedelta, mode=round_, rel_tol=rel_tol, abs_tol=abs_tol
+    match min_value_:
+        case None:
+            min_value_ = PlainDateTime.MIN
+        case PlainDateTime():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = PlainDateTime.MAX
+        case PlainDateTime():
+            ...
+        case never:
+            assert_never(never)
+    py_datetime = draw(
+        datetimes(
+            min_value=min_value_.py_datetime(), max_value=max_value_.py_datetime()
         )
-        _ = assume(min_value_ <= datetime <= max_value_)
-    return datetime
+    )
+    return PlainDateTime.from_py_datetime(py_datetime)
 
 
-@dataclass(kw_only=True, slots=True)
-class PlainDateTimesError(Exception):
-    round_: RoundMode
+##
+
+
+@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,
+        )
+    )
 
-    @override
-    def __str__(self) -> str:
-        return "Rounding requires a timedelta; got None"
+
+##
+
+
+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
 
 
 ##
@@ -974,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_)
 
 
@@ -990,9 +995,9 @@ def sentinels() -> SearchStrategy[Sentinel]:
 
 
 @composite
-def sets_fixed_length(
-    draw: DrawFn, strategy: SearchStrategy[_T], size: MaybeSearchStrategy[int], /
-) -> set[_T]:
+def sets_fixed_length[T](
+    draw: DrawFn, strategy: SearchStrategy[T], size: MaybeSearchStrategy[int], /
+) -> set[T]:
     """Strategy for generating lists of a fixed length."""
     size_ = draw2(draw, size)
     return draw(sets(strategy, min_size=size_, max_size=size_))
@@ -1021,7 +1026,7 @@ def setup_hypothesis_profiles(
                     return 100
                 case Profile.ci:
                     return 1000
-                case _ as never:
+                case never:
                     assert_never(never)
 
         @property
@@ -1031,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:
@@ -1117,51 +1122,6 @@ def slices(
 ##
 
 
-_STRATEGY_DIALECTS: list[Dialect] = ["sqlite", "postgresql"]
-_SQLALCHEMY_ENGINE_DIALECTS = sampled_from(_STRATEGY_DIALECTS)
-
-
-async def sqlalchemy_engines(
-    data: DataObject,
-    /,
-    *tables_or_orms: TableOrORMInstOrClass,
-    dialect: MaybeSearchStrategy[Dialect] = _SQLALCHEMY_ENGINE_DIALECTS,
-) -> AsyncEngine:
-    """Strategy for generating sqlalchemy engines."""
-    from utilities.sqlalchemy import create_async_engine
-
-    dialect_: Dialect = draw2(data, dialect)
-    if "CI" in environ:  # pragma: no cover
-        _ = assume(dialect_ == "sqlite")
-    match dialect_:
-        case "sqlite":
-            temp_path = data.draw(temp_paths())
-            path = Path(temp_path, "db.sqlite")
-            engine = create_async_engine("sqlite+aiosqlite", database=str(path))
-
-            class EngineWithPath(type(engine)): ...
-
-            engine_with_path = EngineWithPath(engine.sync_engine)
-            cast(
-                "Any", engine_with_path
-            ).temp_path = temp_path  # keep `temp_path` alive
-            return engine_with_path
-        case "postgresql":  # skipif-ci-and-not-linux
-            from utilities.sqlalchemy import ensure_tables_dropped
-
-            engine = create_async_engine(
-                "postgresql+asyncpg", host="localhost", port=5432, database="testing"
-            )
-            with assume_does_not_raise(ConnectionRefusedError):
-                await ensure_tables_dropped(engine, *tables_or_orms)
-            return engine
-        case _:  # pragma: no cover
-            raise NotImplementedError(dialect)
-
-
-##
-
-
 @composite
 def str_arrays(
     draw: DrawFn,
@@ -1201,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)
 
 
 ##
@@ -1319,45 +1277,107 @@ def text_printable(
 
 
 @composite
-def timedeltas_2w(
+def time_deltas(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[dt.timedelta] = dt.timedelta.min,
-    max_value: MaybeSearchStrategy[dt.timedelta] = dt.timedelta.max,
-) -> dt.timedelta:
-    """Strategy for generating timedeltas which can be se/deserialized."""
-    from utilities.whenever import (
-        MAX_SERIALIZABLE_TIMEDELTA,
-        MIN_SERIALIZABLE_TIMEDELTA,
+    min_value: MaybeSearchStrategy[TimeDelta | None] = None,
+    max_value: MaybeSearchStrategy[TimeDelta | None] = None,
+) -> TimeDelta:
+    """Strategy for generating time deltas."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = TIME_DELTA_MIN
+        case TimeDelta():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = TIME_DELTA_MAX
+        case TimeDelta():
+            ...
+        case never:
+            assert_never(never)
+    py_time = draw(
+        hypothesis.strategies.timedeltas(
+            min_value=min_value_.py_timedelta(), max_value=max_value_.py_timedelta()
+        )
     )
+    return TimeDelta.from_py_timedelta(py_time)
 
+
+##
+
+
+@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]]
-    return draw(
-        timedeltas(
-            min_value=max(min_value_, MIN_SERIALIZABLE_TIMEDELTA),
-            max_value=min(max_value_, MAX_SERIALIZABLE_TIMEDELTA),
+    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,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Time | None] = None,
+    max_value: MaybeSearchStrategy[Time | None] = None,
+) -> Time:
+    """Strategy for generating times."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = Time.MIN
+        case Time():
+            ...
+        case never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = Time.MAX
+        case Time():
+            ...
+        case never:
+            assert_never(never)
+    py_time = draw(
+        hypothesis.strategies.times(
+            min_value=min_value_.py_time(), max_value=max_value_.py_time()
         )
     )
+    return Time.from_py_time(py_time)
 
 
 ##
 
 
-def triples(
-    strategy: SearchStrategy[_T],
+def triples[T](
+    strategy: SearchStrategy[T],
     /,
     *,
     unique: MaybeSearchStrategy[bool] = False,
     sorted: MaybeSearchStrategy[bool] = False,  # noqa: A002
-) -> SearchStrategy[tuple[_T, _T, _T]]:
+) -> SearchStrategy[tuple[T, T, T]]:
     """Strategy for generating triples of elements."""
     return lists_fixed_length(strategy, 3, unique=unique, sorted=sorted).map(
         _triples_map
     )
 
 
-def _triples_map(elements: list[_T], /) -> tuple[_T, _T, _T]:
+def _triples_map[T](elements: list[T], /) -> tuple[T, T, T]:
     first, second, third = elements
     return first, second, third
 
@@ -1365,18 +1385,48 @@ def _triples_map(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_))
 
 
@@ -1385,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."""
@@ -1411,80 +1496,135 @@ def versions(draw: DrawFn, /, *, suffix: MaybeSearchStrategy[bool] = False) -> V
 
 
 @composite
-def zoned_datetimes(
+def year_months(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_UTC + DAY,
-    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_UTC - DAY,
-    time_zone: MaybeSearchStrategy[ZoneInfo | timezone] = UTC,
-    round_: RoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-    valid: bool = False,
-) -> dt.datetime:
-    """Strategy for generating zoned datetimes."""
-    from utilities.whenever import (
-        CheckValidZonedDateTimeError,
-        check_valid_zoned_datetime,
-    )
+    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_ = draw2(draw, time_zone)
-    if min_value_.tzinfo is None:
-        min_value_ = min_value_.replace(tzinfo=time_zone_)
-    else:
-        with assume_does_not_raise(OverflowError, match="date value out of range"):
-            min_value_ = min_value_.astimezone(time_zone_)
-    if max_value_.tzinfo is None:
-        max_value_ = max_value_.replace(tzinfo=time_zone_)
-    else:
-        with assume_does_not_raise(OverflowError, match="date value out of range"):
-            max_value_ = max_value_.astimezone(time_zone_)
-    try:
-        datetime = draw(
-            plain_datetimes(
-                min_value=min_value_.replace(tzinfo=None),
-                max_value=max_value_.replace(tzinfo=None),
-                round_=round_,
-                timedelta=timedelta,
-                rel_tol=rel_tol,
-                abs_tol=abs_tol,
-            )
-        )
-    except PlainDateTimesError as error:
-        raise ZonedDateTimesError(round_=error.round_) from None
-    datetime = datetime.replace(tzinfo=time_zone_)
-    _ = assume(min_value_ <= datetime <= max_value_)
-    if valid:
-        with assume_does_not_raise(  # skipif-ci-and-windows
-            CheckValidZonedDateTimeError
-        ):
-            check_valid_zoned_datetime(datetime)
-    return datetime
+    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)
 
 
-@dataclass(kw_only=True, slots=True)
-class ZonedDateTimesError(Exception):
-    round_: RoundMode
+##
 
-    @override
-    def __str__(self) -> str:
-        return "Rounding requires a timedelta; got None"
 
+@composite
+def zoned_date_times(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
+) -> ZonedDateTime:
+    """Strategy for generating zoned date-times."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    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 never:
+            assert_never(never)
+    match max_value_:
+        case None | PlainDateTime():
+            ...
+        case ZonedDateTime():
+            with assume_does_not_raise(ValueError):
+                max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
+        case never:
+            assert_never(never)
+    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(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=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",
-    "PlainDateTimesError",
     "Shape",
-    "ZonedDateTimesError",
     "assume_does_not_raise",
     "bool_arrays",
-    "date_durations",
-    "dates_two_digit_year",
-    "datetime_durations",
+    "date_deltas",
+    "date_periods",
+    "date_time_deltas",
+    "dates",
     "draw2",
     "float32s",
     "float64s",
@@ -1492,27 +1632,27 @@ __all__ = [
     "floats_extra",
     "git_repos",
     "hashables",
+    "import_froms",
+    "imports",
+    "int8s",
+    "int16s",
     "int32s",
     "int64s",
     "int_arrays",
     "lists_fixed_length",
-    "min_and_max_datetimes",
-    "min_and_maybe_max_datetimes",
-    "min_and_maybe_max_sizes",
-    "min_and_maybe_max_sizes",
-    "months",
-    "namespace_mixins",
+    "month_days",
     "numbers",
     "pairs",
     "paths",
-    "plain_datetimes",
-    "plain_datetimes",
+    "permissions",
+    "plain_date_times",
+    "py_datetimes",
+    "quadruples",
     "random_states",
     "sentinels",
     "sets_fixed_length",
     "setup_hypothesis_profiles",
     "slices",
-    "sqlalchemy_engines",
     "str_arrays",
     "temp_dirs",
     "temp_paths",
@@ -1522,10 +1662,19 @@ __all__ = [
     "text_clean",
     "text_digits",
     "text_printable",
-    "timedeltas_2w",
+    "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",
 ]