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)