MindsDB 25.7.2.0__py3-none-any.whl → 25.7.4.0__py3-none-any.whl

mindsdb/api/http/namespaces/tree.py

@@ -9,97 +9,105 @@ from mindsdb.api.http.namespaces.configs.tree import ns_conf
 from mindsdb.metrics.metrics import api_endpoint_metrics
 
 
-@ns_conf.route('/')
+@ns_conf.route("/")
 class GetRoot(Resource):
-    @ns_conf.doc('get_tree_root')
-    @api_endpoint_metrics('GET', '/tree')
+    @ns_conf.doc("get_tree_root")
+    @api_endpoint_metrics("GET", "/tree")
     def get(self):
         databases = ca.database_controller.get_list()
-        result = [{
-            'name': x['name'],
-            'class': 'db',
-            'type': x['type'],
-            'engine': x['engine'],
-            'deletable': x['deletable'],
-            'visible': x['visible']
-        } for x in databases]
+        result = [
+            {
+                "name": x["name"],
+                "class": "db",
+                "type": x["type"],
+                "engine": x["engine"],
+                "deletable": x["deletable"],
+                "visible": x["visible"],
+            }
+            for x in databases
+        ]
         return result
 
 
-@ns_conf.route('/<db_name>')
-@ns_conf.param('db_name', "Name of the database")
+@ns_conf.route("/<db_name>")
+@ns_conf.param("db_name", "Name of the database")
 class GetLeaf(Resource):
-    @ns_conf.doc('get_tree_leaf')
-    @api_endpoint_metrics('GET', '/tree/database')
+    @ns_conf.doc("get_tree_leaf")
+    @api_endpoint_metrics("GET", "/tree/database")
     def get(self, db_name):
-        with_schemas = request.args.get('all_schemas')
+        with_schemas = request.args.get("all_schemas")
         if isinstance(with_schemas, str):
-            with_schemas = with_schemas.lower() in ('1', 'true')
+            with_schemas = with_schemas.lower() in ("1", "true")
         else:
             with_schemas = False
         db_name = db_name.lower()
         databases = ca.database_controller.get_dict()
         if db_name not in databases:
-            return http_error(
-                400,
-                "Error",
-                f"There is no element with name '{db_name}'"
-            )
+            return http_error(400, "Error", f"There is no element with name '{db_name}'")
         db = databases[db_name]
-        if db['type'] == 'project':
+        if db["type"] == "project":
             project = ca.database_controller.get_project(db_name)
             tables = project.get_tables()
-            tables = [{
-                'name': key,
-                'schema': None,
-                'class': 'table',
-                'type': val['type'],
-                'engine': val.get('engine'),
-                'deletable': val.get('deletable')
-            } for key, val in tables.items()]
-        elif db['type'] == 'data':
+            tables = [
+                {
+                    "name": key,
+                    "schema": None,
+                    "class": "table",
+                    "type": val["type"],
+                    "engine": val.get("engine"),
+                    "deletable": val.get("deletable"),
+                }
+                for key, val in tables.items()
+            ]
+
+            jobs = ca.jobs_controller.get_list(db_name)
+            tables = tables + [
+                {"name": job["name"], "schema": None, "class": "job", "type": "job", "engine": "job", "deletable": True}
+                for job in jobs
+            ]
+        elif db["type"] == "data":
             handler = ca.integration_controller.get_data_handler(db_name)
-            if 'all' in inspect.signature(handler.get_tables).parameters:
+            if "all" in inspect.signature(handler.get_tables).parameters:
                 response = handler.get_tables(all=with_schemas)
             else:
                 response = handler.get_tables()
-            if response.type != 'table':
+            if response.type != "table":
                 return []
-            table_types = {
-                'BASE TABLE': 'table',
-                'VIEW': 'view'
-            }
-            tables = response.data_frame.to_dict(orient='records')
+            table_types = {"BASE TABLE": "table", "VIEW": "view"}
+            tables = response.data_frame.to_dict(orient="records")
 
             schemas = defaultdict(list)
 
             for table_meta in tables:
                 table_meta = {key.lower(): val for key, val in table_meta.items()}
-                schama = table_meta.get('table_schema')
-                schemas[schama].append({
-                    'name': table_meta['table_name'],
-                    'class': 'table',
-                    'type': table_types.get(table_meta.get('table_type')),
-                    'engine': None,
-                    'deletable': False
-                })
+                schama = table_meta.get("table_schema")
+                schemas[schama].append(
+                    {
+                        "name": table_meta["table_name"],
+                        "class": "table",
+                        "type": table_types.get(table_meta.get("table_type")),
+                        "engine": None,
+                        "deletable": False,
+                    }
+                )
             if len(schemas) == 1 and list(schemas.keys())[0] is None:
                 tables = schemas[None]
             else:
-                tables = [{
-                    'name': key,
-                    'class': 'schema',
-                    'deletable': False,
-                    'children': val
-                } for key, val in schemas.items()]
-        elif db['type'] == 'system':
+                tables = [
+                    {"name": key, "class": "schema", "deletable": False, "children": val}
+                    for key, val in schemas.items()
+                ]
+        elif db["type"] == "system":
             system_db = ca.database_controller.get_system_db(db_name)
             tables = system_db.get_tree_tables()
-            tables = [{
-                'name': table.name,
-                'class': table.kind,
-                'type': 'system view',
-                'engine': None,
-                'deletable': table.deletable,
-            } for table in tables.values()]
+            tables = [
+                {
+                    "name": table.name,
+                    "class": table.kind,
+                    "type": "system view",
+                    "engine": None,
+                    "deletable": table.deletable,
+                }
+                for table in tables.values()
+            ]
         return tables

mindsdb/api/mcp/start.py

@@ -15,6 +15,7 @@ from starlette.responses import Response
 from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
 from mindsdb.utilities import log
+from mindsdb.utilities.log import get_uvicorn_logging_config
 from mindsdb.utilities.config import Config
 from mindsdb.interfaces.storage import db
 
@@ -173,6 +174,7 @@ async def run_sse_async() -> None:
         host=mcp.settings.host,
         port=mcp.settings.port,
         log_level=mcp.settings.log_level.lower(),
+        log_config=get_uvicorn_logging_config("uvicorn_mcp"),
     )
     server = uvicorn.Server(config)
     await server.serve()

mindsdb/api/mysql/mysql_proxy/utilities/dump.py

@@ -118,8 +118,9 @@ def _dump_str(var: Any) -> str | None:
             return json_encoder.encode(var)
         except Exception:
             return str(var)
-    if isinstance(var, list) is False and pd.isna(var):
-        # pd.isna returns array of bools for list, so we need to check if it is not a list
+    # pd.isna returns array of bools for list
+    # and the truth value of a numpy array is ambiguous
+    if isinstance(var, (list, np.ndarray)) is False and pd.isna(var):
         return None
     return str(var)
 

mindsdb/integrations/handlers/autogluon_handler/requirements.txt

@@ -1,2 +1,2 @@
 autogluon
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/autosklearn_handler/requirements.txt

@@ -1,2 +1,2 @@
 auto-sklearn
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py

@@ -1,8 +1,10 @@
-from google.cloud.bigquery import Client, QueryJobConfig
-from google.api_core.exceptions import BadRequest
+import json
+from typing import Any, Dict, Optional, Text
+
+from google.cloud.bigquery import Client, QueryJobConfig, DEFAULT_RETRY
+from google.api_core.exceptions import BadRequest, NotFound
 import pandas as pd
 from sqlalchemy_bigquery.base import BigQueryDialect
-from typing import Any, Dict, Optional, Text
 
 from mindsdb.utilities import log
 from mindsdb_sql_parser.ast.base import ASTNode
@@ -54,9 +56,22 @@ class BigQueryHandler(MetaDatabaseHandler):
         if not all(key in self.connection_data for key in ["project_id", "dataset"]):
             raise ValueError("Required parameters (project_id, dataset) must be provided.")
 
+        service_account_json = self.connection_data.get("service_account_json")
+        if isinstance(service_account_json, str):
+            # GUI send it as str
+            try:
+                service_account_json = json.loads(service_account_json)
+            except json.decoder.JSONDecodeError:
+                raise ValueError("'service_account_json' is not valid JSON")
+        if isinstance(service_account_json, dict) and isinstance(service_account_json.get("private_key"), str):
+            # some editors may escape new line symbol, also replace windows-like newlines
+            service_account_json["private_key"] = (
+                service_account_json["private_key"].replace("\\n", "\n").replace("\r\n", "\n")
+            )
+
         google_sa_oauth2_manager = GoogleServiceAccountOAuth2Manager(
             credentials_file=self.connection_data.get("service_account_keys"),
-            credentials_json=self.connection_data.get("service_account_json"),
+            credentials_json=service_account_json,
         )
         credentials = google_sa_oauth2_manager.get_oauth2_credentials()
 
@@ -85,7 +100,7 @@ class BigQueryHandler(MetaDatabaseHandler):
 
         try:
             connection = self.connect()
-            connection.query("SELECT 1;")
+            connection.query("SELECT 1;", timeout=10, retry=DEFAULT_RETRY.with_deadline(10))
 
             # Check if the dataset exists
             connection.get_dataset(self.connection_data["dataset"])
@@ -94,6 +109,11 @@ class BigQueryHandler(MetaDatabaseHandler):
         except (BadRequest, ValueError) as e:
             logger.error(f"Error connecting to BigQuery {self.connection_data['project_id']}, {e}!")
             response.error_message = e
+        except NotFound:
+            response.error_message = (
+                f"Error connecting to BigQuery {self.connection_data['project_id']}: "
+                f"dataset '{self.connection_data['dataset']}' not found"
+            )
 
         if response.success is False and self.is_connected is True:
             self.is_connected = False

mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py

@@ -59,6 +59,7 @@ class ChromaDBHandler(VectorStoreHandler):
         self._client = None
         self.persist_directory = None
         self.is_connected = False
+        self._use_handler_storage = False
 
         config = self.validate_connection_parameters(name, **kwargs)
 
@@ -72,8 +73,6 @@ class ChromaDBHandler(VectorStoreHandler):
             "hnsw:space": config.distance,
         }
 
-        self._use_handler_storage = False
-
         self.connect()
 
     def validate_connection_parameters(self, name, **kwargs):
@@ -395,7 +394,7 @@ class ChromaDBHandler(VectorStoreHandler):
 
         return df
 
-    def insert(self, collection_name: str, df: pd.DataFrame):
+    def insert(self, collection_name: str, df: pd.DataFrame) -> Response:
         """
         Insert/Upsert data into ChromaDB collection.
         If records with same IDs exist, they will be updated.
@@ -433,6 +432,7 @@ class ChromaDBHandler(VectorStoreHandler):
         except Exception as e:
             logger.error(f"Error during upsert operation: {str(e)}")
             raise Exception(f"Failed to insert/update data: {str(e)}")
+        return Response(RESPONSE_TYPE.OK, affected_rows=len(df))
 
     def upsert(self, table_name: str, data: pd.DataFrame):
         """

mindsdb/integrations/handlers/flaml_handler/requirements.txt

@@ -1,2 +1,2 @@
 flaml<=1.2.3
-type_infer==0.0.20
+type_infer==0.0.23

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_tables.py

@@ -9,7 +9,6 @@ from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditio
 
 
 class GoogleCalendarEventsTable(APITable):
-
     def select(self, query: ast.Select) -> DataFrame:
         """
         Gets all events from the calendar.
@@ -26,33 +25,33 @@ class GoogleCalendarEventsTable(APITable):
         # Get the start and end times from the conditions.
         params = {}
         for op, arg1, arg2 in conditions:
-            if arg1 == 'timeMax' or arg1 == 'timeMin':
+            if arg1 == "timeMax" or arg1 == "timeMin":
                 date = parse_utc_date(arg2)
-                if op == '=':
+                if op == "=":
                     params[arg1] = date
                 else:
                     raise NotImplementedError
-            elif arg1 == 'timeZone':
+            elif arg1 == "timeZone":
                 params[arg1] = arg2
-            elif arg1 == 'maxAttendees':
+            elif arg1 == "maxAttendees":
                 params[arg1] = arg2
-            elif arg1 == 'q':
+            elif arg1 == "q":
                 params[arg1] = arg2
 
         # Get the order by from the query.
         if query.order_by is not None:
-            if query.order_by[0].value == 'start_time':
-                params['orderBy'] = 'startTime'
-            elif query.order_by[0].value == 'updated':
-                params['orderBy'] = 'updated'
+            if query.order_by[0].value == "start_time":
+                params["orderBy"] = "startTime"
+            elif query.order_by[0].value == "updated":
+                params["orderBy"] = "updated"
             else:
                 raise NotImplementedError
 
         if query.limit is not None:
-            params['maxResults'] = query.limit.value
+            params["maxResults"] = query.limit.value
 
         # Get the events from the Google Calendar API.
-        events = self.handler.call_application_api(method_name='get_events', params=params)
+        events = self.handler.call_application_api(method_name="get_events", params=params)
 
         selected_columns = []
         for target in query.targets:
@@ -87,9 +86,20 @@ class GoogleCalendarEventsTable(APITable):
         values = query.values[0]
         # Get the event data from the values.
         event_data = {}
-        timestamp_columns = {'start_time', 'end_time', 'created', 'updated'}
-        regular_columns = {'summary', 'description', 'location', 'status', 'html_link',
-                           'creator', 'organizer', 'reminders', 'timeZone', 'calendar_id', 'attendees'}
+        timestamp_columns = {"start_time", "end_time", "created", "updated"}
+        regular_columns = {
+            "summary",
+            "description",
+            "location",
+            "status",
+            "html_link",
+            "creator",
+            "organizer",
+            "reminders",
+            "timeZone",
+            "calendar_id",
+            "attendees",
+        }
 
         # TODO: check why query.columns is None
         for col, val in zip(query.columns, values):
@@ -100,24 +110,18 @@ class GoogleCalendarEventsTable(APITable):
             else:
                 raise NotImplementedError
 
-        st = datetime.datetime.utcfromtimestamp(event_data['start_time'] / 1000).isoformat() + 'Z'
-        et = datetime.datetime.utcfromtimestamp(event_data['end_time'] / 1000).isoformat() + 'Z'
+        st = datetime.datetime.fromtimestamp(event_data["start_time"] / 1000, datetime.timezone.utc).isoformat() + "Z"
+        et = datetime.datetime.fromtimestamp(event_data["end_time"] / 1000, datetime.timezone.utc).isoformat() + "Z"
 
-        event_data['start'] = {
-            'dateTime': st,
-            'timeZone': event_data['timeZone']
-        }
+        event_data["start"] = {"dateTime": st, "timeZone": event_data["timeZone"]}
 
-        event_data['end'] = {
-            'dateTime': et,
-            'timeZone': event_data['timeZone']
-        }
+        event_data["end"] = {"dateTime": et, "timeZone": event_data["timeZone"]}
 
-        event_data['attendees'] = event_data['attendees'].split(',')
-        event_data['attendees'] = [{'email': attendee} for attendee in event_data['attendees']]
+        event_data["attendees"] = event_data["attendees"].split(",")
+        event_data["attendees"] = [{"email": attendee} for attendee in event_data["attendees"]]
 
         # Insert the event into the Google Calendar API.
-        self.handler.call_application_api(method_name='create_event', params=event_data)
+        self.handler.call_application_api(method_name="create_event", params=event_data)
 
     def update(self, query: ast.Update):
         """
@@ -135,44 +139,48 @@ class GoogleCalendarEventsTable(APITable):
         # Get the event data from the values.
         event_data = {}
         for col, val in zip(query.update_columns, values):
-            if col == 'start_time' or col == 'end_time' or col == 'created' or col == 'updated':
+            if col == "start_time" or col == "end_time" or col == "created" or col == "updated":
                 event_data[col] = utc_date_str_to_timestamp_ms(val)
-            elif col == 'summary' or col == 'description' or col == 'location' or col == 'status' or col == 'html_link' \
-                    or col == 'creator' or col == 'organizer' or col == 'reminders' \
-                    or col == 'timeZone' or col == 'calendar_id' or col == 'attendees':
+            elif (
+                col == "summary"
+                or col == "description"
+                or col == "location"
+                or col == "status"
+                or col == "html_link"
+                or col == "creator"
+                or col == "organizer"
+                or col == "reminders"
+                or col == "timeZone"
+                or col == "calendar_id"
+                or col == "attendees"
+            ):
                 event_data[col] = val
             else:
                 raise NotImplementedError
 
-        event_data['start'] = {
-            'dateTime': event_data['start_time'],
-            'timeZone': event_data['timeZone']
-        }
+        event_data["start"] = {"dateTime": event_data["start_time"], "timeZone": event_data["timeZone"]}
 
-        event_data['end'] = {
-            'dateTime': event_data['end_time'],
-            'timeZone': event_data['timeZone']
-        }
+        event_data["end"] = {"dateTime": event_data["end_time"], "timeZone": event_data["timeZone"]}
 
-        event_data['attendees'] = event_data.get('attendees').split(',')
-        event_data['attendees'] = [{'email': attendee} for attendee in event_data['attendees']]
+        event_data["attendees"] = event_data.get("attendees").split(",")
+        event_data["attendees"] = [{"email": attendee} for attendee in event_data["attendees"]]
 
         conditions = extract_comparison_conditions(query.where)
         for op, arg1, arg2 in conditions:
-            if arg1 == 'event_id':
-                if op == '=':
-                    event_data['event_id'] = arg2
-                elif op == '>':
-                    event_data['start_id'] = arg2
-                elif op == '<':
-                    event_data['end_id'] = arg2
+            if arg1 == "event_id":
+                if op == "=":
+                    event_data["event_id"] = arg2
+                elif op == ">":
+                    event_data["start_id"] = arg2
+                elif op == "<":
+                    event_data["end_id"] = arg2
                 else:
                     raise NotImplementedError
             else:
                 raise NotImplementedError
 
         # Update the event in the Google Calendar API.
-        self.handler.call_application_api(method_name='update_event', params=event_data)
+        self.handler.call_application_api(method_name="update_event", params=event_data)
 
     def delete(self, query: ast.Delete):
         """
@@ -190,35 +198,36 @@ class GoogleCalendarEventsTable(APITable):
         # Get the start and end times from the conditions.
         params = {}
         for op, arg1, arg2 in conditions:
-            if arg1 == 'event_id':
-                if op == '=':
+            if arg1 == "event_id":
+                if op == "=":
                     params[arg1] = arg2
-                elif op == '>':
-                    params['start_id'] = arg2
-                elif op == '<':
-                    params['end_id'] = arg2
+                elif op == ">":
+                    params["start_id"] = arg2
+                elif op == "<":
+                    params["end_id"] = arg2
                 else:
                     raise NotImplementedError
 
         # Delete the events in the Google Calendar API.
-        self.handler.call_application_api(method_name='delete_event', params=params)
+        self.handler.call_application_api(method_name="delete_event", params=params)
 
     def get_columns(self) -> list:
         """Gets all columns to be returned in pandas DataFrame responses"""
         return [
-            'etag',
-            'id',
-            'status',
-            'htmlLink',
-            'created',
-            'updated',
-            'summary',
-            'creator',
-            'organizer',
-            'start',
-            'end',
-            'timeZone',
-            'iCalUID',
-            'sequence',
-            'reminders',
-            'eventType']
+            "etag",
+            "id",
+            "status",
+            "htmlLink",
+            "created",
+            "updated",
+            "summary",
+            "creator",
+            "organizer",
+            "start",
+            "end",
+            "timeZone",
+            "iCalUID",
+            "sequence",
+            "reminders",
+            "eventType",
+        ]

mindsdb/integrations/handlers/hubspot_handler/requirements.txt

@@ -1 +1 @@
-hubspot-api-client
+hubspot-api-client==11.1.0