from config import app_key from config import application from config import bing_api_key from config import cluster from config import config_app from config import devices from config import gateway_locations from config import path_db from config import refresh_period_seconds from config import start_lat from config import start_lon logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s') logger = logging.getLogger(__name__) app = config_app(Flask(__name__, template_folder="./templates")) db = SQLAlchemy(app) def schedule_get_new_data(): get_new_data() scheduler = BackgroundScheduler() job = scheduler.add_job(schedule_get_new_data, 'interval', days=1) scheduler.start() class Location(db.Model): __tablename__ = "location"
''' GOAL: Creates properly configured Flask "app" object and flask_sqlalchemy.SQLAlchemy "db" object at the package level, so they can be fetched with: from strabo import app, db From any file in the package. Also creates an empty configuration dictionary, straboconfig, which is filled in with configuration information when the package is used, in files like runserver.py. It is not filled here because it cranshes when documentation is being built. Then it loads the views package so that flask knows where to send browser requests. ''' import config from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) config.config_app(app) db = SQLAlchemy(app) straboconfig = config.get_config_info() import strabo.views
"""Flask app for Cupcakes""" from flask import Flask, request, redirect, render_template, flash, jsonify from config import settings, DB_CONFIG, config_app app = Flask(__name__) config_app(app) from flask_debugtoolbar import DebugToolbarExtension debug = DebugToolbarExtension(app) from forms import CupcakeForm from models import db, connect_db, Cupcake connect_db(app) def serialize_cupcake(cupcake): """Serialize a cupcake SQLAlchemy obj to dictionary.""" return { "id": cupcake.id, "flavor": cupcake.flavor, "size": cupcake.size, "rating": cupcake.rating, "image": cupcake.image, } @app.route("/api/cupcakes") def get_all_cupcakes(): """Return JSON {'cupcakes': [{id, flavor, size, rating, image}, ...]}"""
# import logging # logger = logging.getLogger(__name__) # logger.addHandler(logging.StreamHandler(stream=sys.stderr)) # logger.setLevel(logging.DEBUG) server = Flask(__name__) app = dash.Dash(name='Bootstrap_docker_app', server=server, static_folder='static', csrf_protect=False) # Add css, js, container div with id='page-content' and location with id='url' app = config_app(app, debug=True) # Generate app layoute with 3 div elements: page-header, page-main, page-footer. # Content of each div is a function input app.layout = app_layout(header=make_header()) @app.callback(Output('page-main', 'children'), [Input('url', 'pathname')]) def routing(pathname): """Very basic router This callback function will read the current url and based on pathname value will populate the children of the page-main Returns: html.Div
import cli import env from config import config_app from constants import LOGGING_FILENAME, MASTER_NODE_ID, UNDEFINED_NODE_ID from dataset import Dataset from dataset.mnist import MNIST from distml import DistML from neural_network import NeuralNetwork from neural_network.test_net import TestNet from training import DistTraining from training.synced_sgd import SyncedSGD from utils.logging import config_logger, getLogger from utils.types import build_types_map, str2bool config_app() logger = getLogger(__name__) datasets = build_types_map(MNIST) models = build_types_map(TestNet) training_methods = build_types_map(SyncedSGD) def main( node_id: Optional[int], num_workers: int, num_nodes: int, dataset_class: Type[Dataset], model_class: Type[NeuralNetwork], training_class: Type[DistTraining], num_epochs: int,
import sys # import logging # logger = logging.getLogger(__name__) # logger.addHandler(logging.StreamHandler(stream=sys.stderr)) # logger.setLevel(logging.DEBUG) server = Flask(__name__) app = dash.Dash(name='Bootstrap_docker_app', server=server, static_folder='static', csrf_protect=False) # Add css, js, container div with id='page-content' and location with id='url' app = config_app(app, debug=True) # Generate app layoute with 3 div elements: page-header, page-main, page-footer. # Content of each div is a function input app.layout = app_layout(header=make_header()) @app.callback(Output('page-main', 'children'), [Input('url', 'pathname')]) def routing(pathname): """Very basic router This callback function will read the current url and based on pathname value will populate the children of the page-main Returns: html.Div
from flask import redirect, url_for from flask_login import login_required, LoginManager, current_user from flask_migrate import Migrate from flask_sqlalchemy import SQLAlchemy from config import db, config_app from auth import setup_login_manager app = config_app() # Connect Flask-Migrate migrate = Migrate(app, db) # Import blueprints from auth import auth from notes import notes # Register blueprints app.register_blueprint(auth) app.register_blueprint(notes) # Connect login_manager login_manager = setup_login_manager() login_manager.init_app(app) @app.route('/home', endpoint='home') @login_required def profile(): return redirect(url_for('notes.display_all_notes'))
import sys import logging logger = logging.getLogger(__name__) logger.addHandler(logging.StreamHandler(stream=sys.stderr)) logger.setLevel(logging.DEBUG) debug_flag = True server = Flask(__name__) app = dash.Dash(name='Bootstrap_docker_app', server=server) #, #static_folder='static', #csrf_protect=False) # Add css, js, container div with id='page-content' and location with id='url' app = config_app(app, debug=debug_flag) # Generate app layoute with 3 div elements: page-header, page-main, page-footer. # Content of each div is a function input app.layout = app_layout(header=make_header(), main=make_main(), footer=make_footer()) all_data_dict = {} print('init') @app.callback( [Output('page-main', 'children'), Output('country_dropdown', 'value')], [Input('url', 'pathname')],