u'2': u'2', u'3': u'3',

u'4': u'4', u'5': u'5',

u'6': u'6', u'7': u'7',

u'B': u'2',

u'C': u'2',

u'D': u'3',

u'E': u'3',

u'F': u'3',

u'G': u'4',

u'H': u'4',

u'I': u'4',

u'J': u'5',

u'K': u'5',

u'L': u'5',

u'M': u'6',

u'N': u'6',

u'O': u'6',

u'P': u'7',

u'Q': u'7',

u'R': u'7',

u'S': u'7',

u'T': u'8',

u'U': u'8',

u'V': u'8',

u'W': u'9',

u'X': u'9',

u'Y': u'9',

u'\uFF0D': u'-',

u'\u2010': u'-',

u'\u2011': u'-',

u'\u2012': u'-',

u'\u2013': u'-',

u'\u2014': u'-',

u'\u2015': u'-',

u'\u2212': u'-',

u'/': u'/',

u'\uFF0F': u'/',

u' ': u' ',

u'\u3000': u' ',

u'\u2060': u' ',

u'.': u'.',

u'\uFF0E': u'.'},

# Put (lower letter -> upper letter) and

# (upper letter -> upper letter) mappings.

**dict([(_c.lower(), _c) for _c in _ALPHA_MAPPINGS.keys()] +

[(_c, _c) for _c in _ALPHA_MAPPINGS.keys()],

u"[ \u00A0\\t,]*(?:ext(?:ensi(?:o\u0301?|\u00F3))?n?|" +

u"\uFF45\uFF58\uFF54\uFF4E?|[,x\uFF58#\uFF03~\uFF5E]|int|anexo|\uFF49\uFF4E\uFF54)" +

u"[:\\.\uFF0E]?[ \u00A0\\t,-]*" + _CAPTURING_EXTN_DIGITS + u"#?|" +

"""

E164 = 0

INTERNATIONAL = 1

NATIONAL = 2

"""Type of phone numbers."""

FIXED_LINE = 0

MOBILE = 1

# In some regions (e.g. the USA), it is impossible to distinguish between

# fixed-line and mobile numbers by looking at the phone number itself.

FIXED_LINE_OR_MOBILE = 2

# Freephone lines

TOLL_FREE = 3

PREMIUM_RATE = 4

# The cost of this call is shared between the caller and the recipient,

# and is hence typically less than PREMIUM_RATE calls. See

# http://en.wikipedia.org/wiki/Shared_Cost_Service for more information.

SHARED_COST = 5

# Voice over IP numbers. This includes TSoIP (Telephony Service over IP).

VOIP = 6

# A personal number is associated with a particular person, and may be

# routed to either a MOBILE or FIXED_LINE number. Some more information

# can be found here: http://en.wikipedia.org/wiki/Personal_Numbers

PERSONAL_NUMBER = 7

PAGER = 8

# Used for "Universal Access Numbers" or "Company Numbers". They may be

# further routed to specific offices, but allow one number to be used for

# a company.

UAN = 9

# A phone number is of type UNKNOWN when it does not fit any of the known

# patterns for a specific region.

"""Types of phone number matches."""

# Not a telephone number

NOT_A_NUMBER = 0

# None of the match types below apply

NO_MATCH = 1

# Returns SHORT_NSN_MATCH if either or both has no region specified, or

# the region specified is the same, and one NSN could be a shorter version

# of the other number. This includes the case where one has an extension

# specified, and the other does not.

SHORT_NSN_MATCH = 2

# Either or both has no region specified, and the NSNs and extensions are

# the same.

NSN_MATCH = 3

# The country_code, NSN, presence of a leading zero for Italian numbers

# and any extension present are the same.

"""Possible outcomes when testing if a PhoneNumber is a possible number."""

IS_POSSIBLE = 0

INVALID_COUNTRY_CODE = 1

TOO_SHORT = 2

"""Attempt to extract a possible number from the string passed in.

match = _VALID_START_CHAR_PATTERN.search(number)

if match:

number = number[match.start():]

# Remove trailing non-alpha non-numberical characters.

trailing_chars_match = _UNWANTED_END_CHAR_PATTERN.search(number)

if trailing_chars_match:

number = number[:trailing_chars_match.start()]

# Check for extra numbers at the end.

second_number_match = _SECOND_NUMBER_START_PATTERN.search(number)

if second_number_match:

number = number[:second_number_match.start()]

return number

else:

"""Checks to see if a string could possibly be a phone number.

if len(number) < _MIN_LENGTH_FOR_NSN:

return False

match = fullmatch(_VALID_PHONE_NUMBER_PATTERN, number)

"""Normalizes a string of characters representing a phone number.

m = fullmatch(_VALID_ALPHA_PHONE_PATTERN, number)

if m:

return _normalize_helper(number, _ALPHA_PHONE_MAPPINGS, True)

else:

"""Normalizes a string of characters representing a phone number.

number = unicode(number)

number_length = len(number)

normalized_digits = u""

for ii in xrange(number_length):

d = unicode_util.digit(number[ii], -1)

if d != -1:

normalized_digits += unicode(d)

"""Return length of the geographical area code for a number.

region_code = region_code_for_number(numobj)

if not _is_valid_region_code(region_code):

return 0

metadata = PhoneMetadata.region_metadata[region_code]

if metadata.national_prefix is None:

return 0

pn_type = _number_type_helper(national_significant_number(numobj),

metadata)

# Most numbers other than the two types below have to be dialled in full.

if (pn_type != PhoneNumberType.FIXED_LINE and

pn_type != PhoneNumberType.FIXED_LINE_OR_MOBILE):

return 0

"""Return length of the national destination code code for a number.

if numobj.extension is not None:

# We don't want to alter the object given to us, but we don't want to

# include the extension when we format it, so we copy it and clear the

# extension here.

copied_numobj = PhoneNumber()

copied_numobj.merge_from(numobj)

copied_numobj.extension = None

else:

copied_numobj = numobj

nsn = format_number(copied_numobj, PhoneNumberFormat.INTERNATIONAL)

number_groups = re.split(_NON_DIGITS_PATTERN, nsn)

# The pattern will start with "+COUNTRY_CODE " so the first group will

# always be the empty string (before the + symbol) and the second group

# will be the country calling code. The third group will be area code if

# it is not the last group.

if len(number_groups) <= 3:

return 0

if (region_code_for_number(numobj) == "AR" and

number_type(numobj) == PhoneNumberType.MOBILE):

# Argentinian mobile numbers, when formatted in the international

# format, are in the form of +54 9 NDC XXXX... As a result, we take the

# length of the third group (NDC) and add 1 for the digit 9, which also

# forms part of the national significant number.

#

# TODO: Investigate the possibility of better modeling the metadata to

# make it easier to obtain the NDC.

return len(number_groups[3]) + 1

"""Normalizes a string of characters representing a phone number by

normalized_number = []

for char in number:

new_digit = replacements.get(char.upper(), None)

if new_digit is not None:

normalized_number.append(new_digit)

elif not remove_non_matches:

normalized_number.append(char)

# If neither of the above are true, we remove this character

"""Helper function to check region code is not unknown or None"""

if region_code is None:

return False

"""Formats a phone number in the specified format using default rules.

country_calling_code = numobj.country_code

nsn = national_significant_number(numobj)

if num_format == PhoneNumberFormat.E164:

# Early exit for E164 case since no formatting of the national number needs to be applied.

# Extensions are not formatted.

return _format_number_by_format(country_calling_code, num_format, nsn)

# Note region_code_for_country_code() is used because formatting

# information for regions which share a country calling code is contained

# by only one region for performance reasons. For example, for NANPA

# regions it will be contained in the metadata for US.

region_code = region_code_for_country_code(country_calling_code)

if not _is_valid_region_code(region_code):

return nsn

formatted_number = _format_national_number(nsn, region_code, num_format)

formatted_number = _maybe_get_formatted_extension(numobj,

region_code,

num_format,

formatted_number)

return _format_number_by_format(country_calling_code,

num_format,

"""Formats a phone number using client-defined formatting rules."

country_code = numobj.country_code

nsn = national_significant_number(numobj)

# Note region_code_for_country_code() is used because formatting

# information for regions which share a country calling code is contained

# by only one region for performance reasons. For example, for NANPA

# regions it will be contained in the metadata for US.

region_code = region_code_for_country_code(country_code)

if not _is_valid_region_code(region_code):

return nsn

user_defined_formats_copy = []

for this_format in user_defined_formats:

np_formatting_rule = this_format.national_prefix_formatting_rule

if (np_formatting_rule is not None and len(np_formatting_rule) > 0):

# Before we do a replacement of the national prefix pattern $NP

# with the national prefix, we need to copy the rule so that

# subsequent replacements for different numbers have the

# appropriate national prefix.

this_format_copy = NumberFormat()

this_format_copy.merge_from(this_format)

metadata = PhoneMetadata.region_metadata[region_code]

national_prefix = metadata.national_prefix

if (national_prefix is not None and len(national_prefix) > 0):

# Replace $NP with national prefix and $FG with the first

# group (\1) matcher.

np_formatting_rule = re.sub(_NP_PATTERN,

national_prefix,

np_formatting_rule,

count=1)

np_formatting_rule = re.sub(_FG_PATTERN,

u"\\\\1",

np_formatting_rule,

count=1)

this_format_copy.national_prefix_formatting_rule = np_formatting_rule

else:

# We don't want to have a rule for how to format the national

# prefix if there isn't one.

this_format_copy.national_prefix_formatting_rule = None

user_defined_formats_copy.append(this_format_copy)

else:

# Otherwise, we just add the original rule to the modified list of

# formats.

user_defined_formats_copy.append(this_format)

formatted_number = _format_according_to_formats(nsn,

user_defined_formats_copy,

num_format)

formatted_number = _maybe_get_formatted_extension(numobj,

region_code,

num_format,

formatted_number)

formatted_number = _format_number_by_format(country_code,

num_format,

formatted_number)

"""Format a number in national format for dialing using the specified carrier.

country_code = numobj.country_code

nsn = national_significant_number(numobj)

# Note region_code_for_country_code() is used because formatting

# information for regions which share a country calling code is contained

# by only one region for performance reasons. For example, for NANPA

# regions it will be contained in the metadata for US.

region_code = region_code_for_country_code(country_code)

if not _is_valid_region_code(region_code):

return nsn

formatted_number = _format_national_number(nsn,

region_code,

PhoneNumberFormat.NATIONAL,

carrier_code)

formatted_number = _maybe_get_formatted_extension(numobj,

region_code,

PhoneNumberFormat.NATIONAL,

formatted_number)

formatted_number = _format_number_by_format(country_code,

PhoneNumberFormat.NATIONAL,

formatted_number)

"""Formats a phone number in national format for dialing using the carrier

if numobj.preferred_domestic_carrier_code is not None:

carrier_code = numobj.preferred_domestic_carrier_code

else:

carrier_code = fallback_carrier_code

"""Formats a phone number for out-of-country dialing purposes.

if not _is_valid_region_code(region_calling_from):

return format_number(numobj, PhoneNumberFormat.INTERNATIONAL)

country_code = numobj.country_code

region_code = region_code_for_country_code(country_code)

nsn = national_significant_number(numobj)

if not _is_valid_region_code(region_code):

return nsn

if country_code == _NANPA_COUNTRY_CODE:

if is_nanpa_country(region_calling_from):

# For NANPA regions, return the national format for these regions

# but prefix it with the country calling code.

return (unicode(country_code) + u" " +

format_number(numobj, PhoneNumberFormat.NATIONAL))

elif country_code == country_code_for_region(region_calling_from):

# For regions that share a country calling code, the country calling

# code need not be dialled. This also applies when dialling within a

# region, so this if clause covers both these cases. Technically this

# is the case for dialling from La Reunion to other overseas

# departments of France (French Guiana, Martinique, Guadeloupe), but

# not vice versa - so we don't cover this edge case for now and for

# those cases return the version including country calling code.

# Details here:

# http://www.petitfute.com/voyage/225-info-pratiques-reunion

return format_number(numobj, PhoneNumberFormat.NATIONAL)

formatted_national_number = _format_national_number(nsn,

region_code,

PhoneNumberFormat.INTERNATIONAL)

metadata = PhoneMetadata.region_metadata[region_calling_from.upper()]

international_prefix = metadata.international_prefix

# For regions that have multiple international prefixes, the international

# format of the number is returned, unless there is a preferred

# international prefix.

i18n_prefix_for_formatting = u""

i18n_match = fullmatch(_UNIQUE_INTERNATIONAL_PREFIX, international_prefix)

if i18n_match:

i18n_prefix_for_formatting = international_prefix

elif metadata.preferred_international_prefix is not None:

i18n_prefix_for_formatting = metadata.preferred_international_prefix

formatted_number = _maybe_get_formatted_extension(numobj,

region_code,

PhoneNumberFormat.INTERNATIONAL,

formatted_national_number)

if len(i18n_prefix_for_formatting) > 0:

formatted_number = (i18n_prefix_for_formatting + u" " +

unicode(country_code) + u" " + formatted_number)

else:

formatted_number = _format_number_by_format(country_code,

PhoneNumberFormat.INTERNATIONAL,

formatted_number)

"""Format a number using the original format that the number was parsed from.

if numobj.country_code_source is None:

return format_number(numobj, PhoneNumberFormat.NATIONAL)

if (numobj.country_code_source ==

CountryCodeSource.FROM_NUMBER_WITH_PLUS_SIGN):

return format_number(numobj, PhoneNumberFormat.INTERNATIONAL)

elif numobj.country_code_source == CountryCodeSource.FROM_NUMBER_WITH_IDD:

return format_out_of_country_calling_number(numobj, region_calling_from)

elif (numobj.country_code_source ==

CountryCodeSource.FROM_NUMBER_WITHOUT_PLUS_SIGN):

return format_number(numobj, PhoneNumberFormat.INTERNATIONAL)[1:]

else:

"""Formats a phone number for out-of-country dialing purposes.

raw_input = numobj.raw_input

# If there is no raw input, then we can't keep alpha characters because there aren't any.

# In this case, we return format_out_of_country_calling_number.

if raw_input is None or len(raw_input) == 0:

return format_out_of_country_calling_number(numobj, region_calling_from)

country_code = numobj.country_code

region_code = region_code_for_country_code(country_code)

if not _is_valid_region_code(region_code):

return raw_input

# Strip any prefix such as country calling code, IDD, that was present. We

# do this by comparing the number in raw_input with the parsed number. To

# do this, first we normalize punctuation. We retain number grouping

# symbols such as " " only.

raw_input = _normalize_helper(raw_input,

_ALL_PLUS_NUMBER_GROUPING_SYMBOLS,

True)

# Now we trim everything before the first three digits in the parsed

# number. We choose three because all valid alpha numbers have 3 digits at

# the start - if it does not, then we don't trim anything at

# all. Similarly, if the national number was less than three digits, we

# don't trim anything at all.

national_number = national_significant_number(numobj)

if len(national_number) > 3:

first_national_number_digit = raw_input.find(national_number[:3])

if first_national_number_digit != -1:

raw_input = raw_input[first_national_number_digit:]

metadata = PhoneMetadata.region_metadata.get(region_calling_from.upper(), None)

if country_code == _NANPA_COUNTRY_CODE:

if is_nanpa_country(region_calling_from):

return unicode(country_code) + u" " + raw_input

elif country_code == country_code_for_region(region_calling_from):

# Here we copy the formatting rules so we can modify the pattern we

# expect to match against.

available_formats = []

for this_format in metadata.number_format:

new_format = NumberFormat()

new_format.merge_from(this_format)

# The first group is the first group of digits that the user

# determined.

new_format.pattern = u"(\\d+)(.*)"

# Here we just concatenate them back together after the national

# prefix has been fixed.

new_format.format = ur"\1\2"

available_formats.append(new_format)

# Now we format using these patterns instead of the default pattern,

# but with the national prefix prefixed if necessary, by choosing the

# format rule based on the leading digits present in the unformatted

# national number. This will not work in the cases where the pattern

# (and not the leading digits) decide whether a national prefix needs

# to be used, since we have overridden the pattern to match anything,