Comment structurer cette application de flacon de taille moyenne?

Question

Utilisation du cadre de FLASK en Python, ma demande doit:

1. registre et connecter les utilisateurs (soit avec une base de données SQLite ou postgres)
2. d'accès d'une feuille de calcul Google spécifique que l'utilisateur connecté possède et sortie ces données dans un format json. je dois avoir ma propre autorisation & système d'authentification

J'ai beaucoup de mal à comprendre comment structurer même l'application - quels répertoires et sous-répertoires dois-je avoir?

J'ai fait BEAUCOUP de jeu (environ 1 mois). J'utilise un environnement virtuel mais je ne sais pas comment bien tester mon code. En général, mes courses de code, mais je ne sais pas comment ils travaillent ensemble vraiment ** Je suis tout à fait nouveau dans le ballon **

Structurer l'application:

| app

| -.. ---run.py

| ---- config.py

| ---- base de données

| --------- database.db

| ---- app

| --------- views.py

| --------- models.py

| - --------forms.py

| --------- extensions.py

| ---- modèles

| ------- -

| ---- statique

| --------....

Autorisation/Authentification: J'ai regardé Flask-Connexion, Flask-Auth, Flacon-Sécurité. Je comprends l'idée générale, mais je ne sais pas comment mettre en œuvre en toute sécurité un système d'authentification complète autorisation &.

app = Flask(__name__) 
app.config.from_object(config) 
login_manager = LoginManager() 
login_manager.init_app(app) 

def create_app(): 
    db.init_app() 
    db.app = app 
    db.create_all() 
    return app 

@app.route('/') 
def index(): 
    #needs to render the homepage template 

@app.route('/signup', methods = ['GET', 'POST']) 
def register(): 
    form = SignupForm() 
    if request.method == 'GET': 
     return render_template('signup.html', form=form) 
    elif request.method == 'POST': 
     if form.validate_on_submit(): 
      if User.query.filter_by(email=form.email.data).first(): 
       return "email exists" 
      else: 
       newuser = User(form.email.data, form.password.data) 
       db.session.add(newuser) 
       db.session.commit() 
       login_user(newuser) 

      return "New User created" 
    else: 
     return "form didn't validate" 

    return "Signup" 

@app.route('/login', methods = ['GET', 'POST']) 
def login(): 
    form = SignupForm() 

    if request.method == 'GET': 
     return render_template('login.html', form=form) 
    elif request.method == 'POST': 
     if form.validate_on_submit(): 
      user = User.query.filter_by(email=form.email.data).first() 
      if user: 
       if user.password == form.password.data: 
        login_user(user) 
        return "you are logged in" 
       else: 
        return "wrong password" 
      else: 
       return "user doesnt exist" 
     else: 
      return "form did not validate" 

@login_manager.user_loader 
def load_user(email): 
    return User.query.filter_by(email = email).first() 

@app.route('/protected') 
@login_required 
def protected(): 
    return "protected area for logged in users only" 

if __name__ == '__main__': 
    #app.create_app() 
    app.run(port=5000, host='localhost')` 

---

from flask_security import Security, SQLAlchemyUserDatastore, UserMixin, RoleMixin, login_required 
import os 

# Create app 
app = Flask(__name__) 
#app.config['DEBUG'] = True 
app.config['SECRET_KEY'] = '' 
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////' 
app.config['SECURITY_PASSWORD_HASH'] = 'sha512_crypt' 
app.config['SECURITY_PASSWORD_SALT'] = str(os.urandom(24)) 
# Create database connection object 
db = SQLAlchemy(app) 

# Define models 
roles_users = db.Table('roles_users', 
    db.Column('user_id', db.Integer(), db.ForeignKey('user.id')), 
    db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))) 

class Role(db.Model, RoleMixin): 
    id = db.Column(db.Integer(), primary_key=True) 
    name = db.Column(db.String(80), unique=True) 
    description = db.Column(db.String(255)) 

class User(db.Model, UserMixin): 
    id = db.Column(db.Integer, primary_key=True) 
    email = db.Column(db.String(255), unique=True) 
    password = db.Column(db.String(255)) 
    active = db.Column(db.Boolean()) 
    confirmed_at = db.Column(db.DateTime()) 
    roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) 


user_datastore = SQLAlchemyUserDatastore(db, User, Role) 
security = Security(app, user_datastore) 

# Create a user to test with 
@app.before_first_request 
def create_user(): 
    db.create_all() 
    user_datastore.create_user(email='', password='') 
    db.session.commit() 

@app.route('/') 
@login_required 
def home(): 
    #password = encrypt_password('mypass') 
    #print verify_and_update_password('mypass', password) 
    return "hello" 

if __name__ == '__main__': 
    app.run(debug=True, use_reloader=False) 

** Je voudrais vraiment apprécier toute orientation **

Answer 1

YA'LL, je me suis dit dehors & mon application est à la recherche BON:) J'utilise blueprints & un modèle d'usine d'application.

APP 
|_runserver.py 
|_/app 
|---__init__.py 
|---config.py 
|---extensions.py 
|---forms.py 
|---models.py 
|---/login_dashboard #blueprint 
|------__init__.py 
|------views.py 
|------/templates 
|---------base.html 
      . 
      . 
|------/static 
|-----------/css 
       . 
       . 
|-----------/js 
       . 
       . 
|-----------/img 
       . 
       . 

Answer 2

Structure du projet:
Si vous avez l'intention de construire une application Flask plus grande, vous devriez envisager de décomposer la fonctionnalité en Blueprints.
La documentation officielle Flask a un tutoriel sur la façon de structurer des applications plus importantes: http://flask.pocoo.org/docs/0.12/patterns/packages/

Aussi, jetez un oeil à la guide de l'auto-stoppeur à l'organisation de votre projet. Il a quelques très bons points: http://python-guide-pt-br.readthedocs.io/en/latest/writing/structure/

Si vous concevez une API REST envisager d'utiliser Flask-RESTful (qui fonctionne aussi bien avec Blueprints)