from flask import Flask, jsonify, url_for, redirect, request
from flask_pymongo import PyMongo
from flask_restful import Api, Resource
from flask_cors import CORS, cross_origin
from bson.objectid import ObjectId
app = Flask(__name__)
CORS(app)
app.config['MONGO_HOST'] = 'ec2-54-193-83-16.us-west-1.compute.amazonaws.com'
app.config['MONGO_PORT'] = 27017
app.config["MONGO_DBNAME"] = "orders_db"
mongo = PyMongo(app, config_prefix='MONGO')
APP_URL = "ec2-54-67-23-66.us-west-1.compute.amazonaws.com:3000"
class orders(Resource):
def get(self, orderid=None, status=None, itemid=None):
data = []
items = []
#get all order and perticular order.
if orderid:
if orderid == "all":
# Return All Ordered
cursor = mongo.db.orders.find({}, {"_id": 0})
for i in cursor:
#print orders
#orders['url'] = APP_URL + url_for('orders') + "/" + orders.get('location')
# Import my env.py that's ignored by git
if os.path.exists("env.py"):
import env
# Set usernames and passwords for login tests
USERNAME_ADMIN = os.environ.get('USERNAME_ADMIN')
USERNAME_USER = os.environ.get('USERNAME_USER')
SPW_ONE = os.environ.get('SPW_ONE')
SPW_TWO = os.environ.get('SPW_TWO')
# MongoDB configuration
mongo = PyMongo(app)
vacancy = mongo.db.vacancies.find_one()
candidate_user = mongo.db.candidates.find_one({'user_name': USERNAME_USER})
candidate_admin = mongo.db.candidates.find_one({'user_name': USERNAME_ADMIN})
application = mongo.db.applications.find_one()
VACANCY_ID = vacancy['_id']
CANDIDATE_ID_USER = candidate_user['_id']
CANDIDATE_NAME_USER = candidate_user['first_name'] \
+ candidate_user['last_name']
CANDIDATE_ID_ADMIN = candidate_admin['_id']
APPLICATION_ID = application['_id']
class LoadsUserAvailable(unittest.TestCase):
#!flask/bin/python
from flask import Flask, jsonify, abort, request, make_response, url_for
from flask_httpauth import HTTPBasicAuth
from flask_pymongo import PyMongo
app = Flask(__name__, static_url_path="")
auth = HTTPBasicAuth()
app.config['MONGO_DBNAME'] = 'restdb'
app.config['MONGO_URI'] = 'mongodb://localhost:27017/prtdb'
mongo_mgr = PyMongo(app)
@auth.error_handler
def unauthorized():
# return 403 instead of 401 to prevent browsers from displaying the default
# auth dialog
return make_response(jsonify({'error': 'Unauthorized access'}), 403)
@app.errorhandler(400)
def bad_request(error):
return make_response(jsonify({'error': 'Bad request'}), 400)
@app.errorhandler(404)
def not_found(error):
return make_response(jsonify({'error': 'Not found'}), 404)
@app.route('/prt/api/v1.0/users', methods=['GET'])
from flask_pymongo import PyMongo
from bson import json_util, ObjectId
import json
mongo = PyMongo()
def get_all_from_collection(collection):
print(collection)
documents = [doc for doc in mongo.db[collection].find({})]
return json.loads(json_util.dumps(documents))
def get_one_from_collection_by_key(collection, key):
document = mongo.db[collection].find_one({key:{'$exists':True}})
if document is not None:
document['_id'] = str(document['_id'])
return document
else:
return document
def post_all_to_collection(collection, data):
if(type(data) == dict):
data = data.values()
mongo.db[collection].insert_many(data)
for element in data:
element['_id'] = str(element['_id'])
return list(data)
def post_single_to_collection(collection, data):
mongo.db[collection].insert_one(data)
data['_id'] = str(data['_id'])
return data
import os
from flask import Flask, render_template, redirect, request, url_for
from flask_pymongo import PyMongo
from bson.objectid import ObjectId
import re
import string
if os.path.exists("env.py"):
import env
# Create instance of flask and assign it to "app"
app = Flask(__name__)
app.config["MONGO_URI"] = os.getenv("connection_string")
# Assign the database collection to the variable "coll"
coll = PyMongo(app).db.trailers
# Landing page
@app.route('/')
@app.route('/get_trailers')
def get_trailers():
return render_template("trailers.html",
trailers=coll.find().sort([('$natural', -1)]),
n_trailers=coll.count_documents({}))
# Search trailers
@app.route('/search_trailers', methods=['POST'])
def search_trailers():
terms_to_search = request.form.get('input-search')
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def home():
mars_data = mongo.db.mars_db.find_one()
return render_template("index.html", mars_data=mars_data)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
mars_db = mongo.db.mars_db
mars_data = scrape_mars.scrape_mars()
mars_db.update({}, mars_data, upsert=True)
return redirect("/", code=302)
if __name__ == "__main__":
app.run(debug=True)
from flask import Flask from flask import request from flask import render_template from flask_pymongo import PyMongo from datetime import datetime from datetime import timedelta from bson.objectid import ObjectId from flask import abort from flask import redirect from flask import url_for from flask import flash from flask import session import time import math app = Flask(__name__) app.config["MONGO_URI"] = "mongodb://localhost:27017/pywebboard" app.config["SECRET_KEY"] = "abcd" # flash함수 사용하기 위해서 반드시 필요 & 실제로는 더 복잡한 값을 줘야함 app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(minutes=30) # 세션 유지 시간 30분 mongo = PyMongo(app) # 이 객체로 mongoDB에 접근할 수 있음 from .common import login_required from .filter import format_datetime from . import board from . import member app.register_blueprint(board.blueprint) app.register_blueprint(member.blueprint)
from flask_pymongo import PyMongo
from flask import render_template, redirect, Flask, jsonify
app = Flask(__name__)
mongo = PyMongo(app, uri='mongodb://*****:*****@app.route('/')
def home():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask, render_template, jsonify, redirect, send_file, request
from flask_pymongo import PyMongo
from .functions import getRidOfId
import os
MONGO_URL = os.environ.get('MONGO_URL')
if not MONGO_URL:
MONGO_URL = "mongodb://*****:*****@dc_dashboard.route('/')
def index():
return render_template("index.html")
@dc_dashboard.route("/sports")
def sports():
# from functions import getRidOfId
capsdata = getRidOfId(mongo.db.capitals.find())
natsdata = getRidOfId(mongo.db.nationals.find())
all_data = [capsdata, natsdata]
return jsonify(all_data)
flask_app.ip_map = dict()
# 注册蓝图
flask_app.register_blueprint(sms_app)
flask_app.register_blueprint(auth_app)
flask_app.register_blueprint(crm_app)
# 初始化各种
manager = Manager(flask_app)
db.init_app(flask_app)
excel.init_excel(flask_app)
migrate = Migrate(flask_app, db)
manager.add_command('db', MigrateCommand)
celery = Celery(flask_app.name, broker=flask_app.config['CELERY_BROKER_URL'])
celery.conf.update(flask_app.config)
mongo = PyMongo(flask_app, uri=flask_app.config['MONGODB_URI'])
mail = Mail(flask_app)
login_manager = LoginManager(flask_app)
login_manager.login_view = 'auth.login'
login_manager.session_protection = 'strong'
login_manager.login_message_category = 'auth'
@login_manager.user_loader
def user_loader(user_id):
return Seller.query.get(user_id)
@manager.shell
def make_shell_context():
return dict(
from flask import Flask, render_template, redirect, jsonify
from flask_pymongo import PyMongo
from bson import ObjectId
import json
import os
import csv
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo_bikes = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def home():
# Find one record of data from the mongo database
bikes_data = mongo_bikes.db.collection.find()
pedes_data = mongo_pedes.db.collection.find()
# Return template and data
return render_template("index.html",
article1=bikes_data,
article2=pedes_data)
# Route that will trigger the scrape function
@app.route("/read_bikes")
from flask import Flask
from flask_cors import CORS
from flask_pymongo import PyMongo
from flask_restful import Api
app = Flask(__name__)
# Configure CORS
cors = CORS(app, origins=['http://localhost:8080'])
# Configure database
app.config["MONGO_URI"] = "mongodb://3.14.7.212:27017/Cars"
app.database = PyMongo(app)
app.cars_collection = app.database.db.cars
# Create api
api = Api(app)
from api.controller.car import Car
from api.controller.car import CarList
#...
#...
#...
api.add_resource(Car,
'/car',
'/car/<car_id>',
methods=['GET', 'POST', 'PUT', 'DELETE'])
def get_db():
if 'db' not in g:
mongo = PyMongo(current_app)
g.db = mongo.db
return g.db
def setUp(self):
self.mongo = PyMongo(app)
with open("id_engine/test/res/1.json") as fdr:
self.data = json.loads(fdr.read())
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
app = Flask(__name__)
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/scrape1")
def index1():
mars_info = mongo.db.collection.find_one()
return render_template('index.html', mars_info=mars_info)
@app.route("/scrape2")
def index2():
mars_data = scrape_mars.scrape()
mongo.db.collection.update({}, mars_data, upsert=True)
return redirect("/")
if __name__ == "__main__":
app.run(debug=True)
import os
from flask import Flask, redirect, url_for, request, jsonify, render_template
from flask_pymongo import PyMongo
import numpy as np
import keras
from keras.preprocessing import image
from keras import backend as K
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = 'uploads'
mongo = PyMongo(app, uri="mongodb://localhost:27017/test_xray")
model = None
graph = None
# Loading a keras model with flask
# https://blog.keras.io/building-a-simple-keras-deep-learning-rest-api.html
def load_model():
global model
global graph
model = keras.models.load_model("Flask/balance_6epoch_vgg.h5")
model._make_predict_function()
graph = K.get_session().graph
load_model()
def model_predict(img_path, model):
img = image.load_img(img_path, target_size=(224, 224))
__name__ = 'WebServer'
__author__ = 'Chang.'
from utils import logger_web_server, Docker
app = flask.Flask(__name__)
app.debug = bool(os.environ.get("DEBUG"))
app.config["JSONIFY_PRETTYPRINT_REGULAR"] = True
app.config['JSON_AS_ASCII'] = False
# app.config["MONGO_URI"] = f"mongodb://192.168.2.100:27017/fake_flow"
app.config[
"MONGO_URI"] = f"mongodb://{Docker.gateway if Docker else '127.0.0.1'}:27017/fake_flow"
app.logger = logger_web_server
mongo = PyMongo(app, maxPoolSize=200, waitQueueMultiple=20)
@app.route('/')
def help():
return '</br>'.join("""
# WebServer 2.*
公司内部使用
目前支持路径
## proxy
* /proxy/
* /proxy/paid/wandou
from flask import Flask, redirect, render_template, request, url_for
from flask_pymongo import PyMongo
import markdown2
import re
app = Flask(__name__)
mongo = PyMongo(app, "mongodb://localhost/wiki")
WIKIPART = re.compile(r"([A-Z][a-z0-9_]+)")
WIKIWORD = re.compile(r"([A-Z][a-z0-9_]+(?:[A-Z][a-z0-9_]+)+)")
@app.route("/", methods=["GET"])
def redirect_to_homepage():
return redirect(url_for("show_page", pagepath="HomePage"))
@app.template_filter()
def totitle(value):
return " ".join(WIKIPART.findall(value))
@app.template_filter()
def wikify(value):
parts = WIKIWORD.split(value)
for i, part in enumerate(parts):
if WIKIWORD.match(part):
name = totitle(part)
parts[i] = "[%s](%s)" % (name, url_for("show_page", pagepath=part))
return markdown2.markdown("".join(parts))
def user(app):
# Setup the Flask-JWT-Extended extension
app.config['JWT_SECRET_KEY'] = 'super-secret' # Change this!
app.config["MONGO_URI"] = Config.MONGO
app.config['JWT_ACCESS_COOKIE_PATH'] = '/api/'
app.config['JWT_REFRESH_COOKIE_PATH'] = '/token/refresh'
app.config['JWT_COOKIE_CSRF_PROTECT'] = False
app.config['JWT_TOKEN_LOCATION'] = ['cookies', 'headers']
jwt = JWTManager(app)
mongo = PyMongo(app)
# Provide a method to create access tokens. The create_access_token()
# function is used to actually generate the token, and you can return
# it to the caller however you choose.
@app.route('/login', methods=['POST'])
def login():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"msg": "Missing username parameter"}), 400
if not password:
return jsonify({"msg": "Missing password parameter"}), 400
users = User.user(mongo, username, password)
if users == None:
return jsonify({"msg": "Usuario o contraseña invalidas"})
# Identity can be any data that is json serializable
expires = datetime.timedelta(hours=Config.TOKEN_TIME)
access_token = create_access_token(identity=username,
expires_delta=expires)
refresh_token = create_refresh_token(identity=username)
login = jsonify({'login': True})
set_access_cookies(login, access_token)
set_refresh_cookies(login, refresh_token)
ret = {
'access_token': create_access_token(identity=username),
'refresh_token': create_refresh_token(identity=username)
}
return jsonify(ret), 200
@app.route('/token/remove', methods=['POST'])
def logout():
resp = jsonify({'logout': True})
unset_jwt_cookies(resp)
return resp, 200
@app.route('/token/refresh', methods=['POST'])
@jwt_refresh_token_required
def refresh():
# Create the new access token
current_user = get_jwt_identity()
access_token = create_access_token(identity=current_user)
# Set the JWT access cookie in the response
resp = jsonify({'refresh': True})
set_access_cookies(resp, access_token)
return resp, 200
# Protect a view with jwt_required, which requires a valid access token
# in the request to access.
@app.route('/protected', methods=['GET'])
@jwt_required
def protected():
# Access the identity of the current user with get_jwt_identity
current_user = get_jwt_identity()
return jsonify(logged_in_as=current_user), 200
#loading necessary libraries
from explore_database import explore_database
from flask import Flask, jsonify, request
from flask_pymongo import PyMongo
# app
app = Flask(__name__)
query_list11 = [
"discounted_products_list", "discounted_products_count|avg_discount",
"expensive_list", "competition_discount_diff_list"
]
#Connecting the database
mongo = PyMongo(
app,
uri="mongodb://*****:*****@ds135966.mlab.com:35966/heroku_66751cjb")
collection = mongo.db.products
# routes
@app.route("/", methods=['POST'])
def predict():
data = request.get_json(force=True)
try:
filter_list = data["filters"]
except:
filter_list = []
query = data["query_type"]
ob = explore_database()
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def home():
# Find one record of data from the mongo database
Mars_data = mongo.db.collection.find_one()
# Return template and data
return render_template("index.html", Space=Mars_data)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
# Run the scrape function
scrape = scrape_mars.scrape_info()
# Update the Mongo database using update and upsert=True
mongo.db.collection.update({}, scrape, upsert=True)
# import necessary libraries
from flask import Flask, render_template
from flask_pymongo import PyMongo
import pandas as pd
import scrape_mars
# create instance of Flask app
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def echo():
# Find data
m_facts = mongo.db.collection.find_one()
#Return templated data
return render_template("index.html", mars=m_facts)
@app.route("/scrape")
def scrape():
# Run the scrape function
mars_data = scrape_mars.scrape_all()
# Update the Mongo database using update and upsert=True
mongo.db.collection.update({}, mars_data, upsert=True)
# Redirect back to home page
return redirect("/", code=302)
def get_db():
if 'db' not in g:
g.db = PyMongo(current_app)
return g.db
# import dependencies
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_world_migration
from dbconfig import dbname, dbuser, psswd, host, parameters
app = Flask(__name__)
connection_string ='mongodb+srv://' + dbuser + ':' + psswd + host + '/' + dbname + "?" + parameters
mongo = PyMongo(app, uri=connection_string)
@app.route("/")
def index():
globalareas = mongo.db.global_areas.find_one()
top5countries = mongo.db.top5countries.find_one()
top10countries = mongo.db.top10countries.find_one()
tables = [ globalareas, top5countries, top10countries]
return render_template("index.html", tables=tables)
@app.route("/scrape")
def scrape():
mars = mongo.db.mars
print("E AQUI *****************************************************************$$$$$$$$$*")
data = scrape_mars.scrape()
print("E AQUI QUE COMEÇA******************************************************************")
mars.update({}, data, upsert=True)
return redirect("/", code=302)
if __name__ == "__main__":
app.run(debug=True)
import os
from flask import Flask, render_template, redirect, request, url_for
from flask_pymongo import PyMongo
from bson.objectid import ObjectId
app = Flask(__name__)
app.config["MONGO_DBNAME"] = 'recipe_db'
app.config[
'MONGO_URI'] = 'mongodb+srv://root:[email protected]/recipe_db?retryWrites=true&w=majority'
mongo = PyMongo(app) #constructor method
#route decorator is a URL that redirects to a Python function
@app.route('/')
@app.route('/get_recipes')
def get_recipes():
return render_template("recipes.html", recipes=mongo.db.recipes.find())
@app.route('/add_recipe')
def add_recipe():
return render_template('add_recipe.html',
ingredients=mongo.db.ingredients.find(),
categories=mongo.db.categories.find())
# return render_template('add_recipe.html', categories=mongo.db.categories.find())
@app.route('/create_recipe', methods=['POST'])
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def home():
# Find one record of data from the mongo database
mars_data = mongo.db.marscollection.find_one()
# Return template and data
return render_template("index.html", mars_info=mars_data)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
# Run the scrape function
mars_data = scrape_mars.scrape_info()
# Update the Mongo database using update and upsert=True
mongo.db.marscollection.update({}, mars_data, upsert=True)
# Controler
# Import All Dependencies
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
#import the scrape
import scrape_mars
app = Flask(__name__)
# Create the database in Mongo
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def index():
project_mars = mongo.db.project_mars.find_one()
return render_template("index.html", project_mars=project_mars)
@app.route("/scrape")
def scraper():
project_mars = mongo.db.project_mars
scrape_mars_data = scrape_mars.scrape()
# update, if not, insert it (because we have upser=True)
project_mars.update({}, scrape_mars_data, upsert=True)
#redirect to my index page
return redirect("/", code=302)
import os
from flask import Flask, render_template, redirect, request, url_for
from flask_pymongo import PyMongo
from bson.objectid import ObjectId
from werkzeug.security import generate_password_hash, check_password_hash
app = Flask(__name__)
#add mongo db name and the url linking to that database
app.config["MONGO_DBNAME"] = 'project3-gaa-players'
app.config["MONGO_URI"] = os.getenv('MONGO_URI', 'mongodb://localhost')
mongo = PyMongo(
app
) #create instance of pymongo. add app into it with method called constructor method
@app.route('/')
@app.route('/get_tasks')
def get_tasks():
return render_template("player_profile.html",
tasks=mongo.db.player_profile.find())
"""
@app.route('/add_profile_data')
def add_profile_data():
heights = []
weights = []
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://127.0.0.1:5000/mars_info")
# Route to render index.html template using data from Mongo
@app.route("/")
def home():
# Find one record of title and para data from the mongo database
title_and_para_data = mongo.db.title_and_para_col.find_one()
# Find one record of featured image data from the mongo database
mars_image_data = mongo.db.mars_image_col.find_one()
# Find one record of mars facts data from the mongo database
mars_facts_data = mongo.db.mars_weather_col.find_one()
# Image 1
img1_data = mongo.db.mars_img1_col.find_one()
# Image 2
img2_data = mongo.db.mars_img2_col.find_one()
# Image 3
from flask import Flask, render_template, request, session, redirect, url_for
from flask_pymongo import PyMongo
app = Flask(__name__)
database_file = open('db.txt', 'U')
db_host = database_file.readline().strip() #URL and port
dbname = database_file.readline().strip()
user = database_file.readline().strip()
password = database_file.readline().strip()
database_file.close()
app.config['MONGO_DBNAME'] = dbname
app.config['MONGO_URI'] = 'mongodb://' + user + ':' + password + '@' + db_host + '/' + dbname
app.config['MONGO_CONNECT'] = False
mongo = PyMongo()
with app.app_context():
mongo.init_app(app)
import json
#Copy from StackOverflow-----------------------------
from os import path
import os
extra_dirs = ['static','templates']
extra_files = extra_dirs[:]
for extra_dir in extra_dirs:
for dirname, dirs, files in os.walk(extra_dir):
for filename in files:
filename = path.join(dirname, filename)
import os
from flask import Flask, request, render_template
from flask_pymongo import PyMongo
from bson.json_util import dumps
app = Flask(__name__)
app.config["MONGO_DBNAME"] = os.getenv("MONGO_DBNAME")
app.config["MONGO_URI"] = os.getenv("MONGO_URI")
app.secret_key = os.getenv("SECRET_KEY")
MONGO = PyMongo(app)
USERS = MONGO.db.users
@app.route("/")
def index():
users = USERS.find()
return render_template("index.html", users=users)
@app.route("/api/test/")
def api_test():
data = {
"a": 1,
"b": 2,
"c": 3,
}
return data
