Flask-Migrate Example Explanation

This document explains the Flask-Migrate example we've set up.

Overview

The example demonstrates how to:

1. Set up a Flask application with SQLAlchemy and Flask-Migrate
2. Define models using SQLAlchemy
3. Create and apply database migrations
4. Add new fields to existing models
5. Create new models and corresponding migrations

Project Structure

flask_migrate_example/
├── app.py
├── migrations/
│   ├── versions/
│   │   ├── <hash>_initial_migration.py
│   │   ├── <hash>_add_data_quality_field.py
│   │   └── <hash>_add_processeddata_model.py
│   ├── alembic.ini
│   ├── env.py
│   ├── README
│   └── script.py.mako
└── app.db

Code Explanation

Model Definition (app.py)

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

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

db = SQLAlchemy(app)
migrate = Migrate(app, db)

class DataSource(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    url = db.Column(db.String(500), nullable=False)
    type = db.Column(db.String(50), nullable=False)

class RawData(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    source_id = db.Column(db.Integer, db.ForeignKey('data_source.id'), nullable=False)
    timestamp = db.Column(db.DateTime, nullable=False)
    content = db.Column(db.Text, nullable=False)
    data_quality = db.Column(db.Float)

    source = db.relationship('DataSource', backref=db.backref('raw_data', lazy=True))

class ProcessedData(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    raw_data_id = db.Column(db.Integer, db.ForeignKey('raw_data.id'), nullable=False)
    processed_content = db.Column(db.Text, nullable=False)
    processing_timestamp = db.Column(db.DateTime, nullable=False)

    raw_data = db.relationship('RawData', backref=db.backref('processed_data', lazy=True))

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

This file sets up the Flask application, configures SQLAlchemy and Flask-Migrate, and defines three models: DataSource, RawData, and ProcessedData.

Running the Example

To run this example:

1. Ensure you have Flask, Flask-SQLAlchemy, and Flask-Migrate installed:

   pip install Flask Flask-SQLAlchemy Flask-Migrate
   

2. Create app.py with the content provided above.

3. Initialize the migration repository:

   flask db init
   

4. Create the initial migration:

   flask db migrate -m "Initial migration"
   

5. Apply the migration:

   flask db upgrade
   

6. To add a new field (e.g., data_quality to RawData), update the model in app.py, then:

   flask db migrate -m "Add data quality field"
   flask db upgrade
   

7. To add a new model (e.g., ProcessedData), add the model to app.py, then:

   flask db migrate -m "Add ProcessedData model"
   flask db upgrade
   

8. To interact with your models, use the Flask shell:

   flask shell
   
   # In the shell:
   from app import db, DataSource, RawData, ProcessedData
   from datetime import datetime
   
   # Create a DataSource
   source = DataSource(name="Example Source", url="https://example.com", type="API")
   db.session.add(source)
   db.session.commit()
   
   # Create a RawData instance
   raw_data = RawData(source=source, timestamp=datetime.now(), content="Sample raw data", data_quality=0.95)
   db.session.add(raw_data)
   db.session.commit()
   
   # Create a ProcessedData instance
   processed_data = ProcessedData(raw_data=raw_data, processed_content="Processed: Sample raw data", processing_timestamp=datetime.now())
   db.session.add(processed_data)
   db.session.commit()
   
   # Query the data
   print(DataSource.query.all())
   print(RawData.query.all())
   print(ProcessedData.query.all())
   

This example showcases how Flask-Migrate integrates Alembic with Flask applications, providing a seamless way to manage database migrations. It allows for version control of your database structure and smooth collaboration in team environments, while leveraging the simplicity of Flask and the power of SQLAlchemy.