def from_basic(self, data):
check_data_type(list, data)
check_length(4, data)
check_data_type(integer_types, data[0])
check_data_type(integer_types, data[1])
check_data_type(integer_types, data[2])
check_data_type(list, data[3])
if data[2] < 0:
raise BadData('Invalid negative number of steps: %d' % (data[2], ))
if data[2] > Settings.default.stateful_step_count * 1000:
raise BadData('Implausibly large number of steps: %d' %
(data[2], ))
record = []
for record_data in data[3]:
if record_data is None:
record.append(TOMBSTONE)
else:
check_data_type(list, record_data)
check_length(1, record_data)
record.append((None, record_data[0]))
return StateMachineRunner(
parameter_seed=data[0],
template_seed=data[1],
n_steps=data[2],
record=record,
)
def from_basic(self, data):
check_length(3, data)
check_data_type(integer_types, data[0])
check_data_type(integer_types, data[1])
if data[1] < self.min_size or data[1] > self.max_size:
raise BadData('Size %d out of range [%d, %r]' %
(data[1], self.min_size, self.max_size))
if data[0] == 0:
check_data_type(list, data[2])
return UniqueListTemplate(size=data[1],
template_seed=0,
parameter_seed=0,
parameter=None,
values=list(
map(self.elements.from_basic,
data[2])))
else:
if data[0] != 1:
raise BadData('Bad type tag %d' % (data[0], ))
check_length(2, data[2])
check_data_type(integer_types, data[2][0])
check_data_type(integer_types, data[2][1])
parameter_seed = data[2][0]
random = Random(parameter_seed)
return UniqueListTemplate(
size=data[1],
parameter_seed=parameter_seed,
template_seed=data[2][1],
values=None,
parameter=self.elements.draw_parameter(random))
def from_basic(self, data):
result = super(FixedBoundedFloatStrategy, self).from_basic(data)
if math.isnan(result):
raise BadData('NaN not allowed in range')
if result < self.lower_bound or result > self.upper_bound:
raise BadData('Value %f out of range [%f, %f]' %
(result, self.lower_bound, self.upper_bound))
return result
def from_basic(self, data):
check_data_type(integer_types, data)
if data < 0:
raise BadData('Index out of range: %d < 0' % (data,))
elif data >= len(self.elements):
raise BadData(
'Index out of range: %d >= %d' % (data, len(self.elements)))
return data
def from_basic(self, value):
check_data_type(list, value)
if self.element_strategy is None:
return ()
if len(value) < (self.min_size or 0):
raise BadData('List too short. len(%r)=%d < self.min_size=%d' %
(value, len(value), self.min_size))
if len(value) > (self.max_size or len(value)):
raise BadData('List too long. len(%r)=%d > self.min_size=%d' %
(value, len(value), self.max_size))
return tuple(map(self.element_strategy.from_basic, value))
def from_basic(self, data):
data = integer_or_bad(data)
if data < 0:
raise BadData(u'Value %d out of range [0, infinity)' % (
data,
))
return data
def from_basic(self, data):
data = integer_or_bad(data)
if data < self.start or data > self.end:
raise BadData(u'Value %d out of range [%d, %d]' % (
data, self.start, self.end
))
return data
def from_basic(self, value):
check_data_type(integer_types, value)
try:
return (
struct.unpack(b'!d', struct.pack(b'!Q', value))[0]
)
except (struct.error, ValueError, OverflowError) as e:
raise BadData(e.args[0])
def from_basic(self, values):
check_data_type(list, values)
check_length(8, values)
for d in values[:-1]:
check_data_type(int, d)
if values[-1] is not None:
check_data_type(text_type, values[-1])
template = tuple(values)
if not self.is_valid_template(template):
raise BadData('Invalid template %r' % (template, ))
return template
def from_basic(self, values):
check_data_type(list, values)
values = list(values)
check_length(8, values)
for d in values[:-1]:
check_data_type(int, d)
if values[-1] is not None:
check_data_type(text_type, values[-1])
try:
values[-1] = pytz.timezone(values[-1])
except pytz.UnknownTimeZoneError as e:
raise BadData(*e.args)
return DateTimeTemplate(*values)
def from_basic(self, data):
check_data_type(list, data)
if not (1 <= len(data) <= 2):
raise BadData('Expected list of length 1 or 2 but got %r' %
(data, ))
if len(data) == 1:
return Leaf(self.leaf_strategy.from_basic(data[0]))
else:
assert len(data) == 2
return Branch(label=self.branch_label_strategy.from_basic(data[0]),
keyed_children=tuple(
(self.branch_key_strategy.from_basic(k),
self.from_basic(v)) for k, v in data[1]))
def from_basic(self, data):
result = super(FloatsFromBase, self).from_basic(data)
if not self.is_valid_value(result, result):
raise BadData(u'Value %f out of range' % (result,))
return result
def from_basic(self, data):
check_data_type(text_type, data)
try:
return tuple(bytearray(base64.b64decode(data.encode('utf-8'))))
except Exception as e:
raise BadData(*e.args)
def from_basic(self, data):
data = integer_or_bad(data)
if data < self.lower_bound:
raise BadData('Value %d out of range [%d, infinity)' %
(data, self.lower_bound))
return data
def integer_or_bad(data):
check_data_type(text_type, data)
try:
return int(data)
except ValueError:
raise BadData(u'Invalid integer %r' % (data,))
def from_basic(self, data):
if data is not None:
raise BadData(u'Expected None but got %r' % (repr(data, )))
return None
def from_basic(self, data):
if data is not None:
raise BadData('Expected None but got %s' % (show(data,)))
return None
