def sms_client(): global _sms_client if _sms_client is None and settings.TWILIO_ACCOUNT_SID: _sms_client = TwilioClient(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN) return _sms_client
def add_member(member_number): member_number = format_number(member_number) client = datastore.Client.from_service_account_json('gcloud.json') key = member_key(client, member_number) member = client.get(key) if member: return f'Member {member_number} already exists' else: member = datastore.Entity(key=key) member.update({ 'number': member_number, 'status': 'created' }) client.put(member) logging.info(f'added member {member_number}') twilio_client = TwilioClient( os.getenv('TWILIO_ACCOUNT_SID'), os.getenv('TWILIO_AUTH_TOKEN')) try: message = twilio_client.messages.create(to=f"+1{member_number}", from_="+%s" % os.getenv('TWILIO_NUMBER'), body="You have been invited to FOOTHODL. Provide your phone number to a volunteer to get their assistance.") except: logging.error('unable to send SMS message') return f'Sent member invite to {member_number}'
def getTwilioClient(matrix_id): try: (sid, auth) = db.getTwilioAuthPair(matrix_id) except: return None twilio_client = TwilioClient(sid, auth) return twilio_client
def check_alerts(self): """Check alerts for all types of assets.""" self.check_date() if self.price_tracker is None: self.price_tracker = PriceTracker() if self.send_message is None: from moontracker.api_keys import twilio_sid, twilio_auth twilio_client = TwilioClient(twilio_sid, twilio_auth) self.send_message = twilio_client.api.account.messages.create for asset in supported_assets: for market in supported_assets[asset]["markets"]: self.check_alerts_for_coin(asset, market) # too many requests per second, keep getting 429 code for asset in supported_assets: for market in supported_assets[asset]["markets"]: # currently only supports 24 hours # for time in supported_durations[market]: # self.check_alerts_for_coin_percent( # asset, market, int(time)) self.check_alerts_for_coin_percent(asset, market, supported_times[1][1])
def add_ambassador(ambassador_number): ambassador_number = format_number(ambassador_number) client = datastore.Client.from_service_account_json('gcloud.json') key = ambassador_key(client, ambassador_number) ambassador = client.get(key) if ambassador: return f'Ambassador {ambassador_number} already exists' else: ambassador = datastore.Entity(key=key) ambassador.update({ 'number': ambassador_number, 'status': 'created' }) client.put(ambassador) logging.info(f'added ambassador {ambassador_number}') twilio_client = TwilioClient( os.getenv('TWILIO_ACCOUNT_SID'), os.getenv('TWILIO_AUTH_TOKEN')) wallet_url = f'http://www.foothodl.com/{ambassador_number}' try: message = twilio_client.messages.create(to="+1%s" % ambassador_number, from_="+%s" % os.getenv('TWILIO_NUMBER'), body=f"(Ambassador invite) Thank you for volunteering to join FOOTHODL as an ambassador. To redeem funds, provide a member's phone number in your wallet - {wallet_url}") except: logging.error('unable to send SMS message') return 'Sent ambassador invite to %s' % ambassador_number
def nook_number(event, lambda_context): PLAID_CLIENT_ID = os.environ['plaid_client_id'] PLAID_SECRET = os.environ['plaid_secret'] PLAID_PUBLIC_KEY = os.environ['plaid_public_key'] PLAID_ACCESS_TOKEN = os.environ['plaid_access_token'] TWILIO_ACCOUNT_SID = os.environ['twilio_account_sid'] TWILIO_AUTH_TOKEN = os.environ['twilio_auth_token'] plaid_client = PlaidClient(client_id=PLAID_CLIENT_ID, secret=PLAID_SECRET, public_key=PLAID_PUBLIC_KEY, environment='development') response = plaid_client.Accounts.balance.get(PLAID_ACCESS_TOKEN) account_balance_data = response['accounts'][0]['balances'] account_limit = account_balance_data['limit'] account_available = account_balance_data['available'] account_balance = '%.2f' % (account_limit - account_available) account_balance_string = f'You currently have a balance of ${account_balance} on your credit card.' print(account_balance_string) twilio_client = TwilioClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN) print(twilio_client) message = twilio_client.messages.create(body=account_balance_string, from_=os.environ['from_number'], to=os.environ['to_number']) print(message)
def alert(self, message): client = TwilioClient(self.params["account_sid"], self.params["auth_token"]) message = client.messages.create(body=message, from_=self.params["from"], to=self.params["to"])
def face_trigger(self, name): global lastSeenMessage print(f"Recognized {name}") if name in self.delay_cache: last_seen = get_pst() diff = time.time() - self.delay_cache[name] print(f"{name} last seen at {last_seen}") lastSeenMessage = name + " last seen at " + last_seen if diff > self.delay_cache_threshold: print("RESET DELAY CACHE FOR THIS NAME") self.delay_cache[name] = time.time() # if time diff greater than some threshold, send message else: self.delay_cache[name] = time.time() if twilioSettingsJSON is not None: self.messenger = TwilioClient( twilioSettingsJSON['account_sid'], twilioSettingsJSON['auth_token']) self.messenger.messages.create( body=self.default_message + name, from_=twilioSettingsJSON['from_number'], to=twilioSettingsJSON['to_number']) print("Twilio SMS Sent") else: print("Add your Twilio credentials to start sending messages")
def alert(self, matches): client = TwilioClient(self.twilio_account_sid, self.twilio_auth_token) try: if self.twilio_use_copilot: if self.twilio_message_service_sid is None: raise EAException( "Twilio Copilot requires the 'twilio_message_service_sid' option" ) client.messages.create( body=self.rule['name'], to=self.twilio_to_number, messaging_service_sid=self.twilio_message_service_sid) else: if self.twilio_from_number is None: raise EAException( "Twilio SMS requires the 'twilio_from_number' option") client.messages.create(body=self.rule['name'], to=self.twilio_to_number, from_=self.twilio_from_number) except TwilioRestException as e: raise EAException("Error posting to twilio: %s" % e) elastalert_logger.info("Trigger sent to Twilio")
def call(number): client = TwilioClient(account_sid, auth_token) call = client.calls.create( twiml= '<Response><Say>Hi there, a seat is now available, hurry up!</Say></Response>', to=number, from_=source_phone_number) log("Making a call to {}".format(number))
def send_sms(body, conf): client = TwilioClient(conf['sid'], conf['token']) log.info('Sending SMS (num: {}, len: {})'.format(conf['to_num'], len(body))) result = client.messages.create(body=body, from_=conf['from_num'], to=conf['to_num']) return result
def send_twilio_message(twilio_config, status_text): client = TwilioClient(twilio_config["account"], twilio_config["token"]) try: client.messages.create(to=twilio_config["to"], from_=twilio_config["from"], body=status_text) except TwilioRestException as e: print(e)
def main(cli, args): profile = cli.profile with open(args.filter_file, 'r', encoding='utf8') as fp: filters = yaml.safe_load(fp) stream_profile = profile.get('stream', {}) report_interval = stream_profile.get('report_interval') if report_interval is not None: report_interval = timedelta(seconds=report_interval) twilio = TwilioClient( profile['twilio']['account_sid'], profile['twilio']['auth_token'], ) while True: stream = TweetStream( profile['twitter']['consumer_key'], profile['twitter']['consumer_secret'], profile['twitter']['access_token'], profile['twitter']['access_token_secret'], path_prefix=args.output_path_prefix, report_interval=report_interval, ) stopping = False def on_sigterm(*args): nonlocal stopping log.info('received SIGTERM, stopping') stopping = True stream.disconnect() try: signal.signal(signal.SIGTERM, on_sigterm) stream.filter(**filters, stall_warnings=True) except Exception as ex: log.info('restarting after receiving exception') try: twilio.messages.create( body=(f'Received twitter-listen exception ' f'type={type(ex).__qualname__} args={ex}'), from_=profile['twilio']['source_phone_number'], to=profile['twilio']['target_phone_number'], ) except Exception: log.exception('squashing error sending sms') except KeyboardInterrupt: log.info('received SIGINT, stopping') break else: if stopping: break log.info('restarting') finally: signal.signal(signal.SIGTERM, signal.SIG_DFL) stream.disconnect()
def get_twilio_client(self): twilio_settings = frappe.get_doc("Twilio Settings") if not twilio_settings.enabled: frappe.throw(_("Please enable twilio settings before sending WhatsApp messages")) auth_token = get_decrypted_password("Twilio Settings", "Twilio Settings", 'auth_token') client = TwilioClient(twilio_settings.account_sid, auth_token) return client
def send_templated_sms(template_name: str, from_number: str, recipient_list: Sequence[str], context: dict) -> None: """Render a plan-text template and send via SMS to all recipients.""" template = get_template(template_name) text = template.render(context) client = TwilioClient(settings.TWILIO_SID, settings.TWILIO_TOKEN) for recipient in recipient_list: client.messages.create(body=text, to=recipient, from_=from_number)
def request_keys(): """ Obtain approval to release repository encryption key from Key Vault via SMS """ pin = random.randint(0, 10**app.config['PIN_LENGTH'] - 1) kr = KeyRequest(pin=pin, approved=False) db.session.add(kr) db.session.commit() client = TwilioClient(app.config['TWILIO_ACCOUNT_ID'], app.config['TWILIO_TOKEN']) sms = client.messages.create( to=app.config['SMS_TO'], from_=app.config['SMS_FROM'], body= "Request received for repository encryption key, respond with this PIN to confirm: %s" % str(pin).zfill(app.config['PIN_LENGTH'])) iteration = 0 while not kr.approved and iteration < app.config['MAX_WAIT']: iteration += 1 db.session.refresh(kr) time.sleep(1) if not kr.approved: return '', 401 authority_url = "%(host)s/%(tenant)s" % { 'host': app.config["AAD_AUTHORITY_HOST_URI"], 'tenant': app.config['AAD_TENANT_ID'] } context = adal.AuthenticationContext( authority_url, validate_authority=app.config['AAD_TENANT_ID'] != 'adfs', api_version=None) token = context.acquire_token_with_client_credentials( app.config['AAD_RESOURCE'], app.config['AAD_CLIENT_ID'], app.config['AAD_CLIENT_SECRET']) uri = "%(kv_uri)s/secrets/%(secret_name)s?api-version=2016-10-01" % { 'kv_uri': app.config['KEY_VAULT_URI'], 'secret_name': app.config['KEY_VAULT_SECRET'] } headers = { 'Authorization': '%s %s' % (token['tokenType'], token['accessToken']) } r = requests.get(uri, headers=headers) if r.status_code == 200: result = r.json() encryption_key = result['value'] return encryption_key sys.stderr.write( "Error: Failed to obtain blob key due to invalid HTTP response %(status_code)d\n" % {'status_code': r.status_code}) return '', 500
def sendSMS(number, message): client = TwilioClient(account_sid, auth_token) message = client.messages \ .create( body=message, from_=source_phone_number, to=number ) log("Sending message '{}' to {}".format(message, number))
def send_sms(number, message): # Your Account Sid and Auth Token from twilio.com/user/account number = re.sub("[^0-9]", "", str(number)) client = TwilioClient(TWILIO_SID, TWILIO_TOKEN) message = client.messages.create( number, body=message, from_=TWILIO_NUMBER, ) print(message) return message
def call_parent(self): account_sid = self.twilioaccount auth_token = self.twiliotoken client = TwilioClient(account_sid, auth_token) for phone_num in self.phone_nums: call = client.calls.create( twiml='<Response><Say>Time to get Seamus!</Say></Response>', to=phone_num, from_=self.twiliophone) print(call.sid)
def __init__(self, settings): """ :param settings: `Twilio Settings` doctype """ self.settings = settings self.account_sid = settings.account_sid self.application_sid = settings.twiml_sid self.api_key = settings.api_key self.api_secret = settings.get_password("api_secret") self.twilio_client = TwilioClient(self.account_sid, settings.get_password("auth_token"))
def send_sms(sms_targets, message_body): account_sid = os.environ['TWILIO_ACCOUNT_SID'] auth_token = os.environ['TWILIO_AUTH_TOKEN'] sms_source = os.environ['TWILIO_ACCOUNT_PHONE'] for sms_target in sms_targets: client = TwilioClient(account_sid, auth_token) message = client.messages.create(body=message_body, from_=sms_source, to=sms_target) print(message.sid)
def text_parent(self, old_status, new_status): account_sid = self.twilioaccount auth_token = self.twiliotoken client = TwilioClient(account_sid, auth_token) message = "Seamus' Snoo just changed from %s to %s" % (old_status, new_status) for phone_num in self.phone_nums: msg = client.messages.create(body=message, to=phone_num, from_=self.twiliophone) print(msg.sid)
def send_warning_message(last_change): event_name = "garage_door_warning" url = f"https://maker.ifttt.com/trigger/{event_name}/with/key/{config.ifttt_key}?value1={last_change.strftime('%H:%M')}" requests.post(url) twilio = TwilioClient(config.twilio["account"], config.twilio["token"]) twilio.messages.create( to=config.twilio["to"], from_=config.twilio["from"], body=f"Garage door has been open since {last_change:%H:%M}", )
def get_twilio_client(): global TWILIO_CLIENT if TWILIO_CLIENT is None: # Make sure all TWILIO_* credentials are set. if not all([ settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN, settings.TWILIO_MESSAGING_SERVICE_SID ]): return None TWILIO_CLIENT = TwilioClient(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN) return TWILIO_CLIENT
def get_twilio_ice_servers(): """Fetch a list of ICE servers provided by Twilio.""" account_sid = current_app.config['TWILIO_ACCOUNT_SID'] auth_token = current_app.config['TWILIO_AUTH_TOKEN'] key_sid = current_app.config['TWILIO_KEY_SID'] try: twilio = TwilioClient(key_sid, auth_token, account_sid) token = twilio.tokens.create() return token.ice_servers except (TwilioException, TwilioRestException): return []
def send_sms(message): if not has_twilio: return #msg = "{}. {}".format(message, url) msg = message client = TwilioClient(twilio_account_sid, twilio_auth_token) for to_number in twilio_to_number: message = client.messages.create(to=to_number, from_=twilio_from_number, body=msg)
def sendsmsout(listofnum, msgbody): # Your Account SID from twilio.com/console account_sid = os.environ['TWILIO_ACCOUNT_SID'] # Your Auth Token from twilio.com/console auth_token = os.environ['TWILIO_AUTH_TOKEN'] client = TwilioClient(account_sid, auth_token) for num in listofnum: print("Sending to " + str(num)) message = client.messages.create( to=num, from_=TWILIOSRCNUM, body=msgbody) print(message.sid)
def __init__(self, args): if args.test or args.replay: self.radio = None else: r = self.radio = rf95.RF95(cs=RF95_SPI_CS, int_pin=RF95_IRQ_PIN, reset_pin=RF95_RESET_PIN) assert r.init(), "failed to intialize radio" r.set_modem_config(rf95.Bw125Cr45Sf128) r.set_frequency(RF95_FREQ) self._args = args self.log_handle = open(args.log, 'w') if args.log else None self.replay_handle = open(args.replay, 'r') if args.replay else None self._pending_line = None self._time_offset = 0 if self.replay_handle: if self.read_replay_line(): self._time_offset = time.time() - self._pending_line[0] self.test = args.test self.use_tts = args.tts self.use_alarm = args.alarm self.numbers = args.phone self.emails = args.email self.stopping = False self.led = RGBLED(*RGBLED_PINS) self.lcd_thread = LCDThread(SEGMENT_PINS, DIGIT_PINS) self.trouble_tags = set() self.known_tags = set() self.monitor_thread = BackgroundThread(self.status_loop, start=False) self.announce_thread = None self._buzzer = False if twilio is not None: self.twilio_client = TwilioClient(TWILIO_SID, TWILIO_AUTH) else: self.twilio_client = None if sendgrid is not None: self.mail_client = sendgrid.SendGridAPIClient(apikey=SENDGRID_API_KEY) else: self.mail_client = None self.conn = None self.states = StateTracker()
def send_text(to, body, media_url=None): client = TwilioClient() if media_url: response = client.messages.create( to=to, from_=settings.TWILIO_NUMBER, body=body, media_url=media_url, ) return response response = client.messages.create( to=to, from_=settings.TWILIO_NUMBER, body=body, ) return response
def send_sms_messages(twilio_sid, twilio_auth_token, from_number, to_number, messages, verbose=False): '''send SMS message via Twilio''' client = TwilioClient(twilio_sid, twilio_auth_token) for m in messages: message = client.messages.create(body=m, from_=from_number, to=to_number) if verbose: print(message.sid) return