Flask-Admin

https://flask-admin.readthedocs.io
Admin
Flask-Admin is a library for Flask that provides a user-friendly administrative interface to manage...
Tokens:77,064
Snippets:624
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Flask-Admin with extras

Source: https://flask-admin.readthedocs.io/en/stable/introduction

Install the package along with specific optional features by listing them in brackets.

```bash
pip install flask-admin[sqlalchemy,s3,images,export,translation]
```

--------------------------------

### Initialize FileAdmin

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_contrib_fileadmin

Basic setup for adding a FileAdmin view to a Flask-Admin instance.

```python
import os.path as op

from flask_admin import Admin
from flask_admin.contrib.fileadmin import FileAdmin

admin = Admin()

path = op.join(op.dirname(__file__), 'static')
admin.add_view(FileAdmin(path, '/static/', name='Static Files'))
```

--------------------------------

### Example return format for scaffold_list_columns

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_contrib_peewee

Shows the expected list of strings representing model field names.

```python
['name', 'first_name', 'last_name']
```

--------------------------------

### Initialize ModelView

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Basic usage example for adding a SQLAlchemy model to the Flask-Admin interface.

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

--------------------------------

### Define ModelView Search Placeholder

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Example of configuring column_labels and column_searchable_list to generate a search placeholder string.

```python
class MyModelView(BaseModelView):
    column_labels = dict(name='Name', last_name='Last Name')
    column_searchable_list = ('name', 'last_name')
```

--------------------------------

### Define a Custom ModelView

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_contrib_sqla

Example of subclassing BaseModelView to define column labels and searchable fields.

```python
class MyModelView(BaseModelView):
    
column_labels = dict(name=’Name’, last_name=’Last Name’) column_searchable_list = (‘name’, ‘last_name’)
```

--------------------------------

### Configure column_searchable_list

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Examples of defining searchable columns using strings or SQLAlchemy model attributes.

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

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

--------------------------------

### Image Upload Initialization

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/form/upload

Initializes the image upload field, checking for PIL installation and setting default image processing parameters.

```python
# Check if PIL is installed
        if Image is None:
            raise Exception(
                "Could not import `PIL`. "
                "Enable `images` integration by installing `flask-admin[images]`"
            )

        self.max_size = max_size
        self.thumbnail_fn = thumbgen or thumbgen_filename
        self.thumbnail_size = thumbnail_size
        self.endpoint = endpoint
        self.image: T_PIL_IMAGE | None = None
        self.url_relative_path = url_relative_path

        if not allowed_extensions:
            allowed_extensions = ("gif", "jpg", "jpeg", "png", "tiff")

        super().__init__(
            label,
            validators,
            base_path=base_path,
            relative_path=relative_path,
            namegen=namegen,
            allowed_extensions=allowed_extensions,
            permission=permission,
            **kwargs,
        )
```

--------------------------------

### expose(url='/', methods=('GET',))

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Decorator to expose methods within a BaseView class as accessible views.

```APIDOC
## expose(url='/', methods=('GET',))

### Description
Use this decorator to expose views in your view classes.

### Parameters
- **url** (str) - Optional - Relative URL for the view. Defaults to '/'.
- **methods** (Iterable[str]) - Optional - Allowed HTTP methods. Defaults to ('GET',).
```

--------------------------------

### Configure column_select_related_list

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Examples of specifying related models for subquery loading to optimize database queries.

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

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

--------------------------------

### Configure Inline Models in Peewee ModelView

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/peewee/view

Examples of how to define inline models using child model classes, options, or InlineFormAdmin instances.

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

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

```python
from flask_admin.model.form import InlineFormAdmin

class MyInlineModelForm(InlineFormAdmin):
    form_columns = ('title', 'date')

class MyModelView(ModelView):
    inline_models = (MyInlineModelForm(MyInlineModel),)
```

--------------------------------

### Instantiate Delete Form

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Handles delete form instantiation, supporting both GET and POST requests for backward compatibility.

```python
def delete_form(self) -> BaseForm:
    """
    Instantiate model delete form and return it.

    Override to implement custom behavior.

    The delete form originally used a GET request, so delete_form
    accepts both GET and POST request for backwards compatibility.
    """
    if request.form:
        return self._delete_form_class(request.form)
    elif request.args:
        # allow request.args for backward compatibility
        return self._delete_form_class(request.args)
    else:
        return self._delete_form_class()
```

--------------------------------

### Define MongoEngine ModelView Column Filters

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/mongoengine/view

Examples of configuring column filters using field names, filter instances, or custom filter classes.

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

```python
from flask_admin.contrib.mongoengine.filters import BooleanEqualFilter

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

```python
from flask_admin.contrib.mongoengine.filters import BaseMongoEngineFilter

class FilterLastNameBrown(BaseMongoEngineFilter):
    def apply(self, query, value):
        if value == '1':
            return query.filter(self.column == "Brown")
        else:
            return query.filter(self.column != "Brown")

    def operation(self):
        return 'is Brown'

class MyModelView(BaseModelView):
    column_filters = [
        FilterLastNameBrown(
            column=User.last_name, name='Last Name',
            options=(('1', 'Yes'), ('0', 'No'))
        )
    ]
```

--------------------------------

### Configuring column_filters in ModelView

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/peewee/view

Examples of defining column filters using field names, specific filter classes, or custom filter implementations.

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

```python
from flask_admin.contrib.peewee.filters import BooleanEqualFilter

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

```python
from flask_admin.contrib.peewee.filters import BasePeeweeFilter

class FilterLastNameBrown(BasePeeweeFilter):
    def apply(self, query, value):
        if value == '1':
            return query.filter(self.column == "Brown")
        else:
            return query.filter(self.column != "Brown")

    def operation(self):
        return 'is Brown'

class MyModelView(BaseModelView):
    column_filters = [
        FilterLastNameBrown(
            column=User.last_name, name='Last Name',
            options=(('1', 'Yes'), ('0', 'No'))
        )
    ]
```

--------------------------------

### Get Save Return URL

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Determines the redirection URL after a successful form save, with an example of overriding to redirect to a details view.

```python
def get_save_return_url(self, model: T_ORM_MODEL, is_created: bool = False) -> str:
    """
    Return url where user is redirected after successful form save.

    :param model:
        Saved object
    :param is_created:
        Whether new object was created or existing one was updated

    For example, redirect use to object details view after form save::

        class MyModelView(ModelView):
            can_view_details = True

            def get_save_return_url(self, model, is_created):
                return self.get_url('.details_view', id=model.id)

    """
    return get_redirect_target() or self.get_url(".index_view")
```

--------------------------------

### ActionsMixin.init_actions()

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/actions

Initializes the list of actions for the current administrative view by scanning for decorated methods.

```APIDOC
## ActionsMixin.init_actions()

### Description
Initialize list of actions for the current administrative view. This should be called in the class constructor.
```

--------------------------------

### Admin.__init__

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Initializes the Admin collection of views and manages the menu structure.

```APIDOC
## Admin.__init__

### Description
Constructor for the Admin class. Initializes the collection of admin views and manages the menu structure.

### Parameters
- **app** (Flask | None) - Optional - Flask application object
- **name** (str | None) - Optional - Application name displayed in the main menu and page title
- **url** (str | None) - Optional - Base URL
- **subdomain** (str | None) - Optional - Subdomain to use
- **index_view** (AdminIndexView | None) - Optional - Home page view to use
- **translations_path** (str | None) - Optional - Location of translation message catalogs
- **endpoint** (str | None) - Optional - Base endpoint name for index view
- **static_url_path** (str | None) - Optional - Static URL path
- **theme** (Theme | None) - Optional - Base theme
- **category_icon_classes** (dict[str, str] | None) - Optional - Dict of category names and html classes for icons
- **host** (str | None) - Optional - Host to register views on
- **csp_nonce_generator** (Callable[[], Any] | None) - Optional - Callable returning a nonce for JS/CSS
```

--------------------------------

### File Renaming View

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Handles GET and POST requests for renaming files, initializing the form with the current filename on GET requests.

```python
    @expose("/rename/", methods=("GET", "POST"))
    def rename(self) -> T_RESPONSE | str:
        """
        Rename view method
        """
        form = self.name_form()

        path = form.path.data  # type: ignore[attr-defined]

        if request.method == "GET" and hasattr(form, "name"):
            form.name.data = op.basename(path)

        if path:
            base_path, full_path, path = self._normalize_path(path)

            return_url = self._get_dir_url(".index_view", op.dirname(path))
        else:
            return redirect(self.get_url(".index_view"))
```

--------------------------------

### Create Directory View Method

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Handles directory creation requests, validating permissions and path accessibility.

```python
    @expose("/mkdir/", methods=("GET", "POST"))
    @expose("/mkdir/<path:path>", methods=("GET", "POST"))
    def mkdir(self, path: str | None = None) -> T_RESPONSE | str:
        """
        Directory creation view method

        :param path:
            Optional directory path. If not provided, will use the base directory
        """
        # Get path and verify if it is valid
        base_path, directory, path = self._normalize_path(path)

        dir_url = self._get_dir_url(".index_view", path)

        if not self.can_mkdir:
            flash(gettext("Directory creation is disabled."), "error")
            return redirect(dir_url)

        if not self.is_accessible_path(path):
            flash(gettext("Permission denied."), "error")
            return redirect(self._get_dir_url(".index_view"))

        form = self.name_form()
```

--------------------------------

### Get List of Objects

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/mongoengine/view

Retrieves a paginated, filtered, and sorted list of objects from MongoEngine.

```python
    def get_list(  # type: ignore[override]
        self,
        page: int | None,
        sort_column: str,
        sort_desc: bool,
        search: str | None,
        filters: t.Sequence[tuple[int, str, str]] | None,
        execute: bool = True,
        page_size: int | None = None,
    ) -> tuple[int | None, Document]:
        """
        Get list of objects from MongoEngine

        :param page:
            Page number
        :param sort_column:
            Sort column
        :param sort_desc:
            Sort descending
        :param search:
            Search criteria
        :param filters:
            List of applied filters
        :param execute:
            Run query immediately or not
        :param page_size:
            Number of results. Defaults to ModelView's page_size. Can be
            overriden to change the page_size limit. Removing the page_size
            limit requires setting page_size to 0 or False.
        """
        query = self.get_query()

        # Filters
        if self._filters:
            for flt, _flt_name, value in filters:  # type: ignore[union-attr]
                f = self._filters[flt]
                query = f.apply(query, f.clean(value))

        # Search
        if self._search_supported and search:
            query = self._search(query, search)

        # Get count
        count = query.count() if not self.simple_list_pager else None

        # Sorting
        if sort_column:
            sort_op = "-" if sort_desc else ""
            query = query.order_by(f"{sort_op}{sort_column}")
        else:
            order = self._get_default_order()

            if order:
                keys = [f"{'-' if desc else ''}{col}" for col, desc in order]
                query = query.order_by(*keys)

        # Pagination
        if page_size is None:
            page_size = self.page_size

        if page_size:
            query = query.limit(page_size)

        if page and page_size:
            query = query.skip(page * page_size)

        if execute:
            query = query.all()

        return count, query
```

--------------------------------

### BaseView.__init__

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Constructor for the BaseView class to initialize administrative view settings.

```APIDOC
## BaseView(name=None, category=None, endpoint=None, url=None, static_folder=None, static_url_path=None, menu_class_name=None, menu_icon_type=None, menu_icon_value=None)

### Description
Base administrative view constructor. Derive from this class to implement your administrative interface piece.

### Parameters
- **name** (str) - Optional - Name of this view.
- **category** (str) - Optional - View category for menu grouping.
- **endpoint** (str) - Optional - Base endpoint name for the view.
- **url** (str) - Optional - Base URL for the view.
- **static_url_path** (str) - Optional - Path to the static url directory.
- **menu_icon_type** (str) - Optional - Icon type (e.g., ICON_TYPE_GLYPH, ICON_TYPE_FONT_AWESOME).
- **menu_icon_value** (str) - Optional - Icon glyph name or URL.
```

--------------------------------

### Get Breadcrumbs

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Generates a list of tuples representing the directory tree structure for breadcrumb navigation.

```python
def _get_breadcrumbs(self, path: str) -> list[tuple[str, str]]:
    """
    Returns a list of tuples with each tuple containing the folder and
    the tree up to that folder when traversing down the `path`
    """
    accumulator = []
    breadcrumbs = []

    for n in path.split(self._separator):
        accumulator.append(n)
        breadcrumbs.append((n, self._separator.join(accumulator)))
    return breadcrumbs
```

--------------------------------

### Initialize Bootstrap4Theme

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_theme

Configure a Bootstrap4Theme instance and apply it to the Admin object during initialization.

```python
t = Bootstrap4Theme(
    base_template='my_base.html', # relative your templates folder
    swatch='cerulean',
    fluid=True
)
admin = Admin(app, name='microblog', theme=t)
```

--------------------------------

### Get Primary Key Value

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/mongoengine/view

Extracts the primary key value from a given model instance.

```python
def get_pk_value(self, model):
    """
    Return the primary key value from the model instance

    :param model:
        Model instance
    """
    return model.pk
```

--------------------------------

### Initialize Flask-Admin

Source: https://flask-admin.readthedocs.io/en/stable/introduction

Create an empty admin interface for a Flask application with an optional theme.

```python
from flask import Flask
from flask_admin import Admin

app = Flask(__name__)

admin = Admin(app, name='microblog', theme=Bootstrap4Theme(swatch='cerulean'))
# Add administrative views here

app.run()
```

--------------------------------

### Configure Flask App for Host Matching

Source: https://flask-admin.readthedocs.io/en/stable/advanced

Set host and static_host parameters during Flask application initialization.

```python
from flask import Flask
app = Flask(__name__, host='my.domain.com', static_host='static.domain.com')
```

--------------------------------

### AdminIndexView Constructor

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Initializes the AdminIndexView with configuration for the administrative index page, including menu settings and URL routing.

```APIDOC
## AdminIndexView(name, category, endpoint, url, template, menu_class_name, menu_icon_type, menu_icon_value)

### Description
Constructor for the AdminIndexView class. This class defines the administrative interface index page, which defaults to the /admin/ URL.

### Parameters
- **name** (str) - Optional - Name of this view. Defaults to the class name.
- **category** (str) - Optional - View category. If provided, the view is placed in a submenu.
- **endpoint** (str) - Optional - Base endpoint name for the view. Defaults to the class name in lower case.
- **url** (str) - Optional - Base URL for the view. If it starts with '/', it is treated as an absolute path.
- **template** (str) - Optional - Template file to render. Defaults to 'admin/index.html'.
- **menu_class_name** (str) - Optional - CSS class name for the menu item.
- **menu_icon_type** (str) - Optional - Type of icon to display (e.g., ICON_TYPE_GLYPH, ICON_TYPE_FONT_AWESOME, ICON_TYPE_IMAGE, ICON_TYPE_IMAGE_URL).
- **menu_icon_value** (str) - Optional - Icon glyph name or URL corresponding to the icon type.
```

--------------------------------

### Retrieve List, Details, and Export Columns

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Methods to fetch column configurations for list, details, and export views, falling back to scaffolded columns if specific lists are not defined.

```python
    def get_list_columns(self) -> list[tuple[T_COLUMN, str]]:
        """
        Uses `get_column_names` to get a list of tuples with the model
        field name and formatted name for the columns in `column_list`
        and not in `column_exclude_list`. If `column_list` is not set,
        the columns from `scaffold_list_columns` will be used.
        """
        return self.get_column_names(
            only_columns=self.column_list or self.scaffold_list_columns(),
            excluded_columns=self.column_exclude_list,
        )
```

```python
    def get_details_columns(self) -> list[tuple[T_COLUMN, str]]:
        """
        Uses `get_column_names` to get a list of tuples with the model
        field name and formatted name for the columns in `column_details_list`
        and not in `column_details_exclude_list`. If `column_details_list`
        is not set, the columns from `scaffold_list_columns` will be used.
        """
        try:
            only_columns = self.column_details_list or self.scaffold_list_columns()
        except NotImplementedError as err:
            raise Exception("Please define column_details_list") from err

        return self.get_column_names(
            only_columns=only_columns,
            excluded_columns=self.column_details_exclude_list,
        )
```

```python
    def get_export_columns(self) -> list[tuple[T_COLUMN, str]]:
        """
        Uses `get_column_names` to get a list of tuples with the model
        field name and formatted name for the columns in `column_export_list`
        and not in `column_export_exclude_list`. If `column_export_list` is
        not set, it will attempt to use the columns from `column_list`
        or finally the columns from `scaffold_list_columns` will be used.
        """
        only_columns = (
            self.column_export_list or self.column_list or self.scaffold_list_columns()
        )

        return self.get_column_names(
            only_columns=only_columns,
            excluded_columns=self.column_export_exclude_list,
        )
```

--------------------------------

### Toggle Hidden Field Visibility

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Control whether fields starting with an underscore are ignored in the view.

```python
class MyModelView(BaseModelView):
    ignore_hidden = False
```

--------------------------------

### Add a view with a menu icon

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Configure menu icons by passing icon type and value parameters during view registration.

```python
admin.add_view(
    MyView(
        name='My View', menu_icon_type='glyph', menu_icon_value='glyphicon-home'
    )
)
```

--------------------------------

### Get and Format Field Identifier

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/fields

Retrieves the primary key from an InlineModelFormField and formats it as a string or tuple of strings.

```python
def get_field_id(field: InlineModelFormField) -> tuple[str, ...] | str:
    """
    get and format id from field
    :rtype: text_type
    """
    field_id = field.get_pk()
    if isinstance(field_id, tuple):
        return tuple(text_type(_) for _ in field_id)

    return text_type(field_id)
```

--------------------------------

### Configure AdminIndexView via Admin constructor

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Pass an instance of AdminIndexView to the Admin constructor to customize the root URL and template.

```python
admin = Admin(
    app,
    index_view=AdminIndexView(
        name='Home',
        template='admin/myhome.html',
        url='/'
    )
)
```

--------------------------------

### Enable Search, Filters, and Sorting

Source: https://flask-admin.readthedocs.io/en/stable/introduction

Configure searchable columns, filters, and sortable fields.

```python
column_searchable_list = ['name', 'email']
column_filters = ['country']
```

```python
column_sortable_list = ['name', 'email', 'country']
```

--------------------------------

### Custom Thumbnail Generation for ImageUploadField

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/form/upload

Example of defining a custom thumbnail filename generation function for ImageUploadField.

```python
import os.path as op

def thumb_name(filename):
    name, _ = op.splitext(filename)
    return secure_filename('%s-thumb.jpg' % name)

class MyForm(BaseForm):
    upload = ImageUploadField('File', thumbgen=thumb_name)
```

--------------------------------

### Instantiate name, edit, delete, and action forms

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Standardized methods to instantiate forms based on request data.

```python
name_form_class = self.get_name_form()
if request.form:
    return name_form_class(request.form)
elif request.args:
    return name_form_class(request.args)
else:
    return name_form_class()
```

```python
edit_form_class = self.get_edit_form()
if request.form:
    return edit_form_class(request.form)
else:
    return edit_form_class()
```

```python
delete_form_class = self.get_delete_form()
if request.form:
    return delete_form_class(request.form)
else:
    return delete_form_class()
```

```python
action_form_class = self.get_action_form()
if request.form:
    return action_form_class(request.form)
else:
    return action_form_class()
```

--------------------------------

### Get active filters as URL arguments

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Converts a list of filter tuples into a dictionary of URL-encoded query parameters.

```python
def _get_filters(self, filters: t.Sequence[T_FILTER] | None) -> dict[str, t.Any]:
    """
    Get active filters as dictionary of URL arguments and values

    :param filters:
        List of filters from ViewArgs object
    """
    kwargs = {}

    if filters:
        for i, pair in enumerate(filters):
            idx, flt_name, value = pair

            key = "flt%d_%s" % (
                i,
                self.get_filter_arg(
                    idx,
                    self._filters[idx],  # type: ignore[index]
                ),
            )
            kwargs[key] = value

    return kwargs
```

--------------------------------

### Search and Filter Configuration

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Methods for initializing search, defining placeholders, and managing filter objects.

```python
    def init_search(self) -> bool:
        """
        Initialize search. If data provider does not support search,
        `init_search` will return `False`.
        """
        return False
```

```python
    def search_placeholder(self) -> str | None:
        """
        Return search placeholder text.
        """
        return None
```

```python
    def scaffold_filters(self, name: str | BaseFilter) -> list[BaseFilter] | None:
        """
        Generate filter object for the given name

        :param name:
            Name of the field
        """
        return None
```

```python
    def is_valid_filter(
        self, filter: filters.BaseFilter | t.Any
    ) -> TypeGuard[BaseFilter]:
        """
        Verify that the provided filter object is valid.

        Override in model backend implementation to verify if
        the provided filter type is allowed.

        :param filter:
            Filter object to verify.
        :return: True if filter is instance of BaseFilter, False otherwise.
        """
        return isinstance(filter, filters.BaseFilter)
```

```python
    def handle_filter(self, filter: BaseFilter) -> BaseFilter:
        """
        Postprocess (add joins, etc) for a filter.

        :param filter:
            Filter object to postprocess
        """
        return filter
```

--------------------------------

### Get Human-Readable Column Name

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Returns a formatted column name based on labels or prettified field names.

```python
    def get_column_name(self, field: str) -> str:
        """
        Return a human-readable column name.

        :param field:
            Model field name.
        """
        if self.column_labels and field in self.column_labels:
            return self.column_labels[field]
        else:
            return self._prettify_name(field)
```

--------------------------------

### Admin.init_app

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Registers all views with the Flask application.

```APIDOC
## Admin.init_app

### Description
Registers all configured views with the provided Flask application instance.

### Parameters
- **app** (Flask) - Required - The Flask application object
- **index_view** (AdminIndexView | None) - Optional - Home page view
- **endpoint** (str | None) - Optional - Base endpoint name
- **url** (str | None) - Optional - Base URL
```

--------------------------------

### Get Model Endpoint

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Retrieves the endpoint for the model, defaulting to the lowercase model name if no specific endpoint is provided.

```python
    # Endpoint
    def _get_endpoint(self, endpoint: str | None) -> str:
        if endpoint:
            return super()._get_endpoint(endpoint)

        return self.model.__name__.lower()
```

--------------------------------

### Serve Flask-Admin on All Hosts

Source: https://flask-admin.readthedocs.io/en/stable/advanced

Use a wildcard host parameter to allow the admin interface to be served on any host.

```python
class AdminView(admin.BaseView):
    @admin.expose('/')
    def index(self):
        return self.render('template.html')

admin1 = admin.Admin(app, url='/admin', host='*')
admin1.add_view(AdminView())
```

--------------------------------

### Column Configuration Methods

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Methods to determine visibility, sortability, and labels for columns in the file admin view.

```python
    def is_column_visible(self, column: str) -> bool:
        """
        Determines if the given column is visible.
        :param column: The column to query.
        :return: Whether the column is visible.
        """
        return column in self.column_list
```

```python
    def is_column_sortable(self, column: str) -> bool:
        """
        Determines if the given column is sortable.
        :param column: The column to query.
        :return: Whether the column is sortable.
        """
        return column in self.column_sortable_list
```

```python
    def column_label(self, column: str) -> T_TRANSLATABLE:
        """
        Gets the column's label.
        :param column: The column to query.
        :return: The column's label.
        """
        return self.column_labels[column]
```

--------------------------------

### Get Sortable Columns Implementation

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Logic for determining sortable columns, including handling of related table joins.

```python
        self._sortable_joins = dict()

        if self.column_sortable_list is None:
            return self.scaffold_sortable_columns()
        else:
            result: dict[T_COLUMN, T_COLUMN] = dict()
            for c in self.column_sortable_list:
                if isinstance(c, tuple):
                    if isinstance(c[1], tuple):
                        column: list[T_COLUMN] = []
                        path: list[T_COLUMN] = []
                        for item in c[1]:
                            column_item, path_item = tools.get_field_with_path(
                                self.model, item
                            )
                            column.append(column_item)
                            path.append(path_item)  # type: ignore[arg-type]
                        column_name = c[0]
                    else:
                        column, path = tools.get_field_with_path(self.model, c[1])
                        column_name = c[0]
                else:
                    column, path = tools.get_field_with_path(
                        self.model,
                        c,  # type: ignore[arg-type]
                    )
                    column_name = text_type(c)

                if path and (hasattr(path[0], "property") or isinstance(path[0], list)):
                    self._sortable_joins[column_name] = path  # type: ignore[assignment]
                elif path:
                    raise Exception(
                        "For sorting columns in a related table, "
                        "column_sortable_list requires a string "
                        "like '<relation name>.<column name>'. "
                        f"Failed on: {c}"
                    )
                else:
                    # column is in same table, use only model attribute name
                    if getattr(column, "key", None) is not None:
                        column_name = column.key  # type: ignore[attr-defined]

                # column_name must match column_name used in `get_list_columns`
                result[column_name] = column  # type: ignore[assignment]
            return result
```

--------------------------------

### Retrieve Base Path and URL

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Methods to fetch the base path and URL, which can be overridden for per-user directory configurations.

```python
def get_base_path(self) -> str:
    """
    Return base path. Override to customize behavior (per-user
    directories, etc)
    """
    return self.storage.get_base_path()  # type: ignore[union-attr]
```

```python
def get_base_url(self) -> str | None:
    """
    Return base URL. Override to customize behavior (per-user
    directories, etc)
    """
    return self.base_url
```

--------------------------------

### Get and Format Object Primary Key

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/fields

Retrieves the primary key value from an object and converts it to a string representation.

```python
def get_obj_pk(obj: t.Any, pk: str | tuple[str, ...]) -> str | tuple[str, ...]:
    """
    get and format pk from obj
    :rtype: text_type
    """

    if isinstance(pk, tuple):
        return tuple(text_type(getattr(obj, k)) for k in pk)

    return text_type(getattr(obj, pk))
```

--------------------------------

### Directory Creation Logic

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Handles directory creation requests, including form validation, storage interaction, and flash messaging.

```python
        if self.validate_form(form):
            try:
                self.storage.make_dir(  # type: ignore[union-attr]
                    directory,
                    form.name.data,  # type: ignore[attr-defined]
                )
                self.on_mkdir(
                    directory,
                    form.name.data,  # type: ignore[attr-defined]
                )
                flash(
                    gettext(
                        "Successfully created directory: %(directory)s",
                        directory=form.name.data,  # type: ignore[attr-defined]
                    ),
                    "success",
                )
                return redirect(dir_url)
            except Exception as ex:
                flash(
                    gettext(
                        "Failed to create directory: %(error)s",
                        error=ex,  # type: ignore[arg-type]
                    ),
                    "error",
                )
        else:
            helpers.flash_errors(form, message="Failed to create directory: %(error)s")

        if self.mkdir_modal and request.args.get("modal"):
            template = self.mkdir_modal_template
        else:
            template = self.mkdir_template

        return self.render(
            template,
            form=form,
            dir_url=dir_url,
            header_text=gettext("Create Directory"),
        )
```

--------------------------------

### Get List Row Actions

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Generates a list of row action objects for the list view based on model permissions.

```python
    def get_list_row_actions(self) -> list[template.BaseListRowAction]:
        """
        Return list of row action objects, each is instance of
        :class:`~flask_admin.model.template.BaseListRowAction`
        """
        actions: list[template.BaseListRowAction] = []

        if self.can_view_details:
            if self.details_modal:
                actions.append(template.ViewPopupRowAction())
            else:
                actions.append(template.ViewRowAction())

        if self.can_edit:
            if self.edit_modal:
                actions.append(template.EditPopupRowAction())
            else:
                actions.append(template.EditRowAction())

        if self.can_delete:
            actions.append(template.DeleteRowAction())

        return actions + (self.column_extra_row_actions or [])
```

--------------------------------

### Implement Custom get_one Method

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Example implementation for overriding the get_one method to retrieve a single model instance by ID.

```python
def get_one(self, id):
    query = self.get_query()
    return query.filter(self.model.id == id).one()
```

--------------------------------

### Create AJAX Loader

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/mongoengine/view

Initializes an AJAX loader for foreign key fields.

```python
    def _create_ajax_loader(self, name, opts):
        return create_ajax_loader(self.model, name, name, opts)
```

--------------------------------

### Configure BootstrapTheme

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/theme

Implementation of a Bootstrap theme for Flask-Admin with configuration options for templates, swatches, and layout.

```python
@dataclass
class BootstrapTheme(Theme):
    """
    Bootstrap theme for Flask-Admin.

    Usage::

        t = Bootstrap4Theme(
            base_template='my_base.html', # relative your templates folder
            swatch='cerulean',
            fluid=True
        )
        admin = Admin(app, name='microblog', theme=t)
    """

    folder: typing.Literal["bootstrap4"]
    base_template: str = "admin/base.html"
    swatch: str = "default"
    fluid: bool = False
```

```python
Bootstrap4Theme = partial(BootstrapTheme, folder="bootstrap4")
```

--------------------------------

### FormOpts Configuration Class

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/form

A helper class for storing widget arguments and form rules.

```python
class FormOpts:
    __slots__ = ["widget_args", "form_rules"]

    def __init__(
        self, widget_args: dict[t.Any, t.Any] | None = None, form_rules: t.Any = None
    ) -> None:
        self.widget_args = widget_args or {}
        self.form_rules = form_rules
```

--------------------------------

### Get Column Names Implementation

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/sqla/view

Retrieves a list of tuples containing model field names and their formatted display names, handling InstrumentedAttributes.

```python
    def get_column_names(
        self,
        only_columns: T_COLUMN_LIST,
        excluded_columns: t.Sequence[str] | None,
    ) -> list[tuple[T_COLUMN, str]]:
        """
        Returns a list of tuples with the model field name and formatted
        field name.

        Overridden to handle special columns like InstrumentedAttribute.

        :param only_columns:
            List of columns to include in the results. If not set,
            `scaffold_list_columns` will generate the list from the model.
        :param excluded_columns:
            List of columns to exclude from the results.
        """
        if excluded_columns:
            only_columns = [c for c in only_columns if c not in excluded_columns]

        formatted_columns: list[tuple[T_COLUMN, str]] = []
        for c in only_columns:
            try:
                column, path = tools.get_field_with_path(
                    self.model,
                    c,  # type: ignore[arg-type]
                )

                if path:
                    # column is a relation (InstrumentedAttribute), use full path
                    column_name = text_type(c)
                else:
                    # column is in same table, use only model attribute name
                    if getattr(column, "key", None) is not None:
                        column_name = column.key
                    else:
                        column_name = text_type(c)
            except AttributeError:
                # TODO: See ticket #1299 - allow virtual columns. Probably figure out
                # better way to handle it. For now just assume if column was not found
                # - it is virtual and there's column formatter for it.
                column_name = text_type(c)

            visible_name = self.get_column_name(column_name)

            # column_name must match column_name in `get_sortable_columns`
            formatted_columns.append((column_name, visible_name))

        return formatted_columns
```

--------------------------------

### Upload File View Method

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Handles file uploads via GET and POST requests, validating permissions and form data before saving.

```python
    @expose("/upload/", methods=("GET", "POST"))
    @expose("/upload/<path:path>", methods=("GET", "POST"))
    def upload(self, path: str | None = None) -> T_RESPONSE | str:
        """
        Upload view method

        :param path:
            Optional directory path. If not provided, will use the base directory
        """
        # Get path and verify if it is valid
        base_path, directory, path = self._normalize_path(path)

        if not self.can_upload:
            flash(gettext("File uploading is disabled."), "error")
            return redirect(self._get_dir_url(".index_view", path))

        if not self.is_accessible_path(path):
            flash(gettext("Permission denied."), "error")
            return redirect(self._get_dir_url(".index_view"))

        form = self.upload_form()
        if self.validate_form(form):
            try:
                self._save_form_files(directory, path, form)
                flash(
                    gettext(
                        "Successfully saved file: %(name)s",
                        name=form.upload.data.filename,  # type: ignore[attr-defined]
                    ),
                    "success",
                )
                return redirect(self._get_dir_url(".index_view", path))
            except Exception as ex:
                flash(
                    gettext(
                        "Failed to save file: %(error)s",
                        error=ex,  # type: ignore[arg-type]
                    ),
                    "error",
                )
        else:
            helpers.flash_errors(form, message="Failed to upload file: %(error)s")

        if self.upload_modal and request.args.get("modal"):
            template = self.upload_modal_template
        else:
            template = self.upload_template

        return self.render(
            template,
            form=form,
            header_text=gettext("Upload File"),
            modal=request.args.get("modal"),
        )
```

--------------------------------

### Instantiate List and Action Forms

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Methods to instantiate forms specifically for list views and model actions.

```python
def list_form(self, obj: object | None = None) -> Form:
    """
    Instantiate model editing form for list view and return it.

    Override to implement custom behavior.
    """
    return self._list_form_class(get_form_data(), obj=obj)
```

```python
def action_form(self, obj: type | None = None) -> Form:
    """
    Instantiate model action form and return it.

    Override to implement custom behavior.
    """
    return self._action_form_class(get_form_data(), obj=obj)
```

--------------------------------

### Add menu links to Admin

Source: https://flask-admin.readthedocs.io/en/stable/api/mod_base

Demonstrates adding one or more MenuLink instances to the admin menu collection.

```python
admin.add_links(link1)
admin.add_links(link1, link2, link3, link4)
admin.add_links(*my_list)
```

--------------------------------

### Configure List View Columns

Source: https://flask-admin.readthedocs.io/en/stable/introduction

Define which columns appear in the list view and toggle primary key display.

```python
column_list = ['name', 'email', 'country']
```

```python
column_display_pk = True
```

--------------------------------

### Configure PyMongo column filters

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/pymongo/view

Examples of defining column filters for a PyMongo ModelView using built-in filters or custom filter classes.

```python
from flask_admin.contrib.pymongo.filters import BooleanEqualFilter

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

```python
from flask_admin.contrib.pymongo.filters import BasePyMongoFilter

class FilterLastNameBrown(BasePyMongoFilter):
    def apply(self, query, value):
        if value == '1':
            return query.filter(self.column == "Brown")
        else:
            return query.filter(self.column != "Brown")

    def operation(self):
        return 'is Brown'

class MyModelView(BaseModelView):
    column_filters = [
        FilterLastNameBrown(
            column=User.last_name, name='Last Name',
            options=(('1', 'Yes'), ('0', 'No'))
        )
    ]
```

--------------------------------

### Enable Modal Forms

Source: https://flask-admin.readthedocs.io/en/stable/introduction

Display create, edit, and details forms in a modal window instead of separate pages.

```python
create_modal = True
edit_modal = True
details_modal = True
```

--------------------------------

### Define a custom filter class

Source: https://flask-admin.readthedocs.io/en/stable/adding_a_new_model_backend

Example of implementing a filter class by inheriting from BaseFilter and defining the apply, operation, validate, and clean methods.

```python
class MyBaseFilter(BaseFilter):
    def __init__(self, column, name, options=None, data_type=None):
        super(MyBaseFilter, self).__init__(name, options, data_type)

        self.column = column

class MyEqualFilter(MyBaseFilter):
    def apply(self, query, value):
        return query.filter(self.column == value)

    def operation(self):
        return gettext('equals')

    # You can validate values. If value is not valid,
    # return `False`, so filter will be ignored.
    def validate(self, value):
        return True

    # You can "clean" values before they will be
    # passed to the your data access layer
    def clean(self, value):
        return value
```

--------------------------------

### Implement edit_view for model editing

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/model/base

Handles the GET and POST requests for editing an existing model instance, including form validation and redirection logic.

```python
@expose("/edit/", methods=("GET", "POST"))
def edit_view(self) -> T_RESPONSE | str:
    """
    Edit model view
    """
    return_url = get_redirect_target() or self.get_url(".index_view")

    if not self.can_edit:
        return redirect(return_url)

    id = get_mdict_item_or_list(request.args, "id")
    if id is None:
        return redirect(return_url)

    model = self.get_one(id)

    if model is None:
        flash(gettext("Record does not exist."), "error")
        return redirect(return_url)
    form = self.edit_form(obj=model)
    if not hasattr(form, "_validated_ruleset") or not form._validated_ruleset:
        self._validate_form_instance(ruleset=self._form_edit_rules, form=form)

    if self.validate_form(form):
        if self.update_model(form, model):
            flash(gettext("Record was successfully saved."), "success")
            if "_add_another" in request.form:
                return redirect(self.get_url(".create_view", url=return_url))
            elif "_continue_editing" in request.form:
                return redirect(
                    self.get_url(
                        ".edit_view", id=self.get_pk_value(model), url=return_url
                    )
                )
            else:
                # save button
                return redirect(self.get_save_return_url(model, is_created=False))
    else:
        if is_form_submitted():
            flash(gettext("Failed to save record."), "danger")

    if request.method == "GET" or form.errors:
        self.on_form_prefill(form, id)

    form_opts = FormOpts(
        widget_args=self.form_widget_args, form_rules=self._form_edit_rules
    )

    if self.edit_modal and request.args.get("modal"):
        template = self.edit_modal_template
    else:
        template = self.edit_template

    return self.render(
        template, model=model, form=form, form_opts=form_opts, return_url=return_url
    )
```

--------------------------------

### POST /action/

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Handles file management actions triggered via POST requests.

```APIDOC
## POST /action/

### Description
Executes a file management action (e.g., delete, edit) based on the provided request data.

### Method
POST

### Endpoint
/action/
```

--------------------------------

### Configure MongoEngine Object ID Converter

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/mongoengine/view

Examples of changing the default ObjectId converter to handle different ID types like int or str.

```python
class MyModelView(BaseModelView):
    object_id_converter = int
```

```python
class MyModelView(BaseModelView):
    object_id_converter = str
```

--------------------------------

### Path and URL Handling Methods

Source: https://flask-admin.readthedocs.io/en/stable/_modules/flask_admin/contrib/fileadmin

Internal methods for managing file paths and generating URLs for static files or directory endpoints.

```python
        if not path:
            return self.get_url(endpoint, **kwargs)
        else:
            if self._on_windows:
                path = path.replace("\\", "/")

            kwargs["path"] = path

            return self.get_url(endpoint, **kwargs)
```

```python
    def _get_file_url(self, path: str, **kwargs: t.Any) -> str:
        """
        Return static file url

        :param path:
            Static file path
        """
        if self._on_windows:
            path = path.replace("\\", "/")

        if self.is_file_editable(path):
            route = ".edit"
        else:
            route = ".download"

        return self.get_url(route, path=path, **kwargs)
```

```python
    def _normalize_path(self, path: str | None) -> tuple[str, str, str]:
        """
        Verify and normalize path.

        If the path is not relative to the base directory, will raise a 404 exception.

        If the path does not exist, this will also raise a 404 exception.
        """
        base_path = self.get_base_path()
        if path is None:
            directory = base_path
            path = ""
        else:
            path = self.normpath(path)
            if base_path:
                directory = self._separator.join([base_path, path])
            else:
                directory = path

            directory = self.normpath(directory)

            if not self.is_in_folder(base_path, directory):
                abort(404)

        if not self.storage.path_exists(directory):  # type: ignore[union-attr]
            abort(404)

        return base_path, directory, path
```
Tokens:
Raw