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

flask_appbuilder/models/base.py

@@ -3,9 +3,7 @@ from functools import reduce
 import logging
 from typing import Any, Type
 
-from flask_babel import lazy_gettext
-
-from .filters import BaseFilterConverter, Filters
+from flask_appbuilder.models.filters import BaseFilterConverter, Filters
 
 try:
     import enum
@@ -17,36 +15,25 @@ except ImportError:
 log = logging.getLogger(__name__)
 
 
-class BaseInterface(object):
+class BaseInterface:
     """
-        Base class for all data model interfaces.
-        Sub class it to implement your own interface for some data engine.
+    Base class for all data model interfaces.
+    Sub class it to implement your own interface for some data engine.
     """
 
     filter_converter_class = Type[BaseFilterConverter]
     """ when sub classing override with your own custom filter converter """
 
-    """ Messages to display on CRUD Events """
-    add_row_message = lazy_gettext("Added Row")
-    edit_row_message = lazy_gettext("Changed Row")
-    delete_row_message = lazy_gettext("Deleted Row")
-    delete_integrity_error_message = lazy_gettext(
-        "Associated data exists, please delete them first"
-    )
-    add_integrity_error_message = lazy_gettext(
-        "Integrity error, probably unique constraint"
-    )
-    edit_integrity_error_message = lazy_gettext(
-        "Integrity error, probably unique constraint"
-    )
-    general_error_message = lazy_gettext("General Error")
-
-    """ Tuple with message and text with severity type ex: ("Added Row", "info") """
-    message = ()
-
     def __init__(self, obj: Type[Any]):
         self.obj = obj
 
+    # def __getattr__(self, name: str) -> Any:
+    #     """
+    #     Make mypy happy about the injected filters like self.datamodel.FilterEqual
+    #     https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html#when-you-re-puzzled-or-when-things-are-complicated
+    #     """
+    #     return super().__getattr__(name)
+
     def _get_attr(self, col_name):
         if not hasattr(self.obj, col_name):
             # it's an inner obj attr
@@ -96,13 +83,13 @@ class BaseInterface(object):
 
     def _get_values(self, lst, list_columns):
         """
-            Get Values: formats values for list template.
-            returns [{'col_name':'col_value',....},{'col_name':'col_value',....}]
+        Get Values: formats values for list template.
+        returns [{'col_name':'col_value',....},{'col_name':'col_value',....}]
 
-            :param lst:
-                The list of item objects from query
-            :param list_columns:
-                The list of columns to include
+        :param lst:
+            The list of item objects from query
+        :param list_columns:
+            The list of columns to include
         """
         retlst = []
         for item in lst:
@@ -114,13 +101,13 @@ class BaseInterface(object):
 
     def get_values(self, lst, list_columns):
         """
-            Get Values: formats values for list template.
-            returns [{'col_name':'col_value',....},{'col_name':'col_value',....}]
+        Get Values: formats values for list template.
+        returns [{'col_name':'col_value',....},{'col_name':'col_value',....}]
 
-            :param lst:
-                The list of item objects from query
-            :param list_columns:
-                The list of columns to include
+        :param lst:
+            The list of item objects from query
+        :param list_columns:
+            The list of columns to include
         """
         for item in lst:
             retdict = {}
@@ -130,7 +117,7 @@ class BaseInterface(object):
 
     def get_values_json(self, lst, list_columns):
         """
-            Converts list of objects from query to JSON
+        Converts list of objects from query to JSON
         """
         result = []
         for item in self.get_values(lst, list_columns):
@@ -210,6 +197,9 @@ class BaseInterface(object):
     def is_enum(self, col_name):
         return False
 
+    def is_json(self, col_name):
+        return False
+
     def is_relation(self, prop):
         return False
 
@@ -238,7 +228,7 @@ class BaseInterface(object):
         return False
 
     def is_pk_composite(self):
-        raise False
+        return False
 
     def is_fk(self, col_name):
         return False
@@ -255,30 +245,30 @@ class BaseInterface(object):
     -----------------------------------------
     """
 
-    def add(self, item):
+    def add(self, item: Any, commit: bool = True) -> None:
         """
-            Adds object
+        Adds object
         """
         raise NotImplementedError
 
-    def edit(self, item):
+    def edit(self, item: Any, commit: bool = True) -> None:
         """
-            Edit (change) object
+        Edit (change) object
         """
         raise NotImplementedError
 
-    def delete(self, item):
+    def delete(self, item: Any, commit: bool = True) -> None:
         """
-            Deletes object
+        Deletes object
         """
         raise NotImplementedError
 
-    def get_col_default(self, col_name):
+    def get_col_default(self, col_name: str):
         pass
 
     def get_keys(self, lst):
         """
-            return a list of pk values from object list
+        return a list of pk values from object list
         """
         pk_name = self.get_pk_name()
         if self.is_pk_composite():
@@ -288,7 +278,7 @@ class BaseInterface(object):
 
     def get_pk_name(self):
         """
-            Returns the primary key name
+        Returns the primary key name
         """
         raise NotImplementedError
 
@@ -301,8 +291,8 @@ class BaseInterface(object):
 
     def get(self, pk, filter=None):
         """
-            return the record from key, you can optionally pass filters
-            if pk exits on the db but filters exclude it it will return none.
+        return the record from key, you can optionally pass filters
+        if pk exits on the db but filters exclude it it will return none.
         """
         pass
 
@@ -311,11 +301,11 @@ class BaseInterface(object):
 
     def get_related_interface(self, col_name):
         """
-            Returns a BaseInterface for the related model
-            of column name.
+        Returns a BaseInterface for the related model
+        of column name.
 
-            :param col_name: Column name with relation
-            :return: BaseInterface
+        :param col_name: Column name with relation
+        :return: BaseInterface
         """
         raise NotImplementedError
 
@@ -327,25 +317,25 @@ class BaseInterface(object):
 
     def get_columns_list(self):
         """
-            Returns a list of all the columns names
+        Returns a list of all the columns names
         """
         return []
 
     def get_user_columns_list(self):
         """
-            Returns a list of user viewable columns names
+        Returns a list of user viewable columns names
         """
         return self.get_columns_list()
 
     def get_search_columns_list(self):
         """
-            Returns a list of searchable columns names
+        Returns a list of searchable columns names
         """
         return []
 
     def get_order_columns_list(self, list_columns=None):
         """
-            Returns a list of order columns names
+        Returns a list of order columns names
         """
         return []
 

flask_appbuilder/models/decorators.py

@@ -1,21 +1,21 @@
 def renders(col_name):
     """
-        Use this decorator to map your custom Model properties to actual
-        Model db properties. As an example::
+    Use this decorator to map your custom Model properties to actual
+    Model db properties. As an example::
 
-            class MyModel(Model):
-                id = Column(Integer, primary_key=True)
-                name = Column(String(50), unique = True, nullable=False)
-                custom = Column(Integer(20))
+        class MyModel(Model):
+            id = Column(Integer, primary_key=True)
+            name = Column(String(50), unique = True, nullable=False)
+            custom = Column(Integer(20))
 
-                @renders('custom')
-                def my_custom(self):
-                    # will render this columns as bold on ListWidget
-                    return Markup('<b>' + custom + '</b>')
+            @renders('custom')
+            def my_custom(self):
+                # will render this columns as bold on ListWidget
+                return Markup('<b>' + self.custom + '</b>')
 
-            class MyModelView(ModelView):
-                datamodel = SQLAInterface(MyTable)
-                list_columns = ['name', 'my_custom']
+        class MyModelView(ModelView):
+            datamodel = SQLAInterface(MyTable)
+            list_columns = ['name', 'my_custom']
 
     """
 

flask_appbuilder/models/filters.py

@@ -14,10 +14,10 @@ map_args_filter = {}
 """ private map for arg_name and child Filter classes """
 
 
-class BaseFilter(object):
+class BaseFilter:
     """
-        Base class for all data filters.
-        Sub class to implement your own custom filters
+    Base class for all data filters.
+    Sub class to implement your own custom filters
     """
 
     column_name = ""
@@ -39,14 +39,14 @@ class BaseFilter(object):
 
     def __init__(self, column_name, datamodel, is_related_view=False):
         """
-            Constructor.
-
-            :param column_name:
-                Model field name
-            :param datamodel:
-                The datamodel access class
-            :param is_related_view:
-                Optional internal parameter to filter related views
+        Constructor.
+
+        :param column_name:
+            Model field name
+        :param datamodel:
+            The datamodel access class
+        :param is_related_view:
+            Optional internal parameter to filter related views
         """
         self.column_name = column_name
         self.datamodel = datamodel
@@ -57,7 +57,7 @@ class BaseFilter(object):
 
     def apply(self, query, value):
         """
-            Override this to implement your own new filters
+        Override this to implement your own new filters
         """
         raise NotImplementedError
 
@@ -67,21 +67,21 @@ class BaseFilter(object):
 
 class FilterRelation(BaseFilter):
     """
-        Base class for all filters for relations
+    Base class for all filters for relations
     """
 
     def apply(self, query, value):
         """
-            Override this to implement your own new filters
+        Override this to implement your own new filters
         """
         raise NotImplementedError
 
 
 class BaseFilterConverter:
     """
-        Base Filter Converter, all classes responsible
-        for the association of columns and possible filters
-        will inherit from this and override the conversion_table property.
+    Base Filter Converter, all classes responsible
+    for the association of columns and possible filters
+    will inherit from this and override the conversion_table property.
 
     """
 
@@ -114,10 +114,10 @@ class BaseFilterConverter:
         for conversion in self.conversion_table:
             if getattr(self.datamodel, conversion[0])(col_name):
                 return [item(col_name, self.datamodel) for item in conversion[1]]
-        log.warning("Filter type not supported for column: %s" % col_name)
+        log.warning("Filter type not supported for column: %s", col_name)
 
 
-class Filters(object):
+class Filters:
     filters: List[BaseFilter] = []
     """ List of instantiated BaseFilter classes """
     values: List[Any] = []
@@ -135,11 +135,11 @@ class Filters(object):
     ):
         """
 
-            :param filter_converter: Accepts BaseFilterConverter class
-            :param search_columns: restricts possible columns,
-                    accepts a list of column names
-            :param search_filters: Add custom defined filters to specific columns
-            :param datamodel: Accepts BaseInterface class
+        :param filter_converter: Accepts BaseFilterConverter class
+        :param search_columns: restricts possible columns,
+                accepts a list of column names
+        :param search_filters: Add custom defined filters to specific columns
+        :param datamodel: Accepts BaseInterface class
         """
         self.search_columns = search_columns or []
         self.filter_converter = filter_converter
@@ -168,9 +168,9 @@ class Filters(object):
         self.filters = []
         self.values = []
 
-    def _add_filter(self, filter_instance, value):
+    def _add_filter(self, filter_instance, values):
         self.filters.append(filter_instance)
-        self.values.append(value)
+        self.values.append(values)
 
     def add_filter_index(
         self, column_name: str, filter_instance_index: int, value: Any
@@ -226,7 +226,7 @@ class Filters(object):
                 return True
         return False
 
-    def add_filter(self, column_name, filter_class, value):
+    def add_filter(self, column_name: str, filter_class: BaseFilter, value: str):
         self._add_filter(filter_class(column_name, self.datamodel), value)
         return self
 
@@ -240,9 +240,9 @@ class Filters(object):
             self._add_filter(filter_class(column_name, self.datamodel), value)
         return self
 
-    def get_joined_filters(self, filters):
+    def get_joined_filters(self, filters) -> "Filters":
         """
-            Creates a new filters class with active filters joined
+        Creates a new filters class with active filters joined
         """
         ret_filters = Filters(self.filter_converter, self.datamodel)
         ret_filters.filters = self.filters + filters.filters
@@ -251,9 +251,9 @@ class Filters(object):
 
     def copy(self):
         """
-            Returns a copy of this object
+        Returns a copy of this object
 
-            :return: A copy of self
+        :return: A copy of self
         """
         retfilters = Filters(self.filter_converter, self.datamodel)
         retfilters.filters = copy.copy(self.filters)
@@ -262,7 +262,7 @@ class Filters(object):
 
     def get_relation_cols(self):
         """
-            Returns the filter active FilterRelation cols
+        Returns the filter active FilterRelation cols
         """
         retlst = []
         for flt, value in zip(self.filters, self.values):
@@ -272,16 +272,16 @@ class Filters(object):
 
     def get_filters_values(self) -> List[Tuple[BaseFilter, Any]]:
         """
-            Returns a list of tuples [(FILTER, value),(...,...),....]
+        Returns a list of tuples [(FILTER, value),(...,...),....]
         """
         return [(flt, value) for flt, value in zip(self.filters, self.values)]
 
     def get_filter_value(self, column_name: str) -> Any:
         """
-            Returns the filtered value for a certain column
+        Returns the filtered value for a certain column
 
-            :param column_name: The name of the column that we want the value from
-            :return: the filter value of the column
+        :param column_name: The name of the column that we want the value from
+        :return: the filter value of the column
         """
         for flt, value in zip(self.filters, self.values):
             if flt.column_name == column_name:
@@ -294,8 +294,12 @@ class Filters(object):
         ]
 
     def apply_all(self, query):
-        for flt, value in zip(self.filters, self.values):
-            query = flt.apply(query, value)
+        for flt, values in zip(self.filters, self.values):
+            if isinstance(values, list) and flt.arg_name not in {"in", "not_in"}:
+                for value in values:
+                    query = flt.apply(query, value)
+            else:
+                query = flt.apply(query, values)
         return query
 
     def __repr__(self):

flask_appbuilder/models/generic/__init__.py

@@ -35,13 +35,13 @@ class GenericColumn(object):
 
 class MetaGenericModel(type):
     """
-        Meta class for GenericModel
-        will change default properties:
-        - instantiates internal '_col_defs' dict with
-            all the defined columns.
-        - Define pk property with the name of the primary key column
-        - Define properties with a list of all column's properties
-        - Define columns with a list of all column's name
+    Meta class for GenericModel
+    will change default properties:
+    - instantiates internal '_col_defs' dict with
+        all the defined columns.
+    - Define pk property with the name of the primary key column
+    - Define properties with a list of all column's properties
+    - Define columns with a list of all column's name
     """
 
     pk = None
@@ -68,18 +68,18 @@ class MetaGenericModel(type):
 
 class GenericModel(with_metaclass(MetaGenericModel, object)):
     """
-        Generic Model class to define generic purpose models to use
-        with the framework.
+    Generic Model class to define generic purpose models to use
+    with the framework.
 
-        Use GenericSession much like SQLAlchemy's Session Class.
-        Extend GenericSession to implement specific engine features.
+    Use GenericSession much like SQLAlchemy's Session Class.
+    Extend GenericSession to implement specific engine features.
 
-        Define your models like::
+    Define your models like::
 
-            class MyGenericModel(GenericModel):
-                id = GenericColumn(int, primary_key=True)
-                age = GenericColumn(int)
-                name = GenericColumn(str)
+        class MyGenericModel(GenericModel):
+            id = GenericColumn(int, primary_key=True)
+            age = GenericColumn(int)
+            name = GenericColumn(str)
 
     """
 
@@ -111,13 +111,13 @@ class GenericModel(with_metaclass(MetaGenericModel, object)):
 
 class GenericSession(object):
     """
-        This class is a base, you should subclass it
-        to implement your own generic data source.
+    This class is a base, you should subclass it
+    to implement your own generic data source.
 
-        Override at least the **all** method.
+    Override at least the **all** method.
 
-        **GenericSession** will implement filter and orders
-        based on your data generation on the **all** method.
+    **GenericSession** will implement filter and orders
+    based on your data generation on the **all** method.
     """
 
     def __init__(self):
@@ -131,20 +131,20 @@ class GenericSession(object):
 
     def clear(self):
         """
-            Deletes the entire store
+        Deletes the entire store
         """
         self.store = dict()
 
     def delete_all(self, model_cls):
         """
-            Deletes all objects of type model_cls
+        Deletes all objects of type model_cls
         """
         self.store[model_cls._name] = []
 
     def get(self, pk):
         """
-            Returns the object for the key
-            Override it for efficiency.
+        Returns the object for the key
+        Override it for efficiency.
         """
         for item in self.store.get(self.query_class):
             # coverts pk value to correct type
@@ -154,7 +154,7 @@ class GenericSession(object):
 
     def query(self, model_cls):
         """
-            SQLAlchemy query like method
+        SQLAlchemy query like method
         """
         self._filters_cmd = list()
         self.query_filters = list()
@@ -350,8 +350,8 @@ class GenericSession(object):
 
     def all(self):
         """
-            SQLA like 'all' method, will populate all rows and apply all
-            filters and orders to it.
+        SQLA like 'all' method, will populate all rows and apply all
+        filters and orders to it.
         """
         items = list()
         if not self._filters_cmd:
@@ -396,7 +396,7 @@ class PSModel(GenericModel):
 
 class PSSession(GenericSession):
     regexp = (
-        "(\w+) +(\w+) +(\w+) +(\w+) +(\w+:\w+|\w+) (\?|tty\w+) +(\w+:\w+:\w+) +(.+)\n"
+        r"(\w+) +(\w+) +(\w+) +(\w+) +(\w+:\w+|\w+) (\?|tty\w+) +(\w+:\w+:\w+) +(.+)\n"
     )
 
     def add_object(self, line):

flask_appbuilder/models/generic/filters.py

@@ -78,8 +78,8 @@ class FilterStartsWith(BaseFilter):
 
 class GenericFilterConverter(BaseFilterConverter):
     """
-        Class for converting columns into a supported list of filters
-        specific for SQLAlchemy.
+    Class for converting columns into a supported list of filters
+    specific for SQLAlchemy.
 
     """
 
@@ -107,6 +107,14 @@ class GenericFilterConverter(BaseFilterConverter):
                 FilterStartsWith,
             ],
         ),
-        ("is_integer", [FilterEqual, FilterNotEqual, FilterGreater, FilterSmaller]),
+        (
+            "is_integer",
+            [
+                FilterEqual,
+                FilterNotEqual,
+                FilterGreater,
+                FilterSmaller,
+            ],
+        ),
         ("is_date", [FilterEqual, FilterNotEqual, FilterGreater, FilterSmaller]),
     )

flask_appbuilder/models/generic/interface.py

@@ -9,7 +9,6 @@ def _include_filters(obj):
 
 
 class GenericInterface(BaseInterface):
-
     filter_converter_class = filters.GenericFilterConverter
 
     def __init__(self, obj, session=None):
@@ -25,7 +24,6 @@ class GenericInterface(BaseInterface):
         page=None,
         page_size=None,
     ):
-
         query = self.session.query(self.obj)
         if filters:
             query = filters.apply_all(query)
@@ -68,7 +66,7 @@ class GenericInterface(BaseInterface):
 
     def get_keys(self, lst):
         """
-            return a list of pk values from object list
+        return a list of pk values from object list
         """
         pk_name = self.get_pk_name()
         return [getattr(item, pk_name) for item in lst]