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

utilities/hypothesis.py

@@ -32,6 +32,7 @@ from hypothesis.strategies import (
     sampled_from,
     sets,
     text,
+    timezones,
     uuids,
 )
 from hypothesis.utils.conventions import not_set
@@ -50,26 +51,35 @@ from whenever import (
     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 module_path, temp_cwd
-from utilities.platform import IS_WINDOWS
-from utilities.sentinel import Sentinel, sentinel
+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.whenever import (
@@ -86,21 +96,27 @@ from utilities.whenever import (
     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, ensure_time_zone
+from utilities.zoneinfo import UTC, to_zone_info
 
 if TYPE_CHECKING:
     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]
@@ -175,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_)
@@ -196,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,
@@ -204,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]]
@@ -212,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_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))
-    nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
+    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)
 
 
@@ -248,14 +291,14 @@ def dates(
             min_value_ = Date.MIN
         case Date():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             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)
@@ -324,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)
 
 
@@ -368,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
@@ -385,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_,
+        )
+    )
 
 
 ##
@@ -596,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_))
 
 
@@ -616,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_))
 
 
@@ -667,14 +762,14 @@ def month_days(
             min_value_ = MonthDay.MIN
         case MonthDay():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = MonthDay.MAX
         case MonthDay():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     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))
@@ -753,20 +848,16 @@ def paths(
 ) -> Path:
     """Strategy for generating `Path`s."""
     min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
-    parts = draw(
-        lists(
-            _path_parts(),
-            min_size=0 if min_depth_ is None else min_depth_,
-            max_size=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"}
+    reserved = {"AUX", "NUL", "nuL", "pRn"}
     _ = assume(part not in reserved)
     return part
 
@@ -775,7 +866,39 @@ def _path_parts(draw: DrawFn, /) -> str:
 
 
 @composite
-def plain_datetimes(
+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_date_times(
     draw: DrawFn,
     /,
     *,
@@ -789,14 +912,14 @@ def plain_datetimes(
             min_value_ = PlainDateTime.MIN
         case PlainDateTime():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = PlainDateTime.MAX
         case PlainDateTime():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     py_datetime = draw(
         datetimes(
@@ -828,6 +951,27 @@ def py_datetimes(
 ##
 
 
+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
@@ -835,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_)
 
 
@@ -882,7 +1026,7 @@ def setup_hypothesis_profiles(
                     return 100
                 case Profile.ci:
                     return 1000
-                case _ as never:
+                case never:
                     assert_never(never)
 
         @property
@@ -892,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:
@@ -1017,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)
 
 
 ##
@@ -1149,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(
@@ -1169,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,
@@ -1181,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_value_ = Time.MIN
         case Time():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = Time.MAX
         case Time():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     py_time = draw(
         hypothesis.strategies.times(
@@ -1225,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_))
 
 
@@ -1245,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."""
@@ -1286,14 +1511,14 @@ def year_months(
             min_value_ = YearMonth.MIN
         case YearMonth():
             ...
-        case _ as never:
+        case never:
             assert_never(never)
     match max_value_:
         case None:
             max_value_ = YearMonth.MAX
         case YearMonth():
             ...
-        case _ as never:
+        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))
@@ -1304,7 +1529,48 @@ def year_months(
 
 
 @composite
-def zoned_datetimes(
+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,
     /,
     *,
@@ -1312,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():
@@ -1329,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"):
+    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",
@@ -1352,6 +1622,7 @@ __all__ = [
     "assume_does_not_raise",
     "bool_arrays",
     "date_deltas",
+    "date_periods",
     "date_time_deltas",
     "dates",
     "draw2",
@@ -1363,6 +1634,8 @@ __all__ = [
     "hashables",
     "import_froms",
     "imports",
+    "int8s",
+    "int16s",
     "int32s",
     "int64s",
     "int_arrays",
@@ -1371,8 +1644,10 @@ __all__ = [
     "numbers",
     "pairs",
     "paths",
-    "plain_datetimes",
+    "permissions",
+    "plain_date_times",
     "py_datetimes",
+    "quadruples",
     "random_states",
     "sentinels",
     "sets_fixed_length",
@@ -1388,11 +1663,18 @@ __all__ = [
     "text_digits",
     "text_printable",
     "time_deltas",
+    "time_periods",
     "times",
     "triples",
+    "uint8s",
+    "uint16s",
     "uint32s",
     "uint64s",
+    "urls",
     "versions",
     "year_months",
-    "zoned_datetimes",
+    "zone_infos",
+    "zoned_date_time_periods",
+    "zoned_date_times",
+    "zoned_date_times_2000",
 ]