def validate(self, value, force=False): if has_phonenumbers: try: phonenumbers.parse(value, None) except NumberParseException as e: raise Invalid(_(unicode(e._msg))) return super(PhoneWidgetValidator, self).validate(value, force)
def valid(number, country_code=None): """Determine whether or not a phone number is valid.""" try: phonenumbers.parse(number, country_code) return True except Exception: return False
def to_python(self, value, *args, **kwargs): """ Convert value from National US phone number to international """ if value in validators.EMPTY_VALUES: value = None else: # Parse the value try: if value.startswith("+"): value = phonenumbers.parse(value) else: value = phonenumbers.parse(value, "US") except phonenumbers.phonenumberutil.NumberParseException: value = phonenumbers.PhoneNumber(raw_input=value) # Produce international format without formatting. value = "+{country_code}{national_number}".format( country_code=value.country_code, national_number=value.national_number ) try: return super(LocalPhoneNumberField, self).to_python( value, *args, **kwargs ) except: raise exceptions.ValidationError("Please enter a phone number in the format (xxx) xxx-xxxx", code="invalid")
def save(self, *args, **kwargs): if self.phone_work: self.phone_work = phonenumbers.format_number(phonenumbers.parse(self.phone_work, 'US'), phonenumbers.PhoneNumberFormat.E164) if self.phone_mobile: self.phone_mobile = phonenumbers.format_number(phonenumbers.parse(self.phone_mobile, 'US'), phonenumbers.PhoneNumberFormat.E164) self.email = self.email.lower() super(Person, self).save(*args, **kwargs)
def phone_number(number, region_code=None, pattern=None, number_format=None, prefix_format=None): """ for number +995595119925 pattern="(\\d{3})(\\d{2})(\\d{2})(\\d{2})", format="\\1 \\2-\\3-\\4" result 595 11-99-25 """ if pattern is None or number_format is None or prefix_format is None: return number if type(number) is PhoneNumber: try: number = phonenumbers.parse(number.phone_number, number.region_code) except: return number elif type(number) is str: if region_code is None: return number try: number = phonenumbers.parse(number, region_code) except: return number new_number_format = NumberFormat(pattern=pattern, format=number_format) new_number_format._mutable = True new_number_format.national_prefix_formatting_rule = prefix_format % (number.country_code, '$FG') new_number_formats = [new_number_format] return phonenumbers.format_by_pattern( number, phonenumbers.PhoneNumberFormat.NATIONAL, new_number_formats )
def is_a_phone(value, key=None, pos=None): value = str(value).strip() if len(value) > 20: return False """Check for international numbers""" if value.startswith('+'): try: phonenumbers.parse(value) return True except: return False """Otherwise let's hope it's a US number""" reg = re.compile(".*?(\(?\d{3}\D{0,3}\d{3}\D{0,3}\d{4}).*?", re.S) matches = reg.search(value) """We're not looking for text fields that contain phone numbers, only fields that are dedicated to phone number""" if matches and len(matches.group(1)) == len(value): return True return False
def from_string(cls, phone_number, region=None): phone_number_obj = cls() if region is None: region = getattr(settings, 'PHONENUMBER_DEFAULT_REGION', None) phonenumbers.parse(number=phone_number, region=region, keep_raw_input=True, numobj=phone_number_obj) return phone_number_obj
def create(self, validated_data): caller = validated_data['caller'] destination = validated_data['destination'] if validated_data['direction'] == 'outbound': # Because of GRID-4965, the API returns the destination number in the same format user inserted it, # so if country code is missing let's patch it with the one from the caller number. if not destination['number'].startswith('+'): if caller['number'].startswith('+'): try: caller_number = phonenumbers.parse(caller['number'], None) country_code = get_country_code_by_country( geocoder.country_name_for_number(caller_number, 'en') ) destination_number = phonenumbers.parse(destination['number'], country_code) if phonenumbers.is_valid_number(destination_number): destination['number'] = phonenumbers.format_number( destination_number, phonenumbers.PhoneNumberFormat.E164 ) except NumberParseException, e: logger.error(traceback.format_exc(e)) data = self.match_external_participant(destination) if not data['source']: # We don't save outbound calls where the destination isn't an account or a contact. # This is the only reliable way to filter out internal calls. return CallRecord()
def test_is_valid_number(self): p = phonenumbers.parse('+1123456789') self.assertFalse(phonenumbers.is_possible_number(p)) self.assertFalse(phonenumbers.is_valid_number(p)) p = phonenumbers.parse('+17184734811') self.assertTrue(phonenumbers.is_possible_number(p)) self.assertTrue(phonenumbers.is_valid_number(p))
def unify_phone(origin_phone): try: try: phone = pn.parse(origin_phone) except NumberParseException: phone = pn.parse(origin_phone, 'RU') return pn.format_number(phone, pn.PhoneNumberFormat.INTERNATIONAL) except NameError: raise ImportError('django-phonenumber-field module is not available')
def from_string(cls, phone_number): phone_number_obj = cls() region = getattr(settings, 'PHONENUMER_DEFAULT_REGION', None) if not region: language_code = getattr(settings, 'LANGUAGE_CODE', None) if language_code: region = language_code.upper() phonenumbers.parse(number=phone_number, region=region, keep_raw_input=True, numobj=phone_number_obj) return phone_number_obj
def phone_controll(phone): numero_tel = None #On controlle qu'il y a un plus au début, sinon il faut donner la localisation if phone[0] == "+": #Si jamais il y a un pb avec le parsage try: number = phonenumbers.parse(phone, None) #On vérifie que le nombre est valide if phonenumbers.is_valid_number(number): numero_tel = {} numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164) numero_tel["country"] = phonenumbers.region_code_for_number(number) return numero_tel else: return numero_tel except phonenumbers.phonenumberutil.NumberParseException: return numero_tel #Sinon on doit donner une localisation else: try: number = phonenumbers.parse(phone, "FR") #On vérifie que le nombre est valide if phonenumbers.is_valid_number(number): numero_tel = {} numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164) numero_tel["country"] = phonenumbers.region_code_for_number(number) return numero_tel elif phone.startswith("07"): numero_tel = {} numero_tel["number"] = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164) numero_tel["country"] = phonenumbers.region_code_for_number(number) return numero_tel else: return numero_tel except phonenumbers.phonenumberutil.NumberParseException: return numero_tel
def format_phone(dct): num_obj = None if dct.get("country_code") and dct.get("phone"): num_obj = phonenumbers.parse("+{country_code} {phone}".format(**dct)) elif dct.get("From"): num_obj = phonenumbers.parse(dct.get("From")) if num_obj: number = phonenumbers.format_number_for_mobile_dialing(num_obj, "us", True) return number else: return ""
def format_phone(dct): num_obj = None if dct.get('country_code') and dct.get('phone'): num_obj = phonenumbers.parse('+{country_code} {phone}'.format(**dct)) elif dct.get('From'): num_obj = phonenumbers.parse(dct.get('From')) if num_obj: number = phonenumbers.format_number_for_mobile_dialing(num_obj, 'us', True) return number else: return ''
def __init__(self, nr): self.phone_number = sub(r'\s', '', str(nr)) self.phone_number = sub(r'/', '', self.phone_number) self.phone_number = sub(r'\-', '', self.phone_number) self.phone_number = sub(r'\(', '', self.phone_number) self.phone_number = sub(r'\)', '', self.phone_number) self.phone_number = sub(r'\\', '', self.phone_number) try: self.phone_number = phonenumbers.parse(self.phone_number, None) except NumberParseException: self.phone_number = phonenumbers.parse(self.phone_number, 'DE') finally: return None return self.phone_number
def get_normalized_phone_review(me): try: if 'phones' in me.keys(): if len(me['phones']): if len(me['phones']) > 1: return( phonenumbers.format_number(phonenumbers.parse(me['phones'][0], 'US'), phonenumbers.PhoneNumberFormat.NATIONAL)) else: return( phonenumbers.format_number(phonenumbers.parse(me['phones'][0], 'US'), phonenumbers.PhoneNumberFormat.NATIONAL)) else: return np.nan else: return np.nan except: return np.nan
def phoneformat(phone_number, phone_format='INTERNATIONAL'): try: parsed_number = parse(phone_number, None) format = getattr(PhoneNumberFormat, phone_format) return format_number(parsed_number, format) except NumberParseException: return phone_number
def normalize_number(number, country_code): """ Normalizes the passed in number, they should be only digits, some backends prepend + and maybe crazy users put in dashes or parentheses in the console. :param number: the number, e.g. "0783835665" :param country_code: the 2-letter country code, e.g. "RW" :return: a tuple of the normalized number and whether it looks like a possible full international number """ # if the number ends with e11, then that is Excel corrupting it, remove it if number.lower().endswith("e+11") or number.lower().endswith("e+12"): number = number[0:-4].replace('.', '') # remove other characters number = regex.sub('[^0-9a-z\+]', '', number.lower(), regex.V0) # add on a plus if it looks like it could be a fully qualified number if len(number) >= 11 and number[0] != '+': number = '+' + number try: normalized = phonenumbers.parse(number, str(country_code) if country_code else None) # now does it look plausible? if phonenumbers.is_possible_number(normalized): return phonenumbers.format_number(normalized, phonenumbers.PhoneNumberFormat.E164), True except Exception: pass # this must be a local number of some kind, just lowercase and save return regex.sub('[^0-9a-z]', '', number.lower(), regex.V0), False
def valid_us_phone(phone): try: phone_number = phonenumbers.parse(phone, "US") if len(str(phone_number.national_number)) == 10 and phone_number.country_code == 1: return except phonenumbers.phonenumberutil.NumberParseException, e: pass
def clean(self): cd = super(CustomerForm, self).clean() phone = cd.get('phone') country = cd.get('country') if len(phone) < 1: return cd try: phonenumbers.parse(phone, country) except phonenumbers.NumberParseException: msg = _('Enter a valid phone number') self._errors["phone"] = self.error_class([msg]) return cd
def _reformat_number( self, cr, uid, erp_number, fs_server=None, context=None): ''' This function is dedicated to the transformation of the number available in OpenERP to the number that FreeSWITCH should dial. You may have to inherit this function in another module specific for your company if you are not happy with the way I reformat the OpenERP numbers. ''' assert(erp_number), 'Missing phone number' _logger.debug('Number before reformat = %s' % erp_number) if not fs_server: fs_server = self._get_freeswitch_server_from_user( cr, uid, context=context) # erp_number are supposed to be in E.164 format, so no need to # give a country code here parsed_num = phonenumbers.parse(erp_number, None) country_code = fs_server.company_id.country_id.code assert(country_code), 'Missing country on company' _logger.debug('Country code = %s' % country_code) to_dial_number = phonenumbers.format_out_of_country_calling_number( parsed_num, country_code.upper()).replace(' ', '').replace('-', '').replace('(', '').replace(')', '') # Add 'out prefix' to all numbers if fs_server.out_prefix: _logger.debug('Out prefix = %s' % fs_server.out_prefix) to_dial_number = '%s%s' % (fs_server.out_prefix, to_dial_number) _logger.debug('Number to be sent to FreeSWITCH = %s' % to_dial_number) return to_dial_number
def get_phone(cls, bot): """ Get a standardized phone number """ try: x = phonenumbers.parse(bot.phone_number, "US") return phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.INTERNATIONAL) except: return "None"
def validate_phone(self, value, context=None): try: number = phonenumbers.parse(value, None) phone_format = phonenumbers.PhoneNumberFormat.INTERNATIONAL return phonenumbers.format_number(number, phone_format) except Exception as exc: raise ValidationError(exc.message)
def validatePhoneNumber(number): valid = False try: # Leave shortcodes alone. if number is not None: if len(number) in (3, 4, 5, 6) and number.isdigit(): return True # it's okay to search for the region US for all US/Can b/c they share # the same parsing/formatting rules p = phonenumbers.parse(number, 'US') # but we need to check the number is valid in either country if phonenumbers.is_valid_number_for_region(p, 'US') or \ phonenumbers.is_valid_number_for_region(p, 'CA'): phonenumbers.format_number( p, phonenumbers.PhoneNumberFormat.E164 ) valid = True except phonenumbers.NumberParseException as e: logging.error('Detected invalid phone number: {0}-{1}'.format( number, e)) return valid
def as_phone_number(value): if not value or isinstance(value, PhoneNumber): return value try: return phonenumbers.parse(value, settings.DEFAULT_TELEPHONE_COUNTRY_CODE) except NumberParseException: return PhoneNumber()
def create(request): form = AppointmentForm() if request.POST: form = AppointmentForm(request.POST) if form.is_valid(): phone_representation = phonenumbers.parse(form.cleaned_data['phone_number'], "US") phone_formatted = str(phonenumbers.format_number(phone_representation, phonenumbers.PhoneNumberFormat.E164)) # get phone owner (or create then) patient = Patient.objects.get_or_create(phone_number=phone_formatted)[0] # make sure appointment date is in the future now = datetime.utcnow().replace(tzinfo=utc) app_date = form.cleaned_data['date'] if now < app_date: appointment = Appointment( owner=patient, date = app_date, ) appointment.save() patient.send_sms('You added an appointment!') return HttpResponseRedirect(reverse(detail, kwargs={ 'appointment_id':appointment.id, })) return render_to_response('appointments/create.html',{ 'form':form, },context_instance=RequestContext(request))
def __build_phone(self, param): # XXX TOFIX _vcard_types = { 'text': 'other', 'voice': 'other', 'fax': 'fax', 'cell': 'mobile', 'video': 'other', 'pager': 'pager', 'textphone': 'other', } phone = NewPhone() phone.number = param.value if 'TYPE' in param.params and param.params['TYPE']: phone_type = param.params['TYPE'][0].lower() if phone_type in _vcard_types: phone.type = _vcard_types[phone_type] else: phone.type = 'other' if 'PREF' in param.params: phone.is_primary = True try: number = phonenumbers.parse(phone.number, None) phone_format = phonenumbers.PhoneNumberFormat.INTERNATIONAL normalized = phonenumbers.format_number(number, phone_format) if normalized: phone.normalized_number = normalized except: pass return phone
def send_sms(destination_phone, message, sender_phone=None): """ destination_phone must be formatted as international E164 sender_phone must be formatted as international E164, or it may be "None" Note that the system will make a "best effort" to make the SMS appear to be sent from sender_phone, but it may not succeed """ p = phonenumbers.parse(destination_phone) if in_testing_mode(): # During unit tests, don't actually send any SMS messages. Instead, # keep a record of sent SMS's in the testing outbox if hasattr(send_sms, 'testing_outbox'): send_sms.testing_outbox.append((destination_phone, message, sender_phone)) return # Don't actually send any SMS messages for test numbers if is_test_number(p): return default_sender = send_sms_twilio country_overrides = { COUNTRY_CODE_ISRAEL: send_sms_smartsms } sender = country_overrides.get(p.country_code, default_sender) sender(p, message, sender_phone)
def generic_phonenumber_to_e164( self, cr, uid, ids, field_from_to_seq, context=None): result = {} from_field_seq = [item[0] for item in field_from_to_seq] for record in self.read(cr, uid, ids, from_field_seq, context=context): result[record['id']] = {} for fromfield, tofield in field_from_to_seq: if not record.get(fromfield): res = False else: try: res = phonenumbers.format_number( phonenumbers.parse(record.get(fromfield), None), phonenumbers.PhoneNumberFormat.E164) except Exception, e: _logger.error( "Cannot reformat the phone number '%s' to E.164 " "format. Error message: %s" % (record.get(fromfield), e)) _logger.error( "You should fix this number and run the wizard " "'Reformat all phone numbers' from the menu " "Settings > Configuration > Phones") # If I raise an exception here, it won't be possible to # install the module on a DB with bad phone numbers res = False result[record['id']][tofield] = res
def _format_phone_number_entry(self, entry): """ Takes a phone number, and adds a default country prefix to it if missing. It is assumed that phone numbers lacking a prefix, is from the default region defined in the configuration. :param unicode : A phone number :return: A phone number with a country prefix, or None :rtype: unicode """ def warn(): self.logger.warning( "CIMDataSource: Invalid phone number for person_id:{}, " "account_name:{}: {} {!r}".format( self.pe.entity_id, self.ac.account_name, str(self.co.ContactInfo(entry['contact_type'])), phone_number)) phone_number = entry['contact_value'] try: parsed_nr = phonenumbers.parse( number=phone_number, region=self.config.phone_country_default) if phonenumbers.is_valid_number(parsed_nr): return phonenumbers.format_number( numobj=parsed_nr, num_format=phonenumbers.PhoneNumberFormat.E164) else: warn() except (phonenumbers.NumberParseException, UnicodeDecodeError): warn() return None
def signup(): error = None if request.method == 'POST': addresslist = [] try: _username = str(request.form['username']) _password = str(request.form['password']) except: error = 'There is an error with your username/password.' return render_template('signup.html', error=error) try: phonenumber = str(request.form['phonenumber']) print phonenumber phonenumObject = ph.parse(phonenumber, None) if not ph.is_valid_number(phonenumObject): raise Exception except: error = 'Invalid Phone Number.' return render_template('signup.html', error=error) _phonenumber = str( ph.format_number(phonenumObject, ph.PhoneNumberFormat.E164)) try: _address1 = str(request.form['address1']) _starttime1 = int(request.form['starttime1']) _endtime1 = int(request.form['endtime1']) # parse address into lat lng try: geocode_result = gmaps.geocode(_address1) if len(geocode_result) == 0: raise Exception #get the lat,long of the address _addresspoint1 = geocode_result[0]['geometry'][ 'location'].values( )[0], geocode_result[0]['geometry']['location'].values()[1] #the _addresspoint1 tuple is flipped around because PostGIS uses long,lat instead of lat,long cur.execute( "SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)".format( _addresspoint1[1], _addresspoint1[0])) _geog1 = cur.fetchall()[0][0] except: error = "First address is invalid.{}".format(_addresspoint1) return render_template('signup.html', error=error) if _starttime1 >= _endtime1: raise Exception addresslist.append( [_address1, _addresspoint1, _starttime1, _endtime1, _geog1]) except: error = "There is an issue with your first address/timings." return render_template('signup.html', error=error) if request.form['address2']: try: _address2 = str(request.form['address2']) _starttime2 = int(request.form['starttime2']) _endtime2 = int(request.form['endtime2']) #parse address into lat long here try: geocode_result = gmaps.geocode(_address2) if len(geocode_result) == 0: raise Exception _addresspoint2 = geocode_result[0]['geometry'][ 'location'].values()[0], geocode_result[0]['geometry'][ 'location'].values()[1] cur.execute( "SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)". format(_addresspoint2[1], _addresspoint2[0])) _geog2 = cur.fetchall()[0][0] except: error = "Second address is invalid." return render_template('signup.html', error=error) if _starttime2 >= _endtime2: raise Exception addresslist.append([ _address2, _addresspoint2, _starttime2, _endtime2, _geog2 ]) except: error = "There is an issue with your second address/timings." return render_template('signup.html', error=error) if request.form['address3']: try: _address3 = str(request.form['address3']) _starttime3 = int(request.form['starttime3']) _endtime3 = int(request.form['endtime3']) #parse address into lat long here try: geocode_result = gmaps.geocode(_address3) if len(geocode_result) == 0: raise Exception _addresspoint3 = geocode_result[0]['geometry'][ 'location'].values()[0], geocode_result[0]['geometry'][ 'location'].values()[1] cur.execute( "SELECT ST_SetSRID(ST_MakePoint('{}', '{}'), 4326)". format(_addresspoint3[1], _addresspoint3[0])) _geog3 = cur.fetchall()[0][0] except: error = "Third address is invalid." return render_template('signup.html', error=error) if _starttime3 >= _endtime3: raise Exception addresslist.append([ _address3, _addresspoint3, _starttime3, _endtime3, _geog3 ]) except: error = "There is an issue with your third address/timings." return render_template('signup.html', error=error) try: file = request.files['file'] _filename = file.filename print _filename _filedata = db.Binary(file.read()) except: error = "There is an issue with your uploaded file.{}".format( request.form) return render_template('signup.html', error=error) # try: cur.execute( "INSERT INTO medics (username, password, phonenumber, active, filename, filedata, validated, pending)\ VALUES ('{}', '{}', '{}', True, '{}', {}, False, True)".format( _username, _password, _phonenumber, _filename, _filedata)) for infolist in addresslist: cur.execute( "INSERT INTO addresses (username, address, addresspoint, starttime, endtime, geog)\ VALUES('{}', '{}', '{}', '{}', '{}', '{}')".format( _username, infolist[0], infolist[1], infolist[2], infolist[3], infolist[4])) # except: # error = 'Unable to insert into database.' # return render_template('signup.html', error=error) session['username'] = _username con.commit() return redirect('user/' + session['username']) return render_template('signup.html')
def phone_validator(num): parsed = phonenumbers.parse(num, "US") if not phonenumbers.is_valid_number(parsed): raise ValidationError('Must be a valid US phone number.') return num
import phonenumbers from phonenumbers import geocoder, carrier given_No = input("Enter the no:") number = phonenumbers.parse(given_No) print(carrier.name_for_number(number, "en")) print(geocoder.description_for_number(number, "en")) if phonenumbers.is_valid_number(number) == False: print("Not a valid number") Y = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.INTERNATIONAL) print(Y)
def migrate_person(self, person, occurrences, episodes): self.total_persons += 1 occurrence = self.get_open_occurrence(occurrences) if occurrence: episodes = [case for case in episodes if not case.closed and case.type == CASE_TYPE_EPISODE and any([index.referenced_id == occurrence.case_id for index in case.indices])] episode = episodes[0] if episodes else None else: episode = None props = { 'updated_by_migration': 'enikshay_2b_case_properties', 'enrolled_in_private': 'false', 'case_version': '20', 'area': person.get_case_property('phi_area'), 'language_code': 'hin', 'referred_outside_enikshay_date': person.get_case_property('date_referred_out'), 'referred_outside_enikshay_by_id': person.get_case_property('referred_by_id'), } if episode: props.update({ 'current_episode_type': episode.get_case_property('episode_type'), 'alcohol_history': episode.get_case_property('alcohol_history'), 'alcohol_deaddiction': episode.get_case_property('alcohol_deaddiction'), 'tobacco_user': episode.get_case_property('tobacco_user'), 'occupation': episode.get_case_property('occupation'), 'phone_number_other': episode.get_case_property('phone_number_other'), }) phone_number = person.get_case_property('phone_number') if phone_number: props['contact_phone_number'] = strip_plus( phonenumbers.format_number( phonenumbers.parse(phone_number, "IN"), phonenumbers.PhoneNumberFormat.E164) ) location = self.locations.get(person.owner_id) if location: dataset = 'real' if location.metadata.get('is_test') == 'no' else 'test' props['dataset'] = person.get_case_property('dataset') or dataset if location.location_type.code == 'phi': props['phi_name'] = location.name ancestors_by_type = self.get_ancestors_by_type(location) if 'tu' in ancestors_by_type: props['tu_name'] = ancestors_by_type['tu'].name props['tu_id'] = ancestors_by_type['tu'].location_id if 'dto' in ancestors_by_type: props['dto_name'] = ancestors_by_type['dto'].name props['dto_id'] = ancestors_by_type['dto'].location_id return CaseStructure( case_id=person.case_id, walk_related=False, attrs={ "create": False, "owner_id": person.owner_id or '-', "update": props, }, )
addresslocation = input("Enter your Address here :") geolocator = Nominatim(user_agent="Curriculum_Validator") location = geolocator.geocode(addresslocation) try: location.latitude a0 = 1 except: a0 = 0 import phonenumbers from phonenumbers import carrier from phonenumbers.phonenumberutil import number_type number = input("Enter your phone number with country code :") try: if (carrier._is_mobile(number_type(phonenumbers.parse(number)))): a1 = 1 else: a1 = 0 except: a1 = 0 emailid = input("Enter your email-id :") is_valid = validate_email(emailid, verify=True) if is_valid == True: a3 = 1 else: a3 = 0 qual = input("Enter your qualification :") qual_List = ['b.tech', 'b.e', 'B.Tech', 'B.E']
def normalize_phone_number(num): return format_number(parse(num.decode('utf-8'), 'US'), PhoneNumberFormat.INTERNATIONAL)
def get_formatted_phone(phone): return phonenumbers.format_number(phonenumbers.parse(phone), phonenumbers.PhoneNumberFormat.E164)
#0645632754 #import phone_iso3166 import pycountry import tkinter from phone_iso3166.country import phone_country import phonenumbers from phonenumbers import geocoder, carrier number = "33645632754" code = phone_country(number) print("code=" + code) C = pycountry.countries.get(alpha_2=code) print("C={}".format(C)) print("getitng continent") ch_number = phonenumbers.parse(number, "CH") #country name print("ch_number={}".format(ch_number)) print("geocoder={}".format(geocoder.description_for_number(ch_number, "en"))) print("getting operator") service_number = phonenumbers.parse(number, "RO") print("carrier={}".format(carrier.name_for_number(service_number, "en")))
import phonenumbers from phonenumbers import geocoder from phonenumbers import carrier number = input('Enter Number (With Country Code): ') ch_num = phonenumbers.parse(number, 'CH') print(geocoder.description_for_number(ch_num, 'en')) service_pro = phonenumbers.parse(number, 'RO') print(carrier.name_for_number(service_pro, 'en'))
import phonenumbers from phonenumbers import carrier mobileNo = input('Enter Mobile Number With Country Code : ') service_provider = phonenumbers.parse(mobileNo) print(carrier.name_for_number(service_provider, "en"))
print("Devloped By C15C01337 (Bishal Aryal)") print("Follow me on Twitter username @C15C01337") import phonenumbers #pip install phonenumbers number = input("Enter your number with country code:") from phonenumbers import geocoder ch_number = phonenumbers.parse(number, "CH") print(geocoder.description_for_number(ch_number, "en")) from phonenumbers import carrier service_number = phonenumbers.parse(number, "RO") print(carrier.name_for_number(service_number, "en"))
import phonenumbers from phonenumbers import geocoder, carrier inp_numero = input('Número: ') try: numero = phonenumbers.parse(inp_numero) operadora = carrier.name_for_number(numero, 'pt-br') regiao = geocoder.description_for_number(numero, 'pt-br') print(f'\n\nOperadora: {operadora}\nEstado: {regiao}') except: print('\n\nAlgo deu errado.')
import phonenumbers from phonenumbers import carrier from phonenumbers import geocoder import sys print("Enter your phonenumber with country code: ") number = sys.argv[1] if len(number) < 1: print("No Number") exit() else: x = phonenumbers.parse(number) print(x) print("Carrier: " + carrier.name_for_number(x, 'en')) print("Location: " + geocoder.description_for_number(x, 'en'))
def get_users(app): USERS_BLACKLIST = os.getenv('USERS_BLACKLIST', '').split(',') SLACK_TOKEN = os.getenv('SLACK_TOKEN') if not SLACK_TOKEN: raise Exception('SLACK_TOKEN not defined!') sc = SlackClient(SLACK_TOKEN) try: users = sc.api_call("users.list")['members'] except Exception: raise Exception('Can not get Slack user list!') # Get users and keep only active members active_users = [] # Compute users list for user in users: # Exclude deleted users if user['deleted'] == True: app.logger.debug('Skip deleted user: %s', user['name']) continue # Exclude bot users if user['is_bot'] == True: app.logger.debug('Skip bot user: %s', user['name']) continue # Exclude users in blacklist if user['name'] in USERS_BLACKLIST: app.logger.debug('Skip blacklisted user: %s', user['name']) continue # Format phone number if 'phone' in user['profile'] and user['profile']['phone']: try: phone_number = phonenumbers.parse(user['profile']['phone'], "FR") user['profile']['phone'] = phonenumbers.format_number( phone_number, phonenumbers.PhoneNumberFormat.NATIONAL) user['profile']['phone_link'] = phonenumbers.format_number( phone_number, phonenumbers.PhoneNumberFormat.E164) except Exception: app.logger.warning('Invalid phone number "%s" for user "%s"!', user['profile']['phone'], user['name']) # According to Slack documentation (https://api.slack.com/methods/users.list), # Only the image_* fields are guaranteed to be included in user profile # So we need to check all user profile fields active_users.append({ 'id': user['id'], 'team_id': user['team_id'], 'name': user['name'], 'deleted': user['deleted'], #'status': user['status'], 'real_name': user['real_name'], 'tz': user['tz'], 'tz_label': user['tz_label'], 'tz_offset': user['tz_offset'], 'profile': { 'first_name': user['profile'].get('first_name', ''), 'last_name': user['profile'].get('last_name', ''), 'avatar_hash': user['profile'].get('avatar_hash', ''), 'title': user['profile'].get('title', ''), 'phone': user['profile'].get('phone', ''), 'phone_link': user['profile'].get('phone_link', ''), 'skype': user['profile'].get('skype', ''), 'image_24': user['profile'].get('image_24', ''), 'image_32': user['profile'].get('image_32', ''), 'image_48': user['profile'].get('image_48', ''), 'image_72': user['profile'].get('image_72', ''), 'image_192': user['profile'].get('image_192', ''), 'image_512': user['profile'].get('image_512', ''), 'image_1024': user['profile'].get('image_1024', ''), 'image_original': user['profile'].get('image_original', ''), 'real_name': user['profile'].get('real_name', ''), 'real_name_normalized': user['profile'].get('real_name_normalized', ''), 'email': user['profile'].get('email', ''), }, 'is_admin': user['is_admin'], 'is_owner': user['is_owner'], #'is_primary_owner': user['is_primary_owner'], #'is_restricted': user['is_restricted'], #'is_ultra_restricted': user['is_ultra_restricted'], 'is_bot': user['is_bot'], #'has_2fa': user['has_2fa'], #'two_factor_type': user['two_factor_type'] }) return active_users
def register(): try: database = psycopg2.connect( user="******", password= "******", host=os.getenv('DATABASE_IP', "172.17.0.1"), port="5432", database="dauhmnvct04jp4") if database: cursor = database.cursor() response = dict() data = request.get_json() for key, value in data.items(): error = checkValidityOfData(value, key) response['error'] = error if error != None: raise Exception(response) email = data['email'].lower() password = data['password'] firstName = data['first_name'] lastName = data['last_name'] personalStreetAddress = data['personal_street_address'] personalCity = data['personal_city'] personalState = data['personal_state'] personalPostal = data['personal_postal'] personalCountry = data['personal_country'] phoneNumber = data['phone_number'] status = data['status'] gender = data['gender'] if (not phonenumbers.is_valid_number( phonenumbers.parse(phoneNumber, "US"))): response['error'] = "Invalid US Phone Number" raise Exception(response) isValid = validate_email(email) if isValid: salt = generate_salt_string() encryptedPassword = encrypt_password(password, salt) salt = salt.decode("utf-8") cursor.execute( f"""SELECT * FROM public."Personal Information" WHERE email = '{email}' and first_name = '{firstName}'""" ) account = cursor.fetchone() if not account: cursor.execute( f"""INSERT INTO public."Personal Information" (email, password, first_name, last_name, personal_street_address, personal_state, personal_city, personal_postal, personal_country, phone_number, status, gender, salts ) VALUES ('{email}', '{encryptedPassword}', '{firstName}', '{lastName}', '{personalStreetAddress}', '{personalState}', '{personalCity}', '{personalPostal}', '{personalCountry}', '{phoneNumber}', '{status}', '{gender}', '{salt}')""" ) database.commit() response['status'] = True response['status_info'] = 'Account created successfully!' return response else: response['error'] = "User Already Exists!" raise Exception(response) else: response['error'] = "Entered Email Is Not Valid!" raise Exception(response) else: error = "Connection to database failed!" response['error'] = error raise Exception(response) except Exception: return (response, 400)
def update(self, instance, validated_data): """ Override this function to include extra functionality. """ # For debugging purposes only. # print(validated_data) # Get our inputs. email = validated_data.get('email', instance.email) # Update telephone numbers. fax_number = validated_data.get('fax_number', instance.fax_number) if fax_number is not None: validated_data['fax_number'] = phonenumbers.parse(fax_number, "CA") telephone = validated_data.get('telephone', instance.telephone) if telephone is not None: validated_data['telephone'] = phonenumbers.parse(telephone, "CA") other_telephone = validated_data.get('other_telephone', instance.other_telephone) if other_telephone is not None: validated_data['other_telephone'] = phonenumbers.parse(other_telephone, "CA") #--------------------------- # Update `SharedUser` object. #--------------------------- instance.owner, created = SharedUser.objects.update_or_create( email=email, defaults={ 'email': email, 'first_name': validated_data.get('given_name', instance.given_name), 'last_name': validated_data.get('last_name', instance.last_name), 'is_active': validated_data.get('is_active', False) } ) logger.info("Updated shared user.") # Update the password. password = validated_data.get('password', None) if password: instance.owner.set_password(password) # Save the model. instance.owner.save() #--------------------------- # Update `Partner` object. #--------------------------- instance.email = email # Organization instance.organization_name = validated_data.get('organization_name', None), instance.organization_type_of = validated_data.get('organization_type_of', None), # Profile instance.given_name=validated_data.get('given_name', instance.given_name) instance.last_name=validated_data.get('last_name', instance.last_name) instance.middle_name=validated_data.get('middle_name', instance.middle_name) instance.birthdate=validated_data.get('birthdate', instance.birthdate) instance.join_date=validated_data.get('join_date', instance.join_date) instance.gender = validated_data.get('gender', instance.gender) instance.description = validated_data.get('description', instance.description) # Misc instance.is_ok_to_email=validated_data.get('is_ok_to_email', None) instance.is_ok_to_text=validated_data.get('is_ok_to_text', None) instance.hourly_salary_desired=validated_data.get('hourly_salary_desired', 0.00) instance.limit_special=validated_data.get('limit_special', None) instance.dues_date=validated_data.get('dues_date', None) instance.commercial_insurance_expiry_date=validated_data.get('commercial_insurance_expiry_date', None) instance.police_check=validated_data.get('police_check', None) instance.drivers_license_class=validated_data.get('drivers_license_class', None) instance.how_hear=validated_data.get('how_hear', None) instance.last_modified_by = self.context['last_modified_by'] instance.last_modified_from = self.context['last_modified_from'] instance.last_modified_from_is_public = self.context['last_modified_from_is_public'] # 'organizations', #TODO: IMPLEMENT. # Contact Point instance.area_served=validated_data.get('area_served', None) instance.available_language=validated_data.get('available_language', None) instance.contact_type=validated_data.get('contact_type', None) instance.fax_number=validated_data.get('fax_number', None) # 'hours_available', #TODO: IMPLEMENT. instance.telephone=validated_data.get('telephone', None) instance.telephone_extension=validated_data.get('telephone_extension', None) instance.telephone_type_of=validated_data.get('telephone_type_of', TELEPHONE_CONTACT_POINT_TYPE_OF_ID) instance.other_telephone=validated_data.get('other_telephone', None) instance.other_telephone_extension=validated_data.get('other_telephone_extension', None) instance.other_telephone_type_of=validated_data.get('other_telephone_type_of', TELEPHONE_CONTACT_POINT_TYPE_OF_ID) # Postal Address instance.address_country=validated_data.get('address_country', None) instance.address_locality=validated_data.get('address_locality', None) instance.address_region=validated_data.get('address_region', None) instance.post_office_box_number=validated_data.get('post_office_box_number', None) instance.postal_code=validated_data.get('postal_code', None) instance.street_address=validated_data.get('street_address', None) instance.street_address_extra=validated_data.get('street_address_extra', None) # Geo-coordinate instance.elevation=validated_data.get('elevation', None) instance.latitude=validated_data.get('latitude', None) instance.longitude=validated_data.get('longitude', None) # 'location' #TODO: IMPLEMENT. # Save our instance. instance.save() logger.info("Updated the partner.") # #--------------------------- # # Attach our comment. # #--------------------------- # extra_comment = validated_data.get('extra_comment', None) # if extra_comment is not None: # comment = Comment.objects.create( # created_by=self.context['last_modified_by'], # last_modified_by=self.context['last_modified_by'], # text=extra_comment # ) # partner_comment = PartnerComment.objects.create( # partner=instance, # comment=comment, # created_from = self.context['last_modified_from'], # created_from_is_public = self.context['last_modified_from_is_public'] # ) #--------------------------- # Update validation data. #--------------------------- # validated_data['comments'] = PartnerComment.objects.filter(partner=instance) validated_data['last_modified_by'] = self.context['last_modified_by'] # validated_data['extra_comment'] = None # Return our validated data. return validated_data
def _save_message(self, message, group_name, chat_id, msg_id, file_name, msg_id_path='/data/mensagens_grupo/'): """ Escreve em formato json a mensagem coletada no arquivo referente ao grupo em que ela foi enviada. Caso o arquivo do grupo ainda não exista, ele será criado. Parâmetros ------------ message : webwhatsapi.Message() Objeto da mensagem coletada. group_name : str Nome do grupo em que a mensagem foi enviada. chat_id : str Id do grupo em que a mensagem foi enviada. msg_id : str Id da mensagem coletada. file_name : str Nome do arquivo da mídia possivelmente contida na mensagem. msg_id_path : str Caminho da pasta em que os arquivos de mensagens por grupo serão escritos. """ if not message.sender: return item = dict() sender = message.sender.id sender = sender.replace(' ', '').strip() sender = sender.split('@')[0] sender = ('+' + sender) try: phone = phonenumbers.parse(sender) except Exception: phone = phonenumbers.parse('+' + sender) country_code = phone.country_code country = phonenumbers.phonenumberutil.region_code_for_country_code( country_code) mid = smart_str(msg_id) gid = smart_str(chat_id) try: content = message.content content = smart_str(content) content = smart_str(content.replace('\n', ' ')) except Exception: content = '<NoContent>' t = str(message) index = t.find(' at ') + 4 index2 = index + 19 date = str(t[index:index2]) date = smart_str(date.replace(' ', '\t').strip()) filename = '<NoFile>' mediatype = 'application/json' if (isinstance(message, MESSAGE.MediaMessage) or isinstance(message, MESSAGE.MMSMessage)): mediatype = smart_str(message.type) try: filename = message.filename content = '<' + filename + '>' except Exception: filename = '<NoFile>' if hasattr(message, 'caption'): content = smart_str(message.caption) if 'text' in mediatype: mediatype = 'application/json' phash = '' checksum = '' if ((mediatype == 'image' and self.process_image_hashes) or (mediatype == 'video' and self.process_video_hashes) or (mediatype == 'audio' and self.process_audio_hashes)): dir = "" if mediatype == 'image': dir = self.data_path + "image" if mediatype == 'video': dir = self.data_path + "video" if mediatype == 'audio': dir = self.data_path + "audio" try: checksum = hash_functions.get_hash_from_method( os.path.join(dir, message.filename), "checksum") except Exception: print("Couldn't process checksum for file %s." % (message.filename)) if mediatype == 'image': try: phash = hash_functions.get_hash_from_method( os.path.join(dir, message.filename), "phash") except Exception: print("Couldn't process phash for file %s." % (message.filename)) item['mensagem_id'] = mid item['identificador'] = mid item['grupo_id'] = gid item['titulo'] = group_name item['pais'] = country item['enviado_por'] = smart_str(sender) item['criado_em'] = smart_str(date) item['tipo'] = mediatype item['arquivo'] = smart_str(filename) item['datalake'] = join(self.data_path, smart_str(filename)) item['texto'] = smart_str(content) if (mediatype == 'video' or mediatype == 'image' or mediatype == 'audio'): item['checksum'] = checksum if mediatype == 'image': item['phash'] = phash messageLine = '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%r\t%s\t%s' % \ (mid, gid, group_name, country, smart_str(sender), smart_str(date), mediatype, checksum, smart_str(filename), self._process_string(content)) print(messageLine) # Save message on kafka if self.save_kafka: topic = self.kafka.get_topic('whatsapp', 'mensagem') json_dump_object = json.dumps(item) self.kafka.publish_kafka_message(self.producer, topic, 'raw', json_dump_object) if self.save_file: # Save message on group ID file if self.write_mode == 'group' or self.write_mode == 'file' or self.write_mode == 'both': message_group_filename = '%smensagens_grupo_%s.json' % ( msg_id_path, gid) with open(message_group_filename, 'a') as json_file: json.dump(item, json_file) print('', file=json_file) if self.write_mode == 'day' or self.write_mode == 'file' or self.write_mode == 'both': message_day_filename = file_name # Save message on file for all messages of the day with open(message_day_filename, 'a') as json_file: json.dump(item, json_file) print('', file=json_file) # Always save mid reference for future checks reference_mid_filename = '/data/mids/%s.txt' % (gid) with open(reference_mid_filename, 'a') as fmid: messageLine = '%s\t%s\t%s' % (mid, gid, smart_str(date)) print(messageLine, file=fmid) return item
def team_edit_user(pid, tid): ''' Team edit user ''' # pylint: disable=too-many-locals,too-many-return-statements,too-many-branches,too-many-statements team, project, _redirect = check_the_team_and_project_are_existed(pid=pid, tid=tid) if _redirect: return _redirect is_admin = (g.user['account']['_id'] in team['chiefs'] or g.user['account']['_id'] in team['owners'] or g.user['account']['_id'] in project['owners']) if not is_admin: return redirect('/') if request.method == 'GET': waitting_list = list(WaitList.list_by_team(pid=pid, tid=tid)) uids = [u['uid'] for u in waitting_list] users_info = User.get_info(uids) for user in waitting_list: user['_info'] = users_info[user['uid']] user['_history'] = [] for wait_info in WaitList.find_history(pid=pid, uid=user['uid']): if 'result' not in wait_info: wait_info['result'] = 'waitting' user['_history'].append(wait_info) user['_mail'] = User(uid=user['uid']).get()['mail'] return render_template('./team_edit_user.html', project=project, team=team, waitting_list=waitting_list) if request.method == 'POST': data = request.json if data['case'] == 'deluser': Team.update_members(pid=pid, tid=tid, del_uids=[ data['uid'], ]) elif data['case'] == 'history': history = [] for raw in WaitList.find_history_in_team(uid=data['uid'], pid=pid, tid=tid): raw['_id'] = str(raw['_id']) history.append(raw) return jsonify({'history': history}) elif data['case'] == 'members': result_members = [] if team['members'] or team['chiefs']: _all_uids = set(team['chiefs']) | set(team['members']) users_info = User.get_info(list(_all_uids)) for uid in _all_uids: result_members.append(users_info[uid]) for user in result_members: user['chat'] = {} mid = MattermostTools.find_possible_mid(uid=user['_id']) if mid: user['chat'] = { 'mid': mid, 'name': MattermostTools.find_user_name(mid=mid) } user['phone'] = {'country_code': '', 'phone': ''} if 'phone' in user['profile_real'] and user[ 'profile_real']['phone']: phone = phonenumbers.parse( user['profile_real']['phone']) user['phone']['country_code'] = phonenumbers.COUNTRY_CODE_TO_REGION_CODE[phone.country_code][0] # pylint: disable=line-too-long user['phone']['phone'] = phonenumbers.format_number( phone, phonenumbers.PhoneNumberFormat.NATIONAL) result_members = sorted( result_members, key=lambda u: u['profile']['badge_name']) return jsonify({ 'members': result_members, 'tags': team.get('tag_members', []), 'members_tags': Team.get_members_tags(pid=pid, tid=tid), }) elif data['case'] == 'add_tag': result = Team.add_tag_member(pid=pid, tid=tid, tag_name=data['tag_name']) return jsonify({'tag': result}) elif data['case'] == 'update_member_tags': team_tags = [i['id'] for i in team.get('tag_members', [])] team_members = set(team['members'] + team['chiefs']) tag_datas = {} for uid in team_members: if uid in data['data']: tag_datas[uid] = { 'tags': list(set(team_tags) & set(data['data'][uid])) } if tag_datas: Team.add_tags_to_members(pid=pid, tid=tid, data=tag_datas) return jsonify({'data': tag_datas}) elif data['case'] == 'del_tag': Team.del_tag(pid=pid, tid=tid, tag_id=data['tag']['id']) return jsonify({}) return jsonify(data) return jsonify({})
import phonenumbers from phonenumbers import geocoder from phonenumbers import carrier user_inp = input('Enter a Phone Number with Country Code: ') # TO know From which country the Number Belongs!! ch_nmber = phonenumbers.parse(user_inp, 'CH') print(geocoder.description_for_number(ch_nmber, "en")) # TO know From which Service Provider the Number is being Linked to!! service_numb = phonenumbers.parse(user_inp, "RO") print(carrier.name_for_number(service_numb, "en")) #help(geocoder)
import phonenumbers # geocoder: to know the specific # location to that phone number from phonenumbers import geocoder from phonenumbers import carrier # Indian phone number example: +91********** phone_number = phonenumbers.parse("+91**********") # this will print the country name print(geocoder.description_for_number(phone_number, 'en')) # this will print the service provider name print(carrier.name_for_number(phone_number, 'en'))
import phonenumbers from phonenumbers import geocoder phone = input("Digite o número no formato +551100000000: ") phone_number = (phonenumbers.parse(phone)) print(geocoder.description_for_number(phone_number, "pt"))
def localScan(InputNumber): global number global localNumber global internationalNumber global numberCountryCode global numberCountry print(code_info + 'Executando verificação local...') time.sleep(1) 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('') print(code_result + '»Formato internacional: {}'.format(internationalNumber)) print print(code_result + '»Formato local: 0{}'.format(localNumber)) print print(code_result + '»Código do país: {}'.format(numberCountryCode)) print print(code_result + '»Localização: {}'.format( geocoder.description_for_number(PhoneNumberObject, "en"))) print print(code_result + '»Transportadora: {}'.format( carrier.name_for_number(PhoneNumberObject, 'en'))) print print(code_result + '»Area: {}'.format( geocoder.description_for_number(PhoneNumberObject, 'en'))) print for timezoneResult in timezone.time_zones_for_number( PhoneNumberObject): print(code_result + '»Fuso horário: {}'.format(timezoneResult)) print if phonenumbers.is_possible_number(PhoneNumberObject): print(code_info + '\033[1;34m>O número é válido e possível. ') else: print( code_warning + '\033[1;36m# >O número é válido, mas pode não ser possível. #' )
def clean_phone(phone): # This could raise, but should have been checked with validate_phone first return phonenumbers.format_number( phonenumbers.parse(phone, DEFAULT_REGION), phonenumbers.PhoneNumberFormat.E164)
import phonenumbers from test import number from phonenumbers import geocoder, carrier, timezone country_num = phonenumbers.parse(number, "CH") print(geocoder.description_for_number(country_num, "en")) service_num = phonenumbers.parse(number, "RO") print(carrier.name_for_number(service_num, "en")) gb_num = phonenumbers.parse(number, "GB") print(timezone.time_zones_for_number(gb_num))
"""main.py""" import phonenumbers from test import number from phonenumbers import geocoder ch_nmber = phonenumbers.parse(number, "CH") print(geocoder.description_for_number(ch_nmber, "en")) """test.py""" n = input("enter country code: ") m = input("enter the Number: ") number = '+' + 'n' + 'm'
import phonenumbers from phonenumbers import geocoder phone_number = phonenumbers.parse('+18033360564') print(geocoder.description_for_number(phone_number, 'en'))
import phonenumbers from colorama import init from phonenumbers import geocoder from termcolor import colored init() print(" ") print(colored(" ███ ██ ██ ███ ██ ███████ ██████ ", "red")) print(colored(" ████ ██ ██ ████ ██ ██ ██ ██ ", "magenta")) print(colored(" ██ ██ ██ - ██ ██ ██ ██ █████ ██ ██ ", "yellow")) print(colored(" ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ", "green")) print(colored(" ██ ████ ██ ██ ████ ██ ██████ ", "blue")) print(" ") print(colored(" Number Service Shower & Country @yFley 2021", "green")) print(" ") number = input(" Number: ") de_nmber = phonenumbers.parse(number, "DE") print(geocoder.description_for_number(de_nmber, "de")) from phonenumbers import carrier service_nmber = phonenumbers.parse(number, "RO") print(carrier.name_for_number(service_nmber, "de"))
def sms_reply(): """Respond to incoming calls with a simple text message.""" # Fetch the message msg = request.form.get('Body').lower() sms_reply.ph = request.form.get("From") lat, lon = request.form.get('Latitude'), request.form.get('Longitude') global lati, long global count # Create reply sms_reply.resp = MessagingResponse() twiml = VoiceResponse() print('What user Typed:', msg) #resp.message("You said: {}".format(msg)) if len(msg) == 12: print("first count") count += 1 sms_reply.z = phonenumbers.parse(msg, "IN") if (phonenumbers.is_valid_number(sms_reply.z)) is True: print("valid:", sms_reply.z) sms_reply.sms = msg print(sms_reply.sms) sms_reply.id = str(random.randint(1000, 9999)) print(sms_reply.id) client = Client(account_sid, auth_token) message = client.messages.create( from_='whatsapp:+<your twilio number>', body=(sms_reply.id), to='whatsapp:+' + sms_reply.sms) print(message.sid) elif count in range(1, 999999) and msg == sms_reply.id: print("count:", count) import requests requests.get('<Your ngrok or server link>/dial/' + sms_reply.sms) elif any(c in msg for c in list1): import requests url = "https://trueway-places.p.rapidapi.com/FindPlacesNearby" querystring = { "location": lati + "," + long, "type": msg, "radius": "1200", "language": "en" } headers = { 'x-rapidapi-key': "<your TrueWay Places rapid api key>", 'x-rapidapi-host': "trueway-places.p.rapidapi.com" } response = requests.request("GET", url, headers=headers, params=querystring) data = response.json() ids = data['results'] for i in range(0, len(ids) - 1): location = str(ids[i]["location"]["lat"]) + "," + str( ids[i]["location"]["lng"]) link = "http://maps.google.com/maps?q=" + location name = " *_Name:_* " + ids[i]["name"] + "\n *_Address:_* " + ( response.json()["results"][i]["address"] ) + "\n *_Distance (Approx):_* " + str( ids[i]["distance"]) + "mt" + "\n\n *_Location:_* " + link print(name) #print("Distance:", ids[i]['distance'],) sms_reply.resp.message(name) #sms_reply.resp.message(ids[i]['address']) #sms_reply.resp.message(str(ids[i]['distance'])) return str(sms_reply.resp) elif 'user1' in msg: match = re.search(r'[\w\.-]+@[\w\.-]+', msg) l = (match.group(0)) sms_reply.to = l print(l) elif 'subject1' in msg: sms_reply.subject = msg print('subject is:', sms_reply.subject) elif 'body1' in msg: sms_reply.body = msg print('body is:', sms_reply.body) elif 'send1' in msg: with smtplib.SMTP('smtp.gmail.com', 587) as smtp: smtp.ehlo() smtp.starttls() smtp.ehlo() smtp.login(EMAIL_ADDRESS, EMAIL_PASSWORD) subject = sms_reply.subject body = sms_reply.body msg = f'Subject: {subject}\n\n{body}' smtp.sendmail(EMAIL_PASSWORD, sms_reply.to, msg) sms_reply.resp.message('send succesfully') print('send succesfully') print("To:", sms_reply.to) print("Subject:", sms_reply.subject) print("Body:", sms_reply.body) elif "my email" in msg: match = re.search(r'[\w\.-]+@[\w\.-]+', msg) s = (match.group(0)) print("Your email:", s) elif "email" in msg: print("its email") sms_reply.resp.message( "OK so you want to send an e-mail\n\n" "1.)Firstly You have to enter email to which you want to send and click send\n\n" "2.)Then type 'subject1' before entering your subject in the same line and click send\n\n" "3.)And for body write 'body1' before writing mssg in the same line and click send\n\n" "4.) After typing all the details types 'send1' and its done") else: print("no phone number") return str(sms_reply.resp)
def setUp(self): self.maxDiff = None self.recipient = RecipientFactory(verification_code="123456", phone_number=phonenumbers.parse( "+61421955955", "AU"))
def is_phone(phone): try: return phonenumbers.is_valid_number(phonenumbers.parse(phone, None)) except phonenumbers.NumberParseException: return False