MindsDB 25.5.4.1__py3-none-any.whl → 25.6.2.0__py3-none-any.whl

mindsdb/integrations/libs/api_handler.py

@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import Any, List, Optional
 import ast as py_ast
 
 import pandas as pd
@@ -6,26 +6,29 @@ from mindsdb_sql_parser.ast import ASTNode, Select, Insert, Update, Delete, Star
 from mindsdb_sql_parser.ast.select.identifier import Identifier
 
 from mindsdb.integrations.utilities.sql_utils import (
-    extract_comparison_conditions, filter_dataframe, sort_dataframe,
-    FilterCondition, FilterOperator, SortColumn
+    extract_comparison_conditions,
+    filter_dataframe,
+    sort_dataframe,
+    FilterCondition,
+    FilterOperator,
+    SortColumn,
 )
 from mindsdb.integrations.libs.base import BaseHandler
 from mindsdb.integrations.libs.api_handler_exceptions import TableAlreadyExists, TableNotFound
 
-from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
-    RESPONSE_TYPE
-)
+from mindsdb.integrations.libs.response import HandlerResponse as Response, RESPONSE_TYPE
+from mindsdb.utilities import log
 
 
-class FuncParser:
+logger = log.getLogger("mindsdb")
 
-    def from_string(self, query_string):
 
-        body = py_ast.parse(query_string.strip(), mode='eval').body
+class FuncParser:
+    def from_string(self, query_string):
+        body = py_ast.parse(query_string.strip(), mode="eval").body
 
         if not isinstance(body, py_ast.Call):
-            raise RuntimeError(f'Api function not found {query_string}')
+            raise RuntimeError(f"Api function not found {query_string}")
 
         fnc_name = body.func.id
 
@@ -39,7 +42,6 @@ class FuncParser:
         return fnc_name, params
 
     def process(self, node):
-
         if isinstance(node, py_ast.List):
             elements = []
             for node2 in node.elts:
@@ -47,7 +49,6 @@ class FuncParser:
             return elements
 
         if isinstance(node, py_ast.Dict):
-
             keys = []
             for node2 in node.keys:
                 if isinstance(node2, py_ast.Constant):
@@ -55,7 +56,7 @@ class FuncParser:
                 elif isinstance(node2, py_ast.Str):  # py37
                     value = node2.s
                 else:
-                    raise NotImplementedError(f'Unknown dict key {node2}')
+                    raise NotImplementedError(f"Unknown dict key {node2}")
 
                 keys.append(value)
 
@@ -68,11 +69,11 @@ class FuncParser:
         if isinstance(node, py_ast.Name):
             # special attributes
             name = node.id
-            if name == 'true':
+            if name == "true":
                 return True
-            elif name == 'false':
+            elif name == "false":
                 return False
-            elif name == 'null':
+            elif name == "null":
                 return None
 
         if isinstance(node, py_ast.Constant):
@@ -92,11 +93,10 @@ class FuncParser:
                 value = self.process(node.operand)
                 return -value
 
-        raise NotImplementedError(f'Unknown node {node}')
+        raise NotImplementedError(f"Unknown node {node}")
 
 
 class APITable:
-
     def __init__(self, handler):
         self.handler = handler
 
@@ -154,7 +154,6 @@ class APITable:
 
 
 class APIResource(APITable):
-
     def __init__(self, *args, table_name=None, **kwargs):
         self.table_name = table_name
         super().__init__(*args, **kwargs)
@@ -179,26 +178,18 @@ class APIResource(APITable):
         if query.order_by and len(query.order_by) > 0:
             sort = []
             for an_order in query.order_by:
-                sort.append(SortColumn(an_order.field.parts[-1],
-                                       an_order.direction.upper() != 'DESC'))
+                sort.append(SortColumn(an_order.field.parts[-1], an_order.direction.upper() != "DESC"))
 
         targets = []
         for col in query.targets:
             if isinstance(col, Identifier):
                 targets.append(col.parts[-1])
 
-        kwargs = {
-            'conditions': conditions,
-            'limit': limit,
-            'sort': sort,
-            'targets': targets
-        }
+        kwargs = {"conditions": conditions, "limit": limit, "sort": sort, "targets": targets}
         if self.table_name is not None:
-            kwargs['table_name'] = self.table_name
+            kwargs["table_name"] = self.table_name
 
-        result = self.list(
-            **kwargs
-        )
+        result = self.list(**kwargs)
 
         filters = []
         for cond in conditions:
@@ -216,17 +207,18 @@ class APIResource(APITable):
             result = sort_dataframe(result, sort_columns)
 
         if limit is not None and len(result) > limit:
-            result = result[:int(limit)]
+            result = result[: int(limit)]
 
         return result
 
-    def list(self,
-             conditions: List[FilterCondition] = None,
-             limit: int = None,
-             sort: List[SortColumn] = None,
-             targets: List[str] = None,
-             **kwargs
-             ):
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        **kwargs,
+    ):
         """
         List items based on specified conditions, limits, sorting, and targets.
 
@@ -254,13 +246,10 @@ class APIResource(APITable):
 
         columns = [col.name for col in query.columns]
 
-        data = [
-            dict(zip(columns, a_row))
-            for a_row in query.values
-        ]
+        data = [dict(zip(columns, a_row)) for a_row in query.values]
         kwargs = {}
         if self.table_name is not None:
-            kwargs['table_name'] = self.table_name
+            kwargs["table_name"] = self.table_name
 
         self.add(data, **kwargs)
 
@@ -332,10 +321,105 @@ class APIResource(APITable):
         raise NotImplementedError()
 
     def _extract_conditions(self, where: ASTNode) -> List[FilterCondition]:
-        return [
-            FilterCondition(i[1], FilterOperator(i[0].upper()), i[2])
-            for i in extract_comparison_conditions(where)
-        ]
+        return [FilterCondition(i[1], FilterOperator(i[0].upper()), i[2]) for i in extract_comparison_conditions(where)]
+
+
+class MetaAPIResource(APIResource):
+    # TODO: Add a meta_table_info() method in case metadata cannot be retrieved as expected below?
+
+    def meta_get_tables(self, table_name: str, **kwargs) -> dict:
+        """
+        Retrieves table metadata for the API resource.
+
+        Args:
+            table_name (str): The name given to the table that represents the API resource. This is required because the name for the APIResource is given by the handler.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            Dict: The dictionary should contain the following fields:
+            - TABLE_NAME (str): Name of the table.
+            - TABLE_TYPE (str): Type of the table, e.g. 'BASE TABLE', 'VIEW', etc. (optional).
+            - TABLE_SCHEMA (str): Schema of the table (optional).
+            - TABLE_DESCRIPTION (str): Description of the table (optional).
+            - ROW_COUNT (int): Estimated number of rows in the table (optional).
+        """
+        pass
+
+    def meta_get_columns(self, table_name: str, **kwargs) -> List[dict]:
+        """
+        Retrieves column metadata for the API resource.
+
+        Args:
+            table_name (str): The name given to the table that represents the API resource. This is required because the name for the APIResource is given by the handler.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            List[dict]: The list should contain dictionaries with the following fields:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column.
+            - DATA_TYPE (str): Data type of the column, e.g. 'VARCHAR', 'INT', etc.
+            - COLUMN_DESCRIPTION (str): Description of the column (optional).
+            - IS_NULLABLE (bool): Whether the column can contain NULL values (optional).
+            - COLUMN_DEFAULT (str): Default value of the column (optional).
+        """
+        pass
+
+    def meta_get_column_statistics(self, table_name: str, **kwargs) -> List[dict]:
+        """
+        Retrieves column statistics for the API resource.
+
+        Args:
+            table_name (str): The name given to the table that represents the API resource. This is required because the name for the APIResource is given by the handler.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            List[dict]: The list should contain dictionaries with the following fields:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column.
+            - MOST_COMMON_VALUES (List[str]): Most common values in the column (optional).
+            - MOST_COMMON_FREQUENCIES (List[str]): Frequencies of the most common values in the column (optional).
+            - NULL_PERCENTAGE: Percentage of NULL values in the column (optional).
+            - MINIMUM_VALUE (str): Minimum value in the column (optional).
+            - MAXIMUM_VALUE (str): Maximum value in the column (optional).
+            - DISTINCT_VALUES_COUNT (int): Count of distinct values in the column (optional).
+        """
+        pass
+
+    def meta_get_primary_keys(self, table_name: str, **kwargs) -> List[dict]:
+        """
+        Retrieves primary key metadata for the API resource.
+
+        Args:
+            table_name (str): The name given to the table that represents the API resource. This is required because the name for the APIResource is given by the handler.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            List[dict]: The list should contain dictionaries with the following fields:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column that is part of the primary key.
+            - ORDINAL_POSITION (int): Position of the column in the primary key (optional).
+            - CONSTRAINT_NAME (str): Name of the primary key constraint (optional).
+        """
+        pass
+
+    def meta_get_foreign_keys(self, table_name: str, all_tables: List[str], **kwargs) -> List[dict]:
+        """
+        Retrieves foreign key metadata for the API resource.
+
+        Args:
+            table_name (str): The name given to the table that represents the API resource. This is required because the name for the APIResource is given by the handler.
+            all_tables (List[str]): A list of all table names in the API resource. This is used to identify relationships between tables.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            List[dict]: The list should contain dictionaries with the following fields:
+            - PARENT_TABLE_NAME (str): Name of the parent table.
+            - PARENT_COLUMN_NAME (str): Name of the parent column that is part of the foreign key.
+            - CHILD_TABLE_NAME (str): Name of the child table.
+            - CHILD_COLUMN_NAME (str): Name of the child column that is part of the foreign key.
+            - CONSTRAINT_NAME (str): Name of the foreign key constraint (optional).
+        """
+        pass
 
 
 class APIHandler(BaseHandler):
@@ -368,14 +452,13 @@ class APIHandler(BaseHandler):
         """
         name = name.parts[-1]
         if name not in self._tables:
-            raise TableNotFound(f'Table not found: {name}')
+            raise TableNotFound(f"Table not found: {name}")
         return self._tables[name]
 
     def query(self, query: ASTNode):
-
         if isinstance(query, Select):
             table = self._get_table(query.from_table)
-            if not hasattr(table, 'list'):
+            if not hasattr(table, "list"):
                 # for back compatibility, targets wasn't passed in previous version
                 query.targets = [Star()]
             result = self._get_table(query.from_table).select(query)
@@ -406,8 +489,8 @@ class APIHandler(BaseHandler):
 
         result = self._get_table(Identifier(table_name)).get_columns()
 
-        df = pd.DataFrame(result, columns=['Field'])
-        df['Type'] = 'str'
+        df = pd.DataFrame(result, columns=["Field"])
+        df["Type"] = "str"
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
@@ -419,14 +502,135 @@ class APIHandler(BaseHandler):
         """
         result = list(self._tables.keys())
 
-        df = pd.DataFrame(result, columns=['table_name'])
-        df['table_type'] = 'BASE TABLE'
+        df = pd.DataFrame(result, columns=["table_name"])
+        df["table_type"] = "BASE TABLE"
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
 
-class APIChatHandler(APIHandler):
+class MetaAPIHandler(APIHandler):
+    """
+    Base class for handlers associated to the applications APIs (e.g. twitter, slack, discord  etc.)
 
+    This class is used when the handler is also needed to store information in the data catalog.
+    """
+
+    def meta_get_tables(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
+        """
+        Retrieves metadata for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (List): A list of table names for which to retrieve metadata.
+            kwargs: Additional keyword arguments that may be used by the specific API resource implementation.
+
+        Returns:
+            Response: A response object containing the table metadata.
+        """
+        df = pd.DataFrame()
+        for table_name, table_class in self._tables.items():
+            if table_names is None or table_name in table_names:
+                try:
+                    if hasattr(table_class, "meta_get_tables"):
+                        table_metadata = table_class.meta_get_tables(table_name, **kwargs)
+                        df = pd.concat([df, pd.DataFrame([table_metadata])], ignore_index=True)
+                except Exception as e:
+                    logger.error(f"Error retrieving metadata for table {table_name}: {e}")
+
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+    def meta_get_columns(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
+        """
+        Retrieves column metadata for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (List): A list of table names for which to retrieve column metadata.
+
+        Returns:
+            Response: A response object containing the column metadata.
+        """
+        df = pd.DataFrame()
+        for table_name, table_class in self._tables.items():
+            if table_names is None or table_name in table_names:
+                try:
+                    if hasattr(table_class, "meta_get_columns"):
+                        column_metadata = table_class.meta_get_columns(table_name, **kwargs)
+                        df = pd.concat([df, pd.DataFrame(column_metadata)], ignore_index=True)
+                except Exception as e:
+                    logger.error(f"Error retrieving column metadata for table {table_name}: {e}")
+
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+    def meta_get_column_statistics(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
+        """
+        Retrieves column statistics for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (List): A list of table names for which to retrieve column statistics.
+
+        Returns:
+            Response: A response object containing the column statistics.
+        """
+        df = pd.DataFrame()
+        for table_name, table_class in self._tables.items():
+            if table_names is None or table_name in table_names:
+                try:
+                    if hasattr(table_class, "meta_get_column_statistics"):
+                        column_statistics = table_class.meta_get_column_statistics(table_name, **kwargs)
+                        df = pd.concat([df, pd.DataFrame(column_statistics)], ignore_index=True)
+                except Exception as e:
+                    logger.error(f"Error retrieving column statistics for table {table_name}: {e}")
+
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+    def meta_get_primary_keys(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
+        """
+        Retrieves primary key metadata for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (List): A list of table names for which to retrieve primary key metadata.
+
+        Returns:
+            Response: A response object containing the primary key metadata.
+        """
+        df = pd.DataFrame()
+        for table_name, table_class in self._tables.items():
+            if table_names is None or table_name in table_names:
+                try:
+                    if hasattr(table_class, "meta_get_primary_keys"):
+                        primary_key_metadata = table_class.meta_get_primary_keys(table_name, **kwargs)
+                        df = pd.concat([df, pd.DataFrame(primary_key_metadata)], ignore_index=True)
+                except Exception as e:
+                    logger.error(f"Error retrieving primary keys for table {table_name}: {e}")
+
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None, **kwargs) -> Response:
+        """
+        Retrieves foreign key metadata for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (List): A list of table names for which to retrieve foreign key metadata.
+
+        Returns:
+            Response: A response object containing the foreign key metadata.
+        """
+        df = pd.DataFrame()
+        all_tables = list(self._tables.keys())
+        for table_name, table_class in self._tables.items():
+            if table_names is None or table_name in table_names:
+                try:
+                    if hasattr(table_class, "meta_get_foreign_keys"):
+                        foreign_key_metadata = table_class.meta_get_foreign_keys(
+                            table_name, all_tables=table_names if table_names else all_tables, **kwargs
+                        )
+                        df = pd.concat([df, pd.DataFrame(foreign_key_metadata)], ignore_index=True)
+                except Exception as e:
+                    logger.error(f"Error retrieving foreign keys for table {table_name}: {e}")
+
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+
+class APIChatHandler(APIHandler):
     def get_chat_config(self):
         """Return configuration to connect to chatbot
 

mindsdb/integrations/libs/base.py

@@ -14,14 +14,14 @@ logger = log.getLogger(__name__)
 
 
 class BaseHandler:
-    """ Base class for database handlers
+    """Base class for database handlers
 
     Base class for handlers that associate a source of information with the
     broader MindsDB ecosystem via SQL commands.
     """
 
     def __init__(self, name: str):
-        """ constructor
+        """constructor
         Args:
             name (str): the handler name
         """
@@ -29,7 +29,7 @@ class BaseHandler:
         self.name = name
 
     def connect(self):
-        """ Set up any connections required by the handler
+        """Set up any connections required by the handler
 
         Should return connection
 
@@ -37,7 +37,7 @@ class BaseHandler:
         raise NotImplementedError()
 
     def disconnect(self):
-        """ Close any existing connections
+        """Close any existing connections
 
         Should switch self.is_connected.
         """
@@ -45,7 +45,7 @@ class BaseHandler:
         return
 
     def check_connection(self) -> HandlerStatusResponse:
-        """ Check connection to the handler
+        """Check connection to the handler
 
         Returns:
             HandlerStatusResponse
@@ -77,7 +77,7 @@ class BaseHandler:
         raise NotImplementedError()
 
     def get_tables(self) -> HandlerResponse:
-        """ Return list of entities
+        """Return list of entities
 
         Return list of entities that will be accesible as tables.
 
@@ -89,7 +89,7 @@ class BaseHandler:
         raise NotImplementedError()
 
     def get_columns(self, table_name: str) -> HandlerResponse:
-        """ Returns a list of entity columns
+        """Returns a list of entity columns
 
         Args:
             table_name (str): name of one of tables returned by self.get_tables()
@@ -113,6 +113,91 @@ class DatabaseHandler(BaseHandler):
         super().__init__(name)
 
 
+class MetaDatabaseHandler(DatabaseHandler):
+    """
+    Base class for handlers associated to data storage systems (e.g. databases, data warehouses, streaming services, etc.)
+
+    This class is used when the handler is also needed to store information in the data catalog.
+    This information is typically avaiable in the information schema or system tables of the database.
+    """
+
+    def __init__(self, name: str):
+        super().__init__(name)
+
+    def meta_get_tables(self, table_names: Optional[List[str]]) -> HandlerResponse:
+        """
+        Returns metadata information about the tables to be stored in the data catalog.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - TABLE_NAME (str): Name of the table.
+            - TABLE_TYPE (str): Type of the table, e.g. 'BASE TABLE', 'VIEW', etc. (optional).
+            - TABLE_SCHEMA (str): Schema of the table (optional).
+            - TABLE_DESCRIPTION (str): Description of the table (optional).
+            - ROW_COUNT (int): Estimated number of rows in the table (optional).
+        """
+        raise NotImplementedError()
+
+    def meta_get_columns(self, table_names: Optional[List[str]]) -> HandlerResponse:
+        """
+        Returns metadata information about the columns in the tables to be stored in the data catalog.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column.
+            - DATA_TYPE (str): Data type of the column, e.g. 'VARCHAR', 'INT', etc.
+            - COLUMN_DESCRIPTION (str): Description of the column (optional).
+            - IS_NULLABLE (bool): Whether the column can contain NULL values (optional).
+            - COLUMN_DEFAULT (str): Default value of the column (optional).
+        """
+        raise NotImplementedError()
+
+    def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> HandlerResponse:
+        """
+        Returns metadata statisical information about the columns in the tables to be stored in the data catalog.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column.
+            - MOST_COMMON_VALUES (List[str]): Most common values in the column (optional).
+            - MOST_COMMON_FREQUENCIES (List[str]): Frequencies of the most common values in the column (optional).
+            - NULL_PERCENTAGE: Percentage of NULL values in the column (optional).
+            - MINIMUM_VALUE (str): Minimum value in the column (optional).
+            - MAXIMUM_VALUE (str): Maximum value in the column (optional).
+            - DISTINCT_VALUES_COUNT (int): Count of distinct values in the column (optional).
+        """
+        raise NotImplementedError()
+
+    def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> HandlerResponse:
+        """
+        Returns metadata information about the primary keys in the tables to be stored in the data catalog.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - TABLE_NAME (str): Name of the table.
+            - COLUMN_NAME (str): Name of the column that is part of the primary key.
+            - ORDINAL_POSITION (int): Position of the column in the primary key (optional).
+            - CONSTRAINT_NAME (str): Name of the primary key constraint (optional).
+        """
+        raise NotImplementedError()
+
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]]) -> HandlerResponse:
+        """
+        Returns metadata information about the foreign keys in the tables to be stored in the data catalog.
+
+        Returns:
+            HandlerResponse: The response should consist of the following columns:
+            - PARENT_TABLE_NAME (str): Name of the parent table.
+            - PARENT_COLUMN_NAME (str): Name of the parent column that is part of the foreign key.
+            - CHILD_TABLE_NAME (str): Name of the child table.
+            - CHILD_COLUMN_NAME (str): Name of the child column that is part of the foreign key.
+            - CONSTRAINT_NAME (str): Name of the foreign key constraint (optional).
+        """
+        raise NotImplementedError()
+
+
 class ArgProbeMixin:
     """
     A mixin class that provides probing of arguments that
@@ -154,26 +239,16 @@ class ArgProbeMixin:
             self.visit(node.value)
 
         def visit_Subscript(self, node):
-            if (
-                isinstance(node.value, ast.Name)
-                and node.value.id in self.var_names_to_track
-            ):
-                if isinstance(node.slice, ast.Index) and isinstance(
-                    node.slice.value, ast.Str
-                ):
+            if isinstance(node.value, ast.Name) and node.value.id in self.var_names_to_track:
+                if isinstance(node.slice, ast.Index) and isinstance(node.slice.value, ast.Str):
                     self.arg_keys.append({"name": node.slice.value.s, "required": True})
             self.generic_visit(node)
 
         def visit_Call(self, node):
             if isinstance(node.func, ast.Attribute) and node.func.attr == "get":
-                if (
-                    isinstance(node.func.value, ast.Name)
-                    and node.func.value.id in self.var_names_to_track
-                ):
+                if isinstance(node.func.value, ast.Name) and node.func.value.id in self.var_names_to_track:
                     if isinstance(node.args[0], ast.Str):
-                        self.arg_keys.append(
-                            {"name": node.args[0].s, "required": False}
-                        )
+                        self.arg_keys.append({"name": node.args[0].s, "required": False})
             self.generic_visit(node)
 
     @classmethod
@@ -197,9 +272,7 @@ class ArgProbeMixin:
         try:
             source_code = self.get_source_code(method_name)
         except Exception as e:
-            logger.error(
-                f"Failed to get source code of method {method_name} in {self.__class__.__name__}. Reason: {e}"
-            )
+            logger.error(f"Failed to get source code of method {method_name} in {self.__class__.__name__}. Reason: {e}")
             return []
 
         # parse the source code
@@ -238,9 +311,7 @@ class ArgProbeMixin:
         """
         method = getattr(self, method_name)
         if method is None:
-            raise Exception(
-                f"Method {method_name} does not exist in {self.__class__.__name__}"
-            )
+            raise Exception(f"Method {method_name} does not exist in {self.__class__.__name__}")
         source_code = inspect.getsource(method)
         return source_code
 
@@ -288,8 +359,8 @@ class BaseMLEngine(ArgProbeMixin):
         self.engine_storage = engine_storage
         self.generative = False  # if True, the target column name does not have to be specified at creation time
 
-        if kwargs.get('base_model_storage'):
-            self.base_model_storage = kwargs['base_model_storage']  # available when updating a model
+        if kwargs.get("base_model_storage"):
+            self.base_model_storage = kwargs["base_model_storage"]  # available when updating a model
         else:
             self.base_model_storage = None