flask-appbuilder 3.2.1rc1__py3-none-any.whl → 5.0.2__py3-none-any.whl

flask_appbuilder/filemanager.py

@@ -4,18 +4,11 @@ import os.path as op
 import re
 import uuid
 
-from flask.globals import _request_ctx_stack
+from flask import current_app
 from werkzeug.datastructures import FileStorage
 from werkzeug.utils import secure_filename
 from wtforms import ValidationError
 
-try:
-    from flask import _app_ctx_stack
-except ImportError:
-    _app_ctx_stack = None
-
-app_stack = _app_ctx_stack or _request_ctx_stack
-
 log = logging.getLogger(__name__)
 
 try:
@@ -35,19 +28,16 @@ class FileManager(object):
         permission=0o755,
         **kwargs
     ):
-
-        ctx = app_stack.top
-
-        if "UPLOAD_FOLDER" in ctx.app.config and not base_path:
-            base_path = ctx.app.config["UPLOAD_FOLDER"]
+        if "UPLOAD_FOLDER" in current_app.config and not base_path:
+            base_path = current_app.config["UPLOAD_FOLDER"]
         if not base_path:
             raise Exception("Config key UPLOAD_FOLDER is mandatory")
 
         self.base_path = base_path
         self.relative_path = relative_path
         self.namegen = namegen or uuid_namegen
-        if not allowed_extensions and "FILE_ALLOWED_EXTENSIONS" in ctx.app.config:
-            self.allowed_extensions = ctx.app.config["FILE_ALLOWED_EXTENSIONS"]
+        if not allowed_extensions and "FILE_ALLOWED_EXTENSIONS" in current_app.config:
+            self.allowed_extensions = current_app.config["FILE_ALLOWED_EXTENSIONS"]
         else:
             self.allowed_extensions = allowed_extensions
         self.permission = permission
@@ -85,8 +75,8 @@ class FileManager(object):
 
 class ImageManager(FileManager):
     """
-        Image Manager will manage your image files referenced on SQLAlchemy Model
-        will save files on IMG_UPLOAD_FOLDER as <uuid>_sep_<filename>
+    Image Manager will manage your image files referenced on SQLAlchemy Model
+    will save files on IMG_UPLOAD_FOLDER as <uuid>_sep_<filename>
     """
 
     keep_image_formats = ("PNG",)
@@ -103,22 +93,20 @@ class ImageManager(FileManager):
         permission=0o755,
         **kwargs
     ):
-
         # Check if PIL is installed
         if Image is None:
             raise Exception("PIL library was not found")
 
-        ctx = app_stack.top
-        if "IMG_SIZE" in ctx.app.config and not max_size:
-            self.max_size = ctx.app.config["IMG_SIZE"]
+        if "IMG_SIZE" in current_app.config and not max_size:
+            self.max_size = current_app.config["IMG_SIZE"]
 
-        if "IMG_UPLOAD_URL" in ctx.app.config and not relative_path:
-            relative_path = ctx.app.config["IMG_UPLOAD_URL"]
+        if "IMG_UPLOAD_URL" in current_app.config and not relative_path:
+            relative_path = current_app.config["IMG_UPLOAD_URL"]
         if not relative_path:
             raise Exception("Config key IMG_UPLOAD_URL is mandatory")
 
-        if "IMG_UPLOAD_FOLDER" in ctx.app.config and not base_path:
-            base_path = ctx.app.config["IMG_UPLOAD_FOLDER"]
+        if "IMG_UPLOAD_FOLDER" in current_app.config and not base_path:
+            base_path = current_app.config["IMG_UPLOAD_FOLDER"]
         if not base_path:
             raise Exception("Config key IMG_UPLOAD_FOLDER is mandatory")
 
@@ -161,10 +149,10 @@ class ImageManager(FileManager):
     # Saving
     def save_file(self, data, filename, size=None, thumbnail_size=None):
         """
-            Saves an image File
+        Saves an image File
 
-            :param data: FileStorage from Flask form upload field
-            :param filename: Filename with full path
+        :param data: FileStorage from Flask form upload field
+        :param filename: Filename with full path
 
         """
         max_size = size or self.max_size
@@ -204,19 +192,19 @@ class ImageManager(FileManager):
 
     def resize(self, image, size):
         """
-            Resizes the image
+        Resizes the image
 
             :param image: The image object
-            :param size: size is PIL tuple (width, heigth, force) ex: (200,100,True)
+            :param size: size is PIL tuple (width, height, force) ex: (200,100,True)
         """
         (width, height, force) = size
 
         if image.size[0] > width or image.size[1] > height:
             if force:
-                return ImageOps.fit(self.image, (width, height), Image.ANTIALIAS)
+                return ImageOps.fit(self.image, (width, height), Image.LANCZOS)
             else:
                 thumb = self.image.copy()
-                thumb.thumbnail((width, height), Image.ANTIALIAS)
+                thumb.thumbnail((width, height), Image.LANCZOS)
                 return thumb
 
         return image
@@ -241,23 +229,23 @@ def uuid_namegen(file_data):
 
 def get_file_original_name(name):
     """
-        Use this function to get the user's original filename.
-        Filename is concatenated with <UUID>_sep_<FILE NAME>, to avoid collisions.
-        Use this function on your models on an aditional function
+    Use this function to get the user's original filename.
+    Filename is concatenated with <UUID>_sep_<FILE NAME>, to avoid collisions.
+    Use this function on your models on an additional function
 
-        ::
+    ::
 
-            class ProjectFiles(Base):
-                id = Column(Integer, primary_key=True)
-                file = Column(FileColumn, nullable=False)
+        class ProjectFiles(Base):
+            id = Column(Integer, primary_key=True)
+            file = Column(FileColumn, nullable=False)
 
-                def file_name(self):
-                    return get_file_original_name(str(self.file))
+            def file_name(self):
+                return get_file_original_name(str(self.file))
 
-        :param name:
-            The file name from model
-        :return:
-            Returns the user's original filename removes <UUID>_sep_
+    :param name:
+        The file name from model
+    :return:
+        Returns the user's original filename removes <UUID>_sep_
     """
     re_match = re.findall(".*_sep_(.*)", name)
     if re_match:

flask_appbuilder/filters.py

@@ -13,11 +13,9 @@ def app_template_filter(filter_name=""):
 
 
 class TemplateFilters(object):
-
     security_manager = None
 
     def __init__(self, app, security_manager):
-
         self.security_manager = security_manager
         for attr_name in dir(self):
             if hasattr(getattr(self, attr_name), "_filter"):
@@ -52,8 +50,8 @@ class TemplateFilters(object):
     @app_template_filter("link_order")
     def link_order_filter(self, column, modelview_name):
         """
-            Arguments are passed like:
-                _oc_<VIEW_NAME>=<COL_NAME>&_od_<VIEW_NAME>='asc'|'desc'
+        Arguments are passed like:
+            _oc_<VIEW_NAME>=<COL_NAME>&_od_<VIEW_NAME>='asc'|'desc'
         """
         new_args = request.view_args.copy()
         args = request.args.copy()
@@ -74,7 +72,7 @@ class TemplateFilters(object):
     @app_template_filter("link_page")
     def link_page_filter(self, page, modelview_name):
         """
-            Arguments are passed like: page_<VIEW_NAME>=<PAGE_NUMBER>
+        Arguments are passed like: page_<VIEW_NAME>=<PAGE_NUMBER>
         """
         new_args = request.view_args.copy()
         args = request.args.copy()
@@ -144,14 +142,14 @@ class TemplateFilters(object):
     @app_template_filter("is_item_visible")
     def is_item_visible(self, permission: str, item: str) -> bool:
         """
-            Check if an item is visible on the template
-            this changed with permission mapping feature.
-            This is a best effort to deliver the feature
-            and not break compatibility
-
-            permission is:
-             - 'can_' + <METHOD_NAME>: On normal routes
-             - <METHOD_NAME>: when it's an action
+        Check if an item is visible on the template
+        this changed with permission mapping feature.
+        This is a best effort to deliver the feature
+        and not break compatibility
+
+        permission is:
+         - 'can_' + <METHOD_NAME>: On normal routes
+         - <METHOD_NAME>: when it's an action
 
         """
         _view = self.find_views_by_name(item)

flask_appbuilder/forms.py

@@ -22,7 +22,6 @@ from .fieldwidgets import (
     Select2ManyWidget,
     Select2Widget,
 )
-from .models.mongoengine.fields import MongoFileField, MongoImageField
 from .upload import (
     BS3FileUploadFieldWidget,
     BS3ImageUploadFieldWidget,
@@ -39,21 +38,20 @@ except Exception:
 log = logging.getLogger(__name__)
 
 
-class FieldConverter(object):
+class FieldConverter:
     """
-        Helper class that converts model fields into WTForm fields
+    Helper class that converts model fields into WTForm fields
 
-        it has a conversion table with type method checks from model
-        interfaces, these methods are invoked with a column name
+    it has a conversion table with type method checks from model
+    interfaces, these methods are invoked with a column name
     """
 
     conversion_table = (
         ("is_image", ImageUploadField, BS3ImageUploadFieldWidget),
         ("is_file", FileUploadField, BS3FileUploadFieldWidget),
-        ("is_gridfs_file", MongoFileField, BS3FileUploadFieldWidget),
-        ("is_gridfs_image", MongoImageField, BS3ImageUploadFieldWidget),
         ("is_text", TextAreaField, BS3TextAreaFieldWidget),
         ("is_binary", TextAreaField, BS3TextAreaFieldWidget),
+        ("is_json", TextAreaField, BS3TextAreaFieldWidget),
         ("is_string", StringField, BS3TextFieldWidget),
         ("is_integer", IntegerField, BS3TextFieldWidget),
         ("is_numeric", DecimalField, BS3TextFieldWidget),
@@ -104,13 +102,13 @@ class FieldConverter(object):
                         validators=self.validators,
                         default=self.default,
                     )
-        log.error("Column %s Type not supported" % self.colname)
+        log.error("Column %s Type not supported", self.colname)
 
 
-class GeneralModelConverter(object):
+class GeneralModelConverter:
     """
-        Returns a form from a model only one public exposed
-        method 'create_form'
+    Returns a form from a model only one public exposed
+    method 'create_form'
     """
 
     def __init__(self, datamodel):
@@ -153,9 +151,9 @@ class GeneralModelConverter(object):
         form_props,
     ):
         """
-            Creates a WTForm field for many to one related fields,
-            will use a Select box based on a query. Will only
-            work with SQLAlchemy interface.
+        Creates a WTForm field for many to one related fields,
+        will use a Select box based on a query. Will only
+        work with SQLAlchemy interface.
         """
         query_func = self._get_related_query_func(col_name, filter_rel_fields)
         get_pk_func = self._get_related_pk_func(col_name)
@@ -188,13 +186,11 @@ class GeneralModelConverter(object):
     ):
         query_func = self._get_related_query_func(col_name, filter_rel_fields)
         get_pk_func = self._get_related_pk_func(col_name)
-        allow_blank = True
         form_props[col_name] = QuerySelectMultipleField(
             label,
             description=description,
             query_func=query_func,
             get_pk_func=get_pk_func,
-            allow_blank=allow_blank,
             validators=lst_validators,
             widget=Select2ManyWidget(),
         )
@@ -259,7 +255,7 @@ class GeneralModelConverter(object):
                     form_props,
                 )
             else:
-                log.warning("Relation {0} not supported".format(col_name))
+                log.warning("Relation %s not supported", col_name)
         else:
             return self._convert_simple(
                 col_name, label, description, lst_validators, form_props
@@ -275,28 +271,28 @@ class GeneralModelConverter(object):
         filter_rel_fields=None,
     ):
         """
-            Converts a model to a form given
+        Converts a model to a form given
 
-            :param label_columns:
-                A dictionary with the column's labels.
-            :param inc_columns:
-                A list with the columns to include
-            :param description_columns:
-                A dictionary with a description for cols.
-            :param validators_columns:
-                A dictionary with WTForms validators ex::
+        :param label_columns:
+            A dictionary with the column's labels.
+        :param inc_columns:
+            A list with the columns to include
+        :param description_columns:
+            A dictionary with a description for cols.
+        :param validators_columns:
+            A dictionary with WTForms validators ex::
 
-                    validators={'personal_email':EmailValidator}
+                validators={'personal_email':EmailValidator}
 
-            :param extra_fields:
-                A dictionary containing column names and a WTForm
-                Form fields to be added to the form, these fields do not
-                 exist on the model itself ex::
+        :param extra_fields:
+            A dictionary containing column names and a WTForm
+            Form fields to be added to the form, these fields do not
+             exist on the model itself ex::
 
-                    extra_fields={'some_col':BooleanField('Some Col', default=False)}
+                extra_fields={'some_col':BooleanField('Some Col', default=False)}
 
-            :param filter_rel_fields:
-                A filter to be applied on relationships
+        :param filter_rel_fields:
+            A filter to be applied on relationships
         """
         label_columns = label_columns or {}
         inc_columns = inc_columns or []
@@ -321,7 +317,7 @@ class GeneralModelConverter(object):
 
 class DynamicForm(FlaskForm):
     """
-        Refresh method will force select field to refresh
+    Refresh method will force select field to refresh
     """
 
     @classmethod

flask_appbuilder/hooks.py

@@ -0,0 +1,90 @@
+from typing import Any, Callable, Dict, List
+
+
+def before_request(
+    hook: Callable[[], Any] = None, only: List[str] = None
+) -> Callable[..., Any]:
+    """
+    This decorator provides a way to hook into the request
+    lifecycle by enqueueing methods to be invoked before
+    each handler in the view. If the method returns a value
+    other than :code:`None`, then that value will be returned
+    to the client. If invoked with the :code:`only` kwarg,
+    the hook will only be invoked for the given list of
+    handler methods.
+
+    Examples::
+
+        class MyFeature(ModelView)
+
+            @before_request
+            def ensure_feature_is_enabled(self):
+                if self.feature_is_disabled:
+                    return self.response_404()
+                return None
+
+            # etc...
+
+
+        class MyView(ModelRestAPI):
+
+            @before_request(only=["create", "update", "delete"])
+            def ensure_write_mode_enabled(self):
+                if self.read_only:
+                    return self.response_400()
+                return None
+
+            # etc...
+
+    :param hook:
+        A callable to be invoked before handlers in the class. If the
+        hook returns :code:`None`, then the request proceeds and the
+        handler is invoked. If it returns something other than :code:`None`,
+        then execution halts and that value is returned to the client.
+    :param only:
+        An optional list of the names of handler methods. If present,
+        :code:`hook` will only be invoked before the handlers specified
+        in the list. If absent, :code:`hook` will be invoked for before
+        all handlers in the class.
+    """
+
+    def wrap(hook: Callable[[], Any]) -> Callable[[], Any]:
+        hook._before_request_hook = True
+        hook._before_request_only = only
+        return hook
+
+    return wrap if hook is None else wrap(hook)
+
+
+def wrap_route_handler_with_hooks(
+    handler_name: str,
+    handler: Callable[..., Any],
+    before_request_hooks: List[Callable[[], Any]],
+) -> Callable[..., Any]:
+    applicable_hooks = []
+    for hook in before_request_hooks:
+        only = hook._before_request_only
+        applicable_hook = only is None or handler_name in only
+        if applicable_hook:
+            applicable_hooks.append(hook)
+
+    if not applicable_hooks:
+        return handler
+
+    def wrapped_handler(*args: List[Any], **kwargs: Dict[str, Any]) -> Any:
+        for hook in applicable_hooks:
+            result = hook()
+            if result is not None:
+                return result
+        return handler(*args, **kwargs)
+
+    return wrapped_handler
+
+
+def get_before_request_hooks(view_or_api_instance: Any) -> List[Callable[[], Any]]:
+    before_request_hooks = []
+    for attr_name in dir(view_or_api_instance):
+        attr = getattr(view_or_api_instance, attr_name)
+        if hasattr(attr, "_before_request_hook") and attr._before_request_hook is True:
+            before_request_hooks.append(attr)
+    return before_request_hooks

flask_appbuilder/menu.py

@@ -9,13 +9,19 @@ from .security.decorators import permission_name, protect
 
 
 class MenuItem(object):
-    def __init__(self, name, href="", icon="", label="", childs=None, baseview=None):
+    def __init__(
+        self, name, href="", icon="", label="", childs=None, baseview=None, cond=None
+    ):
         self.name = name
         self.href = href
         self.icon = icon
         self.label = label
         self.childs = childs or []
         self.baseview = baseview
+        self.cond = cond
+
+    def should_render(self) -> bool:
+        return bool(self.cond()) if self.cond is not None else True
 
     def get_url(self):
         if not self.href:
@@ -65,6 +71,9 @@ class Menu(object):
         )
 
         for i, item in enumerate(menu):
+            if not item.should_render():
+                continue
+
             if item.name == "-" and not i == len(menu) - 1:
                 ret_list.append("-")
             elif item.name not in allowed_menus:
@@ -91,10 +100,10 @@ class Menu(object):
 
     def find(self, name, menu=None):
         """
-            Finds a menu item by name and returns it.
+        Finds a menu item by name and returns it.
 
-            :param name:
-                The menu item name.
+        :param name:
+            The menu item name.
         """
         menu = menu or self.menu
         for i in menu:
@@ -125,20 +134,31 @@ class Menu(object):
         category_icon="",
         category_label="",
         baseview=None,
+        cond=None,
     ):
         label = label or name
         category_label = category_label or category
         if category == "":
             self.menu.append(
                 MenuItem(
-                    name=name, href=href, icon=icon, label=label, baseview=baseview
+                    name=name,
+                    href=href,
+                    icon=icon,
+                    label=label,
+                    baseview=baseview,
+                    cond=cond,
                 )
             )
         else:
             menu_item = self.find(category)
             if menu_item:
                 new_menu_item = MenuItem(
-                    name=name, href=href, icon=icon, label=label, baseview=baseview
+                    name=name,
+                    href=href,
+                    icon=icon,
+                    label=label,
+                    baseview=baseview,
+                    cond=cond,
                 )
                 menu_item.childs.append(new_menu_item)
             else:
@@ -146,14 +166,19 @@ class Menu(object):
                     category=category, icon=category_icon, label=category_label
                 )
                 new_menu_item = MenuItem(
-                    name=name, href=href, icon=icon, label=label, baseview=baseview
+                    name=name,
+                    href=href,
+                    icon=icon,
+                    label=label,
+                    baseview=baseview,
+                    cond=cond,
                 )
                 self.find(category).childs.append(new_menu_item)
 
-    def add_separator(self, category=""):
+    def add_separator(self, category="", cond=None):
         menu_item = self.find(category)
         if menu_item:
-            menu_item.childs.append(MenuItem("-"))
+            menu_item.childs.append(MenuItem("-", cond=cond))
         else:
             raise Exception(
                 "Menu separator does not have correct category {}".format(category)
@@ -213,5 +238,5 @@ class MenuApi(BaseApi):
 
 class MenuApiManager(BaseManager):
     def register_views(self):
-        if self.appbuilder.app.config.get("FAB_ADD_MENU_API", True):
+        if current_app.config.get("FAB_ADD_MENU_API", True):
             self.appbuilder.add_api(MenuApi)