model-bakery 1.19.2__py3-none-any.whl → 1.21.0__py3-none-any.whl

model_bakery/__about__.py

@@ -1 +1 @@
-__version__ = "1.19.2"
+__version__ = "1.21.0"

model_bakery/baker.py

@@ -1,16 +1,9 @@
 import collections
+from collections.abc import Callable, Iterator
 from os.path import dirname, join
 from typing import (
     Any,
-    Callable,
-    Dict,
     Generic,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Type,
-    Union,
     cast,
     overload,
 )
@@ -27,6 +20,7 @@ from django.db.models import (
     Model,
     OneToOneField,
 )
+from django.db.models.fields import NOT_PROVIDED
 from django.db.models.fields.proxy import OrderWrt
 from django.db.models.fields.related import (
     ReverseManyToOneDescriptor as ForeignRelatedObjectsDescriptor,
@@ -65,20 +59,24 @@ mock_file_txt = join(dirname(__file__), "mock_file.txt")
 MAX_MANY_QUANTITY = 5
 
 
-def _valid_quantity(quantity: Optional[Union[str, int]]) -> bool:
+def _valid_quantity(quantity: str | int | None) -> bool:
     return quantity is not None and (not isinstance(quantity, int) or quantity < 1)
 
 
-def seed(seed: Union[int, float, str, bytes, bytearray, None]) -> None:
+def _is_auto_datetime_field(field: Field) -> bool:
+    return getattr(field, "auto_now_add", False) or getattr(field, "auto_now", False)
+
+
+def seed(seed: int | float | str | bytes | bytearray | None) -> None:
     Baker.seed(seed)
 
 
 @overload
 def make(
-    _model: Union[str, Type[M]],
+    _model: str | type[M],
     _quantity: None = None,
     make_m2m: bool = False,
-    _save_kwargs: Optional[Dict] = None,
+    _save_kwargs: dict[str, Any] | None = None,
     _refresh_after_create: bool = False,
     _create_files: bool = False,
     _using: str = "",
@@ -89,29 +87,29 @@ def make(
 
 @overload
 def make(
-    _model: Union[str, Type[M]],
+    _model: str | type[M],
     _quantity: int,
     make_m2m: bool = False,
-    _save_kwargs: Optional[Dict] = None,
+    _save_kwargs: dict[str, Any] | None = None,
     _refresh_after_create: bool = False,
     _create_files: bool = False,
     _using: str = "",
     _bulk_create: bool = False,
-    _fill_optional: Union[List[str], bool] = False,
+    _fill_optional: list[str] | bool = False,
     **attrs: Any,
-) -> List[M]: ...
+) -> list[M]: ...
 
 
 def make(
     _model,
-    _quantity: Optional[int] = None,
+    _quantity: int | None = None,
     make_m2m: bool = False,
-    _save_kwargs: Optional[Dict] = None,
+    _save_kwargs: dict[str, Any] | None = None,
     _refresh_after_create: bool = False,
     _create_files: bool = False,
     _using: str = "",
     _bulk_create: bool = False,
-    _fill_optional: Union[List[str], bool] = False,
+    _fill_optional: list[str] | bool = False,
     **attrs: Any,
 ):
     """Create a persisted instance from a given model its associated models.
@@ -146,32 +144,32 @@ def make(
 
 @overload
 def prepare(
-    _model: Union[str, Type[M]],
+    _model: str | type[M],
     _quantity: None = None,
     _save_related: bool = False,
     _using: str = "",
-    **attrs,
+    **attrs: Any,
 ) -> M: ...
 
 
 @overload
 def prepare(
-    _model: Union[str, Type[M]],
+    _model: str | type[M],
     _quantity: int,
     _save_related: bool = False,
     _using: str = "",
-    _fill_optional: Union[List[str], bool] = False,
-    **attrs,
-) -> List[M]: ...
+    _fill_optional: list[str] | bool = False,
+    **attrs: Any,
+) -> list[M]: ...
 
 
 def prepare(
-    _model: Union[str, Type[M]],
-    _quantity: Optional[int] = None,
+    _model: str | type[M],
+    _quantity: int | None = None,
     _save_related: bool = False,
     _using: str = "",
-    _fill_optional: Union[List[str], bool] = False,
-    **attrs,
+    _fill_optional: list[str] | bool = False,
+    **attrs: Any,
 ):
     """Create but do not persist an instance from a given model.
 
@@ -219,10 +217,10 @@ def prepare_recipe(
 class ModelFinder:
     """Encapsulates all the logic for finding a model to Baker."""
 
-    _unique_models: Optional[Dict[str, Type[Model]]] = None
-    _ambiguous_models: Optional[List[str]] = None
+    _unique_models: dict[str, type[Model]] | None = None
+    _ambiguous_models: list[str] | None = None
 
-    def get_model(self, name: str) -> Type[Model]:
+    def get_model(self, name: str) -> type[Model]:
         """Get a model.
 
         Args:
@@ -246,7 +244,7 @@ class ModelFinder:
 
         return model
 
-    def get_model_by_name(self, name: str) -> Optional[Type[Model]]:
+    def get_model_by_name(self, name: str) -> type[Model] | None:
         """Get a model by name.
 
         If a model with that name exists in more than one app, raises
@@ -257,13 +255,13 @@ class ModelFinder:
         if self._unique_models is None or self._ambiguous_models is None:
             self._populate()
 
-        if name in cast(List, self._ambiguous_models):
+        if name in cast(list, self._ambiguous_models):
             raise AmbiguousModelName(
                 f"{name.title()} is a model in more than one app. "
                 'Use the form "app.model".'
             )
 
-        return cast(Dict, self._unique_models).get(name)
+        return cast(dict, self._unique_models).get(name)
 
     def _populate(self) -> None:
         """Cache models for faster self._get_model."""
@@ -290,7 +288,7 @@ def is_iterator(value: Any) -> bool:
     return isinstance(value, collections.abc.Iterator)
 
 
-def _custom_baker_class() -> Optional[Type]:
+def _custom_baker_class() -> type | None:
     """Return the specified custom baker class.
 
     Returns:
@@ -321,54 +319,54 @@ def _custom_baker_class() -> Optional[Type]:
 class Baker(Generic[M]):
     SENTINEL = object()
 
-    attr_mapping: Dict[str, Any] = {}
-    type_mapping: Dict = {}
+    attr_mapping: dict[str, Any] = {}
+    type_mapping: dict = {}
 
-    _global_seed: Union[object, int, float, str, bytes, bytearray, None] = SENTINEL
+    _global_seed: object | int | float | str | bytes | bytearray | None = SENTINEL
 
     # Note: we're using one finder for all Baker instances to avoid
     # rebuilding the model cache for every make_* or prepare_* call.
     finder = ModelFinder()
 
     @classmethod
-    def seed(cls, seed: Union[int, float, str, bytes, bytearray, None]) -> None:
+    def seed(cls, seed: int | float | str | bytes | bytearray | None) -> None:
         random_gen.baker_random.seed(seed)
         cls._global_seed = seed
 
     @classmethod
     def create(
         cls,
-        _model: Union[str, Type[NewM]],
+        _model: str | type[NewM],
         make_m2m: bool = False,
         create_files: bool = False,
         _using: str = "",
     ) -> "Baker[NewM]":
         """Create the baker class defined by the `BAKER_CUSTOM_CLASS` setting."""
         baker_class = _custom_baker_class() or cls
-        return cast(Type[Baker[NewM]], baker_class)(
+        return cast(type[Baker[NewM]], baker_class)(
             _model, make_m2m, create_files, _using=_using
         )
 
     def __init__(
         self,
-        _model: Union[str, Type[M]],
+        _model: str | type[M],
         make_m2m: bool = False,
         create_files: bool = False,
         _using: str = "",
     ) -> None:
         self.make_m2m = make_m2m
         self.create_files = create_files
-        self.m2m_dict: Dict[str, List] = {}
-        self.iterator_attrs: Dict[str, Iterator] = {}
-        self.model_attrs: Dict[str, Any] = {}
-        self.rel_attrs: Dict[str, Any] = {}
-        self.rel_fields: List[str] = []
+        self.m2m_dict: dict[str, list] = {}
+        self.iterator_attrs: dict[str, Iterator] = {}
+        self.model_attrs: dict[str, Any] = {}
+        self.rel_attrs: dict[str, Any] = {}
+        self.rel_fields: list[str] = []
         self._using = _using
 
         if isinstance(_model, str):
-            self.model = cast(Type[M], self.finder.get_model(_model))
+            self.model = cast(type[M], self.finder.get_model(_model))
         else:
-            self.model = cast(Type[M], _model)
+            self.model = cast(type[M], _model)
 
         self.init_type_mapping()
 
@@ -382,10 +380,10 @@ class Baker(Generic[M]):
 
     def make(
         self,
-        _save_kwargs: Optional[Dict[str, Any]] = None,
+        _save_kwargs: dict[str, Any] | None = None,
         _refresh_after_create: bool = False,
         _from_manager=None,
-        _fill_optional: Union[List[str], bool] = False,
+        _fill_optional: list[str] | bool = False,
         **attrs: Any,
     ):
         """Create and persist an instance of the model associated with Baker instance."""
@@ -403,7 +401,7 @@ class Baker(Generic[M]):
     def prepare(
         self,
         _save_related=False,
-        _fill_optional: Union[List[str], bool] = False,
+        _fill_optional: list[str] | bool = False,
         **attrs: Any,
     ) -> M:
         """Create, but do not persist, an instance of the associated model."""
@@ -415,7 +413,7 @@ class Baker(Generic[M]):
         params.update(attrs)
         return self._make(**params)
 
-    def get_fields(self) -> Set[Any]:
+    def get_fields(self) -> set[Any]:
         return set(self.model._meta.get_fields()) - set(
             self.model._meta.related_objects
         )
@@ -489,7 +487,7 @@ class Baker(Generic[M]):
 
         return instance
 
-    def m2m_value(self, field: ManyToManyField) -> List[Any]:
+    def m2m_value(self, field: ManyToManyField) -> list[Any]:
         if field.name in self.rel_fields:
             return self.generate_value(field)
         if not self.make_m2m or field.null and not field.fill_optional:
@@ -497,7 +495,7 @@ class Baker(Generic[M]):
         return self.generate_value(field)
 
     def instance(
-        self, attrs: Dict[str, Any], _commit, _save_kwargs, _from_manager
+        self, attrs: dict[str, Any], _commit, _save_kwargs, _from_manager
     ) -> M:
         one_to_many_keys = {}
         auto_now_keys = {}
@@ -512,10 +510,7 @@ class Baker(Generic[M]):
             if isinstance(field, ForeignRelatedObjectsDescriptor):
                 one_to_many_keys[k] = attrs.pop(k)
 
-            if hasattr(field, "field") and (
-                getattr(field.field, "auto_now_add", False)
-                or getattr(field.field, "auto_now", False)
-            ):
+            if hasattr(field, "field") and _is_auto_datetime_field(field.field):
                 auto_now_keys[k] = attrs[k]
 
             if BAKER_CONTENTTYPES and isinstance(field, GenericForeignKey):
@@ -523,6 +518,7 @@ class Baker(Generic[M]):
                     "value": attrs.pop(k),
                     "content_type_field": field.ct_field,
                     "object_id_field": field.fk_field,
+                    "for_concrete_model": field.for_concrete_model,
                 }
 
         instance = self.model(**attrs)
@@ -546,7 +542,7 @@ class Baker(Generic[M]):
         return instance
 
     def create_by_related_name(
-        self, instance: Model, related: Union[ManyToOneRel, OneToOneRel]
+        self, instance: Model, related: ManyToOneRel | OneToOneRel
     ) -> None:
         rel_name = related.get_accessor_name()
         if not rel_name or rel_name not in self.rel_fields:
@@ -557,7 +553,7 @@ class Baker(Generic[M]):
 
         make(related.field.model, **kwargs)
 
-    def _clean_attrs(self, attrs: Dict[str, Any]) -> None:
+    def _clean_attrs(self, attrs: dict[str, Any]) -> None:
         def is_rel_field(x: str):
             return "__" in x
 
@@ -638,13 +634,18 @@ class Baker(Generic[M]):
 
         return False
 
-    def _handle_auto_now(self, instance: Model, attrs: Dict[str, Any]):
+    def _handle_auto_now(self, instance: Model, attrs: dict[str, Any]):
         if not attrs:
             return
 
+        # use .update() to force update auto_now fields
         instance.__class__.objects.filter(pk=instance.pk).update(**attrs)
 
-    def _handle_one_to_many(self, instance: Model, attrs: Dict[str, Any]):
+        # to make the resulting instance has the specified values
+        for k, v in attrs.items():
+            setattr(instance, k, v)
+
+    def _handle_one_to_many(self, instance: Model, attrs: dict[str, Any]):
         for key, values in attrs.items():
             manager = getattr(instance, key)
 
@@ -692,26 +693,38 @@ class Baker(Generic[M]):
                     }
                     make(through_model, _using=self._using, **base_kwargs)
 
-    def _handle_generic_foreign_keys(self, instance: Model, attrs: Dict[str, Any]):
+    def _handle_generic_foreign_keys(self, instance: Model, attrs: dict[str, Any]):
         """Set content type and object id for GenericForeignKey fields."""
         for field_name, data in attrs.items():
-            content_type_field = data["content_type_field"]
-            object_id_field = data["object_id_field"]
+            ct_field_name = data["content_type_field"]
+            oid_field_name = data["object_id_field"]
             value = data["value"]
+            if callable(value):
+                value = value()
             if is_iterator(value):
                 value = next(value)
-
-            setattr(instance, field_name, value)
-            setattr(
-                instance,
-                content_type_field,
-                contenttypes_models.ContentType.objects.get_for_model(value),
-            )
-            setattr(instance, object_id_field, value.pk)
+            if value is None:
+                # when GFK is None, we should try to set the content type and object id to None
+                content_type_field = instance._meta.get_field(ct_field_name)
+                object_id_field = instance._meta.get_field(oid_field_name)
+                if content_type_field.null:
+                    setattr(instance, ct_field_name, None)
+                if object_id_field.null:
+                    setattr(instance, oid_field_name, None)
+            else:
+                setattr(instance, field_name, value)
+                setattr(
+                    instance,
+                    ct_field_name,
+                    contenttypes_models.ContentType.objects.get_for_model(
+                        value, for_concrete_model=data["for_concrete_model"]
+                    ),
+                )
+                setattr(instance, oid_field_name, value.pk)
 
     def _remote_field(
-        self, field: Union[ForeignKey, OneToOneField]
-    ) -> Union[OneToOneRel, ManyToOneRel]:
+        self, field: ForeignKey | OneToOneField
+    ) -> OneToOneRel | ManyToOneRel:
         return field.remote_field
 
     def generate_value(self, field: Field, commit: bool = True) -> Any:  # noqa: C901
@@ -719,6 +732,7 @@ class Baker(Generic[M]):
 
         Generator Resolution Precedence Order:
         -- `field.default` - model field default value, unless explicitly overwritten during baking
+        -- `field.db_default` - model field db default value, unless explicitly overwritten
         -- `attr_mapping` - mapping per attribute name
         -- `choices` -- mapping from available field choices
         -- `type_mapping` - mapping from user defined type associated generators
@@ -742,10 +756,14 @@ class Baker(Generic[M]):
             if callable(field.default):
                 return field.default()
             return field.default
+        elif getattr(field, "db_default", NOT_PROVIDED) != NOT_PROVIDED:
+            return field.db_default
         elif field.name in self.attr_mapping:
             generator = self.attr_mapping[field.name]
         elif field.choices:
-            generator = random_gen.gen_from_choices(field.choices)
+            generator = random_gen.gen_from_choices(
+                field.choices, nullable=field.null, blankable=field.blank
+            )
         elif is_content_type_fk:
             generator = self.type_mapping[contenttypes_models.ContentType]
         elif generators.get(field.__class__):
@@ -780,14 +798,14 @@ class Baker(Generic[M]):
 
 def get_required_values(
     generator: Callable, field: Field
-) -> Dict[str, Union[bool, int, str, List[Callable]]]:
+) -> dict[str, bool | int | str | list[Callable]]:
     """Get required values for a generator from the field.
 
     If required value is a function, calls it with field as argument. If
     required value is a string, simply fetch the value from the field
     and return.
     """
-    required_values = {}  # type: Dict[str, Any]
+    required_values = {}  # type: dict[str, Any]
     if hasattr(generator, "required"):
         for item in generator.required:  # type: ignore[attr-defined]
             if callable(item):  # baker can deal with the nasty hacking too!
@@ -805,7 +823,7 @@ def get_required_values(
     return required_values
 
 
-def filter_rel_attrs(field_name: str, **rel_attrs) -> Dict[str, Any]:
+def filter_rel_attrs(field_name: str, **rel_attrs) -> dict[str, Any]:
     clean_dict = {}
 
     for k, v in rel_attrs.items():
@@ -841,7 +859,7 @@ def _save_related_objs(model, objects, _using=None) -> None:
                 setattr(objects[i], fk.name, fk_obj)
 
 
-def bulk_create(baker: Baker[M], quantity: int, **kwargs) -> List[M]:
+def bulk_create(baker: Baker[M], quantity: int, **kwargs) -> list[M]:
     """
     Bulk create entries and all related FKs as well.
 

model_bakery/generators.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
 from decimal import Decimal
-from typing import Any, Callable, Dict, Optional, Type, Union
+from typing import Any
 
 from django.db.backends.base.operations import BaseDatabaseOperations
 from django.db.models import (
@@ -108,7 +109,7 @@ default_mapping = {
     DecimalField: random_gen.gen_decimal,
     BinaryField: random_gen.gen_byte_string,
     CharField: random_gen.gen_string,
-    TextField: random_gen.gen_text,
+    TextField: random_gen.gen_string,
     SlugField: random_gen.gen_slug,
     UUIDField: random_gen.gen_uuid,
     DateField: random_gen.gen_date,
@@ -122,7 +123,7 @@ default_mapping = {
     ImageField: random_gen.gen_image_field,
     DurationField: random_gen.gen_interval,
     JSONField: random_gen.gen_json,
-}  # type: Dict[Type, Callable]
+}  # type: dict[type, Callable]
 
 if ArrayField:
     default_mapping[ArrayField] = random_gen.gen_array
@@ -133,7 +134,7 @@ if CICharField:
 if CIEmailField:
     default_mapping[CIEmailField] = random_gen.gen_email
 if CITextField:
-    default_mapping[CITextField] = random_gen.gen_text
+    default_mapping[CITextField] = random_gen.gen_string
 if DecimalRangeField:
     default_mapping[DecimalRangeField] = random_gen.gen_pg_numbers_range(Decimal)
 if IntegerRangeField:
@@ -149,7 +150,7 @@ if DateTimeRangeField:
 # Add GIS fields
 
 
-def get_type_mapping() -> Dict[Type, Callable]:
+def get_type_mapping() -> dict[type, Callable]:
     from .content_types import default_contenttypes_mapping
     from .gis import default_gis_mapping
 
@@ -162,9 +163,9 @@ def get_type_mapping() -> Dict[Type, Callable]:
 user_mapping = {}
 
 
-def add(field: str, func: Optional[Union[Callable, str]]) -> None:
+def add(field: str, func: Callable | str | None) -> None:
     user_mapping[import_from_str(field)] = import_from_str(func)
 
 
-def get(field: Any) -> Optional[Callable]:
+def get(field: Any) -> Callable | None:
     return user_mapping.get(field)

model_bakery/random_gen.py

@@ -11,11 +11,12 @@ argument.
 
 import string
 import warnings
+from collections.abc import Callable
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from os.path import abspath, dirname, join
 from random import Random
-from typing import Any, Callable, List, Optional, Tuple, Union
+from typing import Any
 from uuid import UUID
 
 from django.core.files.base import ContentFile
@@ -48,7 +49,7 @@ def gen_image_field() -> ContentFile:
         return get_content_file(f.read(), name=name)
 
 
-def gen_from_list(a_list: Union[List[str], range]) -> Callable:
+def gen_from_list(a_list: list[str] | range) -> Callable:
     """Make sure all values of the field are generated from a list.
 
     Examples:
@@ -65,14 +66,22 @@ def gen_from_list(a_list: Union[List[str], range]) -> Callable:
 # -- DEFAULT GENERATORS --
 
 
-def gen_from_choices(choices: List) -> Callable:
+def gen_from_choices(
+    choices: list, nullable: bool = True, blankable: bool = True
+) -> Callable:
     choice_list = []
     for value, label in choices:
+        if not nullable and value is None:
+            continue
+        if not blankable and value == "":
+            continue
+
         if isinstance(label, (list, tuple)):
             for val, _lbl in label:
                 choice_list.append(val)
         else:
             choice_list.append(value)
+
     return gen_from_list(choice_list)
 
 
@@ -80,8 +89,13 @@ def gen_integer(min_int: int = -MAX_INT, max_int: int = MAX_INT) -> int:
     return baker_random.randint(min_int, max_int)
 
 
-def gen_float() -> float:
-    return baker_random.random() * gen_integer()
+def gen_float(min_float: float = -1000000.0, max_float: float = 1000000.0) -> float:
+    """
+    Generate a random float uniformly distributed between `min_float` and `max_float`.
+
+    Defaults to ±1,000,000.0 which is suitable for most test data scenarios.
+    """
+    return baker_random.uniform(min_float, max_float)
 
 
 def gen_decimal(max_digits: int, decimal_places: int) -> Decimal:
@@ -115,7 +129,7 @@ def gen_string(max_length: int) -> str:
     return "".join(baker_random.choice(string.ascii_letters) for _ in range(max_length))
 
 
-def _gen_string_get_max_length(field: Field) -> Tuple[str, int]:
+def _gen_string_get_max_length(field: Field) -> tuple[str, int]:
     max_length = getattr(field, "max_length", None)
     if max_length is None:
         max_length = MAX_LENGTH
@@ -134,6 +148,15 @@ gen_slug.required = ["max_length"]  # type: ignore[attr-defined]
 
 
 def gen_text() -> str:
+    warnings.warn(
+        "\n"
+        "Accessing `model_bakery.random_gen.gen_text` is deprecated "
+        "and will be removed in a future major release. Please use "
+        "`model_bakery.random_gen.gen_string` instead."
+        "\n",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     return gen_string(MAX_LENGTH)
 
 
@@ -166,7 +189,7 @@ def gen_ipv46() -> str:
     return ip_gen()
 
 
-def gen_ip(protocol: str, default_validators: List[Callable]) -> str:
+def gen_ip(protocol: str, default_validators: list[Callable]) -> str:
     from django.core.exceptions import ValidationError
 
     protocol = (protocol or "").lower()
@@ -203,9 +226,18 @@ def gen_byte_string(max_length: int = 16) -> bytes:
     return bytes(generator)
 
 
-def gen_interval(interval_key: str = "milliseconds", offset: int = 0) -> timedelta:
-    interval = gen_integer() + offset
-    kwargs = {interval_key: interval}
+def gen_interval(
+    interval_key: str = "milliseconds",
+    min_interval: int = -365 * 24 * 60 * 60 * 1000,
+    max_interval: int = 365 * 24 * 60 * 60 * 1000,
+) -> timedelta:
+    """
+    Generate a random timedelta for `DurationField` or date range calculations.
+
+    Defaults to ±1 year in milliseconds, suitable for most test scenarios.
+    The `interval_key` determines which timedelta argument is set (e.g., 'seconds', 'days').
+    """
+    kwargs = {interval_key: baker_random.randint(min_interval, max_interval)}
     return timedelta(**kwargs)
 
 
@@ -244,7 +276,7 @@ def gen_hstore():
     return {}
 
 
-def _fk_model(field: Field) -> Tuple[str, Optional[Model]]:
+def _fk_model(field: Field) -> tuple[str, Model | None]:
     try:
         return ("model", field.related_model)
     except AttributeError:
@@ -253,7 +285,7 @@ def _fk_model(field: Field) -> Tuple[str, Optional[Model]]:
 
 def _prepare_related(
     model: str, _create_files=False, **attrs: Any
-) -> Union[Model, List[Model]]:
+) -> Model | list[Model]:
     from .baker import prepare
 
     return prepare(model, **attrs)
@@ -333,37 +365,56 @@ def gen_geometry_collection() -> str:
 
 
 def gen_pg_numbers_range(number_cast: Callable[[int], Any]) -> Callable:
+    """
+    Factory that returns a generator for PostgreSQL numeric range fields.
+
+    The returned generator creates ranges like [-N, N] where N is a random value
+    between 1 and 100,000, cast to the appropriate numeric type (int, float, etc).
+    """
+
     def gen_range():
         try:
             from psycopg.types.range import Range
         except ImportError:
             from psycopg2._range import NumericRange as Range
 
-        base_num = gen_integer(1, 100000)
+        base_num = baker_random.randint(1, 100000)
         return Range(number_cast(-1 * base_num), number_cast(base_num))
 
     return gen_range
 
 
 def gen_date_range():
+    """
+    Generate random `DateRange` for PostgreSQL `DateRangeField`.
+
+    The range spans a random date with a minimum interval of 1 day
+    to avoid empty ranges in tests.
+    """
     try:
         from psycopg.types.range import DateRange
     except ImportError:
         from psycopg2.extras import DateRange
 
     base_date = gen_date()
-    interval = gen_interval(offset=24 * 60 * 60 * 1000)  # force at least 1 day interval
+    interval = gen_interval(min_interval=24 * 60 * 60 * 1000)
     args = sorted([base_date - interval, base_date + interval])
     return DateRange(*args)
 
 
 def gen_datetime_range():
+    """
+    Generate random `TimestamptzRange` for PostgreSQL DateTimeRangeField.
+
+    The range spans a random datetime with a minimum interval of 1 day
+    to avoid empty ranges in tests.
+    """
     try:
         from psycopg.types.range import TimestamptzRange
     except ImportError:
         from psycopg2.extras import DateTimeTZRange as TimestamptzRange
 
     base_datetime = gen_datetime()
-    interval = gen_interval()
+    interval = gen_interval(min_interval=24 * 60 * 60 * 1000)
     args = sorted([base_datetime - interval, base_datetime + interval])
     return TimestamptzRange(*args)

model_bakery/recipe.py

@@ -1,14 +1,10 @@
 import collections
+import copy
 import itertools
 from typing import (
     Any,
-    Dict,
     Generic,
-    List,
-    Optional,
-    Type,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -29,15 +25,15 @@ finder = baker.ModelFinder()
 class Recipe(Generic[M]):
     _T = TypeVar("_T", bound="Recipe[M]")
 
-    def __init__(self, _model: Union[str, Type[M]], **attrs: Any) -> None:
+    def __init__(self, _model: str | type[M], **attrs: Any) -> None:
         self.attr_mapping = attrs
         self._model = _model
         # _iterator_backups will hold values of the form (backup_iterator, usable_iterator).
-        self._iterator_backups = {}  # type: Dict[str, Any]
+        self._iterator_backups = {}  # type: dict[str, Any]
 
     def _mapping(  # noqa: C901
-        self, _using: str, new_attrs: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, _using: str, new_attrs: dict[str, Any]
+    ) -> dict[str, Any]:
         _save_related = new_attrs.get("_save_related", True)
         _quantity = new_attrs.get("_quantity", 1)
         rel_fields_attrs = {k: v for k, v in new_attrs.items() if "__" in k}
@@ -79,6 +75,8 @@ class Recipe(Generic[M]):
                     mapping[k] = v.recipe.prepare(_using=_using, **recipe_attrs)
             elif isinstance(v, related):
                 mapping[k] = v.make
+            elif isinstance(v, collections.abc.Container):
+                mapping[k] = copy.deepcopy(v)
 
         mapping.update(new_attrs)
         mapping.update(rel_fields_attrs)
@@ -93,7 +91,7 @@ class Recipe(Generic[M]):
         _create_files: bool = False,
         _using: str = "",
         _bulk_create: bool = False,
-        _save_kwargs: Optional[Dict[str, Any]] = None,
+        _save_kwargs: dict[str, Any] | None = None,
         **attrs: Any,
     ) -> M: ...
 
@@ -106,21 +104,21 @@ class Recipe(Generic[M]):
         _create_files: bool = False,
         _using: str = "",
         _bulk_create: bool = False,
-        _save_kwargs: Optional[Dict[str, Any]] = None,
+        _save_kwargs: dict[str, Any] | None = None,
         **attrs: Any,
-    ) -> List[M]: ...
+    ) -> list[M]: ...
 
     def make(
         self,
-        _quantity: Optional[int] = None,
-        make_m2m: Optional[bool] = None,
-        _refresh_after_create: Optional[bool] = None,
-        _create_files: Optional[bool] = None,
+        _quantity: int | None = None,
+        make_m2m: bool | None = None,
+        _refresh_after_create: bool | None = None,
+        _create_files: bool | None = None,
         _using: str = "",
-        _bulk_create: Optional[bool] = None,
-        _save_kwargs: Optional[Dict[str, Any]] = None,
+        _bulk_create: bool | None = None,
+        _save_kwargs: dict[str, Any] | None = None,
         **attrs: Any,
-    ) -> Union[M, List[M]]:
+    ) -> M | list[M]:
         defaults = {}
         if _quantity is not None:
             defaults["_quantity"] = _quantity
@@ -154,19 +152,21 @@ class Recipe(Generic[M]):
         _save_related: bool = False,
         _using: str = "",
         **attrs: Any,
-    ) -> List[M]: ...
+    ) -> list[M]: ...
 
     def prepare(
         self,
-        _quantity: Optional[int] = None,
+        _quantity: int | None = None,
         _save_related: bool = False,
         _using: str = "",
         **attrs: Any,
-    ) -> Union[M, List[M]]:
+    ) -> M | list[M]:
         defaults = {
-            "_quantity": _quantity,
             "_save_related": _save_related,
         }
+        if _quantity is not None:
+            defaults["_quantity"] = _quantity  # type: ignore[assignment]
+
         defaults.update(attrs)
         return baker.prepare(
             self._model, _using=_using, **self._mapping(_using, defaults)
@@ -207,7 +207,7 @@ class RecipeForeignKey(Generic[M]):
 
 
 def foreign_key(
-    recipe: Union[Recipe[M], str], one_to_one: bool = False
+    recipe: Recipe[M] | str, one_to_one: bool = False
 ) -> RecipeForeignKey[M]:
     """Return a `RecipeForeignKey`.
 
@@ -230,8 +230,8 @@ def foreign_key(
 
 
 class related(Generic[M]):  # FIXME
-    def __init__(self, *args: Union[str, Recipe[M]]) -> None:
-        self.related = []  # type: List[Recipe[M]]
+    def __init__(self, *args: str | Recipe[M]) -> None:
+        self.related = []  # type: list[Recipe[M]]
         for recipe in args:
             if isinstance(recipe, Recipe):
                 self.related.append(recipe)
@@ -244,6 +244,6 @@ class related(Generic[M]):  # FIXME
             else:
                 raise TypeError("Not a recipe")
 
-    def make(self) -> List[Union[M, List[M]]]:
+    def make(self) -> list[M | list[M]]:
         """Persist objects to m2m relation."""
         return [m.make() for m in self.related]

model_bakery/timezone.py

@@ -8,6 +8,6 @@ from django.conf import settings
 def tz_aware(value: datetime) -> datetime:
     """Return an UTC-aware datetime in case of USE_TZ=True."""
     if settings.USE_TZ:
-        value = value.replace(tzinfo=timezone.utc)
+        return value.replace(tzinfo=timezone.utc)
 
-    return value
+    return value.replace(tzinfo=None)

model_bakery/utils.py

@@ -3,8 +3,9 @@ import importlib
 import inspect
 import itertools
 import warnings
+from collections.abc import Callable
 from types import ModuleType
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 from django.apps import apps
 
@@ -13,7 +14,7 @@ from .timezone import tz_aware
 __all__ = ["import_from_str", "get_calling_module", "seq"]
 
 
-def import_from_str(import_string: Optional[Union[Callable, str]]) -> Any:
+def import_from_str(import_string: Callable | str | None) -> Any:
     """Import an object defined as import if it is an string.
 
     If `import_string` follows the format `path.to.module.object_name`,
@@ -33,7 +34,7 @@ def import_from_str(import_string: Optional[Union[Callable, str]]) -> Any:
     return import_string
 
 
-def get_calling_module(levels_back: int) -> Optional[ModuleType]:
+def get_calling_module(levels_back: int) -> ModuleType | None:
     """Get the module some number of stack frames back from the current one.
 
     Make sure to account for the number of frames between the "calling" code
@@ -86,7 +87,10 @@ def seq(value, increment_by=1, start=None, suffix=None):
         start = (date - epoch_datetime).total_seconds()
         increment_by = increment_by.total_seconds()
         for n in itertools.count(increment_by, increment_by):
-            series_date = tz_aware(datetime.datetime.utcfromtimestamp(start + n))
+            series_date = tz_aware(
+                datetime.datetime.fromtimestamp(start + n, tz=datetime.timezone.utc)
+            )
+
             if type(value) is datetime.time:
                 yield series_date.time()
             elif type(value) is datetime.date:

{model_bakery-1.19.2.dist-info → model_bakery-1.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: model-bakery
-Version: 1.19.2
+Version: 1.21.0
 Summary: Smart object creation facility for Django.
 Project-URL: Homepage, https://github.com/model-bakers/model_bakery
 Author-email: berin <bernardoxhc@gmail.com>, amureki <amureki@hey.com>
@@ -12,18 +12,20 @@ Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
 Classifier: Framework :: Django :: 5.0
 Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: django>=4.2
 Provides-Extra: docs
 Requires-Dist: myst-parser; extra == 'docs'
@@ -46,76 +48,83 @@ Description-Content-Type: text/markdown
 [![Latest PyPI version](https://img.shields.io/pypi/v/model_bakery.svg)](https://pypi.python.org/pypi/model_bakery/)
 [![Documentation Status](https://readthedocs.org/projects/model-bakery/badge/?version=latest)](https://model-bakery.readthedocs.io/en/latest/?badge=latest)
 
-*Model Bakery* offers you a smart way to create fixtures for testing in
-Django.
-With a simple and powerful API you can create many objects with a single
-line of code.
+*Model Bakery* offers you a smart way to create fixtures for testing in Django. With a simple and powerful API, you can create many objects with a single line of code.
 
-Model Bakery is a rename of the legacy [Model Mommy project](https://pypi.org/project/model_mommy/).
+> **Note:** Model Bakery is a rename of the legacy [Model Mommy project](https://pypi.org/project/model_mommy/).
 
-## Install
+## Installation
 
 ```bash
 pip install model-bakery
 ```
 
-## Usage and Info
+## Supported Versions
 
-### Basic usage
+Model Bakery follows the [Python](https://devguide.python.org/versions/) and [Django](https://docs.djangoproject.com/en/stable/internals/release-process/#supported-versions) release and support cycles. We drop support for Python and Django versions when they reach end-of-life.
 
-```python
+## Basic usage
 
+```python
 # models.py
-
 from django.db import models
 
 class Customer(models.Model):
-    enjoy_jards_macale = models.BooleanField()
     name = models.CharField(max_length=30)
     email = models.EmailField()
     age = models.IntegerField()
+    is_jards_macale_fan = models.BooleanField()
     bio = models.TextField()
-    days_since_last_login = models.BigIntegerField()
     birthday = models.DateField()
     last_shopping = models.DateTimeField()
 
 # test_models.py
-
 from django.test import TestCase
 from model_bakery import baker
-from pprint import pprint
 
 class TestCustomerModel(TestCase):
     def setUp(self):
         self.customer = baker.make('shop.Customer')
-        pprint(self.customer.__dict__)
+        print(self.customer.__dict__)
 
 """
 {'_state': <django.db.models.base.ModelState object at 0x1129a3240>,
  'age': 3841,
  'bio': 'vUFzMUMyKzlnTyiCxfgODIhrnkjzgQwHtzIbtnVDKflqevczfnaOACkDNqvCHwvtWdLwoiKrCqfppAlogSLECtMmfleeveyqefkGyTGnpbkVQTtviQVDESpXascHAluGHYEotSypSiHvHzFteKIcUebrzUVigiOacfnGdvijEPrZdSCIIBjuXZMaWLrMXyrsUCdKPLRBRYklRdtZhgtxuASXdhNGhDsrnPHrYRClhrSJSVFojMkUHBvSZhoXoCrTfHsAjenCEHvcLeCecsXwXgWJcnJPSFdOmOpiHRnhSgRF',
  'birthday': datetime.date(2019, 12, 3),
- 'enjoy_jards_macale': True,
+ 'email': 'rpNATNsxoj@example.com',
+ 'is_jards_macale_fan': True,
  'id': 1,
  'last_shopping': datetime.datetime(2019, 12, 3, 21, 42, 34, 77019),
- 'name': 'qiayYnESvqcYLLBzxpFOcGBIfnQEPx',
- 'days_since_last_login': 6016}
+ 'name': 'qiayYnESvqcYLLBzxpFOcGBIfnQEPx'}
 """
-
 ```
 
-Check out [documentation](<http://model-bakery.readthedocs.org/>) for more complete examples.
+## Documentation
+
+For more detailed information, check out the [full documentation](https://model-bakery.readthedocs.io/).
 
 ## Contributing
 
-Detailed info [here](https://github.com/model-bakers/model_bakery/blob/main/CONTRIBUTING.md).
+As an open-source project, Model Bakery welcomes contributions of many forms:
+
+- Code patches
+- Documentation improvements
+- Bug reports
+
+Take a look at our [contribution guidelines](CONTRIBUTING.md) for instructions
+on how to set up your local environment.
 
 ## Maintainers
 
-  - [Bernardo Fontes](https://github.com/berinhard/)
-  - [Rustem Saiargaliev](https://github.com/amureki/)
-  - [Tim Klein](https://github.com/timjklein36)
+- [Bernardo Fontes](https://github.com/berinhard/)
+- [Rustem Saiargaliev](https://github.com/amureki/)
+- [Tim Klein](https://github.com/timjklein36)
 
 ## Creator
 
-  - [Vanderson Mota](https://github.com/vandersonmota/)
+- [Vanderson Mota](https://github.com/vandersonmota/)
+
+## License
+
+Model Bakery is licensed under Apache License 2.0.
+See the [LICENSE](LICENSE) file for more information.

model_bakery-1.21.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+model_bakery/__about__.py,sha256=oQdy_VDKQZm6_UKnVHbkyIDnpqXxS3OREilFLTax8MU,23
+model_bakery/__init__.py,sha256=yY0xZUrr_mskBm07iF-MFBEiXzOuKrlMwpKWkXZs8v0,31
+model_bakery/_types.py,sha256=P0iKC5-Cnh3lyzyZs1mlCfOW31zbEZpxqWCuYonucKo,130
+model_bakery/baker.py,sha256=tjsldeGJUEyIKjhIb3AXt2AjIKJ4MXZKRFJxSqH3_j0,31295
+model_bakery/content_types.py,sha256=3POJ12aqPuSvCdKYuwb1GlJpSocgByG2JW5kw7VBNxQ,395
+model_bakery/exceptions.py,sha256=q1oBZvfxL7HAD-F9aWgiYs4P4rz-hJ5TjeX7gcb3Q0I,333
+model_bakery/generators.py,sha256=pV8amdkkAGbf3ES7fIiRrRyYwKHVXzIe9eN7kR_Mms0,5159
+model_bakery/gis.py,sha256=eTNOfT98_ncLAb4KmOYJhE-3ALU2_pQbUpWPTolFZJI,1028
+model_bakery/mock_file.txt,sha256=CO5zPS6Uydk48ZRnGcRKVEYKd2YjaUMa9QOgF5gGMCo,10
+model_bakery/mock_img.jpeg,sha256=iF2ybgAVtDvl48-8VKdv_QFHKfnqeOaeGwR6ZLexJkY,1916
+model_bakery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model_bakery/random_gen.py,sha256=A_quvJAsihqI7JP94kbJEDTX_yNa76MPIn_p2OFWdVo,11508
+model_bakery/recipe.py,sha256=Ok0cQzX8IKpQLHjf-_kQPdlVRmSt-GPrhJsRBh7tp2g,8450
+model_bakery/timezone.py,sha256=IvrzSer02FkUd_8DcJVOwTcRzeBn4qZ2pYvcI3QOr9E,345
+model_bakery/utils.py,sha256=H7iASipUahE6mluEbP3cZnCkRdY4qfN3QHD7rxoYZZM,4633
+model_bakery-1.21.0.dist-info/METADATA,sha256=771BJtN6L4f4dFuhxpSWYwa1T7Sxj92BbHwksr8tHDU,4961
+model_bakery-1.21.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+model_bakery-1.21.0.dist-info/licenses/LICENSE,sha256=kCwHls7z8Y7NyZCmdnV1qLSdLrQ8bHrXLji5HOasgUc,611
+model_bakery-1.21.0.dist-info/RECORD,,

{model_bakery-1.19.2.dist-info → model_bakery-1.21.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

model_bakery-1.19.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-model_bakery/__about__.py,sha256=V14nqouh0fns5BAgWrw5Aw8DW-D9yIY3TtnyECKUNxM,23
-model_bakery/__init__.py,sha256=yY0xZUrr_mskBm07iF-MFBEiXzOuKrlMwpKWkXZs8v0,31
-model_bakery/_types.py,sha256=P0iKC5-Cnh3lyzyZs1mlCfOW31zbEZpxqWCuYonucKo,130
-model_bakery/baker.py,sha256=NSDx3hezvEG0HpWVXJd1uJPLxhJjc2tI-ipCzMbmWvw,30140
-model_bakery/content_types.py,sha256=3POJ12aqPuSvCdKYuwb1GlJpSocgByG2JW5kw7VBNxQ,395
-model_bakery/exceptions.py,sha256=q1oBZvfxL7HAD-F9aWgiYs4P4rz-hJ5TjeX7gcb3Q0I,333
-model_bakery/generators.py,sha256=agY6pH14vjehVI0wJDw3Q-u4zt7mq2M1a3CUPTkAxp0,5169
-model_bakery/gis.py,sha256=eTNOfT98_ncLAb4KmOYJhE-3ALU2_pQbUpWPTolFZJI,1028
-model_bakery/mock_file.txt,sha256=CO5zPS6Uydk48ZRnGcRKVEYKd2YjaUMa9QOgF5gGMCo,10
-model_bakery/mock_img.jpeg,sha256=iF2ybgAVtDvl48-8VKdv_QFHKfnqeOaeGwR6ZLexJkY,1916
-model_bakery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-model_bakery/random_gen.py,sha256=IYhDhqsRBftceQRHtc9B4bUWLTjvEXkgEwhNhp9DajE,9787
-model_bakery/recipe.py,sha256=3PVg8y-vvfOf7Z4o9J7QPoO8eegGmejFCVWco19AWIs,8378
-model_bakery/timezone.py,sha256=rd-KGVHqJoHdHKBgENPMBTRqqxgKE91CM9C0f9nS90M,325
-model_bakery/utils.py,sha256=fw4ewtwkJ6wZ9PbDzBGvODX7CV81ozy2_6JAQmITmX4,4581
-model_bakery-1.19.2.dist-info/METADATA,sha256=LjZgSNHtbrNUhoAHVpEwA0dgPudklKLP9jtJMkfYo0g,4355
-model_bakery-1.19.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-model_bakery-1.19.2.dist-info/licenses/LICENSE,sha256=kCwHls7z8Y7NyZCmdnV1qLSdLrQ8bHrXLji5HOasgUc,611
-model_bakery-1.19.2.dist-info/RECORD,,