or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

actions-hooks.mdcharts.mdcli-tools.mdconstants-exceptions.mdcore-framework.mddatabase-models.mdforms-fields.mdindex.mdrest-api.mdsecurity.mdviews-crud.md
tile.json

tessl/pypi-flask-appbuilder

Simple and rapid application development framework, built on top of Flask, with detailed security, auto CRUD generation, and comprehensive UI components.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/flask-appbuilder@4.8.x

To install, run

npx @tessl/cli install tessl/pypi-flask-appbuilder@4.8.0

index.mddocs/

Flask-AppBuilder

A rapid application development framework built on top of Flask that provides a comprehensive set of tools for building database-driven web applications with authentication, authorization, forms, charts, and REST APIs. Flask-AppBuilder enables developers to quickly create sophisticated web applications with minimal code by providing pre-built components for common web application patterns.

Package Information

  • Package Name: flask-appbuilder
  • Version: 4.8.1
  • Language: Python
  • Installation: pip install Flask-AppBuilder
  • Dependencies: Flask, SQLAlchemy, WTForms, Marshmallow, PyJWT

Core Imports

from flask_appbuilder import AppBuilder

Common imports for building applications:

from flask_appbuilder import (
    AppBuilder, BaseView, ModelView, IndexView,
    Model, SQLA, expose, has_access, action
)

API-focused imports:

from flask_appbuilder.api import ModelRestApi, expose as api_expose
from flask_appbuilder.security.decorators import protect

Basic Usage

Simple Application Setup

from flask import Flask
from flask_appbuilder import AppBuilder, SQLA
from flask_appbuilder.models.sqla import Model
from sqlalchemy import Column, Integer, String

# Initialize Flask app and database
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'

db = SQLA(app)

# Create a simple model
class Person(Model):
    id = Column(Integer, primary_key=True)
    name = Column(String(150), unique=True, nullable=False)
    email = Column(String(120), unique=True, nullable=False)
    
    def __repr__(self):
        return self.name

# Initialize AppBuilder
appbuilder = AppBuilder(app, db.session)

# Create database tables
db.create_all()

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

Adding CRUD Views

from flask_appbuilder import ModelView
from flask_appbuilder.models.sqla.interface import SQLAInterface

class PersonModelView(ModelView):
    datamodel = SQLAInterface(Person)
    list_columns = ['name', 'email']

# Register view with AppBuilder
appbuilder.add_view(
    PersonModelView,
    "List Persons",
    icon="fa-address-book-o",
    category="Contacts",
)

Creating REST APIs

from flask_appbuilder.api import ModelRestApi

class PersonApi(ModelRestApi):
    datamodel = SQLAInterface(Person)
    list_columns = ['id', 'name', 'email']
    show_columns = ['id', 'name', 'email']
    add_columns = ['name', 'email']
    edit_columns = ['name', 'email']

# Register API
appbuilder.add_api(PersonApi)

Architecture

Flask-AppBuilder follows a layered architecture that promotes separation of concerns and extensibility:

Core Layer

  • AppBuilder: Central application manager that coordinates all components
  • BaseView: Foundation for all views providing routing, templating, and security integration
  • Security Manager: Handles authentication, authorization, and user management

Data Layer

  • Model: SQLAlchemy base model with Flask-AppBuilder enhancements
  • SQLA: Enhanced SQLAlchemy integration with application factory support
  • DataModel Interface: Abstraction layer for different data backends

View Layer

  • ModelView: CRUD operations with automatic form generation and validation
  • BaseFormView: Form handling with validation and processing
  • Chart Views: Data visualization with multiple chart types

API Layer

  • ModelRestApi: Full REST API with OpenAPI documentation
  • BaseApi: Foundation for custom API endpoints with security integration
  • Schema Conversion: Automatic Marshmallow schema generation from models

Security Layer

  • Authentication: Multiple authentication backends (DB, LDAP, OAuth, OpenID)
  • Authorization: Role-based permissions with fine-grained access control
  • Decorators: Security enforcement for views and API endpoints

This architecture enables rapid development while maintaining flexibility for customization and extension.

Capabilities

Core Framework

Foundation classes and application management including AppBuilder initialization, view registration, security setup, and application lifecycle management.

class AppBuilder:
    def __init__(app, session, menu=None, indexview=None): ...
    def add_view(baseview, name, href="", icon="", label="", category=""): ...
    def add_api(baseview): ...
    def init_app(app, session): ...

class BaseView:
    def render_template(template, **kwargs): ...
    def create_blueprint(appbuilder, endpoint=None, static_folder=None): ...

Core Framework

Security System

Authentication, authorization, and security decorators providing user management, role-based permissions, and access control for views and APIs.

@has_access
def secure_method(self): ...

@protect(allow_browser_login=False) 
def api_method(self): ...

@permission_name("custom_permission")
def method_with_custom_permission(self): ...

Security System

REST API System

Complete REST API framework with automatic CRUD operations, OpenAPI documentation, schema generation, and JSON serialization.

class ModelRestApi(BaseModelApi):
    def get_list(**kwargs): ...
    def get(pk, **kwargs): ...  
    def post(): ...
    def put(pk): ...
    def delete(pk): ...
    def info(**kwargs): ...

REST API System

Database Models and Interfaces

SQLAlchemy integration with enhanced models, database interfaces, and application factory support for flexible database management.

class Model:
    def to_json(): ...
    
class SQLA(SQLAlchemy):
    def create_session(options): ...
    def make_declarative_base(model, metadata): ...

Database Models

Views and CRUD Operations

Model views with automatic CRUD operations, form generation, validation, pagination, searching, and filtering capabilities.

class ModelView(BaseCRUDView):
    datamodel = SQLAInterface(Model)
    list_columns = ['field1', 'field2']
    show_columns = ['field1', 'field2', 'field3'] 
    add_columns = ['field1', 'field2']
    edit_columns = ['field1', 'field2']

Views and CRUD

Forms and Field Widgets

Custom form fields, widgets, and form handling including AJAX select fields, query fields, and specialized input widgets.

class AJAXSelectField(Field): ...
class QuerySelectField(SelectFieldBase): ...
class FormWidget(RenderTemplateWidget): ...

Forms and Fields

Charts and Visualizations

Data visualization with chart views supporting pie charts, bar charts, line charts, and custom aggregation functions.

class GroupByChartView(BaseChartView):
    chart_type = "ColumnChart"
    group_bys = ['field']
    
@aggregate(label="Total")
def aggregate_sum(items, col): ...

Charts and Visualizations

CLI Tools and Commands

Command-line interface for user management, database operations, security management, and application maintenance.

# Flask CLI commands
flask fab create-admin
flask fab create-user  
flask fab reset-password
flask fab create-db
flask fab list-users

CLI Tools

Actions and Lifecycle Hooks

Action decorators for bulk operations and lifecycle hooks for customizing create, update, and delete operations.

@action("approve", "Approve", "Approve selected items?", "fa-check")
def approve_action(self, items): ...

def pre_add(self, item): ...
def post_update(self, item): ...

Actions and Hooks

Constants and Exception Handling

Framework constants, authentication types, API configuration, and comprehensive exception classes for error handling.

# Authentication constants
AUTH_DB = 1
AUTH_LDAP = 2  
AUTH_OAUTH = 4

# Exception classes
class FABException(Exception): ...
class InvalidLoginAttempt(FABException): ...

Constants and Exceptions