def validatePhoneNumber(number): valid = False try: # Leave shortcodes alone. if number is not None: if len(number) in (3, 4, 5, 6) and number.isdigit(): return True # it's okay to search for the region US for all US/Can b/c they share # the same parsing/formatting rules p = phonenumbers.parse(number, 'US') # but we need to check the number is valid in either country if phonenumbers.is_valid_number_for_region(p, 'US') or \ phonenumbers.is_valid_number_for_region(p, 'CA'): phonenumbers.format_number( p, phonenumbers.PhoneNumberFormat.E164 ) valid = True except phonenumbers.NumberParseException as e: logging.error('Detected invalid phone number: {0}-{1}'.format( number, e)) return valid
def validatePhoneNumber(number, allowShortcode=True): valid = False try: # Leave shortcodes alone. if number is not None: if allowShortcode and len(number) in ( 3, 4, 5, 6) and number.isdigit(): # noqa return True # it's okay to search for the region US for all US/Can b/c they # share the same parsing/formatting rules p = phonenumbers.parse(number, 'US') # but we need to check the number is valid in either country if phonenumbers.is_valid_number_for_region(p, 'US') or \ phonenumbers.is_valid_number_for_region(p, 'CA'): phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.E164) valid = True except phonenumbers.NumberParseException as e: logging.warning('Detected invalid phone number: {0} - {1}'.format( number, e)) return valid
def test_load_alt_patterns(load_fixture): phone_number = PhoneNumber(load_fixture) assert phone_number.get_national() == '+0{}'.format('2' * 7) assert phone_number.get_mobile() == '+0{}'.format('1' * 9) clean_alt_patters() phone_number = PhoneNumber(load_fixture) num_obj = phonenumbers.parse(phone_number.get_national(), load_fixture) assert phonenumbers.is_valid_number_for_region(num_obj, load_fixture) num_obj = phonenumbers.parse(phone_number.get_mobile(), load_fixture) assert phonenumbers.is_valid_number_for_region(num_obj, load_fixture)
def change_phonenumbers(apps, schema_editor): Flat = apps.get_model('property', 'Flat') for flat in Flat.objects.all(): phone_number = phonenumbers.parse(flat.owners_phonenumber, 'RU') if phonenumbers.is_valid_number_for_region(phone_number, 'RU'): flat.owner_phone_pure = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) flat.save()
def validate_phone_number(phone_number: str = ''): try: if not phone_number: return 'Missing phone number', -4 if type(phone_number) != str: return "Unable to determine phone number", -4 region = "KE" # Create a `PhoneNumber` object from a string representing a phone number # Specify country of origin of phone number. # This maybe unnecessary for numbers starting with '+' since they are globally unique. parsed_phone = phonenumbers.parse(phone_number, region) # Check whether it's a possible number (e.g. it has the right number of digits) if not phonenumbers.is_possible_number(parsed_phone): return "Possibly not a number. Check if e.g. number of digits is correct", -4 # Check whether it's a valid number (e.g. it's in an assigned exchange) if not phonenumbers.is_valid_number_for_region(parsed_phone, region): return "Invalid phone number", -4 # Format number as per international format code E164 phone_number = phonenumbers.format_number( parsed_phone, phonenumbers.PhoneNumberFormat.E164) # Get the carrier of the phone number operator = carrier.name_for_number(parsed_phone, "en") if carrier.name_for_number( parsed_phone, "en") else '' return f"""Phone number valid. Phone: {phone_number}. Operator: {operator}""", 0 except phonenumbers.phonenumberutil.NumberParseException as err: return f'{err}', -4 except BaseException as ex: return f'{ex}', -4
def ussd_flow(request): request_data = request.GET if request.method == 'GET' else request.POST request_data = request_data.copy() request_data['format'] = 'text' mobile = request_data.get(settings.USSD_MOBILE_NUMBER_FIELD, '') try: country_code = pycountry.countries.lookup(settings.COUNTRY).alpha_2 pn = phonenumbers.parse(mobile, country_code) if phonenumbers.is_valid_number_for_region(pn, country_code): mobile = pn.national_number request_data['uid'] = mobile request_data['value'] = request_data.get(settings.USSD_MSG_FIELD, '') if request.method == 'GET': request.GET = request_data if request.method == 'POST': request.POST = request_data _response = respond(request) response = settings.USSD_RESPONSE_FORMAT % { 'response': _response.content.strip() } else: response = 'Invalid mobile number for your region' except phonenumbers.NumberParseException: response = 'Invalid mobile number' return HttpResponse(response.encode('ascii'), content_type='text/plain; charset=utf-8')
def parse_phone(phone_str, country_code=0, alpha2=u"US"): "returns a dict with phone number properties if the string is parsable" """ returns dict w/: phone_str, phone_str_digits_only, country_code, region, errors (if any) """ try: if COUNTRY_RG.match(phone_str): phone = parse_number(rm_punct_leaving_plus_sign(phone_str), keep_raw_input=True) elif country_code != 0: phone = parse_number(u"+{} {}".format(country_code, phone_str), keep_raw_input=True) else: country_code = country_code_for_region(alpha2) if country_code != 0: phone = parse_number(u"+{} {}".format(country_code, phone_str), keep_raw_input=True) else: phone = parse_number(phone_str, alpha2, keep_raw_input=True) phone_dict = phone.__dict__.copy() phone_dict['region_code'] = region_code_for_country_code(phone.country_code) phone_dict['phone_str'] = phone_str phone_dict['is_valid_for_region'] = is_valid_number_for_region(phone, region_code_for_country_code(phone.country_code)) except: keys = ['region_code','italian_leading_zero','extension','national_number','is_valid_for_region','raw_input','country_code_source','phone_str','country_code','number_of_leading_zeros','preferred_domestic_carrier_code'] phone_dict = {k: None for k in keys} phone_dict['phone_str'] = phone_str return phone_dict
def is_phone_number_valid(phone_number): try: parse = phonenumbers.parse(phone_number) except phonenumbers.phonenumberutil.NumberParseException: return False if phonenumbers.is_valid_number_for_region(parse, 'RU'): return parse.national_number
def validate(self): # check if all required fields are filled rv = FlaskForm.validate(self) if not rv: return False password = self.password.data if len(password) < 8 or len(password) > 100: self.password.errors.append( "Please enter a password of between 8 and 100 characters") return False telephone = self.telephone.data if not telephone: self.telephone.errors.append("Missing phone numbers") return False if type(telephone) != str: self.telephone.errors.append("Unable to determine phone number") return False region = "KE" # Create a `PhoneNumber` object from a string representing a phone number # Specify country of origin of phone number. # This maybe unnecessary for numbers starting with '+' since they are globally unique. phone = phonenumbers.parse(telephone, region) # Check whether it's a possible number (e.g. it has the right number of digits) if not phonenumbers.is_possible_number(phone): self.telephone.errors.append( "Possibly not a number. Check if e.g. number of digits is correct" ) return False # Check whether it's a valid number (e.g. it's in an assigned exchange) if not phonenumbers.is_valid_number_for_region(phone, region): self.telephone.errors.append("Invalid phone number") return False # Format number as per international format code E164 phone_number = phonenumbers.format_number( phone, phonenumbers.PhoneNumberFormat.E164) # Get the carrier of the phone number operator = carrier.name_for_number( phone, "en") if carrier.name_for_number(phone, "en") else '' print(phone_number, operator) # Ensure phone is Safaricom if operator != "Safaricom": self.telephone.errors.append( "Kindly use a Safaricom line for MPESA prompt") return False # If telephone is not registered, raise error user = User.query.filter_by(telephone=phone_number).first() if not user: self.telephone.errors.append('User not registered') return False # confirm user's password if not user.verify_password(password): self.password.errors.append("Invalid password") return False return True
def parsePhoneNumber(n, debugging=False): if debugging: print(n) n = pn.parse(n, 'GB') assert (pn.is_possible_number(n)) isUK = pn.is_valid_number_for_region(n, 'GB') if debugging: print('valid UK number?', isUK) INTN = pn.format_number(n, pn.PhoneNumberFormat.INTERNATIONAL) if debugging: print INTN return INTN
def parsePhoneNumber(n,debugging = False): if debugging: print (n) n = pn.parse(n,'GB') assert (pn.is_possible_number(n)) isUK = pn.is_valid_number_for_region(n,'GB') if debugging: print('valid UK number?',isUK) INTN = pn.format_number(n, pn.PhoneNumberFormat.INTERNATIONAL) if debugging: print INTN return INTN
async def get_user_phonenumber(self, phonenumber: str): try: phone = phonenumbers.parse(phonenumber, self.region) except phonenumbers.phonenumberutil.NumberParseException: raise TypeError("Invalid Phone Number") if is_valid_number_for_region(phone, self.region): return phonenumbers.format_number( phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL) raise Exception( f"{phonenumber} is not a valid number format for {self.country_name.name.capitalize()}" )
def parse_phone_number(pnum, country='us'): """Parse and validate phone number input and return an E164 formatted number or None if invalid.""" region_code = country.upper() try: pn = phonenumbers.parse(pnum, region_code) except phonenumbers.NumberParseException: return None if phonenumbers.is_valid_number_for_region(pn, region_code): return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164) return None
def parse_phone_number(pnum, country="us"): """Parse and validate phone number input and return an E164 formatted number or None if invalid.""" region_code = country.upper() try: pn = phonenumbers.parse(pnum, region_code) except phonenumbers.NumberParseException: return None if phonenumbers.is_valid_number_for_region(pn, region_code): return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164) return None
def format_for_display(value, region): try: phonenumber = phonenumbers.parse(value, region) except phonenumbers.NumberParseException: # For historical data that may not be parseable return value if phonenumbers.is_valid_number_for_region(phonenumber, region): return phonenumbers.format_number( phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL) else: return phonenumbers.format_number( phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def detect(self, txt, country="FR"): """ :param txt: the text where we will try to find phone numbers :param country: the country format of the phone """ txt = re.sub("\s", " ", txt) return [(self._categorize_phone(txt, match), pn.format_number(match.number, pn.PhoneNumberFormat.INTERNATIONAL)) for match in pn.PhoneNumberMatcher(txt, country) if pn.is_valid_number_for_region(match.number, country)]
def send(self, message): """ Send a single text message. TODO: Add a batch send feature. :param message: (smsframework.OutgoingMessage) The message to send. :return: (smsframework.OutgoingMessage) The sent message, updated with msgid. """ logging.debug('smsframework africastalking sending sms') target_country = message.provider_params['target_country'] try: phone_number = phonenumbers.parse(message.dst, target_country) except: raise InvalidNumberError(message.dst, 'Unable to Parse Number') number_is_valid = phonenumbers.is_valid_number_for_region( phone_number, target_country) if number_is_valid is False: raise InvalidNumberError(message.dst, 'Invalid Phone Number for Target Country', target_country=target_country) try: formatted_number = phonenumbers.format_number( phone_number, phonenumbers.PhoneNumberFormat.E164) except: InvalidNumberError(message.dst, 'Unable to Parse Phone Number') try: api_response = self.sms_client.send( message.body, [formatted_number], message.provider_options.senderId) except Exception as e: error = json.loads(e.args[0]) error_status = error['SMSMessageData']['Recipients'][0]['status'] logging.error('smsframework africastalking sms failed') if error_status == 'InvalidPhoneNumber': raise InvalidNumberError(formatted_number) else: raise AfricasTalkingProviderError(error_status) sent_message = api_response['SMSMessageData']['Recipients'][0] message.msgid = sent_message['messageId'] return message
def format_for_display(value, region=None): try: phonenumber = phonenumbers.parse(value, region) except phonenumbers.NumberParseException: # For historical data that may not be parseable return value if region is not None and phonenumbers.is_valid_number_for_region( phonenumber, region): return phonenumbers.format_number( phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL) else: return phonenumbers.format_number( phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def validatePhoneNumber(self): self.phonenumber_details[ 'is_validnumber'] = phonenumbers.is_valid_number( self.phonenumber_object) self.phonenumber_details[ 'is_possiblenumber'] = phonenumbers.is_possible_number( self.phonenumber_object) self.phonenumber_details[ 'is_validnumberforRegion'] = phonenumbers.is_valid_number_for_region( self.phonenumber_object, self.get_iso2()) return self.phonenumber_details[ 'is_validnumber'] * self.phonenumber_details[ 'is_possiblenumber'] * self.phonenumber_details[ 'is_validnumberforRegion']
def validate_phone_number(value, country_code='VN'): """ Validate a phone number :param value: :param country_code: country code to check phone number :return: formated phone number """ msg = _('Invalid phone number format.') try: phone = phonenumbers.parse(value, country_code) except: raise ValidationError(msg) if not phonenumbers.is_valid_number_for_region(phone, country_code): raise ValidationError(msg) return value
def clean_phone_number(self): region_code = "US" # US only for proof of concept. number = self.cleaned_data["phone_number"] # For testing purposes we accept 5555555555 (no formatting). if number == "5555555555": return number try: pn = phonenumbers.parse(number, region_code) except phonenumbers.NumberParseException: raise forms.ValidationError("Invalid phone number") if not phonenumbers.is_valid_number_for_region(pn, region_code): raise forms.ValidationError(f"Invalid phone number for region: {region_code}") return phonenumbers.format_number(pn, phonenumbers.PhoneNumberFormat.E164)
def parse_mobile_number(value): def is_mobile_number(parsed_number): for prefix in MOBILE_PHONE_PREFIXES: if str(parsed_number.national_number).startswith(prefix[1:]): return True return False try: parsed_number = phonenumbers.parse(value, 'DE') except NumberParseException: raise ValidationError(BAD_FORMAT_NUMBER) if not phonenumbers.is_valid_number_for_region(parsed_number, 'de'): raise ValidationError(INVALID_NUMBER) if not is_mobile_number(parsed_number): raise ValidationError(INVALID_MOBILE_NUMBER) return phonenumbers.format_number(parsed_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def parse_mobile_number(value): def is_mobile_number(parsed_number): for prefix in MOBILE_PHONE_PREFIXES: if str(parsed_number.national_number).startswith(prefix[1:]): return True return False try: parsed_number = phonenumbers.parse(value, 'DE') except NumberParseException: raise ValidationError(BAD_FORMAT_NUMBER) if not phonenumbers.is_valid_number_for_region(parsed_number, 'de'): raise ValidationError(INVALID_NUMBER) if not is_mobile_number(parsed_number): raise ValidationError(INVALID_MOBILE_NUMBER) return phonenumbers.format_number( parsed_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
def clean_user_identifier(self): identifier = self.cleaned_data.get('user_identifier', '') try: country_code = pycountry.countries.lookup(settings.COUNTRY).alpha_2 identifier = phonenumbers.parse(identifier, country_code) if phonenumbers.is_valid_number_for_region(identifier, country_code): self.cleaned_data[ 'user_identifier'] = identifier.national_number else: raise ValidationError('Invalid mobile number for your region') except phonenumbers.NumberParseException: raise ValidationError('Invalid mobile number') accesses = USSDAccess.objects.filter( user_identifier=identifier.national_number) if self.instance and accesses.exclude( interviewer=self.instance.interviewer).exists(): raise ValidationError( 'This mobile number is already in use by %s' % accesses. exclude( interviewer=self.instance.interviewer)[0].interviewer.name) return self.cleaned_data['user_identifier']
def clean_user_identifier(self): identifier = self.cleaned_data.get('user_identifier', '') try: identifier = phonenumbers.parse(identifier, settings.COUNTRY_CODE) if phonenumbers.is_valid_number_for_region(identifier, settings.COUNTRY_CODE): self.cleaned_data[ 'user_identifier'] = identifier.national_number else: raise ValidationError('Invalid mobile number for your region') except phonenumbers.NumberParseException: raise ValidationError('Invalid mobile number') accesses = USSDAccess.objects.filter( user_identifier=identifier.national_number) if self.instance and accesses.exclude( interviewer=self.instance.interviewer).exists(): raise ValidationError( 'This mobile number is already in use by %s' % accesses.exclude( interviewer=self.instance.interviewer)[0].interviewer.name) return self.cleaned_data['user_identifier']
def validate(self, attrs): """ Validate that every attributes of the serializer is valid. This mainly checks the phone number. :param attrs: attributes to validate :return: all valid attributes """ attrs = super().validate(attrs) if "phone_number" in attrs and "country" not in attrs: raise ValidationError({ "country": "This field is required when giving phone number." }) if "country" in attrs and "phone_number" not in attrs: raise ValidationError({ "phone_number": "This field is required when giving a country." }) if "phone_number" in attrs: try: phone_number = phonenumbers.parse(attrs["phone_number"], attrs["country"]) except Exception: raise ValidationError( {"phone_number": "This is not a valid phone number"}) if not phonenumbers.is_valid_number_for_region( phone_number, attrs["country"]): raise ValidationError( {"phone_number": "This is not a valid phone number."}) attrs["phone_number"] = phonenumbers.format_number( phone_number, phonenumbers.PhoneNumberFormat.E164) attrs.pop("country") return attrs
def handle(request): if request.method == 'GET': data = request.GET else: data = request.POST trnx_id = data.get('transactionId', '').strip() msisdn = data.get('msisdn', '').strip() try: pn = phonenumbers.parse(msisdn, settings.COUNTRY_CODE) if phonenumbers.is_valid_number_for_region(pn, settings.COUNTRY_CODE): msisdn = pn.national_number else: return HttpResponse('Invaid mobile number for your region') except phonenumbers.NumberParseException: return HttpResponse('Invaid mobile number') request_string = data.get('ussdRequestString', '').strip() res = manage(msisdn, trnx_id, request_string) action = 0 if res: action = 1 ussd_resp = 'responseString=%s&action=%s' % (res, action) return HttpResponse(ussd_resp)
def format_value(cls, value=None, type_=None): if phonenumbers and type_ in _PHONE_TYPES: Configuration = Pool().get('party.configuration') config = Configuration(1) if config.party_phonecountry: code = config.party_phonecountry.code try: phonenumber = phonenumbers.parse(value, region=code) except NumberParseException: pass else: if phonenumbers.is_possible_number( phonenumber) and phonenumbers.is_valid_number( phonenumber): if code and phonenumbers.is_valid_number_for_region( phonenumber, code): value = phonenumbers.format_number( phonenumber, PhoneNumberFormat.NATIONAL) else: value = phonenumbers.format_number( phonenumber, PhoneNumberFormat.INTERNATIONAL) return value
def clean_phone_number(self): value = self.cleaned_data["phone_number"] if not value: return value country = self.initial.get("country") if country is None: return value country = "{}".format(country) try: ph = phonenumbers.parse(value, country) if not phonenumbers.is_valid_number(ph): raise forms.ValidationError(_("Invalid phone number")) if not phonenumbers.is_valid_number_for_region(ph, country): raise forms.ValidationError(_("Invalid phone number")) except phonenumbers.NumberParseException: raise forms.ValidationError(_("Invalid phone number")) return value
def test_find_iso3(capfd, iso, code, arg): os.system('phone-gen {}{}'.format(arg, iso)) captured = capfd.readouterr() num_obg = phonenumbers.parse(captured.out, code) assert phonenumbers.is_valid_number_for_region(num_obg, code)
def test_get_without_country_code(capfd, country, arg): os.system('phone-gen -f{} {}'.format(arg, country)) captured = capfd.readouterr() code = PATTERNS['data'][country]['code'] num_obg = phonenumbers.parse('{}{}'.format(code, captured.out), country) assert phonenumbers.is_valid_number_for_region(num_obg, country)
def test_get_country(capfd, country, arg): os.system('phone-gen {}{}'.format(arg, country)) captured = capfd.readouterr() num_obg = phonenumbers.parse(captured.out, country) assert phonenumbers.is_valid_number_for_region(num_obg, country)
def valid_mobile_number(number): parsed_number = phonenumbers.parse(number, 'DE') assert phonenumbers.is_valid_number_for_region( parsed_number, 'de'), parsed_number return True
def validatePhoneNumber(self): self.phonenumber_details['is_validnumber'] = phonenumbers.is_valid_number(self.phonenumber_object) self.phonenumber_details['is_possiblenumber'] = phonenumbers.is_possible_number(self.phonenumber_object) self.phonenumber_details['is_validnumberforRegion'] = phonenumbers.is_valid_number_for_region(self.phonenumber_object,self.get_iso2()) return self.phonenumber_details['is_validnumber'] * self.phonenumber_details['is_possiblenumber'] * self.phonenumber_details['is_validnumberforRegion']
def validate_phone_number(self, phone_number): phone_number_obj = phonenumbers.parse(phone_number, 'US') if not phonenumbers.is_valid_number_for_region(phone_number_obj, 'US'): raise ValidationError('Not USA phone number') return phone_number
def test_mobile(country, count): phone_number = PhoneNumber(country) number = phone_number.get_mobile() num_obj = phonenumbers.parse(number, country) assert phonenumbers.is_valid_number_for_region(num_obj, country)
def test_ref(code, ref, count): number = PhoneNumber(code).get_number() num_obj = phonenumbers.parse(number, code) assert phonenumbers.is_valid_number_for_region(num_obj, ref)