def get_df(): while True: try: first_msg = c.poll(10) mapa = first_msg.value() print(mapa) mapa['CODE'] = region_code_for_number( phonenumbers.parse('+' + str(int(mapa['CALLEE'])))) callee_country = pycountry.countries.get( alpha_2=region_code_for_number( phonenumbers.parse('+' + str(int(mapa['CALLEE']))))) mapa['CALLEE_COUNTRY'] = callee_country.name caller_country = pycountry.countries.get( alpha_2=region_code_for_number( phonenumbers.parse('+' + str(int(mapa['CALLER']))))) mapa['CALLER_COUNTRY'] = caller_country.name mapa['AVG_CALL_DURATION_LAST_1D'] = mapa[ 'TOTAL_CALL_DURATION_LAST_1D'] / ( mapa['CALLER_CALL_COUNT_LAST_1D'] + mapa['CALLEE_CALL_COUNT_LAST_1D']) if float(mapa['AVG_CALL_DURATION_LAST_1D']) > float( mapa['TOTAL_CALL_DURATION_LAST_1D']): continue values = [list(mapa.values())] #spremamo vrijednosti prve poruke columns = list(mapa.keys()) #spremamo atribute prve poruke df = pd.DataFrame(values, columns=columns) return df except: continue
def get_phone_number_object(self, data_string): """ Takes the data_string and tries to parse a phone number out of it :param data_string: data that might be a phone number :type data_string: str :return: phone number data if it's a phone number :rtype: dict """ try: check_region = (data_string[0] == "+") # First pass to see if it's a valid number num_obj = phonenumberutil.parse( data_string, _check_region=check_region ) num_desc = geocoder.description_for_valid_number( num_obj, "en" ).strip() except NumberParseException: # If we can't parse it out, it's not a valid number return False # if we weren't able to check the region, and we didn't get a # description we want to modify the data and give it another go # with a country code added if not check_region and not num_desc: prefix = None if len(self.digits) == 11 and data_string[0] == "1": prefix = "+" elif len(self.digits) == 10 \ and (data_string[0].isdigit() or data_string[0] in string.punctuation): prefix = "+1" if prefix: try: # Second pass to see if we can get an actual # geocode out of it using a hammer second_pass = phonenumberutil.parse(prefix + data_string) num_desc = geocoder.description_for_valid_number( second_pass, "en" ).strip() if num_desc: num_obj = second_pass # confidence hit because we had to # modify the data to get a result self.confidence -= 5 except (NumberParseException, Exception): pass # Attempting to get a valid region num_region = phonenumberutil.region_code_for_number(num_obj) # This is the compiled phone number data that # we will use for the confidence decision return self.build_phone_number_dict(num_obj, num_desc, num_region)
def twilioSMS(k,msg, count): # To check for country code pn = phonenumbers.parse(k) print pn.country_code country = pycountry.countries.get(alpha_2=region_code_for_number(pn)) yo = region_code_for_country_code(pn.country_code) # To get timezone for the specified country url = "http://api.timezonedb.com/v2/list-time-zone?key=" + API_Key + "&format=json&country=" + yo json_obj_places = urllib2.urlopen(url) places = json.load(json_obj_places) print places["zones"][0]["zoneName"] local_date = datetime.now(pytz.timezone(places["zones"][0]["zoneName"])) print local_date.time() hour = local_date.time().hour try: # To check whether the time is the night time or not if hour in range(7, 23): client = Client(account_sid, auth_token) message = client.messages.create(to=k, from_=my_twilio, body=msg) time.sleep( 60 ) print message.sid bappa = client.messages(message.sid).fetch() print(bappa.body) print(bappa.status) # Checking the status of the Message after 1 minute if not delivered or sent, sending again if bappa.status not in ["delivered", "sent"] and count<5: print bappa.status count = count +1 print count logging.basicConfig() time.sleep(2) obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Failed or Undelivered") obj.save() print "yoyo" time.sleep(5) twilioSMS(k,msg, count) else: #Saving to database in Night Time print "Night time" time.sleep(2) logging.basicConfig() obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Night Time") print obj obj.save() print "bappa" except: # Checking if the number is invalid print "yo bappa" obj = MessageLog(number=k, dateField=local_date.date(), timeField=local_date.time(), status="Not Sent") obj.save() print "error"
def region_code(self): """ Generate region code of phone number or None if it's invalid. """ code = None if self.is_valid(): code = region_code_for_number(self) return code
def phone_number_display(self): if not isinstance(self.phone_number, PhoneNumber): return self.phone_number if region_code_for_number( self.phone_number) == settings.PHONENUMBER_DEFAULT_REGION: return self.phone_number.as_national else: return self.phone_number.as_international
def country_hint(self, value: str) -> Optional[str]: try: number = parse_number(value) code = region_code_for_number(number) if code is None: return None return str(code).lower() except NumberParseException: return None
def format_value(self, value): if isinstance(value, PhoneNumber): number_region = region_code_for_number(value) if self.region != number_region: formatter = PhoneNumberFormat.INTERNATIONAL else: formatter = PhoneNumberFormat.NATIONAL return value.format_as(formatter) return super().format_value(value)
def _format_value(self, value): if isinstance(value, PhoneNumber): number_region = region_code_for_number(value) if self.region != number_region: formatter = PhoneNumberFormat.INTERNATIONAL else: formatter = PhoneNumberFormat.NATIONAL return value.format_as(formatter) return super(PhoneNumberInternationalFallbackWidget, self)._format_value(value)
def post(self, request, *args, **kwargs): data = request.data try: check_if_user_have_phone_registerd = Sim.objects.get( phone_number=data['phone']) if check_if_user_have_phone_registerd: user = User.objects.get( id=check_if_user_have_phone_registerd.fk_account.id) verification_code = str(randint(100000, 999999)) check_if_user_have_phone_registerd.verified_sim_code = verification_code check_if_user_have_phone_registerd.save() return JsonResponse({ 'status': 'not_verified', 'username': user.username }) except: username = uuid.uuid1( ) # make a UUID based on the host ID and current time username_hashed = hashlib.md5(( str(username)).encode()) # encode() : Converts the string into username_hashed = username_hashed.hexdigest( ) # bytes to be acceptable by hash function. user = User.objects.create_user(username=username_hashed, password='******', first_name=data['first_name'], last_name=data['last_name']) device = Device.objects.create( fk_account=AdditionalUserData.objects.get(user=user), device_uuid=data['device_uuid'], vendor=data['device_vender'], model=data['device_model'], os=data['device_platform']) pn = phonenumbers.parse(str(data['phone'])) country = pycountry.countries.get( alpha_2=region_code_for_number(pn)) verification_code = str(randint(100000, 999999)) sim = Sim.objects.create(fk_account=user, country=country.name, phone_number=data['phone'], verified_sim_code=verification_code) M2M_Device_Sim.objects.create(id_sim=sim, id_device=device, fk_account=user.id) data = { 'number': sim.phone_number, 'message': 'Your Events confirmation code is : ' + verification_code, 'type': 'reset password', 'uuid': 'events', 'status': 0, } r = requests.post(url=settings.SMSSERVER, data=data) return JsonResponse({ 'status': 'not_verified', 'username': username_hashed })
def __get_country_by_phone(self, phone): if phone == None: return {} pn = phonenumbers.parse(phone) country = pycountry.countries.get(alpha_2=region_code_for_number(pn)) return { 'region_code': region_code_for_country_code(pn.country_code), 'country': country.name }
def run(self, users): self.country_count = {} for user in users: pn = phonenumbers.parse('+' + str(user)) country = pycountry.countries.get( alpha_2=region_code_for_number(pn)).name if country not in self.country_count: self.country_count[country] = 0 self.country_count[country] += 1 return {"user_counties_count": len(self.country_count)}
def get_phone_number_object(self, data_string): """Takes the data_string and tries to parse a phone number out of it""" try: check_region = (data_string[0] == "+") # First pass to see if it's a valid number num_obj = phonenumberutil.parse( data_string, _check_region=check_region ) num_desc = geocoder.description_for_valid_number( num_obj, "en" ).strip() except NumberParseException: # If we can't parse it out, it's not a valid number return False # if we weren't able to check the region, and we didn't get a # description we want to modify the data and give it another go # with a country code added if not check_region and not num_desc: prefix = None if len(self.digits) == 11 and data_string[0] == "1": prefix = "+" elif len(self.digits) == 10 \ and (data_string[0].isdigit() or data_string[0] in string.punctuation): prefix = "+1" if prefix: try: # Second pass to see if we can get an actual # geocode out of it using a hammer second_pass = phonenumberutil.parse(prefix + data_string) num_desc = geocoder.description_for_valid_number( second_pass, "en" ).strip() if num_desc: num_obj = second_pass # confidence hit because we had to # modify the data to get a result self.confidence -= 5 except (NumberParseException, Exception): pass # Attempting to get a valid region num_region = phonenumberutil.region_code_for_number(num_obj) # This is the compiled phone number data that # we will use for the confidence decision return self.build_phone_number_dict(num_obj, num_desc, num_region)
def _format_phonenumber(value): number_region = region_code_for_number(value) if DEFAULT_REGION != number_region: formatter = PhoneNumberFormat.INTERNATIONAL else: formatter = PhoneNumberFormat.NATIONAL fv = value.format_as(formatter) # use the raw input if all else fails... # (Can happen when PHONENUMBER_DEFAULT_REGION is not set) if fv is None or fv == "None": fv = value.raw_input return fv
def get_existing_numbers(self, org): client = org.get_twilio_client() if client: twilio_account_numbers = client.api.incoming_phone_numbers.stream(page_size=1000) numbers = [] for number in twilio_account_numbers: parsed = phonenumbers.parse(number.phone_number, None) numbers.append( dict( number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL), country=region_code_for_number(parsed), ) ) return numbers
def get_existing_numbers(self, org): client = org.get_twilio_client() if client: twilio_account_numbers = client.phone_numbers.list(page_size=1000) twilio_short_codes = client.sms.short_codes.list(page_size=1000) numbers = [] for number in twilio_account_numbers: parsed = phonenumbers.parse(number.phone_number, None) numbers.append(dict(number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL), country=region_code_for_number(parsed))) org_country = timezone_to_country_code(org.timezone) for number in twilio_short_codes: numbers.append(dict(number=number.short_code, country=org_country)) return numbers
def get_existing_numbers(self, org): client = org.get_twilio_client() if client: twilio_account_numbers = client.api.incoming_phone_numbers.stream(page_size=1000) twilio_short_codes = client.api.short_codes.stream(page_size=1000) numbers = [] for number in twilio_account_numbers: parsed = phonenumbers.parse(number.phone_number, None) numbers.append( dict( number=phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL), country=region_code_for_number(parsed), ) ) org_country = timezone_to_country_code(org.timezone) for number in twilio_short_codes: numbers.append(dict(number=number.short_code, country=org_country)) return numbers
def e164_to_e212(number, verbose=0): if number[0] != "+": number = "+" + number try: parsed = parse_number(number) if verbose > 1: print("number info: " + str(parsed)) country = phonenumberutil.region_code_for_number(parsed) if not country: country = phone_iso3166.country.phone_country(number) if country in countries: country2 = countries[country] if verbose > 0: print(" country: " + country + " -> " + country2) country = country2 else: if verbose > 0: print(" country: " + country) networks = phone_iso3166.network.country_networks(country) if verbose > 0: print(" networks: " + str(networks)) name = phonenumbers.carrier.name_for_valid_number(parsed, "en").lower() if verbose > 0: print(" name: " + str(name)) if not name: return ("error", "name_not_found") names = name.split("/") found = [] for name in names: for (mcc, mnc, ntw) in networks: if ntw.lower().find(name) != -1: found.append("{}{:02d}".format(mcc, mnc)) if found: return ("ok", found) else: return ("error", "id_not_found") except Exception as e: print(number) raise
def geo(request): res = {} status_code = 200 if request.method == 'GET': if 'number' in request.GET: number = request.GET['number'] country = '' if 'country' in request.GET: country = request.GET['country'] tmpphone = cleaner(number, country.upper()) try: parse_number = phonenumbers.parse(tmpphone, country.upper()) except NumberParseException: try: if not tmpphone.startswith('+'): tmpphone = '+' + tmpphone parse_number = phonenumbers.parse(tmpphone, None) except NumberParseException: c = get_object_or_404(Country, iata=country.upper()) try: parse_number = phonenumbers.parse( '+' + c.code + tmpphone.replace('+', ''), country.upper()) except: raise Http404( 'Country {0} does not match with number'.format( country.upper())) if not phonenumbers.is_valid_number(parse_number) and country: c = get_object_or_404(Country, iata=country.upper()) try: parse_number = phonenumbers.parse( '+' + c.code + tmpphone.replace('+', ''), country.upper()) except: raise Http404( 'Country {0} does not match with number'.format( country.upper())) if country.upper() == 'AR' or tmpphone.startswith('+54'): parse_number = format_ar_number(tmpphone) if Country.objects.filter(code='54').exists(): country_object = Country.objects.get(code='54') mobile_code = country_object.mobile_code trunk_prefix = country_object.trunk_prefix else: mobile_code = '15' trunk_prefix = '0' national_number = parse_number['discable'] region_code = parse_number['interurban'] country_code = parse_number['country'] number_type = parse_number['type'] is_valid = True if number_type != PhoneNumberType.UNKNOWN else False location = parse_number['location'] country = 'Argentina' country_iata = 'AR' tmpcarrier = parse_number['carrier'] urbano = parse_number['urban'] linea = parse_number['line'] local_number = parse_number['urban'] + parse_number['line'] is_posible = True if number_type != PhoneNumberType.UNKNOWN else False dial_number = phonenumbers.format_number( phonenumbers.parse('+' + country_code + national_number, None), phonenumbers.PhoneNumberFormat.E164) else: national_number = local_number = str( parse_number.national_number) region_code = '' country_code = str(parse_number.country_code) number_type = carrier.number_type(parse_number) is_valid = phonenumbers.is_valid_number(parse_number) location = geocoder.description_for_number(parse_number, 'EN') country = geocoder.country_name_for_number(parse_number, 'EN') country_iata = region_code_for_number(parse_number) tmpcarrier = carrier.name_for_valid_number(parse_number, 'EN') is_posible = phonenumbers.is_possible_number(parse_number) urbano = '' linea = '' mobile_code = '' trunk_prefix = '' dial_number = phonenumbers.format_number( parse_number, phonenumbers.PhoneNumberFormat.E164) if Country.objects.filter(code=country_code).exists(): country_object = Country.objects.filter(code=country_code) if len(country_object) == 1: country_object = country_object[0] country = country_object.name mobile_code = country_object.mobile_code trunk_prefix = country_object.trunk_prefix for i in range(1, 5): sub = local_number[:i] if AreaCode.objects.filter(country=country_object, code=sub).exists(): ac = AreaCode.objects.get( country=country_object, code=sub) location = ac.name local_number = local_number[i:] region_code = ac.code break if country_code == '52' and is_valid: parse_mx_number = format_mx_number(region_code, local_number) urbano = parse_mx_number['urban'] linea = parse_mx_number['line'] number_type = parse_mx_number['type'] if is_posible: res = { 'is_valid': is_valid, 'location': location, 'country': country, 'country_iata': country_iata, 'carrier': tmpcarrier, 'type': number_type, 'dial_number': dial_number, 'urban': urbano, 'line': linea, 'is_posible': is_posible, 'ori_number': number, 'number_data': { 'CC': country_code, 'NN': national_number, 'AC': region_code, 'LN': local_number, 'MC': mobile_code, 'IM': True if number_type == 1 else (True if location == 'Mobile' else False), 'TP': trunk_prefix, 'IN': dial_number.replace('+', '').strip() } } else: status_code = 400 res.update({'code': status_code, 'message': 'invalid number'}) else: status_code = 400 res.update({ 'code': status_code, 'message': 'some arguments missing' }) else: status_code = 405 res.update({ 'code': status_code, 'message': 'illegal request method ' + str(request.method) }) response = JsonResponse(res) response.status_code = status_code return response
def country_parser(y): try: return (pycountry.countries.get( alpha2=region_code_for_number(y)).name) except: " "
def get_country_iso_code(phone_object): return region_code_for_number(phone_object)