def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' ').strip() if number[:3].lower() == 'bc1': number = number.lower() return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' .-').strip() if number.startswith('0000'): number = number[4:] # strip leading 0000 postgiro bank code return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' -').upper().strip() if number.startswith('MT'): number = number[2:] return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, '').upper().strip() module = _get_cc_module(number[:2]) if not module: raise InvalidComponent() return number[:2] + module.compact(number[2:])
def validate(number): """Checks to see if the number provided is a valid VAT number. This performs the country-specific check for the number.""" number = clean(number, '').upper().strip() module = _get_cc_module(number[:2]) if not module: raise InvalidComponent() return number[:2] + module.validate(number[2:])
def validate(number): """Checks to see if the number provided is a valid EIN. This checks the length, groups and formatting if it is present.""" match = _ein_re.search(clean(number, '').strip()) if not match: raise InvalidFormat() get_campus(number) # raises exception for unknown campus return compact(number)
def validate(number): """Checks to see if the number provided is a valid ATIN. This checks the length and formatting if it is present.""" match = _atin_re.search(clean(number, '').strip()) if not match: raise InvalidFormat() # sadly, no more information on ATIN number validation was found return compact(number)
def _split(number): """Split the number into a court, registry, register number and optionally qualifier.""" number = clean(number).strip() for fmt in _formats: m = re.match(fmt, number, flags=re.I | re.U) if m: return m.group('court'), m.group('registry'), m.group('nr'), m.group('x') raise InvalidFormat()
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' -./:').upper().strip() if number.startswith('EL') or number.startswith('GR'): number = number[2:] if len(number) == 8: number = '0' + number # old format had 8 digits return number
def compact(number, convert=False): """Convert the ISBN to the minimal representation. This strips the number of any valid ISBN separators and removes surrounding whitespace. If the covert parameter is True the number is also converted to ISBN-13 format.""" number = clean(number, ' -').strip().upper() if len(number) == 9: number = '0' + number if convert: return to_isbn13(number) return number
def validate(number): """Check if the number is a valid VAT number. This performs the country-specific check for the number. """ number = clean(number, '').strip() module = _get_cc_module(number[:2]) try: return number[:2].upper() + module.validate(number[2:]) except ValidationError: return module.validate(number)
def validate(number): """Checks to see if the number provided is a valid ITIN. This checks the length, groups and formatting if it is present.""" match = _itin_re.search(clean(number, '').strip()) if not match: raise InvalidFormat() area = match.group('area') group = match.group('group') if area[0] != '9' or group not in _allowed_groups: raise InvalidComponent() return compact(number)
def split(number): """Splits the number into a root, an episode or part, a check digit a version and another check digit. If any of the parts are missing an empty string is returned.""" number = clean(number, ' -').strip().upper() if len(number) == 17 or len(number) == 26: return number[0:12], number[12:16], number[16], number[17:25], number[25:] elif len(number) > 16: return number[0:12], number[12:16], '', number[16:24], number[24:] else: return number[0:12], number[12:16], number[16:], '', ''
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' -./').upper().strip() if number.startswith('BE'): number = number[2:] if number.startswith('(0)'): number = '0' + number[3:] if len(number) == 9: number = '0' + number # old format had 9 digits return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number).strip().replace(' ', '-').split('-') if len(number) == 4: # zero pad the different sections if they are found lengths = (2, 4, 7, 3) return ''.join(n.zfill(l) for n, l in zip(number, lengths)) else: # otherwise zero pad the account type number = ''.join(number) return number[:13] + number[13:].zfill(3)
def split(number): """Split the number into a root, an episode or part, a check digit a version and another check digit. If any of the parts are missing an empty string is returned.""" number = clean(number, ' -').strip().upper() if len(number) == 17 or len(number) == 26: return number[0:12], number[12:16], number[16], number[17:25], number[ 25:] elif len(number) > 16: return number[0:12], number[12:16], '', number[16:24], number[24:] else: return number[0:12], number[12:16], number[16:], '', ''
def validate(number): """Check if the number is a valid VAT number. This performs the country-specific check for the number.""" number = clean(number, '').upper().strip() cc = number[:2] module = _get_cc_module(cc) if not module: raise InvalidComponent() number = module.validate(number) if not number.startswith(cc): number = cc + number return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, '').upper().strip() cc = number[:2] module = _get_cc_module(cc) if not module: raise InvalidComponent() number = module.compact(number) if not number.startswith(cc): number = cc + number return number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' ').upper().strip() for prefix in ('УНП', u'УНП', 'UNP', u'UNP'): if type(number) == type(prefix) and number.startswith(prefix): number = number[len(prefix):] # Replace Cyrillic letters with Latin letters cleaned = ''.join(_cyrillic_to_latin.get(x, x) for x in to_unicode(number)) if type(cleaned) != type(number): # pragma: no cover (Python2 only) cleaned = cleaned.encode('utf-8') return cleaned
def check_vat_nl(self, vat): """ Temporary Netherlands VAT validation to support the new format introduced in January 2020, until upstream is fixed. Algorithm detail: http://kleineondernemer.nl/index.php/nieuw-btw-identificatienummer-vanaf-1-januari-2020-voor-eenmanszaken TODO: remove when fixed upstream """ try: from stdnum.util import clean from stdnum.nl.bsn import checksum except ImportError: return True vat = clean(vat, ' -.').upper().strip() # Remove the prefix if vat.startswith("NL"): vat = vat[2:] if not len(vat) == 12: return False # Check the format match = self.__check_vat_nl_re.match(vat) if not match: return False # Match letters to integers char_to_int = {k: str(ord(k) - 55) for k in string.ascii_uppercase} char_to_int['+'] = '36' char_to_int['*'] = '37' # 2 possible checks: # - For natural persons # - For non-natural persons and combinations of natural persons (company) # Natural person => mod97 full checksum check_val_natural = '2321' for x in vat: check_val_natural += x if x.isdigit() else char_to_int[x] if int(check_val_natural) % 97 == 1: return True # Company => weighted(9->2) mod11 on bsn vat = vat[:-3] if vat.isdigit() and checksum(vat) == 0: return True return False
def validate(number): """Check if the number is a valid identity number.""" number = compact(number) if len(number) not in (11, 13): raise InvalidLength() if number[-5] not in '-+': raise InvalidFormat() digits = clean(number, '-+') if not isdigits(digits): raise InvalidFormat() get_birth_date(number) luhn.validate(digits[-10:]) return number
def check_vat_ec(self, vat): try: from stdnum.util import clean from stdnum.ec import ci, ruc except ImportError: return True if self.l10n_latam_identification_type_id.is_vat: vat = clean(vat, ' -.').upper().strip() if self.l10n_latam_identification_type_id.name == 'Ced': return ci.is_valid(vat) elif self.l10n_latam_identification_type_id.name == 'RUC' and vat != '9999999999999': return ruc.is_valid(vat) return True
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = _cleanup_re.sub('/', clean(number).upper().strip()) # remove optional slash between first letter and county digits if number[1:2] == '/': number = number[:1] + number[2:] # normalise county number to two digits if number[2:3] == '/': number = number[:1] + '0' + number[1:] # convert trailing full date to year only m = _onrc_fulldate_re.match(number) if m: number = ''.join(m.groups()) return number
def to_isbn13(number): """Convert the number to ISBN-13 format.""" number = number.strip() min_number = clean(number, ' -') if len(min_number) == 13: return number # nothing to do, already ISBN-13 if len(min_number) == 9: number = '0' + number # convert from 9 to 10 digits # put new check digit in place number = number[:-1] + ean.calc_check_digit('978' + min_number[:-1]) # add prefix if ' ' in number: return '978 ' + number elif '-' in number: return '978-' + number else: return '978' + number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace. Also adds padding zeroes if necessary. """ number = clean(number, ' ').upper().strip() parts = number.split('-') if len(parts) == 3: # Pad each group with zeroes parts[0] = '0' * (2 - len(parts[0])) + parts[0] parts[1] = '0' * (4 - len(parts[1])) + parts[1] parts[2] = '0' * (4 - len(parts[2])) + parts[2] number = ''.join(parts) if len(number) == 9: number = '0' + number # Add leading zero return number
def validate(number): """Checks to see if the number provided is a valid SSN. This checks the length, groups and formatting if it is present.""" match = _ssn_re.search(clean(number, "").strip()) if not match: raise InvalidFormat() area = match.group("area") group = match.group("group") serial = match.group("serial") # check for all-0 or some unused areas # (9xx also won't be issued which includes the advertising range) if area == "000" or area == "666" or area[0] == "9" or group == "00" or serial == "0000": raise InvalidComponent() # check blacklists if format(number) in _ssn_blacklist: raise InvalidComponent() return compact(number)
def validate(number): """Check if the number is a valid SSN. This checks the length, groups and formatting if it is present.""" match = _ssn_re.search(clean(number, '').strip()) if not match: raise InvalidFormat() area = match.group('area') group = match.group('group') serial = match.group('serial') # check for all-0 or some unused areas # (9xx also won't be issued which includes the advertising range) if area == '000' or area == '666' or area[0] == '9' or \ group == '00' or serial == '0000': raise InvalidComponent() # check blacklists if format(number) in _ssn_blacklist: raise InvalidComponent() return compact(number)
def validate(number): """Checks to see if the number provided is a valid SSN. This checks the length, groups and formatting if it is present.""" match = _ssn_re.search(clean(number, '').strip()) if not match: raise InvalidFormat() area = match.group('area') group = match.group('group') serial = match.group('serial') # check for all-0 or some unused areas # (9xx also won't be issued which includes the advertising range) if area == '000' or area == '666' or area[0] == '9' or \ group == '00' or serial == '0000': raise InvalidComponent() # check blacklists if format(number) in _ssn_blacklist: raise InvalidComponent() return compact(number)
def __init__(self, plmnid): plmnid = clean(plmnid, ' -').strip().upper() if not isdigits(plmnid): raise ValueError("Invalid PLMNID %s" % plmnid) if len(plmnid) not in (4, 5): raise ValueError("Invalid PLMNID length %s" % plmnid) if len(tuple(numdb.get('imsi').split(plmnid))) < 2: raise ValueError("Invalid PLMNID format %s" % plmnid) self.info = dict(plmnid=plmnid) mcc_info, mnc_info = numdb.get('imsi').info(plmnid) self.info['mcc'] = mcc_info[0] self.info.update(mcc_info[1]) self.info['mnc'] = mnc_info[0] self.info.update(mnc_info[1])
def __init__(self, imsi): imsi = clean(imsi, ' -').strip().upper() if not isdigits(imsi): raise ValueError("Invalid IMSI %s" % imsi) if len(imsi) not in (14, 15): raise ValueError("Invalid IMSI length %s" % imsi) if len(tuple(numdb.get('imsi').split(imsi))) < 2: raise ValueError("Invalid IMSI length %s" % imsi) self.info = dict(imsi=imsi) mcc_info, mnc_info, msin_info = numdb.get('imsi').info(imsi) self.info['mcc'] = mcc_info[0] self.info.update(mcc_info[1]) self.info['mnc'] = mnc_info[0] self.info.update(mnc_info[1]) self.info['msin'] = msin_info[0] self.info.update(msin_info[1])
def compact(number): """Convert the HETU to the minimal representation. This strips surrounding whitespace and converts it to upper case.""" return clean(number, '').upper().strip()
def _cleanup(number): """Remove any grouping information from the number and removes surrounding whitespace.""" return clean(str(number), " -").strip().upper()
def check_vat_ec(self, vat): vat = clean(vat, ' -.').upper().strip() return self.is_valid_ruc_ec(vat)
def compact(number): """Convert the ISIL to the minimal representation. This strips surrounding whitespace.""" return clean(number, '').strip()
def compact(number): """Convert the Veronumero to the minimal representation. This strips surrounding whitespace and removes separators.""" return clean(number, ' ').strip()
def _cleanup(number): """Remove any grouping information from the number and removes surrounding whitespace.""" return clean(number, ' -').strip().upper()
def compact(number): """Convert the number to the minimal representation. This strips surrounding whitespace and separation dash.""" return clean(number, ' ').upper().strip()
def compact(number): """Convert the number to the minimal representation.""" number = clean(number, ' ').strip() if '-' not in number: number = '-'.join((number[:-3], number[-3:-1], number[-1:])) return number
def compact(number): """Convert the number to the minimal representation.""" return clean(number, ' ').upper().strip()
def compact(number): """Convert the number to the minimal representation. This strips the number of any surrounding whitespace.""" return clean(number, ' -').strip().upper()
def compact(number): """Convert the AT-02 number to the minimal representation. This strips the number of any valid separators and removes invalid characters.""" return clean(number, ' -/?:().m\'+"').strip().upper()
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' -.').strip() # pad with leading zeroes return (9 - len(number)) * '0' + number
def compact(number): """Convert the number to the minimal representation. This strips the number of any surrounding whitespace.""" number = clean(number).strip() return number
def compact(number): """Convert the kennitala to the minimal representation. This strips surrounding whitespace and separation dash, and converts it to upper case.""" return clean(number, '-').upper().strip()
def compact(number): """Convert the iban number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" return clean(number, ' -.').strip().upper()
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" number = clean(number, ' -').strip() # pad with leading zeroes return (9 - len(number)) * '0' + number
def compact(number): """Convert the number to the minimal representation. This strips the number of any valid separators and removes surrounding whitespace.""" return clean(number, '-').strip()
def compact(number): """Convert the number to the minimal representation.""" number = clean(number, ' -').upper().strip() if number.startswith('NZ'): return number[2:] return number
def compact(number): """Convert the number to the minimal representation.""" number = clean(number).strip() module = _get_cc_module(number[:2]) return number[:2] + module.compact(number[2:])
def compact(number): """Convert the MAC address to the minimal, consistent representation.""" number = clean(number, ' ').strip().lower().replace('-', ':') # zero-pad single-digit elements return ':'.join('0' + n if len(n) == 1 else n for n in number.split(':'))