Migrate to FastAPI with a focus on async code

app/__init__.py

@@ -1,13 +1,5 @@
-from flask import Flask
+from fastapi import FastAPI
-from config import Config
-from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
-from flask_marshmallow import Marshmallow
 
-app = Flask(__name__)
+app = FastAPI()
-app.config.from_object(Config)
-db = SQLAlchemy(app)
-migrate = Migrate(app, db)
-ma = Marshmallow(app)
 
-from app import routes, models, schema
+from app import routes, schema

app/models.py

@@ -1,355 +0,0 @@
-from app import db
-from sqlalchemy import text
-
-
-class Users(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    social_id = db.Column(db.Text)
-    type = db.Column(db.Integer)
-    full_name = db.Column(db.String(255), index=True, unique=True)
-    email = db.Column(db.String(255), index=True, unique=True)
-    password = db.Column(db.String(255))
-    gender = db.Column(db.Integer)
-    mobile = db.Column(db.String(255))
-    user_image = db.Column(db.String(255))
-    city_id = db.Column(db.Integer)
-    user_type = db.Column(db.Integer)
-    otp = db.Column(db.String(255))
-    otp_valid_time = db.Column(db.Date)
-    access_key = db.Column(db.Text)
-    lang_type = db.Column(db.Integer)
-    badge = db.Column(db.Integer)
-    status = db.Column(db.Integer, server_default=text("0"))
-    admin_status = db.Column(db.Integer, server_default=text("0"))
-    device_id = db.Column(db.Text)
-    device_type = db.Column(db.Integer)
-    created = db.Column(db.TIMESTAMP, nullable=False, server_default=db.func.now())
-
-    def __init__(
-        self,
-        full_name,
-        email,
-        password,
-        gender,
-        mobile,
-        city_id,
-        user_type,
-        lang_type,
-        badge,
-        device_id,
-        device_type,
-        social_id="",
-        access_key="",
-        user_image=None,
-        type=0,
-    ):
-        self.social_id = social_id
-        self.type = type
-        self.full_name = full_name
-        self.email = email
-        self.password = password
-        self.gender = gender
-        self.mobile = mobile
-        self.user_image = user_image
-        self.city_id = city_id
-        self.user_type = user_type
-        self.access_key = access_key
-        self.lang_type = lang_type
-        self.badge = badge
-        self.device_id = device_id
-        self.device_type = device_type
-
-
-class Cities(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(255))
-    image = db.Column(db.String(255))
-    status = db.Column(db.Enum("1", "0"))
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(self, name, image, status, created, modified):
-        self.name = name
-        self.image = image
-        self.status = status
-        self.created = created
-        self.modified = modified
-
-
-class Games(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(255))
-    image = db.Column(db.String(255))
-    date_time = db.Column(db.DateTime)
-    price = db.Column(db.String(100))
-    description = db.Column(db.Text)
-    user_id = db.Column(db.Integer)
-    gender = db.Column(db.Enum("1", "2", "3"))
-    city_id = db.Column(db.Integer)
-    venue_id = db.Column(db.Integer)
-    sports_id = db.Column(db.Integer)
-    no_of_player = db.Column(db.Integer)
-    min_player = db.Column(db.Integer)
-    already_player = db.Column(db.Integer)
-    no_of_already_player = db.Column(db.Integer)
-    payment_mode = db.Column(db.Integer)
-    card_id = db.Column(db.Integer)
-    status = db.Column(db.Integer, server_default=text("1"))
-    game_status = db.Column(db.Integer, server_default=text("0"))
-    cancel_status = db.Column(db.Integer)
-    cancel_date = db.Column(db.DateTime)
-    noti_status = db.Column(db.Integer, server_default=text("0"))
-    conduct_status = db.Column(db.Integer, server_default=text("1"))
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self,
-        name,
-        image,
-        date_time,
-        price,
-        description,
-        user_id,
-        gender,
-        city_id,
-        venue_id,
-        sports_id,
-        no_of_player,
-        min_player,
-        already_player,
-        no_of_already_player,
-        payment_mode,
-        card_id,
-    ):
-        self.name = name
-        self.image = image
-        self.date_time = date_time
-        self.price = price
-        self.description = description
-        self.user_id = user_id
-        self.gender = gender
-        self.city_id = city_id
-        self.venue_id = venue_id
-        self.sports_id = sports_id
-        self.no_of_player = no_of_player
-        self.no_of_already_player = no_of_already_player
-        self.payment_mode = payment_mode
-        self.card_id = card_id
-
-
-class Payments(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    user_id = db.Column(db.Integer)
-    game_id = db.Column(db.Integer)
-    amount = db.Column(db.Integer)
-    token = db.Column(db.String(100))
-    charge_id = db.Column(db.String(200))
-    transfer_id = db.Column(db.String(200))
-    transaction_id = db.Column(db.String(200))
-    account_no = db.Column(db.String(200))
-    description = db.Column(db.Text)
-    pay_mode = db.Column(db.Integer)
-    status = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self,
-        user_id,
-        game_id,
-        amount,
-        token,
-        charge_id,
-        transfer_id,
-        transaction_id,
-        account_no,
-        description,
-        pay_mode,
-        status,
-    ):
-        self.user_id = user_id
-        self.game_id = game_id
-        self.amount = amount
-        self.token = token
-        self.charge_id = charge_id
-        self.transfer_id = transfer_id
-        self.transaction_id = transaction_id
-        self.account_no = account_no
-        self.description = description
-        self.pay_mode = pay_mode
-        self.status = status
-
-
-class PlayerAvailabilities(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    game_id = db.Column(db.Integer)
-    player_id = db.Column(db.Integer)
-    status = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, game_id, player_id, status,
-    ):
-        self.game_id = game_id
-        self.player_id = player_id
-        self.status = status
-
-
-class PlayerCancelGames(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    player_id = db.Column(db.Integer)
-    game_id = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, player_id, game_id,
-    ):
-        self.player_id = player_id
-        self.game_id = game_id
-
-
-class PurchaseGames(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    game_id = db.Column(db.Integer)
-    user_id = db.Column(db.Integer)
-    pay_mode = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, game_id, user_id, pay_mode,
-    ):
-        self.game_id = game_id
-        self.user_id = user_id
-        self.pay_mode = pay_mode
-
-
-class Sports(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(255))
-    spanish_name = db.Column(db.String(100))
-    status = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, name, spanish_name, status,
-    ):
-        self.name = name
-        self.spanish_name = spanish_name
-        self.status = status
-
-
-class Teams(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    user_id = db.Column(db.Integer)
-    team_id = db.Column(db.Enum("1", "2"))
-    game_id = db.Column(db.Integer)
-    status = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, game_id, user_id, team_id, status,
-    ):
-        self.game_id = game_id
-        self.user_id = user_id
-        self.team_id = team_id
-        self.status = status
-
-
-class UserRatings(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    game_id = db.Column(db.Integer)
-    user_id = db.Column(db.Integer)
-    player_id = db.Column(db.Integer)
-    rating = db.Column(db.String(100))
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-    user_type = db.Column(db.Integer)
-
-    def __init__(self, game_id, user_id, player_id, rating, user_type):
-        self.game_id = game_id
-        self.user_id = user_id
-        self.player_id = player_id
-        self.rating = rating
-        self.user_type = user_type
-
-
-class VenueImages(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    venue_id = db.Column(db.Integer)
-    user_id = db.Column(db.Integer)
-    image = db.Column(db.String(255))
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    updated = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, venue_id, user_id, image,
-    ):
-        self.venue_id = venue_id
-        self.user_id = user_id
-        self.image = image
-
-
-class Venues(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    user_id = db.Column(db.Integer)
-    address = db.Column(db.Text)
-    latitude = db.Column(db.String(100))
-    longitude = db.Column(db.String(100))
-    name = db.Column(db.String(100))
-    sports_id = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    modified = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, user_id, address, latitude, longitude, name, sports_id,
-    ):
-        self.user_id = user_id
-        self.address = address
-        self.latitude = latitude
-        self.longitude = longitude
-        self.name = name
-        self.sports_id = sports_id
-
-
-class ViewNews(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    news_id = db.Column(db.Integer)
-    user_id = db.Column(db.Integer)
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    updated = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, news_id, user_id,
-    ):
-        self.news_id = news_id
-        self.user_id = user_id
-
-
-class WebBookings(db.Model):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(255))
-    email = db.Column(db.String(255))
-    contact = db.Column(db.String(100))
-    message = db.Column(db.Text)
-    game = db.Column(db.String(255))
-    city = db.Column(db.String(100))
-    created = db.Column(db.DateTime, nullable=False, server_default=db.func.now())
-    updated = db.Column(db.DateTime, nullable=False, onupdate=db.func.now())
-
-    def __init__(
-        self, user_id, address, name, email, contact, message, game, city,
-    ):
-        self.user_id = user_id
-        self.address = address
-        self.name = name
-        self.email = email
-        self.contact = contact
-        self.message = message
-        self.game = game
-        self.city = city

app/routes.py

@@ -1,28 +1,29 @@
-from flask import request, jsonify, make_response
+from fastapi import Response, status
-from database.crud import insert_data, verify_otp, verify_login
+
-from app.twilio import send_otp
 from app import app
+from app.schemas import *
+from app.twilio import send_otp
+from database.crud import insert_data, verify_login, verify_otp
 
 
-@app.route("/register", methods=["POST"])
+@app.post("/register", status_code=status.HTTP_200_OK)
-def create_user():
+async def create_user(request: RegisterSchema):
-    data = request.get_json()
+    insert_data(schema="Users", data=request)
-    insert_data(schema="Users", data=data)
+    send_otp(receiver=request.mobile)
-    send_otp(receiver=data["mobile"])
+    return {"message": "User created, pending OTP verification"}
-    return make_response(jsonify("User created, pending OTP verification"))
 
 
-@app.route("/login", methods=["POST"])
+# FIXME Use OAuth2 for verification
-def log_in():
+@app.post("/login", status_code=status.HTTP_200_OK)
-    data = request.get_json
+async def log_in(request: LoginSchema, response: Response):
-    if verify_login(data=data):
+    return {"message": "Logged in successfully"}
-        return make_response(jsonify("Successful login"))
+    # response.status_code = status.HTTP_400_BAD_REQUEST
-    return make_response(jsonify("The email/password combination is not correct"))
+    # return {"message": "The email/password combination is not correct"}
 
 
-@app.route("/otpVerification", methods=["POST"])
+@app.post("/otpVerification", status_code=status.HTTP_200_OK)
-def validate_otp():
+async def validate_otp(request: OTPSchema, response: Response):
-    data = request.get_json()
+    if verify_otp(data=request):
-    if verify_otp(mobile=data["mobile"], otp=data["otp"]):
+        return {"message": "The OTP has been verified successfully"}
-        return make_response(jsonify("The OTP has been verified successfully"))
+    response.status_code = status.HTTP_400_BAD_REQUEST
-    return make_response(jsonify("The OTP is not correct"))
+    return {"message": "The OTP is not correct"}

app/schema.py

@@ -1,101 +0,0 @@
-from app import ma
-from app.models import *
-from marshmallow import fields
-from marshmallow.validate import Length, Range
-
-
-class UsersSchema(ma.Schema):
-    full_name = fields.Str(required=True, validate=Length(max=255))
-    email = fields.Email(required=True, validate=Length(max=255))
-    password = fields.Str(validate=Length(max=255))
-    gender = fields.Integer(required=True, validate=Range(min=1, max=3))
-    mobile = fields.Str(required=True, validate=Length(max=13))
-    user_image = fields.Str(validate=Length(max=255))
-    user_type = fields.Integer(required=True, validate=Range(min=1, max=2))
-    lang_type = fields.Integer(required=True, validate=Range(min=1, max=2))
-    device_type = fields.Integer(validate=Range(min=1, max=2))
-    device_id = fields.Str(required=True)
-
-
-class CitiesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Cities
-        load_instance = True
-        include_relationships = True
-
-
-class GamesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Games
-        load_instance = True
-        include_relationships = True
-
-
-class PlayerAvailabilitiesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = PlayerAvailabilities
-        load_instance = True
-        include_relationships = True
-
-
-class PlayerCancelGamesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = PlayerCancelGames
-        load_instance = True
-        include_relationships = True
-
-
-class PurchaseGamesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = PurchaseGames
-        load_instance = True
-        include_relationships = True
-
-
-class SportsSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Sports
-        load_instance = True
-        include_relationships = True
-
-
-class TeamsSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Teams
-        load_instance = True
-        include_relationships = True
-
-
-class UserRatingsSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = UserRatings
-        load_instance = True
-        include_relationships = True
-
-
-class VenueImagesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = VenueImages
-        load_instance = True
-        include_relationships = True
-
-
-class VenuesSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Venues
-        load_instance = True
-        include_relationships = True
-
-
-class ViewNewsSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = ViewNews
-        load_instance = True
-        include_relationships = True
-
-
-class WebBookingsSchema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = WebBookings
-        load_instance = True
-        include_relationships = True

app/schemas.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel, EmailStr
+from fastapi import Query
+
+
+class RegisterSchema(BaseModel):
+    full_name: str
+    email: EmailStr
+    password: str
+    gender: int = Query(le=1, ge=3)
+    mobile: str = Query(min_length=8, max_length=13)
+    user_image: str = None
+    user_type: int = Query(le=1, ge=2)
+    lang_type: int = Query(le=1, ge=2)
+    device_type: int = Query(le=1, ge=2)
+    device_id: str
+
+
+class LoginSchema(BaseModel):
+    email: EmailStr
+    password: str
+    user_type: int = Query(le=1, ge=2)
+    lang_type: int = Query(le=1, ge=2)
+    device_id: str
+
+
+class OTPSchema(BaseModel):
+    mobile: str = Query(min_length=8, max_length=13)
+    otp: int = Query(le=6, ge=6)

app/twilio.py

@@ -1,25 +1,25 @@
 from twilio.rest import Client
 from secrets import randbits
-from constants import account_id, token, sms_sender
+from constants import ACCOUNT_ID, TOKEN, SMS_SENDER
 from database.crud import save_otp
 
 
-def connect_api():
+async def connect_api():
-    account_sid = account_id
+    account_sid = ACCOUNT_ID
-    auth_token = token
+    auth_token = TOKEN
     client = Client(account_sid, auth_token)
     return client
 
 
-def generate_code():
+async def generate_code():
     bits = 16
     code = randbits(bits)
     return code
 
 
-def send_otp(receiver):
+async def send_otp(receiver):
     client = connect_api()
     code = generate_code()
     message = "Your OTP code is {0}".format(code)
-    client.messages.create(to=receiver, from_=sms_sender, body=message)
+    client.messages.create(to=receiver, from_=SMS_SENDER, body=message)
     save_otp(receiver, code)

config.py

@@ -1,7 +0,0 @@
-from constants import connection_uri, secret_key
-
-
-class Config(object):
-    SQLALCHEMY_DATABASE_URI = connection_uri
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
-    SECRET_KEY = secret_key

database/__init__.py

@@ -0,0 +1,12 @@
+from constants import CONNECTION_URI
+from sqlalchemy import MetaData, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from databases import Database
+
+metadata = MetaData()
+engine = create_engine(CONNECTION_URI)
+metadata.create_all(engine)
+Base = declarative_base()
+database = Database(CONNECTION_URI)
+
+from database import models

database/crud.py

@@ -1,73 +1,74 @@
 from datetime import datetime
-from app import db
+
-from app.models import *
+from app import app
-from app.schema import *
+from app.schemas import *
-from marshmallow import ValidationError
+from database import database
-from pydoc import locate
 from werkzeug.security import check_password_hash
+from pydoc import locate
 
 
-def validate_schema(schema, data):
+@app.on_event("startup")
-    schema_name = schema + "Schema"
+async def startup():
-    validation_schema = locate("app.schema." + schema_name)
+    await database.connect()
-    instance = validation_schema()
-    instance.load(data)
 
 
-def validate_json(schema, data):
+@app.on_event("shutdown")
-    validate_schema(schema=schema, data=data)
+async def shutdown():
-    model = locate("app.models." + schema)
+    await database.disconnect()
+
+
+async def instantiate_model(schema, data):
+    model = locate("database.models." + schema)
     instance = model(**data)
     return instance
 
 
-def insert_data(schema, data):
+async def insert_data(schema, data):
-    instance = validate_json(schema, data)
+    instance = instantiate_model(schema, data)
-    db.session.add(instance)
+    query = instance.insert()
-    db.session.commit()
+    await database.execute(query=query, values=data)
 
 
-def delete_data(data):
+# FIXME instance.id has to be replaced with the table's UID
-    db.session.delete(data)
+async def delete_data(schema, data):
-    db.session.commit()
+    instance = instantiate_model(schema, data)
+    query = instance.delete().where(instance.id == data.id)
+    await database.execute(query=query)
 
 
-def save_otp(mobile, otp):
+async def fetch_user(data):
-    db.session.query(table="Users").filter_by(mobile=mobile).update(dict(otp=otp))
+    instance = instantiate_model(schema="Users", data=data)
-    db.session.commit()
+    query = instance.select().where(instance.email == data.email)
+    return await database.fetch_one(query=query)
 
 
-def fetch_stored_otp(mobile):
+async def fetch_otp(data: OTPSchema):
-    user = db.session.query(table="Users").filter_by(mobile=mobile)
+    instance = instantiate_model(schema="Users", data=data)
-    otp = user.otp
+    query = instance.select().where(instance.mobile == data.mobile)
-    return otp
+    return await database.fetch_one(query=query)
 
 
-def activate_account(mobile):
+async def save_otp(data: OTPSchema):
+    instance = instantiate_model(schema="Users", data=data)
+    query = instance.update().where(instance.mobile == data.mobile).values(otp=data.otp)
+    await database.execute(query=query)
+
+
+async def activate_account(data: OTPSchema):
     timestamp = datetime.now()
-    db.session.query(table="Users").filter_by(mobile=mobile).update(
+    instance = instantiate_model(schema="Users", data=data)
-        dict(otp_valid_time=timestamp)
+    query = (
+        instance.update()
+        .where(instance.mobile == data.mobile)
+        .values(mobile=instance.data, otp_valid_time=timestamp, status=1)
     )
-    db.session.query(table="Users").filter_by(mobile=mobile).update(dict(status=1))
+    await database.execute(query=query)
 
 
-def verify_otp(mobile, otp):
+async def verify_otp(data: OTPSchema):
-    stored_otp = fetch_stored_otp(mobile=mobile)
+    user = fetch_otp(data=data)
+    stored.otp = user.otp
     if stored_otp == otp:
         activate_account(mobile=mobile)
         return True
     return False
-
-
-def fetch_user(data):
-    user = db.session.query(table="Users").filter_by(email=data["email"])
-    email = user.email
-    password = user.password
-    return email, password
-
-
-def verify_login(data):
-    user, password = fetch_user(data)
-    if user == data["email"] and check_password_hash(password, data["password"]):
-        return True
-    return False

database/models.py

@@ -0,0 +1,356 @@
+from app import Base
+from sqlalchemy import Column, Integer, String, DateTime, Text, Enum
+from sqlalchemy.sql import func
+
+
+class Users(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    social_id = Column(Text)
+    type = Column(Integer)
+    full_name = Column(String(255), index=True, unique=True)
+    email = Column(String(255), index=True, unique=True)
+    password = Column(String(255))
+    gender = Column(Integer)
+    mobile = Column(String(255))
+    user_image = Column(String(255))
+    city_id = Column(Integer)
+    user_type = Column(Integer)
+    otp = Column(String(255))
+    otp_valid_time = Column(DateTime)
+    access_key = Column(Text)
+    lang_type = Column(Integer)
+    badge = Column(Integer)
+    status = Column(Integer, server_default=Text("0"))
+    admin_status = Column(Integer, server_default=Text("0"))
+    device_id = Column(Text)
+    device_type = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+
+    def __init__(
+        self,
+        full_name,
+        email,
+        password,
+        gender,
+        mobile,
+        city_id,
+        user_type,
+        lang_type,
+        badge,
+        device_id,
+        device_type,
+        social_id="",
+        access_key="",
+        user_image=None,
+        type=0,
+    ):
+        self.social_id = social_id
+        self.type = type
+        self.full_name = full_name
+        self.email = email
+        self.password = password
+        self.gender = gender
+        self.mobile = mobile
+        self.user_image = user_image
+        self.city_id = city_id
+        self.user_type = user_type
+        self.access_key = access_key
+        self.lang_type = lang_type
+        self.badge = badge
+        self.device_id = device_id
+        self.device_type = device_type
+
+
+class Cities(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255))
+    image = Column(String(255))
+    status = Column(Enum("1", "0"))
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(self, name, image, status, created, modified):
+        self.name = name
+        self.image = image
+        self.status = status
+        self.created = created
+        self.modified = modified
+
+
+class Games(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255))
+    image = Column(String(255))
+    date_time = Column(DateTime)
+    price = Column(String(100))
+    description = Column(Text)
+    user_id = Column(Integer)
+    gender = Column(Enum("1", "2", "3"))
+    city_id = Column(Integer)
+    venue_id = Column(Integer)
+    sports_id = Column(Integer)
+    no_of_player = Column(Integer)
+    min_player = Column(Integer)
+    already_player = Column(Integer)
+    no_of_already_player = Column(Integer)
+    payment_mode = Column(Integer)
+    card_id = Column(Integer)
+    status = Column(Integer, server_default=Text("1"))
+    game_status = Column(Integer, server_default=Text("0"))
+    cancel_status = Column(Integer)
+    cancel_date = Column(DateTime)
+    noti_status = Column(Integer, server_default=Text("0"))
+    conduct_status = Column(Integer, server_default=Text("1"))
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self,
+        name,
+        image,
+        date_time,
+        price,
+        description,
+        user_id,
+        gender,
+        city_id,
+        venue_id,
+        sports_id,
+        no_of_player,
+        min_player,
+        already_player,
+        no_of_already_player,
+        payment_mode,
+        card_id,
+    ):
+        self.name = name
+        self.image = image
+        self.date_time = date_time
+        self.price = price
+        self.description = description
+        self.user_id = user_id
+        self.gender = gender
+        self.city_id = city_id
+        self.venue_id = venue_id
+        self.sports_id = sports_id
+        self.no_of_player = no_of_player
+        self.no_of_already_player = no_of_already_player
+        self.payment_mode = payment_mode
+        self.card_id = card_id
+
+
+class Payments(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(Integer)
+    game_id = Column(Integer)
+    amount = Column(Integer)
+    token = Column(String(100))
+    charge_id = Column(String(200))
+    transfer_id = Column(String(200))
+    transaction_id = Column(String(200))
+    account_no = Column(String(200))
+    description = Column(Text)
+    pay_mode = Column(Integer)
+    status = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self,
+        user_id,
+        game_id,
+        amount,
+        token,
+        charge_id,
+        transfer_id,
+        transaction_id,
+        account_no,
+        description,
+        pay_mode,
+        status,
+    ):
+        self.user_id = user_id
+        self.game_id = game_id
+        self.amount = amount
+        self.token = token
+        self.charge_id = charge_id
+        self.transfer_id = transfer_id
+        self.transaction_id = transaction_id
+        self.account_no = account_no
+        self.description = description
+        self.pay_mode = pay_mode
+        self.status = status
+
+
+class PlayerAvailabilities(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    game_id = Column(Integer)
+    player_id = Column(Integer)
+    status = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, game_id, player_id, status,
+    ):
+        self.game_id = game_id
+        self.player_id = player_id
+        self.status = status
+
+
+class PlayerCancelGames(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    player_id = Column(Integer)
+    game_id = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, player_id, game_id,
+    ):
+        self.player_id = player_id
+        self.game_id = game_id
+
+
+class PurchaseGames(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    game_id = Column(Integer)
+    user_id = Column(Integer)
+    pay_mode = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, game_id, user_id, pay_mode,
+    ):
+        self.game_id = game_id
+        self.user_id = user_id
+        self.pay_mode = pay_mode
+
+
+class Sports(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255))
+    spanish_name = Column(String(100))
+    status = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, name, spanish_name, status,
+    ):
+        self.name = name
+        self.spanish_name = spanish_name
+        self.status = status
+
+
+class Teams(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(Integer)
+    team_id = Column(Enum("1", "2"))
+    game_id = Column(Integer)
+    status = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, game_id, user_id, team_id, status,
+    ):
+        self.game_id = game_id
+        self.user_id = user_id
+        self.team_id = team_id
+        self.status = status
+
+
+class UserRatings(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    game_id = Column(Integer)
+    user_id = Column(Integer)
+    player_id = Column(Integer)
+    rating = Column(String(100))
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+    user_type = Column(Integer)
+
+    def __init__(self, game_id, user_id, player_id, rating, user_type):
+        self.game_id = game_id
+        self.user_id = user_id
+        self.player_id = player_id
+        self.rating = rating
+        self.user_type = user_type
+
+
+class VenueImages(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    venue_id = Column(Integer)
+    user_id = Column(Integer)
+    image = Column(String(255))
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    updated = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, venue_id, user_id, image,
+    ):
+        self.venue_id = venue_id
+        self.user_id = user_id
+        self.image = image
+
+
+class Venues(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(Integer)
+    address = Column(Text)
+    latitude = Column(String(100))
+    longitude = Column(String(100))
+    name = Column(String(100))
+    sports_id = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    modified = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, user_id, address, latitude, longitude, name, sports_id,
+    ):
+        self.user_id = user_id
+        self.address = address
+        self.latitude = latitude
+        self.longitude = longitude
+        self.name = name
+        self.sports_id = sports_id
+
+
+class ViewNews(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    news_id = Column(Integer)
+    user_id = Column(Integer)
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    updated = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, news_id, user_id,
+    ):
+        self.news_id = news_id
+        self.user_id = user_id
+
+
+class WebBookings(Base):
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255))
+    email = Column(String(255))
+    contact = Column(String(100))
+    message = Column(Text)
+    game = Column(String(255))
+    city = Column(String(100))
+    created = Column(DateTime, nullable=False, server_default=func.now())
+    updated = Column(DateTime, nullable=False, onupdate=func.now())
+
+    def __init__(
+        self, user_id, address, name, email, contact, message, game, city,
+    ):
+        self.user_id = user_id
+        self.address = address
+        self.name = name
+        self.email = email
+        self.contact = contact
+        self.message = message
+        self.game = game
+        self.city = city

shell.nix

@@ -5,15 +5,16 @@ with pkgs.python37Packages;
 pkgs.mkShell {
   buildInputs = [
     # Dependencies
-    flask
+    fastapi
-    flask_sqlalchemy
+    uvicorn
-    flask_migrate
+    pydantic
-    flask_marshmallow
+    email_validator
+    sqlalchemy
     pymysql
-    marshmallow
+    databases
-    marshmallow-sqlalchemy
+    aiomysql
+    alembic
     pytest
-    pytest-flask
     twilio
     # Development tools
     black
@@ -22,5 +23,6 @@ pkgs.mkShell {
     python-language-server
     pyls-black
     pyls-isort
+    pyls-mypy
   ];
 }

tests/conftest.py

@@ -1,10 +0,0 @@
-from app import app as test_app
-from pytest import fixture
-from secrets import token_bytes
-
-
-@fixture
-def app():
-    test_app.config["TESTING"] = True
-    test_app.config["WTF_CSRF_ENABLED"] = False
-    return test_app

tests/queries_test.py

@@ -1,4 +1,4 @@
-from app.models import *
+from database.models import *
 from datetime import datetime