示例#1
0
def run_supernova():
    """
    Handles all of the prep work and error checking for the
    supernova executable.
    """
    config.run_config()

    parser = argparse.ArgumentParser()
    parser.add_argument("-x", "--executable", default="nova", help="command to run instead of nova")
    parser.add_argument("-l", "--list", action=_ListAction, help="list all configured environments")
    parser.add_argument("-d", "--debug", action="store_true", help="show novaclient debug output")
    parser.add_argument(
        "env", help=("environment to run nova against. " "valid options: %s" % sorted(config.nova_creds.sections()))
    )

    # Allow for passing --options all the way through to novaclient
    supernova_args, nova_args = parser.parse_known_args()

    # Did we get any arguments to pass on to nova?
    if not nova_args:
        utils.warn_missing_nova_args()
        sys.exit(1)

    # Is our environment argument a single environment or a supernova group?
    if utils.is_valid_group(supernova_args.env):
        envs = utils.get_envs_in_group(supernova_args.env)
    else:
        envs = [supernova_args.env]

    snobj = SuperNova()
    for env in envs:
        snobj.nova_env = env
        snobj.run_novaclient(nova_args, supernova_args)
示例#2
0
def create_app():
    app = Flask(__name__)
    app.config.from_object(run_config())
    db.init_app(app)
    Migrate().init_app(app, db)
    app.permanent_session_lifetime = timedelta(
        minutes=20)  # add session expire time
    app.register_blueprint(room_b)
    app.register_blueprint(staff_b)
    app.register_blueprint(tenants_b)
    app.register_blueprint(create_db)
    return app
示例#3
0
def create_app():
    my_app = Flask(__name__)
    my_app.config.from_object(run_config())

    db.init_app(my_app)
    Migrate(my_app, db)
    my_app.register_blueprint(create_db)
    my_app.register_blueprint(users_bp)
    my_app.register_blueprint(books_bp)
    my_app.register_blueprint(library_bp)

    return my_app
示例#4
0
def create_app():
    app = Flask(__name__)
    app.config.from_object(run_config())
    db.init_app(app)

    app.register_blueprint(app_tenant)
    app.register_blueprint(app_room)
    app.register_blueprint(app_staff)

    db.create_all(app=app)

    return app
示例#5
0
def create_app():
    app = Flask(__name__)
    app.config.from_object(run_config())

    db.init_app(app)
    migrate.init_app(app, db)
    app.permanent_session_lifetime = timedelta(minutes=20)

    app.register_blueprint(create_db)
    app.register_blueprint(name_bp)

    return app
示例#6
0
文件: my_app.py 项目: arturUkr/common
def create_app():

    app = Flask(__name__)
    app.config.from_object(run_config())

    db.init_app(app)

    app.register_blueprint(create_db_bp)
    app.register_blueprint(tenant_bp)
    app.register_blueprint(room_bp)
    app.register_blueprint(staff_bp)

    return app
示例#7
0
def run_app():
    app.config.from_object(run_config())

    db.init_app(app)
    app.permanent_session_lifetime = timedelta(
        minutes=20)  # add session expire time

    app.register_blueprint(auth)
    app.register_blueprint(create_db)
    app.register_blueprint(news)
    app.register_blueprint(one_to_many)
    app.register_blueprint(many_to_many)

    return app
示例#8
0
def create_app():
    app = Flask(__name__, static_folder="static")
    app.config.from_object(run_config())

    db.init_app(app)
    migrate = Migrate(app, db)
    app.permanent_session_lifetime = timedelta(
        minutes=20)  # add session expire time
    UserManager(app, db, User)
    app.register_blueprint(blueprint, url_prefix='/api')
    app.register_blueprint(user_bp)
    app.register_blueprint(game_bp)
    app.register_blueprint(base_bp)
    app.register_blueprint(wish_list_bp)

    return app
示例#9
0
def create_app():
    app = Flask(__name__)

    app.register_blueprint(room)
    app.register_blueprint(tenant)
    app.register_blueprint(stuff)
    app.config.from_object(run_config())

    @app.errorhandler(404)
    def page_not_found(e):
        code = 404
        if isinstance(e, HTTPException):
            code = e.code
        return jsonify(error=str(e)), code

    return app
示例#10
0
def create_app(env='DEV'):
    app = Flask(__name__)
    app.register_blueprint(app_user)
    app.register_blueprint(app_book)
    app.register_blueprint(app_library)
    app.register_blueprint(app_home)
    app.config.from_object(run_config(env))

    db.init_app(app)
    db.create_all(app=app)

    @app.errorhandler(404)
    def page_not_found(error):
        return render_template('page_not_found.html'), 404

    return app
示例#11
0
def runSim(input):
    """
    Call Vissim application through com object, load Vissim inpx file
    and run simulation with input parameters.

    :type input: dictionary
    :param input: decoded parameters
    :return: pandas dataframe
    """
    cfg = config.run_config()
    path = 'C:\Users\\nli\PycharmProjects\GA sim\hwy_1_corridor(autorun).inpx'
    run = cfg['run']
    period = cfg['period']

    def genQuery(input):
        x = 'TravTm(' + str(input) + ',1,All)'
        return x

    Vissim = com.Dispatch('Vissim.Vissim')
    Vissim.LoadNet(path)
    db = Vissim.Net.DrivingBehaviors.ItemByKey(3)

    Vissim.Graphics.CurrentNetworkWindow.SetAttValue("QuickMode",1)
    Vissim.SuspendUpdateGUI()
    Vissim.Simulation.SetAttValue('UseMaxSimSpeed', True)
    Vissim.Simulation.SetAttValue('NumRuns', run)
    Vissim.Simulation.SetAttValue('SimPeriod', period)

    db.SetAttValue('W99cc0', input['cc0'])
    db.SetAttValue('W99cc1Distr', input['cc1'])
    db.SetAttValue('W99cc4', input['cc4'])
    db.SetAttValue('W99cc5', input['cc5'])

    Vissim.Simulation.RunContinuous()

    # append results from each simulation run to table
    result = []
    for i in range(1, run+1):
        r = Vissim.Net.VehicleTravelTimeMeasurements.GetMultipleAttributes(('Name', genQuery(i)))
        result.append(list(r))

    df = pd.DataFrame(np.array(result).reshape(run,2), columns=['Route','TravTm'])
    df['TravTm'] = df['TravTm'].apply(pd.to_numeric)

    return df
示例#12
0
文件: app.py 项目: ibra86/common
def create_app():
    app = Flask(__name__)
    app.config.from_object(run_config())
    db.init_app(app)

    @app.before_first_request
    def create_tables():
        db.drop_all(app=app)
        db.create_all(app=app)
        db.session = db_init_room(db)

        db.session = db_init_stuff(db)
        db.session = db_init_tenant(db)
        db.session = db_init_stuff_to_room(db)
        db.session.commit()

    app.register_blueprint(healthcheck)
    app.register_error_handler(404, page_not_found)

    app.register_blueprint(room)
    app.register_blueprint(tenant)
    app.register_blueprint(stuff)

    return app
示例#13
0
from functools import wraps

from flask import Flask, request
from errors import errors
from config import run_config
from flask_restful import Api, Resource, reqparse, fields, marshal_with

app = Flask(__name__)
api = Api(app, errors=errors)
app.config.from_object(run_config())


class HelloRest(Resource):
    def get(self):
        return {"key": "value"}, 200, {"custom_header": "value"}

    def post(self):
        return "post"


a = ["Apple", "Amazon", "Alphabet", "Microsoft"]

parser = reqparse.RequestParser(bundle_errors=True)
parser.add_argument('page', type=int, help="wrong page expecting int")
parser.add_argument('filter', type=int, help="wrong filter type")
parser_2 = parser.copy()
parser_2.add_argument('new_value')


def cache(f):
    @wraps(f)
示例#14
0
from discord.ext import commands
import discord
from keep_alive import keep_alive
import os

from config import run_config

run_config()

bot = commands.Bot(command_prefix="m!",
                   case_insensitive=True,
                   description="Hypnotics Music ModMail Bot")


@bot.event
async def on_ready():  # When the bot is ready
    await bot.change_presence(activity=discord.Activity(
        type=discord.ActivityType.watching, name='your DMs!'))
    print("READY,", bot.user)


@bot.event
async def on_command_error(ctx, exception):
    if int(os.environ.get('DEBUG')):
        await ctx.send(exception)
    elif isinstance(exception, commands.errors.MissingRequiredArgument):
        await ctx.send(exception)


extensions = ['cogs.modmail', 'jishaku']
示例#15
0
 def __init__(self):
     config.run_config()
     self.nova_env = None
     self.env = os.environ.copy()
示例#16
0
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "execution_name",
        help="Name to identify the train execution - used to name the log files"
    )
    parser.add_argument("-d",
                        "--default",
                        help="Use default options when configuring execution",
                        action='store_true')
    args = parser.parse_args()

    #Run pre-train config
    try:
        import config
        print("Running config from config.py")
        config.run_config()
    except ImportError:
        print(
            "Unable to load config.py - Executing program with no pre-runtime configuration"
        )

#General imports
import os, shutil
import math, json
from time import time, strftime

if __name__ == '__main__':
    #TODO Determine how to use learning rate multipliers
    #TODO Determine how to use grouping in convolutional layer

    #Keras imports