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