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

flask_appbuilder/api/convert.py

@@ -1,21 +1,21 @@
-from typing import List, Optional, Type
+from typing import Any, Callable, Dict, List, Optional, Type
 
+from flask import current_app
 from flask_appbuilder.models.sqla import Model
 from flask_appbuilder.models.sqla.interface import SQLAInterface
-from marshmallow import fields
+from marshmallow import fields, Schema
 from marshmallow.fields import Field
-from marshmallow_enum import EnumField
 from marshmallow_sqlalchemy import field_for
 from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
 
 
 class TreeNode:
-    def __init__(self, data):
-        self.data = data
-        self.childs = list()
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.children: List["TreeNode"] = []
 
-    def __repr__(self):
-        return f"{self.data}.{str(self.childs)}"
+    def __repr__(self) -> str:
+        return f"{self.name}.{str(self.children)}"
 
 
 class Tree:
@@ -23,26 +23,26 @@ class Tree:
     Simplistic one level Tree
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.root = TreeNode("+")
 
-    def add(self, data):
-        node = TreeNode(data)
-        self.root.childs.append(node)
+    def add(self, name: str) -> None:
+        node = TreeNode(name)
+        self.root.children.append(node)
 
-    def add_child(self, parent, data):
-        node = TreeNode(data)
-        for n in self.root.childs:
-            if n.data == parent:
-                n.childs.append(node)
+    def add_child(self, parent: str, name: str) -> None:
+        node = TreeNode(name)
+        for child in self.root.children:
+            if child.name == parent:
+                child.children.append(node)
                 return
         root = TreeNode(parent)
-        self.root.childs.append(root)
-        root.childs.append(node)
+        self.root.children.append(root)
+        root.children.append(node)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         ret = ""
-        for node in self.root.childs:
+        for node in self.root.children:
             ret += str(node)
         return ret
 
@@ -51,43 +51,62 @@ def columns2Tree(columns: List[str]) -> Tree:
     tree = Tree()
     for column in columns:
         if "." in column:
-            tree.add_child(column.split(".")[0], column.split(".")[1])
+            parent, child = column.split(".")
+            tree.add_child(parent, child)
         else:
             tree.add(column)
     return tree
 
 
 class BaseModel2SchemaConverter(object):
-    def __init__(self, datamodel: SQLAInterface, validators_columns):
+    def __init__(
+        self,
+        datamodel: SQLAInterface,
+        validators_columns: Dict[str, Callable[[Any], Any]],
+    ):
         """
         :param datamodel: SQLAInterface
         """
         self.datamodel = datamodel
         self.validators_columns = validators_columns
 
-    def convert(self, columns, **kwargs):
+    def convert(
+        self,
+        columns: List[str],
+        model: Optional[Type[Model]] = None,
+        nested: bool = True,
+        parent_schema_name: Optional[str] = None,
+    ) -> SQLAlchemyAutoSchema:
         pass
 
 
 class Model2SchemaConverter(BaseModel2SchemaConverter):
     """
-        Class that converts Models to marshmallow Schemas
+    Class that converts Models to marshmallow Schemas
     """
 
-    def __init__(self, datamodel: SQLAInterface, validators_columns):
+    def __init__(
+        self,
+        datamodel: SQLAInterface,
+        validators_columns: Dict[str, Callable[[Any], Any]],
+    ):
         """
         :param datamodel: SQLAInterface
         """
         super(Model2SchemaConverter, self).__init__(datamodel, validators_columns)
 
     @staticmethod
-    def _debug_schema(schema):
+    def _debug_schema(schema: SQLAlchemyAutoSchema) -> None:
         for k, v in schema._declared_fields.items():
             print(k, v)
 
     def _meta_schema_factory(
-        self, columns: List[str], model: Model, class_mixin, parent_schema_name=None
-    ):
+        self,
+        columns: List[str],
+        model: Optional[Type[Model]],
+        class_mixin: Type[Schema],
+        parent_schema_name: Optional[str] = None,
+    ) -> Type[SQLAlchemyAutoSchema]:
         """
         Creates ModelSchema marshmallow-sqlalchemy
 
@@ -100,45 +119,44 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
         _parent_schema_name = parent_schema_name
         if columns:
 
-            class MetaSchema(SQLAlchemyAutoSchema, class_mixin):
+            class MetaSchema(SQLAlchemyAutoSchema, class_mixin):  # type: ignore
                 class Meta:
                     model = _model
                     fields = columns
                     load_instance = True
-                    sqla_session = self.datamodel.session
+                    sqla_session = current_app.appbuilder.session
                     # The parent_schema_name is useful to humanize nested schema names
                     # This name comes from ModelRestApi
                     parent_schema_name = _parent_schema_name
 
-        else:
+            return MetaSchema
 
-            class MetaSchema(SQLAlchemyAutoSchema, class_mixin):
-                class Meta:
-                    model = _model
-                    load_instance = True
-                    sqla_session = self.datamodel.session
-                    # The parent_schema_name is useful to humanize nested schema names
-                    # This name comes from ModelRestApi
-                    parent_schema_name = _parent_schema_name
+        class MetaSchema(SQLAlchemyAutoSchema, class_mixin):  # type: ignore
+            class Meta:
+                model = _model
+                load_instance = True
+                sqla_session = current_app.appbuilder.session
+                # The parent_schema_name is useful to humanize nested schema names
+                # This name comes from ModelRestApi
+                parent_schema_name = _parent_schema_name
 
         return MetaSchema
 
-    def _column2enum(
-        self,
-        datamodel: SQLAInterface,
-        column: TreeNode,
-        enum_dump_by_name: bool = False,
-    ):
-        required = not datamodel.is_nullable(column.data)
-        enum_class = datamodel.list_columns[column.data].info.get(
-            "enum_class", datamodel.list_columns[column.data].type
-        )
-        if enum_dump_by_name:
-            enum_dump_by = EnumField.NAME
+    def _column2enum(self, datamodel: SQLAInterface, column: TreeNode) -> Field:
+        required = not datamodel.is_nullable(column.name)
+        sqla_column = datamodel.list_columns[column.name]
+        # get SQLAlchemy column user info, we use it to get the marshmallow enum options
+        column_info = sqla_column.info
+        # TODO: Default should be False, but keeping this to True to keep compatibility
+        # Turn this to False in the next major release
+        by_value = column_info.get("marshmallow_by_value", True)
+        # Get the original enum class from SQLAlchemy Enum field
+        enum_class = sqla_column.type.enum_class
+        if not enum_class:
+            field = field_for(datamodel.obj, column.name)
         else:
-            enum_dump_by = EnumField.VALUE
-        field = EnumField(enum_class, dump_by=enum_dump_by, required=required)
-        field.unique = datamodel.is_unique(column.data)
+            field = fields.Enum(enum_class, required=required, by_value=by_value)
+        field.unique = datamodel.is_unique(column.name)
         return field
 
     def _column2relation(
@@ -147,40 +165,37 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
         column: TreeNode,
         nested: bool = False,
         parent_schema_name: Optional[str] = None,
-    ):
+    ) -> Field:
         if nested:
-            required = not datamodel.is_nullable(column.data)
-            nested_model = datamodel.get_related_model(column.data)
-            lst = [item.data for item in column.childs]
+            required = not datamodel.is_nullable(column.name)
+            nested_model = datamodel.get_related_model(column.name)
+            lst = [item.name for item in column.children]
             nested_schema = self.convert(
                 lst, nested_model, nested=False, parent_schema_name=parent_schema_name
             )
-            if datamodel.is_relation_many_to_one(column.data):
+            if datamodel.is_relation_many_to_one(column.name):
                 many = False
-            elif datamodel.is_relation_many_to_many(column.data):
+            elif datamodel.is_relation_many_to_many(column.name):
                 many = True
                 required = False
-            elif datamodel.is_relation_one_to_many(column.data):
+            elif datamodel.is_relation_one_to_many(column.name):
                 many = True
             else:
                 many = False
             field = fields.Nested(nested_schema, many=many, required=required)
-            field.unique = datamodel.is_unique(column.data)
+            field.unique = datamodel.is_unique(column.name)
             return field
         # Handle bug on marshmallow-sqlalchemy
         # https://github.com/marshmallow-code/marshmallow-sqlalchemy/issues/163
         if datamodel.is_relation_many_to_many(
-            column.data
-        ) or datamodel.is_relation_one_to_many(column.data):
-            if datamodel.get_info(column.data).get("required", False):
-                required = True
-            else:
-                required = False
+            column.name
+        ) or datamodel.is_relation_one_to_many(column.name):
+            required = datamodel.get_info(column.name).get("required", False)
         else:
-            required = not datamodel.is_nullable(column.data)
-        field = field_for(datamodel.obj, column.data)
+            required = not datamodel.is_nullable(column.name)
+        field = field_for(datamodel.obj, column.name)
         field.required = required
-        field.unique = datamodel.is_unique(column.data)
+        field.unique = datamodel.is_unique(column.name)
         return field
 
     def _column2field(
@@ -188,7 +203,6 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
         datamodel: SQLAInterface,
         column: TreeNode,
         nested: bool = True,
-        enum_dump_by_name: bool = False,
         parent_schema_name: Optional[str] = None,
     ) -> Field:
         """
@@ -196,34 +210,31 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
         :param datamodel: SQLAInterface
         :param column: TreeNode column (childs are dotted columns)
         :param nested: Boolean if will create nested fields
-        :param enum_dump_by_name:
         :return: Schema.field
         """
         # Handle relations
-        if datamodel.is_relation(column.data):
+        if datamodel.is_relation(column.name):
             return self._column2relation(
                 datamodel, column, nested=nested, parent_schema_name=parent_schema_name
             )
         # Handle Enums
-        elif datamodel.is_enum(column.data):
-            return self._column2enum(
-                datamodel, column, enum_dump_by_name=enum_dump_by_name
-            )
+        if datamodel.is_enum(column.name):
+            return self._column2enum(datamodel, column)
         # is custom property method field?
-        if hasattr(getattr(datamodel.obj, column.data), "fget"):
+        if hasattr(getattr(datamodel.obj, column.name), "fget"):
             return fields.Raw(dump_only=True)
         # its a model function
-        if hasattr(getattr(datamodel.obj, column.data), "__call__"):
-            return fields.Function(getattr(datamodel.obj, column.data), dump_only=True)
+        if hasattr(getattr(datamodel.obj, column.name), "__call__"):
+            return fields.Function(getattr(datamodel.obj, column.name), dump_only=True)
         # is a normal model field not a function?
-        if not hasattr(getattr(datamodel.obj, column.data), "__call__"):
-            field = field_for(datamodel.obj, column.data)
-            field.unique = datamodel.is_unique(column.data)
-            if column.data in self.validators_columns:
+        if not hasattr(getattr(datamodel.obj, column.name), "__call__"):
+            field = field_for(datamodel.obj, column.name)
+            field.unique = datamodel.is_unique(column.name)
+            if column.name in self.validators_columns:
                 if field.validate is None:
                     field.validate = []
-                field.validate.append(self.validators_columns[column.data])
-                field.validators.append(self.validators_columns[column.data])
+                field.validate.append(self.validators_columns[column.name])
+                field.validators.append(self.validators_columns[column.name])
             return field
 
     def convert(
@@ -231,9 +242,8 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
         columns: List[str],
         model: Optional[Type[Model]] = None,
         nested: bool = True,
-        enum_dump_by_name: bool = False,
         parent_schema_name: Optional[str] = None,
-    ):
+    ) -> SQLAlchemyAutoSchema:
         """
             Creates a Marshmallow ModelSchema class
 
@@ -257,16 +267,12 @@ class Model2SchemaConverter(BaseModel2SchemaConverter):
 
         _columns = list()
         tree_columns = columns2Tree(columns)
-        for column in tree_columns.root.childs:
+        for column in tree_columns.root.children:
             # Get child model is column is dotted notation
-            ma_sqla_fields_override[column.data] = self._column2field(
-                _datamodel,
-                column,
-                nested,
-                enum_dump_by_name,
-                parent_schema_name=parent_schema_name,
+            ma_sqla_fields_override[column.name] = self._column2field(
+                _datamodel, column, nested, parent_schema_name=parent_schema_name
             )
-            _columns.append(column.data)
+            _columns.append(column.name)
         for k, v in ma_sqla_fields_override.items():
             setattr(SchemaMixin, k, v)
         return self._meta_schema_factory(

flask_appbuilder/api/manager.py

@@ -1,7 +1,7 @@
 from apispec import APISpec
 from apispec.ext.marshmallow import MarshmallowPlugin
 from apispec.ext.marshmallow.common import resolve_schema_cls
-from flask import current_app
+from flask import current_app, request
 from flask_appbuilder.api import BaseApi
 from flask_appbuilder.api import expose, protect, safe
 from flask_appbuilder.basemanager import BaseManager
@@ -30,7 +30,7 @@ class OpenApi(BaseApi):
     @protect()
     @safe
     def get(self, version):
-        """ Endpoint that renders an OpenApi spec for all views that belong
+        """Endpoint that renders an OpenApi spec for all views that belong
             to a certain version
         ---
         get:
@@ -66,18 +66,20 @@ class OpenApi(BaseApi):
 
     @staticmethod
     def _create_api_spec(version):
+        servers = current_app.config.get(
+            "FAB_OPENAPI_SERVERS", [{"url": request.host_url}]
+        )
         return APISpec(
             title=current_app.appbuilder.app_name,
             version=version,
             openapi_version="3.0.2",
             info=dict(description=current_app.appbuilder.app_name),
             plugins=[MarshmallowPlugin(schema_name_resolver=resolver)],
-            servers=[{"url": "/api/{}".format(version)}],
+            servers=servers,
         )
 
 
 class SwaggerView(BaseView):
-
     route_base = "/swagger"
     default_view = "ui"
     openapi_uri = "/api/{}/_openapi"
@@ -85,16 +87,20 @@ class SwaggerView(BaseView):
     @expose("/<version>")
     @has_access
     def show(self, version):
+        # Apply APPLICATION_ROOT config to the swagger URL
+        openapi_uri = request.script_root + self.openapi_uri.format(version)
         return self.render_template(
-            "appbuilder/swagger/swagger.html",
-            openapi_uri=self.openapi_uri.format(version),
+            current_app.config.get(
+                "FAB_API_SWAGGER_TEMPLATE", "appbuilder/swagger/swagger.html"
+            ),
+            openapi_uri=openapi_uri,
         )
 
 
 class OpenApiManager(BaseManager):
     def register_views(self):
-        if not self.appbuilder.app.config.get("FAB_ADD_SECURITY_VIEWS", True):
+        if not current_app.config.get("FAB_ADD_OPENAPI_VIEWS", True):
             return
-        if self.appbuilder.get_app.config.get("FAB_API_SWAGGER_UI", False):
+        if current_app.config.get("FAB_API_SWAGGER_UI", False):
             self.appbuilder.add_api(OpenApi)
             self.appbuilder.add_view_no_menu(SwaggerView)

flask_appbuilder/api/schemas.py

@@ -18,6 +18,7 @@ from ..const import (
     API_PERMISSIONS_RIS_KEY,
     API_SELECT_COLUMNS_RIS_KEY,
     API_SELECT_KEYS_RIS_KEY,
+    API_SELECT_SEL_COLUMNS_RIS_KEY,
     API_SHOW_COLUMNS_RIS_KEY,
     API_SHOW_TITLE_RIS_KEY,
 )
@@ -70,6 +71,7 @@ get_list_schema = {
             },
         },
         API_SELECT_COLUMNS_RIS_KEY: {"type": "array", "items": {"type": "string"}},
+        API_SELECT_SEL_COLUMNS_RIS_KEY: {"type": "array", "items": {"type": "string"}},
         API_ORDER_COLUMN_RIS_KEY: {"type": "string"},
         API_ORDER_DIRECTION_RIS_KEY: {"type": "string", "enum": ["asc", "desc"]},
         API_PAGE_INDEX_RIS_KEY: {"type": "integer"},
@@ -86,7 +88,16 @@ get_list_schema = {
                             {"type": "number"},
                             {"type": "string"},
                             {"type": "boolean"},
-                            {"type": "array"},
+                            {
+                                "type": "array",
+                                "items": {
+                                    "anyOf": [
+                                        {"type": "number"},
+                                        {"type": "string"},
+                                        {"type": "boolean"},
+                                    ]
+                                },
+                            },
                         ]
                     },
                 },

flask_appbuilder/babel/manager.py

@@ -1,31 +1,28 @@
 import os
 
-from flask import has_request_context, request, session
+from flask import current_app, has_request_context, request, session
+from flask_appbuilder.babel.views import LocaleView
+from flask_appbuilder.basemanager import BaseManager
 from flask_babel import Babel
 
-from .views import LocaleView
-from ..basemanager import BaseManager
-
 
 class BabelManager(BaseManager):
-
     babel = None
     locale_view = None
 
     def __init__(self, appbuilder):
         super(BabelManager, self).__init__(appbuilder)
-        app = appbuilder.get_app
-        app.config.setdefault("BABEL_DEFAULT_LOCALE", "en")
-        if not app.config.get("LANGUAGES"):
-            app.config["LANGUAGES"] = {"en": {"flag": "us", "name": "English"}}
+        current_app.config.setdefault("BABEL_DEFAULT_LOCALE", "en")
+        if not current_app.config.get("LANGUAGES"):
+            current_app.config["LANGUAGES"] = {"en": {"flag": "us", "name": "English"}}
         appbuilder_parent_dir = os.path.join(
             os.path.dirname(os.path.abspath(__file__)), os.pardir
         )
         appbuilder_translations_path = os.path.join(
             appbuilder_parent_dir, "translations"
         )
-        if "BABEL_TRANSLATION_DIRECTORIES" in app.config:
-            current_translation_directories = app.config.get(
+        if "BABEL_TRANSLATION_DIRECTORIES" in current_app.config:
+            current_translation_directories = current_app.config.get(
                 "BABEL_TRANSLATION_DIRECTORIES"
             )
             translations_path = (
@@ -33,9 +30,8 @@ class BabelManager(BaseManager):
             )
         else:
             translations_path = appbuilder_translations_path + ";translations"
-        app.config["BABEL_TRANSLATION_DIRECTORIES"] = translations_path
-        self.babel = Babel(app)
-        self.babel.locale_selector_func = self.get_locale
+        current_app.config["BABEL_TRANSLATION_DIRECTORIES"] = translations_path
+        self.babel = Babel(current_app, locale_selector=self.get_locale)
 
     def register_views(self):
         self.locale_view = LocaleView()
@@ -43,11 +39,11 @@ class BabelManager(BaseManager):
 
     @property
     def babel_default_locale(self):
-        return self.appbuilder.get_app.config["BABEL_DEFAULT_LOCALE"]
+        return current_app.config["BABEL_DEFAULT_LOCALE"]
 
     @property
     def languages(self):
-        return self.appbuilder.get_app.config["LANGUAGES"]
+        return current_app.config["LANGUAGES"]
 
     def get_locale(self):
         if has_request_context():