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