MindsDB 25.9.2.0a1__py3-none-any.whl → 25.10.0__py3-none-any.whl

mindsdb/integrations/handlers/zendesk_handler/zendesk_tables.py

@@ -34,41 +34,31 @@ class ZendeskUsersTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'users',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "users", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.users(**subset_where_conditions)
+        result = self.handler.zen_client.users(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for user in result:
+                response.append(user.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -85,15 +75,43 @@ class ZendeskUsersTable(APITable):
         """
 
         return [
-            "active", "alias", "chat_only", "created_at", "custom_role_id",
-            "details", "email", "external_id", "id", "last_login_at",
-            "locale", "locale_id", "moderator", "name", "notes",
-            "only_private_comments", "organization_id", "phone", "photo",
-            "restricted_agent", "role", "shared", "shared_agent",
-            "signature", "suspended", "tags", "ticket_restriction",
-            "time_zone", "two_factor_auth_enabled", "updated_at", "url",
-            "verified", "iana_time_zone", "shared_phone_number", "role_type",
-            "default_group_id", "report_csv"
+            "active",
+            "alias",
+            "chat_only",
+            "created_at",
+            "custom_role_id",
+            "details",
+            "email",
+            "external_id",
+            "id",
+            "last_login_at",
+            "locale",
+            "locale_id",
+            "moderator",
+            "name",
+            "notes",
+            "only_private_comments",
+            "organization_id",
+            "phone",
+            "photo",
+            "restricted_agent",
+            "role",
+            "shared",
+            "shared_agent",
+            "signature",
+            "suspended",
+            "tags",
+            "ticket_restriction",
+            "time_zone",
+            "two_factor_auth_enabled",
+            "updated_at",
+            "url",
+            "verified",
+            "iana_time_zone",
+            "shared_phone_number",
+            "role_type",
+            "default_group_id",
+            "report_csv",
         ]
 
 
@@ -119,41 +137,31 @@ class ZendeskTicketsTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'tickets',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "tickets", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.tickets(**subset_where_conditions)
+        result = self.handler.zen_client.tickets(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for ticket in result:
+                response.append(ticket.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -170,20 +178,54 @@ class ZendeskTicketsTable(APITable):
         """
 
         return [
-            "assignee_id", "brand_id", "collaborator_ids", "created_at",
-            "custom_fields", "description", "due_at", "external_id",
-            "fields", "forum_topic_id", "group_id", "has_incidents", "id",
-            "organization_id", "priority", "problem_id", "raw_subject",
-            "recipient", "requester_id", "sharing_agreement_ids", "status",
-            "subject", "submitter_id", "tags", "type", "updated_at", "url",
-            "generated_timestamp", "follower_ids", "email_cc_ids", "is_public",
-            "custom_status_id", "followup_ids", "ticket_form_id",
-            "allow_channelback", "allow_attachments", "from_messaging_channel",
-            "satisfaction_rating.assignee_id", "satisfaction_rating.created_at",
-            "satisfaction_rating.group_id", "satisfaction_rating.id",
-            "satisfaction_rating.requester_id", "satisfaction_rating.score",
-            "satisfaction_rating.ticket_id", "satisfaction_rating.updated_at",
-            "satisfaction_rating.url", "via.channel", "via.source.rel"
+            "assignee_id",
+            "brand_id",
+            "collaborator_ids",
+            "created_at",
+            "custom_fields",
+            "description",
+            "due_at",
+            "external_id",
+            "fields",
+            "forum_topic_id",
+            "group_id",
+            "has_incidents",
+            "id",
+            "organization_id",
+            "priority",
+            "problem_id",
+            "raw_subject",
+            "recipient",
+            "requester_id",
+            "sharing_agreement_ids",
+            "status",
+            "subject",
+            "submitter_id",
+            "tags",
+            "type",
+            "updated_at",
+            "url",
+            "generated_timestamp",
+            "follower_ids",
+            "email_cc_ids",
+            "is_public",
+            "custom_status_id",
+            "followup_ids",
+            "ticket_form_id",
+            "allow_channelback",
+            "allow_attachments",
+            "from_messaging_channel",
+            "satisfaction_rating.assignee_id",
+            "satisfaction_rating.created_at",
+            "satisfaction_rating.group_id",
+            "satisfaction_rating.id",
+            "satisfaction_rating.requester_id",
+            "satisfaction_rating.score",
+            "satisfaction_rating.ticket_id",
+            "satisfaction_rating.updated_at",
+            "satisfaction_rating.url",
+            "via.channel",
+            "via.source.rel",
         ]
 
 
@@ -209,41 +251,31 @@ class ZendeskTriggersTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'triggers',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "triggers", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.triggers(**subset_where_conditions)
+        result = self.handler.zen_client.triggers(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for trigger in result:
+                response.append(trigger.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -260,9 +292,20 @@ class ZendeskTriggersTable(APITable):
         """
 
         return [
-            "actions", "active", "description", "id", "position", "title",
-            "url", "updated_at", "created_at", "default", "raw_title",
-            "category_id", "conditions.all", "conditions.any"
+            "actions",
+            "active",
+            "description",
+            "id",
+            "position",
+            "title",
+            "url",
+            "updated_at",
+            "created_at",
+            "default",
+            "raw_title",
+            "category_id",
+            "conditions.all",
+            "conditions.any",
         ]
 
 
@@ -288,41 +331,31 @@ class ZendeskActivitiesTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'activities',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "activities", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.activities(**subset_where_conditions)
+        result = self.handler.zen_client.activities(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for activity in result:
+                response.append(activity.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -459,5 +492,5 @@ class ZendeskActivitiesTable(APITable):
             "target.ticket.type",
             "target.ticket.updated_at",
             "target.ticket.url",
-            "target.ticket.via"
+            "target.ticket.via",
         ]

mindsdb/integrations/libs/api_handler.py

@@ -550,8 +550,8 @@ class MetaAPIHandler(APIHandler):
                     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}")
+                except Exception:
+                    logger.exception(f"Error retrieving metadata for table {table_name}:")
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
@@ -572,8 +572,8 @@ class MetaAPIHandler(APIHandler):
                     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}")
+                except Exception:
+                    logger.exception(f"Error retrieving column metadata for table {table_name}:")
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
@@ -594,8 +594,8 @@ class MetaAPIHandler(APIHandler):
                     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}")
+                except Exception:
+                    logger.exception(f"Error retrieving column statistics for table {table_name}:")
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
@@ -616,8 +616,8 @@ class MetaAPIHandler(APIHandler):
                     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}")
+                except Exception:
+                    logger.exception(f"Error retrieving primary keys for table {table_name}:")
 
         return Response(RESPONSE_TYPE.TABLE, df)
 
@@ -641,8 +641,8 @@ class MetaAPIHandler(APIHandler):
                             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}")
+                except Exception:
+                    logger.exception(f"Error retrieving foreign keys for table {table_name}:")
 
         return Response(RESPONSE_TYPE.TABLE, df)
 

mindsdb/integrations/libs/base.py

@@ -202,8 +202,8 @@ class MetaDatabaseHandler(DatabaseHandler):
                         logger.error(
                             f"Error retrieving column statistics for table {table_name}: {result.error_message}"
                         )
-                except Exception as e:
-                    logger.error(f"Exception occurred while retrieving column statistics for table {table_name}: {e}")
+                except Exception:
+                    logger.exception(f"Exception occurred while retrieving column statistics for table {table_name}:")
 
             if not results:
                 logger.warning("No column statistics could be retrieved for the specified tables.")
@@ -355,8 +355,8 @@ 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}")
+        except Exception:
+            logger.exception(f"Failed to get source code of method {method_name} in {self.__class__.__name__}. Reason:")
             return []
 
         # parse the source code

mindsdb/integrations/libs/llm/utils.py

@@ -304,10 +304,10 @@ def ft_jsonl_validation(
                     assistant_key=assistant_key,
                 )
             except Exception as e:
-                raise Exception(f"{prefix}{e}")
+                raise Exception(f"{prefix}{e}") from e
 
     except Exception as e:
-        raise Exception(f"Fine-tuning data format is not valid. Got {e}")
+        raise Exception(f"Fine-tuning data format is not valid. Got {e}") from e
 
 
 def ft_chat_format_validation(

mindsdb/integrations/libs/ml_handler_process/create_engine_process.py

@@ -13,16 +13,13 @@ def create_engine_process(connection_args: dict, integration_id: int, module_pat
 
     result = None
 
-    if hasattr(module.Handler, 'create_engine'):
+    if hasattr(module.Handler, "create_engine"):
         engine_storage = HandlerStorage(integration_id)
         try:
-            result = module.Handler(
-                engine_storage=engine_storage,
-                model_storage=None
-            ).create_engine(connection_args=connection_args)
+            result = module.Handler(engine_storage=engine_storage, model_storage=None).create_engine(
+                connection_args=connection_args
+            )
         except NotImplementedError:
             return None
-        except Exception as e:
-            raise e
 
     return result

mindsdb/integrations/libs/ml_handler_process/func_call_process.py

@@ -11,16 +11,11 @@ def func_call_process(name: str, args: dict, integration_id: int, module_path: s
 
     result = None
 
-    if hasattr(module.Handler, 'function_call'):
+    if hasattr(module.Handler, "function_call"):
         engine_storage = HandlerStorage(integration_id)
         try:
-            result = module.Handler(
-                engine_storage=engine_storage,
-                model_storage=None
-            ).function_call(name, args)
+            result = module.Handler(engine_storage=engine_storage, model_storage=None).function_call(name, args)
         except NotImplementedError:
             return None
-        except Exception as e:
-            raise e
 
     return result

mindsdb/integrations/libs/ml_handler_process/learn_process.py

@@ -1,6 +1,5 @@
 import os
 import importlib
-import traceback
 import datetime as dt
 
 from sqlalchemy.orm.attributes import flag_modified
@@ -25,56 +24,52 @@ from mindsdb.integrations.libs.ml_handler_process.handlers_cacher import handler
 logger = log.getLogger(__name__)
 
 
-@mark_process(name='learn')
-def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_data_query: str,
-                  project_name: str, model_id: int, integration_id: int, base_model_id: int,
-                  set_active: bool, module_path: str):
-    ctx.profiling = {
-        'level': 0,
-        'enabled': True,
-        'pointer': None,
-        'tree': None
-    }
-    profiler.set_meta(query='learn_process', api='http', environment=Config().get('environment'))
-    with profiler.Context('learn_process'):
+@mark_process(name="learn")
+def learn_process(
+    data_integration_ref: dict,
+    problem_definition: dict,
+    fetch_data_query: str,
+    project_name: str,
+    model_id: int,
+    integration_id: int,
+    base_model_id: int,
+    set_active: bool,
+    module_path: str,
+):
+    ctx.profiling = {"level": 0, "enabled": True, "pointer": None, "tree": None}
+    profiler.set_meta(query="learn_process", api="http", environment=Config().get("environment"))
+    with profiler.Context("learn_process"):
         from mindsdb.interfaces.database.database import DatabaseController
 
         try:
             predictor_record = db.Predictor.query.with_for_update().get(model_id)
-            predictor_record.training_metadata['process_id'] = os.getpid()
-            flag_modified(predictor_record, 'training_metadata')
+            predictor_record.training_metadata["process_id"] = os.getpid()
+            flag_modified(predictor_record, "training_metadata")
             db.session.commit()
 
-            target = problem_definition.get('target', None)
+            target = problem_definition.get("target", None)
             training_data_df = None
             if data_integration_ref is not None:
                 database_controller = DatabaseController()
                 sql_session = make_sql_session()
-                if data_integration_ref['type'] == 'integration':
-                    integration_name = database_controller.get_integration(data_integration_ref['id'])['name']
+                if data_integration_ref["type"] == "integration":
+                    integration_name = database_controller.get_integration(data_integration_ref["id"])["name"]
                     query = Select(
                         targets=[Star()],
-                        from_table=NativeQuery(
-                            integration=Identifier(integration_name),
-                            query=fetch_data_query
-                        )
+                        from_table=NativeQuery(integration=Identifier(integration_name), query=fetch_data_query),
                     )
                     sqlquery = SQLQuery(query, session=sql_session)
-                if data_integration_ref['type'] == 'system':
+                if data_integration_ref["type"] == "system":
                     query = Select(
-                        targets=[Star()],
-                        from_table=NativeQuery(
-                            integration=Identifier('log'),
-                            query=fetch_data_query
-                        )
+                        targets=[Star()], from_table=NativeQuery(integration=Identifier("log"), query=fetch_data_query)
                     )
                     sqlquery = SQLQuery(query, session=sql_session)
-                elif data_integration_ref['type'] == 'view':
+                elif data_integration_ref["type"] == "view":
                     project = database_controller.get_project(project_name)
                     query_ast = parse_sql(fetch_data_query)
                     view_meta = project.get_view_meta(query_ast)
-                    sqlquery = SQLQuery(view_meta['query_ast'], session=sql_session)
-                elif data_integration_ref['type'] == 'project':
+                    sqlquery = SQLQuery(view_meta["query_ast"], session=sql_session)
+                elif data_integration_ref["type"] == "project":
                     query_ast = parse_sql(fetch_data_query)
                     sqlquery = SQLQuery(query_ast, session=sql_session)
 
@@ -97,17 +92,13 @@ def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_da
 
             handlerStorage = HandlerStorage(integration_id)
             modelStorage = ModelStorage(model_id)
-            modelStorage.fileStorage.push()     # FIXME
+            modelStorage.fileStorage.push()  # FIXME
 
             kwargs = {}
             if base_model_id is not None:
-                kwargs['base_model_storage'] = ModelStorage(base_model_id)
-                kwargs['base_model_storage'].fileStorage.pull()
-            ml_handler = module.Handler(
-                engine_storage=handlerStorage,
-                model_storage=modelStorage,
-                **kwargs
-            )
+                kwargs["base_model_storage"] = ModelStorage(base_model_id)
+                kwargs["base_model_storage"].fileStorage.pull()
+            ml_handler = module.Handler(engine_storage=handlerStorage, model_storage=modelStorage, **kwargs)
             handlers_cacher[predictor_record.id] = ml_handler
 
             if not ml_handler.generative and target is not None:
@@ -119,18 +110,19 @@ def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_da
                         training_data_df.rename(columns={target_found: target}, inplace=True)
                     else:
                         raise Exception(
-                            f'Prediction target "{target}" not found in training dataframe: {list(training_data_df.columns)}')
+                            f'Prediction target "{target}" not found in training dataframe: {list(training_data_df.columns)}'
+                        )
 
             # create new model
             if base_model_id is None:
-                with profiler.Context('create'):
+                with profiler.Context("create"):
                     ml_handler.create(target, df=training_data_df, args=problem_definition)
 
             # fine-tune (partially train) existing model
             else:
                 # load model from previous version, use it as starting point
-                with profiler.Context('finetune'):
-                    problem_definition['base_model_id'] = base_model_id
+                with profiler.Context("finetune"):
+                    problem_definition["base_model_id"] = base_model_id
                     ml_handler.finetune(df=training_data_df, args=problem_definition)
 
             predictor_record.status = PREDICTOR_STATUS.COMPLETE
@@ -139,9 +131,7 @@ def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_da
             # if retrain and set_active after success creation
             if set_active is True:
                 models = get_model_records(
-                    name=predictor_record.name,
-                    project_id=predictor_record.project_id,
-                    active=None
+                    name=predictor_record.name, project_id=predictor_record.project_id, active=None
                 )
                 for model in models:
                     model.active = False
@@ -149,7 +139,7 @@ def learn_process(data_integration_ref: dict, problem_definition: dict, fetch_da
                 models.sort(key=lambda x: x.created_at)
                 models[-1].active = True
         except Exception as e:
-            logger.error(traceback.format_exc())
+            logger.exception("Error during 'learn' process:")
             error_message = format_exception_error(e)
 
             predictor_record = db.Predictor.query.with_for_update().get(model_id)