def __init__(self, device_name="cpu"): self.device_name = device_name device = torch.device(device_name) self.sq_feature, self.vae = mymodels.create_models() self.vae.load_state_dict(torch.load('../ml/vae.md')) self.vae = self.vae.eval() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.loader = transforms.Compose( [transforms.Resize((256, 256)), transforms.ToTensor(), normalize]) self.centers = torch.load('../index/centroids.tensor') self.cos = nn.CosineSimilarity(dim=-1)
from flask import Flask, render_template from flask_sqlalchemy import SQLAlchemy as SA import config import mysql.connector app = Flask('Library Management System') app.config["SQLALCHEMY_DATABASE_URI"] = config.DEV db = SA(app) from models import create_models create_models(db) # @app.route('/') # def index(): # def db_query(): # db = Database() # emps = db.list_employees() # return emps # res = db_query() # print(res) # return render_template('employess.html', result=res, content_type='application/json')
from flask import Flask from common.oauth_client import create_oauth_client from models import create_models, db from admin import create_admin_endpoints from okpy import create_okpy_endpoints from worker import create_worker_endpoints from superadmin import create_superadmin_endpoints app = Flask(__name__) if __name__ == "__main__": app.debug = True create_oauth_client(app, "61a-autograder") create_models(app) create_admin_endpoints(app) create_okpy_endpoints(app) create_worker_endpoints(app) create_superadmin_endpoints(app) @app.before_first_request def init_db(): db.init_app(app) db.create_all(app=app) @app.route("/") def index():
transforms.ToTensor(), normalize]) traindir = '../danbooru/' image_dataset = datasets.ImageFolder(traindir, loader) validate_set, training_set = torchdata.random_split( image_dataset, (validate_size, len(image_dataset) - validate_size)) print(len(validate_set), len(training_set)) training_dataloader = DataLoader(training_set, batch_size=bsize, shuffle=True) validate_dataloader = repeating_dataloader_generator(validate_set, bsize) # torch stuff device = torch.device("cpu") sq_feature, vae = mymodels.create_models() sq_feature = sq_feature.to(device) # ~ if path.exists('vae.md'): # ~ vae.load_state_dict(torch.load('vae.md')) vae = vae.to(device) optimizer = optim.Adam(vae.parameters(), lr=1e-4) loss_list = [] # training for i, (training_data, _) in enumerate(training_dataloader): optimizer.zero_grad() training_loss = get_loss(training_data, sq_feature, vae, device)
elif opt.dataset == 'celebA': raise NotImplementedError('CelebA is not available in visiontorch yet ;D') assert dataset dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=int(opt.workers)) ngpu = int(opt.ngpu) # number of GPUs nc = int(opt.nc) # number input channels nz = int(opt.nz) # latent space size eps = 1e-15 # to avoid possible numerical instabilities during backward # create models and load parameters if needed netGx, netGz, netDx, netDz, netDxz = ali.create_models(opt.dataset, nz, ngpu) if opt.netGz != '': # load checkpoint if needed netGz.load_state_dict(torch.load(opt.netGz)) print(netGz) if opt.netGx != '': # load checkpoint if needed netGx.load_state_dict(torch.load(opt.netGx)) print(netGx) if opt.netDz != '': # load checkpoint if needed netDz.load_state_dict(torch.load(opt.netDz)) print(netDz) if opt.netDx != '': # load checkpoint if needed netDx.load_state_dict(torch.load(opt.netDx))
import models as m import database as db import data import create_warehouse as cw if __name__ == '__main__': engine, session = db.sqlalchemy_session() m.create_models(engine) data.main() cw.main()
if not ship_skin: continue ship_skins.append(ship_skin) return ship_skins if __name__ == '__main__': try: path_to_game = sys.argv[2] except IndexError: path_to_game = os.path.expanduser('~/Starsector') ENGINE = create_engine( "postgresql+psycopg2://admiral:fleet@localhost/starsector", isolation_level="READ UNCOMMITTED") create_models(ENGINE) with ENGINE.connect() as connection: Session = sessionmaker(bind=ENGINE) session = Session() mods = get_mods_folders(path_to_game) for mod in mods: weapons = parse_weapon_files(mods[mod], mod) for weapon in weapons: copy_weapon_sprites_to_static(weapon, mods[mod]) _ = insert_or_update_weapon(weapon, session) session.commit() ships = parse_hull_files(mods[mod], mod) for ship in ships: copy_ship_sprite_to_static(ship, mods[mod])
def create_app(test_config=None): # For automated tests # Setup Flask and read config from ConfigClass defined above app = Flask(__name__) app.config.from_object(__name__+'.ConfigClass') # Load local_settings.py if file exists # For automated tests try: app.config.from_object('local_settings') except: pass # Load optional test_config # For automated tests if test_config: app.config.update(test_config) # Initialize Flask extensions mail = Mail(app) # Initialize Flask-Mail db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy User, Role, UserRoles, Posts = create_models(db) # Reset all the database tables db.create_all() # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Create 'user007' user with 'secret' and 'agent' roles if not User.query.filter(User.username=='admin').first(): user1 = User(username='******', email='*****@*****.**', active=True, password=user_manager.hash_password('password')) user1.roles.append(Role(name='admin')) db.session.add(user1) db.session.commit() if len(Posts.query.all()) == 0: post = Posts(user_id=3, title='hello world', content='this is a test post to test the query') db.session.add(post) db.session.commit() # The Home page is accessible to anyone @app.route('/') @login_required def home_page(): # posts = get_posts(db) posts = Posts.query.all() return render_template('main.html', posts=posts) @app.route('/post', methods=['GET', 'POST']) def new_post(): if request.method == 'GET': return render_template('post_form.html') elif request.method == 'POST': form = request.form post = Posts(user_id=session['user_id'], title=form['title'], content=form['content']) db.session.add(post) db.session.commit() flash('post successful') return redirect(url_for('home_page')) # The Special page requires a user with 'special' and 'sauce' roles or with 'special' and 'agent' roles. @app.route('/admin') @roles_required('admin') # Use of @roles_required decorator def special_page(): return 'this isn\'t done yet' return app
from flask import render_template from database import db from api import app from models import create_models # Create a URL route in application for "/" @app.route('/') def home(): return render_template('home.html') # If in stand alone mode, run the application if __name__ == '__main__': db.connect() create_models() app.run(debug=True)
def create_app(test_config=None): app = Flask(__name__) db_data = create_models(app) db = db_data['db'] Account = db_data['Account'] Transaction = db_data['Transaction'] @app.route('/accounts') def get_accounts(): """ GET Accounts curl http://127.0.0.1:5000/accounts """ accounts_query = Account.query accounts = accounts_query.all() accounts_count = accounts_query.count() return jsonify({ 'accounts': [a.serialize for a in accounts], 'accounts_count': accounts_count }) @app.route('/transactions') def get_transactions(): """ GET Accounts curl http://127.0.0.1:5000/accounts """ transactions_query = Transaction.query transactions = transactions_query.all() transactions_count = transactions_query.count() return jsonify({ 'transactions': [t.serialize for t in transactions], 'transactions_count': transactions_count }) @app.route('/transactions/<int:trans_id>') def get_transaction(trans_id): """ GET Transaction(only one) curl http://127.0.0.1:5000/transactions/3 """ trans = Transaction.query.get(trans_id) if trans is None: abort(404) return jsonify({'success': True, 'transaction': trans.serialize}) @app.route('/accounts', methods=['POST']) def add_account(): """ POST Account curl -X POST -H "Content-Type:application/json" -d '{"name":"ali","type":"Savings","address":"egy cairo", "phone":"01001234567","balance":"1000","active":"true"}' http://127.0.0.1:5000/accounts """ body = request.get_json() name = body.get('name') account_type = body.get('type') address = body.get('address') phone = body.get('phone') balance = float(body.get('balance')) active = bool(body.get('active')) try: account = Account(name=name, type=account_type, address=address, phone=phone, balance=balance, active=active) db.session.add(account) # Error when return this object "'dict' object is not callable" serialized = account.serialize db.session.commit() return jsonify({'success': True, 'account': serialized}) except Exception as e: print(str(e)) db.session.rollback() abort(422) @app.route("/transactions", methods=["POST"]) def add_transaction(): """ POST Transaction curl http://127.0.0.1:5000/transactions -X POST -H "Content-Type:application/json" -d '{"account_id":1, "amount":500.0, "transaction_type":"deposit"}' """ body = request.get_json() account_id = body.get("account_id", None) amount = body.get("amount", None) transaction_type = body.get("transaction_type", None) try: account = Account.query.get(account_id) if account is None: raise Exception("Invalid Account Id") new_transaction = Transaction(account_id=account_id, amount=amount, type=transaction_type, date=datetime.now()) if transaction_type.lower() == "withdraw": account.balance -= amount elif transaction_type.lower() == "deposit": account.balance += amount db.session.add(new_transaction) serialized = new_transaction.serialize db.session.commit() return jsonify({"success": True, "transaction": serialized}) except Exception as e: print(str(e)) db.session.rollback() abort(422) finally: db.session.close() @app.route("/accounts/<int:account_id>", methods=['PATCH']) def toggle_account_activation(account_id): ''' Activate and deactivate the account. curl http://127.0.0.1:5000/accounts/1 -X PATCH ''' try: account = Account.query.get(account_id) if account == None: raise Exception("Invalid Account Id") account.active = not account.active current_status = account.active db.session.commit() return jsonify({"success": True, "active": current_status}) except Exception as e: print(str(e)) db.session.rollback() abort(422) finally: db.session.close() @app.errorhandler(400) def bad_request(error): return jsonify({ 'success': False, 'error': 400, 'message': 'Bad request' }), 400 @app.errorhandler(404) def notfound(error): return jsonify({ 'success': False, 'error': 404, 'message': 'Resource not found' }), 404 @app.errorhandler(405) def not_allowed(error): return jsonify({ 'success': False, 'error': 405, 'message': 'Method not allowed' }), 405 @app.errorhandler(422) def unprocessable(error): return jsonify({ 'success': False, 'error': 422, 'message': 'Unprocessable entity' }), 422 @app.errorhandler(500) def server_error(error): return jsonify({ 'success': False, 'error': 500, 'message': 'Internal server error' }), 500 return app
def main(): engine = sqlalchemy_connect() m.create_models(engine)
app.config['MAIL_PORT'] = os.environ.get('MAIL_PORT', '25') app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME') app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD') app.config['MAIL_USE_TLS'] = True app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = 'FROM FLASKY:' app.config['FLASKY_MAIL_SENDER'] = 'Victor' app.config['FLASKY_ADMIN'] = '*****@*****.**' db = SQLAlchemy(app) migrate = Migrate(app, db) bootstrap = Bootstrap(app) mail = Mail(app) mails = EmailService(app, mail) # import all the models here Role, User = create_models() # Routes and view functions @app.shell_context_processor def make_shell_context(): return dict(db=db, User=User, Role=Role, mail=mail) @app.before_request def initiate_user(): user = { "name": "Victor Ughonu", "age": 24