Declaring Models in Flask

In Flask, models represent the data structure and handle database interactions. It allows developers to interact with databases using object-oriented programming instead of writing raw SQL queries. It simplifies database operations by converting database tables into Python classes and rows into objects. They define how data is stored, retrieved and managed in the application using Object Relational Mapping (ORM). Models work with databases like SQL, SQLite and more.

What is ORM in Python Flask?

ORM (Object Relational Mapping) is a technique that Models use ORM to make database interactions easier. Instead of dealing with complex SQL syntax, we can use Python classes and methods to manage data efficiently. Most popular used ORM is SQLAlchemy.

Declaring Models in Flask with Flask-SQL Alchemy

To declare models in flask, we start by importing the necessary modules and defining the create_app function, which returns a Flask app using the app factory pattern.

For small apps, everything is defined inside this function. In larger apps, it's best to organize the code into multiple files and use Flask Blueprints for better structure.

Here’s a breakdown of the code inside this function:

Step 1: Install flask-sqlalchemy

Flask doesn't support ORM, but with the help of flask-sqlalchemy, we can achieve the ORM functionalities. Install flask-sqlalchemy extension (if not already installed) using-

pip install flask-sqlalchemy

Step 2: Import Necessary Modules

First we import the Flask and SQLAlchemy.

from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
import datetime

Step 3: Configure the Flask App and Database

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///event_database.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

Explanation:

• SQLALCHEMY_DATABASE_URI: Specifies the database location (SQLite in this case).
• SQLALCHEMY_TRACK_MODIFICATIONS: Disables unnecessary change tracking for better performance.

Step 4: Initialize the Database

Create a database object

try:
    os.makedirs(app.instance_path)
except OSError:
    pass

Step 5: Define a Model

Now, we define a model, which represents a table in the database.

class Event(db.Model):
    id = db.Column(db.Integer, primary_key=True)  # Unique identifier
    date = db.Column(db.DateTime, default=datetime.datetime.utcnow)  # Event timestamp
    event = db.Column(db.String(200), nullable=False)  # Event description

Explanation:

• id: Auto-incrementing primary key.
• date: Stores event timestamps (defaults to the current time).
• event: Stores the event description, which cannot be null.

Step 6: Create the Database

Run the following inside an app context to generate the tables:

with app.app_context():
    db.create_all()

Explanation: This ensures all models are converted into database tables.

Step 7: Inserting Data into the Database

To add an event, create an instance of Event and commit it:

def add_event(event_description):
    new_event = Event(event=event_description)
    db.session.add(new_event)
    db.session.commit()

Explanation:

• new_event = Event(event=event_description): Creates a new event with the given description.
• db.session.add(new_event): Adds the new event to the database session.
• db.session.commit(): Commits the transaction, saving the event permanently.

Step 8: Querying the database

After adding events we can query the database using SQLAlchemy via db.session.

• In our home page, we query the database based on the request type:
  • GET request- Returns an HTML page with a table of all events.
  • We fetch events using:

db.session.execute(db.select(Event).order_by(Event.date)).scalars()

• This returns an iterable of Event objects.
• In the template, we access attributes:
  • e.date- Event date
  • e.event- Event description

@app.route('/', methods=['GET', 'POST'])
    def home():
        if(request.method == 'POST'):
            db.session.add(Event(date=datetime.datetime.now(
            ).__str__(), event=request.form['eventBox']))
            db.session.commit()
            return redirect(url_for('home'))
        return render_template('home.html', eventsList=db.session.execute(db.select(Event).order_by(Event.date)).scalars())

    return app

Similarly, the homepage can handle POST requests to add an event.

• The event details are received from the form.
• A new Event instance is created with the current date and description.
• We use db.session.add() to add it to the database.
• Finally, db.session.commit() is called to save the changes.

Flask app using Models

Let's create a simple flask app named "eventLog" as discussed in above steps where we can see and add events. The date and time are added automatically when the event is added.

File structure

rootFolder
|_ eventLog
    |_templates
    |   |_ home.html
    |_app.py

app.py File

This Flask web application uses a SQLite database to manage events. It defines a create_app function to set up the Flask app, SQLAlchemy and an Event model.

• A route handles form submissions on the home page, allowing users to add events.
• A CLI command (init-db) is included to initialize the database.

from flask import Flask, redirect, url_for, render_template, request
import os
import datetime
import click
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column

def create_app(test_config=None):
    # Create the Flask app
    app = Flask(__name__, instance_relative_config=True)

    app.config.from_pyfile('config.py', silent=True)
    app.config.from_mapping(SECRET_KEY='dev')

    # Ensure instance folder exists
    try:
        os.makedirs(app.instance_path)
    except OSError:
        pass

    # Configure the path to SQLite database
    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///event_database.db"

    class Base(DeclarativeBase):
        pass

    # Create the database object and initialize it
    db = SQLAlchemy(model_class=Base)
    db.init_app(app)

    # Define model for event
    class Event(db.Model):
        date = mapped_column(db.String, primary_key=True)
        event = mapped_column(db.String)

    @click.command('init-db')
    def init_db_command():
        """Command for initializing the database"""
        with app.app_context():
            db.create_all()
            click.echo('Database created successfully')

    app.cli.add_command(init_db_command)

    @app.route('/', methods=['GET', 'POST'])
    def home():
        if request.method == 'POST':
            db.session.add(Event(date=datetime.datetime.now().__str__(), event=request.form['eventBox']))
            db.session.commit()
            return redirect(url_for('home'))
        return render_template('home.html', eventsList=db.session.execute(db.select(Event).order_by(Event.date)).scalars())

    return app

if __name__ == "__main__":
    app = create_app()
    app.run(debug=True)  # Debug mode enabled for development

home.html Jinja Template

This HTML code creates a simple webpage to display an event log with a table showing date-time and event details.

• Jinja2 templating is used to loop through events from the Flask app and populate the table.
• A form allows users to add new events with a text input and submit button.
• An external "style.css" file is linked for styling.

<html>
    <head>
        <title>EventLog</title>
    </head>
    <body>
        <table>
            <tr>
                <th>Date & Time</th>
                <th>Event Details</th>
            </tr>
        {%-for row in eventsList-%}
            <tr>
                <td>{{row.date}}</td>
                <td>{{row.event}}</td>
            </tr>
        {%-endfor-%}
        </table>
        <hr/>
        <form method="post">
            <title>Add event</title>
            <label for="eventBox">Event Description</label>
            <input name="eventBox" id="eventBox" required/>
            <input type="submit" value = "Add">
        </form>
    </body>
</html>

Running the app

• First make sure that virtual environment is activated, execute this command to activate it-

venv\Scripts\activate

• Then run the following command to create the database and tables-

flask init-db

• Once done, run the flask app using the command-

python app.py

• This will start the app in debug mode at local host port 5000. Visit the following URL in browser-

http://127.0.0.1:5000/

Output: