from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_surfing
app = Flask(__name__)
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route('/')
def index():
surfing = mongo.db.surfing.find_one()
return render_template('index.html', surfing=surfing)
@app.route('/scrape')
def scrape():
surfing = mongo.db.surfing
data = scrape_surfing.scrape()
surfing.update(
{},
data,
upsert=True
)
return redirect("/", code=302)
if __name__ == "__main__":
app.run(debug=True)
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_marte
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def index():
mars = mongo.db.mars.find_one()
return render_template("index.html", mars = mars)
@app.route("/scrape")
def scrape():
mars = mongo.db.mars
mars_data = scrape_marte.scrape()
mars.update({}, mars_data, upsert=True)
return redirect("http://localhost:5000/", code=302)
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import scrape_mars
app = Flask(__name__)
# Use flask_pymongo to set up mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def index():
news = mongo.db.news.find_one()
return render_template("index.html", news=news)
@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.news.update({}, mars_data, upsert=True)
# Redirect back to home page
return redirect("/")
if __name__ == "__main__":
app.run(debug=True)
basedir = os.path.abspath(os.path.dirname(__file__))
connex_app = connexion.App(__name__, specification_dir=basedir)
flask_app = connex_app.app
# TODO leave this hardcoded for now
env = 'dev'
settings_file = os.path.join(basedir, 'settings.yml')
yml = {}
with open(settings_file) as f:
yml = yaml.safe_load(f)[env]
port = yml['port']
drive_letter = os.path.splitdrive(sys.executable)[0]
if drive_letter:
drive_letter += '\\'
else:
drive_letter = r'/'
text_files_dir = os.path.join(drive_letter, 'data', 'text_files')
connex_app.add_api("rest_api.yml")
flask_app.config["MONGO_URI"] = yml['mongo_uri']
mongo = PyMongo(flask_app)
ma = Marshmallow(flask_app)
from flask import Flask, render_template, url_for, request, session, redirect,flash, message_flashed
from flask_pymongo import PyMongo
import os
app= Flask(__name__)
# Here i am writing all code to connect my application with mongoDb and user authentications.
app.config['MONGO_HOST'] ='localhost'
app.config['MONGO_PORT'] = '27017'
app.config['MONGO_DBNAME']="myfyp"
app.config['SECRET_KEY'] = "You_r_secret"
mongo = PyMongo(app,config_prefix ="MONGO")
# app.secret_key == "keep it secret"
@app.route('/')
def home():
# if 'username' in session:
# return 'You are logged in as ' + session['username']
return render_template('page_home3.html')
@app.route('/about')
def about():
return render_template('page_about3.html')
@app.route('/projects')
def projects():
return render_template('page_profile_projects.html')
""" Module summary: Variables: """ from flask_pymongo import PyMongo ############################################################################ # Connect to database and create database session: mongo = PyMongo()
from flask import Flask, request, jsonify, redirect, url_for
from flask_pymongo import PyMongo
import os
#
DB_NAME = 'app.sqlite'
DB_PATH = 'data'
BASE_DIR = os.path.abspath((os.path.dirname(__file__)))
# initialize
app = Flask(__name__)
app.config["MONGO_URI"] = "mongodb://*****:*****@app.route("/slot_info", methods=["GET"])
def get_slot_info():
gym_slots = tracker_mongo.db.gym_slots
month = request.json['month']
date_ = request.json['date']
slot_name = request.json['slot_name']
record = gym_slots.find_one({'month': month, 'date': date_,
'slot_name': slot_name})
if record:
return jsonify({"month": record["month"],
"date": record["date"],
"slot_name": record["slot_name"],
"slot_free_count": record["slot_free_count"]
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 index():
# Find one record of data from the mongo database
mars_library = mongo.db.collection.find_one()
# Return template and data
return render_template("index.html", mars_library = mars_library)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
# Run the scrape function
mars_library = scrape_mars.scrape_input()
# Update the Mongo database using update and upsert=True
mongo.db.collection.update({}, mars_library, upsert=True)
import os
from flask import Flask, render_template
from flask_cache import Cache
from flask_pymongo import PyMongo
app = Flask(__name__, static_url_path='')
app.config['MONGO_DBNAME'] = 'yelp_comparative_analytics'
app.config['MONGO_URI'] = 'mongodb://localhost:27017/yelp_comparative_analytics'
mongo_connection = PyMongo(app)
cache = Cache(app, config={'CACHE_TYPE': 'filesystem', 'CACHE_DIR': '_flask_cache_tmp_'})
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('500.html'), 500
# Import a module / component using its blueprint handler variable (mod_auth)
from server.mod_api.controller import mod_api as mod_api
from server.mod_client.controller import mod_client as mod_client
# Register blueprint(s)
app.register_blueprint(mod_api)
app.register_blueprint(mod_client)
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_Data1 = mongo.db.collection.find_one()
# Return template and data
return render_template("index.html", Mars_Data1=Mars_Data1)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
# Run the scrape function
Mars_data1 = Scrape_Mars.scrape_info()
# Update the Mongo database using update and upsert=True
def user_loader(username):
mongo = PyMongo(app)
if mongo.db.User_Info.find({'username': username}) is not None:
user = User()
user.id = username
return user
from flask import Flask, render_template, redirect, jsonify
from flask_pymongo import PyMongo
import json
from bson import ObjectId
from bson import json_util
# Create an instance of Flask
app = Flask(__name__)
# Use PyMongo to establish Mongo connection
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route("/")
def home():
ulta_data = []
#Find data from the mongo database
for data in mongo.db.ulta.find({}, {"_id":False}):
ulta_data.append(data)
#dumped_data = [json_util.dumps(data) for data in ulta_data]
#cleaned_data = [json.loads(data) for data in dumped_data]
#return jsonify(cleaned_data)
return render_template("index.html", ulta_data = ulta_data)
@app.route("/foundation")
def foundation():
foundation_data = []
#Find data from the mongo database
import datetime
import json
# pylint: disable=RP0401
from bson.objectid import ObjectId
from flask_pymongo import PyMongo
MONGO = PyMongo()
class JSONEncoder(json.JSONEncoder):
# extend json encoder for compatibility with mongoDB
def default(self, o): # pylint: disable=E0202
if isinstance(o, ObjectId):
return str(o)
if isinstance(o, datetime.datetime):
return str(o)
return json.JSONEncoder.default(self, o)
import os
from flask import Flask, jsonify
from flask_pymongo import PyMongo
from .utils.encoder import MongoJSONEncoder
APP = Flask(__name__, static_folder="../client")
APP.json_encoder = MongoJSONEncoder
APP.config["JSON_AS_ASCII"] = False
APP.config[
"MONGO_URI"] = "mongodb+srv://amd:[email protected]/photorun?retryWrites=true&w=majority"
MONGO = PyMongo(APP)
from .db.database import create_collections
create_collections()
from .db.start_value_db import add_start_values
if os.environ.get(
"FLASK_ENV") == "development" or MONGO.db.posts.count_documents(
{}) == 0:
add_start_values()
from . import views
from .api import feed_printer, post_operations, register_user
from flask import Flask, jsonify from flask_pymongo import PyMongo from flask_cors import CORS, cross_origin server = Flask(__name__) CORS(server) server.secret_key = "7bce579c0af059582f18bd5158f22ef78dae5055" server.config['MONGO_DBNAME'] = 'bude' # server.config['MONGO_URI'] = 'mongodb://*****:*****@ds123725.mlab.com:23725/bud-e' server.config['MONGO_URI'] = 'mongodb://localhost:27017/bude' mongo = PyMongo(server) from app.controllers import DiscoveryController, DevicesController
from flask import Flask, jsonify, render_template, redirect, url_for, request, Response, stream_with_context
from pprint import pprint
import json
from bson import json_util
import numpy as np
from flask_pymongo import PyMongo
from pprint import pprint
app = Flask(__name__)
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route('/')
def redhome():
return render_template('reddithome.html')
@app.route('/twitter')
def twithome():
return render_template('twitterhome.html')
# @app.route('/simpler')
# def simpler():
# documents = [doc for doc in mongo.db.rs.find({})]
from flask import Flask, request, redirect, render_template, url_for, session, flash, g
from flask_restful import Api
from flask_pymongo import PyMongo
from app.api_v1.accounts import Account, AccountUtils
from app.helpers import helpers
from os import makedirs
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(DEBUG=True,
TESTING=True,
SECRET_KEY='dev',
MONGO_URI='mongodb://localhost:27017/PyAPI')
app.config.from_json('config.json', silent=True)
makedirs(app.instance_path, exist_ok=True)
mongo = PyMongo(app, uri=app.config['MONGO_URI'])
api = Api(app)
api.add_resource(Account, '/api_v1/account')
@app.errorhandler(500)
def error(error):
return "We've encountered an error! ({})".format(str(error))
@app.route('/')
def app_index():
return render_template('index.html', title='Home')
@app.route('/account')
from flask import Flask, render_template, jsonify, redirect
from flask_pymongo import PyMongo
from scrape_mars import scrape
app = Flask(__name__)
mongo = PyMongo(app) #this is creating the database
@app.route('/')
def home():
mars_info = mongo.db.mars_info.find_one()
return render_template('index.html', dict=mars_info)
@app.route('/scrape')
def scrapeAgain():
fresh_info = scrape()
collection.update({'$set': fresh_info}, upsert=True)
return ('*refreshing data*')
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask, render_template, request, jsonify, url_for, redirect, abort
from flask_pymongo import PyMongo
import shortid
import re
app = Flask(__name__)
mongodb = PyMongo(app)
def validate_url(url):
regex = re.compile(
'^((ht|f)tps?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$',
re.IGNORECASE)
return regex.match(url)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/<string:short_id>')
def jump(short_id):
record = mongodb.db.short_urls.find_one_or_404({'_id': short_id})
return redirect(record['url'])
@app.route('/gen', methods=['POST'])
def generate_short():
url = request.values.get('url')
if not validate_url(url):
import random
import string
import logging
from bson import json_util
from flask import Flask, request
from flask_pymongo import PyMongo
from flask_restplus import Api, Resource
from pymongo.errors import DuplicateKeyError
from werkzeug.exceptions import BadRequest
from constants import local_connection_string
app = Flask(__name__)
app.config["MONGO_URI"] = local_connection_string
mongo_conn = PyMongo(app)
api = Api(app)
@api.route("/api/v0.1/<string:prod_id>")
class EditProductAPI(Resource):
def get(self, prod_id):
"""
Description: Will get the product information associated with the passed product ID.
Parameters:
prod_id: The product ID of the product whose information is required.
Return:
JSON containing the information of the user.
e.g:
{
"_id" : ObjectId("5e4a81de2c2fc0c10b7d336e"),
app.config['MAIL_SERVER']='smtp.gmail.com'
app.config['MAIL_PORT'] = 465
app.config['MAIL_USERNAME'] = os.getenv('GMAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.getenv('GMAIL_PASSWORD')
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USE_SSL'] = True
mail = Mail(app)
road_map_dir = os.path.expanduser('/Users/diye/PycharmProjects/MachineLearning/RoadMap')
load_dotenv(os.path.join(road_map_dir, '.env'))
map_api_key = os.getenv('ADDIS_SQUID_GOOGLE_MAPS_API_KEY')
# app.config["MONGO_URI"] = "mongodb://localhost:27017/testdb"
mongo_users = PyMongo(app, uri = 'mongodb://localhost:27017/testdb')
mongo_road_data = PyMongo(app, uri = 'mongodb://localhost:27017/addissquid_db')
class AddUserForm(FlaskForm):
first_name = StringField('First Name',validators = [DataRequired(), Length(min=2, max=20)])
last_name = StringField('Last Name', validators=[DataRequired(), Length(min=2, max=20)])
username = StringField('Username', validators=[DataRequired(), Length(min=2, max=20)])
email = StringField('Email', validators=[DataRequired(), Email()])
password = PasswordField('Password', validators=[DataRequired(), Length(min=8, max=64)])
confirm_password = PasswordField('Confirm Password', validators=[DataRequired(), EqualTo('password')])
submit = SubmitField('Add')
class LoginForm(FlaskForm):
username = StringField('Username', validators = [DataRequired(), Length(min=2, max=20)], render_kw={"placeholder": "Username"})
password = PasswordField('Password', validators = [DataRequired(), Length(min=8, max=64)], render_kw={"placeholder": "Password"})
submit = SubmitField('Login')
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_info = mongo.db.collection.find_one()
# Return template and data
return render_template('index.html', mars=mars_info)
# Route to trigger the scrape function
@app.route('/scrape')
def scrape():
# Run the scrape function
mars_info = scrape_mars.scrape()
# Update the Mongo database using update and upsert=True
mongo.db.collection.update({}, mars_info, upsert=True)
def __init__(self, app):
mlab_uri = 'mongodb://*****:*****@ds125602.mlab.com:25602/todo'
local_uri = 'mongodb://localhost/todo'
app.config['MONGO_DBNAME'] = 'todo'
app.config['MONGO_URI'] = mlab_uri
self.mongo = PyMongo(app)
from lib.discord import get_user_info
from lib.redisIO import RedisIO
from lib.utils import jsonify
SENTRY_DSN = os.getenv('SENTRY_DSN') or None
TESTING = True if os.environ.get("TESTING") else False
if SENTRY_DSN is not None:
sentry_sdk.init(dsn=SENTRY_DSN,
environment='Development' if TESTING else 'Production',
integrations=[FlaskIntegration()])
app = Flask(__name__)
app.rdb = rdb = RedisIO(
config.redis_url if not TESTING else config.test_redis_url)
app.mdb = mdb = PyMongo(
app, config.mongo_url if not TESTING else config.test_mongo_url).db
CORS(app)
# routes
@app.route('/', methods=["GET"])
def hello_world():
return 'Hello World!'
@app.route('/user', methods=["GET"])
def user():
info = get_user_info()
data = {
"username": info.username,
from bson.json_util import dumps
import os
from pymongo import MongoClient
from bson import ObjectId
from flask import jsonify, request
#from erkzeug.wsecurity import generate_password_hash,check_password_hash
from temp import temperature1
print(temperature1)
from datetime import datetime
app = Flask(__name__)
app.secret_key = "secret"
app.config['MONGO_URI'] = "mongodb://*****:*****@app.route('/')
def index():
return render_template('index.html')
if __name__ == "__main__":
app.run(debug=True)
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
Marsdata = mongo.db.collection.find_one()
# Return template and data
return render_template("index.html", Data=Marsdata)
# Route that will trigger the scrape function
@app.route("/scrape")
def scrape():
# Run the scrape function
Mars_data = scrape_mars.scrape()
# Update the Mongo database using update and upsert=True
def __init__(self, app):
self.mongo = PyMongo(app)
def get_db():
if 'mongo' not in g:
current_app.config["MONGO_URI"] = "mongodb://mongodb:27017/myDatabase"
g.mongo = PyMongo(current_app)
return g.mongo
from flask import (Flask, flash, render_template, redirect, request, session,
url_for)
from flask_pymongo import PyMongo
from bson.objectid import ObjectId
from werkzeug.security import generate_password_hash, check_password_hash
if os.path.exists("env.py"):
import env
app = Flask(__name__)
app.config["MONGO_DBNAME"] = os.environ.get("MONGO_DBNAME")
app.config["MONGO_URI"] = os.environ.get("MONGO_URI")
app.secret_key = os.environ.get("SECRET_KEY")
mongo = PyMongo(app)
@app.route("/", methods=["GET", "POST"])
def home():
url = "https://freegeoip.app/json/"
headers = {
'accept': "application/json",
'content-type': "application/json"
}
# get current country name
response = requests.request("GET", url, headers=headers)
session['country_name'] = response.json()["country_name"]
# set first station id or set a default country and station id
existing_country = mongo.db.countries.find_one(
{'name': session['country_name']})
from flask import Flask, render_template, redirect
from flask_pymongo import PyMongo
import mars_yo
app = Flask(__name__)
mongo = PyMongo(app, uri="mongodb://*****:*****@app.route('/')
def index():
mars = mongo.db.mars.find_one()
print(mars)
return render_template('index.html', mars=mars)
@app.route('/scrape')
def scrape():
mars_scrape_data = mars_yo.scrape_info()
print("*******Loook Here****************")
print(mars_scrape_data)
mongo.db.mars.update({}, mars_scrape_data, upsert=True)
return redirect("/")
