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()],

"""Helper initialiser method to create the regular-expression pattern to

# There are three regular expressions here. The first covers RFC 3966

# format, where the extension is added using ";ext=". The second more

# generic one starts with optional white space and ends with an optional

# full stop (.), followed by zero or more spaces/tabs and then the numbers

# themselves. The other one covers the special case of American numbers

# where the extension is written with a hash at the end, such as "- 503#".

# Note that the only capturing groups should be around the digits that you

# want to capture as part of the extension, or else parsing will fail!

# Canonical-equivalence doesn't seem to be an option with Android java, so

# we allow two options for representing the accented o - the character

# itself, and one in the unicode decomposed form with the combining acute

# accent.

return (_RFC3966_EXTN_PREFIX + _CAPTURING_EXTN_DIGITS + u("|") +

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

u("\uFF45?\uFF58\uFF54\uFF4E?|") +

u("[") + single_extn_symbols + u("]|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

# Used for "Voice Mail Access Numbers".

VOICEMAIL = 10

# 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 = unicod(number)

number_length = len(number)

normalized_digits = U_EMPTY_STRING

for ii in range(number_length):

d = unicode_digit(number[ii], -1)

if d != -1:

normalized_digits += unicod(d)

elif keep_non_digits:

normalized_digits += number[ii]

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

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

metadata = PhoneMetadata.metadata_for_region(region_code_for_number(numobj), None)

if metadata is None:

return 0

# If a country doesn't use a national prefix, and this number doesn't have

# an Italian leading zero, we assume it is a closed dialling plan with no

# area codes.

if metadata.national_prefix is None and not numobj.italian_leading_zero:

return 0

if not _is_number_geographical(numobj):

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 number_type(numobj) == PhoneNumberType.MOBILE:

# For example 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 the

# length of the second group (which is the mobile token), which also

# forms part of the national significant number. This assumes that

# the mobile token is always formatted separately from the rest of the

# phone number.

mobile_token = country_mobile_token(numobj.country_code)

if mobile_token != U_EMPTY_STRING:

return len(number_groups[2]) + len(number_groups[3])

"""Returns the mobile token for the provided country calling code if it has one, otherwise

"""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 if the national prefix formatting rule has the

if national_prefix_formatting_rule is None:

return True

return bool(fullmatch(_FIRST_GROUP_ONLY_PREFIX_PATTERN,

num_type = number_type(numobj)

# TODO: Include mobile phone numbers from countries like Indonesia, which

# has some mobile numbers that are geographical.

return (num_type == PhoneNumberType.FIXED_LINE or

"""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.

if numobj.national_number == 0 and numobj.raw_input is not None:

# Unparseable numbers that kept their raw input just use that. This

# is the only case where a number can be formatted as E164 without a

# leading '+' symbol (but the original number wasn't parseable

# anyway).

# TODO: Consider removing the 'if' above so that unparseable strings

# without raw input format to the empty string instead of "+00"

if len(numobj.raw_input) > 0:

return numobj.raw_input

country_calling_code = numobj.country_code

nsn = national_significant_number(numobj)

if num_format == PhoneNumberFormat.E164:

# Early exit for E164 case (even if the country calling code is

# invalid) since no formatting of the national number needs to be

# applied. Extensions are not formatted.

return _prefix_number_with_country_calling_code(country_calling_code, num_format, nsn)

if not _has_valid_country_calling_code(country_calling_code):

return 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)

# Metadata cannot be None because the country calling code is valid (which

# means that the region code cannot be ZZ and must be one of our supported

# region codes).

metadata = PhoneMetadata.metadata_for_region_or_calling_code(country_calling_code, region_code.upper())

formatted_number = _format_nsn(nsn, metadata, num_format)

formatted_number = _maybe_append_formatted_extension(numobj,

metadata,

num_format,

formatted_number)

return _prefix_number_with_country_calling_code(country_calling_code,

num_format,

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

country_code = numobj.country_code

nsn = national_significant_number(numobj)

if not _has_valid_country_calling_code(country_code):

return 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_code)

# Metadata cannot be None because the country calling code is valid

metadata = PhoneMetadata.metadata_for_region_or_calling_code(country_code, region_code)

formatted_number = U_EMPTY_STRING

formatting_pattern = choose_formatting_pattern_for_number(user_defined_formats, nsn)

if formatting_pattern is None:

# If no pattern above is matched, we format the number as a whole.

formatted_number = nsn

else:

num_format_copy = NumberFormat()

num_format_copy._mutable = True

# 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.

num_format_copy.merge_from(formatting_pattern)

np_formatting_rule = formatting_pattern.national_prefix_formatting_rule

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

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,

unicod("\\\\1"),

np_formatting_rule,

count=1)

num_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.

num_format_copy.national_prefix_formatting_rule = None

formatted_number = format_nsn_using_pattern(nsn, num_format_copy, number_format)

formatted_number = _maybe_append_formatted_extension(numobj,

metadata,

number_format,

formatted_number)

formatted_number = _prefix_number_with_country_calling_code(country_code,

number_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)

if not _has_valid_country_calling_code(country_code):

return 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_code)

# Metadata cannot be None because the country calling code is valid

metadata = PhoneMetadata.metadata_for_region_or_calling_code(country_code, region_code)

formatted_number = _format_nsn(nsn,

metadata,

PhoneNumberFormat.NATIONAL,

carrier_code)

formatted_number = _maybe_append_formatted_extension(numobj,

metadata,

PhoneNumberFormat.NATIONAL,

formatted_number)

formatted_number = _prefix_number_with_country_calling_code(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

"""Returns a number formatted in such a way that it can be dialed from a

country_calling_code = numobj.country_code

if not _has_valid_country_calling_code(country_calling_code):

if numobj.raw_input is None:

return U_EMPTY_STRING

else:

return numobj.raw_input

formatted_number = U_EMPTY_STRING

# Clear the extension, as that part cannot normally be dialed together with the main number.

numobj_no_ext = PhoneNumber()

numobj_no_ext.merge_from(numobj)

numobj_no_ext.extension = None

region_code = region_code_for_country_code(country_calling_code)

numobj_type = number_type(numobj_no_ext)

is_valid_number = (numobj_type != PhoneNumberType.UNKNOWN)

if region_calling_from == region_code:

is_fixed_line_or_mobile = ((numobj_type == PhoneNumberType.FIXED_LINE) or

(numobj_type == PhoneNumberType.MOBILE) or

(numobj_type == PhoneNumberType.FIXED_LINE_OR_MOBILE))

# Carrier codes may be needed in some countries. We handle this here.

if region_code == "CO" and numobj_type == PhoneNumberType.FIXED_LINE:

formatted_number = format_national_number_with_carrier_code(numobj_no_ext,

_COLOMBIA_MOBILE_TO_FIXED_LINE_PREFIX)

elif region_code == "BR" and is_fixed_line_or_mobile:

if numobj_no_ext.preferred_domestic_carrier_code is not None:

formatted_number = format_national_number_with_preferred_carrier_code(numobj_no_ext, "")

else:

# Brazilian fixed line and mobile numbers need to be dialed with a

# carrier code when called within Brazil. Without that, most of

# the carriers won't connect the call. Because of that, we return

# an empty string here.

formatted_number = U_EMPTY_STRING

elif is_valid_number and region_code == "HU":

# The national format for HU numbers doesn't contain the national

# prefix, because that is how numbers are normally written

# down. However, the national prefix is obligatory when dialing

# from a mobile phone, except for short numbers. As a result, we

# add it back here if it is a valid regular length phone number.

formatted_number = (ndd_prefix_for_region(region_code, True) + # strip non-digits

U_SPACE + format_number(numobj_no_ext, PhoneNumberFormat.NATIONAL))

elif country_calling_code == _NANPA_COUNTRY_CODE: