def testGetDescriptionForFixedLineNumber(self):
self.assertEqual("", name_for_number(AO_FIXED1, _ENGLISH))
self.assertEqual("", name_for_number(UK_FIXED1, _ENGLISH))
# If the carrier information is present in the files and the method
# that assumes a valid number is used, a carrier is returned.
self.assertEqual("Angolan fixed line carrier", name_for_valid_number(AO_FIXED2, _ENGLISH))
self.assertEqual("", name_for_valid_number(UK_FIXED2, _ENGLISH))
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 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 validate_phone_number(number):
obj = phonenumbers.parse(number, "UG")
if not phonenumbers.is_valid_number(obj):
raise ValidationError("Invalid Phone number {0}".format(number))
if (carrier.name_for_number(obj, "en") !=
"MTN") or (carrier.name_for_number(obj, "en") != "Airtel"):
raise ValidationError(
"{0}: Only MTN | Airtel is supported at the moment".format(number))
return "256{0}".format(obj.national_number)
def testGetDescriptionForMobilePortableRegion(self):
self.assertEqual("British carrier",
name_for_number(UK_MOBILE1, _ENGLISH))
self.assertEqual(u"Brittisk operat\u00F6r",
name_for_number(UK_MOBILE1, "sv", region="SE"))
self.assertEqual("British carrier",
name_for_number(UK_MOBILE1, _FRENCH))
# Returns an empty string because the UK implements mobile number portability.
self.assertEqual("", safe_display_name(UK_MOBILE1, _ENGLISH))
def testGetDescriptionForNumberWithNoDataFile(self):
self.assertEqual(
"", name_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH))
self.assertEqual("", name_for_number(INTERNATIONAL_TOLL_FREE,
_ENGLISH))
self.assertEqual(
"",
name_for_valid_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH))
self.assertEqual(
"", name_for_valid_number(INTERNATIONAL_TOLL_FREE, _ENGLISH))
def numberScan():
global phoneNumberGET, phoneNumber, numberNSCAN, numberCC, numberC, numberLOCAL, numberINTER, countryNSCAN, locationNSCAN, carrierNameNSCAN
phoneNumberGET = numberSCANentryVar.get()
#GET INFORMATIONS - PHONE NUMBER SCANNER FRAME
phoneNumber = phonenumbers.parse(phoneNumberGET, None)
numberNSCAN = phonenumbers.format_number(
phoneNumber, phonenumbers.PhoneNumberFormat.E164).replace('+', '')
numberCC = phonenumbers.format_number(
phoneNumber,
phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(' ')[0]
numberC = phonenumbers.region_code_for_country_code(int(numberCC))
numberLOCAL = phonenumbers.format_number(
phoneNumber,
phonenumbers.PhoneNumberFormat.E164).replace(numberCC, '')
numberINTER = phonenumbers.format_number(
phoneNumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
countryNSCAN = geocoder.country_name_for_number(phoneNumber, 'en')
locationNSCAN = geocoder.description_for_number(phoneNumber, 'en')
carrierNameNSCAN = carrier.name_for_number(phoneNumber, 'en')
#APPLY RESULTS - PHONE NUMBER SCANNER FRAME
numberReset()
numberSCANentryVar.set(phoneNumberGET)
localNSCANentryVar.set(numberLOCAL)
interNSCANentryVar.set(numberINTER)
countryNSCANentryVar.set("{} ({})".format(countryNSCAN, numberCC))
areaNSCANentryVar.set(locationNSCAN)
carrierNSCANentryVar.set(carrierNameNSCAN)
for timezoneResult in timezone.time_zones_for_number(phoneNumber):
timezoneNSCANentryVar.set(timezoneResult)
if phonenumbers.is_possible_number(phoneNumber):
validNSCANentryVar.set("VALID+POSSIBLE")
else:
validNSCANentryVar.set("INVALID")
def localScan(InputNumber, print_results=True):
print("Running local scan...")
FormattedPhoneNumber = "+" + formatNumber(InputNumber)
try:
PhoneNumberObject = phonenumbers.parse(FormattedPhoneNumber, None)
except Exception as e:
print(e)
else:
if not phonenumbers.is_valid_number(PhoneNumberObject):
return False
number = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164
).replace("+", "")
numberCountryCode = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.INTERNATIONAL
).split(" ")[0]
numberCountry = phonenumbers.region_code_for_country_code(
int(numberCountryCode)
)
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164
).replace(numberCountryCode, "")
internationalNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.INTERNATIONAL
)
country = geocoder.country_name_for_number(PhoneNumberObject, "en")
location = geocoder.description_for_number(PhoneNumberObject, "en")
carrierName = carrier.name_for_number(PhoneNumberObject, "en")
if print_results:
print("International format: {}".format(internationalNumber))
print("Local format: {}".format(localNumber))
print("Country found: {} ({})".format(country, numberCountryCode))
print("City/Area: {}".format(location))
print("Carrier: {}".format(carrierName))
for timezoneResult in timezone.time_zones_for_number(PhoneNumberObject):
print("Timezone: {}".format(timezoneResult))
if phonenumbers.is_possible_number(PhoneNumberObject):
print("The number is valid and possible.")
else:
print("The number is valid but might not be possible.")
numberObj = {}
numberObj["input"] = InputNumber
numberObj["default"] = number
numberObj["local"] = localNumber
numberObj["international"] = internationalNumber
numberObj["country"] = country
numberObj["countryCode"] = numberCountryCode
numberObj["countryIsoCode"] = numberCountry
numberObj["location"] = location
numberObj["carrier"] = carrierName
return numberObj
def get(self):
res = dict()
phoneNumber = self.request.get("number")
country = str(self.request.get("country"))
if phoneNumber != '' and country != '':
try:
info = phonenumbers.parse(phoneNumber, country.upper())
res['country_code'] = '+' + str(info.country_code)
res['carrier'] = carrier.name_for_number(info, "en")
res['is_valid'] = phonenumbers.is_valid_number(info)
res['is_possible'] = phonenumbers.is_possible_number(info)
formats = dict()
formats['national'] = phonenumbers.format_number(
info, phonenumbers.PhoneNumberFormat.NATIONAL)
formats['international'] = phonenumbers.format_number(
info, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
formats['e164'] = phonenumbers.format_number(
info, phonenumbers.PhoneNumberFormat.E164)
res['formats'] = formats
except:
res['message'] = 'error'
self.response.headers.add_header("Access-Control-Allow-Origin",
"*")
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(res))
else:
self.set_status(404)
def number_phone_function():
print(" ")
print("ATTENTION DONT FORGET => +48... <= OR SOMETHING LIKE THAT...")
y = input("write phonenumber => ")
x = phonenumbers.parse(y, None)
print(x)
x2 = phonenumbers.is_possible_number(x)
print("is possible number? =>", x2)
x3 = phonenumbers.is_valid_number(x)
print("is valid number? =>", x3)
#country..
print("from where is use the number? =>",
geocoder.description_for_number(x, 'pl'))
#services..
print("services of phonenumber? =>", carrier.name_for_number(x, 'pl'))
#timezone..
print("timezone =>", timezone.time_zones_for_number(x))
print(" ")
def get(self, number):
code = 0
message = 'success'
data = {'number': number, 'isValid': None}
try:
if not number.startswith("+"):
number = "+" + number
logger.info('valid number:{0}'.format(number))
x = phonenumbers.parse(number, None)
data['countryCode'] = x.country_code
data['nationalNumber'] = x.national_number
# a = phonenumbers.is_possible_number(x)
# 验证是否是可用的
b = phonenumbers.is_valid_number(x)
data['isValid'] = b
# 本国格式化
rx = phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.NATIONAL)
data['nationalFormat'] = rx
# 国际格式化
rx = phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
data['internationalFormat'] = rx
# 地区
c = geocoder.description_for_number(x, "en")
data['region'] = c
# 运营商
d = carrier.name_for_number(x, "en")
data['carrier'] = d
logger.info('valid result:{0}'.format(data))
except Exception as err:
logger.error(err, exc_info=True)
code = 1000
message = 'valid fail'
return {'code': code, 'message': message, 'data': data}
def textmsg(phonenumber, msg, countrycode):
number = phonenumbers.parse(phonenumber, countrycode)
if carrier.name_for_number(number, 'en') != '':
message = client.messages.create(body=msg, to=phonenumber, from_="+13177933648")
pprint(message.sid)
return True
else: return False
def phone():
os.system('figlet phone number')
print(colored('================================', 'cyan'))
# Parsing String to Phone number
a = str(input(colored('enter number: ', 'green')))
print(
colored(
'''=======================
[ TIME ZONE ]
======================= ''', 'green'))
phoneNumber = phonenumbers.parse(a)
# Pass the parsed phone number in below function
timeZone = timezone.time_zones_for_number(phoneNumber)
time.sleep(1)
# It print the timezone of a phonenumber
print(colored(timeZone, 'yellow'))
print(
colored(
'''=======================
[ NETWORK ]
======================= ''', 'green'))
ro_number = phonenumbers.parse(a, "RO")
time.sleep(1)
print(colored(carrier.name_for_number(ro_number, "en"), 'yellow'))
print(
colored(
'''=======================
[ GEOLOCATION ]
======================= ''', 'green'))
ch_number = phonenumbers.parse(a, "CH")
time.sleep(1)
print(colored(geocoder.description_for_number(ch_number, "en"), 'yellow'))
def onchange_mobile(self, cr, uid, ids, mobile, context=None):
value = {}
warning = {}
if mobile:
id_number = phonenumbers.parse(mobile, "ID")
if not carrier._is_mobile(number_type(id_number)):
warning = {
'title': ('Perhatian !'),
'message':
(('Masukkan nomor handphone dengan benar, misal: 0817989800'
)),
}
value['mobile'] = ''
else:
formatted_mobile = phonenumbers.format_number(
id_number, phonenumbers.PhoneNumberFormat.E164)
provider_mobile = eval(
repr(carrier.name_for_number(id_number, "en")))
value['mobile'] = formatted_mobile
value['mobile_provider'] = provider_mobile
return {
'warning': warning,
'value': value,
}
def number_check(Phone_number):
number = phonenumbers.parse(Phone_number)
description = geocoder.description_for_number(number, "en")
supplier = carrier.name_for_number(number, "en")
info = [["country", "supplier"], [description, supplier]]
return tabulate(info, headers="firstrow", tablefmt="github")
def simple_scan(self, working=True):
# function to get the basic info about a number (phonenumbers module)
phone = phonenumbers.parse(self.phonenumber)
if not phonenumbers.is_valid_number(phone):
return False
if phonenumbers.is_possible_number(phone):
print(f"{b}{plus} The number is valid and possible.")
else:
print(f"{b}{warn} The number is valid but not possible.")
international = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
countrycode = phonenumbers.format_number(
phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(" ")[0]
country = geocoder.country_name_for_number(phone, 'en')
location = geocoder.description_for_number(phone, 'en')
carrierr = carrier.name_for_number(phone, 'en')
# ------------------------------------------------------------------------
if working:
print(f'{b}{plus} International Format : {international}')
print(
f'{b}{plus} Country name : {country} ({countrycode})')
print(f'{b}{plus} City/Province : {location}')
print(f'{b}{plus} Carrier : {carrierr}')
for time in timezone.time_zones_for_number(phone):
print(f'{b}{plus} Timezone : {time}')
def number_scan(phone):
number = phonenumbers.parse(phone)
des = geocoder.descriptiong_for_number(number, 'en')
sup = carrier.name_for_number(number, 'en')
info = [['Country', 'Supplier']], [des, sup]
data = str(tabulate(info, headers='firstrow', tablefmt='github'))
return data
def formatNumber(number):
'''
number 必须是带区号的
'''
code = 0
message = 'success'
data = {'number': number, 'isValid': None}
print "number:", number
x = phonenumbers.parse(number, None)
print x
data['countryCode'] = x.country_code
data['nationalNumber'] = x.national_number
# a = phonenumbers.is_possible_number(x)
# 验证是否是可用的
b = phonenumbers.is_valid_number(x)
print b
data['isValid'] = b
# 格式化
rx = phonenumbers.format_number(
x, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print rx
data['format'] = rx
# 地区
c = geocoder.description_for_number(x, "en")
print c
data['region'] = c
#运营商
d = carrier.name_for_number(x, "en")
print(d)
data['carrier'] = d
print data
def number_scanner(phone_number):
number = phonenumbers.parse(phone_number)
description = geocoder.description_for_number(number, "en")
supplier = carrier.name_for_number(number, "en")
info = [["Country", "Supplier"], [description, supplier]]
data = str(tabulate(info, headers="firstrow", tablefmt="github"))
return data
def numberScanner(number):
number = phonenumbers.parse(number)
description = geocoder.description_for_number(number, 'en')
supplier = carrier.name_for_number(number, 'en')
info = [['Country', 'Supplier'], [description, supplier]]
data = str(tabulate(info, headers="firstrow", tablefmt="github"))
return data
def scan(InputNumber, print_results=True):
test('Running local scan...')
FormattedPhoneNumber = "+" + formatNumber(InputNumber)
try:
PhoneNumberObject = phonenumbers.parse(FormattedPhoneNumber, None)
except Exception as e:
throw(e)
else:
if not phonenumbers.is_valid_number(PhoneNumberObject):
return False
number = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.E164).replace('+', '')
numberCountryCode = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(' ')[0]
numberCountry = phonenumbers.region_code_for_country_code(
int(numberCountryCode))
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '')
internationalNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
country = geocoder.country_name_for_number(PhoneNumberObject, "en")
location = geocoder.description_for_number(PhoneNumberObject, "en")
carrierName = carrier.name_for_number(PhoneNumberObject, 'en')
if print_results:
plus('International format: {}'.format(internationalNumber))
plus('Local format: {}'.format(localNumber))
plus('Country found: {} ({})'.format(country, numberCountryCode))
plus('City/Area: {}'.format(location))
plus('Carrier: {}'.format(carrierName))
for timezoneResult in timezone.time_zones_for_number(
PhoneNumberObject):
plus('Timezone: {}'.format(timezoneResult))
if phonenumbers.is_possible_number(PhoneNumberObject):
plus('The number is valid and possible!')
else:
warn('The number is valid but might not be possible.')
numberObj = {}
numberObj['input'] = InputNumber
numberObj['default'] = number
numberObj['local'] = localNumber
numberObj['international'] = internationalNumber
numberObj['country'] = country
numberObj['countryCode'] = numberCountryCode
numberObj['countryIsoCode'] = numberCountry
numberObj['location'] = location
numberObj['carrier'] = carrierName
return numberObj
def handleEvent(self, event):
eventName = event.eventType
srcModuleName = event.module
eventData = event.data
sourceData = self.sf.hashstring(eventData)
if sourceData in self.results:
return None
else:
self.results[sourceData] = True
self.sf.debug("Received event, " + eventName + ", from " + srcModuleName)
if eventName in ['TARGET_WEB_CONTENT', 'DOMAIN_WHOIS', 'NETBLOCK_WHOIS']:
# Make potential phone numbers more friendly to parse
content = eventData.replace('.', '-')
for match in phonenumbers.PhoneNumberMatcher(content, region=None):
n = phonenumbers.format_number(match.number,
phonenumbers.PhoneNumberFormat.E164)
evt = SpiderFootEvent("PHONE_NUMBER", n, self.__name__, event)
if event.moduleDataSource:
evt.moduleDataSource = event.moduleDataSource
else:
evt.moduleDataSource = "Unknown"
self.notifyListeners(evt)
if eventName == 'PHONE_NUMBER':
try:
number = phonenumbers.parse(eventData)
except BaseException as e:
self.sf.debug('Error parsing phone number: ' + str(e))
return None
try:
number_carrier = carrier.name_for_number(number, 'en')
except BaseException as e:
self.sf.debug('Error retrieving phone number carrier: ' + str(e))
return None
if number_carrier:
evt = SpiderFootEvent("PROVIDER_TELCO", number_carrier, self.__name__, event)
self.notifyListeners(evt)
else:
self.sf.debug("No carrier information found for " + eventData)
#try:
# location = geocoder.description_for_number(number, 'en')
#except BaseException as e:
# self.sf.debug('Error retrieving phone number location: ' + str(e))
# return None
#if location:
# evt = SpiderFootEvent("GEOINFO", location, self.__name__, event)
# self.notifyListeners(evt)
#else:
# self.sf.debug("No location information found for " + eventData)
return None
def PhoneNumber():
numInput = input("Enter Phone Number - (Ex. = +447777123456) > ")
ro_number = phonenumbers.parse(numInput, "RO")
gb_number = phonenumbers.parse(numInput, "GB")
timezone_gb = timezone.time_zones_for_number(gb_number)
x = carrier.name_for_number(ro_number, "en")
print("Carrier: " + (x))
print("Timezone: " + str((timezone_gb)))
def get_mobile_number_carrier(self):
"""
get numbers mobile carrier, return empty string is not found.
:return: string
"""
from phonenumbers import carrier, parse
number = parse(str(self.number))
return carrier.name_for_number(number, "en")
def num_scanner(phn_num):
number = phonenumbers.parse(phn_num)
description = geocoder.description_for_number(number, 'en')
supplier = carrier.name_for_number(number, 'en')
info = [["COUNTRY", "SUPPLIER"], [description, supplier]]
data = str(tabulate(info, headers="firstrow", tablefmt="github"))
return data
def localScan(InputNumber):
global number
global localNumber
global internationalNumber
global numberCountryCode
global numberCountry
print(code_info + 'Running local scan...')
FormattedPhoneNumber = "+" + formatNumber(InputNumber)
try:
PhoneNumberObject = phonenumbers.parse(FormattedPhoneNumber, None)
except:
return False
else:
if not phonenumbers.is_valid_number(PhoneNumberObject):
return False
number = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.E164).replace('+', '')
numberCountryCode = phonenumbers.format_number(
PhoneNumberObject,
phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(' ')[0]
countryRequest = json.loads(
requests.request(
'GET',
'https://restcountries.eu/rest/v2/callingcode/{}'.format(
numberCountryCode.replace('+', ''))).content)
numberCountry = countryRequest[0]['alpha2Code']
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '')
internationalNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print(code_result +
'International format: {}'.format(internationalNumber))
print(code_result + 'Local format: 0{}'.format(localNumber))
print(code_result + 'Country code: {}'.format(numberCountryCode))
print(code_result + 'Location: {}'.format(
geocoder.description_for_number(PhoneNumberObject, "en")))
print(code_result + 'Carrier: {}'.format(
carrier.name_for_number(PhoneNumberObject, 'en')))
print(code_result + 'Area: {}'.format(
geocoder.description_for_number(PhoneNumberObject, 'en')))
for timezoneResult in timezone.time_zones_for_number(
PhoneNumberObject):
print(code_result + 'Timezone: {}'.format(timezoneResult))
if phonenumbers.is_possible_number(PhoneNumberObject):
print(code_info + 'The number is valid and possible.')
else:
print(code_warning +
'The number is valid but might not be possible.')
def details():
ph_no = input("Enter the number")
ch_no = phonenumbers.parse(ph_no,"CH")
geo = geocoder.description_for_number(ch_no, "en")
car = carrier.name_for_number(ch_no, "en")
time = timezone.time_zones_for_number(ch_no)
print(f'country : {geo}')
print(f'carrier : {car}')
print(f'timezone : {time}')
def IP():
target = input('Enter the host to be scanned: ')
phonne_number = phonenumbers.parse(target)
print(target)
print(geocoder.description_for_number(phonne_number, 'en'))
print(carrier.name_for_number(phonne_number, 'en'))
time.sleep(2)
main()
def get_tel_provider():
try:
service_provider = phonenumbers.parse(myNumber, 'RO')
if service_provider:
print("Your service provider is " +
carrier.name_for_number(service_provider, 'en'))
else:
print('Service provider not avaliable')
except:
print("Service provider not found!!")
def ph_num_lookup():
your_ph_num = input('Your Number: ')
phone_number = phonenumbers.parse(your_ph_num)
# put your phonenumber with the country code eg:+1xxxxxxxx
print(geocoder.description_for_number(phone_number, 'en'))
from phonenumbers import carrier
service_provider = phonenumbers.parse(your_ph_num)
# put your phonenumber with the country code eg:+1xxxxxxxx
print(carrier.name_for_number(service_provider, 'en'))
def run(node):
""" This returns any US phone numbers in the text.
:param node: a python dictionary with the 'text' field
"""
results = []
for match in phonenumbers.PhoneNumberMatcher(node['text'], "US"):
results.append({
"number" : phonenumbers.format_number(match.number, phonenumbers.PhoneNumberFormat.E164),
"location" : geocoder.description_for_number(match.number, "en"),
"carrier" : carrier.name_for_number(match.number, "en"),
"time_zone" : timezone.time_zones_for_number(match.number)
})
# http://stackoverflow.com/questions/11092511/python-list-of-unique-dictionaries
return {"phonenumbers": uniq_lod(results, 'number')}
def get_de_operator(self):
self.phonenumber_details['operator'] = carrier.name_for_number(self.phonenumber_object, "de")
return self.phonenumber_details['operator']
def testGetDescriptionForNumberWithMissingPrefix(self):
self.assertEqual("", name_for_number(UK_MOBILE2, _ENGLISH))
self.assertEqual("", name_for_number(AO_MOBILE2, _ENGLISH))
def testGetDescriptionForNumberWithNoDataFile(self):
self.assertEqual("", name_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH))
self.assertEqual("", name_for_number(INTERNATIONAL_TOLL_FREE, _ENGLISH))
self.assertEqual("", name_for_valid_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH))
self.assertEqual("", name_for_valid_number(INTERNATIONAL_TOLL_FREE, _ENGLISH))
def find_phone_numbers(source_txt):
# logger = get_logger()
tagged_phone_entities = []
for match in re.finditer(phonenum_candidate_regex_str, source_txt, re.MULTILINE):
# Extract the full-text value and the "normalized" value (i.e., digits only)
value = source_txt[match.start() : match.end()]
value_normalized = re.sub(u'[^\d]', u'', value)
# Extract an excerpt of text that precedes the match
excerpt_start = match.start() - EXCERPT_CHAR_BUFFER
if excerpt_start < 0:
excerpt_start = 0
excerpt_prefix = source_txt[ excerpt_start : match.start() ]
phone_number_obj = None
try:
# print "phone guess: %s"%value_normalized
# Try using the 'phonenumbers' module to parse the number. Note that we need to prefix
# the phone number string with "+" for parse() to work properly. If the number can't
# be parsed it will throw a NumberParseException.
phone_number_obj = phonenumbers.parse(u'+'+value_normalized, None)
# More lenient than valid_num
possible_num = phonenumbers.is_possible_number(phone_number_obj)
valid_num= phonenumbers.is_valid_number(phone_number_obj)
# print "possible=%s valid=%s"%(str(possible_num), str(valid_num))
# If the phonenumbers module thinks the number is invalid BUT it is preceded by text
# with a phone-related keyword, we'll accept the number. If the number is invalid and
# doesn't have a phone-related keyword, however, skip it.
if (not possible_num or not valid_num) and not contains_tel_keyword(excerpt_prefix[-15:]):
continue
except phonenumbers.phonenumberutil.NumberParseException as err:
# The phonenumbers modules couldn't parse the number; however, if it's preceded by text
# with a phone-related keyword we'll still accept it. Or put another way, if it is NOT
# preceded by a phone keyword, skip it.
if not contains_tel_keyword(excerpt_prefix[-15:]):
continue
#There seems to be a bug with some strings that cause partial numbers to be returned
if len(value_normalized) < 7:
continue
# If we got this far, it means we're accepting the number as a phone number. Extract a snippet
# of text that follows the match.
excerpt_stop = match.end() + EXCERPT_CHAR_BUFFER
if excerpt_stop > len(source_txt):
excerpt_stop = len(source_txt)
excerpt = source_txt[excerpt_start:excerpt_stop]
excerpt_value_start = match.start() - excerpt_start
excerpt_value_stop = excerpt_stop - match.end()
# Remove carriage returns replace multiple, consecutive whitespace with a single space
# so the excerpt will be compact and one line.
excerpt = re.sub('\r+', u'', excerpt)
excerpt = re.sub('\n+', u' ', excerpt)
excerpt = re.sub(u'\s+', u' ', excerpt)
print(u"Phone #: %s, \"%s\"" % (value_normalized, excerpt))
entity_dict = {
u"type": u"phone_number",
u"value": value,
u"value_normalized": value_normalized,
u"note": None,
u"body_offset_start": match.start(),
u"body_offset_stop": match.end(),
u"excerpt": excerpt,
u"excerpt_value_start": excerpt_value_start,
u"excerpt_value_stop": excerpt_value_stop,
u"possible_area": None,
u"possible_carrier": None
}
# If the phonenumbers module was able to construct an actual phone number object, attempt to
# add some notes about the possible geographic region and telco carrier.
if phone_number_obj is not None:
area_name = geocoder.description_for_number(phone_number_obj, "en")
if area_name:
entity_dict[u'possible_area'] = u"Possible area: %s. " % area_name
carrier_name = carrier.name_for_number(phone_number_obj, "en")
if carrier_name:
entity_dict[u'possible_carrier'] = u"Possible carrier: %s." % carrier_name
tagged_phone_entities.append(entity_dict)
return tagged_phone_entities
def testGetDescriptionForInvalidNumber(self):
self.assertEqual("", name_for_number(UK_INVALID_NUMBER, _ENGLISH))
self.assertEqual("", name_for_number(AO_INVALID_NUMBER, _ENGLISH))
def testGetDescriptionForMobilePortableRegion(self):
self.assertEqual("British carrier", name_for_number(UK_MOBILE1, _ENGLISH))
self.assertEqual(u("Brittisk operat\u00F6r"), name_for_number(UK_MOBILE1, "sv", region="SE"))
self.assertEqual("British carrier", name_for_number(UK_MOBILE1, _FRENCH))
# Returns an empty string because the UK implements mobile number portability.
self.assertEqual("", safe_display_name(UK_MOBILE1, _ENGLISH))
def testGetDescriptionForNonMobilePortableRegion(self):
self.assertEqual("Angolan carrier", name_for_number(AO_MOBILE1, _ENGLISH))
self.assertEqual("Angolan carrier", safe_display_name(AO_MOBILE1, _ENGLISH))
phonenumbers.is_valid_number(z)
print dir(phonenumbers.PhoneNumberFormat)
print
print x.country_code
print x
print str(x)
p = z
resp = {
"countryCode": p.country_code,
"nationalNumber": p.national_number,
"isPossible": phonenumbers.is_possible_number(p),
"isValid": phonenumbers.is_valid_number(p),
"e164": phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.E164),
"international": phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
"national": phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.NATIONAL),
"rfc3966": phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.RFC3966),
"location": geocoder.description_for_number(p, "en"),
"country": geocoder.country_name_for_number(p, "en"),
}
print json.dumps(resp, indent=2)
exit()
print y
print z
print repr(carrier.name_for_number(x, "en"))
print repr(carrier.name_for_number(y, "en"))
print repr(carrier.name_for_number(z, "en"))
def testGetDescriptionForPagerNumber(self):
self.assertEqual("British pager", name_for_number(UK_PAGER, _ENGLISH))
def testGetDescriptionForFixedOrMobileNumber(self):
self.assertEqual("US carrier", name_for_number(US_FIXED_OR_MOBILE, _ENGLISH))