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

mindsdb/integrations/handlers/file_handler/file_handler.py

@@ -50,6 +50,7 @@ class FileHandler(DatabaseHandler):
         self.chunk_size = connection_data.get("chunk_size", DEFAULT_CHUNK_SIZE)
         self.chunk_overlap = connection_data.get("chunk_overlap", DEFAULT_CHUNK_OVERLAP)
         self.file_controller = file_controller
+        self.thread_safe = True
 
     def connect(self, **kwargs):
         return
@@ -83,6 +84,12 @@ class FileHandler(DatabaseHandler):
                 table_name = table_identifier.parts[-1]
                 try:
                     self.file_controller.delete_file(table_name)
+                except FileNotFoundError as e:
+                    if not query.if_exists:
+                        return Response(
+                            RESPONSE_TYPE.ERROR,
+                            error_message=f"Can't delete table '{table_name}': {e}",
+                        )
                 except Exception as e:
                     return Response(
                         RESPONSE_TYPE.ERROR,

mindsdb/integrations/handlers/lightwood_handler/functions.py

@@ -27,51 +27,40 @@ logger = log.getLogger(__name__)
 
 
 def create_learn_mark():
-    if os.name == 'posix':
-        p = Path(tempfile.gettempdir()).joinpath('mindsdb/learn_processes/')
+    if os.name == "posix":
+        p = Path(tempfile.gettempdir()).joinpath("mindsdb/learn_processes/")
         p.mkdir(parents=True, exist_ok=True)
-        p.joinpath(f'{os.getpid()}').touch()
+        p.joinpath(f"{os.getpid()}").touch()
 
 
 def delete_learn_mark():
-    if os.name == 'posix':
-        p = (
-            Path(tempfile.gettempdir())
-            .joinpath('mindsdb/learn_processes/')
-            .joinpath(f'{os.getpid()}')
-        )
+    if os.name == "posix":
+        p = Path(tempfile.gettempdir()).joinpath("mindsdb/learn_processes/").joinpath(f"{os.getpid()}")
         if p.exists():
             p.unlink()
 
 
-@mark_process(name='learn')
+@mark_process(name="learn")
 @profiler.profile()
 def run_generate(df: DataFrame, predictor_id: int, model_storage, args: dict = None):
+    model_storage.training_state_set(current_state_num=1, total_states=5, state_name="Generating problem definition")
+    json_ai_override = args.pop("using", {})
 
-    model_storage.training_state_set(
-        current_state_num=1, total_states=5, state_name='Generating problem definition'
-    )
-    json_ai_override = args.pop('using', {})
-
-    if 'dtype_dict' in json_ai_override:
-        args['dtype_dict'] = json_ai_override.pop('dtype_dict')
+    if "dtype_dict" in json_ai_override:
+        args["dtype_dict"] = json_ai_override.pop("dtype_dict")
 
-    if 'problem_definition' in json_ai_override:
-        args = {**args, **json_ai_override['problem_definition']}
+    if "problem_definition" in json_ai_override:
+        args = {**args, **json_ai_override["problem_definition"]}
 
-    if 'timeseries_settings' in args:
-        for tss_key in [
-            f.name for f in dataclasses.fields(lightwood.api.TimeseriesSettings)
-        ]:
-            k = f'timeseries_settings.{tss_key}'
+    if "timeseries_settings" in args:
+        for tss_key in [f.name for f in dataclasses.fields(lightwood.api.TimeseriesSettings)]:
+            k = f"timeseries_settings.{tss_key}"
             if k in json_ai_override:
-                args['timeseries_settings'][tss_key] = json_ai_override.pop(k)
+                args["timeseries_settings"][tss_key] = json_ai_override.pop(k)
 
     problem_definition = lightwood.ProblemDefinition.from_dict(args)
 
-    model_storage.training_state_set(
-        current_state_num=2, total_states=5, state_name='Generating JsonAI'
-    )
+    model_storage.training_state_set(current_state_num=2, total_states=5, state_name="Generating JsonAI")
     json_ai = lightwood.json_ai_from_problem(df, problem_definition)
     json_ai = json_ai.to_dict()
     unpack_jsonai_old_args(json_ai_override)
@@ -79,9 +68,7 @@ def run_generate(df: DataFrame, predictor_id: int, model_storage, args: dict = N
     rep_recur(json_ai, json_ai_override)
     json_ai = JsonAI.from_dict(json_ai)
 
-    model_storage.training_state_set(
-        current_state_num=3, total_states=5, state_name='Generating code'
-    )
+    model_storage.training_state_set(current_state_num=3, total_states=5, state_name="Generating code")
     code = lightwood.code_from_json_ai(json_ai)
 
     predictor_record = db.Predictor.query.with_for_update().get(predictor_id)
@@ -89,33 +76,27 @@ def run_generate(df: DataFrame, predictor_id: int, model_storage, args: dict = N
     db.session.commit()
 
     json_storage = get_json_storage(resource_id=predictor_id)
-    json_storage.set('json_ai', json_ai.to_dict())
+    json_storage.set("json_ai", json_ai.to_dict())
 
 
-@mark_process(name='learn')
+@mark_process(name="learn")
 @profiler.profile()
 def run_fit(predictor_id: int, df: pd.DataFrame, model_storage) -> None:
     try:
         predictor_record = db.Predictor.query.with_for_update().get(predictor_id)
         assert predictor_record is not None
 
-        predictor_record.data = {'training_log': 'training'}
+        predictor_record.data = {"training_log": "training"}
         predictor_record.status = PREDICTOR_STATUS.TRAINING
         db.session.commit()
 
-        model_storage.training_state_set(
-            current_state_num=4, total_states=5, state_name='Training model'
-        )
-        predictor: lightwood.PredictorInterface = lightwood.predictor_from_code(
-            predictor_record.code
-        )
+        model_storage.training_state_set(current_state_num=4, total_states=5, state_name="Training model")
+        predictor: lightwood.PredictorInterface = lightwood.predictor_from_code(predictor_record.code)
         predictor.learn(df)
 
         db.session.refresh(predictor_record)
 
-        fs = FileStorage(
-            resource_group=RESOURCE_GROUP.PREDICTOR, resource_id=predictor_id, sync=True
-        )
+        fs = FileStorage(resource_group=RESOURCE_GROUP.PREDICTOR, resource_id=predictor_id, sync=True)
         predictor.save(fs.folder_path / fs.folder_name)
         fs.push(compression_level=0)
 
@@ -124,9 +105,7 @@ def run_fit(predictor_id: int, df: pd.DataFrame, model_storage) -> None:
         # getting training time for each tried model. it is possible to do
         # after training only
         fit_mixers = list(
-            predictor.runtime_log[x]
-            for x in predictor.runtime_log
-            if isinstance(x, tuple) and x[0] == "fit_mixer"
+            predictor.runtime_log[x] for x in predictor.runtime_log if isinstance(x, tuple) and x[0] == "fit_mixer"
         )
         submodel_data = predictor_record.data.get("submodel_data", [])
         # add training time to other mixers info
@@ -135,43 +114,39 @@ def run_fit(predictor_id: int, df: pd.DataFrame, model_storage) -> None:
                 submodel_data[i]["training_time"] = tr_time
         predictor_record.data["submodel_data"] = submodel_data
 
-        model_storage.training_state_set(
-            current_state_num=5, total_states=5, state_name='Complete'
-        )
+        model_storage.training_state_set(current_state_num=5, total_states=5, state_name="Complete")
         predictor_record.dtype_dict = predictor.dtype_dict
         db.session.commit()
     except Exception as e:
         db.session.refresh(predictor_record)
-        predictor_record.data = {'error': f'{traceback.format_exc()}\nMain error: {e}'}
+        predictor_record.data = {"error": f"{traceback.format_exc()}\nMain error: {e}"}
         db.session.commit()
         raise e
 
 
-@mark_process(name='learn')
+@mark_process(name="learn")
 def run_learn_remote(df: DataFrame, predictor_id: int) -> None:
     try:
         serialized_df = json.dumps(df.to_dict())
         predictor_record = db.Predictor.query.with_for_update().get(predictor_id)
         resp = requests.post(
-            predictor_record.data['train_url'],
-            json={'df': serialized_df, 'target': predictor_record.to_predict[0]},
+            predictor_record.data["train_url"],
+            json={"df": serialized_df, "target": predictor_record.to_predict[0]},
         )
 
         assert resp.status_code == 200
-        predictor_record.data['status'] = 'complete'
+        predictor_record.data["status"] = "complete"
     except Exception:
-        predictor_record.data['status'] = 'error'
-        predictor_record.data['error'] = str(resp.text)
+        predictor_record.data["status"] = "error"
+        predictor_record.data["error"] = str(resp.text)
 
     db.session.commit()
 
 
-@mark_process(name='learn')
+@mark_process(name="learn")
 def run_learn(df: DataFrame, args: dict, model_storage) -> None:
     if df is None or df.shape[0] == 0:
-        raise Exception(
-            'No input data. Ensure the data source is healthy and try again.'
-        )
+        raise Exception("No input data. Ensure the data source is healthy and try again.")
 
     predictor_id = model_storage.predictor_id
 
@@ -187,15 +162,13 @@ def run_learn(df: DataFrame, args: dict, model_storage) -> None:
     db.session.commit()
 
 
-@mark_process(name='finetune')
+@mark_process(name="finetune")
 def run_finetune(df: DataFrame, args: dict, model_storage):
     try:
         if df is None or df.shape[0] == 0:
-            raise Exception(
-                'No input data. Ensure the data source is healthy and try again.'
-            )
+            raise Exception("No input data. Ensure the data source is healthy and try again.")
 
-        base_predictor_id = args['base_model_id']
+        base_predictor_id = args["base_model_id"]
         base_predictor_record = db.Predictor.query.get(base_predictor_id)
         if base_predictor_record.status != PREDICTOR_STATUS.COMPLETE:
             raise Exception("Base model must be in status 'complete'")
@@ -204,11 +177,9 @@ def run_finetune(df: DataFrame, args: dict, model_storage):
         predictor_record = db.Predictor.query.get(predictor_id)
 
         # TODO move this to ModelStorage (don't work with database directly)
-        predictor_record.data = {'training_log': 'training'}
+        predictor_record.data = {"training_log": "training"}
         predictor_record.training_start_at = datetime.now()
-        predictor_record.status = (
-            PREDICTOR_STATUS.FINETUNING
-        )  # TODO: parallel execution block
+        predictor_record.status = PREDICTOR_STATUS.FINETUNING  # TODO: parallel execution block
         db.session.commit()
 
         base_fs = FileStorage(
@@ -219,28 +190,23 @@ def run_finetune(df: DataFrame, args: dict, model_storage):
         predictor = lightwood.predictor_from_state(
             base_fs.folder_path / base_fs.folder_name, base_predictor_record.code
         )
-        predictor.adjust(df, adjust_args=args.get('using', {}))
+        predictor.adjust(df, adjust_args=args.get("using", {}))
 
-        fs = FileStorage(
-            resource_group=RESOURCE_GROUP.PREDICTOR, resource_id=predictor_id, sync=True
-        )
+        fs = FileStorage(resource_group=RESOURCE_GROUP.PREDICTOR, resource_id=predictor_id, sync=True)
         predictor.save(fs.folder_path / fs.folder_name)
         fs.push(compression_level=0)
 
-        predictor_record.data = (
-            predictor.model_analysis.to_dict()
-        )  # todo: update accuracy in LW as post-finetune hook
+        predictor_record.data = predictor.model_analysis.to_dict()  # todo: update accuracy in LW as post-finetune hook
         predictor_record.code = base_predictor_record.code
-        predictor_record.update_status = 'up_to_date'
+        predictor_record.update_status = "up_to_date"
         predictor_record.status = PREDICTOR_STATUS.COMPLETE
         predictor_record.training_stop_at = datetime.now()
         db.session.commit()
 
     except Exception as e:
-        logger.error(e)
+        logger.error("Unexpected error during Lightwood model finetune:", exc_info=True)
         predictor_id = model_storage.predictor_id
         predictor_record = db.Predictor.query.with_for_update().get(predictor_id)
-        logger.error(traceback.format_exc())
         error_message = format_exception_error(e)
         predictor_record.data = {"error": error_message}
         predictor_record.status = PREDICTOR_STATUS.ERROR

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,5 +1,6 @@
 import time
 import json
+import logging
 from typing import Optional, Any
 
 import pandas as pd
@@ -304,8 +305,19 @@ class PostgresHandler(MetaDatabaseHandler):
                     result = cur.fetchall()
                     response = _make_table_response(result, cur)
                 connection.commit()
+            except (psycopg.ProgrammingError, psycopg.DataError) as e:
+                # These is 'expected' exceptions, they should not be treated as mindsdb's errors
+                # ProgrammingError: table not found or already exists, syntax error, etc
+                # DataError: division by zero, numeric value out of range, etc.
+                # https://www.psycopg.org/psycopg3/docs/api/errors.html
+                log_message = "Database query failed with error, likely due to invalid SQL query"
+                if logger.isEnabledFor(logging.DEBUG):
+                    log_message += f". Executed query:\n{query}"
+                logger.info(log_message)
+                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e), is_acceptable_error=True)
+                connection.rollback()
             except Exception as e:
-                logger.error(f"Error running query: {query} on {self.database}, {e}!")
+                logger.error(f"Error running query:\n{query}\non {self.database}, {e}")
                 response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e))
                 connection.rollback()
 

mindsdb/integrations/handlers/shopify_handler/shopify_handler.py

@@ -1,7 +1,17 @@
 import shopify
 import requests
 
-from mindsdb.integrations.handlers.shopify_handler.shopify_tables import ProductsTable, CustomersTable, OrdersTable, InventoryLevelTable, LocationTable, CustomerReviews, CarrierServiceTable, ShippingZoneTable, SalesChannelTable
+from mindsdb.integrations.handlers.shopify_handler.shopify_tables import (
+    ProductsTable,
+    CustomersTable,
+    OrdersTable,
+    InventoryLevelTable,
+    LocationTable,
+    CustomerReviews,
+    CarrierServiceTable,
+    ShippingZoneTable,
+    SalesChannelTable,
+)
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
@@ -9,7 +19,11 @@ from mindsdb.integrations.libs.response import (
 
 from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
-from mindsdb.integrations.libs.api_handler_exceptions import InvalidNativeQuery, ConnectionFailed, MissingConnectionParams
+from mindsdb.integrations.libs.api_handler_exceptions import (
+    InvalidNativeQuery,
+    ConnectionFailed,
+    MissingConnectionParams,
+)
 
 logger = log.getLogger(__name__)
 
@@ -19,7 +33,7 @@ class ShopifyHandler(APIHandler):
     The Shopify handler implementation.
     """
 
-    name = 'shopify'
+    name = "shopify"
 
     def __init__(self, name: str, **kwargs):
         """
@@ -81,10 +95,12 @@ class ShopifyHandler(APIHandler):
         if self.kwargs.get("connection_data") is None:
             raise MissingConnectionParams("Incomplete parameters passed to Shopify Handler")
 
-        api_session = shopify.Session(self.connection_data['shop_url'], '2021-10', self.connection_data['access_token'])
+        api_session = shopify.Session(self.connection_data["shop_url"], "2021-10", self.connection_data["access_token"])
 
-        self.yotpo_app_key = self.connection_data['yotpo_app_key'] if 'yotpo_app_key' in self.connection_data else None
-        self.yotpo_access_token = self.connection_data['yotpo_access_token'] if 'yotpo_access_token' in self.connection_data else None
+        self.yotpo_app_key = self.connection_data["yotpo_app_key"] if "yotpo_app_key" in self.connection_data else None
+        self.yotpo_access_token = (
+            self.connection_data["yotpo_access_token"] if "yotpo_access_token" in self.connection_data else None
+        )
 
         self.connection = api_session
 
@@ -107,16 +123,13 @@ class ShopifyHandler(APIHandler):
             shopify.Shop.current()
             response.success = True
         except Exception as e:
-            logger.error('Error connecting to Shopify!')
-            raise ConnectionFailed("Conenction to Shopify failed.")
+            logger.error("Error connecting to Shopify!")
             response.error_message = str(e)
+            raise ConnectionFailed("Conenction to Shopify failed.")
 
         if self.yotpo_app_key is not None and self.yotpo_access_token is not None:
             url = f"https://api.yotpo.com/v1/apps/{self.yotpo_app_key}/reviews?count=1&utoken={self.yotpo_access_token}"
-            headers = {
-                "accept": "application/json",
-                "Content-Type": "application/json"
-            }
+            headers = {"accept": "application/json", "Content-Type": "application/json"}
             if requests.get(url, headers=headers).status_code == 200:
                 response.success = True
             else:

mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -204,10 +204,11 @@ class SnowflakeHandler(MetaDatabaseHandler):
             "user": self.connection_data.get("user"),
             "password": self.connection_data.get("password"),
             "database": self.connection_data.get("database"),
+            "schema": self.connection_data.get("schema", "PUBLIC"),
         }
 
         # Optional connection parameters
-        optional_params = ["schema", "warehouse", "role"]
+        optional_params = ["warehouse", "role"]
         for param in optional_params:
             if param in self.connection_data:
                 config[param] = self.connection_data[param]

mindsdb/integrations/handlers/statsforecast_handler/requirements.txt

@@ -1,2 +1,3 @@
 statsforecast==1.6.0
 scipy==1.15.3
+numba >=0.55.0, <=0.61.2

mindsdb/integrations/handlers/statsforecast_handler/requirements_extra.txt

@@ -1,2 +1,3 @@
 statsforecast==1.6.0
 scipy==1.15.3
+numba >=0.55.0, <=0.61.2

mindsdb/integrations/handlers/web_handler/urlcrawl_helpers.py

@@ -170,9 +170,9 @@ def get_all_website_links(url, headers: dict = None) -> dict:
                 href = href.rstrip("/")
                 urls.add(href)
 
-    except Exception as e:
+    except Exception:
         error_message = traceback.format_exc().splitlines()[-1]
-        logger.error("An exception occurred: %s", str(e))
+        logger.exception("An exception occurred:")
         return {
             "url": url,
             "urls": urls,
@@ -238,9 +238,9 @@ def get_all_website_links_recursively(
     if url not in reviewed_urls and matches_filter:
         try:
             reviewed_urls[url] = get_all_website_links(url, headers=headers)
-        except Exception as e:
+        except Exception:
             error_message = traceback.format_exc().splitlines()[-1]
-            logger.error("An exception occurred: %s", str(e))
+            logger.exception("An exception occurred:")
             reviewed_urls[url] = {
                 "url": url,
                 "urls": [],

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