MindsDB 25.9.2.0a1__py3-none-any.whl → 25.9.3rc1__py3-none-any.whl

mindsdb/api/http/namespaces/agents.py

@@ -1,6 +1,5 @@
 import os
 import json
-import traceback
 from http import HTTPStatus
 from typing import Dict, Iterable, List
 
@@ -307,10 +306,10 @@ def _completion_event_generator(agent_name: str, messages: List[Dict], project_n
 
         logger.info("Completion stream finished")
 
-    except Exception as e:
-        logger.error(f"Error in completion event generator: {e}")
-        logger.error(traceback.format_exc())
-        yield json_serialize({"error": "error in completion event generator"})
+    except Exception:
+        error_message = "Error in completion event generator"
+        logger.exception(error_message)
+        yield json_serialize({"error": error_message})
 
     finally:
         yield json_serialize({"type": "end"})
@@ -337,12 +336,12 @@ class AgentCompletionsStream(Resource):
         try:
             existing_agent = session.agents_controller.get_agent(agent_name, project_name=project_name)
             if existing_agent is None:
-                logger.error(f"Agent {agent_name} not found in project {project_name}")
+                logger.warning(f"Agent {agent_name} not found in project {project_name}")
                 return http_error(
                     HTTPStatus.NOT_FOUND, "Agent not found", f"Agent with name {agent_name} does not exist"
                 )
         except ValueError as e:
-            logger.error(f"Project {project_name} not found: {str(e)}")
+            logger.warning(f"Project {project_name} not found: {e}")
             return http_error(
                 HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
@@ -352,10 +351,9 @@ class AgentCompletionsStream(Resource):
             logger.info(f"Starting streaming response for agent {agent_name}")
             return Response(gen, mimetype="text/event-stream")
         except Exception as e:
-            logger.error(f"Error during streaming for agent {agent_name}: {str(e)}")
-            logger.error(traceback.format_exc())
+            logger.exception(f"Error during streaming for agent {agent_name}:")
             return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, "Streaming error", f"An error occurred during streaming: {str(e)}"
+                HTTPStatus.INTERNAL_SERVER_ERROR, "Streaming error", f"An error occurred during streaming: {e}"
             )
 
 
@@ -416,8 +414,8 @@ class AgentCompletions(Resource):
                     last_context = completion.iloc[-1]["context"]
                     if last_context:
                         context = json.loads(last_context)
-                except (json.JSONDecodeError, IndexError) as e:
-                    logger.error(f"Error decoding context: {e}")
+                except (json.JSONDecodeError, IndexError):
+                    logger.warning("Error decoding context:", exc_info=True)
                     pass  # Keeping context as an empty list in case of error
 
             response["message"]["context"] = context

mindsdb/api/http/namespaces/analysis.py

@@ -36,6 +36,7 @@ def analyze_df(df: DataFrame) -> dict:
     df.columns = cols
 
     from dataprep_ml.insights import analyze_dataset
+
     analysis = analyze_dataset(df)
     return analysis.to_dict()
 
@@ -43,7 +44,7 @@ def analyze_df(df: DataFrame) -> dict:
 @ns_conf.route("/query")
 class QueryAnalysis(Resource):
     @ns_conf.doc("post_query_to_analyze")
-    @api_endpoint_metrics('POST', '/analysis/query')
+    @api_endpoint_metrics("POST", "/analysis/query")
     def post(self):
         data = request.json
         query = data.get("query")
@@ -67,10 +68,8 @@ class QueryAnalysis(Resource):
         try:
             result = mysql_proxy.process_query(query)
         except Exception as e:
-            import traceback
-
-            logger.error(traceback.format_exc())
-            return http_error(500, "Error", str(e))
+            logger.exception("Error during query analysis:")
+            return http_error(500, "Error", f"Unexpected error duting query analysis: {e}")
 
         if result.type == SQL_RESPONSE_TYPE.ERROR:
             return http_error(500, f"Error {result.error_code}", result.error_message)
@@ -83,14 +82,12 @@ class QueryAnalysis(Resource):
             analysis = analyze_df(df)
         except ImportError:
             return {
-                'analysis': {},
-                'timestamp': time.time(),
-                'error': 'To use this feature, please install the "dataprep_ml" package.'
+                "analysis": {},
+                "timestamp": time.time(),
+                "error": 'To use this feature, please install the "dataprep_ml" package.',
             }
 
-        query_tables = [
-            table.to_string() for table in get_query_tables(ast)
-        ]
+        query_tables = [table.to_string() for table in get_query_tables(ast)]
 
         return {
             "analysis": analysis,
@@ -104,7 +101,7 @@ class QueryAnalysis(Resource):
 @ns_conf.route("/data")
 class DataAnalysis(Resource):
     @ns_conf.doc("post_data_to_analyze")
-    @api_endpoint_metrics('POST', '/analysis/data')
+    @api_endpoint_metrics("POST", "/analysis/data")
     def post(self):
         payload = request.json
         column_names = payload.get("column_names")
@@ -116,15 +113,11 @@ class DataAnalysis(Resource):
             return {"analysis": analysis, "timestamp": time.time()}
         except ImportError:
             return {
-                'analysis': {},
-                'timestamp': timestamp,
-                'error': 'To use this feature, please install the "dataprep_ml" package.'
+                "analysis": {},
+                "timestamp": timestamp,
+                "error": 'To use this feature, please install the "dataprep_ml" package.',
             }
         except Exception as e:
             # Don't want analysis exceptions to show up on UI.
             # TODO: Fix analysis so it doesn't throw exceptions at all.
-            return {
-                'analysis': {},
-                'timestamp': timestamp,
-                'error': str(e)
-            }
+            return {"analysis": {}, "timestamp": timestamp, "error": str(e)}

mindsdb/api/http/namespaces/auth.py

@@ -117,7 +117,7 @@ class Auth(Resource):
             if resp.status_code != 200:
                 logger.warning(f"Wrong response from cloud server: {resp.status_code}")
         except Exception as e:
-            logger.warning(f"Cant't send request to cloud server: {e}")
+            logger.warning(f"Cant't send request to cloud server: {e}", exc_info=True)
 
         if request.path.endswith("/auth/callback/cloud_home"):
             return redirect(f"https://{auth_server}")

mindsdb/api/http/namespaces/config.py

@@ -11,6 +11,7 @@ from flask import current_app as ca
 from mindsdb.api.http.namespaces.configs.config import ns_conf
 from mindsdb.api.http.utils import http_error
 from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.utilities.api_status import get_api_status
 from mindsdb.utilities import log
 from mindsdb.utilities.functions import decrypt, encrypt
 from mindsdb.utilities.config import Config
@@ -32,6 +33,13 @@ class GetConfig(Resource):
             value = config.get(key)
             if value is not None:
                 resp[key] = value
+
+        api_status = get_api_status()
+        api_configs = copy.deepcopy(config["api"])
+        for api_name, api_config in api_configs.items():
+            api_config["running"] = api_status.get(api_name, False)
+        resp["api"] = api_configs
+
         return resp
 
     @ns_conf.doc("put_config")
@@ -163,9 +171,7 @@ class Integration(Resource):
             )
 
         try:
-            engine = params["type"]
-            if engine is not None:
-                del params["type"]
+            engine = params.pop("type", None)
             params.pop("publish", False)
             storage = params.pop("storage", None)
             ca.integration_controller.add(name, engine, params)
@@ -178,10 +184,10 @@ class Integration(Resource):
                 handler.handler_storage.import_files(export)
 
         except Exception as e:
-            logger.error(str(e))
+            logger.exception("An error occurred during the creation of the integration:")
             if temp_dir is not None:
                 shutil.rmtree(temp_dir)
-            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during config update: {str(e)}")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during config update: {e}")
 
         if temp_dir is not None:
             shutil.rmtree(temp_dir)
@@ -198,8 +204,8 @@ class Integration(Resource):
         try:
             ca.integration_controller.delete(name)
         except Exception as e:
-            logger.error(str(e))
-            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration delete: {str(e)}")
+            logger.exception("An error occurred while deleting the integration")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration delete: {e}")
         return "", 200
 
     @ns_conf.doc("modify_integration")
@@ -223,8 +229,6 @@ class Integration(Resource):
             ca.integration_controller.modify(name, params)
 
         except Exception as e:
-            logger.error(str(e))
-            return http_error(
-                HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration modification: {str(e)}"
-            )
+            logger.exception("An error occurred while modifying the integration")
+            return http_error(HTTPStatus.INTERNAL_SERVER_ERROR, "Error", f"Error during integration modification: {e}")
         return "", 200