'''
Alexa Request Server
For CLIVE
Built in in flask
'''
from flask import Flask
from flask_ask import Ask, statement, question, session
import json
import requests
import time
import unidecode
app = Flask(__name__)
ask = Ask(app, "/clive_reader")
def get_clive_info():
pass
@app.route('/')
def homepage():
return "hi there, how you doin"
if __name__ == "__main__":
app.run(debug=True, port=8443)
from flask import Flask
from flask_ask import Ask, statement, question, session
import json, requests, time, random
from steem import Steem
from steem.account import Account
from steem.instance import set_shared_steemd_instance
from steem.steemd import Steemd
session = requests.Session()
app = Flask(__name__)
ask = Ask(app, "/steem_assistant")
s = Steem(nodes=["https://api.steemit.com", "https://rpc.buildteam.io"])
steemd_nodes = [
'https://api.steemit.com/',
'https://gtg.steem.house:8090/',
'https://steemd.steemitstage.com/',
'https://steemd.steemgigs.org/'
'https://steemd.steemit.com/',
]
set_shared_steemd_instance(Steemd(nodes=steemd_nodes)) # set backup API nodes
nickname = "ned" # THIS WILL BE INTEGRATED WITH STEEMCONNECT WHEN I GET A HOLD OF HOW TO USE IT, FOR NOW, FOR TESTING PURPOSES, THE NICKNAME IS HARDCODED.
class SteemUser:
def __init__(self, username):
self.username = username
self.session = Account(self.username, steemd_instance=s)
self.wallet = {
"steem_balance":
class flotapp(mp.Process):
app = Flask(__name__)
ask = Ask(app, "/")
logging.getLogger("flask_ask").setLevel(logging.DEBUG)
def __init__(self):
super(flotapp, self).__init__()
@ask.launch
def welcome():
msg = render_template('welcome')
reprompt = render_template('prompt')
if g.client is not None:
# with app.app_context():
print('Client: {}'.format(g.client[0]))
else:
print('g.client is None')
return question(msg).reprompt(reprompt)
@ask.intent("SelfieIntent")
def selfie():
msg = None
image = None
if g.client is not None:
# with app.app_context():
print('Client: {}'.format(g.client[0]))
else:
print('g.client is None')
if image is not None:
# cur_stamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d_%H%M%S')
# Image.fromarray(image).save(cur_stamp + ".jpeg")
msg = render_template('selfie_ok')
else:
msg = render_template('selfie_fail')
return question(msg)
@ask.intent("YesIntent")
def yes():
msg = render_template('yes_retake')
return question(msg)
@ask.intent("NoIntent")
def no():
msg = render_template('no_retake')
return question(msg)
@ask.intent("StopIntent")
def stop():
msg = render_template('stop')
return statement(msg)
def run(self):
self.app.run(debug=True)
def updateClient(self, client):
with self.app.app_context():
g.client = client
# Written By Mourad Lasga
import json, time
from flask import Flask
from flask_ask import Ask, statement, question, session
app = Flask(__name__)
ask = Ask(app, '/iot-and-me')
@app.route('/')
def homepage():
return "Hi, how are you doing?"
@ask.launch
def start_skill():
welcome_message = "Hi, ask me a specific question?"
return question(welcome_message)
@ask.intent('QuestionOneIntent')
def question_1():
output = "Nothing Much. I\'ve heard that MozFest is cool, especially IoT & Me!"
with open('./alexa.txt', 'w') as alexa_responses:
alexa_responses.write('1')
return statement(output)
@ask.intent('QuestionTwoIntent')
def question_2():
def create(logger):
app = Flask(__name__)
ask = Ask(app, '/daikin')
units = discover()
@ask.launch
def launch():
logger.debug('launch')
return question('What would you like to do?') \
.reprompt("I didn't get that. What can I do for you?")
@ask.on_session_started
def new_session():
logger.debug('session started')
@ask.session_ended
def session_end():
logger.debug('session ended')
return statement('Something went wrong')
@ask.intent('AMAZON.StopIntent')
def stop():
logger.debug('stop')
return statement('Ok')
@ask.intent('AMAZON.CancelIntent')
def stop():
logger.debug('cancel')
return statement('Ok')
@ask.intent('AMAZON.HelpIntent')
def help():
logger.debug('help')
intro = 'Try something like "switch on living" or "what is the temperature?".'
message = intro + ' What do you wish to do?'
card_content = intro + ""
return question(message) \
.simple_card(
title= 'Things to try',
content= card_content
)
@ask.intent('Temperature', mapping= {'alias': 'Unit'})
def temperature(alias):
logger.debug('temperature')
result = units.apply(alias, lambda u: u.temperature())
if not result:
return question('{} not found. Anything else?'.format(alias))
message = ''
content = ''
for u,t in result.iteritems():
message += '{} temperature is {} degrees, '.format(u, t.inside)
content += '{}: {}°\n'.format(u.capitalize(), t.inside)
message += 'outside temperature is {} degrees. '.format(t.outside)
content += 'Outside: {}°\n'.format(t.outside)
return question('{} Anything else?'.format(message)) \
.simple_card(
title= 'Temperature',
content= content
)
@ask.intent('Mode', mapping= {'alias': 'Unit'})
def mode(alias):
logger.debug('mode')
result = units.apply(alias, lambda u: u.mode())
if not result:
return question('{} not found. Anything else?'.format(alias))
message = ''
content = ''
count_off = 0
for u,m in result.iteritems():
if m.power:
message += '{} is on and set to {} degrees, '.format(u, m.temperature)
content += '{}: {}°\n'.format(u.capitalize(), m.temperature)
else:
count_off += 1
message += '{} is off, '.format(u)
content += '{}: off'.format(u.capitalize())
if count_off == len(result):
message = 'all off.'
content = 'All off'
return question('{} Anything else?'.format(message)) \
.simple_card(title= 'Status',
content= content)
@ask.intent('Off', mapping= {'alias': 'Unit'})
def off(alias):
logger.debug('off')
result = units.apply(alias, lambda u: u.off())
if not result:
return question('{} not found. Anything else?'.format(alias))
if len(result) == 1:
message = '{} is off, '.format(alias)
else:
message = 'all off'
return statement(message)
@ask.intent('On', mapping= {'alias': 'Unit'})
def on(alias):
logger.debug('on')
result = units.apply(alias, lambda u: u.on())
if not result:
return question('{} not found. Anything else?'.format(alias))
if len(result) == 1:
message = '{} is on, '.format(alias)
else:
message = 'all on'
return statement(message)
return app
from flask import Flask, request, jsonify, Response, render_template
from flask_ask import Ask, question, statement
import requests
import json
import cv2
import numpy as np
import os
import matplotlib.pyplot as plt
from twilio_test import send_msg
import time
from heart_beat_code import appropriate_H_R
TEMP_FOLDER = './temp'
app = Flask('Third Eye')
ask = Ask(app, '/alexa')
nodes = {'bathroom': '192.168.43.23'}
pi_ip = "http://192.168.43.138:5000"
pulse_list = []
pulse_start = time.time()
@app.route('/test')
def test():
return "Hello"
'''
ALEXA INTENTS
'''
# -*- coding:utf-8 -*-
import logging
import os
from flask import Flask, json, Blueprint, render_template
from flask_ask import Ask, request, session, question, statement
session = Blueprint('session',
__name__,
url_prefix="/session",
static_folder='./session_jp')
ask = Ask(blueprint=session)
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
COLOR_KEY = "COLOR"
@ask.launch
def launch():
card_title = render_template('card_title')
question_text = render_template('welcome')
reprompt_text = render_template('welcome_reprompt')
return question(question_text).reprompt(reprompt_text).simple_card(
card_title, question_text)
@ask.intent('MyColorIsIntent', mapping={'color': 'Color'})
def my_color_is(color):
card_title = render_template('card_title')
class Record():
def __init__(self, rank, artist, song):
self.rank = rank
self.artist = artist
self.song = song
def __str__(self):
return '{} by {}'.format(self.song, self.artist)
url = 'http://www.billboard.com/charts/hot-100'
source = urllib.request.urlopen(url)
soup = bs.BeautifulSoup(source, 'lxml')
app = Flask(__name__)
ask = Ask(app, "/billboard-top-ten")
@ask.launch
def start_skill():
return share_top_ten()
@ask.intent("YesIntent")
def share_top_ten():
return statement("Here are the top 10 songs for today: {}".format(
stringify_records(get_records())))
@ask.intent("NoIntent")
def no_intent():
import logging
import os
from multiprocessing import Process
from flask import Flask
from flask_ask import Ask, question, statement
import ahlogger
import media_downloader
from messaging import launcher, mqtt_publish
from services import calendar_service
app = Flask(__name__)
ask = Ask(app, "/alexa/home")
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
@app.route('/alexa')
def homepage():
return "Hi there, how ya doin?"
@ask.launch
def launch():
speech_text = 'Welcome to the Alexa Skills Kit, you can say hello'
return question(speech_text).reprompt(speech_text).simple_card(
'HelloWorld', speech_text)
@ask.intent('HelloWorldIntent')
def hello_world():
import logging
from random import shuffle
from flask import Flask, render_template
from flask_ask import Ask, statement, question, session
logging.getLogger("flask_ask").setLevel(logging.DEBUG)
application = Flask(__name__)
ask = Ask(application, '/dinnerbot')
test_data = [
'spaghetti and meatballs',
'fried rice',
'that sausage and tortellini thing',
'hamburgers',
'ham steaks',
'tacos',
'pot roast',
'fried catfish',
'steak',
]
@application.route('/')
def index():
return "dinnerbot"
@ask.launch
def dinnerbot_launch():
welcome_msg = render_template('welcome')
# import flask
## pip install cryptography==2.1.0
## ngrok http 5000
## we had to downgrade pip to a different version
##
# import the following
from flask import Flask
from flask_ask import Ask, statement, question, session
import json
import ast
import requests
import time
import unidecode
app = Flask(__name__)
ask = Ask(app, "/adelphi_calendar")
def get_event_date(event, semester):
# default value for date if event is not found
date = 0
#JSON files stored as the semester name
with open(semester + ".json") as json_file:
data = json.load(json_file)
# convert to dictionary
data = ast.literal_eval(data)
for keys, values in data.items():
if event.lower() in values.lower():
date = keys
import logging
from flask import Flask
from flask_ask import Ask, statement, question, session
import reddit_play
import random
app = Flask(__name__)
ask = Ask(app, "/joke_search_for_reddit")
logging.getLogger("flask_ask").setLevel(logging.DEBUG)
@ask.launch
def ask_joke_type():
welcome = "Welcome! What kind of joke would you like to hear?"
return question(welcome).reprompt('What kind of joke would you like?')
@ask.intent("JokeType")
def tell_joke(joke_type=None):
try:
if joke_type is None:
joke_type = 'funny'
jokehead, joke, joke_type = reddit_play.get_joke(joke_type)
msg = "I couldn't understand you, so instead I'll tell you one of my favorite jokes. "
else:
jokehead, joke, joke_type = reddit_play.get_joke(joke_type)
if joke_type in ['funny', 'dirty', 'dad']:
if args.password:
print("ADOP password:"******"Missing [--password] flag:", args.password)
sys.exit(0)
if args.driver:
print("Using driver:", args.driver)
else:
print("Missing [--driver chrome|firerfox|firefox-esr] flag:", args.driver)
sys.exit(0)
sys.stdout.flush()
# Web Wervice ---------------------------------------------
app = Flask(__name__)
ask = Ask(app, "/platform")
# Global Variables
driver = None
tabs = None
ADOP_HOST = args.host
ADOP_USER = args.user
ADOP_PASS = args.password
SELENIUM_DRIVER = args.driver
BINARY = FirefoxBinary("/usr/lib/firefox-esr/firefox-esr")
# Pages that will be opened at Browser
pages = {
'adop': {
'page': 'http://{}:{}@{}/'.format(ADOP_USER, ADOP_PASS, ADOP_HOST),
'tab': ''
from flask import Flask
from flask_ask import Ask, statement, question, session
import json
import requests
import time
import unidecode
import random
app = Flask(__name__)
ask = Ask(app, "/fact")
@app.route('/')
def homepage():
return 'hello world skill running perfectly fine :)'
def getfact():
facts = [
'first christmas fact', 'second christmas fact',
'third christmas fact', 'fourth christmas fact', 'five christmas fact',
'six christmas fact', 'seven christmas fact', 'eight christmas fact',
'nine christmas fact', 'ten christmas fact'
]
return random.choice(facts)
@ask.launch
def launch():
fact = getfact()
thread = Thread(target=moveup)
thread.start()
response = "The couch is now moving {} ".format(direction)
elif direction == "down":
thread = Thread(target=movedown)
thread.start()
response = "The couch is now moving {} ".format(direction)
else:
GPIO.output(PINS[0], GPIO.LOW)
GPIO.output(PINS[1], GPIO.LOW)
GPIO.output(PINS[2], GPIO.LOW)
response = "Invalid Direction"
else:
response = "The couch is currently moving please try again in a few moments"
return statement(response)
APP = Flask(__name__)
ASK = Ask(APP, "/")
CURRENTLY_RUNNING = 0
GPIO.setmode(GPIO.BCM)
PINS = (9, 10, 11)
if __name__ == "__main__":
try:
for pin in PINS:
GPIO.setup(pin, GPIO.OUT)
APP.run(debug=True)
finally:
GPIO.cleanup()
from flask import Flask
from flask_ask import Ask, statement, session, question
from datetime import datetime
import delighted_clock as dl
import multiprocessing
import psutil
import os
app = Flask(__name__)
ask = Ask(app, "/skill")
dct = {}
@app.route('/')
def homepage():
return "hi there, how is it going."
def print_console(msg):
pounds = '#'
print(len(msg))
for i in range(len(msg) + 7):
pounds += '#'
print('\n' + pounds)
print('# ' + msg + ' #')
print(pounds + '\n')
@ask.launch
def satart_skill():
welcome_msg = 'Hello there, can I help you?'
from flask import Flask
from flask_ask import Ask, statement, question, session
import os
import random
import time
app = Flask(__name__)
ask = Ask(app, "/darwin")
encode = {"walk": '1', "balance": 2, "stand": '2'}
@app.route('/')
def homepage():
return "hi there, how ya doin?"
@ask.launch
def start_skill():
welcome_message = 'Hello there! would you like me to do something for you?'
return question(welcome_message)
def execute(motion):
print motion
flag = True
with open('file.txt', 'r') as file:
value = file.read()
if value != '-1' and len(value) != 0:
flag = False
if flag:
from threading import Timer
import time
from datetime import *
import geocoder
from dateutil.parser import parse
from isodate import parse_time
import logging
import sys
from geopy.distance import vincenty
# Alexa Skill credentials are stored separately as an environment variable
APP_ID = os.environ['APP_ID']
# Hosting service looks for an 'application' callable by default.
application = Flask(__name__)
ask = Ask(application, '/')
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
#Flag to use userId/password or token
def use_token():
if os.environ['USE_TOKEN'] == "YES":
return True
else:
return False
# Check if Alexa Skill credentials included OAUTH token
def passed_token():
if hasattr(session, 'user') and hasattr(session.user, 'accessToken'):
if format(session.user.accessToken) == "None":
# -*- coding:utf-8 -*-
import logging
import os
from flask import Flask, json, Blueprint, render_template
from flask_ask import Ask, request, session, question, statement, audio
todaykoh = Blueprint('todaykoh',
__name__,
url_prefix="/todaykoh",
static_folder='./todaykoh')
## print (__name__) // todaykoh.session
ask = Ask(blueprint=todaykoh)
log = logging.getLogger()
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
end = 8
level = int(end / 2)
@ask.launch
def launch():
card_title = render_template('card_title')
msg = "today card_title:%s" % card_title
print(msg)
question_text = render_template('welcome')
msg = "today question_text:%s" % question_text
print(msg)
question_text_card = render_template('welcome_card')
from flask import Flask, render_template
from flask_ask import Ask, statement, question
import time
from pyvcapi import *
app = Flask(__name__)
ask = Ask(app, "/hackathon")
@app.route('/')
def homepage():
return 'Flask Server is Running Successfully'
@ask.launch
def start_skill():
welcome_message = "Welcome to the hackathon, ask me a question and i'll give you some answers"
return question(welcome_message)
@ask.intent('currentDateIntent')
def current_date():
currentDate = time.strftime("%d/$m/%Y")
return statement("The current date is " + currentDate)
@ask.intent('getvcHealthIntent')
def get_vcenter_health():
health = get_vcenter_health_status()
return statement("The health of your vCenter environment is {}".format(health))
question,
responselogger=self)
except Exception as e:
print("Error asking Alexa: ", e)
return response
if __name__ == "__main__":
ALEXA_CLIENT = None
print("Initiating Alexa Client...")
APP = Flask(__name__)
print("Initiating Ask Client...")
ask = Ask(APP, "/")
@ask.launch
def launch_boracle():
response = APP.get_launch_message()
return question(response)
@ask.intent("AskBoracle")
def ask_boracle(text):
response = APP.ask_question('alexa', text)
return question(response)
@ask.intent("AskWho")
def ask_who(text):
question = "WHO " + text
response = APP.ask_question('alexa', question)
from flask import Flask, render_template
from flask_ask import Ask, statement, question, session
import json
import requests
import time
from datetime import datetime
import logging
from utils import get_nearest_weekend_date, parse_events_to_speech
from get_listings import generate_url, get_and_parse_events, choose_events
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
app = Flask(__name__)
ask = Ask(app, "/comrade_resident_advisor")
@ask.launch
def start_skill():
logging.info('entering Comrade Resident Advisor')
welcome_message = 'Welcome to comrade resident advisor, Which city and date would you like events information for?'
return question(welcome_message)
@ask.intent('EventsIntent',
convert={'eventDate': 'date'},
default={
'eventCity': 'london',
'eventDate': get_nearest_weekend_date(datetime.now())
}
)
def read_events(eventCity, eventDate):
from flask import Flask, session, request, redirect, render_template, url_for
from flask_ask import Ask, statement, question
from twitter_client import TwitterClient
import tweepy
import tokens
app = Flask(__name__)
ask = Ask(app, "/twitter_skill")
CALLBACK_URL = 'http://*****:*****@app.route("/")
def send_token():
auth = tweepy.OAuthHandler(tokens.CONSUMER_KEY, tokens.CONSUMER_SECRET,
CALLBACK_URL)
redirect_url = auth.get_authorization_url()
session['request_token'] = auth.request_token
return redirect(redirect_url)
@app.route("/verify")
def get_verification():
verifier = request.args['oauth_verifier']
auth = tweepy.OAuthHandler(tokens.CONSUMER_KEY, tokens.CONSUMER_SECRET)
token = session['request_token']
del session['request_token']
def setUp(self):
self.ask_patcher = patch('flask_ask.core.find_ask', return_value=Ask())
self.ask_patcher.start()
from flask import Flask
from flask_ask import Ask, statement, question, session
from account_info import USERNAME, PASSWORD
import json
import requests
import time
import unidecode
app = Flask(__name__)
ask = Ask(app, "/reddit_reader")
subreddit = "hockey"
reddit_url = "https://www.reddit.com"
reddit_api_url = "{}/api/login".format(reddit_url)
def get_reddit_data():
user_pass_dict = {'user': USERNAME, 'passwd': PASSWORD, 'api_type': 'json'}
sess = requests.Session()
sess.headers.update({'User-Agent': 'Testing Alexa: Ray'})
print(reddit_api_url)
sess.post(reddit_api_url, data=user_pass_dict)
# REDDIT API is picky when making rapid API calls
time.sleep(1)
url = "{}/r/{}/.json?limit=5".format(reddit_url, subreddit)
html = sess.get(url)
data = json.loads(html.content.decode("utf-8"))
titles = [
unidecode.unidecode(listing['data']['title'])
for listing in data['data']['children']
] # flake8: noqa
titles = '...'.join([i for i in titles])
import random
import redis
import flask
from flask_ask import Ask, statement, question
from config import REDIS_URL
CONTAINER_CHOICES = [
"nginx", "redis", "busybox", "ubuntu", "alpine", "registry", "mysql",
"mongo", "elasticsearch", "hello-world", "swarm", "postgres", "node",
"httpd", "logstash", "debian", "centos", "wordpress", "ruby", "python",
"kibana", "java", "jenkins", "php", "rabbitmq", "consul", "golang",
"docker", "haproxy", "mariadb"
]
app = flask.Flask(__name__)
ask = Ask(app, "/alexa")
r = redis.StrictRedis.from_url(REDIS_URL)
pubsub = r.pubsub()
pubsub.subscribe(["hunter"])
client = docker.DockerClient(base_url='unix://var/run/docker.sock',
version='auto')
state_next = None
@ask.intent('DockerChaosIntent')
def docker_chaos():
containers = client.containers.list()
if not containers:
return statement("Can't find anything to kill")
from flask import Flask, render_template
from flask_ask import Ask, statement
app = Flask(__name__)
ask = Ask(app, '/')
@ask.intent('HelloIntent')
def hello(firstname):
text = render_template('hello', firstname=firstname)
return statement(text).simple_card('Hello', text)
def main(debug=True):
app.run(debug=debug)
if __name__ == '__main__':
main()
from flask import Flask, render_template
from flask_ask import Ask, statement, question, session
import pywinauto.application, pywinauto.findwindows
f_app = Flask(__name__)
ask = Ask(f_app, '/System_Control')
def startApplication(application):
app = pywinauto.application.Application().start(application)
return app
def closeApplication(application):
search_str = ".*" + application + ".*"
if (len(pywinauto.findwindows.find_elements(title_re=search_str)) != 1):
print("Not specific enough, sorry")
print("Applicable values:")
for i in pywinauto.findwindows.find_elements(title_re=search_str):
print(i.name)
else:
app = pywinauto.application.Application()
app.connect(title_re=search_str)
app.Kill_()
return
def keyInputtoApplication(application, inp):
searchAppString = ".*" + application
app = pywinauto.application.Application()
if (len(pywinauto.findwindows.find_elements(title_re=searchAppString)) !=
1):
from flask import Flask
from flask_ask import Ask, statement, question, session
import json
import requests
import time
import unidecode
app = Flask(__name__)
ask = Ask(app, "/")
def get_headlines():
titles = ["I am in new world", "hack the world"]
titles = '... '.join([i for i in titles])
return titles
@ask.intent('HelloIntent')
def hello(firstname):
speech_text = "Hello %s" % firstname
return statement(speech_text).simple_card('Hello', speech_text)
@ask.launch
def start_skill():
print("answering skill ... ")
r = requests.get('http://localhost:5000/time/pratik')
data = r.json()
answer = ""
for each_friends, each_time in data['timing']:
each_time = each_time.split("-")
from backend.database import db_session, ReminderEvents
from flask import Blueprint, render_template
from flask import current_app as capp
from flask_ask import Ask, question, statement, session
blueprint = Blueprint('event_reminders', __name__, url_prefix="/")
ask = Ask(blueprint=blueprint)
## Event reminder CRUD
@ask.launch
def startup():
welcome_msg = render_template('welcome')
capp.logger.info(session.user.userId)
print(session.user.userId)
return question(welcome_msg)
@ask.intent('ReminderEventDoneIntent', convert={'id': int})
def event_reminder_complete(id):
try:
r = db_session.query(ReminderEvents).filter(
ReminderEvents.id == id).first()
r.completed_since_last = True
db_session.commit()
return statement(render_template('reminder_completed'))
except:
return statement('Unable to find reminder {}'.format(id))
