def testShortNumbersValidAndCorrectCost(self):
invalid_string_cases = []
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
exampleShortNumber = shortnumberinfo._example_short_number(
regionCode)
phoneNumber = phonenumberutil.parse(exampleShortNumber, regionCode)
if not shortnumberinfo.is_valid_short_number_for_region(
phoneNumber, regionCode):
invalid_string_case = "region_code: %s, national_number: %s" % (
regionCode, exampleShortNumber)
invalid_string_cases.append(invalid_string_case)
prnt("Failed validation from string %s" % invalid_string_case,
file=sys.stderr)
if not shortnumberinfo.is_valid_short_number(phoneNumber):
self.invalid_cases.append(phoneNumber)
prnt("Failed validation for %s" % phoneNumber, file=sys.stderr)
for cost in [
ShortNumberCost.TOLL_FREE, ShortNumberCost.STANDARD_RATE,
ShortNumberCost.PREMIUM_RATE, ShortNumberCost.UNKNOWN_COST
]:
exampleShortNumber = shortnumberinfo._example_short_number_for_cost(
regionCode, cost)
if exampleShortNumber != "":
phoneNumber = phonenumberutil.parse(
exampleShortNumber, regionCode)
if cost != shortnumberinfo.expected_cost_for_region(
phoneNumber, regionCode):
self.wrong_type_cases.append(phoneNumber)
prnt("Wrong cost for %s" % phoneNumber,
file=sys.stderr)
self.assertEqual(0, len(invalid_string_cases))
self.assertEqual(0, len(self.invalid_cases))
self.assertEqual(0, len(self.wrong_type_cases))
def testShortNumbersValidAndCorrectCost(self):
invalid_string_cases = []
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
if regionCode == "PG":
# The only short number for Papua New Guinea is 000, which
# fails the test, since the national prefix is 0. This needs
# to be fixed.
continue
exampleShortNumber = shortnumberinfo._example_short_number(regionCode)
if not shortnumberinfo.is_valid_short_number(exampleShortNumber, regionCode):
invalid_string_case = "region_code: %s, national_number: %s" % (regionCode, exampleShortNumber)
invalid_string_cases.append(invalid_string_case)
print >> sys.stderr, "Failed validation from string %s" % invalid_string_case
phoneNumber = phonenumberutil.parse(exampleShortNumber, regionCode)
if not shortnumberinfo.is_valid_short_number_object(phoneNumber):
self.invalid_cases.append(phoneNumber)
print >> sys.stderr, "Failed validation for %s" % phoneNumber
for cost in [ShortNumberCost.TOLL_FREE, ShortNumberCost.STANDARD_RATE,
ShortNumberCost.PREMIUM_RATE, ShortNumberCost.UNKNOWN_COST]:
exampleShortNumber = shortnumberinfo._example_short_number_for_cost(regionCode, cost)
if exampleShortNumber != "":
phoneNumber = phonenumberutil.parse(exampleShortNumber, regionCode)
if cost != shortnumberinfo.expected_cost(phoneNumber):
self.wrong_type_cases.append(phoneNumber)
print >> sys.stderr, "Wrong cost for %s" % phoneNumber
self.assertEqual(0, len(invalid_string_cases))
self.assertEqual(0, len(self.invalid_cases))
self.assertEqual(0, len(self.wrong_type_cases))
def get_phone_number_object(self, data_string):
"""
Takes the data_string and tries to parse a phone number out of it
:param data_string: data that might be a phone number
:type data_string: str
:return: phone number data if it's a phone number
:rtype: dict
"""
try:
check_region = (data_string[0] == "+")
# First pass to see if it's a valid number
num_obj = phonenumberutil.parse(
data_string,
_check_region=check_region
)
num_desc = geocoder.description_for_valid_number(
num_obj, "en"
).strip()
except NumberParseException:
# If we can't parse it out, it's not a valid number
return False
# if we weren't able to check the region, and we didn't get a
# description we want to modify the data and give it another go
# with a country code added
if not check_region and not num_desc:
prefix = None
if len(self.digits) == 11 and data_string[0] == "1":
prefix = "+"
elif len(self.digits) == 10 \
and (data_string[0].isdigit() or
data_string[0] in string.punctuation):
prefix = "+1"
if prefix:
try:
# Second pass to see if we can get an actual
# geocode out of it using a hammer
second_pass = phonenumberutil.parse(prefix + data_string)
num_desc = geocoder.description_for_valid_number(
second_pass, "en"
).strip()
if num_desc:
num_obj = second_pass
# confidence hit because we had to
# modify the data to get a result
self.confidence -= 5
except (NumberParseException, Exception):
pass
# Attempting to get a valid region
num_region = phonenumberutil.region_code_for_number(num_obj)
# This is the compiled phone number data that
# we will use for the confidence decision
return self.build_phone_number_dict(num_obj, num_desc, num_region)
def testWhitespaceInNationalPrefixForParsing(self):
# Python version extra test
# AR metadata has whitespace in the RE for nationalPrefixForParsing
number = phonenumberutil.parse("+540348215617137", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
number = phonenumberutil.parse("0344615614207", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
def testWhitespaceInNationalPrefixForParsing(self):
# Python version extra test
# AR metadata has whitespace in the RE for nationalPrefixForParsing
number = phonenumberutil.parse("+540348215617137", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
number = phonenumberutil.parse("0344615614207", "AR")
self.assertTrue(phonenumberutil.is_valid_number(number))
self.assertEqual(PhoneNumberType.MOBILE, phonenumberutil.number_type(number))
def get_phone_number_object(self, data_string):
"""Takes the data_string and tries to parse a phone number out of it"""
try:
check_region = (data_string[0] == "+")
# First pass to see if it's a valid number
num_obj = phonenumberutil.parse(
data_string,
_check_region=check_region
)
num_desc = geocoder.description_for_valid_number(
num_obj, "en"
).strip()
except NumberParseException:
# If we can't parse it out, it's not a valid number
return False
# if we weren't able to check the region, and we didn't get a
# description we want to modify the data and give it another go
# with a country code added
if not check_region and not num_desc:
prefix = None
if len(self.digits) == 11 and data_string[0] == "1":
prefix = "+"
elif len(self.digits) == 10 \
and (data_string[0].isdigit() or
data_string[0] in string.punctuation):
prefix = "+1"
if prefix:
try:
# Second pass to see if we can get an actual
# geocode out of it using a hammer
second_pass = phonenumberutil.parse(prefix + data_string)
num_desc = geocoder.description_for_valid_number(
second_pass, "en"
).strip()
if num_desc:
num_obj = second_pass
# confidence hit because we had to
# modify the data to get a result
self.confidence -= 5
except (NumberParseException, Exception):
pass
# Attempting to get a valid region
num_region = phonenumberutil.region_code_for_number(num_obj)
# This is the compiled phone number data that
# we will use for the confidence decision
return self.build_phone_number_dict(num_obj, num_desc, num_region)
def testEmergency(self):
wrongTypeCounter = 0
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
if regionCode == "PG":
# The only short number for Papua New Guinea is 000, which
# fails the test, since the national prefix is 0. This needs
# to be fixed.
continue
metadata = PhoneMetadata.short_metadata_for_region(
regionCode, None)
desc = metadata.emergency
if desc.example_number is not None:
exampleNumber = desc.example_number
if (not fullmatch(re.compile(desc.possible_number_pattern),
exampleNumber)
or not is_emergency_number(exampleNumber, regionCode)):
wrongTypeCounter += 1
print >> sys.stderr, "Emergency example number test failed for %s" % regionCode
else:
emergencyNumber = phonenumberutil.parse(
exampleNumber, regionCode)
if shortnumberinfo.expected_cost(
emergencyNumber) != ShortNumberCost.TOLL_FREE:
# TODO: Reenable this when a method is available to get the expected cost for a
# particular region.
#wrongTypeCounter += 1
print >> sys.stderr, "Emergency example number not toll free for %s" % regionCode
self.assertEqual(0, wrongTypeCounter)
def testBlankMetadata(self):
# Python version extra test
# Some metadata is blank; check that we cope with this.
# Example: MH (+692)
number = phonenumberutil.parse("+6927654321", "US")
self.assertEqual("Country Code: 692 National Number: 7654321",
str(number))
def test_build_phone_number_dict(self):
numObj = phonenumberutil.parse("+1-979-549-5150")
numDict = self.pp.build_phone_number_dict(numObj, "Angleton, TX", "US")
self.assertEqual(numDict, self.testDict)
def calculate_confidence(cls, data):
"""Calculates a confidence rating for this (possible) equation"""
# We start with 100% confidence, and
# then lower our confidence if needed.
confidence = 100
# lowering confidence if we have a phone number
try:
if len(data) <= 30 and len(data) >= 7:
phonenumberutil.parse(data, _check_region=False)
for _ in [c for c in data if c in string.punctuation]:
confidence -= 10
except NumberParseException:
pass
return confidence
def to_python(self, value):
if isinstance(value, basestring) and value != '':
try:
value = format_number(parse(value,"US"),PhoneNumberFormat.INTERNATIONAL)
except NumberParseException:
pass
return value
def testGBLocalNumberLength(self):
# Python version extra test. Issue #172.
numobj = phonenumberutil.parse("+4408001111", "GB")
self.assertEqual(
"+44 800 1111",
phonenumberutil.format_number(
numobj, phonenumberutil.PhoneNumberFormat.INTERNATIONAL))
def testMatchWithSurroundingZipcodes(self):
number = "415-666-7777"
zipPreceding = "My address is CA 34215 - " + number + " is my number."
expectedResult = phonenumberutil.parse(number, "US")
matcher = PhoneNumberMatcher(zipPreceding, "US")
if matcher.has_next():
match = matcher.next()
else:
match = None
self.assertTrue(match is not None,
msg="Did not find a number in '" + zipPreceding +
"'; expected " + number)
self.assertEqual(expectedResult, match.number)
self.assertEqual(number, match.raw_string)
# Now repeat, but this time the phone number has spaces in it. It should still be found.
number = "(415) 666 7777"
zipFollowing = "My number is " + number + ". 34215 is my zip-code."
matcher = PhoneNumberMatcher(zipFollowing, "US")
if matcher.has_next():
matchWithSpaces = matcher.next()
else:
matchWithSpaces = None
self.assertTrue(matchWithSpaces is not None,
msg="Did not find a number in '" + zipFollowing +
"'; expected " + number)
self.assertEqual(expectedResult, matchWithSpaces.number)
self.assertEqual(number, matchWithSpaces.raw_string)
def testMatchWithSurroundingZipcodes(self):
number = "415-666-7777"
zipPreceding = "My address is CA 34215. " + number + " is my number."
expectedResult = phonenumberutil.parse(number, "US")
matcher = PhoneNumberMatcher(zipPreceding, "US")
if matcher.has_next():
match = matcher.next()
else:
match = None
self.assertTrue(match is not None,
msg="Did not find a number in '" + zipPreceding + "'; expected " + number)
self.assertEquals(expectedResult, match.number)
self.assertEquals(number, match.raw_string)
# Now repeat, but this time the phone number has spaces in it. It should still be found.
number = "(415) 666 7777"
zipFollowing = "My number is " + number + ". 34215 is my zip-code."
matcher = PhoneNumberMatcher(zipFollowing, "US")
if matcher.has_next():
matchWithSpaces = matcher.next()
else:
matchWithSpaces = None
self.assertTrue(matchWithSpaces is not None,
msg="Did not find a number in '" + zipFollowing + "'; expected " + number)
self.assertEquals(expectedResult, matchWithSpaces.number)
self.assertEquals(number, matchWithSpaces.raw_string)
def calculate_confidence(cls, data):
"""Calculates a confidence rating for this (possible) equation"""
# We start with 100% confidence, and
# then lower our confidence if needed.
confidence = 100
# lowering confidence if we have a phone number
try:
if len(data) <= 30 and len(data) >= 7:
phonenumberutil.parse(data, _check_region=False)
for _ in [c for c in data if c in string.punctuation]:
confidence -= 10
except NumberParseException:
pass
return confidence
def test_null_field_returns_none(self):
model = NullablePhoneNumber()
self.assertEqual(model.phone_number, None)
model.phone_number = self.test_number_1
self.assertEqual(type(model.phone_number), PhoneNumber)
model.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True)
self.assertEqual(type(model.phone_number), PhoneNumber)
def assertMatchProperties(self, match, text, number, region):
"""Asserts that the expected match is non-null, and that the raw string
and expected proto buffer are set appropriately."""
expectedResult = phonenumberutil.parse(number, region)
self.assertTrue(match is not None,
msg="Did not find a number in '" + text + "'; expected " + number)
self.assertEqual(expectedResult, match.number)
self.assertEqual(number, match.raw_string)
def testBlankMetadata(self):
# Python version extra test
# Some metadata is blank; check that we cope with this.
# Example: MH (+692)
number = phonenumberutil.parse("+6921234567", "US")
self.assertEquals(
"Country Code: 692 National Number: 1234567 Leading Zero: False",
str(number))
def test_null_field_returns_none(self):
model = models.NullablePhoneNumber()
self.assertIsNone(model.phone_number)
model.phone_number = self.test_number_1
self.assertIsInstance(model.phone_number, PhoneNumber)
model.phone_number = phonenumberutil.parse(self.test_number_1,
keep_raw_input=True)
self.assertIsInstance(model.phone_number, PhoneNumber)
def test_null_field_returns_none(self):
model = NullablePhoneNumber()
self.assertEqual(model.phone_number, None)
model.phone_number = '+49 176 96842671'
self.assertEqual(type(model.phone_number), PhoneNumber)
model.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True)
self.assertEqual(type(model.phone_number), PhoneNumber)
def assertMatchProperties(self, match, text, number, region):
"""Asserts that the expected match is non-null, and that the raw string
and expected proto buffer are set appropriately."""
expectedResult = phonenumberutil.parse(number, region)
self.assertTrue(match is not None,
msg="Did not find a number in '" + text + "'; expected " + number)
self.assertEqual(expectedResult, match.number)
self.assertEqual(number, match.raw_string)
def test_can_assign_phonenumber(self):
"""
Tests assignment phonenumberutil.PhoneNumber to field
"""
opt_phone = OptionalPhoneNumber()
opt_phone.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True)
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
def test_null_field_returns_none(self):
model = models.NullablePhoneNumber()
self.assertIsNone(model.phone_number)
model.phone_number = self.test_number_1
self.assertIsInstance(model.phone_number, PhoneNumber)
model.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True
)
self.assertIsInstance(model.phone_number, PhoneNumber)
def test_can_assign_phonenumber(self):
"""
Tests assignment phonenumberutil.PhoneNumber to field
"""
opt_phone = OptionalPhoneNumber()
opt_phone.phone_number = phonenumberutil.parse(self.test_number_1,
keep_raw_input=True)
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
def testMaxMatches(self):
# Set up text with 100 valid phone numbers.
numbers = "My info: 415-666-7777," * 100
# Matches all 100. Max only applies to failed cases.
number = phonenumberutil.parse("+14156667777", None)
expected = [number] * 100
matcher = PhoneNumberMatcher(numbers, "US", Leniency.VALID, 10)
actual = [x.number for x in matcher]
self.assertEquals(expected, actual)
def testMaxMatchesMixed(self):
# Set up text with 100 valid numbers inside an invalid number.
numbers = "My info: 415-666-7777 123 fake street" * 100
# Only matches the first 10 despite there being 100 numbers due to max matches.
number = phonenumberutil.parse("+14156667777", None)
expected = [number] * 10
matcher = PhoneNumberMatcher(numbers, "US", Leniency.VALID, 10)
actual = [x.number for x in matcher]
self.assertEqual(expected, actual)
def testMaxMatches(self):
# Set up text with 100 valid phone numbers.
numbers = "My info: 415-666-7777," * 100
# Matches all 100. Max only applies to failed cases.
number = phonenumberutil.parse("+14156667777", None)
expected = [number] * 100
matcher = PhoneNumberMatcher(numbers, "US", Leniency.VALID, 10)
actual = [x.number for x in matcher]
self.assertEqual(expected, actual)
def testMaxMatchesMixed(self):
# Set up text with 100 valid numbers inside an invalid number.
numbers = "My info: 415-666-7777 123 fake street" * 100
# Only matches the first 10 despite there being 100 numbers due to max matches.
number = phonenumberutil.parse("+14156667777", None)
expected = [number] * 10
matcher = PhoneNumberMatcher(numbers, "US", Leniency.VALID, 10)
actual = [x.number for x in matcher]
self.assertEqual(expected, actual)
def testSmsServiceShortNumbers(self):
wrongTagCounter = 0
for regionCode in shortnumberinfo.SUPPORTED_SHORT_REGIONS:
metadata = PhoneMetadata.short_metadata_for_region(regionCode, None)
desc = metadata.sms_services
if desc is not None and desc.example_number is not None:
exampleNumber = desc.example_number
smsServiceNumber = phonenumberutil.parse(exampleNumber, regionCode)
if (not shortnumberinfo.is_possible_short_number_for_region(smsServiceNumber, regionCode) or
not shortnumberinfo.is_sms_service_for_region(smsServiceNumber, regionCode)):
wrongTagCounter += 1
prnt("SMS service test failed for %s" % regionCode, file=sys.stderr)
self.assertEqual(0, wrongTagCounter)
def testCarrierSpecificShortNumbers(self):
wrongTagCounter = 0
for regionCode in shortnumberinfo.SUPPORTED_SHORT_REGIONS:
metadata = PhoneMetadata.short_metadata_for_region(regionCode, None)
desc = metadata.carrier_specific
if desc is not None and desc.example_number is not None:
exampleNumber = desc.example_number
carrierSpecificNumber = phonenumberutil.parse(exampleNumber, regionCode)
if (not shortnumberinfo.is_possible_short_number_for_region(carrierSpecificNumber, regionCode) or
not shortnumberinfo.is_carrier_specific_for_region(carrierSpecificNumber, regionCode)):
wrongTagCounter += 1
prnt("Carrier-specific test failed for %s" % regionCode, file=sys.stderr)
self.assertEqual(0, wrongTagCounter)
def testShortNumbersValidAndCorrectCost(self):
invalid_string_cases = []
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
exampleShortNumber = shortnumberinfo._example_short_number(regionCode)
phoneNumber = phonenumberutil.parse(exampleShortNumber, regionCode)
if not shortnumberinfo.is_valid_short_number_for_region(phoneNumber, regionCode):
invalid_string_case = "region_code: %s, national_number: %s" % (regionCode, exampleShortNumber)
invalid_string_cases.append(invalid_string_case)
prnt("Failed validation from string %s" % invalid_string_case, file=sys.stderr)
if not shortnumberinfo.is_valid_short_number(phoneNumber):
self.invalid_cases.append(phoneNumber)
prnt("Failed validation for %s" % phoneNumber, file=sys.stderr)
for cost in [ShortNumberCost.TOLL_FREE, ShortNumberCost.STANDARD_RATE,
ShortNumberCost.PREMIUM_RATE, ShortNumberCost.UNKNOWN_COST]:
exampleShortNumber = shortnumberinfo._example_short_number_for_cost(regionCode, cost)
if exampleShortNumber != "":
phoneNumber = phonenumberutil.parse(exampleShortNumber, regionCode)
if cost != shortnumberinfo.expected_cost_for_region(phoneNumber, regionCode):
self.wrong_type_cases.append(phoneNumber)
prnt("Wrong cost for %s" % phoneNumber, file=sys.stderr)
self.assertEqual(0, len(invalid_string_cases))
self.assertEqual(0, len(self.invalid_cases))
self.assertEqual(0, len(self.wrong_type_cases))
def testCarrierSpecificShortNumbers(self):
wrongTagCounter = 0
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
# Test the carrier-specific tag.
metadata = PhoneMetadata.short_metadata_for_region(regionCode, None)
desc = metadata.carrier_specific
if desc.example_number is not None:
exampleNumber = desc.example_number
carrierSpecificNumber = phonenumberutil.parse(exampleNumber, regionCode)
if (not fullmatch(re.compile(desc.possible_number_pattern), exampleNumber) or
not shortnumberinfo.is_carrier_specific(carrierSpecificNumber)):
wrongTagCounter += 1
prnt("Carrier-specific test failed for %s" % regionCode, file=sys.stderr)
# TODO: Test other tags here
self.assertEqual(0, wrongTagCounter)
def test_can_assign_phonenumber(self):
"""
Tests assignment phonenumberutil.PhoneNumber to field
"""
opt_phone = OptionalPhoneNumber()
opt_phone.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True)
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
opt_phone.full_clean()
opt_phone.save()
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
opt_phone_db = OptionalPhoneNumber.objects.get(id=opt_phone.id)
self.assertEqual(type(opt_phone_db.phone_number), PhoneNumber)
self.assertEqual(opt_phone_db.phone_number.as_e164, self.test_number_1)
def test_can_assign_phonenumber(self):
"""
Tests assignment phonenumberutil.PhoneNumber to field
"""
opt_phone = OptionalPhoneNumber()
opt_phone.phone_number = phonenumberutil.parse(
self.test_number_1, keep_raw_input=True)
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
opt_phone.full_clean()
opt_phone.save()
self.assertEqual(type(opt_phone.phone_number), PhoneNumber)
self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
opt_phone_db = OptionalPhoneNumber.objects.get(id=opt_phone.id)
self.assertEqual(type(opt_phone_db.phone_number), PhoneNumber)
self.assertEqual(opt_phone_db.phone_number.as_e164, self.test_number_1)
def testEmergency(self):
wrongTypeCounter = 0
for regionCode in shortnumberinfo.SUPPORTED_SHORT_REGIONS:
metadata = PhoneMetadata.short_metadata_for_region(regionCode, None)
desc = metadata.emergency
if desc is not None and desc.example_number is not None:
exampleNumber = desc.example_number
phoneNumber = phonenumberutil.parse(exampleNumber, regionCode)
if (not is_possible_short_number_for_region(phoneNumber, regionCode) or
not is_emergency_number(exampleNumber, regionCode)):
wrongTypeCounter += 1
prnt("Emergency example number test failed for %s" % regionCode, file=sys.stderr)
elif shortnumberinfo.expected_cost_for_region(phoneNumber, regionCode) != ShortNumberCost.TOLL_FREE:
wrongTypeCounter += 1
prnt("Emergency example number not toll free for %s" % regionCode, file=sys.stderr)
self.assertEqual(0, wrongTypeCounter)
def testCanBeInternationallyDialled(self):
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = None
metadata = PhoneMetadata.region_metadata.get(regionCode, None)
desc = None
if metadata is not None:
desc = metadata.no_international_dialling
try:
if desc.example_number is not None:
exampleNumber = phonenumberutil.parse(desc.example_number, regionCode)
except NumberParseException, e:
print >> sys.stderr, "Failed parse: %s" % e
if (exampleNumber is not None and
phonenumberutil._can_be_internationally_dialled(exampleNumber)):
self.wrong_type_cases.append(exampleNumber)
def testCanBeInternationallyDialled(self):
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = None
metadata = PhoneMetadata.region_metadata.get(regionCode, None)
desc = None
if metadata is not None:
desc = metadata.no_international_dialling
try:
if desc.example_number is not None:
exampleNumber = phonenumberutil.parse(desc.example_number, regionCode)
except NumberParseException, e:
print >> sys.stderr, "Failed parse: %s" % e
if (exampleNumber is not None and
phonenumberutil._can_be_internationally_dialled(exampleNumber)):
self.wrong_type_cases.append(exampleNumber)
def testCarrierSpecificShortNumbers(self):
wrongTagCounter = 0
for regionCode in phonenumberutil.SUPPORTED_SHORT_REGIONS:
# Test the carrier-specific tag.
metadata = PhoneMetadata.short_metadata_for_region(
regionCode, None)
desc = metadata.carrier_specific
if desc.example_number is not None:
exampleNumber = desc.example_number
carrierSpecificNumber = phonenumberutil.parse(
exampleNumber, regionCode)
if (not fullmatch(re.compile(desc.possible_number_pattern),
exampleNumber)
or not shortnumberinfo.is_carrier_specific(
carrierSpecificNumber)):
wrongTagCounter += 1
prnt("Carrier-specific test failed for %s" % regionCode,
file=sys.stderr)
# TODO: Test other tags here
self.assertEqual(0, wrongTagCounter)
def testCanBeInternationallyDialled(self):
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = None
metadata = PhoneMetadata.metadata_for_region(regionCode, None)
desc = None
if metadata is not None:
desc = metadata.no_international_dialling
try:
if desc is not None and desc.example_number is not None:
exampleNumber = phonenumberutil.parse(desc.example_number, regionCode)
except NumberParseException:
_, e, _ = sys.exc_info()
prnt("Failed parse: %s" % e, file=sys.stderr)
if (exampleNumber is not None and
phonenumberutil.can_be_internationally_dialled(exampleNumber)):
self.wrong_type_cases.append(exampleNumber)
prnt("Number %s should not be internationally diallable" % exampleNumber, file=sys.stderr)
self.assertEqual(0, len(self.wrong_type_cases))
def testCanBeInternationallyDialled(self):
for regionCode in phonenumberutil.SUPPORTED_REGIONS:
exampleNumber = None
metadata = PhoneMetadata.metadata_for_region(regionCode, None)
desc = None
if metadata is not None:
desc = metadata.no_international_dialling
try:
if desc.example_number is not None:
exampleNumber = phonenumberutil.parse(desc.example_number, regionCode)
except NumberParseException:
_, e, _ = sys.exc_info()
prnt("Failed parse: %s" % e, file=sys.stderr)
if (exampleNumber is not None and
phonenumberutil._can_be_internationally_dialled(exampleNumber)):
self.wrong_type_cases.append(exampleNumber)
prnt("Number %s should not be internationally diallable" % exampleNumber, file=sys.stderr)
self.assertEqual(0, len(self.wrong_type_cases))
def testBlankMetadata(self):
# Python version extra test
# Some metadata is blank; check that we cope with this.
# Example: MH (+692)
number = phonenumberutil.parse("+6921234567", "US")
self.assertEquals("Country Code: 692 National Number: 1234567 Leading Zero: False", str(number))
def format_us_phone_number(value):
phone = parse(value, 'US')
formatted = format_number(phone, PhoneNumberFormat.E164)
if phone.extension:
formatted += 'x%s' % phone.extension
return formatted
def value_to_string(self, obj):
value = self._get_val_from_obj(obj)
try:
return format_number(parse(value,"US"),PhoneNumberFormat.INTERNATIONAL)
except NumberParseException:
return value
def doTestFindInContext(self, number, defaultCountry):
"""Tests numbers found by PhoneNumberMatcher in various textual contexts"""
self.findPossibleInContext(number, defaultCountry)
parsed = phonenumberutil.parse(number, defaultCountry)
if phonenumberutil.is_valid_number(parsed):
self.findValidInContext(number, defaultCountry)
def test_phonenumber():
p = phonenumberutil.parse(p_loc, 'TW')
i = phonenumberutil.parse(p_int, 'TW')
print phonenumberutil.is_number_match(p, i)
assert_equal(phonenumberutil.MatchType.EXACT_MATCH, phonenumberutil.is_number_match(p, i))
def testBlankMetadata(self):
# Python version extra test
# Some metadata is blank; check that we cope with this.
# Example: MH (+692)
number = phonenumberutil.parse("+6927654321", "US")
self.assertEqual("Country Code: 692 National Number: 7654321", str(number))
def doTestFindInContext(self, number, defaultCountry):
"""Tests numbers found by PhoneNumberMatcher in various textual contexts"""
self.findPossibleInContext(number, defaultCountry)
parsed = phonenumberutil.parse(number, defaultCountry)
if phonenumberutil.is_valid_number(parsed):
self.findValidInContext(number, defaultCountry)
logging.debug('Parsing config files...')
config = ConfigParser.RawConfigParser()
config.read(args['--config'])
api_key = config.get('Password', 'api_key')
api_secret = config.get('Password', 'api_secret')
except Exception, e:
logging.error(traceback.format_exc())
exit(e)
msg = args['MESSAGE']
f_num = args['FROM_NUM']
t_num = args['TO_NUM']
country = args['--country']
if t_num[0] == '+':
logging.debug('Senderid use E164 form, e.g. +886123456...')
from_num = phonenumberutil.format_number(phonenumberutil.parse(f_num, country) \
, phonenumberutil.PhoneNumberFormat.E164).lstrip('+')
logging.debug('Senderid use national form, e.g. 09123456...')
from_num = ''.join(phonenumberutil.format_number(phonenumberutil.parse(f_num, country) \
, phonenumberutil.PhoneNumberFormat.NATIONAL).split())
to_num = phonenumberutil.format_number(phonenumberutil.parse(t_num, country) \
, phonenumberutil.PhoneNumberFormat.E164)
sms = NexmoMessage({
'reqtype': 'json',
'type': 'unicode',
'api_secret': api_secret,
'api_key': api_key,
'from': from_num,
'to': to_num,
'text': msg
def format_us_phone_number(value):
phone = parse(value, 'US')
formatted = format_number(phone, PhoneNumberFormat.E164)
if phone.extension:
formatted += 'x%s' % phone.extension
return formatted
def _clean_phone_for_rows(dataframe, phonenum_field, newField, region_string, region_field, use_orig_on_error, category):
"""
Called by main function to iterate through phone number elements and clean them one by one.
Assumes region values have already been validated as supported region abbreviations.
:param dataframe:
:param phonenum_field:
:param newField:
:param region_string:
:param region_field:
:param use_orig_on_error:
:param category:
:return:
"""
if not dataframe[phonenum_field].index.is_unique:
raise IndexError('indexes/keys in dataframe must be unique per row for this function to work correctly!')
NULL_VALUES = IGNORED_VALUES # null values that will be ignored
# looping through elements because phone num library doesn't allow bulk validation
for idx, value in dataframe[phonenum_field].iteritems():
# for trivial null cases, don't attempt to parse phonenum and just continue to next value
if value in NULL_VALUES:
# in the future, might want to add some logic here to update the other field. For now, don't do anything
pass
else:
# set region to appropriate specified string, or string specified in a specific column-row
if category == 'both_string_and_field':
if dataframe[region_field][idx] not in NULL_VALUES:
region = str(dataframe[region_field][idx])
else:
region = region_string
elif category == 'only_region_field':
if dataframe[region_field][idx] not in NULL_VALUES:
region = str(dataframe[region_field][idx])
else:
region = None
else:
region = region_string
# validate/format phone number, or nullify value as NaN
try:
# parse will raise an exception if value doesn't seem to be a phone number, so need to use a try block
phonenum = phonenumberutil.parse(str(value), region=region, keep_raw_input=False,
numobj=None, _check_region=True)
# update with validated, formatted phone number, or nullify as NaN
if phonenumberutil.is_valid_number_for_region(phonenum, region):
_update_element(dataframe=dataframe, phonenum_field=phonenum_field, newField=newField,
index=idx, replacement_value=phonenum.national_number)
else:
_update_element(dataframe=dataframe, phonenum_field=phonenum_field, newField=newField,
index=idx, replacement_value=np.nan)
except:
# update value as NaN or paste original value
if use_orig_on_error:
_update_element(dataframe=dataframe, phonenum_field=phonenum_field, newField=newField,
index=idx, replacement_value=dataframe[phonenum_field][idx])
else:
_update_element(dataframe=dataframe, phonenum_field=phonenum_field, newField=newField,
index=idx, replacement_value=np.nan)