fix: handle constrained datetimes

Author: adhtruong

polyfactory/factories/base.py

@@ -73,7 +73,7 @@
     handle_constrained_collection,
     handle_constrained_mapping,
 )
-from polyfactory.value_generators.constrained_dates import handle_constrained_date
+from polyfactory.value_generators.constrained_dates import handle_constrained_date, handle_constrained_datetime
 from polyfactory.value_generators.constrained_numbers import (
     handle_constrained_decimal,
     handle_constrained_float,
@@ -624,15 +624,15 @@ def create_factory(
         )
 
     @classmethod
-    def get_constrained_field_value(  # noqa: C901, PLR0911
+    def get_constrained_field_value(  # noqa: C901, PLR0911, PLR0912
         cls,
         annotation: Any,
         field_meta: FieldMeta,
         field_build_parameters: Any | None = None,
         build_context: BuildContext | None = None,
     ) -> Any:
+        constraints = cast("Constraints", field_meta.constraints)
         try:
-            constraints = cast("Constraints", field_meta.constraints)
             if is_safe_subclass(annotation, float):
                 return handle_constrained_float(
                     random=cls.__random__,
@@ -705,6 +705,16 @@ def get_constrained_field_value(  # noqa: C901, PLR0911
                     build_context=build_context,
                 )
 
+            if is_safe_subclass(annotation, datetime):
+                return handle_constrained_datetime(
+                    faker=cls.__faker__,
+                    ge=cast("Any", constraints.get("ge")),
+                    gt=cast("Any", constraints.get("gt")),
+                    le=cast("Any", constraints.get("le")),
+                    lt=cast("Any", constraints.get("lt")),
+                    tz=cast("Any", constraints.get("tz")),
+                )
+
             if is_safe_subclass(annotation, date):
                 return handle_constrained_date(
                     faker=cls.__faker__,

polyfactory/value_generators/constrained_dates.py

@@ -27,15 +27,49 @@ def handle_constrained_date(
     :returns: A date instance.
     """
     start_date = datetime.now(tz=tz).date() - timedelta(days=100)
-    if ge:
+    if ge is not None:
         start_date = ge
-    elif gt:
+    elif gt is not None:
         start_date = gt + timedelta(days=1)
 
     end_date = datetime.now(tz=timezone.utc).date() + timedelta(days=100)
-    if le:
+    if le is not None:
         end_date = le
-    elif lt:
+    elif lt is not None:
         end_date = lt - timedelta(days=1)
 
     return faker.date_between(start_date=start_date, end_date=end_date)
+
+
+def handle_constrained_datetime(
+    faker: Faker,
+    ge: datetime | None = None,
+    gt: datetime | None = None,
+    le: datetime | None = None,
+    lt: datetime | None = None,
+    tz: tzinfo | None = None,
+) -> datetime:
+    """Generates a datetime value fulfilling the expected constraints.
+
+    :param faker: An instance of faker.
+    :param lt: Less than value.
+    :param le: Less than or equal value.
+    :param gt: Greater than value.
+    :param ge: Greater than or equal value.
+    :param tz: A timezone. If not provided, infers from constraint values.
+
+    :returns: A datetime instance.
+    """
+    start_datetime = datetime.now(tz=tz) - timedelta(days=100)
+    if ge:
+        start_datetime = ge
+    elif gt:
+        start_datetime = gt + timedelta(seconds=1)
+
+    end_datetime = datetime.now(tz=tz) + timedelta(days=100)
+    if le is not None:
+        end_datetime = le
+    elif lt is not None:
+        end_datetime = lt - timedelta(seconds=1)
+
+    return faker.date_time_between(start_date=start_datetime, end_date=end_datetime, tzinfo=tz)

tests/constraints/test_date_constraints.py

@@ -1,5 +1,4 @@
 from datetime import date, timedelta
-from typing import Optional
 
 import pytest
 from hypothesis import given
@@ -14,10 +13,18 @@
     dates(max_value=date.today() - timedelta(days=3)),
     dates(min_value=date.today()),
 )
-@pytest.mark.parametrize(("start", "end"), (("ge", "le"), ("gt", "lt"), ("ge", "lt"), ("gt", "le")))
+@pytest.mark.parametrize(
+    ("start", "end"),
+    (
+        ("ge", "le"),
+        ("gt", "lt"),
+        ("ge", "lt"),
+        ("gt", "le"),
+    ),
+)
 def test_handle_constrained_date(
-    start: Optional[str],
-    end: Optional[str],
+    start: str | None,
+    end: str | None,
     start_date: date,
     end_date: date,
 ) -> None:

tests/constraints/test_datetime_constraints.py

@@ -0,0 +1,80 @@
+"""Test datetime constraints, including Issue #734."""
+
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+
+import pytest
+from annotated_types import Timezone
+from hypothesis import given
+from hypothesis.strategies import datetimes
+from typing_extensions import Literal
+
+from pydantic import BaseModel, BeforeValidator, Field
+
+from polyfactory.factories.pydantic_factory import ModelFactory
+
+
+@given(
+    datetimes(min_value=datetime(1900, 1, 1), max_value=datetime.now() - timedelta(days=3)),
+    datetimes(min_value=datetime.now(), max_value=datetime(2100, 1, 1)),
+)
+@pytest.mark.parametrize(
+    ("start", "end"),
+    (
+        ("ge", "le"),
+        ("gt", "lt"),
+        ("ge", "lt"),
+        ("gt", "le"),
+    ),
+)
+def test_handle_constrained_datetime(
+    start: Literal["ge", "gt"],
+    end: Literal["le", "lt"],
+    start_datetime: datetime,
+    end_datetime: datetime,
+) -> None:
+    """Test that constrained datetimes are generated correctly."""
+    if start_datetime == end_datetime:
+        return
+
+    kwargs: dict[Literal["ge", "gt", "le", "lt"], datetime] = {}
+    if start:
+        kwargs[start] = start_datetime
+    if end:
+        kwargs[end] = end_datetime
+
+    class MyModel(BaseModel):
+        value: datetime = Field(**kwargs)  # type: ignore
+
+    class MyFactory(ModelFactory[MyModel]): ...
+
+    result = MyFactory.build()
+
+    assert result.value
+    assert isinstance(result.value, datetime), "Should be datetime.datetime, not date"
+    assert result.value >= start_datetime if "ge" in kwargs else result.value > start_datetime
+    assert result.value <= end_datetime if "le" in kwargs else result.value < end_datetime
+
+
+def validate_datetime(value: datetime) -> datetime:
+    """Validator that expects a datetime object with timezone info."""
+    assert isinstance(value, datetime), f"Expected datetime.datetime, got {type(value)}"
+    assert value.tzinfo == timezone.utc, f"Expected UTC timezone, got {value.tzinfo}"
+    return value
+
+
+ValidatedDatetime = Annotated[datetime, BeforeValidator(validate_datetime), Timezone(tz=timezone.utc)]
+
+
+def test_annotated_datetime_with_validator_and_constraint() -> None:
+    minimum_datetime = datetime(2030, 1, 1, tzinfo=timezone.utc)
+
+    class MyModel(BaseModel):
+        dt: ValidatedDatetime = Field(gt=minimum_datetime)
+
+    class MyModelFactory(ModelFactory[MyModel]): ...
+
+    instance = MyModelFactory.build()
+    assert isinstance(instance.dt, datetime), "Should be datetime.datetime"
+    assert instance.dt.tzinfo == timezone.utc, "Should have UTC timezone"
+    assert instance.dt > minimum_datetime, "Should respect gt constraint"