def _make_client(configuration):
account_sid = configuration['twilio']['account_sid']
auth_token = configuration['twilio']['auth_token']
number = configuration['twilio']['number']
client = TwilioRestClient(account_sid, auth_token)
client.from_ = number
return client
class RestClientTest(unittest.TestCase):
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN")
@patch("twilio.rest.make_request")
def test_request(self, mock):
self.client.request("2010-04-01", method="GET")
mock.assert_called_with("GET", "https://api.twilio.com/2010-04-01",
headers={"User-Agent": 'twilio-python'}, params={},
auth=AUTH, data=None)
def test_connect_apps(self):
self.assertIsInstance(self.client.connect_apps,
resources.ConnectApps)
def test_authorized_apps(self):
self.assertIsInstance(self.client.authorized_connect_apps,
resources.AuthorizedConnectApps)
@patch("twilio.rest.resources.base.make_request")
def test_conferences(self, mock):
mock.return_value = Mock()
mock.return_value.ok = True
mock.return_value.content = '{"conferences": []}'
self.client.conferences.list()
@patch("twilio.rest.resources.base.make_twilio_request")
def test_members(self, mock):
resp = create_mock_json("tests/resources/members_list.json")
mock.return_value = resp
self.client.members("QU123").list()
uri = "https://api.twilio.com/2010-04-01/Accounts/ACCOUNT_SID/Queues/QU123/Members"
mock.assert_called_with("GET", uri, params={}, auth=AUTH)
def beacon(config):
'''
Emit a dict name "texts" whose value is a list
of texts.
.. code-block:: yaml
beacons:
twilio_txt_msg:
account_sid: "<account sid>"
auth_token: "<auth token>"
twilio_number: "+15555555555"
poll_interval: 10
poll_interval defaults to 10 seconds
'''
log.trace('twilio_txt_msg beacon starting')
ret = []
if not all([config['account_sid'], config['auth_token'], config['twilio_number']]):
return ret
output = {}
poll_interval = config.get('poll_interval')
if not poll_interval:
# Let's default to polling every 10 secons
poll_interval = 10
now = datetime.now()
if 'twilio_txt_msg' in __context__:
timedelta = now - __context__['twilio_txt_msg']
if timedelta.seconds < poll_interval:
log.trace('Twilio beacon poll interval not met.')
log.trace('Twilio polling in {0}'.format(poll_interval - timedelta.seconds))
return ret
output['texts'] = []
client = TwilioRestClient(config['account_sid'], config['auth_token'])
messages = client.messages.list(to=config['twilio_number'])
log.trace('Num messages: {0}'.format(len(messages)))
if len(messages) < 1:
log.trace('Twilio beacon has no texts')
__context__['twilio_txt_msg'] = now
return ret
for message in messages:
item = {}
item['id'] = str(message.sid)
item['body'] = str(message.body)
item['from'] = str(message.from_)
item['sent'] = str(message.date_sent)
item['images'] = []
if int(message.num_media):
media = client.media(message.sid).list()
if len(media):
for pic in media:
item['images'].append(str(pic.uri))
output['texts'].append(item)
message.delete()
__context__['twilio_txt_msg'] = now
ret.append(output)
return ret
class RestClientTest(unittest.TestCase):
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN")
@patch("twilio.rest.make_request")
def test_request(self, mock):
self.client.request("2010-04-01", method="GET")
mock.assert_called_with("GET", "https://api.twilio.com/2010-04-01",
headers={"User-Agent": 'twilio-python'}, params={},
auth=("ACCOUNT_SID", "AUTH_TOKEN"), data=None)
def test_connect_apps(self):
self.assertIsInstance(self.client.connect_apps,
resources.ConnectApps)
def test_authorized_apps(self):
self.assertIsInstance(self.client.authorized_connect_apps,
resources.AuthorizedConnectApps)
@patch("twilio.rest.resources.make_request")
def test_conferences(self, mock):
mock.return_value = Mock()
mock.return_value.ok = True
mock.return_value.content = '{"conferences": []}'
self.client.conferences.list()
class RestClientTest(unittest.TestCase):
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN")
self.task_router_client = TwilioTaskRouterClient("ACCOUNT_SID",
"AUTH_TOKEN")
@patch("twilio.rest.base.make_request")
def test_request(self, mock):
self.client.request("2010-04-01", method="GET")
mock.assert_called_with("GET", "https://api.twilio.com/2010-04-01",
headers={"User-Agent": ANY,
'Accept-Charset': 'utf-8',
'Authorization':
'Basic QUNDT1VOVF9TSUQ6QVVUSF9UT0tFTg=='},
params={}, auth=AUTH, data=None)
called_kwargs = mock.mock_calls[0][2]
self.assertTrue(
'twilio-python' in called_kwargs['headers']['User-Agent']
)
def test_connect_apps(self):
assert_true(isinstance(self.client.connect_apps,
resources.ConnectApps))
def test_authorized_apps(self):
assert_true(isinstance(self.client.authorized_connect_apps,
resources.AuthorizedConnectApps))
@patch("twilio.rest.resources.base.make_request")
def test_conferences(self, mock):
mock.return_value = Mock()
mock.return_value.ok = True
mock.return_value.content = '{"conferences": []}'
self.client.conferences.list()
@patch("twilio.rest.resources.base.make_twilio_request")
def test_members(self, mock):
resp = create_mock_json("tests/resources/members_list.json")
mock.return_value = resp
self.client.members("QU123").list()
uri = "https://api.twilio.com/2010-04-01/Accounts/ACCOUNT_SID" \
"/Queues/QU123/Members"
mock.assert_called_with("GET", uri, params={}, auth=AUTH,
use_json_extension=True)
@patch("twilio.rest.resources.base.make_request")
def test_workflows(self, request):
resp = create_mock_json(
"tests/resources/task_router/workflows_list.json"
)
request.return_value = resp
workflows = self.task_router_client.workflows("WS123")
workflows = workflows.list()
assert_true(workflows[0].sid is not None)
uri = "https://taskrouter.twilio.com/v1/Workspaces/WS123/Workflows"
request.assert_called_with("GET", uri, headers=ANY, params={},
auth=AUTH)
def beacon(config):
'''
Emit a dict name "texts" whose value is a list
of texts.
.. code-block:: yaml
beacons:
twilio_txt_msg:
account_sid: "<account sid>"
auth_token: "<auth token>"
twilio_number: "+15555555555"
interval: 10
'''
log.trace('twilio_txt_msg beacon starting')
ret = []
if not all([config['account_sid'], config['auth_token'], config['twilio_number']]):
return ret
output = {}
output['texts'] = []
client = TwilioRestClient(config['account_sid'], config['auth_token'])
messages = client.messages.list(to=config['twilio_number'])
log.trace('Num messages: {0}'.format(len(messages)))
if len(messages) < 1:
log.trace('Twilio beacon has no texts')
return ret
for message in messages:
item = {}
item['id'] = str(message.sid)
item['body'] = str(message.body)
item['from'] = str(message.from_)
item['sent'] = str(message.date_sent)
item['images'] = []
if int(message.num_media):
media = client.media(message.sid).list()
if len(media):
for pic in media:
item['images'].append(str(pic.uri))
output['texts'].append(item)
message.delete()
ret.append(output)
return ret
class RestClientTimeoutTest(unittest.TestCase):
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN", timeout=sentinel.timeout)
@patch("twilio.rest.resources.base.make_twilio_request")
def test_members(self, mock_request):
resp = create_mock_json("tests/resources/members_list.json")
mock_request.return_value = resp
self.client.members("QU123").list()
mock_request.assert_called_with("GET", ANY, params=ANY, auth=AUTH, timeout=sentinel.timeout)
@patch("twilio.rest.resources.base.make_twilio_request")
def test_arbitrary_member(self, mock_request):
mock_response = Mock()
mock_response.ok = True
mock_response.content = json.dumps({"short_codes": []})
mock_request.return_value = mock_response
self.assertEqual([], self.client.sms.short_codes.list())
mock_request.assert_called_once_with("GET", ANY, params=ANY, auth=AUTH, timeout=sentinel.timeout)
from datetime import datetime, timedelta
from flask import Flask, request, redirect, render_template, session, url_for, send_from_directory, jsonify, Blueprint
from app import app
import twilio.twiml
from twilio.rest import TwilioRestClient
from lib import tokens, forms
import json
import pdb
import sys
import json
client = TwilioRestClient(tokens.TWILIO_ID, tokens.TWILIO_TOKEN)
views = Blueprint('views', __name__)
# Renders page for dashboard and current pitches
@views.route('/', methods=['GET'])
def index():
from models import get_active_pitches
active_pitches = get_active_pitches()
return render_template('dashboard.html', stocks=active_pitches)
# Renders page for latest pitch, basically a copy of current
@views.route('/latest', methods=['GET'])
def latest():
from models import get_all_pitches
# TODO: change to current pitches
pitches = get_all_pitches()
return render_template('latest.html', stocks=pitches)
# -*- coding: utf-8 -*-
#
# Download the twilio-python library from http://twilio.com/docs/libraries
from twilio.rest import TwilioRestClient
client = TwilioRestClient(account_sid, auth_token)
message = client.sms.messages.create(to="+13477676683",
from_="+13477676683",
body="Hello from Python!")
from twilio.rest import TwilioRestClient
from imgurpython import ImgurClient
client_id = '3ddacdbd10e0d71'
client_secret = '85037f60c00294c91f55598b0b67a89ffc62a3a9'
client = ImgurClient(client_id, client_secret)
ret = client.upload_from_path("button.jpg", config=None, anon=True)
image_url = ret.get('link')
ACCOUNT_SID = "AC942cf3a4709c5898acd0b2f757ccdbeb"
AUTH_TOKEN = "f37f9cd47a55ae8f2678376bc4106aed"
f = open('numbers.txt', 'r')
num_to = f.readline().rstrip()
num_from = f.readline().rstrip()
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
message = client.messages.create(to=num_to,
from_=num_from,
media_url=image_url)
def __init__(self):
self.client = TwilioRestClient(getattr(settings, 'TWILIO_ACCOUNT_SID'),
getattr(settings, 'TWILIO_AUTH_TOKEN'))
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN")
def create_and_notify(delf,
request,
channel_name=(str, ),
channel_id=(str, ),
title=(str, ),
content=(str, )):
broadcasted_msg = PushMessage(channel_id=channel_id,
channel_name=channel_name,
title=title,
content=content)
datamsg = f3.messages.serialize(MessageMsg, broadcasted_msg)
broadcasted_msg.put()
#get subscribers of that channel
subs = Subscriber.query(Subscriber.channels == channel_id)
#make email recipients string
recipients = ""
if subs is not None:
for sub in subs:
#only email subscribers with email ntifications enabled
if sub.email_enabled and sub.email_verified:
#re.match(r"[^@]+@[^@]+\.[^@]+", sub.object_id):
recipients += sub.email + ","
#send the emails
if recipients:
mail.send_mail(
sender="*****@*****.**",
to=recipients,
subject="Message from " + channel_name,
body=content)
#send the sms
sms_recipients = []
client = TwilioRestClient(twilio_acc, twilio_tkn)
if subs is not None:
for sub in subs:
#only email subscribers with sms ntifications enabled
if sub.sms_enabled and sub.sms_verified:
message = client.messages.create(to=sub.phone_number,
from_="+12057915054",
body=channel_name + "-" +
content)
#send parse message
url = "https://api.parse.com/1/push"
payload_content = {
'channels': [channel_id],
'data': {
'alert': channel_name + ": " + title + "-" + content
}
}
result = urlfetch.fetch(url=url,
payload=json.dumps(payload_content),
method=urlfetch.POST,
headers={
'Content-Type': 'application/json',
'X-Parse-Application-Id': parse_appid,
'X-Parse-REST-API-Key': parse_apikey
})
return datamsg
def twilio_client():
from twilio.rest import TwilioRestClient
return TwilioRestClient(settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN)
def call():
client = TwilioRestClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
client.calls.create(to="+15154512927",
from_="+13198048229",
url="http://hotlines.herokuapp.com/response/")
return jsonify({"success": True})
def make_call():
client = TwilioRestClient(settings.ACCOUNT_SID, settings.AUTH_TOKEN)
call = client.calls.create(url=settings.XML_URL, to=settings.NUM, from_=settings.FROM, IfMachine='Continue')
call = client.calls.create(url=settings.XML_URL, to=settings.CONFIRMATION, from_=settings.FROM, IfMachine='Continue')
# send_message.py
#==============Imports==========================================================
from twilio.rest import TwilioRestClient
from subprocess import call
import logging
import speech_recognition as sr
log = logging.getLogger(__name__) # logs all text
logger = logging.getLogger(__name__)
#==============TWILIO ESSENTIALS================================================
#api_key = open('api_key.txt','r').readline().strip()
#sid = open('sid.txt','r').readline().strip()
api_key = 'ACfe712cf8d40a3051dbcb283ada0b348e'
sid = 'ed3171d5762363af48af7c6361f4563a'
client = TwilioRestClient(api_key, sid)
class Message:
def send_text():
"""Sends a text to chosen person based off input number"""
#text = input('Message: ')
#toNumber = input('Enter the number to send to: ')
GOOGLE_SPEECH_RECOGNITION_API_KEY = None # for testing purposes, we're just using the default API key
r = sr.Recognizer()
with sr.Microphone() as source:
message = None
number = None
while message == None and number == None:
# Twilio phone number goes here. Grab one at https://twilio.com/try-twilio
# and use the E.164 format, for example: "+12025551234"
TWILIO_PHONE_NUMBER = "+18039982205 "
# list of one or more phone numbers to dial, in "+19732644210" format
DIAL_NUMBERS = [
"+918329469206",
]
# URL location of TwiML instructions for how to handle the phone call
TWIML_INSTRUCTIONS_URL = \
"http://static.fullstackpython.com/phone-calls-python.xml"
# replace the placeholder values with your Account SID and Auth Token
# found on the Twilio Console: https://www.twilio.com/console
client = TwilioRestClient("", "")
def dial_numbers(numbers_list):
"""Dials one or more phone numbers from a Twilio phone number."""
for number in numbers_list:
print("Dialing " + number)
# set the method to "GET" from default POST because Amazon S3 only
# serves GET requests on files. Typically POST would be used for apps
client.calls.create(to=number,
from_=TWILIO_PHONE_NUMBER,
url=TWIML_INSTRUCTIONS_URL,
method="GET")
if __name__ == "__main__":
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
# A list of dependent phone number objects
numbers = client.dependent_phone_numbers('AD2a0747eba6abf96b7e3c3ff0b4530f6e'
).list()
for number in numbers:
print(number.friendly_name)
from flask import Flask, request, redirect, send_from_directory
import twilio.twiml
import os
# import googlemaps and geocoder
import geocoder
import googlemaps
from datetime import datetime
gmaps = googlemaps.Client(key=os.getenv('GOOGLE_SERVER_API_KEY'))
# download the twilio-python library from http://twilio.com/docs/libraries
# and create a client object to use the twilio REST api
from twilio.rest import TwilioRestClient
twilioclient = TwilioRestClient(os.getenv('TWILIO_ACCOUNT_SID'), os.getenv('TWILIO_AUTH_TOKEN'))
# create a client object to use Yelp API
from yelp.client import Client
from yelp.oauth1_authenticator import Oauth1Authenticator
auth = Oauth1Authenticator(
consumer_key=os.getenv('YELP_CONSUMER_KEY'),
consumer_secret=os.getenv('YELP_CONSUMER_SECRET'),
token=os.getenv('YELP_TOKEN_KEY'),
token_secret=os.getenv('YELP_TOKEN_SECRET')
)
yelpclient = Client(auth)
params = {
'term': 'In-N-Out Burger',
'lang': 'en',
from __future__ import absolute_import
from twilio.rest import TwilioRestClient
from django.conf import settings
client = TwilioRestClient(account=settings.TWILIO_ACCOUNT_SID,
token=settings.TWILIO_AUTH_TOKEN)
def sendSMS(msg):
# the following line needs your Twilio Account SID and Auth Token
client = TwilioRestClient(accountId, authToken)
print ts() + "Send SMS MSG: " + msg
# print "debuging"
client.messages.create(to=toNum, from_=fromNum, body=msg)
# Get app path from user
app_route = raw_input("Enter custom app route (press return to use default): ");
app_route = app_route.strip('/')
if len(app_route) is 0:
app_route = DEFAULT_APP_ROUTE
# Parse configuration file
try:
config_file = open(config_filepath, 'r')
config = json.load(config_file)
except IOError:
print "Configuration file not found - run `make install`"
exit(-1)
print "Account SID: " + config['account_sid']
print "Auth Token: " + config['auth_token']
print "Phone Number SID: " + config['phone_number_sid']
# Scrape app url from env and update PN SMS URL
app_url = 'http://' + os.environ[VARNAME_HOSTNAME] + '/' + app_route
print "App URL: " + app_url
print "Updating SMS URL for phone number..."
client = TwilioRestClient(config['account_sid'], config['auth_token'])
try:
number = client.phone_numbers.update(config['phone_number_sid'], sms_url=app_url)
except:
print "Could not update your Twilio phone number SMS URL"
print "First, check your internet connection"
print "Also, try reconfiguring by running `make configure`"
exit(-1)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
participant = client.participants("CFbbe4632a3c49700934481addd5ce1659").update(
"CA386025c9bf5d6052a1d1ea42b4d16662", muted="True"
)
print(participant.muted)
def textmyself(message):
twilioCli = TwilioRestClient(accountSID, authTOKEN)
twilioCli.messages.create(body=message,
from_=mytwilionumber,
to=mycellphone)
if (toast_counter < 3 and
float(model_json[u'outputs'][0][u'data'][u'concepts'][0][u'value'])
> .48):
toast_counter = toast_counter + 1
print("toast done is true")
print(toast_counter)
if (toast_counter >= 3):
toast_done = True
print("Toast RIP")
break
else:
print("toast done is false")
continue
print(toast_perfect)
toast_perfect = model_json[u'outputs'][0][u'data'][u'concepts'][0][
u'value']
print("\n")
client = TwilioRestClient(account='AC24b3c0ad866586038e4f5ca818ae30ed',
token='3bab3d6d5bef27855cfb5bada3c39346')
client.messages.create(to="+14077583284", from_="+14079019282", body="TOAST")
GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.OUT)
GPIO.output(2, GPIO.LOW)
time.sleep(1)
GPIO.output(2, GPIO.HIGH)
GPIO.cleanup()
def __init__(self,
tw_client_id=TW_CLIENT_ID,
tw_secret_key=TW_SECRET_KEY,
tw_app_id=TW_APP_ID):
self.acc_sid = tw_app_id
self.twilio = TwilioRestClient(tw_client_id, tw_secret_key)
def check_price():
for stock, price in zip(portfolio, bought_price):
try:
ticker = stock.lower()
res = requests.get('http://finance.yahoo.com/q?s=' + ticker)
soup = bs4.BeautifulSoup(res.text, 'html.parser')
elems = soup.select('#yfs_l84_' + str(ticker))
current_price = elems[0].getText()
ticker = stock.upper()
if float(current_price
) > 1.02 * float(price) and stock not in checked:
#Email
today = datetime.datetime.today()
today = today.strftime('%m/%d/%Y %I:%M %p')
smtpObj = smtplib.SMTP('smtp.gmail.com', 587)
smtpObj.ehlo()
smtpObj.starttls()
smtpObj.login('******************@gmail.com',
'***************')
print(smtpObj.sendmail('******************@gmail.com',\
'******************@gmail.com',\
'Subject: ' + str(today) + ' | Stock to sell after 2% gains: ' + str(ticker) + '.\nSell this stock' + '\n'))
smtpObj.quit()
#Text me
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (2% gain): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#Text Scott
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (2% gain): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#Text Carl
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (2% gain): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#remove from portfolio
portfolio.remove(stock)
bought_price.remove(price)
checked.append(stock)
f = open("portfolio.txt", "r+")
d = f.readlines()
f.seek(0)
for i in d:
if i != str(stock + '\n'):
f.write(i)
f.truncate()
f.close()
f = open("bought_price.txt", "r+")
d = f.readlines()
f.seek(0)
for i in d:
if i != str(price + '\n'):
f.write(i)
f.truncate()
f.close()
checked.append(stock)
elif float(current_price
) < .95 * float(price) and stock not in checked:
#Email
today = datetime.datetime.today()
today = today.strftime('%m/%d/%Y %I:%M %p')
smtpObj = smtplib.SMTP('smtp.gmail.com', 587)
smtpObj.ehlo()
smtpObj.starttls()
smtpObj.login('******************@gmail.com',
'***************')
print(smtpObj.sendmail('******************@gmail.com',\
'******************@gmail.com',\
'Subject: ' + str(today) + ' | Stock to sell after 5% losses: ' + str(ticker) + '.\nSell this stock' + '\n'))
smtpObj.quit()
#Text me
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '+***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (5% loss): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#Text Scott
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (5% loss): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#Text Carl
accountSID = '***************'
authToken = '***************'
twilioCli = TwilioRestClient(accountSID, authToken)
myTwilioNumber = '***************'
myCellPhone = '+***************'
message = twilioCli.messages.create(
body='Yo, sell this stock (5% loss): ' + str(ticker),
from_=myTwilioNumber,
to=myCellPhone)
#Remove from portfolio
portfolio.remove(stock)
bought_price.remove(price)
stock = stock.upper()
f = open("portfolio.txt", "r+")
d = f.readlines()
f.seek(0)
for i in d:
if i != str(stock + '\n'):
f.write(i)
f.truncate()
f.close()
f = open("bought_price.txt", "r+")
d = f.readlines()
f.seek(0)
for i in d:
if i != str(price + '\n'):
f.write(i)
f.truncate()
f.close()
checked.append(stock)
else:
pass
except Exception as e:
print(e)
pass
url = active_xml)
print "ok"
except TwilioRestException as e:
if "21211" in e.msg or "13224" in e.msg:
print "bad number"
return False
elif "21215" in e.msg:
print "international number: %s" % number
return False
else:
raise e
return True
account = "TWILIO_ACCOUnt_ID_HERE"
token = "TWILIO_AUTH_TOKEN_HERE"
client = TwilioRestClient(account, token)
number_re = re.compile(r'^\d{10}$')
os.chdir(os.path.dirname(sys.argv[0]))
db_path = './numbers.sqlite'
db = sqlite3.connect(db_path)
c = db.cursor()
parser = optparse.OptionParser()
options, args = parser.parse_args()
if len(args) == 0:
print "usage: %s command..."
exit(1)
def sendMessage(to, from_, body):
client = TwilioRestClient('ACeb797975cb0ac7c3680042a67753399b',
'cab43fc750fdc1309bebc5757407262c')
client.messages.create(from_=from_, to=to, body=body)
#!/usr/bin/env python3
import os
from twilio.rest import TwilioRestClient
from flask import Flask, request
from two1.wallet import Wallet
from two1.bitserv.flask import Payment
app = Flask(__name__)
wallet = Wallet()
payment = Payment(app, wallet)
# create the twilio rest client
client = TwilioRestClient(os.environ.get('TWILIO_ACCOUNT_SID'),
os.environ.get('TWILIO_AUTH_TOKEN'))
@app.route('/send-sms')
@payment.required(1000)
def send_sms():
"""Send an sms for bitcoin"""
text = request.args.get('text')
client.messages.create(to=os.environ.get('MY_PHONE_NUMBER'),
from_=os.environ.get('TWILIO_PHONE_NUMBER'),
body=text)
return "Message sent."
# set up and run the server
if __name__ == '__main__':
class TwilioClient(object):
CORP_FMT = '''Company: {}
Last price: {:.2f}
Ask: {:.2f}
Bid: {:.2f}'''
COUNTRY_FMT = '''Country: {}
Population: {:.0f} million
Unemployment rate: {:.3f}%'''
BASE_FMT = '''
<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Message>{}.</Message>
</Response>
'''
MEDIA_FMT = '''
<?xml version="1.0" encoding="UTF-8"?>
<Response>
<Message>
<Media>{}</Media>
<Body>{}.</Body>
</Message>
</Response>
'''
REJ_FMT = "Nothing recognized."
PRIV_FMT = "This company is not privately traded."
OUR_NUM = "+16466473401"
def __init__(self,
tw_client_id=TW_CLIENT_ID,
tw_secret_key=TW_SECRET_KEY,
tw_app_id=TW_APP_ID):
self.acc_sid = tw_app_id
self.twilio = TwilioRestClient(tw_client_id, tw_secret_key)
@staticmethod
def _plusify(num):
return ("+{}" if not "+" in num else "{}").format(num)
def get_media(self, recvd):
return self.twilio.media(recvd.sid)
def _message(self, recvd, body, media=None):
message = self.twilio.messages.create(
body=body,
media_url=[media] if media else None,
to=self._plusify(recvd.sender),
from_=self.OUR_NUM)
print "sent message: ", message
def reject(self, recvd):
self._message(recvd, self.REJ_FMT)
def private(self, recvd):
self._message(recvd, self.PRIV_FMT)
def accept(self, recvd, best_match, info):
print "trying to accept ", info
self._message(recvd,
self.CORP_FMT.format(
best_match,
float(info['PX_LAST']),
float(info['PX_ASK']),
float(info['PX_BID'])))
def country(self, recvd, best_match, info):
self._message(recvd,
self.COUNTRY_FMT.format(
best_match.capitalize(),
float(info['WPOP']),
float(info['UNEMP'])))
def post(self, request, **kwargs):
""" Twilio is configured to POST to this URL when a text message is received.
1. Receive text message
2. Verify text message and continue if verified
3. Snap photo (use subprocess module)
4. Photo needs to be accessible via a URL
5. Use Twilio API to attach photo to SMS
"""
text_message = request.POST.get('Body')
requesting_phone_number = request.POST.get('From')
budgiecam_phone_number = request.POST.get('To')
context = {}
if self.FLIP_CAMERA_VERTICAL:
self.FLIP_CAMERA_VERTICAL = ['-vf']
else:
self.FLIP_CAMERA_VERTICAL = []
if self.FLIP_CAMERA_HORIZONTAL:
self.FLIP_CAMERA_HORIZONTAL = ['-hf']
else:
self.FLIP_CAMERA_HORIZONTAL = []
if self.LOW_LIGHT:
self.LOW_LIGHT = ['--drc', self.LOW_LIGHT]
else:
self.LOW_LIGHT = []
if text_message:
if BUDGIE_PASSPHRASE in text_message.lower():
if 'video' in text_message.lower():
try:
budgie_filename = '{0}.h264'.format(''.join(['{0:02d}'.format(x) for x in time.localtime()[:6]]))
# raspivid -o video.h264 -t 10000
subprocess.call(['raspivid', '--nopreview', '-t', '30000','-o', '{0}{1}'.format(BUDGIE_FILE_PATH, budgie_filename)] + self.FLIP_CAMERA_VERTICAL + self.FLIP_CAMERA_HORIZONTAL + self.LOW_LIGHT)
# This would convert the h264 video to mp4 but unfortunately it doesn't run quickly enough on the Raspberry Pi
# Maybe later versions of the Pi would be able to handle it, but this one can't.
# try:
# print "\t Converting {0} to mp4".format(budgie_filename)
# subprocess.call([
# 'ffmpeg',
# '-i',
# '{0}{1}'.format(BUDGIE_FILE_PATH, budgie_filename),
# "{0}{1}.mp4".format(BUDGIE_FILE_PATH, budgie_filename[:-5])
# ])
# except Exception:
# print "[ERROR] Failed to convert {0} to mp4".format(budgie_filename)
# else:
# subprocess.call([
# 'rm',
# '{0}{1}'.format(BUDGIE_FILE_PATH, budgie_filename)
# ])
# budgie_filename = "{0}.mp4".format(budgie_filename[:-5])
except Exception, e:
print "[ERROR] Call to raspivid failed; could not take video ({0}: {1}{2})".format(e, BUDGIE_FILE_PATH, budgie_filename)
else:
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
client.messages.create(
to=requesting_phone_number,
from_=budgiecam_phone_number,
body="Video ready here: {0}{1}{2}".format(RASPI_IP, BUDGIE_WEB_PATH, budgie_filename)
)
context['response'] = '200'
elif 'audio' in text_message.lower():
try:
budgie_filename = '{0}.wav'.format(''.join(['{0:02d}'.format(x) for x in time.localtime()[:6]]))
subprocess.call(['arecord', '-d', '15', '--device=hw:1,0', '--format', 'S16_LE', '--rate', '44100', '-c1', '{0}{1}'.format(BUDGIE_FILE_PATH, budgie_filename)])
except Exception, e:
print "[ERROR] Call to arecord failed; could not record audio. ({0}: {1}{2})".format(e, BUDGIE_FILE_PATH, budgie_filename)
context['response'] = '500'
else:
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
client.messages.create(
to=requesting_phone_number,
from_=budgiecam_phone_number,
body="Audio ready here: {0}{1}{2}".format(RASPI_IP, BUDGIE_WEB_PATH, budgie_filename),
)
context['response'] = '200'
else:
try:
budgie_filename = '{0}.jpg'.format(''.join(['{0:02d}'.format(x) for x in time.localtime()[:6]]))
subprocess.call(['raspistill', '--nopreview', '-t', '5000', '-o', "{0}{1}".format(BUDGIE_FILE_PATH, budgie_filename)] + self.FLIP_CAMERA_VERTICAL + self.FLIP_CAMERA_HORIZONTAL + self.LOW_LIGHT)
except Exception, e:
print "[ERROR] Call to raspistill failed; could not take photo ({0}: {1}{2})".format(e, BUDGIE_FILE_PATH, budgie_filename)
context['response'] = '500'
else:
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
# A list of member objects with the properties described above
members = client.members('QU5ef8732a3c49700934481addd5ce1659').list()
#sending text messages
import twilio
import twilio.rest
from twilio.rest import TwilioRestClient
accountSID = 'ACbcccf5d7007895a74e45fac4f5ce2e39'
authtoken = 'da98937a6467f2a584ca6b3a725871a2'
twilio = TwilioRestClient(accountSID, authtoken)
mynumber = '+15129483374'
try:
cellphone = input("enter the recepient phone number")
message = twilio.messages.create(body=input('enter message'),
from_=mynumber,
to=cellphone)
except Exception as e:
print("please enter a valid phone number")
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN")
self.task_router_client = TwilioTaskRouterClient("ACCOUNT_SID",
"AUTH_TOKEN")
import random import pickle import math #this file has your account info # Parameters you need to supply Taccount, Ttoken, Tnumber, To_number # # wehre to put the twillo account information #Taccount= 'twillo account' #Ttoken ='twillo token' #Tnumber = 'Twillo number' #To_number = 'NUMBER TO CALL' from twilloaccount import * # twillo account: password: ... username: [email protected] from twilio.rest import TwilioRestClient client = TwilioRestClient(account=Taccount, token=Ttoken) # read SPI data from MCP3008 chip, 8 possible adc's (0 thru 7) #single endded ADC right now. def readadc(adcnum, clockpin, mosipin, misopin, cspin): if ((adcnum > 7) or (adcnum < 0)): return -1 GPIO.output(cspin, True) GPIO.output(clockpin, False) # start clock low GPIO.output(cspin, False) # bring CS low commandout = adcnum commandout |= 0x18 # start bit + single-ended bit # commandout &= 0xF7 # make the differential bit zero (bit 4) for diff adc (ch0-ch1)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
client.participants('CFbbe4632a3c49700934481addd5ce1659'
).delete("CA386025c9bf5d6052a1d1ea42b4d16662")
# To allow python 2.7.6 to send safe http requests
http = urllib3.PoolManager(
cert_reqs='CERT_REQUIRED', # Force certificate check.
ca_certs=certifi.where(), # Path to the Certifi bundle.
)
#loads account_sid and auth_token from private space
config = imp.load_source('config', '../sensitive_data/config.py')
#for heroku. need to improve security
TWILIO_ACCOUNT_SID = config.TWILIO_ACCOUNT_SID
TWILIO_AUTH_TOKEN = config.TWILIO_AUTH_TOKEN
app = Flask(__name__, template_folder='templates')
app.secret_key = config.SECRET_KEY
gmaps = googlemaps.Client(key=config.GMAPS_KEY)
client = TwilioRestClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
#search radius for app
SEARCH_RADIUS = 1000.0
# connect to testdbdoc database
try:
con = db.connect(database="lifeline", user="******", password="******", host="localhost")
print 'Successfully connected to databases!'
cur = con.cursor()
except:
print 'Failed to connect to database.'
@app.route('/receivemessage', methods = ['GET', 'POST'])
def receivemessage():
def setUp(self):
self.client = TwilioRestClient("ACCOUNT_SID", "AUTH_TOKEN", timeout=sentinel.timeout)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "{{ auth_token }}"
client = TwilioRestClient(account_sid, auth_token)
member = client.members('QU5ef8732a3c49700934481addd5ce1659').dequeue("http://demo.twilio.com/docs/voice.xml", "CA5ef8732a3c49700934481addd5ce1659", method="POST")
print member.position
import bottle
import pymongo
import datetime
import time
import threading
from twilio.rest import TwilioRestClient
from twilio import twiml
from twilio.util import RequestValidator
# suck in the Twilio account creds
execfile(os.environ['OPENSHIFT_REPO_DIR'] + "twilio_creds", globals(),
locals())
# todo, cleanly handle failure
twilio_client = TwilioRestClient(twilio_account, twilio_token)
twilio_validator = RequestValidator(twilio_token)
# connect to the OpenShift MongoDB
mongo_con = pymongo.Connection(os.environ['OPENSHIFT_NOSQL_DB_HOST'],
int(os.environ['OPENSHIFT_NOSQL_DB_PORT']))
mongo_db = mongo_con[os.environ['OPENSHIFT_APP_NAME']]
mongo_db.authenticate(os.environ['OPENSHIFT_NOSQL_DB_USERNAME'],
os.environ['OPENSHIFT_NOSQL_DB_PASSWORD'])
# todo, cleanly handle failure
def worker():
while True:
# todo, wait on a trigger condition, instead of polling
def get_twilio_client():
return TwilioRestClient(settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
# A list of participant objects with the properties described above
participants = client.participants('CFbbe4632a3c49700934481addd5ce1659').list()
def textmyself(message):
twilioCli = TwilioRestClient(accountSID, authToken)
twilioCli.messages.create(body=message, from_=twilioNumber, to=myNumber)
sSid = ""
sSMSSender = ""
GPIO_PIN = 23
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIO_PIN, GPIO.OUT)
# Unfortunately, you can't delete SMS messages from Twilio's list.
# So we store previously processed SIDs into the database.
lstSids = list()
lstAuthorized = list() # authorized phone numbers, that can open the garage
# Connect to local MySQL database
con = MySQLdb.connect('localhost', 'garage', 'garagepassword', 'GarageDoor')
# Twilio client which will be fetching messages from their server
TwilioClient = TwilioRestClient(twilio_account_sid, twilio_auth_token)
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# FUNCTIONS
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This function sends an SMS message, wrapped in some error handling
def SendSMS(sMsg):
try:
sms = TwilioClient.sms.messages.create(
body="{0}".format(sMsg),
to="{0}".format(sSMSSender),
from_="{0}".format(sTwilioNumber))
except:
print "Error inside function SendSMS"
def connect(self):
self.client = TwilioRestClient(self.account_sid, self.auth_token)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "{{ account_sid }}"
auth_token = "{{ auth_token }}"
client = TwilioRestClient(account_sid, auth_token)
# A list of media objects with the properties described above
medias = client.media('MM800f449d0399ed014aae2bcc0cc2f2ec').list()
def make_twilio():
client = TwilioRestClient(account_sid, auth_token)
return client
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
member = client.members('QU5ef8732a3c49700934481addd5ce1659'
).get("CA386025c9bf5d6052a1d1ea42b4d16662")
print(member.wait_time)
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import TwilioRestClient
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
auth_token = "your_auth_token"
client = TwilioRestClient(account_sid, auth_token)
# A list of dependent phone number objects
numbers = client.dependent_phone_numbers(
'AD2a0747eba6abf96b7e3c3ff0b4530f6e').list()
for number in numbers:
print(number.friendly_name)
