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')],
