-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathvalues.py
146 lines (120 loc) · 5.49 KB
/
values.py
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# Copyright 2016 Parinz Ameri, Haipeng Guan
#
# This file is part of Nowog.
#
# Nowog is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Nowog is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Nowog. If not, see <http://www.gnu.org/licenses/>
"""Random values generator
This module generate random values for database operation. Types of random
values including random integer, string, boolean, float point, a dictionary
of random range in MongoDB (e.g. {"$gte": 0, "$lt": 10}), as well as random
array of integer, string, boolean, float point.Several internal parameters
limit the range of output numbers, characters of stringsand length of arrays.
"""
import random
import string
## --------------- default values ----------------
DEFAULT = {
'num_min': -1000,
'num_max': 1000,
'str_len_min': 1,
'str_len_max': 10,
'array_len_min': 1,
'array_len_max': 10,
'chars': string.ascii_uppercase + string.ascii_lowercase + string.digits + "_"
}
class Values(object):
"""Generate random values
Attributes:
rand (Random): a Random instance used for generating all values
num_min (int): Lower boundary of all output number (integer and float).
All number generated will be greater than or equal to num_min, including those in array.
The default value is -1000.
num_max (int): Upper boundary of the output number (integer and float), including those in array.
All values generated will be less than or equal to num_max.
The default value is 1000.
str_len_min (int): minimum length of all generated string, including those in array. Default: 1
str_len_max (int): maximum length of all generated string, including those in array. Default: 10
array_len_min (int): the minimum length of all array. Default: 1
array_len_min (int): the maximum length of all array. Default: 10
chars (str): all candidate characters in generating random string.
"""
def __init__(self, seed=None, **kwargs):
"""Able to set seed and change parameters in initialization"""
self.rand = random.Random()
self.seed(seed)
self.set_parameters(**kwargs)
def set_parameters(self, **kwargs):
"""change all internal parameters"""
self.num_min = int(kwargs.get('num_min', DEFAULT['num_min']))
self.num_max = int(kwargs.get('num_max', DEFAULT['num_max']))
if self.num_max < self.num_min:
raise ValueError('[num_max] must be equal or greater than [num_min]')
self.str_len_min = int(kwargs.get('str_len_min', DEFAULT['str_len_min']))
self.str_len_max = int(kwargs.get('str_len_max', DEFAULT['str_len_max']))
if self.str_len_max < self.str_len_min:
raise ValueError('[str_len_max] must be equal or greater than [str_len_min]')
self.array_len_min = int(kwargs.get('array_len_min', DEFAULT['array_len_min']))
self.array_len_max = int(kwargs.get('array_len_max', DEFAULT['array_len_max']))
if self.array_len_max < self.array_len_min:
raise ValueError('[array_len_max] must be equal or greater than [array_len_min]')
self.chars = kwargs.get('chars', DEFAULT['chars'])
def seed(self, seed=None):
"""Initialize internal seed of Random instance"""
self.rand.seed(seed)
def randInt(self):
return self.rand.randint(self.num_min, self.num_max)
def randStr(self):
str_len = self.rand.randint(self.str_len_min, self.str_len_max)
return ''.join(self.rand.choice(self.chars) for _ in xrange(str_len))
def randBool(self):
return bool(self.rand.getrandbits(1))
def randFloat(self):
return self.rand.uniform(self.num_min, self.num_max)
def randNum(self):
"""generate a random number: a integer or a float point"""
return self.randInt() if self.randBool() else self.randFloat()
def randRangeDict(self):
[small, large] = sorted([self.randInt(), self.randInt()])
return {"$gte": small, "$lt": large}
def randIntArray(self):
"""Generate a array of random integer with random length"""
array_len = self.rand.randint(self.array_len_min, self.array_len_max)
return [self.randInt() for _ in xrange(array_len)]
def randNumArray(self):
"""Generate a array of random number with random length"""
array_len = self.rand.randint(self.array_len_min, self.array_len_max)
return [self.randNum() for _ in xrange(array_len)]
def randStrArray(self):
"""Generate a array of random string with random length"""
array_len = self.rand.randint(self.array_len_min, self.array_len_max)
return [self.randStr() for _ in xrange(array_len)]
def randBoolArray(self):
"""Generate a array of random boolean with random length"""
array_len = self.rand.randint(self.array_len_min, self.array_len_max)
return [self.randBool() for _ in xrange(array_len)]
# Create one instance, seeded from current time, and export its methods
# as module-level functions. The functions share state across all uses.
_inst = Values()
seed = _inst.seed
set_parameters = _inst.set_parameters
randInt = _inst.randInt
randStr = _inst.randStr
randBool = _inst.randBool
randFloat = _inst.randFloat
randNum = _inst.randNum
randRangeDict = _inst.randRangeDict
randIntArray = _inst.randIntArray
randNumArray = _inst.randNumArray
randStrArray = _inst.randStrArray
randBoolArray = _inst.randBoolArray