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.
—
Pending
Quality
Pending
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
core-framework.mddocs/
Core Framework
Foundation classes and application management providing the central coordination for Flask-AppBuilder applications. These components handle application initialization, view registration, security setup, menu management, and the complete application lifecycle.
Capabilities
AppBuilder Class
The central framework class that coordinates all Flask-AppBuilder components, manages the application lifecycle, and provides the primary interface for registering views, APIs, and other application components.
from flask_appbuilder import AppBuilder
class AppBuilder:
def __init__(self, app=None, session=None, menu=None, indexview=None,
base_template="appbuilder/baselayout.html", static_folder="static/appbuilder",
static_url_path="/appbuilder", security_manager_class=None, update_perms=True):
"""
Initialize AppBuilder instance.
Parameters:
- app: Flask application instance
- session: SQLAlchemy session
- menu: Menu instance for navigation
- indexview: Default index view class
- base_template: Base template path
- static_folder: Static files folder
- static_url_path: URL path for static files
- security_manager_class: Custom security manager class
- update_perms: Auto-update permissions flag
"""
def init_app(self, app, session):
"""
Initialize Flask application with AppBuilder (application factory pattern).
Parameters:
- app: Flask application instance
- session: SQLAlchemy session
"""
def add_view(self, baseview, name, href="", icon="", label="", category="",
category_icon="", category_label="", menu_cond=None):
"""
Add view to application with menu entry.
Parameters:
- baseview: View class to register
- name: Menu item name
- href: URL href (auto-generated if empty)
- icon: Font Awesome icon class
- label: Display label (defaults to name)
- category: Menu category
- category_icon: Category icon class
- category_label: Category display label
- menu_cond: Callable for conditional menu display
"""
def add_view_no_menu(self, baseview, endpoint=None, static_folder=None):
"""
Add view without menu entry.
Parameters:
- baseview: View class to register
- endpoint: Custom endpoint name
- static_folder: Static files folder
"""
def add_api(self, baseview):
"""
Add API view to application.
Parameters:
- baseview: API view class to register
"""
def add_link(self, name, href, icon="", label="", category="",
category_icon="", category_label="", baseview=None, cond=None):
"""
Add menu link without associated view.
Parameters:
- name: Link name
- href: Link URL
- icon: Font Awesome icon class
- label: Display label
- category: Menu category
- category_icon: Category icon class
- category_label: Category display label
- baseview: Associated view for permissions
- cond: Callable for conditional display
"""
def add_separator(self, category="", cond=None):
"""
Add menu separator.
Parameters:
- category: Menu category
- cond: Callable for conditional display
"""
def security_cleanup(self):
"""Clean up unused permissions from database."""
def security_converge(self, dry=True):
"""
Migrate permissions to new names.
Parameters:
- dry: Dry run flag (no actual changes)
Returns:
Dict with migration information
"""
def add_permissions(self, update_perms=True):
"""
Add permissions for all registered views.
Parameters:
- update_perms: Update existing permissions flag
"""
def register_blueprint(self, baseview, endpoint=None, static_folder=None):
"""
Register view blueprint with Flask application.
Parameters:
- baseview: View instance
- endpoint: Blueprint endpoint
- static_folder: Static files folder
Returns:
Blueprint instance
"""
# Properties
app = None # Current Flask application
sm = None # Security Manager instance
bm = None # Babel Manager instance
openapi_manager = None # OpenAPI Manager instance
menuapi_manager = None # Menu API Manager instance
menu = None # Menu instance
baseviews = [] # List of registered views
addon_managers = {} # Dict of addon managers
# Dynamic properties
get_app = property(...) # Current Flask app
get_session = property(...) # Current SQLAlchemy session
app_name = property(...) # Application name from config
app_theme = property(...) # Application theme
app_icon = property(...) # Application icon
languages = property(...) # Supported languages dict
version = property(...) # Flask-AppBuilder versionBaseView Class
Foundation class for all views providing routing, templating, security integration, and basic view functionality that other view classes extend.
from flask_appbuilder.baseviews import BaseView, expose
class BaseView:
def __init__(self):
"""Initialize base view with permissions and properties."""
def create_blueprint(self, appbuilder, endpoint=None, static_folder=None):
"""
Create Flask blueprint for this view.
Parameters:
- appbuilder: AppBuilder instance
- endpoint: Custom endpoint name
- static_folder: Static files folder
Returns:
Flask Blueprint instance
"""
def render_template(self, template, **kwargs):
"""
Render Jinja2 template with context.
Parameters:
- template: Template path
- **kwargs: Template context variables
Returns:
Rendered template string
"""
def update_redirect(self):
"""Update navigation history for redirect functionality."""
def get_redirect(self):
"""
Get previous URL from navigation history.
Returns:
Previous URL string or None
"""
def get_method_permission(self, method_name):
"""
Get permission name for view method.
Parameters:
- method_name: Method name
Returns:
Permission name string
"""
# Class properties
route_base = "" # Base URL route
template_folder = "templates" # Template folder location
static_folder = None # Static files folder
base_permissions = [] # List of allowed permissions
class_permission_name = "" # Override class permission name
method_permission_name = {} # Override method permission names
exclude_route_methods = set() # Methods to exclude from routing
include_route_methods = set() # Methods to include in routing (whitelist)
default_view = "" # Default view method name
extra_args = {} # Extra template arguments
limits = [] # Rate limiting configurationView Decorators
Decorators for exposing view methods as routes and controlling access to view functionality.
from flask_appbuilder.baseviews import expose
from flask_appbuilder.security.decorators import has_access, permission_name
@expose(url="/", methods=["GET"])
def expose(url="/", methods=("GET",)):
"""
Expose view method as Flask route.
Parameters:
- url: URL pattern for route
- methods: HTTP methods list
Usage:
@expose('/custom-endpoint/')
@has_access
def my_view(self):
return self.render_template('my_template.html')
"""
@has_access
def has_access(f):
"""
Enable granular security permissions for view methods.
Redirects to login page on access denied.
Usage:
@expose('/admin-only/')
@has_access
def admin_method(self):
return "Admin only content"
"""
@permission_name("custom_permission")
def permission_name(name):
"""
Override permission name for a view method.
Parameters:
- name: Custom permission name
Usage:
@expose('/special/')
@has_access
@permission_name("can_access_special")
def special_method(self):
return "Special access required"
"""BaseFormView Class
Foundation for form-based views providing form processing, validation, and rendering capabilities.
from flask_appbuilder.baseviews import BaseFormView
class BaseFormView(BaseView):
def form_get(self, form):
"""
Override for custom form GET processing.
Parameters:
- form: WTForms form instance
"""
def form_post(self, form):
"""
Override for custom form POST processing.
Parameters:
- form: WTForms form instance with submitted data
Returns:
Response or None to use default processing
"""
# Form properties
form_template = "appbuilder/general/model/edit.html" # Form template path
edit_widget = None # Form widget class
form_title = "" # Form title
form_columns = [] # Form columns to include
form = None # WTForms form instance
form_fieldsets = [] # Form field groupingsBaseModelView Class
Foundation for model-based views providing data model integration, searching, filtering, and basic model operations.
from flask_appbuilder.baseviews import BaseModelView
from flask_appbuilder.models.sqla.interface import SQLAInterface
class BaseModelView(BaseView):
def _init_properties(self):
"""Initialize view properties from datamodel."""
def _init_forms(self):
"""Initialize search and other forms."""
def _init_titles(self):
"""Initialize view titles."""
def _get_search_widget(self, form, exclude_cols=[], widgets={}):
"""
Get search widget for the view.
Parameters:
- form: Search form instance
- exclude_cols: Columns to exclude from search
- widgets: Custom widget overrides
Returns:
SearchWidget instance
"""
# Model properties
datamodel = None # SQLAlchemy interface instance
title = "" # View title
search_columns = [] # Searchable columns
search_exclude_columns = [] # Columns to exclude from search
search_form_extra_fields = {} # Extra search form fields
search_form_query_rel_fields = {} # Related field queries for search
label_columns = {} # Column label overrides
search_form = None # Search form instance
base_filters = [] # Base query filters
base_order = [] # Default ordering
search_widget = None # Search widget class
# Usage example
class MyModelView(BaseModelView):
datamodel = SQLAInterface(MyModel)
search_columns = ['name', 'email']
label_columns = {'name': 'Full Name'}
base_filters = [['active', FilterEqual, True]]Install with Tessl CLI
npx tessl i tessl/pypi-flask-appbuilder