summaryrefslogtreecommitdiff
path: root/venv/lib/python3.11/site-packages/faker/providers/python
diff options
context:
space:
mode:
authorcyfraeviolae <cyfraeviolae>2024-04-03 03:10:44 -0400
committercyfraeviolae <cyfraeviolae>2024-04-03 03:10:44 -0400
commit6d7ba58f880be618ade07f8ea080fe8c4bf8a896 (patch)
treeb1c931051ffcebd2bd9d61d98d6233ffa289bbce /venv/lib/python3.11/site-packages/faker/providers/python
parent4f884c9abc32990b4061a1bb6997b4b37e58ea0b (diff)
venv
Diffstat (limited to 'venv/lib/python3.11/site-packages/faker/providers/python')
-rw-r--r--venv/lib/python3.11/site-packages/faker/providers/python/__init__.py543
-rw-r--r--venv/lib/python3.11/site-packages/faker/providers/python/__pycache__/__init__.cpython-311.pycbin0 -> 25003 bytes
-rw-r--r--venv/lib/python3.11/site-packages/faker/providers/python/en_US/__init__.py5
-rw-r--r--venv/lib/python3.11/site-packages/faker/providers/python/en_US/__pycache__/__init__.cpython-311.pycbin0 -> 494 bytes
4 files changed, 548 insertions, 0 deletions
diff --git a/venv/lib/python3.11/site-packages/faker/providers/python/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/python/__init__.py
new file mode 100644
index 0000000..f16f30c
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/faker/providers/python/__init__.py
@@ -0,0 +1,543 @@
+import math
+import string
+import sys
+import warnings
+
+from decimal import Decimal
+from enum import Enum
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Set, Tuple, Type, TypeVar, Union, cast, no_type_check
+
+from ...exceptions import BaseFakerException
+from .. import BaseProvider, ElementsType
+
+TypesNames = List[str]
+TypesSpec = Union[List[Type], Tuple[Type, ...]]
+TEnum = TypeVar("TEnum", bound=Enum)
+
+
+class EmptyEnumException(BaseFakerException):
+ pass
+
+
+class Provider(BaseProvider):
+ default_value_types: ElementsType[str] = (
+ "str",
+ "str",
+ "str",
+ "str",
+ "float",
+ "int",
+ "int",
+ "decimal",
+ "date_time",
+ "uri",
+ "email",
+ )
+
+ def _check_signature(self, value_types: Optional[TypesSpec], allowed_types: Optional[TypesSpec]) -> TypesSpec:
+ if value_types is not None and not isinstance(value_types, (list, tuple)):
+ value_types = (value_types,)
+ warnings.warn(
+ "Passing `value_types` as positional arguments is going to be "
+ "deprecated. Pass them as a list or tuple instead.",
+ PendingDeprecationWarning,
+ )
+ if allowed_types is not None and not isinstance(allowed_types, (list, tuple)):
+ allowed_types = (allowed_types,)
+ warnings.warn(
+ "Passing `allowed_types` as positional arguments is going to be "
+ "deprecated. Pass them as a list or tuple instead.",
+ PendingDeprecationWarning,
+ )
+ if value_types is None:
+ value_types = ()
+ if allowed_types is None:
+ allowed_types = ()
+ return tuple(value_types) + tuple(allowed_types)
+
+ def pyobject(
+ self,
+ object_type: Optional[Type[Union[bool, str, float, int, tuple, set, list, Iterable, dict]]] = None,
+ ) -> Optional[Union[bool, str, float, int, tuple, set, list, Iterable, dict]]:
+ """
+ Generates a random object passing the type desired.
+
+ :object_type: the type of the object to generate.
+ :return: the random object generated.
+ :raises ValueError: if the object type passed is not supported
+ """
+ if object_type is None:
+ return None
+ elif object_type == bool:
+ return self.pybool()
+ elif object_type == str:
+ return self.pystr()
+ elif object_type == float:
+ return self.pyfloat()
+ elif object_type == int:
+ return self.pyint()
+ elif object_type == tuple:
+ return self.pytuple()
+ elif object_type == set:
+ return self.pyset()
+ elif object_type == list:
+ return self.pylist()
+ elif object_type == Iterable:
+ return self.pyiterable()
+ elif object_type == dict:
+ return self.pydict()
+ else:
+ raise ValueError(f"Object type `{object_type}` is not supported by `pyobject` function")
+
+ def pybool(self, truth_probability: int = 50) -> bool:
+ """
+ Generates a random boolean, optionally biased towards `True` or `False`.
+
+ :truth_probability: Probability of generating a `True` value. Must be between `0` and `100` inclusive'.
+ :return: Random boolean.
+ :raises ValueError: If invalid `truth_probability` is provided.
+ """
+ if truth_probability < 0 or truth_probability > 100:
+ raise ValueError("Invalid `truth_probability` value: must be between `0` and `100` inclusive")
+
+ return self.random_int(1, 100) <= truth_probability
+
+ def pystr(
+ self,
+ min_chars: Optional[int] = None,
+ max_chars: int = 20,
+ prefix: str = "",
+ suffix: str = "",
+ ) -> str:
+ """
+ Generates a random string of upper and lowercase letters.
+
+ :param min_chars: minimum length of the random part.
+ :param max_chars: maximum length of the random part.
+ :param prefix: an optional prefix to prepend to the random string.
+ :param suffix: an optional suffix to append to the random string.
+ :return: Random of random length between min and max characters.
+ """
+ if min_chars is None:
+ chars = "".join(self.random_letters(length=max_chars))
+ else:
+ assert max_chars >= min_chars, "Maximum length must be greater than or equal to minimum length"
+ chars = "".join(
+ self.random_letters(
+ length=self.generator.random.randint(min_chars, max_chars),
+ ),
+ )
+
+ return prefix + chars + suffix
+
+ def pystr_format(
+ self,
+ string_format: str = "?#-###{{random_int}}{{random_letter}}",
+ letters: str = string.ascii_letters,
+ ) -> str:
+ return self.bothify(self.generator.parse(string_format), letters=letters)
+
+ def pyfloat(
+ self,
+ left_digits=None,
+ right_digits=None,
+ positive=None,
+ min_value=None,
+ max_value=None,
+ ):
+ if left_digits is not None and left_digits < 0:
+ raise ValueError("A float number cannot have less than 0 digits in its " "integer part")
+ if right_digits is not None and right_digits < 0:
+ raise ValueError("A float number cannot have less than 0 digits in its " "fractional part")
+ if left_digits == 0 and right_digits == 0:
+ raise ValueError("A float number cannot have less than 0 digits in total")
+ if None not in (min_value, max_value) and min_value > max_value:
+ raise ValueError("Min value cannot be greater than max value")
+ if None not in (min_value, max_value) and min_value == max_value:
+ raise ValueError("Min and max value cannot be the same")
+ if positive and min_value is not None and min_value <= 0:
+ raise ValueError("Cannot combine positive=True with negative or zero min_value")
+ if left_digits is not None and max_value and math.ceil(math.log10(abs(max_value))) > left_digits:
+ raise ValueError("Max value must fit within left digits")
+ if left_digits is not None and min_value and math.ceil(math.log10(abs(min_value))) > left_digits:
+ raise ValueError("Min value must fit within left digits")
+
+ # Make sure at least either left or right is set
+ if left_digits is None and right_digits is None:
+ needed_left_digits = max(1, math.ceil(math.log10(max(abs(max_value or 1), abs(min_value or 1)))))
+ right_digits = self.random_int(1, sys.float_info.dig - needed_left_digits)
+
+ # If only one side is set, choose #digits for other side
+ if (left_digits is None) ^ (right_digits is None):
+ if left_digits is None:
+ left_digits = max(1, sys.float_info.dig - right_digits)
+ else:
+ right_digits = max(1, sys.float_info.dig - left_digits)
+
+ # Make sure we don't ask for too many digits!
+ if left_digits + right_digits > sys.float_info.dig:
+ raise ValueError(
+ f"Asking for too many digits ({left_digits} + {right_digits} == {left_digits + right_digits} > "
+ f"{sys.float_info.dig})",
+ )
+
+ sign = ""
+ if (min_value is not None) or (max_value is not None):
+ # Copy values to ensure we're not modifying the original values and thus going out of bounds
+ left_min_value = min_value
+ left_max_value = max_value
+ # Make sure left_digits still respected
+ if left_digits is not None:
+ if max_value is None:
+ left_max_value = 10**left_digits # minus smallest representable, adjusted later
+ if min_value is None:
+ left_min_value = -(10**left_digits) # plus smallest representable, adjusted later
+
+ if max_value is not None and max_value < 0:
+ left_max_value += 1 # as the random_int will be generated up to max_value - 1
+ if min_value is not None and min_value < 0:
+ left_min_value += 1 # as we then append digits after the left_number
+ left_number = self._safe_random_int(
+ left_min_value,
+ left_max_value,
+ positive,
+ )
+ else:
+ if positive is None:
+ sign = self.random_element(("+", "-"))
+ elif positive is True:
+ sign = "+"
+ else:
+ sign = "-"
+
+ left_number = self.random_number(left_digits)
+
+ result = float(f"{sign}{left_number}.{self.random_number(right_digits)}")
+ if positive and result == 0:
+ if right_digits:
+ result = float("0." + "0" * (right_digits - 1) + "1")
+ else:
+ result += sys.float_info.epsilon
+
+ if right_digits:
+ result = min(result, 10**left_digits - float(f'0.{"0" * (right_digits - 1)}1'))
+ result = max(result, -(10**left_digits + float(f'0.{"0" * (right_digits - 1)}1')))
+ else:
+ result = min(result, 10**left_digits - 1)
+ result = max(result, -(10**left_digits + 1))
+
+ # It's possible for the result to end up > than max_value or < than min_value
+ # When this happens we introduce some variance so we're not always the exactly the min_value or max_value.
+ # Which can happen a lot depending on the difference of the values.
+ # Ensure the variance is bound by the difference between the max and min
+ if max_value is not None:
+ if result > max_value:
+ result = result - (result - max_value + self.generator.random.uniform(0, max_value - min_value))
+ if min_value is not None:
+ if result < min_value:
+ result = result + (min_value - result + self.generator.random.uniform(0, max_value - min_value))
+
+ return result
+
+ def _safe_random_int(self, min_value: float, max_value: float, positive: bool) -> int:
+ orig_min_value = min_value
+ orig_max_value = max_value
+
+ if min_value is None:
+ min_value = max_value - self.random_int()
+ if max_value is None:
+ max_value = min_value + self.random_int()
+ if positive:
+ min_value = max(min_value, 0)
+
+ if min_value == max_value:
+ return self._safe_random_int(orig_min_value, orig_max_value, positive)
+ else:
+ min_value = int(min_value)
+ max_value = int(max_value - 1)
+ if max_value < min_value:
+ max_value += 1
+ return self.random_int(min_value, max_value)
+
+ def pyint(self, min_value: int = 0, max_value: int = 9999, step: int = 1) -> int:
+ return self.generator.random_int(min_value, max_value, step=step)
+
+ def _random_int_of_length(self, length: int) -> int:
+ """Generate a random integer of a given length
+
+ If length is 0, so is the number. Otherwise the first digit must not be 0.
+ """
+
+ if length < 0:
+ raise ValueError("Length must be a non-negative integer.")
+ elif length == 0:
+ return 0
+ else:
+ min_value = 10 ** (length - 1)
+ max_value = (10**length) - 1
+ return self.pyint(min_value=min_value, max_value=max_value)
+
+ def pydecimal(
+ self,
+ left_digits: Optional[int] = None,
+ right_digits: Optional[int] = None,
+ positive: bool = False,
+ min_value: Optional[float] = None,
+ max_value: Optional[float] = None,
+ ) -> Decimal:
+ if left_digits is not None and left_digits < 0:
+ raise ValueError("A decimal number cannot have less than 0 digits in its " "integer part")
+ if right_digits is not None and right_digits < 0:
+ raise ValueError("A decimal number cannot have less than 0 digits in its " "fractional part")
+ if (left_digits is not None and left_digits == 0) and (right_digits is not None and right_digits == 0):
+ raise ValueError("A decimal number cannot have 0 digits in total")
+ if min_value is not None and max_value is not None and min_value > max_value:
+ raise ValueError("Min value cannot be greater than max value")
+ if min_value is not None and max_value is not None and min_value == max_value:
+ raise ValueError("Min and max value cannot be the same")
+ if positive and min_value is not None and min_value <= 0:
+ raise ValueError("Cannot combine positive=True with negative or zero min_value")
+ if left_digits is not None and max_value and math.ceil(math.log10(abs(max_value))) > left_digits:
+ raise ValueError("Max value must fit within left digits")
+ if left_digits is not None and min_value and math.ceil(math.log10(abs(min_value))) > left_digits:
+ raise ValueError("Min value must fit within left digits")
+
+ # if either left or right digits are not specified we randomly choose a length
+ max_random_digits = 100
+ # Because if min_value is bigger than 10**100
+ max_digits_from_value = max(
+ math.ceil(math.log10(abs(min_value or 1))),
+ math.ceil(math.log10(abs(max_value or 1))),
+ )
+ max_left_random_digits = max(max_random_digits, max_digits_from_value + 10)
+
+ if min_value is not None and min_value >= 0:
+ sign = "+"
+ elif max_value is not None and max_value <= 0:
+ sign = "-"
+ else:
+ sign = "+" if positive else self.random_element(("+", "-"))
+
+ if sign == "+":
+ if max_value is not None:
+ left_number = str(self.random_int(int(max(min_value or 0, 0)), int(max_value)))
+ else:
+ min_left_digits = math.ceil(math.log10(max(min_value or 1, 1)))
+ if left_digits is None:
+ left_digits = self.random_int(min_left_digits, max_left_random_digits)
+ left_number = str(self._random_int_of_length(left_digits))
+ else:
+ if min_value is not None:
+ left_number = str(self.random_int(int(max(max_value or 0, 0)), int(abs(min_value))))
+ else:
+ min_left_digits = math.ceil(math.log10(abs(min(max_value or 1, 1))))
+ if left_digits is None:
+ left_digits = self.random_int(min_left_digits, max_left_random_digits)
+ left_number = str(self._random_int_of_length(left_digits))
+
+ if right_digits is None:
+ right_digits = self.random_int(0, max_random_digits)
+
+ right_number = "".join([str(self.random_digit()) for i in range(0, right_digits)])
+
+ result = Decimal(f"{sign}{left_number}.{right_number}")
+
+ # Because the random result might have the same number of decimals as max_value the random number
+ # might be above max_value or below min_value
+ if max_value is not None and result > max_value:
+ result = Decimal(max_value)
+ if min_value is not None and result < min_value:
+ result = Decimal(min_value)
+
+ return result
+
+ def pytuple(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Tuple[Any, ...]:
+ return tuple(
+ self._pyiterable(
+ nb_elements=nb_elements,
+ variable_nb_elements=variable_nb_elements,
+ value_types=value_types,
+ allowed_types=allowed_types,
+ )
+ )
+
+ def pyset(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Set[Any]:
+ return set(
+ self._pyiterable(
+ nb_elements=nb_elements,
+ variable_nb_elements=variable_nb_elements,
+ value_types=value_types,
+ allowed_types=allowed_types,
+ )
+ )
+
+ def pylist(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> List[Any]:
+ return list(
+ self._pyiterable(
+ nb_elements=nb_elements,
+ variable_nb_elements=variable_nb_elements,
+ value_types=value_types,
+ allowed_types=allowed_types,
+ )
+ )
+
+ @no_type_check
+ def pyiterable(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Iterable[Any]:
+ value_types: TypesSpec = self._check_signature(value_types, allowed_types)
+ return self.random_element([self.pylist, self.pytuple, self.pyset])(
+ nb_elements=nb_elements,
+ variable_nb_elements=variable_nb_elements,
+ value_types=value_types,
+ allowed_types=allowed_types,
+ )
+
+ def _random_type(self, type_list: List[str]) -> str:
+ value_type: str = self.random_element(type_list)
+
+ method_name = f"py{value_type}"
+ if hasattr(self, method_name):
+ value_type = method_name
+
+ return self.generator.format(value_type)
+
+ def _pyiterable(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Iterator:
+ value_types: TypesSpec = self._check_signature(value_types, allowed_types)
+
+ value_types: TypesNames = [
+ t if isinstance(t, str) else getattr(t, "__name__", type(t).__name__).lower()
+ for t in value_types
+ # avoid recursion
+ if t not in ["iterable", "list", "tuple", "dict", "set"]
+ ]
+ if not value_types:
+ value_types = self.default_value_types # type: ignore
+
+ if variable_nb_elements:
+ nb_elements = self.randomize_nb_elements(nb_elements, min=1)
+
+ for _ in range(nb_elements):
+ yield self._random_type(value_types)
+
+ def pydict(
+ self,
+ nb_elements: int = 10,
+ variable_nb_elements: bool = True,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Dict[Any, Any]:
+ """
+ Returns a dictionary.
+
+ :nb_elements: number of elements for dictionary
+ :variable_nb_elements: is use variable number of elements for dictionary
+ :value_types: type of dictionary values
+ """
+ if variable_nb_elements:
+ nb_elements = self.randomize_nb_elements(nb_elements, min=1)
+
+ return dict(
+ zip(
+ self.generator.words(nb_elements, unique=True),
+ self._pyiterable(
+ nb_elements=nb_elements,
+ variable_nb_elements=False,
+ value_types=value_types,
+ allowed_types=allowed_types,
+ ),
+ )
+ )
+
+ def pystruct(
+ self,
+ count: int = 10,
+ value_types: Optional[TypesSpec] = None,
+ allowed_types: Optional[TypesSpec] = None,
+ ) -> Tuple[List, Dict, Dict]:
+ value_types: TypesSpec = self._check_signature(value_types, allowed_types)
+
+ value_types: TypesNames = [
+ t if isinstance(t, str) else getattr(t, "__name__", type(t).__name__).lower()
+ for t in value_types
+ # avoid recursion
+ if t != "struct"
+ ]
+ if not value_types:
+ value_types = self.default_value_types # type: ignore
+
+ types = []
+ d = {}
+ nd = {}
+ for i in range(count):
+ d[self.generator.word()] = self._random_type(value_types)
+ types.append(self._random_type(value_types))
+ nd[self.generator.word()] = {
+ i: self._random_type(value_types),
+ i
+ + 1: [
+ self._random_type(value_types),
+ self._random_type(value_types),
+ self._random_type(value_types),
+ ],
+ i
+ + 2: {
+ i: self._random_type(value_types),
+ i + 1: self._random_type(value_types),
+ i
+ + 2: [
+ self._random_type(value_types),
+ self._random_type(value_types),
+ ],
+ },
+ }
+ return types, d, nd
+
+ def enum(self, enum_cls: Type[TEnum]) -> TEnum:
+ """
+ Returns a random enum of the provided input `Enum` type.
+
+ :param enum_cls: The `Enum` type to produce the value for.
+ :returns: A randomly selected enum value.
+ """
+
+ if enum_cls is None:
+ raise ValueError("'enum_cls' cannot be None")
+
+ if not issubclass(enum_cls, Enum):
+ raise TypeError("'enum_cls' must be an Enum type")
+
+ members: List[TEnum] = list(cast(Iterable[TEnum], enum_cls))
+
+ if len(members) < 1:
+ raise EmptyEnumException(f"The provided Enum: '{enum_cls.__name__}' has no members.")
+
+ return self.random_element(members)
diff --git a/venv/lib/python3.11/site-packages/faker/providers/python/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/python/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..91430a2
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/faker/providers/python/__pycache__/__init__.cpython-311.pyc
Binary files differ
diff --git a/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__init__.py
new file mode 100644
index 0000000..23d8b4e
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__init__.py
@@ -0,0 +1,5 @@
+from .. import Provider as PythonProvider # pragma: no cover
+
+
+class Provider(PythonProvider): # pragma: no cover
+ pass
diff --git a/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..13ded30
--- /dev/null
+++ b/venv/lib/python3.11/site-packages/faker/providers/python/en_US/__pycache__/__init__.cpython-311.pyc
Binary files differ