diff options
Diffstat (limited to 'venv/lib/python3.11/site-packages/polyfactory/value_generators')
22 files changed, 1155 insertions, 0 deletions
diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__init__.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__init__.py diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/__init__.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..c95bde0 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/__init__.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/complex_types.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/complex_types.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..b99a526 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/complex_types.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_collections.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_collections.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..bb33c8a --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_collections.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_dates.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_dates.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..f649c36 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_dates.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_numbers.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_numbers.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..926ca52 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_numbers.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_path.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_path.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..5808e81 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_path.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_strings.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_strings.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..53efa2f --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_strings.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_url.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_url.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..4dd4ad5 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_url.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_uuid.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_uuid.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..e653a72 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/constrained_uuid.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/primitives.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/primitives.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..97787ad --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/primitives.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/regex.cpython-311.pyc b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/regex.cpython-311.pyc Binary files differnew file mode 100644 index 0000000..319510e --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/__pycache__/regex.cpython-311.pyc diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/complex_types.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/complex_types.py new file mode 100644 index 0000000..2706891 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/complex_types.py @@ -0,0 +1,111 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, AbstractSet, Any, Iterable, MutableMapping, MutableSequence, Set, Tuple, cast + +from typing_extensions import is_typeddict + +from polyfactory.constants import INSTANTIABLE_TYPE_MAPPING, PY_38 +from polyfactory.field_meta import FieldMeta +from polyfactory.utils.model_coverage import CoverageContainer + +if TYPE_CHECKING: + from polyfactory.factories.base import BaseFactory + + +def handle_collection_type(field_meta: FieldMeta, container_type: type, factory: type[BaseFactory[Any]]) -> Any: + """Handle generation of container types recursively. + + :param container_type: A type that can accept type arguments. + :param factory: A factory. + :param field_meta: A field meta instance. + + :returns: A built result. + """ + + if PY_38 and container_type in INSTANTIABLE_TYPE_MAPPING: + container_type = INSTANTIABLE_TYPE_MAPPING[container_type] # type: ignore[assignment] + + container = container_type() + if not field_meta.children: + return container + + if issubclass(container_type, MutableMapping) or is_typeddict(container_type): + for key_field_meta, value_field_meta in cast( + Iterable[Tuple[FieldMeta, FieldMeta]], + zip(field_meta.children[::2], field_meta.children[1::2]), + ): + key = factory.get_field_value(key_field_meta) + value = factory.get_field_value(value_field_meta) + container[key] = value + return container + + if issubclass(container_type, MutableSequence): + container.extend([factory.get_field_value(subfield_meta) for subfield_meta in field_meta.children]) + return container + + if issubclass(container_type, Set): + for subfield_meta in field_meta.children: + container.add(factory.get_field_value(subfield_meta)) + return container + + if issubclass(container_type, AbstractSet): + return container.union(handle_collection_type(field_meta, set, factory)) + + if issubclass(container_type, tuple): + return container_type(map(factory.get_field_value, field_meta.children)) + + msg = f"Unsupported container type: {container_type}" + raise NotImplementedError(msg) + + +def handle_collection_type_coverage( + field_meta: FieldMeta, + container_type: type, + factory: type[BaseFactory[Any]], +) -> Any: + """Handle coverage generation of container types recursively. + + :param container_type: A type that can accept type arguments. + :param factory: A factory. + :param field_meta: A field meta instance. + + :returns: An unresolved built result. + """ + container = container_type() + if not field_meta.children: + return container + + if issubclass(container_type, MutableMapping) or is_typeddict(container_type): + for key_field_meta, value_field_meta in cast( + Iterable[Tuple[FieldMeta, FieldMeta]], + zip(field_meta.children[::2], field_meta.children[1::2]), + ): + key = CoverageContainer(factory.get_field_value_coverage(key_field_meta)) + value = CoverageContainer(factory.get_field_value_coverage(value_field_meta)) + container[key] = value + return container + + if issubclass(container_type, MutableSequence): + container_instance = container_type() + for subfield_meta in field_meta.children: + container_instance.extend(factory.get_field_value_coverage(subfield_meta)) + + return container_instance + + if issubclass(container_type, Set): + set_instance = container_type() + for subfield_meta in field_meta.children: + set_instance = set_instance.union(factory.get_field_value_coverage(subfield_meta)) + + return set_instance + + if issubclass(container_type, AbstractSet): + return container.union(handle_collection_type_coverage(field_meta, set, factory)) + + if issubclass(container_type, tuple): + return container_type( + CoverageContainer(factory.get_field_value_coverage(subfield_meta)) for subfield_meta in field_meta.children + ) + + msg = f"Unsupported container type: {container_type}" + raise NotImplementedError(msg) diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_collections.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_collections.py new file mode 100644 index 0000000..405d02d --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_collections.py @@ -0,0 +1,92 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Callable, List, Mapping, TypeVar, cast + +from polyfactory.exceptions import ParameterException +from polyfactory.field_meta import FieldMeta + +if TYPE_CHECKING: + from polyfactory.factories.base import BaseFactory + +T = TypeVar("T", list, set, frozenset) + + +def handle_constrained_collection( + collection_type: Callable[..., T], + factory: type[BaseFactory[Any]], + field_meta: FieldMeta, + item_type: Any, + max_items: int | None = None, + min_items: int | None = None, + unique_items: bool = False, +) -> T: + """Generate a constrained list or set. + + :param collection_type: A type that can accept type arguments. + :param factory: A factory. + :param field_meta: A field meta instance. + :param item_type: Type of the collection items. + :param max_items: Maximal number of items. + :param min_items: Minimal number of items. + :param unique_items: Whether the items should be unique. + + :returns: A collection value. + """ + min_items = abs(min_items if min_items is not None else (max_items or 0)) + max_items = abs(max_items if max_items is not None else min_items + 1) + + if max_items < min_items: + msg = "max_items must be larger or equal to min_items" + raise ParameterException(msg) + + collection: set[T] | list[T] = set() if (collection_type in (frozenset, set) or unique_items) else [] + + try: + length = factory.__random__.randint(min_items, max_items) or 1 + while len(collection) < length: + value = factory.get_field_value(field_meta) + if isinstance(collection, set): + collection.add(value) + else: + collection.append(value) + return collection_type(collection) + except TypeError as e: + msg = f"cannot generate a constrained collection of type: {item_type}" + raise ParameterException(msg) from e + + +def handle_constrained_mapping( + factory: type[BaseFactory[Any]], + field_meta: FieldMeta, + max_items: int | None = None, + min_items: int | None = None, +) -> Mapping[Any, Any]: + """Generate a constrained mapping. + + :param factory: A factory. + :param field_meta: A field meta instance. + :param max_items: Maximal number of items. + :param min_items: Minimal number of items. + + :returns: A mapping instance. + """ + min_items = abs(min_items if min_items is not None else (max_items or 0)) + max_items = abs(max_items if max_items is not None else min_items + 1) + + if max_items < min_items: + msg = "max_items must be larger or equal to min_items" + raise ParameterException(msg) + + length = factory.__random__.randint(min_items, max_items) or 1 + + collection: dict[Any, Any] = {} + + children = cast(List[FieldMeta], field_meta.children) + key_field_meta = children[0] + value_field_meta = children[1] + while len(collection) < length: + key = factory.get_field_value(key_field_meta) + value = factory.get_field_value(value_field_meta) + collection[key] = value + + return collection diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_dates.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_dates.py new file mode 100644 index 0000000..4e92601 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_dates.py @@ -0,0 +1,41 @@ +from __future__ import annotations + +from datetime import date, datetime, timedelta, timezone, tzinfo +from typing import TYPE_CHECKING, cast + +if TYPE_CHECKING: + from faker import Faker + + +def handle_constrained_date( + faker: Faker, + ge: date | None = None, + gt: date | None = None, + le: date | None = None, + lt: date | None = None, + tz: tzinfo = timezone.utc, +) -> date: + """Generates a date 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. + + :returns: A date instance. + """ + start_date = datetime.now(tz=tz).date() - timedelta(days=100) + if ge: + start_date = ge + elif gt: + start_date = gt + timedelta(days=1) + + end_date = datetime.now(tz=timezone.utc).date() + timedelta(days=100) + if le: + end_date = le + elif lt: + end_date = lt - timedelta(days=1) + + return cast("date", faker.date_between(start_date=start_date, end_date=end_date)) diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_numbers.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_numbers.py new file mode 100644 index 0000000..23516ce --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_numbers.py @@ -0,0 +1,440 @@ +from __future__ import annotations + +from decimal import Decimal +from sys import float_info +from typing import TYPE_CHECKING, Any, Protocol, TypeVar, cast + +from polyfactory.exceptions import ParameterException +from polyfactory.value_generators.primitives import create_random_decimal, create_random_float, create_random_integer + +if TYPE_CHECKING: + from random import Random + +T = TypeVar("T", Decimal, int, float) + + +class NumberGeneratorProtocol(Protocol[T]): + """Protocol for custom callables used to generate numerical values""" + + def __call__(self, random: "Random", minimum: T | None = None, maximum: T | None = None) -> T: + """Signature of the callable. + + :param random: An instance of random. + :param minimum: A minimum value. + :param maximum: A maximum value. + :return: The generated numeric value. + """ + ... + + +def almost_equal_floats(value_1: float, value_2: float, *, delta: float = 1e-8) -> bool: + """Return True if two floats are almost equal + + :param value_1: A float value. + :param value_2: A float value. + :param delta: A minimal delta. + + :returns: Boolean dictating whether the floats can be considered equal - given python's problematic comparison of floats. + """ + return abs(value_1 - value_2) <= delta + + +def is_multiply_of_multiple_of_in_range( + minimum: T, + maximum: T, + multiple_of: T, +) -> bool: + """Determine if at least one multiply of `multiple_of` lies in the given range. + + :param minimum: T: A minimum value. + :param maximum: T: A maximum value. + :param multiple_of: T: A value to use as a base for multiplication. + + :returns: Boolean dictating whether at least one multiply of `multiple_of` lies in the given range between minimum and maximum. + """ + + # if the range has infinity on one of its ends then infinite number of multipliers + # can be found within the range + + # if we were given floats and multiple_of is really close to zero then it doesn't make sense + # to continue trying to check the range + if ( + isinstance(minimum, float) + and isinstance(multiple_of, float) + and minimum / multiple_of in [float("+inf"), float("-inf")] + ): + return False + + multiplier = round(minimum / multiple_of) + step = 1 if multiple_of > 0 else -1 + + # since rounding can go either up or down we may end up in a situation when + # minimum is less or equal to `multiplier * multiple_of` + # or when it is greater than `multiplier * multiple_of` + # (in this case minimum is less than `(multiplier + 1)* multiple_of`). So we need to check + # that any of two values is inside the given range. ASCII graphic below explain this + # + # minimum + # -----------------+-------+-----------------------------------+---------------------------- + # + # + # minimum + # -------------------------+--------+--------------------------+---------------------------- + # + # since `multiple_of` can be a negative number adding +1 to `multiplier` drives `(multiplier + 1) * multiple_of`` + # away from `minimum` to the -infinity. It looks like this: + # minimum + # -----------------------+--------------------------------+------------------------+-------- + # + # so for negative `multiple_of` we want to subtract 1 from multiplier + for multiply in [multiplier * multiple_of, (multiplier + step) * multiple_of]: + multiply_float = float(multiply) + if ( + almost_equal_floats(multiply_float, float(minimum)) + or almost_equal_floats(multiply_float, float(maximum)) + or minimum < multiply < maximum + ): + return True + + return False + + +def passes_pydantic_multiple_validator(value: T, multiple_of: T) -> bool: + """Determine whether a given value passes the pydantic multiple_of validation. + + :param value: A numeric value. + :param multiple_of: Another numeric value. + + :returns: Boolean dictating whether value is a multiple of value. + + """ + if multiple_of == 0: + return True + mod = float(value) / float(multiple_of) % 1 + return almost_equal_floats(mod, 0.0) or almost_equal_floats(mod, 1.0) + + +def get_increment(t_type: type[T]) -> T: + """Get a small increment base to add to constrained values, i.e. lt/gt entries. + + :param t_type: A value of type T. + + :returns: An increment T. + """ + values: dict[Any, Any] = { + int: 1, + float: float_info.epsilon, + Decimal: Decimal("0.001"), + } + return cast("T", values[t_type]) + + +def get_value_or_none( + t_type: type[T], + lt: T | None = None, + le: T | None = None, + gt: T | None = None, + ge: T | None = None, +) -> tuple[T | None, T | None]: + """Return an optional value. + + :param equal_value: An GE/LE value. + :param constrained: An GT/LT value. + :param increment: increment + + :returns: Optional T. + """ + if ge is not None: + minimum_value = ge + elif gt is not None: + minimum_value = gt + get_increment(t_type) + else: + minimum_value = None + + if le is not None: + maximum_value = le + elif lt is not None: + maximum_value = lt - get_increment(t_type) + else: + maximum_value = None + return minimum_value, maximum_value + + +def get_constrained_number_range( + t_type: type[T], + random: Random, + lt: T | None = None, + le: T | None = None, + gt: T | None = None, + ge: T | None = None, + multiple_of: T | None = None, +) -> tuple[T | None, T | None]: + """Return the minimum and maximum values given a field_meta's constraints. + + :param t_type: A primitive constructor - int, float or Decimal. + :param random: An instance of Random. + :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 multiple_of: Multiple of value. + + :returns: a tuple of optional minimum and maximum values. + """ + seed = t_type(random.random() * 10) + minimum, maximum = get_value_or_none(lt=lt, le=le, gt=gt, ge=ge, t_type=t_type) + + if minimum is not None and maximum is not None and maximum < minimum: + msg = "maximum value must be greater than minimum value" + raise ParameterException(msg) + + if multiple_of is None: + if minimum is not None and maximum is None: + return ( + (minimum, seed) if minimum == 0 else (minimum, minimum + seed) + ) # pyright: ignore[reportGeneralTypeIssues] + if maximum is not None and minimum is None: + return maximum - seed, maximum + else: + if multiple_of == 0.0: # TODO: investigate @guacs # noqa: PLR2004, FIX002 + msg = "multiple_of can not be zero" + raise ParameterException(msg) + if ( + minimum is not None + and maximum is not None + and not is_multiply_of_multiple_of_in_range(minimum=minimum, maximum=maximum, multiple_of=multiple_of) + ): + msg = "given range should include at least one multiply of multiple_of" + raise ParameterException(msg) + + return minimum, maximum + + +def generate_constrained_number( + random: Random, + minimum: T | None, + maximum: T | None, + multiple_of: T | None, + method: "NumberGeneratorProtocol[T]", +) -> T: + """Generate a constrained number, output depends on the passed in callbacks. + + :param random: An instance of random. + :param minimum: A minimum value. + :param maximum: A maximum value. + :param multiple_of: A multiple of value. + :param method: A function that generates numbers of type T. + + :returns: A value of type T. + """ + if minimum is None or maximum is None: + return multiple_of if multiple_of is not None else method(random=random) + if multiple_of is None: + return method(random=random, minimum=minimum, maximum=maximum) + if multiple_of >= minimum: + return multiple_of + result = minimum + while not passes_pydantic_multiple_validator(result, multiple_of): + result = round(method(random=random, minimum=minimum, maximum=maximum) / multiple_of) * multiple_of + return result + + +def handle_constrained_int( + random: Random, + multiple_of: int | None = None, + gt: int | None = None, + ge: int | None = None, + lt: int | None = None, + le: int | None = None, +) -> int: + """Handle constrained integers. + + :param random: An instance of Random. + :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 multiple_of: Multiple of value. + + :returns: An integer. + + """ + + minimum, maximum = get_constrained_number_range( + gt=gt, + ge=ge, + lt=lt, + le=le, + t_type=int, + multiple_of=multiple_of, + random=random, + ) + return generate_constrained_number( + random=random, + minimum=minimum, + maximum=maximum, + multiple_of=multiple_of, + method=create_random_integer, + ) + + +def handle_constrained_float( + random: Random, + multiple_of: float | None = None, + gt: float | None = None, + ge: float | None = None, + lt: float | None = None, + le: float | None = None, +) -> float: + """Handle constrained floats. + + :param random: An instance of Random. + :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 multiple_of: Multiple of value. + + :returns: A float. + """ + + minimum, maximum = get_constrained_number_range( + gt=gt, + ge=ge, + lt=lt, + le=le, + t_type=float, + multiple_of=multiple_of, + random=random, + ) + + return generate_constrained_number( + random=random, + minimum=minimum, + maximum=maximum, + multiple_of=multiple_of, + method=create_random_float, + ) + + +def validate_max_digits( + max_digits: int, + minimum: Decimal | None, + decimal_places: int | None, +) -> None: + """Validate that max digits is greater than minimum and decimal places. + + :param max_digits: The maximal number of digits for the decimal. + :param minimum: Minimal value. + :param decimal_places: Number of decimal places + + :returns: 'None' + + """ + if max_digits <= 0: + msg = "max_digits must be greater than 0" + raise ParameterException(msg) + + if minimum is not None: + min_str = str(minimum).split(".")[1] if "." in str(minimum) else str(minimum) + + if max_digits <= len(min_str): + msg = "minimum is greater than max_digits" + raise ParameterException(msg) + + if decimal_places is not None and max_digits <= decimal_places: + msg = "max_digits must be greater than decimal places" + raise ParameterException(msg) + + +def handle_decimal_length( + generated_decimal: Decimal, + decimal_places: int | None, + max_digits: int | None, +) -> Decimal: + """Handle the length of the decimal. + + :param generated_decimal: A decimal value. + :param decimal_places: Number of decimal places. + :param max_digits: Maximal number of digits. + + """ + string_number = str(generated_decimal) + sign = "-" if "-" in string_number else "+" + string_number = string_number.replace("-", "") + whole_numbers, decimals = string_number.split(".") + + if ( + max_digits is not None + and decimal_places is not None + and len(whole_numbers) + decimal_places > max_digits + or (max_digits is None or decimal_places is None) + and max_digits is not None + ): + max_decimals = max_digits - len(whole_numbers) + elif max_digits is not None: + max_decimals = decimal_places # type: ignore[assignment] + else: + max_decimals = cast("int", decimal_places) + + if max_decimals < 0: # pyright: ignore[reportOptionalOperand] + return Decimal(sign + whole_numbers[:max_decimals]) + + decimals = decimals[:max_decimals] + return Decimal(sign + whole_numbers + "." + decimals[:decimal_places]) + + +def handle_constrained_decimal( + random: Random, + multiple_of: Decimal | None = None, + decimal_places: int | None = None, + max_digits: int | None = None, + gt: Decimal | None = None, + ge: Decimal | None = None, + lt: Decimal | None = None, + le: Decimal | None = None, +) -> Decimal: + """Handle a constrained decimal. + + :param random: An instance of Random. + :param multiple_of: Multiple of value. + :param decimal_places: Number of decimal places. + :param max_digits: Maximal number of digits. + :param lt: Less than value. + :param le: Less than or equal value. + :param gt: Greater than value. + :param ge: Greater than or equal value. + + :returns: A decimal. + + """ + + minimum, maximum = get_constrained_number_range( + gt=gt, + ge=ge, + lt=lt, + le=le, + multiple_of=multiple_of, + t_type=Decimal, + random=random, + ) + + if max_digits is not None: + validate_max_digits(max_digits=max_digits, minimum=minimum, decimal_places=decimal_places) + + generated_decimal = generate_constrained_number( + random=random, + minimum=minimum, + maximum=maximum, + multiple_of=multiple_of, + method=create_random_decimal, + ) + + if max_digits is not None or decimal_places is not None: + return handle_decimal_length( + generated_decimal=generated_decimal, + max_digits=max_digits, + decimal_places=decimal_places, + ) + + return generated_decimal diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_path.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_path.py new file mode 100644 index 0000000..debaf86 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_path.py @@ -0,0 +1,13 @@ +from os.path import realpath +from pathlib import Path +from typing import Literal, cast + +from faker import Faker + + +def handle_constrained_path(constraint: Literal["file", "dir", "new"], faker: Faker) -> Path: + if constraint == "new": + return cast("Path", faker.file_path(depth=1, category=None, extension=None)) + if constraint == "file": + return Path(realpath(__file__)) + return Path(realpath(__file__)).parent diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_strings.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_strings.py new file mode 100644 index 0000000..c7da72b --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_strings.py @@ -0,0 +1,138 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Callable, Pattern, TypeVar, Union, cast + +from polyfactory.exceptions import ParameterException +from polyfactory.value_generators.primitives import create_random_bytes, create_random_string +from polyfactory.value_generators.regex import RegexFactory + +T = TypeVar("T", bound=Union[bytes, str]) + +if TYPE_CHECKING: + from random import Random + + +def _validate_length( + min_length: int | None = None, + max_length: int | None = None, +) -> None: + """Validate the length parameters make sense. + + :param min_length: Minimum length. + :param max_length: Maximum length. + + :raises: ParameterException. + + :returns: None. + """ + if min_length is not None and min_length < 0: + msg = "min_length must be greater or equal to 0" + raise ParameterException(msg) + + if max_length is not None and max_length < 0: + msg = "max_length must be greater or equal to 0" + raise ParameterException(msg) + + if max_length is not None and min_length is not None and max_length < min_length: + msg = "max_length must be greater than min_length" + raise ParameterException(msg) + + +def _generate_pattern( + random: Random, + pattern: str | Pattern, + lower_case: bool = False, + upper_case: bool = False, + min_length: int | None = None, + max_length: int | None = None, +) -> str: + """Generate a regex. + + :param random: An instance of random. + :param pattern: A regex or string pattern. + :param lower_case: Whether to lowercase the result. + :param upper_case: Whether to uppercase the result. + :param min_length: A minimum length. + :param max_length: A maximum length. + + :returns: A string matching the given pattern. + """ + regex_factory = RegexFactory(random=random) + result = regex_factory(pattern) + if min_length: + while len(result) < min_length: + result += regex_factory(pattern) + + if max_length is not None and len(result) > max_length: + result = result[:max_length] + + if lower_case: + result = result.lower() + + if upper_case: + result = result.upper() + + return result + + +def handle_constrained_string_or_bytes( + random: Random, + t_type: Callable[[], T], + lower_case: bool = False, + upper_case: bool = False, + min_length: int | None = None, + max_length: int | None = None, + pattern: str | Pattern | None = None, +) -> T: + """Handle constrained string or bytes, for example - pydantic `constr` or `conbytes`. + + :param random: An instance of random. + :param t_type: A type (str or bytes) + :param lower_case: Whether to lowercase the result. + :param upper_case: Whether to uppercase the result. + :param min_length: A minimum length. + :param max_length: A maximum length. + :param pattern: A regex or string pattern. + + :returns: A value of type T. + """ + _validate_length(min_length=min_length, max_length=max_length) + + if max_length == 0: + return t_type() + + if pattern: + return cast( + "T", + _generate_pattern( + random=random, + pattern=pattern, + lower_case=lower_case, + upper_case=upper_case, + min_length=min_length, + max_length=max_length, + ), + ) + + if t_type is str: + return cast( + "T", + create_random_string( + min_length=min_length, + max_length=max_length, + lower_case=lower_case, + upper_case=upper_case, + random=random, + ), + ) + + return cast( + "T", + create_random_bytes( + min_length=min_length, + max_length=max_length, + lower_case=lower_case, + upper_case=upper_case, + random=random, + ), + ) diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_url.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_url.py new file mode 100644 index 0000000..d29555e --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_url.py @@ -0,0 +1,10 @@ +from polyfactory.field_meta import UrlConstraints + + +def handle_constrained_url(constraints: UrlConstraints) -> str: + schema = (constraints.get("allowed_schemes") or ["http", "https"])[0] + default_host = constraints.get("default_host") or "localhost" + default_port = constraints.get("default_port") or 80 + default_path = constraints.get("default_path") or "" + + return f"{schema}://{default_host}:{default_port}{default_path}" diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_uuid.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_uuid.py new file mode 100644 index 0000000..053f047 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/constrained_uuid.py @@ -0,0 +1,31 @@ +from typing import Literal, cast +from uuid import NAMESPACE_DNS, UUID, uuid1, uuid3, uuid5 + +from faker import Faker + +UUID_VERSION_1 = 1 +UUID_VERSION_3 = 3 +UUID_VERSION_4 = 4 +UUID_VERSION_5 = 5 + + +def handle_constrained_uuid(uuid_version: Literal[1, 3, 4, 5], faker: Faker) -> UUID: + """Generate a UUID based on the version specified. + + Args: + uuid_version: The version of the UUID to generate. + faker: The Faker instance to use. + + Returns: + The generated UUID. + """ + if uuid_version == UUID_VERSION_1: + return uuid1() + if uuid_version == UUID_VERSION_3: + return uuid3(NAMESPACE_DNS, faker.pystr()) + if uuid_version == UUID_VERSION_4: + return cast("UUID", faker.uuid4()) + if uuid_version == UUID_VERSION_5: + return uuid5(NAMESPACE_DNS, faker.pystr()) + msg = f"Unknown UUID version: {uuid_version}" + raise ValueError(msg) diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/primitives.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/primitives.py new file mode 100644 index 0000000..2cf6b41 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/primitives.py @@ -0,0 +1,129 @@ +from __future__ import annotations + +from binascii import hexlify +from decimal import Decimal +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from random import Random + + +def create_random_float( + random: Random, + minimum: Decimal | float | None = None, + maximum: Decimal | float | None = None, +) -> float: + """Generate a random float given the constraints. + + :param random: An instance of random. + :param minimum: A minimum value + :param maximum: A maximum value. + + :returns: A random float. + """ + if minimum is None: + minimum = float(random.randint(0, 100)) if maximum is None else float(maximum) - 100.0 + if maximum is None: + maximum = float(minimum) + 1.0 * 2.0 if minimum >= 0 else float(minimum) + 1.0 / 2.0 + return random.uniform(float(minimum), float(maximum)) + + +def create_random_integer(random: Random, minimum: int | None = None, maximum: int | None = None) -> int: + """Generate a random int given the constraints. + + :param random: An instance of random. + :param minimum: A minimum value + :param maximum: A maximum value. + + :returns: A random integer. + """ + return round(create_random_float(random=random, minimum=minimum, maximum=maximum)) + + +def create_random_decimal( + random: Random, + minimum: Decimal | None = None, + maximum: Decimal | None = None, +) -> Decimal: + """Generate a random Decimal given the constraints. + + :param random: An instance of random. + :param minimum: A minimum value + :param maximum: A maximum value. + + :returns: A random decimal. + """ + return Decimal(str(create_random_float(random=random, minimum=minimum, maximum=maximum))) + + +def create_random_bytes( + random: Random, + min_length: int | None = None, + max_length: int | None = None, + lower_case: bool = False, + upper_case: bool = False, +) -> bytes: + """Generate a random bytes given the constraints. + + :param random: An instance of random. + :param min_length: A minimum length. + :param max_length: A maximum length. + :param lower_case: Whether to lowercase the result. + :param upper_case: Whether to uppercase the result. + + :returns: A random byte-string. + """ + if min_length is None: + min_length = 0 + if max_length is None: + max_length = min_length + 1 * 2 + + length = random.randint(min_length, max_length) + result = b"" if length == 0 else hexlify(random.getrandbits(length * 8).to_bytes(length, "little")) + + if lower_case: + result = result.lower() + elif upper_case: + result = result.upper() + + if max_length and len(result) > max_length: + end = random.randint(min_length or 0, max_length) + return result[:end] + + return result + + +def create_random_string( + random: Random, + min_length: int | None = None, + max_length: int | None = None, + lower_case: bool = False, + upper_case: bool = False, +) -> str: + """Generate a random string given the constraints. + + :param random: An instance of random. + :param min_length: A minimum length. + :param max_length: A maximum length. + :param lower_case: Whether to lowercase the result. + :param upper_case: Whether to uppercase the result. + + :returns: A random string. + """ + return create_random_bytes( + random=random, + min_length=min_length, + max_length=max_length, + lower_case=lower_case, + upper_case=upper_case, + ).decode("utf-8") + + +def create_random_boolean(random: Random) -> bool: + """Generate a random boolean value. + + :param random: An instance of random. + + :returns: A random boolean. + """ + return bool(random.getrandbits(1)) diff --git a/venv/lib/python3.11/site-packages/polyfactory/value_generators/regex.py b/venv/lib/python3.11/site-packages/polyfactory/value_generators/regex.py new file mode 100644 index 0000000..eab9bd0 --- /dev/null +++ b/venv/lib/python3.11/site-packages/polyfactory/value_generators/regex.py @@ -0,0 +1,150 @@ +"""The code in this files is adapted from https://github.com/crdoconnor/xeger/blob/master/xeger/xeger.py.Which in turn +adapted it from https://bitbucket.org/leapfrogdevelopment/rstr/. + +Copyright (C) 2015, Colm O'Connor +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the Leapfrog Direct Response, LLC, including + its subsidiaries and affiliates nor the names of its + contributors, may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEAPFROG DIRECT +RESPONSE, LLC, INCLUDING ITS SUBSIDIARIES AND AFFILIATES, BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" +from __future__ import annotations + +from itertools import chain +from string import ( + ascii_letters, + ascii_lowercase, + ascii_uppercase, + digits, + printable, + punctuation, + whitespace, +) +from typing import TYPE_CHECKING, Any, Pattern + +try: # >=3.11 + from re._parser import SubPattern, parse +except ImportError: # < 3.11 + from sre_parse import SubPattern, parse # pylint: disable=deprecated-module + +if TYPE_CHECKING: + from random import Random + +_alphabets = { + "printable": printable, + "letters": ascii_letters, + "uppercase": ascii_uppercase, + "lowercase": ascii_lowercase, + "digits": digits, + "punctuation": punctuation, + "nondigits": ascii_letters + punctuation, + "nonletters": digits + punctuation, + "whitespace": whitespace, + "nonwhitespace": printable.strip(), + "normal": ascii_letters + digits + " ", + "word": ascii_letters + digits + "_", + "nonword": "".join(set(printable).difference(ascii_letters + digits + "_")), + "postalsafe": ascii_letters + digits + " .-#/", + "urlsafe": ascii_letters + digits + "-._~", + "domainsafe": ascii_letters + digits + "-", +} + +_categories = { + "category_digit": _alphabets["digits"], + "category_not_digit": _alphabets["nondigits"], + "category_space": _alphabets["whitespace"], + "category_not_space": _alphabets["nonwhitespace"], + "category_word": _alphabets["word"], + "category_not_word": _alphabets["nonword"], +} + + +class RegexFactory: + """Factory for regexes.""" + + def __init__(self, random: Random, limit: int = 10) -> None: + """Create a RegexFactory""" + self._limit = limit + self._cache: dict[str, Any] = {} + self._random = random + + self._cases = { + "literal": chr, + "not_literal": lambda x: self._random.choice(printable.replace(chr(x), "")), + "at": lambda x: "", + "in": self._handle_in, + "any": lambda x: self._random.choice(printable.replace("\n", "")), + "range": lambda x: [chr(i) for i in range(x[0], x[1] + 1)], + "category": lambda x: _categories[str(x).lower()], + "branch": lambda x: "".join(self._handle_state(i) for i in self._random.choice(x[1])), + "subpattern": self._handle_group, + "assert": lambda x: "".join(self._handle_state(i) for i in x[1]), + "assert_not": lambda x: "", + "groupref": lambda x: self._cache[x], + "min_repeat": lambda x: self._handle_repeat(*x), + "max_repeat": lambda x: self._handle_repeat(*x), + "negate": lambda x: [False], + } + + def __call__(self, string_or_regex: str | Pattern) -> str: + """Generate a string matching a regex. + + :param string_or_regex: A string or pattern. + + :return: The generated string. + """ + pattern = string_or_regex.pattern if isinstance(string_or_regex, Pattern) else string_or_regex + parsed = parse(pattern) + result = self._build_string(parsed) # pyright: ignore[reportGeneralTypeIssues] + self._cache.clear() + return result + + def _build_string(self, parsed: SubPattern) -> str: + return "".join([self._handle_state(state) for state in parsed]) # pyright:ignore[reportGeneralTypeIssues] + + def _handle_state(self, state: tuple[SubPattern, tuple[Any, ...]]) -> Any: + opcode, value = state + return self._cases[str(opcode).lower()](value) # type: ignore[no-untyped-call] + + def _handle_group(self, value: tuple[Any, ...]) -> str: + result = "".join(self._handle_state(i) for i in value[3]) + if value[0]: + self._cache[value[0]] = result + return result + + def _handle_in(self, value: tuple[Any, ...]) -> Any: + candidates = list(chain(*(self._handle_state(i) for i in value))) + if candidates and candidates[0] is False: + candidates = list(set(printable).difference(candidates[1:])) + return self._random.choice(candidates) + return self._random.choice(candidates) + + def _handle_repeat(self, start_range: int, end_range: Any, value: SubPattern) -> str: + end_range = min(end_range, self._limit) + + result = [ + "".join(self._handle_state(v) for v in list(value)) # pyright: ignore[reportGeneralTypeIssues] + for _ in range(self._random.randint(start_range, max(start_range, end_range))) + ] + return "".join(result) |