def create_app(): app = Flask( __name__, static_url_path="/static", instance_relative_config=True ) GoogleMaps(app, key="AIzaSyADCxm6oxGCYP94Gq7igqtczUDycRvTbJU") # load configuration configMode = os.environ.get("app_configuration", "Config") app.config.from_object("config." + str(configMode)) with app.app_context(): # database setup from rounded.models import db db.init_app(app) migrate = flask_migrate.Migrate(app, db) firebase.connect() redis.init() # default app related views from rounded.views.controller import views # import other blueprints from rounded.mod_voting.controller import mod_voting # register controller blueprinters app.register_blueprint(views) app.register_blueprint(mod_voting, url_prefix="/voting") return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.config.from_envvar('remap-config') config[config_name].init_app(app) db.init_app(app) GoogleMaps(app) login_manager.init_app(app) from app.main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .project import project as project_blueprint app.register_blueprint(project_blueprint, url_prefix='/project') from .profile import profile as profile_blueprint app.register_blueprint(profile_blueprint, url_prefix='/profile') return app
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = 'my_app_secret' # MYSQL CONFIGURATIONS app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///scrap_database.sqlite' scrap_database.init_app(app) # maps config app.config['GOOGLEMAPS_KEY'] = "8JZ7i18MjFuM35dJHq70n3Hx4" GoogleMaps(app, key="8JZ7i18MjFuM35dJHq70n3Hx4") login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.init_app(app) from src.models import User @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id)) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = 'secret-key-goes-here' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' app.config['GOOGLEMAPS_KEY'] = "" db.init_app(app) login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.init_app(app) GoogleMaps(app) from .models import User @login_manager.user_loader def load_user(user_id): # since the user_id is just the primary key of our user table, use it in the query for the user return User.query.get(int(user_id)) # blueprint for auth routes in our app from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) # blueprint for non-auth parts of app from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(spark_context): global recommendation_engine recommendation_engine = YelpRecommenderEngine( {'spark_context': spark_context}) app = Flask(__name__) app.register_blueprint(main) app.static_folder = 'static' Bootstrap(app) Bower(app) GoogleMaps(app, key='AIzaSyAT3qnHmIi6ujVBhyoFGtgwKIPQMPaTWA4') return app
def create_app(test_config=None): # Creates Instance & Tells App where files are relative app = Flask(__name__, instance_relative_config=True) """ Sets configuration for DB with SQLITE3 """ app.config.from_mapping( SECRET_KEY='dev', DATABASE=os.path.join(app.instance_path, 'imprint.sqlite') ) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER # Sets configuration for images # config for google maps app.config['GOOGLEMAPS_KEY'] = config.mapsKey GoogleMaps(app) # a simple page that says hello @app.route('/') def hello(): return render_template('index.html') @app.route('/website') def website_index(): return render_template('index.html') """ Adding Database to 'app' """ from . import db db.init_app(app) """ Adding Authroization to 'app'""" from . import auth app.register_blueprint(auth.bp) """ Adding admin dashboard panel """ from . import dashboard app.register_blueprint(dashboard.bp) """ Adding blog """ from . import blog app.register_blueprint(blog.bp) """ Adding Pages""" from . import product_page app.register_blueprint(product_page.bp) """ Add Landing Page""" from . import landing_page app.register_blueprint(landing_page.bp) """ ADdress """ from . import address app.register_blueprint(address.bp) return app
def create_app(config_object=settings): # create and configure the app app = Flask(__name__, instance_relative_config=True) app.config.from_object(config_object) gm = GoogleMaps(app, key="REDACTED") register_extensions(app) register_blueprints(app) register_errorhandlers(app) return app
def create_app(config_object=settings): # create and configure the app app = Flask(__name__, instance_relative_config=True) app.config.from_object(config_object) gm = GoogleMaps(app, key="AIzaSyCt_HeBKWlD7QZg2jH4qSaqEMPYYflkxYU") register_extensions(app) register_blueprints(app) register_errorhandlers(app) return app
def create_app(config_name=DEVELOPMENT_CONFIG_NAME): app = Flask(__name__) app.config.from_object(config[config_name]) register_extensions(app) register_blueprints(app) init_celery(app, celery) GoogleMaps(app) set_indico_key(config[config_name]) return app
def create_app(config_name): if os.getenv('FLASK_CONFIG') == "production": app = Flask(__name__) app.config.update( SECRET_KEY=os.getenv('SECRET_KEY'), SQLALCHEMY_DATABASE_URI=os.getenv('SQLALCHEMY_DATABASE_URI') ) else: app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') #set key sebagai config app.config['GOOGLEMAPS_KEY'] = "AIzaSyAyoxpbvRDXrAdzZxkDqLxG20U1p1EjAKU" #inisialisasi extensi GoogleMaps(app) Bootstrap(app) db.init_app(app) login_manager.init_app(app) login_manager.login_message = "Kamu harus login untuk melihat halaman ini." login_manager.login_view = "auth.login" migrate = Migrate(app, db) from app import models from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) from .home import home as home_blueprint app.register_blueprint(home_blueprint) from .user import user as user_blueprint app.register_blueprint(user_blueprint) @app.errorhandler(403) def forbidden(error): return render_template('errors/403.html', title='Forbidden'), 403 @app.errorhandler(404) def page_not_found(error): return render_template('errors/404.html', title='Page Not Found'), 404 @app.errorhandler(500) def internal_server_error(error): return render_template('errors/500.html', title='Server Error'), 500 return app
def create_app(bind='development', debug=False, default_config=None, mysql_path=None): app = Flask(__name__) if default_config is None: app.config.from_pyfile('../../etc/frontend_default.cfg') else: app.config.from_object(default_config) try: env_config = 'FRONTEND_FOR_TWEETS_SETTINGS' if os.getenv(env_config) is not None: app.config.from_envvar(env_config) else: app.logger.info( "Environment variable {} was not set.".format(env_config)) except Exception as e: app.logger.error("Error: {}".format(e.message)) # set logger format and logging level logging.basicConfig(format=app.config['LOG_FORMAT'], level=app.config['LOG_LEVEL']) app.debug_log_format = app.config['LOG_FORMAT'] # set up database if mysql_path is None: app.engine = create_engine(app.config['SQLALCHEMY_BINDS'][bind], convert_unicode=True, pool_recycle=3600, pool_size=10) else: app.engine = create_engine(mysql_path, convert_unicode=True, pool_recycle=3600, pool_size=10) app.db_session = scoped_session( sessionmaker(autocommit=False, autoflush=False, bind=app.engine)) # set debug app.debug = debug app.register_blueprint(google_map) google_map.logger = app.logger GoogleMaps(app) return app
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = 'mysite' app.config['SQLALCHEMY_DATABASE_URI'] = \ 'sqlite:///' + os.path.join(basedir, 'data.sqlite') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False from flaskr.views import bp app.register_blueprint(bp) db.init_app(app) migrate.init_app(app, db) login_manager.init_app(app) from flask_googlemaps import GoogleMaps, Map api_key = 'AIzaSyCXF164yON68t8Kddfel51JBDliZPGZqIk' GoogleMaps(app, key=api_key) return app
def __init__(self): self.cv = Condition() self.app = Flask(__name__) self.app.config['GOOGLEMAPS_KEY'] = "AIzaSyDcA0xJAaREE2vCdgjDnE-j9HQDChCvmWg" GoogleMaps(self.app) self.geolocator = Nominatim(user_agent="example app") self.login_manager = LoginManager(self.app) engine = create_engine('postgres://*****:*****@ec2-54-196-1-212.compute-1.amazonaws.com:5432/d77flf5a3j6r0c', echo=False) #engine = create_engine('sqlite:///cas.db') Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) self.session = Session() self.app.config['DEBUG'] = True self.app.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245' self.position = {'latitude': 0, 'longitude': 0} self.locations = []
def create_app(): app = Flask(__name__) app.config['GOOGLEMAPS_KEY'] = config.GOOGLEMAPS_KEY app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = config.SQLALCHEMY_DATABASE_URI db.init_app(app) GoogleMaps(app) @app.route("/") def index(): engine = create_engine(config.SQLALCHEMY_DATABASE_URI_LOCAL) connection = engine.connect() mymap = Map( identifier="view-side", lat=27.4419, lng=-112.1419, ) markers = [] rows = connection.execute( "SELECT latitude,longitude,callsign,datetime \ FROM (SELECT t.*, MAX(datetime) OVER (partition BY callsign) maxdatetime \ FROM PUBLIC.trace AS t) AS tt \ WHERE tt.datetime=tt.maxdatetime \ ORDER BY callsign").fetchall() for row in rows: markers.append({ 'icon': 'http://maps.google.com/mapfiles/ms/icons/plane.png', 'lat': row[0], 'lng': row[1], 'infobox': f"<b>{row[2]}</b>" }) sndmap = Map(identifier="sndmap", lat=55.9000, lng=37.7800, markers=markers, zoom=3, style="height:720px;width:1100px;margin:0;") return render_template('index.html', mymap=mymap, sndmap=sndmap) return app
def __init__(self): # Flask initialisation self.app = Flask(__name__) # Google maps API key (necessary for requesting map data) self.app.config[ 'GOOGLEMAPS_KEY'] = "AIzaSyBkFBjMxRZsKjoqDC9DrH0VWn2PNLxLdJo" # Initialize the extension GoogleMaps(self.app) # add links on your flask app here in the format: # self.app.add_url_rule('URL NAME', view_func=CLASS NAME OF EXTENSION.as_view('REPRESENTATIVE CLASS NAME')) self.app.add_url_rule('/', view_func=Intro.as_view('')) self.app.add_url_rule('/index', view_func=Home.as_view('index')) self.app.add_url_rule('/bot', view_func=Recommend.as_view('bot')) self.app.add_url_rule('/recommend', view_func=Recommend.as_view('recommend')) self.app.add_url_rule('/topic', view_func=Topic.as_view('topic')) # reads all destinations from all_destinations.csv for wikipedia api # tmp_df = pd.read_csv(str(os.getcwd() + '//all_destinations.csv'), sep=';', encoding="latin-1") # tmp_df.replace('\s+', '_',regex=True,inplace=True) # self.dest_as_list = [tmp_df.loc[x, :].values.tolist() for x in range(len(tmp_df)) if not pd.isnull(tmp_df.loc[x][1])] # tmp_df = None # loop over previous defined list and extract all destinations information via REST API if not exists already # AIM: centralize all APIs in scirpt destinations_api.py to extract information and safe as .txt # print('setting up information about total {0} destinations'.format(str(len(self.dest_as_list)))) # self.destinations_wikipedia = {} # for each_destination in self.dest_as_list: # self.destinations_wikipedia[each_destination[0]] = Destination(each_destination[0], each_destination[1]) # Write collected data into database (neo4j) print('setting up database...') self.db_connection = Database() # Calculate similarity between destination texts print('calculation similarity...') self.language_module = LanguageProcessing(self.db_connection) if create_topics: self.language_module.save_topics(3, 10) # Setting up flask app on specified port print('setting up user interface...') self.app.run(host='0.0.0.0', port=80, debug=False)
def post(self): if self.db.is_first_run(): username = request.form['settings-name'] birthdate = request.form['settings-birth'] gender = request.form['settings-gender'] weight = int(request.form['settings-weight']) gmap_apikey = request.form['settings-mapskey'] password = pbkdf2_sha256.encrypt(request.form['settings-pass'], rounds=200000, salt_size=16) self.db.update_settings(username, birthdate, gender, weight, gmap_apikey, password=password) GoogleMaps(current_app, key=self.db.get_gmaps_api_key()) return url_for('login_view') else: return url_for('index_view')
def creat_app(config_name): app = Flask(__name__, static_folder='adminDashboard/base/static') app.config.from_object(config_by_name[config_name]) app.config['GOOGLEMAPS_KEY'] = "AIzaSyBp1G6tb0v3JzSfcPtmKGwLI018Q-DL41E" GoogleMaps(app) db.init_app(app) cors.init_app(app) login_manager.init_app(app) bcrypt.init_app(app) rq.init_app(app) QRcode(app) # register blueprints # test app.register_blueprint(root) # Admin Dashboard blueprints app.register_blueprint(api_bl) app.register_blueprint(base_admin) app.register_blueprint(home_admin) app.register_blueprint(factory_admin) app.register_blueprint(company_admin) app.register_blueprint(driver_admin) app.register_blueprint(orders_admin) # Company Dashboard blueprint app.register_blueprint(home_company) app.register_blueprint(cars_company) app.register_blueprint(drivers_company) app.register_blueprint(orders_company) # Factory Dashboard blueprint app.register_blueprint(factory_blueprint) app.register_blueprint(orders_factory) app.register_blueprint(new_order_factory) r = Redis(os.getenv('REDIS_URL', 'redis://localhost:6379')) return app, r
def create_app(): app = Flask(__name__) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:enazumaeleven@localhost/safedrive' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY') or '3cjdaj#dsalp' app.config['INCIDENTS_PER_PAGE'] = 10 app.config['GOOGLEMAPS_KEY'] = "AIzaSyDxrZwnqA7Tm9uLeguM8XK78GqB-ZHIbJE" GoogleMaps(app) bootstrap.init_app(app) database.init_app(app) login_manager.init_app(app) moment = Moment(app) from authentication import authentication as authentication_blueprint app.register_blueprint(authentication_blueprint) from safedrive import safedrive as safedrive_blueprint app.register_blueprint(safedrive_blueprint) return app
def create_app(): # init Flask app = Flask(__name__) # install bootstrap extension Bootstrap(app) # Use application factory: # import blueprint and register it to app # defined the prefix url to separate each service # Home Page app.register_blueprint(home_blueprint) # Map Page app.register_blueprint(map_blueprint) app.config['TEMPLATES_AUTO_RELOAD'] = True # Initialize the extension and register GoogleMaps(app, key="AIzaSyCnJzJWFZEawx6AwTJiALRWa6MB0aLsvN8") return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(Config) GoogleMaps(app) #db.init_app(app) bcrypt.init_app(app) #login_manager.init_app(app) mail.init_app(app) from flaskblog.users.routes import users from flaskblog.posts.routes import posts from flaskblog.main.routes import main from flaskblog.errors.handlers import errors from flaskblog.maps.routes import maps from flaskblog.resource.routes import resource app.register_blueprint(users) app.register_blueprint(posts) app.register_blueprint(main) app.register_blueprint(errors) app.register_blueprint(maps) app.register_blueprint(resource) return app
def create_app(): """ Create the app Can receive a string that specifies the configuration to use """ app = Flask(__name__) app.config['WTF_CSRF_SECRET_KEY'] = WTF_CSRF_SECRET_KEY app.config['SECRET_KEY'] = SECRET_KEY for bp in blueprints: app.register_blueprint(bp) bp.app = app login_manager.init_app(app) GoogleMaps(app) filters.init_app(app) return app
def start(self): log.info( 'starting runnerdash, base_path: %s, db: %s, port: %d, debug: %s', cfg.base_path, cfg.db_file, self.port, self.debug ) self.app.add_url_rule('/', view_func=IndexView.as_view('index_view')) self.app.add_url_rule('/api', view_func=APIView.as_view('api_view')) self.app.add_url_rule('/wizard', view_func=WizardView.as_view('wizard_view')) self.app.add_url_rule('/login', view_func=LoginView.as_view('login_view')) self.app.add_url_rule('/logout', view_func=LogoutView.as_view('logout_view')) self.app.add_url_rule('/dashboard', view_func=DashboardView.as_view('dashboard_view')) self.app.add_url_rule('/settings', view_func=SettingsView.as_view('settings_view')) self.app.add_url_rule('/statistics', view_func=StatisticsView.as_view('statistics_view')) self.notify.start() db = RunnerDB(cfg.db_file) gmap_apikey = db.get_gmaps_api_key() if gmap_apikey: GoogleMaps(self.app, key=gmap_apikey) login_manager.login_view = "login_view" login_manager.setup_app(self.app) if self.devel: self.app.config['TEMPLATES_AUTO_RELOAD'] = True self.app.secret_key = db._generate_random_api_key() self.app.run(host=self.host, port=self.port, debug=self.debug, use_reloader=self.devel)
from config import Config from logging.handlers import RotatingFileHandler from flask_login import LoginManager from flask_bootstrap import Bootstrap import os import logging from flask_googlemaps import GoogleMaps app = Flask(__name__) app.config.from_object(Config) db = MongoEngine(app) login = LoginManager(app) login.login_view = 'login' bootstrap = Bootstrap(app) app.config['GOOGLEMAPS_KEY'] = os.environ.get('GOOGLEMAPS_KEY') GoogleMaps(app) if not app.debug: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/porchfest_BAG.log', maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter( '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]' )) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO)
def create_app(): app = Flask(__name__, template_folder='templates') GoogleMaps(app, key=GOOGLEMAPS_KEY) return app
dist_station = 0 weather_data = "N/A" asked_stations = "N/A" return closest_location, dist_station, weather_data, asked_stations ########### 2 NOTE SITE LIST ###################### # import list of locations. Contains sites and coordinates. sites_coord = pd.read_excel("sites/my_sites.xlsx") ########### 3 NOTE FLASK APP ###################### # initialize Flask application app = Flask(__name__) GoogleMaps(app) # used to show available stations on map @app.route('/') def home(): return (render_template('home.html')) @app.route("/get_weather_data", methods=['GET', 'POST']) def get_weather_data(): # get all available weather parameters smhi_weather_parameters = smhi_parameters() if request.method == 'POST': site_id = request.form["site_id"]
client = pymongo.MongoClient( "mongodb+srv://gabrielelkadki:[email protected]/test?retryWrites=true&w=majority" ) db = client.test collection = db.coordinates app = Flask(__name__, template_folder="templates") app.secret_key = b'_5#y2L"F4Q8z\n\xec]/' app.config['SESSION_TYPE'] = 'filesystem' Session(app) key = "AIzaSyDzLfe1r1aV48C15pGg_-PI0m0upPwFi3U" GoogleMaps(app, key=key) def geocode(address=None, components=None, bounds=None, region=None, language=None): """ Geocoding is the process of converting addresses (like ``"1600 Amphitheatre Parkway, Mountain View, CA"``) into geographic coordinates (like latitude 37.423021 and longitude -122.083739), which you can use to place markers or position the map. :param address: The address to geocode. :type address: string :param components: A component filter for which you wish to obtain a
import sys import requests import json import category_predictor # App config. # DEBUG = True application = Flask(__name__, template_folder="templates") application.config.from_object(__name__) application.config['SECRET_KEY'] = '7d441f27d441f27567d441f2b6176a' # you can set key as config application.config[ 'GOOGLEMAPS_KEY'] = "AIzaSyAXozhGr5tKlXS4l8FRri4CX36aTviOzXk" # you can also pass key here GoogleMaps(application, key="AIzaSyAXozhGr5tKlXS4l8FRri4CX36aTviOzXk") class ReusableForm(Form): food = TextField('Food:', validators=[validators.required()]) class ReviewCategoryClassifier(object): """Predict categories for text using a simple naive-bayes classifier.""" @classmethod def load_data(cls, input_file): """Read the output of the CategoryPredictor mrjob, returning total category counts (count of # of reviews for each category), and counts of words for each category. """
from wtforms.validators import Email app = Flask(__name__) # Config MySQL app.config['MYSQL_HOST'] = 'localhost' app.config['MYSQL_USER'] = '******' app.config['MYSQL_PASSWORD'] = '******' app.config['MYSQL_DB'] = 'flaskappdb' app.config['MYSQL_UNIX_SOCKET'] = '/Applications/MAMP/tmp/mysql/mysql.sock' app.config['MYSQL_CURSORCLASS'] = 'DictCursor' # you can set key as config app.config['GOOGLEMAPS_KEY'] = "8JZ7i18MjFuM35dJHq70n3Hx4" # you can also pass the key here if you prefer GoogleMaps(app, key="AIzaSyAFkMCq9GY2J9N-LDOlqCpBWDM1c4QwKbs") geopy.geocoders.options.default_user_agent = 'my_app/1' geopy.geocoders.options.default_timeout = 7 ctx = ssl.create_default_context(cafile=certifi.where()) geopy.geocoders.options.default_ssl_context = ctx geolocator = Nominatim(scheme='http') API_KEY = "AIzaSyAFkMCq9GY2J9N-LDOlqCpBWDM1c4QwKbs" RETURN_FULL_RESULTS = False # app.config['profile-images'] = '/Users/DRob/PycharmProjects/myflaskapp/static/profile-images' app.config['profile-images'] = '/Users/DRob/sites/content/uploads' # init MySQL mysql = MySQL(app)
# coding: utf-8 from flask import Flask, render_template, make_response, request from flask_googlemaps import Map, GoogleMaps import json from tsp_config import api_key from my_tsp import get_visit_order from tsp_helper import GeoPoint app = Flask(__name__, template_folder="templates") # you can set key as config GoogleMaps(app, key=api_key) @app.route('/') def fullmap(): """Display main web page.""" fullmap = Map( identifier="fullmap", varname="fullmap", style=("height:80%;" "width:100%;" "bottom:0;" "left:0;" "position:absolute;" "z-index:200;"), lat=45.5017, lng=-73.5673, zoom=12,
from flask import Flask from flask_googlemaps import GoogleMaps from os import environ google_maps = GoogleMaps() def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = environ.get('SECRET_KEY') app.config['GOOGLEMAPS_KEY'] = environ.get('GOOGLEAPIS_KEY') google_maps.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app