flask.ext.admin.contrib.sqla

SQLAlchemy model backend implementation.

class ModelView(model, session, name=None, category=None, endpoint=None, url=None)

SQLAlchemy model view

Usage sample:

admin = Admin()
admin.add_view(ModelView(User, db.session))

Class inherits configuration options from BaseModelView and they’re not displayed here.

column_auto_select_related

Enable automatic detection of displayed foreign keys in this view and perform automatic joined loading for related models to improve query performance.

Please note that detection is not recursive: if __unicode__ method of related model uses another model to generate string representation, it will still make separate database call.

column_select_related_list

List of parameters for SQLAlchemy subqueryload. Overrides column_auto_select_related property.

For example:

class PostAdmin(ModelView):
    column_select_related_list = ('user', 'city')

You can also use properties:

class PostAdmin(ModelView):
    column_select_related_list = (Post.user, Post.city)

Please refer to the subqueryload on list of possible values.

column_searchable_list

Collection of the searchable columns. Only text-based columns are searchable (String, Unicode, Text, UnicodeText).

Example:

class MyModelView(ModelView):
    column_searchable_list = ('name', 'email')

You can also pass columns:

class MyModelView(ModelView):
    column_searchable_list = (User.name, User.email)

The following search rules apply:

• If you enter ZZZ in the UI search field, it will generate ILIKE ‘%ZZZ%’ statement against searchable columns.
• If you enter multiple words, each word will be searched separately, but only rows that contain all words will be displayed. For example, searching for ‘abc def’ will find all rows that contain ‘abc’ and ‘def’ in one or more columns.
• If you prefix your search term with ^, it will find all rows that start with ^. So, if you entered ^ZZZ, ILIKE ‘ZZZ%’ will be used.
• If you prefix your search term with =, it will perform an exact match. For example, if you entered =ZZZ, the statement ILIKE ‘ZZZ’ will be used.

column_filters = None

Collection of the column filters.

Can contain either field names or instances of flask.ext.admin.contrib.sqla.filters.BaseFilter classes.

For example:

class MyModelView(BaseModelView):
    column_filters = ('user', 'email')

or:

class MyModelView(BaseModelView):
    column_filters = (BooleanEqualFilter(User.name, 'Name'))

filter_converter = <flask_admin.contrib.sqla.filters.FilterConverter object at 0x7f875e21a410>

Field to filter converter.

Override this attribute to use non-default converter.

model_form_converter = <class 'flask_admin.contrib.sqla.form.AdminModelConverter'>

Model form conversion class. Use this to implement custom field conversion logic.

For example:

class MyModelConverter(AdminModelConverter):
    pass


class MyAdminView(ModelView):
    model_form_converter = MyModelConverter

inline_model_form_converter = <class 'flask_admin.contrib.sqla.form.InlineModelConverter'>

Inline model conversion class. If you need some kind of post-processing for inline forms, you can customize behavior by doing something like this:

class MyInlineModelConverter(AdminModelConverter):
    def post_process(self, form_class, info):
        form_class.value = wtf.TextField('value')
        return form_class

class MyAdminView(ModelView):
    inline_model_form_converter = MyInlineModelConverter

fast_mass_delete = False

If set to False and user deletes more than one model using built in action, all models will be read from the database and then deleted one by one giving SQLAlchemy a chance to manually cleanup any dependencies (many-to-many relationships, etc).

If set to True, will run a DELETE statement which is somewhat faster, but may leave corrupted data if you forget to configure DELETE CASCADE for your model.

inline_models = None

Inline related-model editing for models with parent-child relations.

Accepts enumerable with one of the following possible values:

1. Child model class:

   class MyModelView(ModelView):
       inline_models = (Post,)
   

2. Child model class and additional options:

   class MyModelView(ModelView):
       inline_models = [(Post, dict(form_columns=['title']))]
   

3. Django-like InlineFormAdmin class instance:

   class MyInlineModelForm(InlineFormAdmin):
       form_columns = ('title', 'date')
   
   class MyModelView(ModelView):
       inline_models = (MyInlineModelForm(MyInlineModel),)
   

You can customize the generated field name by:

1. Using the form_name property as a key to the options dictionary:

   class MyModelView(ModelView):

   inline_models = ((Post, dict(form_label=’Hello’)))

2. Using forward relation name and column_labels property:

   class Model1(Base):

   pass

   class Model2(Base):

   # ... model1 = relation(Model1, backref=’models’)

   class MyModel1View(Base):

   inline_models = (Model2,) column_labels = {‘models’: ‘Hello’}

form_choices = None

Map choices to form fields

Example:

class MyModelView(BaseModelView):
    form_choices = {'my_form_field': [
        ('db_value', 'display_value'),
    ]

form_optional_types = (<class 'sqlalchemy.sql.sqltypes.Boolean'>,)

List of field types that should be optional if column is not nullable.

Example:

class MyModelView(BaseModelView):
    form_optional_types = (Boolean, Unicode)

action_view(*args, **kwargs)

Mass-model action view.

after_model_change(form, model, is_created)

Perform some actions after a model was created or updated and committed to the database.

Called from create_model after successful database commit.

By default does nothing.

Parameters:

• form – Form used to create/update model
• model – Model that was created/updated
• is_created – True if model was created, False if model was updated

column_display_all_relations

Controls if list view should display all relations, not only many-to-one.

create_blueprint(admin)

Create Flask blueprint.

create_form(obj=None)

Instantiate model creation form and return it.

Override to implement custom behavior.

create_model(form)

Create model from form.

Parameters:form – Form instance

create_view(*args, **kwargs)

Create model view

delete_model(model)

Delete model.

Parameters:model – Model to delete

delete_view(*args, **kwargs)

Delete model view. Only POST method is allowed.

edit_form(obj=None)

Instantiate model editing form and return it.

Override to implement custom behavior.

edit_view(*args, **kwargs)

Edit model view

get_actions_list()

Return a list and a dictionary of allowed actions.

get_column_name(field)

Return a human-readable column name.

Parameters:field – Model field name.

get_count_query()

Return a the count query for the model type

get_create_form()

Create form class for model creation view.

Override to implement customized behavior.

get_edit_form()

Create form class for model editing view.

Override to implement customized behavior.

get_filter_arg(index, flt)

Given a filter flt, return a unique name for that filter in this view.

Does not include the flt[n]_ portion of the filter name.

Parameters:

• index – Filter index in _filters array
• flt – Filter instance

get_filters()

Return a list of filter objects.

If your model backend implementation does not support filters, override this method and return None.

get_form()

Get form class.

If self.form is set, will return it and will call self.scaffold_form otherwise.

Override to implement customized behavior.

get_list(page, sort_column, sort_desc, search, filters, execute=True)

Return models from the database.

Parameters:

• page – Page number
• sort_column – Sort column name
• sort_desc – Descending or ascending sort
• search – Search query
• execute – Execute query immediately? Default is True
• filters – List of filter tuples

get_list_columns()

Returns a list of the model field names. If column_list was set, returns it. Otherwise calls scaffold_list_columns to generate the list from the model.

get_list_value(context, model, name)

Returns the value to be displayed in the list view

Parameters:

• context – jinja2.runtime.Context
• model – Model instance
• name – Field name

get_one(id)

Return a single model by its id.

Parameters:id – Model id

get_pk_value(model)

Return the PK value from a model object. PK can be a single value or a tuple if multiple PKs exist

get_query()

Return a query for the model type.

If you override this method, don’t forget to override get_count_query as well.

get_sortable_columns()

Returns a dictionary of the sortable columns. Key is a model field name and value is sort column (for example - attribute).

If column_sortable_list is set, will use it. Otherwise, will call scaffold_sortable_columns to get them from the model.

handle_action(return_view=None)

Handle action request.

Parameters:return_view – Name of the view to return to after the request. If not provided, will return user to the index view.

index_view(*args, **kwargs)

List view

init_actions()

Initialize list of actions for the current administrative view.

init_search()

Initialize search. Returns True if search is supported for this view.

For SQLAlchemy, this will initialize internal fields: list of column objects used for filtering, etc.

is_accessible()

Override this method to add permission checks.

Flask-Admin does not make any assumptions about the authentication system used in your application, so it is up to you to implement it.

By default, it will allow access for everyone.

is_sortable(name)

Verify if column is sortable.

Parameters:name – Column name.

is_text_column_type(name)

Verify if the provided column type is text-based.

Returns:True for String, Unicode, Text, UnicodeText

is_valid_filter(filter)

Verify that the provided filter object is derived from the SQLAlchemy-compatible filter class.

Parameters:filter – Filter object to verify.

is_visible()

Override this method if you want dynamically hide or show administrative views from Flask-Admin menu structure

By default, item is visible in menu.

Please note that item should be both visible and accessible to be displayed in menu.

on_model_change(form, model, is_created)

Perform some actions after a model is created or updated.

Called from create_model and update_model in the same transaction (if it has any meaning for a store backend).

By default does nothing.

Parameters:

• form – Form used to create/update model
• model – Model that will be created/updated
• is_created – Will be set to True if model was created and to False if edited

on_model_delete(model)

Perform some actions before a model is deleted.

Called from delete_model in the same transaction (if it has any meaning for a store backend).

By default do nothing.

render(template, **kwargs)

Render template

Parameters:

• template – Template path to render
• kwargs – Template arguments

scaffold_auto_joins()

Return a list of joined tables by going through the displayed columns.

scaffold_filters(name)

Return list of enabled filters

scaffold_form()

Create form from the model.

scaffold_inline_form_models(form_class)

Contribute inline models to the form

Parameters:form_class – Form class

scaffold_list_columns()

Return a list of columns from the model.

scaffold_pk()

Return the primary key name from a model PK can be a single value or a tuple if multiple PKs exist

scaffold_sortable_columns()

Return a dictionary of sortable columns. Key is column name, value is sort column/field.

update_model(form, model)

Update model from form.

Parameters:

• form – Form instance
• model – Model instance