MindsDB 25.9.1.2__py3-none-any.whl → 25.9.3rc1__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.9.1.2"
+__version__ = "25.9.3rc1"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/__main__.py

@@ -8,8 +8,8 @@ import atexit
 import signal
 import psutil
 import asyncio
-import traceback
 import threading
+import shutil
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import Callable, Optional, Tuple, List
@@ -39,6 +39,7 @@ from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_mar
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.auth import register_oauth_client, get_aws_meta_data
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
+from mindsdb.utilities.api_status import set_api_status
 
 try:
     import torch.multiprocessing as mp
@@ -152,6 +153,16 @@ def close_api_gracefully(trunc_processes_struct):
         sys.exit(0)
 
 
+def clean_mindsdb_tmp_dir():
+    """Clean the MindsDB tmp dir at exit."""
+    temp_dir = config["paths"]["tmp"]
+    for file in temp_dir.iterdir():
+        if file.is_dir():
+            shutil.rmtree(file)
+        else:
+            file.unlink()
+
+
 def set_error_model_status_by_pids(unexisting_pids: List[int]):
     """Models have id of its traiing process in the 'training_metadata' field.
     If the pid does not exist, we should set the model status to "error".
@@ -217,19 +228,20 @@ def create_permanent_integrations():
     """
     integration_name = "files"
     existing = db.session.query(db.Integration).filter_by(name=integration_name, company_id=None).first()
-    if existing is None:
-        integration_record = db.Integration(
-            name=integration_name,
-            data={},
-            engine=integration_name,
-            company_id=None,
-        )
-        db.session.add(integration_record)
-        try:
-            db.session.commit()
-        except Exception as e:
-            logger.error(f"Failed to commit permanent integration {integration_name}: {e}")
-            db.session.rollback()
+    if existing is not None:
+        return
+    integration_record = db.Integration(
+        name=integration_name,
+        data={},
+        engine=integration_name,
+        company_id=None,
+    )
+    db.session.add(integration_record)
+    try:
+        db.session.commit()
+    except Exception:
+        logger.exception(f"Failed to create permanent integration '{integration_name}' in the internal database.")
+        db.session.rollback()
 
 
 def validate_default_project() -> None:
@@ -289,7 +301,7 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
         )
         trunc_process_data.process.start()
     except Exception as e:
-        logger.error(f"Failed to start {trunc_process_data.name} API with exception {e}\n{traceback.format_exc()}")
+        logger.exception(f"Failed to start '{trunc_process_data.name}' API process due to unexpected error:")
         close_api_gracefully(trunc_processes_struct)
         raise e
 
@@ -363,8 +375,8 @@ if __name__ == "__main__":
     if environment == "aws_marketplace":
         try:
             register_oauth_client()
-        except Exception as e:
-            logger.error(f"Something went wrong during client register: {e}")
+        except Exception:
+            logger.exception("Something went wrong during client register:")
     elif environment != "local":
         try:
             aws_meta_data = get_aws_meta_data()
@@ -384,6 +396,7 @@ if __name__ == "__main__":
     logger.info(f"Version: {mindsdb_version}")
     logger.info(f"Configuration file: {config.config_path or 'absent'}")
     logger.info(f"Storage path: {config.paths['root']}")
+    log.log_system_info(logger)
     logger.debug(f"User config: {config.user_config}")
     logger.debug(f"System config: {config.auto_config}")
     logger.debug(f"Env config: {config.env_config}")
@@ -391,13 +404,12 @@ if __name__ == "__main__":
     is_cloud = config.is_cloud
     unexisting_pids = clean_unlinked_process_marks()
     if not is_cloud:
-        logger.debug("Applying database migrations")
         try:
             from mindsdb.migrations import migrate
 
             migrate.migrate_to_head()
-        except Exception as e:
-            logger.error(f"Error! Something went wrong during DB migrations: {e}")
+        except Exception:
+            logger.exception("Failed to apply database migrations. This may prevent MindsDB from operating correctly:")
 
         validate_default_project()
 
@@ -484,8 +496,12 @@ if __name__ == "__main__":
         if trunc_process_data.started is True or trunc_process_data.need_to_run is False:
             continue
         start_process(trunc_process_data)
+        # Set status for APIs without ports (they don't go through wait_api_start)
+        if trunc_process_data.port is None:
+            set_api_status(trunc_process_data.name, True)
 
     atexit.register(close_api_gracefully, trunc_processes_struct=trunc_processes_struct)
+    atexit.register(clean_mindsdb_tmp_dir)
 
     async def wait_api_start(api_name, pid, port):
         timeout = 60
@@ -494,6 +510,9 @@ if __name__ == "__main__":
         while (time.time() - start_time) < timeout and started is False:
             await asyncio.sleep(0.5)
             started = is_pid_listen_port(pid, port)
+
+        set_api_status(api_name, started)
+
         return api_name, port, started
 
     async def wait_apis_start():

mindsdb/api/a2a/agent.py

@@ -73,17 +73,15 @@ class MindsDBAgent:
                     "parts": [{"type": "text", "text": error_msg}],
                 }
         except requests.exceptions.RequestException as e:
-            error_msg = f"Error connecting to MindsDB: {str(e)}"
-            logger.error(error_msg)
+            logger.exception("Error connecting to MindsDB:")
             return {
-                "content": error_msg,
+                "content": f"Error connecting to MindsDB: {e}",
                 "parts": [{"type": "text", "text": error_msg}],
             }
         except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            logger.error(error_msg)
+            logger.exception("Error: ")
             return {
-                "content": error_msg,
+                "content": f"Error: {e}",
                 "parts": [{"type": "text", "text": error_msg}],
             }
 
@@ -102,7 +100,7 @@ class MindsDBAgent:
                         try:
                             yield json.loads(payload)
                         except Exception as e:
-                            logger.error(f"Failed to parse SSE JSON payload: {e}; line: {payload}")
+                            logger.exception(f"Failed to parse SSE JSON payload: {e}; line: {payload}")
                     # Ignore comments or control lines
                 # Signal the end of the stream
                 yield {"is_task_complete": True}
@@ -129,13 +127,13 @@ class MindsDBAgent:
                 wrapped_chunk = {"is_task_complete": False, "content": content_value, "metadata": {}}
                 yield wrapped_chunk
         except Exception as e:
-            logger.error(f"Error in streaming: {str(e)}")
+            logger.exception(f"Error in streaming: {e}")
             yield {
                 "is_task_complete": True,
                 "parts": [
                     {
                         "type": "text",
-                        "text": f"Error: {str(e)}",
+                        "text": f"Error: {e}",
                     }
                 ],
                 "metadata": {

mindsdb/api/a2a/common/server/server.py

@@ -118,7 +118,7 @@ class A2AServer:
         elif isinstance(e, ValidationError):
             json_rpc_error = InvalidRequestError(data=json.loads(e.json()))
         else:
-            logger.error(f"Unhandled exception: {e}")
+            logger.exception("Unhandled exception:")
             json_rpc_error = InternalError()
 
         response = JSONRPCResponse(id=None, error=json_rpc_error)
@@ -137,8 +137,8 @@ class A2AServer:
                         else:
                             data = json.dumps(item)
                     except Exception as e:
-                        logger.error(f"Serialization error in SSE stream: {e}")
-                        data = json.dumps({"error": f"Serialization error: {str(e)}"})
+                        logger.exception("Serialization error in SSE stream:")
+                        data = json.dumps({"error": f"Serialization error: {e}"})
                     yield {"data": data}
 
             # Add robust SSE headers for compatibility

mindsdb/api/a2a/common/server/task_manager.py

@@ -152,8 +152,8 @@ class InMemoryTaskManager(TaskManager):
                 task_notification_params.id,
                 task_notification_params.pushNotificationConfig,
             )
-        except Exception as e:
-            logger.error(f"Error while setting push notification info: {e}")
+        except Exception:
+            logger.exception("Error while setting push notification info:")
             return JSONRPCResponse(
                 id=request.id,
                 error=InternalError(message="An error occurred while setting push notification info"),
@@ -169,8 +169,8 @@ class InMemoryTaskManager(TaskManager):
 
         try:
             notification_info = await self.get_push_notification_info(task_params.id)
-        except Exception as e:
-            logger.error(f"Error while getting push notification info: {e}")
+        except Exception:
+            logger.exception("Error while getting push notification info:")
             return GetTaskPushNotificationResponse(
                 id=request.id,
                 error=InternalError(message="An error occurred while getting push notification info"),

mindsdb/api/a2a/task_manager.py

@@ -1,4 +1,8 @@
-from typing import AsyncIterable, Dict
+import time
+import logging
+import asyncio
+from typing import AsyncIterable, Dict, Union
+
 from mindsdb.api.a2a.common.types import (
     SendTaskRequest,
     TaskSendParams,
@@ -20,11 +24,6 @@ from mindsdb.api.a2a.common.server.task_manager import InMemoryTaskManager
 from mindsdb.api.a2a.agent import MindsDBAgent
 from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 
-from typing import Union
-import logging
-import asyncio
-import time
-import traceback
 
 logger = logging.getLogger(__name__)
 
@@ -80,11 +79,11 @@ class AgentTaskManager(InMemoryTaskManager):
             task = await self.upsert_task(task_send_params)
             logger.info(f"Task created/updated with history length: {len(task.history) if task.history else 0}")
         except Exception as e:
-            logger.error(f"Error creating task: {str(e)}")
+            logger.exception("Error creating task:")
             error_result = to_serializable(
                 {
                     "id": request.id,
-                    "error": to_serializable(InternalError(message=f"Error creating task: {str(e)}")),
+                    "error": to_serializable(InternalError(message=f"Error creating task: {e}")),
                 }
             )
             yield error_result
@@ -149,14 +148,14 @@ class AgentTaskManager(InMemoryTaskManager):
                 return
 
             except Exception as e:
-                logger.error(f"Error invoking agent: {e}")
+                logger.exception("Error invoking agent:")
                 error_result = to_serializable(
                     {
                         "id": request.id,
                         "error": to_serializable(
                             JSONRPCResponse(
                                 id=request.id,
-                                error=to_serializable(InternalError(message=f"Error invoking agent: {str(e)}")),
+                                error=to_serializable(InternalError(message=f"Error invoking agent: {e}")),
                             )
                         ),
                     }
@@ -182,11 +181,10 @@ class AgentTaskManager(InMemoryTaskManager):
                     item["artifact"]["parts"] = [to_serializable(p) for p in item["artifact"]["parts"]]
                 yield to_serializable(item)
         except Exception as e:
-            logger.error(f"An error occurred while streaming the response: {e}")
-            logger.error(traceback.format_exc())
-            error_text = f"An error occurred while streaming the response: {str(e)}"
+            error_text = "An error occurred while streaming the response:"
+            logger.exception(error_text)
             # Ensure all parts are plain dicts
-            parts = [{"type": "text", "text": error_text}]
+            parts = [{"type": "text", "text": f"{error_text} {e}"}]
             parts = [to_serializable(part) for part in parts]
             artifact = {
                 "parts": parts,
@@ -333,11 +331,11 @@ class AgentTaskManager(InMemoryTaskManager):
                 yield response
         except Exception as e:
             # If an error occurs, yield an error response
-            logger.error(f"Error in on_send_task_subscribe: {str(e)}")
+            logger.exception(f"Error in on_send_task_subscribe: {e}")
             error_result = to_serializable(
                 {
                     "id": request.id,
-                    "error": to_serializable(InternalError(message=f"Error processing streaming request: {str(e)}")),
+                    "error": to_serializable(InternalError(message=f"Error processing streaming request: {e}")),
                 }
             )
             yield error_result
@@ -463,7 +461,7 @@ class AgentTaskManager(InMemoryTaskManager):
                 )
                 return to_serializable(SendTaskResponse(id=request.id, result=task))
         except Exception as e:
-            logger.error(f"Error invoking agent: {e}")
+            logger.exception("Error invoking agent:")
             result_text = f"Error invoking agent: {e}"
             parts = [{"type": "text", "text": result_text}]
 

mindsdb/api/common/middleware.py

@@ -1,13 +1,13 @@
+import os
+import hmac
+import secrets
+import hashlib
+from http import HTTPStatus
+from typing import Optional
+
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
-from http import HTTPStatus
-from typing import Optional
-import secrets
-import hmac
-import hashlib
-import os
-import traceback
 
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
@@ -100,7 +100,5 @@ def check_auth(username, password, scramble_func, salt, company_id, config):
 
         logger.info(f"Check auth, user={username}: Ok")
         return {"success": True, "username": username}
-    except Exception as e:
-        logger.error(f"Check auth, user={username}: ERROR")
-        logger.error(e)
-        logger.error(traceback.format_exc())
+    except Exception:
+        logger.exception(f"Check auth, user={username}: ERROR")

mindsdb/api/executor/command_executor.py

@@ -757,8 +757,6 @@ class ExecuteCommands:
         except EntityNotExistsError:
             if statement.if_exists is False:
                 raise
-        except Exception as e:
-            raise e
 
         return ExecuteAnswer()
 
@@ -844,7 +842,7 @@ class ExecuteCommands:
         try:
             sqlquery = SQLQuery(statement.data, session=self.session, database=database_name)
         except Exception as e:
-            raise Exception(f'Nested query failed to execute with error: "{e}", please check and try again.')
+            raise Exception(f'Nested query failed to execute with error: "{e}", please check and try again.') from e
         df = sqlquery.fetched_data.to_df()
         df.columns = [str(t.alias) if hasattr(t, "alias") else str(t.parts[-1]) for t in statement.data.targets]
 
@@ -1210,7 +1208,7 @@ class ExecuteCommands:
             ast_drop = DropMLEngine(name=Identifier(name))
             self.answer_drop_ml_engine(ast_drop)
             logger.info(msg)
-            raise ExecutorException(msg)
+            raise ExecutorException(msg) from e
 
         return ExecuteAnswer()
 

mindsdb/api/executor/datahub/datanodes/datanode.py

@@ -4,7 +4,7 @@ from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 
 
 class DataNode:
-    type = 'meta'
+    type = "meta"
 
     def __init__(self):
         pass
@@ -21,5 +21,5 @@ class DataNode:
     def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
         pass
 
-    def query(self, query=None, native_query=None, session=None) -> DataHubResponse:
+    def query(self, query=None, session=None) -> DataHubResponse:
         pass

mindsdb/api/executor/datahub/datanodes/integration_datanode.py

@@ -1,5 +1,6 @@
 import time
 import inspect
+import functools
 from dataclasses import astuple
 from typing import Iterable, List
 
@@ -20,7 +21,7 @@ from mindsdb.integrations.utilities.utils import get_class_name
 from mindsdb.metrics import metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.profiler import profiler
-from mindsdb.utilities.exception import format_db_error_message
+from mindsdb.utilities.exception import QueryError
 from mindsdb.api.executor.datahub.datanodes.system_tables import infer_mysql_type
 
 logger = log.getLogger(__name__)
@@ -30,6 +31,51 @@ class DBHandlerException(Exception):
     pass
 
 
+def collect_metrics(func):
+    """Decorator for collecting performance metrics if integration handler query.
+
+    The decorator measures:
+    - Query execution time using high-precision performance counter
+    - Response size (number of rows returned)
+
+    Args:
+        func: The function to be decorated (integration handler method)
+
+    Returns:
+        function: Wrapped function that includes metrics collection and error handling
+    """
+
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        try:
+            time_before_query = time.perf_counter()
+            result = func(self, *args, **kwargs)
+
+            # metrics
+            handler_class_name = get_class_name(self.integration_handler)
+            elapsed_seconds = time.perf_counter() - time_before_query
+            query_time_with_labels = metrics.INTEGRATION_HANDLER_QUERY_TIME.labels(handler_class_name, result.type)
+            query_time_with_labels.observe(elapsed_seconds)
+
+            num_rows = 0
+            if result.data_frame is not None:
+                num_rows = len(result.data_frame.index)
+            response_size_with_labels = metrics.INTEGRATION_HANDLER_RESPONSE_SIZE.labels(
+                handler_class_name, result.type
+            )
+            response_size_with_labels.observe(num_rows)
+            logger.debug(f"Handler '{handler_class_name}' returned {num_rows} rows in {elapsed_seconds:.3f} seconds")
+        except Exception as e:
+            msg = str(e).strip()
+            if msg == "":
+                msg = e.__class__.__name__
+            msg = f"[{self.ds_type}/{self.integration_name}]: {msg}"
+            raise DBHandlerException(msg) from e
+        return result
+
+    return wrapper
+
+
 class IntegrationDataNode(DataNode):
     type = "integration"
 
@@ -46,16 +92,10 @@ class IntegrationDataNode(DataNode):
         response = self.integration_handler.get_tables()
         if response.type == RESPONSE_TYPE.TABLE:
             result_dict = response.data_frame.to_dict(orient="records")
-            result = []
-            for row in result_dict:
-                result.append(TablesRow.from_dict(row))
-            return result
+            return [TablesRow.from_dict(row) for row in result_dict]
         else:
             raise Exception(f"Can't get tables: {response.error_message}")
 
-        result_dict = response.data_frame.to_dict(orient="records")
-        return [TablesRow.from_dict(row) for row in result_dict]
-
     def get_table_columns_df(self, table_name: str, schema_name: str | None = None) -> pd.DataFrame:
         """Get a DataFrame containing representation of information_schema.columns for the specified table.
 
@@ -214,50 +254,54 @@ class IntegrationDataNode(DataNode):
         return self.integration_handler.query_stream(query, fetch_size=fetch_size)
 
     @profiler.profile()
-    def query(self, query: ASTNode | None = None, native_query: str | None = None, session=None) -> DataHubResponse:
-        try:
-            time_before_query = time.perf_counter()
-            if query is not None:
-                result: HandlerResponse = self.integration_handler.query(query)
-            else:
-                # try to fetch native query
-                result: HandlerResponse = self.integration_handler.native_query(native_query)
+    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+        """Execute a query against the integration data source.
 
-            # metrics
-            elapsed_seconds = time.perf_counter() - time_before_query
-            query_time_with_labels = metrics.INTEGRATION_HANDLER_QUERY_TIME.labels(
-                get_class_name(self.integration_handler), result.type
-            )
-            query_time_with_labels.observe(elapsed_seconds)
+        This method processes SQL queries either as ASTNode objects or raw SQL strings
 
-            num_rows = 0
-            if result.data_frame is not None:
-                num_rows = len(result.data_frame.index)
-            response_size_with_labels = metrics.INTEGRATION_HANDLER_RESPONSE_SIZE.labels(
-                get_class_name(self.integration_handler), result.type
-            )
-            response_size_with_labels.observe(num_rows)
-        except Exception as e:
-            msg = str(e).strip()
-            if msg == "":
-                msg = e.__class__.__name__
-            msg = f"[{self.ds_type}/{self.integration_name}]: {msg}"
-            raise DBHandlerException(msg) from e
+        Args:
+            query (ASTNode | str, optional): The query to execute. Can be either:
+                - ASTNode: A parsed SQL query object
+                - str: Raw SQL query string
+            session: Session object (currently unused but kept for compatibility)
+
+        Returns:
+            DataHubResponse: Response object
+
+        Raises:
+            NotImplementedError: If query is not ASTNode or str type
+            Exception: If the query execution fails with an error response
+        """
+        if isinstance(query, ASTNode):
+            result: HandlerResponse = self.query_integration_handler(query=query)
+        elif isinstance(query, str):
+            result: HandlerResponse = self.native_query_integration(query=query)
+        else:
+            raise NotImplementedError("Thew query argument must be ASTNode or string type")
 
         if result.type == RESPONSE_TYPE.ERROR:
-            failed_sql_query = native_query
-            if query is not None:
-                failed_sql_query = query.to_string()
-
-            raise Exception(
-                format_db_error_message(
-                    db_name=self.integration_handler.name,
-                    db_type=self.integration_handler.__class__.name,
-                    db_error_msg=result.error_message,
-                    failed_query=failed_sql_query,
-                )
+            if isinstance(query, ASTNode):
+                try:
+                    query_str = query.to_string()
+                except Exception:
+                    # most likely it is CreateTable with exotic column types
+                    query_str = "can't be dump"
+            else:
+                query_str = query
+
+            exception = QueryError(
+                db_name=self.integration_handler.name,
+                db_type=self.integration_handler.__class__.name,
+                db_error_msg=result.error_message,
+                failed_query=query_str,
+                is_acceptable=result.is_acceptable_error,
             )
 
+            if result.exception is None:
+                raise exception
+            else:
+                raise exception from result.exception
+
         if result.type == RESPONSE_TYPE.OK:
             return DataHubResponse(affected_rows=result.affected_rows)
 
@@ -271,8 +315,8 @@ class IntegrationDataNode(DataNode):
             # replace python's Nan, np.NaN, np.nan and pd.NA to None
             # TODO keep all NAN to the end of processing, bacause replacing also changes dtypes
             df.replace([np.NaN, pd.NA, pd.NaT], None, inplace=True)
-        except Exception as e:
-            logger.error(f"Issue with clearing DF from NaN values: {e}")
+        except Exception:
+            logger.exception("Issue with clearing DF from NaN values:")
         # endregion
 
         columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
@@ -280,3 +324,11 @@ class IntegrationDataNode(DataNode):
         return DataHubResponse(
             data_frame=df, columns=columns_info, affected_rows=result.affected_rows, mysql_types=result.mysql_types
         )
+
+    @collect_metrics
+    def query_integration_handler(self, query: ASTNode) -> HandlerResponse:
+        return self.integration_handler.query(query)
+
+    @collect_metrics
+    def native_query_integration(self, query: str) -> HandlerResponse:
+        return self.integration_handler.native_query(query)

mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -2,6 +2,7 @@ from copy import deepcopy
 from dataclasses import astuple
 
 import pandas as pd
+from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb_sql_parser import parse_sql
 from mindsdb_sql_parser.ast import (
     BinaryOperation,
@@ -99,9 +100,9 @@ class ProjectDataNode(DataNode):
 
         return ml_handler.predict(model_name, df, project_name=self.project.name, version=version, params=params)
 
-    def query(self, query=None, native_query=None, session=None) -> DataHubResponse:
-        if query is None and native_query is not None:
-            query = parse_sql(native_query)
+    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+        if isinstance(query, str):
+            query = parse_sql(query)
 
         if isinstance(query, Update):
             query_table = query.table.parts[0].lower()
@@ -132,7 +133,10 @@ class ProjectDataNode(DataNode):
                 case [query_table, str(version)], [is_quoted, _] if version.isdigit():
                     ...
                 case _:
-                    raise ValueError("Table name should contain only one part")
+                    raise EntityNotExistsError(
+                        f"Table '{query.from_table}' not found in the database. The project database support only single-part names",
+                        self.project.name,
+                    )
 
             if not is_quoted:
                 query_table = query_table.lower()

mindsdb/api/executor/datahub/datanodes/system_tables.py

@@ -131,7 +131,7 @@ class TablesTable(Table):
                     row.TABLE_SCHEMA = ds_name
                     data.append(row.to_list())
             except Exception:
-                logger.error(f"Can't get tables from '{ds_name}'")
+                logger.exception(f"Can't get tables from '{ds_name}'")
 
         for project_name in inf_schema.get_projects_names():
             if databases is not None and project_name not in databases: