def testGetDescriptionForNumber_en_US(self): self.assertEqual("CA", geocoder.description_for_number(US_NUMBER1, _ENGLISH, region=_USA)) self.assertEqual("Mountain View, CA", geocoder.description_for_number(US_NUMBER2, _ENGLISH, region=_USA)) self.assertEqual("New York, NY", geocoder.description_for_number(US_NUMBER3, _ENGLISH, region=_USA))
def testGetDescriptionForNumber_en_US(self): self.assertEquals( "CA", geocoder.description_for_number(US_NUMBER1, _ENGLISH, region=_USA)) self.assertEquals( "Mountain View, CA", geocoder.description_for_number(US_NUMBER2, _ENGLISH, region=_USA)) self.assertEquals( "New York, NY", geocoder.description_for_number(US_NUMBER3, _ENGLISH, region=_USA))
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/%s' % 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: %s' % internationalNumber print code_result + 'Local format: 0%s' % localNumber print code_result + 'Country code: %s' % numberCountryCode print code_result + 'Location: %s' % geocoder.description_for_number( PhoneNumberObject, "en") print code_result + 'Carrier: %s' % carrier.name_for_number( PhoneNumberObject, 'en') print code_result + 'Area: %s' % geocoder.description_for_number( PhoneNumberObject, 'en') for timezoneResult in timezone.time_zones_for_number( PhoneNumberObject): print code_result + 'Timezone: %s' % (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 testGetDescriptionForKoreanNumber(self): self.assertEqual("Seoul", geocoder.description_for_number(KO_NUMBER1, _ENGLISH)) self.assertEqual("Incheon", geocoder.description_for_number(KO_NUMBER2, _ENGLISH)) self.assertEqual("Jeju", geocoder.description_for_number(KO_NUMBER3, _ENGLISH)) self.assertEqual(u"\uC11C\uC6B8", geocoder.description_for_number(KO_NUMBER1, _KOREAN)) self.assertEqual(u"\uC778\uCC9C", geocoder.description_for_number(KO_NUMBER2, _KOREAN))
def testGetDescriptionForKoreanNumber(self): self.assertEqual("Seoul", geocoder.description_for_number(KO_NUMBER1, _ENGLISH)) self.assertEqual("Incheon", geocoder.description_for_number(KO_NUMBER2, _ENGLISH)) self.assertEqual("Jeju", geocoder.description_for_number(KO_NUMBER3, _ENGLISH)) self.assertEqual(u"\uC11C\uC6B8", geocoder.description_for_number(KO_NUMBER1, _KOREAN)) self.assertEqual(u"\uC778\uCC9C", geocoder.description_for_number(KO_NUMBER2, _KOREAN))
def testGetDescriptionForFallBack(self): # No fallback, as the location name for the given phone number is # available in the requested language. self.assertEqual("Kalifornien", description_for_number(US_NUMBER1, _GERMAN)) # German falls back to English. self.assertEqual("New York, NY", description_for_number(US_NUMBER3, _GERMAN)) # Italian falls back to English. self.assertEqual("CA", description_for_number(US_NUMBER1, _ITALIAN)) # Korean doesn't fall back to English. self.assertEqual(u"\uB300\uD55C\uBBFC\uAD6D", description_for_number(KO_NUMBER3, _KOREAN))
def testGetDescriptionForNumberWithNoDataFile(self): # No data file containing mappings for US numbers is available in Chinese for the unittests. As # a result, the country name of United States in simplified Chinese is returned. self.assertEqual(u("\u7F8E\u56FD"), description_for_number(US_NUMBER1, _CHINESE, region=_CHINA)) self.assertEqual("Bahamas", description_for_number(BS_NUMBER1, _ENGLISH, region=_USA)) self.assertEqual("Australia", description_for_number(AU_NUMBER, _ENGLISH, region=_USA)) self.assertEqual("", description_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH, region=_USA)) self.assertEqual("", description_for_number(INTERNATIONAL_TOLL_FREE, _ENGLISH, region=_USA))
def testGetDescriptionForNumberWithNoDataFile(self): # No data file containing mappings for US numbers is available in Chinese for the unittests. As # a result, the country name of United States in simplified Chinese is returned. self.assertEqual(u"\u7F8E\u56FD", geocoder.description_for_number(US_NUMBER1, _CHINESE, region=_CHINA)) self.assertEqual("Bahamas", geocoder.description_for_number(BS_NUMBER1, _ENGLISH, region=_USA)) self.assertEqual("Australia", geocoder.description_for_number(AU_NUMBER, _ENGLISH, region=_USA)) self.assertEqual("", geocoder.description_for_number(NUMBER_WITH_INVALID_COUNTRY_CODE, _ENGLISH, region=_USA)) self.assertEqual("", geocoder.description_for_number(INTERNATIONAL_TOLL_FREE, _ENGLISH, region=_USA))
def testGetDescriptionForFallBack(self): # No fallback, as the location name for the given phone number is # available in the requested language. self.assertEqual("Kalifornien", geocoder.description_for_number(US_NUMBER1, _GERMAN)) # German falls back to English. self.assertEqual("New York, NY", geocoder.description_for_number(US_NUMBER3, _GERMAN)) # Italian falls back to English. self.assertEqual("CA", geocoder.description_for_number(US_NUMBER1, _ITALIAN)) # Korean doesn't fall back to English. self.assertEqual(u"\uB300\uD55C\uBBFC\uAD6D", geocoder.description_for_number(KO_NUMBER3, _KOREAN))
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 get_number_location_description(self): """ return a text description of a PhoneNumber object, return empty string is not found. :return: string """ from phonenumbers import geocoder, parse return geocoder.description_for_number(parse(str(self.number)), "en")
def url_fetch(query=""): if not query: last_query = session.get('last_query', None) if last_query is not None: query = session['last_query']['query'] stopset = set(stopwords.words('english')) q = { "fields": ["file"], "query": { "term": {"file": query} } } r = es.search(body=q, index=es_index) data = r['hits']['hits'] urls = [] pn = [] for doc in data: urls.append(re.findall(r'(https?://[^\s]+)', doc['fields']['file'][0])) try: for match in phonenumbers.PhoneNumberMatcher(doc['fields']['file'][0], region=None): pn.append({'number': phonenumbers.format_number(match.number, phonenumbers.PhoneNumberFormat.E164), 'location': geocoder.description_for_number(match.number, "en")}) except KeyError: pass urls = filter(lambda x: x != [], urls) # urls_flat=reduce(lambda x,y: x.extend(y),urls) urls_flat = [item for sublist in urls for item in sublist] return json.dumps({'urls': dict(Counter(urls_flat)), 'pn': pn})
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 locate_numbers(): if request.method == 'POST': if 'numbers' not in request.files: return redirect(url_for('index')) numbers = request.files['numbers'].readlines() numbers_results = [] for line in numbers: line = line.rstrip().decode() number = format_phonenumber(line) if number == 'numbers': number_result = [line, 'valid', 'location'] else: try: parsed_number = phonenumbers.parse(number, PHONE_REGION) if phonenumbers.is_valid_number(parsed_number): location = geocoder.description_for_number( parsed_number, "en") number_result = [line, 'true', location] else: number_result = [line, 'false', 'n/a'] except: number_result = [line, 'false', 'n/a'] numbers_results.append(number_result) return '\n'.join(', '.join(elems) for elems in numbers_results), 200, { 'Content-Type': 'text/plain' } else: # request.method == 'GET' msg = "HTTP 501: Not implemented" return msg, 501, {'Content-Type': 'text/plain'}
def testGetDescriptionForArgentinianMobileNumber(self): self.assertEqual("La Plata", description_for_number(AR_MOBILE_NUMBER, _ENGLISH)) # Python version extra test # Put an invalid number after the mobile token ("9") and lie about # this being a valid number arInvalidMobileNumber = PhoneNumber(country_code=54, national_number=91) self.assertEqual("Argentina", description_for_valid_number(arInvalidMobileNumber, _ENGLISH))
def testGetDescriptionForArgentinianMobileNumber(self): self.assertEqual("La Plata", description_for_number(AR_MOBILE_NUMBER, _ENGLISH)) # Python version extra test # Put an invalid number after the mobile token ("9") and lie about # this being a valid number arInvalidMobileNumber = PhoneNumber(country_code=54, national_number=91) self.assertEqual("Argentina", description_for_valid_number(arInvalidMobileNumber, _ENGLISH))
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 phone_anonymizer(phone): #return a phone number anonymized "Anonymizes a phone number in order to respect privacy in the PoC" #the phone number must have a '+' to be in E.164 format #in order to be parseable by phonenumbers if phone[0] is not '+': phone = str('+')+phone try: phone_number = phonenumbers.parse(phone, None) phone_format = phonenumbers.format_number(phone_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) phone_geo = str(geocoder.description_for_number(phone_number, "en")) if phone_geo is None: #idk if needed, just in case some city/country is not in the mapping table phone_geo = 'Unknown' tokens = phone_format.split() pre_anonym = '' for i in range(0,len(tokens)): pre_anonym = pre_anonym+str(tokens[i])+phone_geo ###### hash of the recently generated string. I chose the less demanding algorithm, without collisions, in term of ###### computing load among the supported ones ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512') hash_object = hashlib.sha224(pre_anonym) return hash_object.hexdigest() except NumberParseException as err: logging.warning('Error ocurred while processing in phone_anonymizer: %s', str(err))
def info(): while True: b = input(colored(" Enter number: ", 'blue')) inp = input(colored("Continue ? Y/n: ", 'red')) if inp == "n": sys.exit("\n Shutting down... ") if inp == "y": print(colored("\n Target Number... \n", 'blue')) else: print(colored(f"\n Invalid '{inp}' Try again ! \n", 'red')) break ex = phonenumbers.parse(b) # ex=phonenumbers.PhoneMetadata.load_all(inp) # exp=timezone.time_zones_for_number(ex, "GB") exp = geocoder.description_for_number(ex, "en") print(colored("Country: ", 'green'), exp) #if inp=="y" or "Y": # sys.exit("\n Shutting down... ") def isp(): i = phonenumbers.parse(b) s = carrier.name_for_number(i, "en") print(colored("ISP: ", 'green'), s) isp() def time(): p = phonenumbers.parse(b) e = timezone.time_zones_for_number(p) print(colored("Timezone: ", 'green'), e, "\n") time()
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 test_getCountryMax(): countryCount = {} countryWithMaxCount = None finalDic = {} reader = io.StringIO("""History trip always room. c369e42170409b5a250f5ec8a86fa5bf +61353386215 +447733795449 Bag show white artist town message field catch. 6d:a6:0f:0b:94:17 Continue address throw difference discover. 43,221,224 +40756809984 Continue address throw difference discover. 43,221,224 +40756809984 Davidside, NY 84689 +61786844803 +61211549558 +61303024775""") for line in reader.readlines(): m = re.search(r"\+[\d]+", line) if m != None: ch_number = phonenumbers.parse(m.group(0), "US") country = geocoder.description_for_number(ch_number, "en") print(country == "") if country in countryCount.keys(): countryCount[country] += 1 elif country == "": countryCount["notfound in {}".format(m.group(0))] = 1 else: countryCount[country] = 1 countryWithMaxCount = max(countryCount, key=countryCount.get) assert countryWithMaxCount == "Australia" assert countryCount[countryWithMaxCount] == 3
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 validate_number(number, country, include_description=True) -> Optional[Number]: try: p = parse_number(number, country) except NumberParseException: return if not is_valid_number(p): return is_mobile = number_type(p) in MOBILE_NUMBER_TYPES descr = None if include_description: country = country_name_for_number(p, 'en') region = description_for_number(p, 'en') descr = country if country == region else f'{region}, {country}' return Number( number=format_number(p, PhoneNumberFormat.E164), country_code=f'{p.country_code}', number_formatted=format_number(p, PhoneNumberFormat.INTERNATIONAL), descr=descr, is_mobile=is_mobile, )
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 getCountry(phone): try: query = parse("+" + phone, None) country = repr(geocoder.description_for_number(query, 'en')) except: country = "Unknown" return country
def info(): while True: b = input(" টুনির মার নম্বার: ") inp = input(" ভরতে চাস ? Y/n: ") if inp == "n": sys.exit("\n বিদাই পিতিবি... ") if inp == "y": print("\n ভরে দেওয়া নম্বার... \n") else: print(f"\n কানাষুদা '{inp}' দেখে লেখ \n") break ex = phonenumbers.parse(b) # ex=phonenumbers.PhoneMetadata.load_all(inp) # exp=timezone.time_zones_for_number(ex, "GB") exp = geocoder.description_for_number(ex, "en") print("দেশ =", exp) def time(): p = phonenumbers.parse(b) e = timezone.time_zones_for_number(p) print("সময়যাত্রা=", e) time()
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 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 url_fetch(query=""): if not query: last_query = session.get('last_query', None) if last_query is not None: query = session['last_query']['query'] stopset = set(stopwords.words('english')) q = {"fields": ["file"], "query": {"term": {"file": query}}} r = es.search(body=q, index=es_index) data = r['hits']['hits'] urls = [] pn = [] for doc in data: urls.append(re.findall(r'(https?://[^\s]+)', doc['fields']['file'][0])) try: for match in phonenumbers.PhoneNumberMatcher( doc['fields']['file'][0], region=None): pn.append({ 'number': phonenumbers.format_number( match.number, phonenumbers.PhoneNumberFormat.E164), 'location': geocoder.description_for_number(match.number, "en") }) except KeyError: pass urls = filter(lambda x: x != [], urls) # urls_flat=reduce(lambda x,y: x.extend(y),urls) urls_flat = [item for sublist in urls for item in sublist] return json.dumps({'urls': dict(Counter(urls_flat)), 'pn': pn})
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 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 test_getCountryTest(): ch_number = phonenumbers.parse("+447733795449", "US") # requires E164 format # E.164 numbers are formatted [+] [country code] [subscriber number including area code] and can have a maximum of fifteen digits # @see https://www.twilio.com/docs/glossary/what-e164 geo = geocoder.description_for_number(ch_number, "en") assert geo == "United Kingdom"
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 lambda_handler(event, context=None): phone_number = event["params"]["querystring"]["phone"] phone_number = '+' + phone_number print phone_number try: v = phonenumbers.parse(phone_number, None) except: v = None if v and v.country_code == 1: # This is a US number, so lets do the geocoder state = geocoder.description_for_number(v, "en") country_code = "US" return {"country_code": country_code, "state": state} if v and v.country_code == 91: # This is India, so we may get some more info about this guy country_code = "IN" phone_without = str(v.national_number) url = 'https://avneesh-indian-phone-number-info-v1.p.mashape.com/getphoneinfo' params = {'mobile_number': phone_without[:4]} headers = { 'X-Mashape-Key': 'gi7WK8GMREmshSQcmqWtPalrLYrap1D3t32jsnMgtJqq0NafUR', 'Accept': 'application/json' } r = requests.get(url, params=params, headers=headers) if r.status_code == 200 and 'location' in r.json().keys(): state = r.json()['location'] if state == 'Kolkatta': state = 'Kolkata' if state == 'Andra Pradesh': state = 'Andhra Pradesh' if state == 'Maharastra': state = 'Maharashtra' if state == 'Gujarat': state = 'Gujrat' if state == 'Goa&Maharashtra': state = 'Maharashtra' if state == 'Uttar Pradesh(East)': state = 'Uttar Pradesh East' if state == 'Uttar Pradesh(West)': state = 'Uttar Pradesh West' if state == 'Madhya Pradesh & Chhattisgarh': state = 'Madhya Pradesh' if state == 'karnataka': state = 'Karnataka' if state == 'Bihar & Jharkhand': state = 'Bihar' if state == 'Orissa': state = 'Odisha' if state == 'Uttar Pradesh(west) & Uttarakhand': state = 'Uttar Pradesh West' if state == 'Uttar Pradesh(west) & Uttarkhand': state = 'Uttar Pradesh West' if state == 'Tata Docomo': return None return {'country_code': country_code, "state": state} return None
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 testGetDescriptionForNumberWithUserRegion(self): # User in Italy, American number. We should just show United States, in # Spanish, and not more detailed information. self.assertEqual("Estados Unidos", description_for_number(US_NUMBER1, _SPANISH, region="IT")) # Unknown region - should just show country name. self.assertEqual("Estados Unidos", description_for_number(US_NUMBER1, _SPANISH, region="ZZ")) # User in the States, language German, should show detailed data. self.assertEqual("Kalifornien", description_for_number(US_NUMBER1, _GERMAN, region="US")) # User in the States, language French, no data for French, so we fallback # to English detailed data. self.assertEqual("CA", description_for_number(US_NUMBER1, _FRENCH, region="US")) # Invalid number - return an empty string. self.assertEqual("", description_for_number(US_INVALID_NUMBER, _ENGLISH, region="US"))
def testGetDescriptionForNumberWithUserRegion(self): # User in Italy, American number. We should just show United States, in # Spanish, and not more detailed information. self.assertEqual("Estados Unidos", geocoder.description_for_number(US_NUMBER1, _SPANISH, region="IT")) # Unknown region - should just show country name. self.assertEqual("Estados Unidos", geocoder.description_for_number(US_NUMBER1, _SPANISH, region="ZZ")) # User in the States, language German, should show detailed data. self.assertEqual("Kalifornien", geocoder.description_for_number(US_NUMBER1, _GERMAN, region="US")) # User in the States, language French, no data for French, so we fallback # to English detailed data. self.assertEqual("CA", geocoder.description_for_number(US_NUMBER1, _FRENCH, region="US")) # Invalid number - return an empty string. self.assertEqual("", geocoder.description_for_number(US_INVALID_NUMBER, _ENGLISH, region="US"))
def tz_ids_for_phone(phone, country='US'): """ Get the TZ identifiers that a phone number might be related to, e.g. >>> tztrout.tz_ids_for_phone('+16503334444') [u'America/Los_Angeles'] >>> tztrout.tz_ids_for_phone('+49 (0)711 400 40990') [u'Europe/Berlin', u'Europe/Busingen'] """ from phonenumbers.geocoder import description_for_number try: phone = phonenumbers.parse(phone, country) except: pass else: country_iso = phonenumbers.region_code_for_number(phone) if not country_iso: country_iso = phonenumbers.region_code_for_country_code(phone.country_code) if country_iso == 'US': # check if we have a specific exception for a given area code first exception_key = 'areacode:%s' % str(phone.national_number)[:3] if exception_key in data_exceptions: return data_exceptions[exception_key]['include'] state = city = None area = description_for_number(phone, 'en').split(',') if len(area) == 2: city = area[0].strip() state = area[1].strip() elif len(area) == 1 and area[0]: state = area[0].lower().strip() state = td.normalized_states['US'].get(state, None) return tz_ids_for_address(country_iso, state=state, city=city) elif country_iso == 'CA': area_code = str(phone.national_number)[:3] state = td.ca_area_code_to_state.get(area_code) return td.ca_state_to_tz_ids.get(state) elif country_iso == 'AU': area_code = str(phone.national_number)[:2] state = td.au_area_code_to_state.get(area_code) # Some Australian number prefixes (e.g. 04) are country-wide - fall # back to all the AU tz ids if state: return td.au_state_to_tz_ids.get(state) return pytz.country_timezones.get(country_iso) elif country_iso: return pytz.country_timezones.get(country_iso) return []
def testCoverage(self): # Python version extra tests invalid_number = PhoneNumber(country_code=210, national_number=123456L) self.assertEqual("", geocoder.country_name_for_number(invalid_number, "en")) # Add in some script and region specific fictional names TEST_GEOCODE_DATA['1650960'] = {'en': u'Mountain View, CA', "en_GB": u'Mountain View California', "en_US": u'Mountain View, Sunny California', "en_Latn": u'MountainView'} # The following test might one day return "Mountain View California" self.assertEqual("United States", geocoder.description_for_number(US_NUMBER2, _ENGLISH, region="GB")) self.assertEqual("Mountain View, Sunny California", geocoder.description_for_number(US_NUMBER2, _ENGLISH, region="US")) self.assertEqual("MountainView", geocoder.description_for_number(US_NUMBER2, _ENGLISH, script="Latn")) self.assertEqual("United States", geocoder.description_for_number(US_NUMBER2, _ENGLISH, script="Latn", region="GB")) # Get a different result when there is a script-specific variant self.assertEqual("MountainView", geocoder.description_for_number(US_NUMBER2, _ENGLISH, script="Latn", region="US")) TEST_GEOCODE_DATA['1650960'] = {'en': u'Mountain View, CA'}
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 testCoverage(self): # Python version extra tests invalid_number = PhoneNumber(country_code=210, national_number=123456) self.assertEqual("", country_name_for_number(invalid_number, "en")) # Ensure we exercise all public entrypoints directly self.assertEqual("CA", _prefix_description_for_number(TEST_GEOCODE_DATA, TEST_GEOCODE_LONGEST_PREFIX, US_NUMBER1, "en")) self.assertEqual("CA", description_for_valid_number(US_NUMBER1, "en")) self.assertEqual("", description_for_valid_number(US_INVALID_NUMBER, "en")) # Add in some script and region specific fictional names TEST_GEOCODE_DATA['1650960'] = {'en': u("Mountain View, CA"), "en_GB": u("Mountain View California"), "en_US": u("Mountain View, Sunny California"), "en_Xyzz_US": u("MTV - xyzz"), "en_Latn": u("MountainView")} # The following test might one day return "Mountain View California" self.assertEqual("United States", description_for_number(US_NUMBER2, _ENGLISH, region="GB")) self.assertEqual("Mountain View, Sunny California", description_for_number(US_NUMBER2, _ENGLISH, region="US")) self.assertEqual("MountainView", description_for_number(US_NUMBER2, _ENGLISH, script="Latn")) self.assertEqual("United States", description_for_number(US_NUMBER2, _ENGLISH, script="Latn", region="GB")) self.assertEqual("MTV - xyzz", description_for_number(US_NUMBER2, _ENGLISH, script="Xyzz", region="US")) self.assertEqual("Mountain View, Sunny California", description_for_number(US_NUMBER2, _ENGLISH, script="Zazz", region="US")) # Get a different result when there is a script-specific variant self.assertEqual("MountainView", description_for_number(US_NUMBER2, _ENGLISH, script="Latn", region="US")) TEST_GEOCODE_DATA['1650960'] = {'en': u("Mountain View, CA")} # Test the locale mapping TEST_GEOCODE_DATA['8868'] = {'zh': u("Chinese"), 'zh_Hant': u("Hant-specific")} tw_number = FrozenPhoneNumber(country_code=886, national_number=810080123) self.assertEqual("Hant-specific", description_for_number(tw_number, "zh", region="TW")) del TEST_GEOCODE_DATA['8868']
def testGetDescriptionForNumberWithMissingPrefix(self): # Test that the name of the country is returned when the number passed in # is valid but not covered by the geocoding data file. self.assertEqual("United States", geocoder.description_for_number(US_NUMBER4, _ENGLISH, region=_USA))
def testGetDescriptionForNumberBelongingToMultipleCountriesIsEmpty(self): # Test that nothing is returned when the number passed in is valid but # not covered by the geocoding data file and belongs to multiple # countries self.assertEqual("", description_for_number(NANPA_TOLL_FREE, _ENGLISH, region=_USA))
def description(number): n = phonenumbers.parse(number, 'US') return description_for_number(n, 'en', region='US')
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 testGetDescriptionForInvalidNumber(self): self.assertEqual("", geocoder.description_for_number(KO_INVALID_NUMBER, _ENGLISH)) self.assertEqual("", geocoder.description_for_number(US_INVALID_NUMBER, _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