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 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()