1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
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:
if maximum is None:
minimum = float(random.randint(0, 100))
else:
minimum = float(maximum) / 2 if maximum >= 0 else float(maximum) * 2.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))
|
