def get_app():
app = Flask(__name__)
c = get_collector('order-mgmt')
add_routes(app, c)
add_metrics_route(app, c)
instrument_requests(app, c)
return app
# src/app.py
From flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world:
return 'Hey, we have Flask in a Docker container!'
if __name == '__main__':
app.run(debug=True, host='0.0.0.0')
rom flask import Flask
from flask import request
app=Flask(__name__)
@app.route('/')
def index(name ="student"):
name= request.args.get('name',name)
return"welcome {}".format(name)
@app.route('/home')
def home():
return "welcome home"
if __name__=='__main__':
app.run(host='0.0.0.0',port=8080)
import Flask
import random
app = Flask(__name__)
app.config['DEBUG'] = True # displays runtime errors in the browser, too
@app.route("/")
def index():
# choose a movie by invoking our new function
movie = get_random_movie()
# build the response string
content = "<h1>Movie of the Day</h1>"
content += "<ul>"
content += "<li>" + movie + "</li>"
content += "</ul>"
movie = get_random_movie()
content += "<h1>Movie for Tomorrow</h1>"
content += "<ul>"
content += "<li>" + movie + "</li>"
content += "</ul>"
# TODO: pick another random movie, and display it under
# the heading "<h1>Tommorrow's Movie</h1>"
return content
fromm flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
return render_template('template.html')
@app.route('/my-link/')
def my_link():
print 'I got clicked!'
return 'Click.'
if __name__ == '__main__':
app.run()
import scrape_mars
import from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
app = Flask(__name__)
app.config["MONGO_URI"] = "mongodb://*****:*****@app.route("/")
def index():
mars = mongo.db.mars.find()
return render_template("index.html", mars=mars)
@app.route("/scrape")
def scraper():
mars = mongo.db.mars
mars_data = scrape_mars.scrape()
mars.update({}, mars_data, upsert=True)
return redirect("/", code=302)
if __name__ == "__main__":
app.run(debug=True)
#!/usr/bin/python
# coding: utf8
From flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Flask Dockerized'
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0')
import logging
import os
import flask from Flask
from flask_ask import Ask, request, Statement, question, render_template
app = Flask(__name__)
ask = Ask(app,'/')
logging.getLogger('flask_ask').setLevel(logging.DEBUG)
@ask.launch
def launch():
return get_fact() #basically starting the act at the launch oh the application
@ask.intent('SomethingNew')
def get_fact():
tot_facts = 4
fact_i = randint(0,tot_facts-1) #random is used so that we dont have to create one exxtra question for next fact
fact_text = render_template('some_facts{}'.format(fact_i))
card_title = render_template('card_title')
return statement(fact_text).simple_card(card_title,fact_text)
@ask.intent('Amazon.HelpIntent') #standard alexa intent
def help_me():
hi = render_template('help')
return question(hi).reprompt(hi)
@ask.intent('Amazon.StopIntent') #standard alexa intent
def stop_it():
going = render_template('going now bye')
return statement(going)
From flask import Flask
app=Flask()
@app.route("/<var>")
def home(var=None):
return "Hlw bro" +str(var)
if __name__=="__name__":
app.run()
rom flask import Flask, flash, redirect, render_template, request, url_for
app = Flask(__name__)
app.secret_key = 'random string'
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login', methods = ['GET', 'POST'])
def login():
error = None
if request.method == 'POST':
if request.form['username'] != 'admin' or \
request.form['password'] != 'admin':
error = 'Invalid username or password. Please try again!'
else:
flash('You were successfully logged in')
return redirect(url_for('index'))
return render_template('login.html', error = error)
if __name__ == "__main__":
app.run(debug = True)
import Flask
import datetime
app = Flask(__name__)
app.config['TEMPLATES_AUTO_RELOAD'] = True
class sound:
def __init__(vol, direc, time):
self.vol = vol
self.dir = direc
self.time = time
import json
#result = es.search(index="movie_db", body={'query': {'match': {'description': 'CIA'}}})
from elasticsearch import Elasticsearch
es = Elasticsearch(['172.31.2.97'])
#result = es.search(index="test-31")
#print json.dumps(result, indent=2)
# setting up connections to cassandra
from cqlengine import connection
connection.setup(['52.88.228.98','52.11.49.170'], 'test')
#cluster = Cluster(['52.88.228.98','52.11.49.170'])
#session = cluster.connect('watch_events')
app = Flask(__name__)
api = Api(app)
# homepage
@app.route("/")
@app.route("/index")
def hello():
return render_template("index.html")
# graph query page
@app.route("/graph")
def graph():
return render_template("graph_query.html")
# get username and return graph
@app.route("/graph", methods=['POST'])
import os
import sqlite3
import flask import Flask, request, session, g, reirect, url_for, abort, render_template, flash
app = Flask(__name__) #Býr til app dæmið
app.config.from_object(__name__) #loadar stillingar frá þessum file, flaskr.py
#loadar sjálfgefnar stillingar og skrifar yfir stillingar frá umhverfis breytu
app.config.update(dict(
DATABASE=os.path.join(app.root_path, 'flaskr.db'),
SECRET_KEY='development key',
USERNAME='******',
PASSWORD='******'
))
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
def connect_db():
'''Tengir við ákveðinn gagnagrunn'''
rv = sqlite3.connect(app.config['DATABASE'])
rv.row_factory = sqlite3.Row
return rv
def init_db():
db = get_db()
with app.open_resource('schema.sql', mode='r') as f:
db.cursor().executescript(f.read())
db.commit()
@app.cli.command('initdb')
def initdb_command():
'''frumstillir gagnagrunnin'''
Ufrom flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
#kurylo
m flask import Flask app=Flask(__name__)@app.route("/")def hello(): return "hello World!"if __name__=="__main__": app.run(host="0.0.0.0",port=8080,debug=True)
rt urllib.request
import urllib.parse
import time
from bs4 import BeautifulSoup
class Zhilian(object):
def __init__(self, jl, kw, start_page, end_page):
# 保存到成员属性中，其他方法中才能直接使用
self.jl = jl
self.kw = kw
self.start_page = start_page
self.end_page = end_page
self.items = []
From flask os
From flask import Flask render_template, url_for, redirect
from flask_Sqlalchemy import sqlalchemy
From flask_migrate import migrate
app=Flask(__name__)
app. Config['secret_key']='mysecretkey'
Basedir=OS.path.absname(os.path.dirname(__file__)
app.config['SQLALCHEMY_DATABASE_URI']='sqlite:///'os.path.join(basedir, 'data_sqlite'
app. Config['SQLALCHEMY_TRACK_MODIFICATIONS']= false
db=SQLALCHEMY(app)
Migrate(app,Db)
Class puppy (db.model) :
_tablename_='puppies'
id=db.column(db.integer,primary key=true)
Name=db.column(db.text)
def __init__(self, name):
self. Name=name
def __repr__(self):
return f"puppy name is {self. Name}"
afrom flask import Flask, request
from flask_restful import Resource, Api
from sqlalchemy import create_engine
from json import dumps
from flask.ext.jsonpify import jsonify
from flask import send_file
from cv2 import *
import time
app = Flask(__name__)
engine = create_engine('oracle://*****:*****@127.0.0.1:1521/xe', convert_unicode=True)
@app.route("/getdata")
def getdata():
#conn = engine.connect()
#query = conn.execute("select * from employees") # This line performs query and returns json result
return ("asdfasd") # Fetches first column that is Employee ID
@app.route("/pic")
def index():
pic= str(time.time())
print(pic)
#conn = engine.connect()
#query = conn.execute("select * from employees") # This line performs query and returns json result
#return {'employees': [i[0] for i in query.cursor.fetchall()]} # Fetches first column that is Employee ID
# initialize the camera
cam = VideoCapture(0) # 0 -> index of camera
s, img = cam.read()
if s: # frame captured without any errors
rom flask import Flask, render_template, url_for, flash, redirect
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI']='mysql://*****:*****@localhost/naven'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
"""app.config.update(
TESTING=True,
SECRET_KEY=b'_5#y2L"F4Q8z\n\xec]/'
)"""
db = SQLAlchemy(app)
class Location(db.Model):
Location_id = db.Column(db.Integer, primary_key= True)
def __repr__(self):
return f"Location('{self.Location_id}')"
class Product(db.Model):
product_id = db.Column(db.Integer, primary_key= True)
def __repr__(self):
return f"Product('{self.Product_id}')"
class ProductMovement(db.Model):
Movement_id = db.Column(db.Integer, primary_key= True)
TimeStamp = db.Column(db.DateTime, default=datetime.utcnow)
From_Location = db.Column(db.String(20), nullable = False)
To_Location = db.Column(db.String(20), nullable = False)
Product_id= db.Column(db.Integer)
Product_qnty= db.Column(db.Integer, nullable = False)
from flask_sqlalchemy import SQLAlchemy
#database backup
from flask_migrate import Migrate
#form
from flask_wtf import FlaskForm
from wtforms import StringField,SubmitField
from wtforms.validators import DataRequired
#mail
from flask_mail import Mail
basedir=os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'
app.config['SQLALCHEMY_DATABASE_URI'] =\
'sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
#mail
app.config['MAIL_SERVER']='smtp.163.com'
app.config['MAIL_PORT']=465
app.config['MAIL_USE_SSL']=True
app.config['MAIL_USERNAME']=os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD']=os.environ.get('MAIL_PASSWORD')
db=SQLAlchemy(app)
migrate = Migrate(app,db)
From flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Flask Dockerized'
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0',port=5000)
gifrom flask import Flask, jsonify, render_template, request
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
##Connect to Database
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///cafes.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
##Cafe TABLE Configuration
class Cafe(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), unique=True, nullable=False)
map_url = db.Column(db.String(500), nullable=False)
img_url = db.Column(db.String(500), nullable=False)
location = db.Column(db.String(250), nullable=False)
seats = db.Column(db.String(250), nullable=False)
has_toilet = db.Column(db.Boolean, nullable=False)
has_wifi = db.Column(db.Boolean, nullable=False)
has_sockets = db.Column(db.Boolean, nullable=False)
can_take_calls = db.Column(db.Boolean, nullable=False)
coffee_price = db.Column(db.String(250), nullable=True)
@app.route("/")
def home():
return render_template("index.html")
rom flask import Flask, render_template
from flask_socketio import SocketIO, emit
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
@app.route('/')
def index():
return render_template('index.html')
@socketio.on('my event')
def test_message(message):
emit('my response', {'data': 'got it!'})
if __name__ == '__main__':
socketio.run(app)
import Flask
app = Flask(__name__)
@app.route('/')
def index():
return"Hello,World!"
app.run(port='8000')
# Command to run the project on a local server: pipenv run python src/app.py
flask import Flask, request
from flask import jsonify, json
app = Flask(__name__)
todos = [
{"label": "My first Task", "done": False},
{"label": "Sample Task 2", "done": False}
]
@app.route('/todos', methods=['GET'])
def hello_world():
request_body = jsonify(todos)
return request_body
@app.route('/todos', methods=['POST'])
def add_new_todo():
request_body = request.data
decoded_object = json.loads(request.data)
todos.append(decoded_object)
print("Incoming request with the following body" , request_body)
return jsonify(todos)
@app.route('/todos/<int:position>', methods=['DELETE'])
def delete_todo(position):
todos.pop(position -1)
print("This is the item to delete:", position)
return jsonify(todos)
from flask importfrom flask import Flask
app = Flask(__name__)
app.users = {}
app.id_count = 1
@app.route("/sign-up", methods=['POST'])
def sign_up():
new_user = request.json
new_user["id"] = app.id_count
app.users[app.id_count] = new_user
app.id_count = app.id_count+1
return jsonify(new_user)
rom flask import Flask, redirect, url_for, request
app = Flask(__name__)
@app.route('/success/<name>')
def success(name):
return 'welcome %s' % name
@app.route('/login',methods = ['POST', 'GET'])
def login():
if request.method == 'POST':
user = request.form['nm']
return redirect(url_for('success',name = user))
else:
user = request.args.get('nm')
return redirect(url_for('success',name = user))
if __name__ == '__main__':
app.run(debug = True)
rom flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
from flask_heroku import Heroku
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'Your DB URI'
heroku = Heroku()
db = SQLAlchemy(app)
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(200))
complete = db.Column(db.Boolean)
@app.route('/')
def index():
incomplete = Todo.query.filter_by(complete=False).all()
complete = Todo.query.filter_by(complete=True).all()
return render_template('todotemp.html', incomplete=incomplete, complete=complete)
@app.route('/add', methods=['POST'])
def add():
todo = Todo(text=request.form['todoitem'], complete=False)
db.session.add(todo)
db.session.commit()
return redirect(url_for('index'))
import flask from Flask
fun = Flask(__name__)
@fun.route("/")
def home():
print("Server received request for 'Home' page...")
return "Welcome world!"
@fun.route("/about")
def about():
print("Server received request for 'About' page...")
return "Welcome to my 'About' page! I am Elizabeth Schilling from St. Louis, MO."
@fun.route("/contact")
def about():
print("Server received request for 'Contact' page..")
return "If you wish to contact me; my email is [email protected]"
if __name__ == "__main__":
app.run(debug=True)
for flask import Flask
app = Flask(__name__, static_folder='');
@app.route("/")
def helo():
return app.send_static_file('index.html')
if __name__ == "__main__":
app.run(host='0.0.0.0', port=80, debug=True, threaded=True)
Enter file contents herefrom flask import Flask
from flask import request
from flask import render_template
from flask import jsonify
import json
import ast
import dbm
app = Flask(__name__)
@app.route('/')
def index():
return render_template("index.html")
@app.route('/videos', methods = ['POST'])
def create_videoitem():
if not request.json or not 'title' in request.json:
abort(400)
db = dbm.open('videodb', 'c')
video = {
'id': len(db.items()) + 1,
'title': request.json['title'],
'description': request.json.get('description'),
'youtubelink': request.json.get('youtubelink')
}
db[str(len(db.items()) + 1)] = str(video);
db.close()
return get_videoitems()
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 16 17:14:20 2019
@author: bingqingxie
"""
import Flask
from flask import request, jsonify, send_file
import boto3
import json
import os
#app configuration
app = Flask(__name__)
app.config["DEBUG"] = True
app.config.from_object(__name__)
app.config['SECRET_KEY'] = '****'
#app configuration
app = Flask(__name__)
app.config["DEBUG"] = True
app.config.from_object(__name__)
app.config['SECRET_KEY'] = 'frenzy2018datafeedsearchengine'
def Wrap(feed, url, subid):
new_link = ' '
if feed == 'Rakuten':
import flask from Flask, render_template app = Flask(__name__)
import Flask from flask
import jsonify
import recognition
app = Flask(__name__)
@app.route('/runrecognizer/<id>', methods=['GET'])
def runRecognizer(id):
result = recognition.runSpeechRecognizer(id)
if result == "fail":
return jsonify({"code": 400,
"message": "fail"})
return jsonify({"code": 200,
"message": "success",
"data": result})
if __name__ == '__main__':
app.run(debug=False)
rom flask import Flask, request
app = Flask(__name__)
@app.route("/account/", methods=['POST','GET'])
def account():
if request.method == 'POST':
print request.form
name = request.form['name']
return "Hello %s" % name
else:
page ='''
<html><body>
<form action="" method="post" name="form">
<label for="name">Name:</label>
<input type="text" name="name" id="name"/>
<input type="submit" name="submit" id="submit"/>
</form>
</body><html>'''
return page
if __name__ == "__main__":
app.run(host='0.0.0.0', debug=True)
frot flask import Flask
from redis import Redis
app = Flask(__name__)
redis = Redis(host='redis', port=6379)
@app.route('/')
def hello():
count = redis.incr('hits')
return 'Hello World! I have been seen {} times.\n'.format(count)
if __name__ == "__main__":
app.run(host="0.0.0.0", debug=True)
