class Handpar_Process:
"""
Handpar randomizer: see Cli() for usage.
"""
def __init__(self, **lopts):
self.random = SystemRandom()
if len(lopts) > 0:
self.update(lopts)
def update(self, lopts):
self.__dict__.update(lopts)
self.parangle = self.markovwalk(getattr(self, "minparangle", 0),
getattr(self, "maxparangle", 0))
@autocount
def __call__(self, par):
return "\\begin{handparfull}{%d}{%.2f}\n%s\n\end{handparfull}" % (
next(self.parangle),
self.random.uniform(self.minparscale, self.maxparscale),
fill(" ".join(
[(self.rotatebox(word) if state else word)
for state, word in izip(
self.bernouilli(self.freqword),
[
self.wordcount(i)
for i in re.split("\s+", par.group(1)) if len(i) > 0
],
)])),
)
@autocount
def wordcount(self, word):
return word
@autocount
def rotatebox(self, word):
return "\\handword{%d}{%s}" % (
self.randpick((self.lowwordangle, self.highwordangle)),
word,
)
def bernouilli(self, freq):
while True:
yield True if (self.random.uniform(0, 1) <= freq) else False
def markovwalk(self, a, b):
pos = self.random.randint(a, b)
while True:
step = self.random.randint(-1, 1)
pos += step
if (pos < a) or (pos > b):
pos -= step
yield pos
def randpick(self, pick):
return pick[self.random.randint(0, len(pick) - 1)]
def test_stress(self):
"""
Runs a large number of threads doing operations with resources
checked out, ensuring properties of the pool.
"""
rand = SystemRandom()
n = rand.randint(1, 400)
passes = rand.randint(1, 20)
rounds = rand.randint(1, 200)
breaker = rand.uniform(0, 1)
pool = EmptyListPool()
def _run():
for i in range(rounds):
with pool.transaction() as a:
self.assertEqual([], a)
a.append(currentThread())
self.assertEqual([currentThread()], a)
for p in range(passes):
self.assertEqual([currentThread()], a)
if rand.uniform(0, 1) > breaker:
break
a.remove(currentThread())
threads = []
for i in range(n):
th = Thread(target=_run)
threads.append(th)
th.start()
for th in threads:
th.join()
def test_stress(self):
"""
Runs a large number of threads doing operations with resources
checked out, ensuring properties of the pool.
"""
rand = SystemRandom()
n = rand.randint(1, 400)
passes = rand.randint(1, 20)
rounds = rand.randint(1, 200)
breaker = rand.uniform(0, 1)
pool = EmptyListPool()
def _run():
for i in range(rounds):
with pool.transaction() as a:
self.assertEqual([], a)
a.append(currentThread())
self.assertEqual([currentThread()], a)
for p in range(passes):
self.assertEqual([currentThread()], a)
if rand.uniform(0, 1) > breaker:
break
a.remove(currentThread())
threads = []
for i in range(n):
th = Thread(target=_run)
threads.append(th)
th.start()
for th in threads:
th.join()
def main(args):
r = SystemRandom()
try:
try:
_min = int(args[1])
_max = int(args[2])
except:
_min = 0
_max = int(args[1])
except:
_min = 0
_max = 10
try:
if args[0] == 'simple':
l = list(string.letters + string.digits)
r.shuffle(l)
return ''.join(l[0:_max])
if args[0] == 'strong':
l = list(string.letters + string.digits + string.punctuation)
r.shuffle(l)
return ''.join(l[0:_max])
if args[0] == 'integer':
return r.randint(_min, _max)
return r.uniform(_min, _max)
except:
return r.random()
def throwAndSetRandomRun(source,runsAndProbs):
"""Pass a list of tuple pairs, with the first item of the pair a run number
and the second number of the pair a weight. The function will normalize the
weights so you do not have to worry about that. The pairs will be used to randomly choose what Run
should be assigned to the job.
"""
from random import SystemRandom
totalProb = 0.
for r,p in runsAndProbs:
totalProb+=p
#this is the same random generator used to set the seeds for the RandomNumberGeneratorService
random = SystemRandom()
runProb = random.uniform(0,totalProb)
sumProb = 0
runNumber = 0
for r,p in runsAndProbs:
sumProb+=p
if sumProb >= runProb:
runNumber = r
break
print('setting runNumber to: ',runNumber)
if source.type_() == "PoolSource":
source.setRunNumber = cms.untracked.uint32(runNumber)
else:
#sources that inherit from ConfigurableInputSource use 'firstRun'
source.firstRun = cms.untracked.uint32(runNumber)
return
def _random_array(shape, lower=0.0, upper=1.0, **kwargs):
"""random_array(shape, lower=0.0, upper=1.0, **kwargs) -> array
Return a np.array of `shape` with the elements filled with uniform random
values between `lower` and `upper`."""
rand = SystemRandom()
length = reduce(lambda acc, x: acc * x, shape, 1)\
if isinstance(shape, tuple) else shape
rands = [rand.uniform(lower, upper) for _ in range(length)]
return np.array(rands, **kwargs).reshape(shape)
async def get_all(self):
"""Скачать все страницы книги"""
generator = SystemRandom()
# Выставляем максимальный delay
if self.pages_count < 50:
cooldown = 5
elif self.pages_count < 85:
cooldown = 10
elif self.pages_count >= 100:
cooldown = 60
elif self.pages_count >= 250:
cooldown = 120
else:
cooldown = 30
if self.debug_mode:
logger.debug(f'Delay value set to {cooldown}')
# Готовим обманку
headers = WebPage.get_headers()
headers['Referer'] = f'http://elibrary.asu.ru/els/files/book' \
f'?name={self.name_for_headers}&id={self.name_for_request}.7book'
pages = []
for task_num in range(1, self.pages_count + 1):
page = ReaderPage(
self.session,
f'http://elibrary.asu.ru/els/files/test/' \
f'?name={self.name_for_request}&id={self.id_for_request}' \
f'&page={task_num}&mode=1',
debug=self.debug_mode,
headers=headers,
cooldown=generator.uniform(0, cooldown),
task_num=task_num
)
pages.append(page)
tasks = []
for page in pages:
tasks.append(
create_task(
page.get()
)
)
return await gather(*tasks)
def synth_noise(coef=0, datasize=0, fname=''):
'''Generates noise samples
'''
if not (coef and datasize and fname):
raise ValueError('empty param(s): {!r}'.format(repr((coef, datasize,
fname))))
amplitude = 8000.0
boost = coef * amplitude / 2.0
samples = array('h')
rand = SystemRandom()
for _ in range(datasize):
samples.append(int(rand.uniform(-1, 1) * boost))
with open(fname, 'wb') as fd_obj:
samples.tofile(fd_obj)
def createUser(request,cursor):
fullname = request['fullname']
username = request['username']
if (fullname == "" or username == ""): return 401
ctype = int(request['ctype'])
type = int(request['type'])
if (ctype == 0 or ctype == 1):
passwd = request['password']
else:
ra = SystemRandom()
passwd = str(ra.uniform(0,1000))
if (type == 1): # pn
if not(len(username) == 10 or (len(username) == 11 and username[0] == '1')):
return 401
cursor.execute("SELECT phonenumber FROM endusers WHERE phonenumber = %s",(int(username),))
elif (type == 2): # email
if not('@' in username):
return 401
cursor.execute("SELECT email FROM endusers WHERE email = %s",(username,))
else:
return 401
res = cursor.fetchone()
if (res is None):
pn = None
email = None
msgval = 1
if (type == 1):
pn = username
msgval *= 2
elif (type == 2):
email = username
msgval *= 3
if (ctype == 0 or ctype == 1):
msgval *= 5
hashed = crypt(passwd)
empty = []
cursor.execute("INSERT INTO endusers VALUES (nextval('counter_users'),%s,%s,%s,%s,%s,%s) RETURNING acc_id",(pn,None,msgval,email,hashed,fullname))
acc_id = cursor.fetchone()[0]
cursor.execute("INSERT INTO points VALUES (%s,%s,%s)",(acc_id,empty,empty))
cursor.execute("INSERT INTO subscriptions VALUES (%s,%s,%s)",(acc_id,empty,empty))
return 200
else:
return 400
class DefaultRandomizer(Randomizer):
def __init__(self):
Randomizer.__init__(self)
self.secure_random = SystemRandom()
self.logger = ESAPI.logger("Randomizer")
def get_random_string(self, length, character_set):
ret = ""
for i in range(length):
ret += self.get_random_choice(character_set)
return ret
def get_random_boolean(self):
return self.get_random_choice([True, False])
def get_random_integer(self, min_=MIN_INTEGER, max_=MAX_INTEGER):
return self.secure_random.randint(min_, max_)
def get_random_filename(self, extension):
filename = self.get_random_string(12, Encoder.CHAR_ALPHANUMERICS) + \
"." + extension
self.logger.debug(Logger.SECURITY_SUCCESS,
_("Generated a new random filename: ") + filename)
return filename
def get_random_float(self, min_=MIN_FLOAT, max_=MAX_FLOAT):
return self.secure_random.uniform(min_, max_)
def get_random_guid(self):
parts = [None] * 5
parts[0] = self.get_random_string(8, Encoder.CHAR_LOWER_HEX)
parts[1] = self.get_random_string(4, Encoder.CHAR_LOWER_HEX)
# Sets GUID version to 4
parts[2] = '4' + self.get_random_string(3, Encoder.CHAR_LOWER_HEX)
# Sets high bits
parts[3] = self.get_random_choice('89ab') + \
self.get_random_string(3, Encoder.CHAR_LOWER_HEX)
parts[4] = self.get_random_string(12, Encoder.CHAR_LOWER_HEX)
return '-'.join(parts)
def get_random_choice(self, seq):
return self.secure_random.choice(seq)
class DefaultRandomizer(Randomizer):
def __init__(self):
Randomizer.__init__(self)
self.secure_random = SystemRandom()
self.logger = ESAPI.logger("Randomizer")
def get_random_string(self, length, character_set):
ret = []
for i in range(length):
ret.append( self.get_random_choice(character_set) )
return ''.join(ret)
def get_random_boolean(self):
return self.get_random_choice([True, False])
def get_random_integer(self, min_=MIN_INTEGER, max_=MAX_INTEGER):
return self.secure_random.randint(min_, max_)
def get_random_filename(self, extension):
filename = self.get_random_string(12, Encoder.CHAR_ALPHANUMERICS) + \
"." + extension
self.logger.debug(Logger.SECURITY_SUCCESS,
_("Generated a new random filename: ") + filename)
return filename
def get_random_float(self, min_=MIN_FLOAT, max_=MAX_FLOAT):
return self.secure_random.uniform(min_, max_)
def get_random_guid(self):
parts = [None] * 5
parts[0] = self.get_random_string(8, Encoder.CHAR_LOWER_HEX)
parts[1] = self.get_random_string(4, Encoder.CHAR_LOWER_HEX)
# Sets GUID version to 4
parts[2] = '4' + self.get_random_string(3, Encoder.CHAR_LOWER_HEX)
# Sets high bits
parts[3] = self.get_random_choice('89ab') + \
self.get_random_string(3, Encoder.CHAR_LOWER_HEX)
parts[4] = self.get_random_string(12, Encoder.CHAR_LOWER_HEX)
return '-'.join(parts)
def get_random_choice(self, seq):
return self.secure_random.choice(seq)
class Randomizer:
"""Utility class used for returning random values."""
def __init__(self):
self.random = SystemRandom()
def get_random_dict_key(self, d):
"""Returns a random key from dictionary based on given percentages."""
if d is None or len(d) < 2 or sum(list(d.values())) not in [99.9, 100]:
raise Exception(
"Given dict has less than 2 items or dict values do not add up to 100."
)
dict_values = list(d.values())
ordered_dict = sorted(d.items(), key=operator.itemgetter(1))
ordered_list = sorted(dict_values, key=int)
random_num = self.random.uniform(1, 99.9)
# Loop through the list and return the dictionary key of value
sum_so_far = 0
for i, value in enumerate(ordered_list):
if random_num <= value + sum_so_far:
if ordered_dict[i][0] is None or ordered_dict[i][
0] not in d.keys():
raise Exception(" Key not found in dict.")
return ordered_dict[i][0]
sum_so_far += value
# Raise exception if no matching value
raise Exception("Key not found in dict.")
def get_random_item(self, lst):
"""Returns a completely random item from given list."""
if lst is not None and len(lst) > 0:
return self.random.choice(lst)
else:
raise Exception("Given list is empty.")
def get_random_number(self, start, end):
"""Returns a random number within given range."""
return self.random.randint(start, end)
def insertInto(self, parameterSet, myname):
from random import SystemRandom
totalProb = 0.
for r,p in self.__dict__['runsAndProbs']:
totalProb+=p
#this is the same random generator used to set the seeds for the RandomNumberGeneratorService
random = SystemRandom()
runProb = random.uniform(0,totalProb)
print(runProb)
sumProb = 0
runNumber = 0
for r,p in self.__dict__['runsAndProbs']:
sumProb+=p
if sumProb >= runProb:
runNumber = r
break
if self.type_() == "PoolSource":
self.setRunNumber = cms.untracked.uint32(runNumber)
else:
#sources that inherit from ConfigurableInputSource use 'firstRun'
self.firstRun = cms.untracked.uint32(runNumber)
super(RandomRunSource,self).insertInto(parameterSet,myname)
def vrr_get_trip_data(parameters_ref):
main_start = time.time()
# print ('parameters_ref', parameters_ref)
parameters = parameters_ref.copy()
address_origin = parameters.pop('origin')
address_destination = parameters.pop('destination')
if 'departure_time' in parameters:
departure_time = parameters.pop('departure_time')
else:
departure_time = dict()
parameters = {**XML_TRIP_REQUEST2_DEFAULT, **parameters}
# Parsing the time variable
parameters, departure_time = prepare_departure_time(
parameters, departure_time)
if 'filter' in parameters:
filter = parameters.pop('filter')
else:
filter = []
tries = 0
while tries < 20:
cryptogen = SystemRandom()
lat_unit = 111
lng_unit = 111 * math.cos(2 * math.pi * 51 / 180)
random_number_1 = cryptogen.uniform(0, tries * 0.1) / lat_unit
random_number_2 = cryptogen.uniform(0, tries * 0.1) / lng_unit
random_number_3 = cryptogen.uniform(0, tries * 0.1) / lat_unit
random_number_4 = cryptogen.uniform(0, tries * 0.1) / lng_unit
tries += 1
coords_offset_1 = {'lat': random_number_1, 'lng': random_number_2}
coords_offset_2 = {'lat': random_number_3, 'lng': random_number_4}
parameters['name_origin'] = vrr_get_coord_format(
address_origin, coords_offset_1)
parameters['name_destination'] = vrr_get_coord_format(
address_destination, coords_offset_2)
A = 0
start_time_loop = time.time()
# Sending the request to VRR
start = time.time()
data_raw = vrr_get_trip_request(parameters)
time_passed = max(time.time() - start, 0.0001)
print('Time for request from VRR:', time_passed)
# print('After main Start:', max(time.time() - main_start, 0.0001) )
A += time.time() - start_time_loop
# print ('Time vrr_get_trip_request:', '%.2f' % (A))
# Parsing the resopnse
start = time.time()
start_soup = time.time()
soup = BeautifulSoup(data_raw, 'lxml-xml')
print('Time for soup:', max(time.time() - start_soup, 0.0001))
# print('After main Start:', max(time.time() - main_start, 0.0001))
data_all = dict()
data_all['travel_time'] = []
data_all['departure_time'] = departure_time
data_all['origin'] = dict()
data_all['destination'] = dict()
data_all['trip'] = []
data_all['origin']['station'] = []
data_all['destination']['station'] = []
itdRouteList = soup.find_all('itdRoute')
del soup
del data_raw
if len(itdRouteList) > 0:
# Doing havy parsing of the data.
data_all = vrr_get_PT_data(itdRouteList, data_all)
data_all['origin'] = data_all['origin']['station']
data_all['destination'] = data_all['destination']['station']
data_all['travel_time'] = min(
data_all['travel_time']) # todo: average
data_all['trip'] = data_all['trip']
print('After main Start:', max(time.time() - main_start, 0.0001))
return data_all
return []
def intSeqToHalton(i, b = 2):
return map(lambda f: intToHalton(f, b), i)
if __name__ == '__main__':
from argparse import ArgumentParser
parser = ArgumentParser(description="generate and plot Halton sequence")
parser.add_argument('-s', '--start', dest='start', metavar='N', action='store', type=int, default=0, help="start from N when generating the sequence")
parser.add_argument('-n', '--numbers', dest='numbers', metavar='N', action='store', type=int, default=512, help="generate N numbers")
parser.add_argument('-x', '--xbase', dest='xbase', metavar='N', action='store', type=int, default=2, help="use N as base for the numbers on the x-axis")
parser.add_argument('-y', '--ybase', dest='ybase', metavar='N', action='store', type=int, default=3, help="use N as base for the numbers on the y-axis")
parser.add_argument('-r', '--random', dest='random', action='store_const', default=False, const=True, help="generate an equal number of random numbers (using /dev/urandom) and plot in a subplot")
args = parser.parse_args()
i = range(args.start, args.start+args.numbers)
from matplotlib.pyplot import scatter, show, figure
fig = figure()
ax = fig.add_subplot(2 if args.random else 1, 1, 1)
ax.set_title("Halton sequences for [{},{}) using bases {} and {}".format(args.start, args.start+args.numbers, args.xbase, args.ybase))
scatter(intSeqToHalton(i, args.xbase), intSeqToHalton(i, args.ybase))
if args.random:
from random import SystemRandom
s = SystemRandom()
ax = fig.add_subplot(2, 1, 2)
ax.set_title("{} random number pairs generated using /dev/urandom".format(args.numbers))
scatter(map(lambda i: s.uniform(0.,1.), i), map(lambda i: s.uniform(0.,1.), i))
show()
