def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s" % (random.getstate(), time.time())).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
python类getstate()的实例源码
def __init__(self, opt, shared=None):
"""Initialize the parameters of the DefaultTeacher"""
assert opt['train_part'] + opt['test_part'] + opt['valid_part'] == 1
self.parts = [opt['train_part'], opt['valid_part'], opt['test_part']]
# store datatype
self.dt = opt['datatype'].split(':')[0]
self.opt = opt
opt['datafile'] = _path(opt)
# store identifier for the teacher in the dialog
self.id = 'ner_teacher'
random_state = random.getstate()
random.seed(opt.get('teacher_seed'))
self.random_state = random.getstate()
random.setstate(random_state)
if shared and shared.get('metrics'):
self.metrics = shared['metrics']
else:
self.metrics = CoNLLClassificationMetrics(opt['model_file'])
# define standard question, since it doesn't change for this task
super().__init__(opt, shared)
def __init__(self, opt, shared=None):
"""Initialize the class accordint to given parameters in opt."""
# store datatype
self.datatype_strict = opt['datatype'].split(':')[0]
opt['datafile'] = _path(opt)
# store identifier for the teacher in the dialog
self.id = 'insults_teacher'
self.answer_candidates = ['Non-insult', "Insult"]
random_state = random.getstate()
random.seed(opt.get('teacher_random_seed'))
self.random_state = random.getstate()
random.setstate(random_state)
super().__init__(opt, shared)
if shared:
self.observations = shared['observations']
self.labels = shared['labels']
else:
self.observations = []
self.labels = []
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def adapt_z_state(self,main_rdd, cinfo,beta):
ainv = cinfo
def Updatez(tpl):
tt=[]
for ((tx,lam,state,z),index) in tpl:
random.setstate(state)
p = random.random()
state = random.getstate()
if p<self.ptr:
znew=float(-np.matrix(tx)*ainv*np.matrix(tx).T)
else:
znew=0.0
z=(1-beta)*z+beta*znew
tt.append(((tx,lam,state,z),index))
return tt
main_rdd = main_rdd.mapValues(Updatez).cache()
return main_rdd
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Return a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
('%s%s%s' % (random.getstate(), time.time(), settings.SECRET_KEY)).encode()
).digest()
)
return ''.join(random.choice(allowed_chars) for i in range(length))
def seed_generator(pid, tid):
"""
Sets python's random number generator.
Args:
pid: the problem id
tid: the team id
Returns:
The previous state of the random generator
"""
previous_state = random.getstate()
random.seed(get_seed(pid, tid))
return previous_state
def do_setup(deterministic=True):
global _old_python_random_state
global _old_numpy_random_state
global _old_cupy_random_states
_old_python_random_state = random.getstate()
_old_numpy_random_state = numpy.random.get_state()
_old_cupy_random_states = cupy.random.generator._random_states
cupy.random.reset_states()
# Check that _random_state has been recreated in
# cupy.random.reset_states(). Otherwise the contents of
# _old_cupy_random_states would be overwritten.
assert (cupy.random.generator._random_states is not
_old_cupy_random_states)
if not deterministic:
random.seed()
numpy.random.seed()
cupy.random.seed()
else:
random.seed(99)
numpy.random.seed(100)
cupy.random.seed(101)
def get_rand_string(length=12, allowed_chars='0123456789abcdef'):
"""
Returns a securely generated random string. Taken from the Django project
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s" % (
random.getstate(),
time.time())).encode('utf-8')
).digest())
return ''.join([random.choice(allowed_chars) for i in range(length)])
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def random_seed(seed=None):
"""Execute code inside this with-block using the specified seed.
If no seed is specified, nothing happens.
Does not affect the state of the random number generator outside this block.
Not thread-safe.
Args:
seed (int): random seed
"""
if seed is None:
yield
else:
py_state = random.getstate() # save state
np_state = np.random.get_state()
random.seed(seed) # alter state
np.random.seed(seed)
yield
random.setstate(py_state) # restore state
np.random.set_state(np_state)
def random_seed(seed=None):
"""Execute code inside this with-block using the specified seed.
If no seed is specified, nothing happens.
Does not affect the state of the random number generator outside this block.
Not thread-safe.
Args:
seed (int): random seed
"""
if seed is None:
yield
else:
py_state = random.getstate() # save state
np_state = np.random.get_state()
random.seed(seed) # alter state
np.random.seed(seed)
yield
random.setstate(py_state) # restore state
np.random.set_state(np_state)
def random_seed(seed=42):
""" sets the random seed of Python within the context.
Example
-------
>>> import random
>>> with random_seed(seed=0):
... random.randint(0, 1000) # doctest: +SKIP
864
"""
old_state = random.getstate()
random.seed(seed)
try:
yield
finally:
random.setstate(old_state)
def derandomize(seed=123):
'''
Disable randomization for a block
Since bloomfilter generates hash seeds randomly, it is inherently instable object.
It considerably complicates testing. This helper addresses the issue:
with bloomfilter.util.derandomize():
bloom_filter_1 = BloomFilter(100, 0.1)
with bloomfilter.util.derandomize():
bloom_filter_2 = BloomFilter(100, 0.1)
The resulting bloom_filters are stable between runs.
'''
state = random.getstate()
try:
random.seed(seed)
yield
finally:
random.setstate(state)
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def test_the_same_random_seed_per_test_can_be_turned_off(ourtestdir):
ourtestdir.makepyfile(
test_one="""
import random
def test_a():
test_a.state1 = random.getstate()
assert test_a.state1 == random.getstate() # sanity check
assert random.random() >= 0 # mutate state
test_a.state2 = random.getstate()
def test_b():
test_b.state = random.getstate()
assert test_b.state == random.getstate() # sanity check
assert test_a.state1 != test_b.state
assert test_a.state2 == test_b.state
"""
)
out = ourtestdir.runpytest(
'--randomly-dont-reset-seed', '--randomly-dont-reorganize',
)
out.assert_outcomes(passed=2, failed=0)
def test_fixtures_get_different_random_state_to_tests(ourtestdir):
ourtestdir.makepyfile(
test_one="""
import random
import pytest
@pytest.fixture()
def myfixture():
return random.getstate()
def test_one(myfixture):
assert myfixture != random.getstate()
"""
)
out = ourtestdir.runpytest()
out.assert_outcomes(passed=1)
def _reseed(config, offset=0):
seed = config.getoption('randomly_seed') + offset
if seed not in random_states:
random.seed(seed)
random_states[seed] = random.getstate()
else:
random.setstate(random_states[seed])
if have_factory_boy:
factory_set_random_state(random_states[seed])
if have_faker:
faker_random.setstate(random_states[seed])
if have_numpy:
if seed not in np_random_states:
np_random.seed(seed)
np_random_states[seed] = np_random.get_state()
else:
np_random.set_state(np_random_states[seed])
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
"""
Returns a securely generated random string.
The default length of 12 with the a-z, A-Z, 0-9 character set returns
a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
"""
if not using_sysrandom:
# This is ugly, and a hack, but it makes things better than
# the alternative of predictability. This re-seeds the PRNG
# using a value that is hard for an attacker to predict, every
# time a random string is required. This may change the
# properties of the chosen random sequence slightly, but this
# is better than absolute predictability.
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
settings.SECRET_KEY)).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
def reset(self):
"""Reset Teacher random states"""
random_state = random.getstate()
random.setstate(self.random_state)
random.shuffle(self.data.data)
self.random_state = random.getstate()
random.setstate(random_state)
self.lastY = None
self.episode_idx = self.data_offset - self.step_size
self.episode_done = True
self.epochDone = False
if not self.random and self.data_offset >= self.data.num_episodes():
# could have bigger batchsize then episodes... so nothing to do
self.epochDone = True
def setup_data(self, path):
"""Read and iteratively yield data to agent"""
print('loading: ' + path)
questions = []
y = []
# open data file with labels
# (path will be provided to setup_data from opt['datafile'] defined above)
with open(path) as labels_file:
context = csv.reader(labels_file)
next(context)
for item in context:
label, text = item
questions.append(text)
y.append([self.answer_candidates[int(label)]])
episode_done = True
indexes = range(len(questions))
if self.datatype_strict != 'test':
random_state = random.getstate()
random.setstate(self.random_state)
kf_seed = random.randrange(500000)
kf = KFold(self.opt.get('bagging_folds_number'), shuffle=True,
random_state=kf_seed)
i = 0
for train_index, test_index in kf.split(questions):
indexes = train_index if self.datatype_strict == 'train' else test_index
if i >= self.opt.get('bagging_fold_index', 0):
break
self.random_state = random.getstate()
random.setstate(random_state)
# define iterator over all queries
for i in indexes:
# get current label, both as a digit and as a text
# yield tuple with information and episode_done? flag
yield (questions[i], y[i]), episode_done
def reset(self):
"""Reset class, random state"""
super().reset()
random_state = random.getstate()
random.setstate(self.random_state)
random.shuffle(self.data.data)
self.random_state = random.getstate()
random.setstate(random_state)
def reset(self):
"""Reset class and random state."""
super().reset()
random_state = random.getstate()
random.setstate(self.random_state)
random.shuffle(self.data.data)
self.random_state = random.getstate()
random.setstate(random_state)
def __init__(self, random_state=None):
self._random_state = random_state
if self._random_state is None:
self._random_state = random.getstate()
def use_internal_state(self):
"""Use a specific RNG state."""
old_state = random.getstate()
random.setstate(self._random_state)
yield
self._random_state = random.getstate()
random.setstate(old_state)
def set_seed_tmp(seed=None):
if seed is None:
yield
else:
state = random.getstate()
np_state = np.random.get_state()
random.seed(seed)
np.random.seed(seed)
yield
np.random.set_state(np_state)
random.setstate(state)
def get_random_string(length=30, allowed_chars=string.ascii_letters + string.digits):
"""
Heavily inspired by Plone/Django
Returns a securely generated random string.
"""
if not using_sys_random:
# do our best to get secure random without sysrandom
seed_value = "%s%s%s" % (random.getstate(), time.time(), RANDOM_SECRET)
random.seed(sha(seed_value).digest())
return ''.join([random.choice(allowed_chars) for i in range(length)])
def get_random_string(length=12,
allowed_chars='abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
'''
?????????????????
'''
random.seed(
hashlib.sha256(
("%s%s%s" % (
random.getstate(),
time.time(),
'SCRWEWYOURBITCHES')).encode('utf-8')
).digest())
return ''.join(random.choice(allowed_chars) for i in range(length))
