def testGetTimeZonesForNumber(self):
# Test with invalid numbers even when their country code prefixes exist in the mapper.
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST,
time_zones_for_number(US_INVALID_NUMBER))
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST,
time_zones_for_number(KO_INVALID_NUMBER))
# Test with valid prefixes.
self.assertEqual((_SYDNEY_TZ, ), time_zones_for_number(AU_NUMBER))
self.assertEqual((_SEOUL_TZ, ), time_zones_for_number(KO_NUMBER))
self.assertEqual((_WINNIPEG_TZ, ), time_zones_for_number(CA_NUMBER))
self.assertEqual((_LOS_ANGELES_TZ, ),
time_zones_for_number(US_NUMBER1))
self.assertEqual((_NEW_YORK_TZ, ), time_zones_for_number(US_NUMBER2))
# Test with an invalid country code.
self.assertEqual(
_UNKNOWN_TIME_ZONE_LIST,
time_zones_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE))
# Test with a non geographical phone number.
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST,
time_zones_for_number(INTERNATIONAL_TOLL_FREE))
# Python version extra test: check a number that can't geocoded; falls back to per-country
kr_mobile_number = FrozenPhoneNumber(country_code=82,
national_number=801234567)
self.assertEqual((_SEOUL_TZ, ),
time_zones_for_number(kr_mobile_number))
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 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 post(self, request, *args, **kwargs):
try:
msisdn = request.data['msisdn']
except KeyError:
raise ValidationError({"msisdn": ["This field is required."]})
msisdn = msisdn if msisdn.startswith("+") else "+" + msisdn
try:
msisdn = phonenumbers.parse(msisdn)
except phonenumbers.phonenumberutil.NumberParseException:
raise ValidationError({
"msisdn":
["This value must be a phone number with a region prefix."]
})
if not (phonenumbers.is_possible_number(msisdn)
and phonenumbers.is_valid_number(msisdn)):
raise ValidationError({
"msisdn":
["This value must be a phone number with a region prefix."]
})
zones = list(ph_timezone.time_zones_for_number(msisdn))
if (len(zones) > 1 and request.query_params.get(
'return_one', 'false').lower() == 'true'):
zones = [get_middle_tz(zones)]
return Response({"success": True, "timezones": zones}, status=200)
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 sent_msg(users):
if working_hours(users.phone_number):
client = TwilioRestClient(account_sid, auth_token)
f = open('log.txt', 'a')
phone_number = phonenumbers.parse(users.phone_number, None)
curr_timezone = timezone.time_zones_for_number(phone_number)[0]
now = datetime.now(pytz.timezone(curr_timezone))
time = datetime.utcnow().replace(tzinfo=utc)
diff_time = time - users.created_at
no_of_attempts = 0
while no_of_attempts < 5:
try:
message = "Hi!! your name is " + users.name
client.messages.create(body=message,
to=users.phone_number,
from_="+12092922212")
f.write("%s Message sent successfully to %s running for %s\n" %
(now, users.phone_number, diff_time))
except TwilioRestException as e:
f.write(
"Error : %s message not sent due to technical issue to %s running for %s\n"
% (now, users.phone_number, diff_time))
no_of_attempts = no_of_attempts + 1
f.close()
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 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 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 testGetTimeZonesForNumber(self):
# Test with invalid numbers even when their country code prefixes exist in the mapper.
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST, time_zones_for_number(US_INVALID_NUMBER))
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST, time_zones_for_number(KO_INVALID_NUMBER))
# Test with valid prefixes.
self.assertEqual((_SYDNEY_TZ,), time_zones_for_number(AU_NUMBER))
self.assertEqual((_SEOUL_TZ,), time_zones_for_number(KO_NUMBER))
self.assertEqual((_WINNIPEG_TZ,), time_zones_for_number(CA_NUMBER))
self.assertEqual((_LOS_ANGELES_TZ,), time_zones_for_number(US_NUMBER1))
self.assertEqual((_NEW_YORK_TZ,), time_zones_for_number(US_NUMBER2))
# Test with an invalid country code.
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST, time_zones_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE))
# Test with a non geographical phone number.
self.assertEqual(_UNKNOWN_TIME_ZONE_LIST, time_zones_for_number(INTERNATIONAL_TOLL_FREE))
# Python version extra test: check a number that can't geocoded; falls back to per-country
kr_mobile_number = FrozenPhoneNumber(country_code=82, national_number=801234567)
self.assertEqual((_SEOUL_TZ,), time_zones_for_number(kr_mobile_number))
def working_hours(number):
phone_number = phonenumbers.parse(number, None)
curr_timezone = timezone.time_zones_for_number(phone_number)[0]
now = datetime.now(pytz.timezone(curr_timezone))
if starttime <= now.hour <= endtime:
return True
else:
return False
def valid_hours(number):
phone_number = ph.parse(number, None)
country_timezone = ptz.time_zones_for_number(phone_number)[0]
country_time = datetime.now(timezone(country_timezone))
if country_time.hour <= ALERT_STOP_TIME or country_time.hour >= ALERT_START_TIME:
return True
else:
return False
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 timezone_info(ngnumber):
# Basic OSINT Info
target_info = phonenumbers.parse(ngnumber, "NG")
# Timezone information
target_timezone = timezone.time_zones_for_number(target_info)
return {"phone": ngnumber, "timezone": target_timezone}
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 add_lead(request):
if request.method == 'POST':
print(request.POST)
time_zone = "None"
country = "None"
name = request.POST.get('name')
phone = request.POST.get('phone')
try:
if phonenumbers.is_valid_number(phone):
p = phonenumbers.parse(phone)
time_zone = timezone.time_zones_for_number(p)
country = phonenumbers.region_code_for_number(p)
except (AttributeError, ValueError, Exception):
pass
email = request.POST.get('email')
created_date = request.POST.get('created_date')
status = request.POST.get('status')
if request.POST.get('manager') is not None:
manager_id = request.POST.get('manager')
else:
manager_id = request.user.id
lead = models.Lead(name=name,
phone=phone,
email=email,
country=country,
time_zone=time_zone,
created_date=created_date,
status=status,
manager=models.User.objects.get(id=manager_id))
lead.save()
manager = None
if lead.manager:
manager = lead.manager.username
content = {
'id': lead.pk,
'name': lead.name,
'email': lead.email,
'depozit': lead.depozit,
'phone': lead.phone,
'country': lead.country,
'created_date': models.json_serial(lead.created_date),
'status': lead.status,
'manager': manager,
'type': "data.new",
}
response_data = {
'result': 'Lead create successful',
'flag': 'new',
'content': content
}
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
return HttpResponse(json.dumps(
{"nothing to see": "this isn't happening"}),
content_type="application/json")
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 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 Exception as e:
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]
numberCountry = phonenumbers.region_code_for_country_code(
int(numberCountryCode))
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '0')
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')
print(code_result +
'International format: {}'.format(internationalNumber))
print(code_result + 'Local format: 0{}'.format(localNumber))
print(code_result +
'Country found: {} ({})'.format(country, numberCountryCode))
print(code_result + 'City/Area: {}'.format(location))
print(code_result + 'Carrier: {}'.format(carrierName))
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 ExamineNumber(phoneNumber, countryCode, verbosity=False):
if verbosity:
print(f'{bcolors.BOLD}Examining: ', phoneNumber, f'{bcolors.ENDC}')
print(f'{bcolors.BOLD}Country Code set: ', countryCode,
f'{bcolors.ENDC}')
print('\n\n')
try:
print(f'{bcolors.BOLD}Validating...{bcolors.ENDC}\n')
meta = phonenumbers.parse(countryCode + phoneNumber, None)
if not phonenumbers.is_valid_number(meta):
print(
f'{bcolors.FAIL} Phone Number could not be Validated. Exiting... {bcolors.ENDC}'
)
return "Invalid", "Invalid", "Invalid"
print(f'{bcolors.BOLD}', meta, f'{bcolors.ENDC}\n\n')
except phonenumbers.NumberParseException:
print(
f'{bcolors.FAIL} Phone Number could not be Validated. Exiting... {bcolors.ENDC}'
)
return 'Invalid', 'Invalid', 'Invalid'
if verbosity:
print(f'{bcolors.BOLD} Retrieving Country {bcolors.ENDC}')
area = geocoder.description_for_number(meta, 'en')
print(f'{bcolors.BOLD} Area: ', area, f'{bcolors.ENDC}\n')
if verbosity:
print(
f'{bcolors.BOLD} Attempting to get Carrier Informaion {bcolors.ENDC}'
)
carrier_info = carrier.name_for_number(meta, 'en')
if carrier_info is not None and not carrier_info == "":
if verbosity:
print(f'{bcolors.BOLD} Success {bcolors.ENDC}')
print(f'{bcolors.BOLD}Carrier: ', carrier_info, f'{bcolors.ENDC}\n')
else:
carrier_info = 'Could Not Be Traced'
print(f'{bcolors.FAIL}Carrier could not be Traced!{bcolors.ENDC}\n')
if verbosity:
print(
f'{bcolors.BOLD} Attempting to get TimeZone Information {bcolors.ENDC}'
)
timezone_info = timezone.time_zones_for_number(meta)
if timezone_info is not None and not timezone_info == "":
if verbosity:
print(f'{bcolors.BOLD} Success {bcolors.ENDC}')
print(f'{bcolors.BOLD}Timezone: ', timezone_info, f'{bcolors.ENDC}\n')
else:
timezone_info = "Could Not Be Traced"
print(f'{bcolors.FAIL}Timezone could not be Traced!{bcolors.ENDC}\n')
return area, carrier_info, timezone_info
def operation():
if (i=="1"):
exit()
elif(i=="2"):
banner()
number=input(colored("Telefon Numarasını ülke kodu ile birlikte giriniz-enter your phone number with country code (+90..........): ","green"))
phone_number = phonenumbers.parse(number, None)
print("Ülke/Şehir-Country/City: ",geocoder.description_for_number(phone_number,'tr'))
print("Saat dilimi-Time zone: ",timezone.time_zones_for_number(phone_number))
print("Operatör-Operator: ",carrier.name_for_number(phone_number,'tr'))
else:
print("Hatalı işlem-Incorrect operation")
def phonedetails(az):
try:
x = phonenumbers.parse(az, None)
ro = phonenumbers.parse(az, "RO")
gb = phonenumbers.parse(az, "GB")
az1=ro
az2=geocoder.description_for_number(x, "en")
az3=carrier.name_for_number(ro, "en")
az4=timezone.time_zones_for_number(gb)
return str(az1)+'\n'+'country : '+str(az2)+'\n'+'Service provider : '+str(az3)+'\n'+'time Zone : '+str(az4)
except:
return "we could not able give infomation"
def localScan(InputNumber):
global number
global localNumber
global internationalNumber
global numberCountryCode
global numberCountry
print(code_info + 'Executando verificação local...')
FormattedPhoneNumber = "+" + formatNumber(InputNumber)
try:
PhoneNumberObject = phonenumbers.parse(FormattedPhoneNumber, None)
except Exception as e:
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]
numberCountry = phonenumbers.region_code_for_country_code(
int(numberCountryCode))
localNumber = phonenumbers.format_number(
PhoneNumberObject, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '0')
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')
print(code_result + f'Formato internacional:{B} {internationalNumber}')
print(code_result + f'Formato local:{B} 0 {localNumber}')
print(code_result + f'País: {B}{country} ({numberCountryCode})')
print(code_result + f'Cidade/Estado:{B} {location}')
print(code_result + f'Operadora:{B} {carrierName}')
for timezoneResult in timezone.time_zones_for_number(
PhoneNumberObject):
print(code_result + f'Fuso horário:{B} {timezoneResult}')
if phonenumbers.is_possible_number(PhoneNumberObject):
print(code_info + 'O número é válido e possível.')
else:
print(code_warning +
'O número é válido, mas pode não ser possível.')
def location(phone_number):
number = phonenumbers.parse(phone_number, "EN")
liste = time_zones_for_number(number)
country = geocoder.description_for_number(number, "en")
operator = carrier.name_for_number(number, "en")
print(colored.green("[+]Country:" + str(country)))
print(colored.green("[+]Time Zone:" + str(liste[0])))
print(colored.green("[+]Carrier:" + str(operator)))
with open("output/location_operator.txt", "a+") as file:
file.write(
"\n[+]Country:\n" + str(country) + "\n[+]Time Zone:\n" +
str(liste[0]) + "\n[+]Carrier:\n" + str(operator) +
"\n--------------------------------------------------------------")
def phonenumber_lookup(ph):
try:
number = phonenumbers.parse(ph)
phonenumbers.is_possible_number(number)
print("Country: " + geocoder.region_code_for_number(number))
if geocoder.description_for_number(number, "en").lstrip() != "":
print("City: " + geocoder.description_for_number(number, "en"))
print(
"Timezone: " +
re.sub("[()'',]", "", str(timezone.time_zones_for_number(number))))
print("Carrier: " + carrier.name_for_number(number, "en"))
except phonenumbers.phonenumberutil.NumberParseException:
cprint(error, "Invalid or malformed number.")
return
def is_phone_valid(phone_number: str) -> bool:
"""
:param phone_number:
:return: True, correct phone number or False, blank
:rtype: tuple
"""
try:
area_zone = timezone.time_zones_for_number(phonenumbers.parse(phone_number, 'GB'))[0]
except:
return False
if area_zone == "Etc/Unknown":
return False
return True
def is_phone_valid(phone_number: str) -> bool:
"""
validate any country phone number
:param phone_number:
:return: True, correct phone number or False, blank
:rtype: bool
"""
if not phone_number:
return False
area_zone = timezone.time_zones_for_number(
phonenumbers.parse(phone_number, 'GB'))[0]
if area_zone == "Etc/Unknown":
return False
return True
def uploaded(file_location, **kwargs):
"""
uploaded
"""
LOG.info('Open file: %s', file_location)
with open(file_location, 'r') as reader:
csv_read = csv.reader(reader)
x = 0
for row in csv_read:
if x != 0:
us_number = phonenumbers.parse("".join(row), "US")
for i in timezone.time_zones_for_number(us_number):
location, _ = Location.objects.get_or_create(name=i)
x = +1
x = +1
LOG.info('Location added...')
LOG.info('Uploading number to Number table...')
with open(file_location, 'r') as reader:
csv_read = csv.reader(reader)
x = 0
for row in csv_read:
if x != 0:
us_number = phonenumbers.parse("".join(row), "US")
location = ', '.join(timezone.time_zones_for_number(us_number))
validated = True if location != 'Etc/Unknown' else False
data, _ = Number.objects.get_or_create(
national_number=us_number.national_number,
validated=validated)
loc = list(timezone.time_zones_for_number(us_number))
for lrow in Location.objects.filter(name__in=loc):
if data.location.filter(name=lrow).count() == 0:
data.location.add(lrow)
data.save()
x = +1
x = +1
LOG.info('Numbers uploaded...')
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 numberSave():
#SAVE RESULTS - PHONE NUMBER SCANNER FRAME
folder5 = filedialog.askdirectory()
filename5 = "scanPhone_{}.txt".format(phoneNumberGET)
file5_path = os.path.join(folder5, filename5)
f5 = open(file5_path, 'w+')
f5.write(
"INTER FORMAT: {}\nLOCAL FORMAT: {}\nCOUNTRY: {} ({})\nCITY/AREA: {}\nCARRIER: {}\n"
.format(numberINTER, numberLOCAL, countryNSCAN, numberCC,
locationNSCAN, carrierNameNSCAN))
for timezoneResult in timezone.time_zones_for_number(phoneNumber):
f5.write("TIMEZONE: {}\n".format(timezoneResult))
if phonenumbers.is_possible_number(phoneNumber):
f5.write("VALID + POSSIBLE NUMBER.\n")
f5.close()
messagebox.showinfo("Saved (TXT)", "Saved to: {}".format(file5_path))
def getInformation(canvas):
number = textField.get()
ch_number = phonenumbers.parse(number, "CH")
# print(geocoder.description_for_number(ch_number, "en"))
service_number = phonenumbers.parse(number, "RO")
# print(carrier.name_for_number(service_number, "en"))
tz_number = phonenumbers.parse(number)
# print(timezone.time_zones_for_number(tz_number))
info = str(carrier.name_for_number(service_number, "en")) + "\n" + str(
timezone.time_zones_for_number(tz_number))[2:-3]
label1.config(text=str(geocoder.description_for_number(ch_number, "en")))
label2.config(text=info)
def lscan(unumber):
print("Scanning [" + unumber +
"] using *Python Scan* phoneSc - by Qzacy")
sleep(0.5)
try:
numberObj = phonenumbers.parse(unumber, None)
except Exception as err:
print("\n\nError: " + err)
trm()
else:
if not phonenumbers.is_valid_number(numberObj):
return False
iNum = phonenumbers.format_number(
numberObj, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
cCode = phonenumbers.format_number(
numberObj,
phonenumbers.PhoneNumberFormat.INTERNATIONAL).split(' ')[0]
lNum = phonenumbers.format_number(
numberObj, phonenumbers.PhoneNumberFormat.E164).replace(cCode, '')
country = geocoder.country_name_for_number(numberObj, "en")
city = geocoder.description_for_number(numberObj, "en")
nCarrier = carrier.name_for_number(numberObj, "en")
timezones = str(timezone.time_zones_for_number(numberObj))
if iNum == "":
iNum = "/"
if lNum == "":
lNum = "/"
if country == "":
country = "/"
if cCode == "":
cCode = "/"
if city == "":
city = "/"
if nCarrier == "":
nCarrier = "/"
if timezones == "":
timezones = "/"
print("\nInternational format: {}".format(iNum))
print("Local format: {}".format(lNum))
print("Country: {}".format(country))
print("Country Code: {}".format(cCode))
print("City: {}".format(city))
print("Carrier: {}".format(nCarrier))
print("Timezones: {}\n".format(timezones))
trm()
def libphonenumbers(number):
print('\n[*] Running local scan...\n')
try:
phonenumber = phonenumbers.parse(number, None)
except:
return False
else:
if not phonenumbers.is_valid_number(phonenumber):
return False
number = phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.E164).replace('+', '')
numberCountryCode = phonenumbers.format_number(
phonenumber,
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(
phonenumber, phonenumbers.PhoneNumberFormat.E164).replace(
numberCountryCode, '')
internationalNumber = phonenumbers.format_number(
phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
print('[+] International format: {}'.format(internationalNumber))
print('[+] Local format: 0{}'.format(localNumber))
print('[+] Country code: {}'.format(numberCountryCode))
print('[+] Location: {}'.format(
geocoder.description_for_number(phonenumber, "en")))
print('[+] Carrier: {}'.format(
phonenumbers.carrier.name_for_number(phonenumber, 'en')))
for libphonenumbers.timezoneResult in timezone.time_zones_for_number(
phonenumber):
print('[+] Timezone: {}'.format(libphonenumbers.timezoneResult))
if phonenumbers.is_possible_number(phonenumber):
print('[*] The number is valid and possible.')
else:
print('(!) The number is valid but might not be possible.')
def get_timezone(self):
self.phonenumber_details['timezone'] = timezone.time_zones_for_number(self.phonenumber_object)
return self.phonenumber_details['timezone']
def testGetTimeZonesForValidNumberSearchingAtCountryCodeLevel(self):
# Test that the country level time zones are returned when the number passed in is valid but
# not covered by any non-country level prefixes in the mapper.
self.assertEqual(time_zones_for_number(US_NUMBER3), _NANPA_TZ_LIST)
