def validate(self, trace=False): ''' Validates the input data. Raises a ValidationError upon failure. ''' # get row count self.rowcount = len(self.raw_data) # check for empty cells and mismatched column counts column_count = 0 if self.rowcount == 0 else len(self.raw_data[0]) for row in range(1, self.rowcount): count = len(self.raw_data[row]) if column_count != count: raise errors.ValidationError( 'Mismatched column counts: {0}, {1}'.format( column_count, count)) for col in range(count): cell = self.raw_data[row][col] if len(cell) == 0: raise errors.ValidationError( 'Empty cell at ({0},{1})'.format(row, col)) self.colcount = column_count if trace: print 'TRACE input matrix has {0} rows and {1} columns'.format( self.rowcount, self.colcount)
def check_input_single(seq): """Function for check sequence from input if a single siRNA strand have only actgu letters and is 19-21 nucleotides long. Also rigth end of siRNA is cut if contain 'uu' or 'tt'. Args: seq(str): sequence Returns: List of sequence, warning(or None), True Raises: ValidationError """ seq = seq.upper().replace('U', 'T') pattern = re.compile(r'^[ACGT]{19,21}$') cut_warn = "cut 'UU' or 'TT'" if not pattern.search(seq): if len(seq) > 21 or len(seq) < 19: raise errors.ValidationError('%s' % errors.len_error) raise errors.ValidationError('%s' % errors.patt_error) elif seq[-2:] == "TT" and pattern.search(seq): seq = seq[:-2] logging.warn(cut_warn) return [seq, cut_warn, True] elif pattern.search(seq): return [seq, None, True]
def get_param(source, param_name, validator=None, required=True, default=None, setto=None, no_null=True): """ A wrapper on a get-able source to allow validators as well. Parameters: source - An interface that provides a get method to obtain a value by key and a check for containment. param_name - Name of the parameter whose value is to be fetched. validator - The validator function to be applied (if one exists). required - Ensures that the value actually exists before validation is applied. default - If a value does not exist, then a default is used (before validation is applied). no_null - If True then a ValidationError is raised if the validator function returns a None value (even if it does not raise an exception). """ provided = param_name in source if required and default is None and not provided: raise errors.ValidationError( "Param '%s' required but not provided and default is None." % param_name) if not provided: value = default else: value = source.get(param_name) # Validate the value if it is required *or* provided if required or provided: if validator: if type(validator) is list: for v in validator: value = v(value) else: value = validator(value) if value is None and no_null: raise errors.ValidationError( "Parameter '%s' was found but validation return a null value." % param_name) if setto is not None: target, attr = setto setattr(target, attr, value) return value
def convert(self, trace=False): ''' Converts entries to numerical values. Handles an indicator for missing values. ''' try: for i in range(self.rowcount): row = self.raw_data[i] row_converted = [] for j in range(len(row)): value = self.raw_data[i][j] # record missing values as 'nan' if self.missing_designator and value == self.missing_designator: if trace: print 'TRACE missing value \'{0}\'found at ({1},{2})'.format( value, i, j) row_converted.append(float('nan')) else: row_converted.append(float(value)) self.converted.append(row_converted) except ValueError as e: raise errors.ValidationError( 'Non-numerical value at {0}, {1}'.format(i, j)) if trace: print 'TRACE converted data: ', self.converted
def ensurer(strinput): try: if type(strinput) is datetime.datetime: return strinput else: return datetime.datetime.strptime(strinput, date_format) except ValueError, ve: raise errors.ValidationError(ve.message)
def validate(data, validate_class): validate_data = validate_class(data) try: validate_data.validate() except schematics.exceptions.ValidationError as e: raise errors.ValidationError(400, error_messages=e.messages) return validate_data
def get_required_field(name, verbose_name=None): """Retrieve a field or raise an error.""" try: return flask.request.form[name] except KeyError: verbose_name = verbose_name or name raise errors.ValidationError('%s is a required field.' % verbose_name)
def validate_body(self, request): body = request.bounded_stream.read() try: request_data = json.loads(body) except ValueError: self.logger.warning('malformed request body', body=str(body)) raise errors.ValidationError() return request_data
def test_validated(self): dummy_validator = MagicMock() func = validated(dummy_validator)(lambda *a, **k: 'ok') self.assertEqual(func(), 'ok') # raise error dummy_validator.side_effect = errors.ValidationError('a') with patch('decorators.send_error') as mock: mock.return_value = '_error' self.assertEqual(func(), '_error') mock.assert_called_once_with('a is not valid')
def get_public_url(self, file_id, file_key): ''' Get a files public link including decrypted key ''' if file_id and file_key: public_handle = self.api_request({'a': 'l', 'n': file_id}) decrypted_key = a32_to_base64(file_key) return '{0}://{1}/#!%s!%s'.format(self.schema, self.domain) % (public_handle, decrypted_key) else: raise errors.ValidationError('File id and key must be set')
def parse_month(month): if month == 'all': return 0 try: return int(month) except ValueError: try: return constants.MONTHS_MAP[month.title()] except KeyError: raise errors.ValidationError('Invalid "Month" input.')
def parse_day(day): if day == 'all': return 0 try: return int(day) except ValueError: try: return constants.DAYS_MAP[day.title()] except KeyError: raise errors.ValidationError('Invalid "Day" input.')
def __init__(self, request): self.form, self.cleaned_data, self._error = {}, {}, None for name, params in self.fields.items(): value = get_request_arg(request, name) if params.get('required') and value is None: raise errors.ValidationRequiredError(name) if value is not None: try: value = get_argument(value, params['type']) except (TypeError, ValueError): raise errors.ValidationError(name) else: value = params.get('default') self.form[name] = value
def get_link(self, file): ''' Get a file public link from given file object ''' #print "file=",file file = file[1] if 'h' in file and 'k' in file: public_handle = self.api_request({'a': 'l', 'n': file['h']}) file_key = file['k'][file['k'].index(':') + 1:] decrypted_key = a32_to_base64( decrypt_key(base64_to_a32(file_key), self.master_key)) return '{0}://{1}/#!{2}!{3}'.format(self.schema, self.domain, public_handle, decrypted_key) else: raise errors.ValidationError('File id and key must be present')
def check_complementary(seq1, seq2): """Test for complementary, if both strands are in 5'-3' orientation class perform only when there are two strands given; should take as input both strand, input: * 5'acggcttGGaactuctggtac3' * 5'gtaccagaagttccaagccgt3' reverse second: * 3'tgccgaaccttgaagaccatg5' translate second strand in a way (a->t, t->a, u->a, c->g, g->c), * 5'acggcttGGaactuctggtac3' check if the strands are the same, starting with first nucleotide or -2,-1, +1,+2 (from the beggining or the end) with minimum 80% similarity 3) 5'acggcttGGaactuctggtac3' ||||||||||||||||||||| 3'tgccgaaccttgaagaccatg5' 5'acggcttGGaactuctggtac3' output: 'first sequence' (19-21nt), 'second sequence' (19-21nt), left_end {-4,-3,-2,-1,0,1,2,3,4}, rigth_end{-4,-3,-2,-1,0,1,2,3,4} Args: seq1(str): frist sequence seq2(str): second sequence Returns: tuple (first sequence(str), second sequence(str), left offset(int), right offset(int)) """ nr_offset = 5 tab = [] end_offset = len(seq1) - len(seq2) if check_complementary_single(seq1, seq2) >= 80: tab.append((seq1, seq2, 0, end_offset)) for offset in range(1, nr_offset): if check_complementary_single(seq1[offset:], seq2) >= 80: end_offset = len(seq1) - len(seq2) - offset tab.append((seq1, seq2, offset, end_offset)) if check_complementary_single(seq1, seq2[:-offset]) >= 80: end_offset = len(seq1) - len(seq2) + offset tab.append((seq1, seq2, -offset, end_offset)) if not tab: raise errors.ValidationError(errors.error) return tab[0]
def check_input(seq_to_be_check): """Function for checking many sequences and throw error if wrong input input limitations: possible letters: {ACTGUactgu}, change all 'u' to 't', length 19-21, one strand or two strands splitted by space, if two strands check if they are in correct 5'-3' orientation, allow |_20%_| mismatches, if the sequence is correct input returns 'first sequence' (19-21nt), 'second sequence' (19-21nt), left_end{-4,-3,-2,-1,0,1,2,3,4}, rigth_end{-4,-3,-2,-1,0,1,2,3,4} messages: * "correct sequence" * "changed 'u' to 't'" * "cut 'uu' or 'tt' ends" errors: * "too short" * "insert your siRNA sequence" * "too long" * "insert only one siRNA sequence or both strands of one siRNA at a time; check if both stands are in 5'-3' orientation" * "sequence can contain only {actgu} letters Args: seq_to_be_check: sequence(str) which will be check Returns: tuple from check_complementary Raises: ValidationError """ sequence = seq_to_be_check.split(" ") len_seq = len(sequence) if len_seq == 1: return (check_input_single(sequence[0])[0], '', 0, 0) elif len_seq == 2: ch_seq1 = check_input_single(sequence[0]) ch_seq2 = check_input_single(sequence[1]) if ch_seq1[2] and ch_seq2[2]: return check_complementary(ch_seq1[0], ch_seq2[0]) else: raise errors.ValidationError('{}'.format(errors.error))
def _find_suitable_storage_targets(self, media_id, data, distribution_total): """ Find distribution_total nodes capable of storing the supplied binary data. @param media_id: Unique id for the media. @type media_id: String @param data: Binary data to store @type data: String @param distribution_total: Number of nodes to get @type distribution_total: Integer @return: Hosts @rtype: List """ try: media_id = validation.media_id(media_id) if md5(data).hexdigest() != media_id: raise errors.ValidationError("media_id doesn't match data!") except errors.ValidationError, ex: return utils.return_deferred_error(ex.value)
def main(): global CITY_CHOICE while True: try: CITY_CHOICE, month, day = get_filters() df = load_data(CITY_CHOICE, month, day) if len(df) == 0: raise errors.ValidationError('No data to be displayed. Please change your filter options.') time_stats(df) station_stats(df) trip_duration_stats(df) user_stats(df) except errors.ValidationError as e: print('=' * 40) print('Error: {}'.format(e.message)) print('=' * 40) finally: restart = input('\nWould you like to restart? Enter yes or no.\n') if restart.lower() != 'yes': break
def datetime_from_now(delta_in_seconds): if type(delta_in_seconds) not in (float, long, int): raise errors.ValidationError("Expected long/float, found: %s" % str(type(delta_in_seconds))) return datetime.datetime.utcnow() + datetime.timedelta(0, delta_in_seconds)
def decorator(self, *args, **kwargs): val = validator(request) if not val.is_valid(): raise errors.ValidationError(val.get_error()) self.data = val.cleaned_data return method(self, *args, **kwargs)
def parse_city(city): city = city.strip().replace('_', ' ').title() if city not in constants.CITY_DATA: raise errors.ValidationError('Invalid "City" input.') return city
def _validateKeypress(self, keys): """Validates a keypress list""" for key in keys: if key.upper() not in values.key_list: raise errors.ValidationError("Invalid Key: {}".format(key)) return True
def parse_filter_choice(filter_choice): filter_choice = filter_choice.strip().lower() if filter_choice not in constants.ALLOWED_FILTER_CHOICES: raise errors.ValidationError('Invalid "Filter Choice" input.') return filter_choice