MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.0__py3-none-any.whl

mindsdb/integrations/handlers/mendeley_handler/mendeley_handler.py

@@ -1,23 +1,21 @@
 from mindsdb_sql_parser import parse_sql
 import pandas as pd
 from mendeley import Mendeley
-from mindsdb.integrations.libs.api_handler import APIHandler, FuncParser
+from mindsdb.integrations.libs.api_handler import APIHandler
 from mendeley.session import MendeleySession
-from mindsdb.integrations.handlers.mendeley_handler.mendeley_tables import CatalogSearchTable 
+from mindsdb.integrations.handlers.mendeley_handler.mendeley_tables import CatalogSearchTable
 from mindsdb.utilities import log
 from typing import Dict
 from mindsdb.integrations.libs.response import (
-    HandlerStatusResponse as StatusResponse,
-    HandlerResponse as Response,
-    RESPONSE_TYPE
+    HandlerStatusResponse as StatusResponse
 )
 
 logger = log.getLogger(__name__)
 
-class MendeleyHandler(APIHandler): 
 
-    def __init__(self, name, **kwargs): 
+class MendeleyHandler(APIHandler):
 
+    def __init__(self, name, **kwargs):
         """ constructor
         Args:
             name (str): the handler name
@@ -25,16 +23,16 @@ class MendeleyHandler(APIHandler):
         super().__init__(name)
 
         self.connection_args = kwargs.get('connection_data', {})
-        
+
         self.client_id = self.connection_args.get('client_id', None)
         self.client_secret = self.connection_args.get('client_secret', None)
         self.session = self.connect()
 
         self.session = None
         self.is_connected = False
-    
+
         catalog_search_data = CatalogSearchTable(self)
-        self.catalog_search_data = catalog_search_data 
+        self.catalog_search_data = catalog_search_data
         self._register_table('catalog_search_data', catalog_search_data)
 
     def connect(self) -> MendeleySession:
@@ -47,7 +45,7 @@ class MendeleyHandler(APIHandler):
         Returns:
         HandlerStatusResponse """
 
-        if self.is_connected == True:
+        if self.is_connected:
             return self.session
 
         mendeley = Mendeley(self.client_id, self.client_secret)
@@ -56,9 +54,8 @@ class MendeleyHandler(APIHandler):
 
         self.is_connected = True
         return self.session
-    
-    def check_connection(self) -> StatusResponse:
 
+    def check_connection(self) -> StatusResponse:
         """ The check_connection method checks the connection to the handler
         Returns:
             HandlerStatusResponse
@@ -77,7 +74,6 @@ class MendeleyHandler(APIHandler):
         return response
 
     def native_query(self, query_string: str):
-        
         """The native_query method receives raw query and acts upon it.
             Args:
                 query_string (str): query in native format
@@ -86,9 +82,9 @@ class MendeleyHandler(APIHandler):
         """
         ast = parse_sql(query_string)
         return self.query(ast)
-    
-    def get_authors(self,data):
-        """The get_authors method receives the data - a specific document returned by the API, gets the names of the authors 
+
+    def get_authors(self, data):
+        """The get_authors method receives the data - a specific document returned by the API, gets the names of the authors
             and combines them in a string, so as to allow the use of DataFrame.
             Args:
                 data (CatalogDocument): document returned by API
@@ -97,18 +93,18 @@ class MendeleyHandler(APIHandler):
         """
         authors = ""
         sum = 0
-        if data.authors!=None:
+        if data.authors is not None:
             for x in data.authors:
-                if sum + 1 == len(data.authors) and x.first_name!=None and x.last_name!=None  :
+                if sum + 1 == len(data.authors) and x.first_name is not None and x.last_name is not None:
                     authors = authors + x.first_name + " " + x.last_name
                 else:
-                    if x.first_name!=None and x.last_name!=None:
+                    if x.first_name is not None and x.last_name is not None:
                         authors = authors + x.first_name + " " + x.last_name + ", "
                         sum = sum + 1
         return authors
 
-    def get_keywords(self,data):
-        """The get_keywords method receives the data-a specific document returned by the API, gets the specified keywords 
+    def get_keywords(self, data):
+        """The get_keywords method receives the data-a specific document returned by the API, gets the specified keywords
             and combines them in a string, so as to allow the use of DataFrame.
             Args:
                 data (CatalogDocument) : document returned by the API
@@ -117,18 +113,17 @@ class MendeleyHandler(APIHandler):
         """
         keywords = ""
         sum = 0
-        if data.keywords!=None:
+        if data.keywords is not None:
             for x in data.keywords:
                 if sum + 1 == len(data.keywords):
-                    keywords = keywords  + x + " "
+                    keywords = keywords + x + " "
                 else:
-                    if x!=None :
+                    if x is not None:
                         keywords = keywords + x + ", "
                         sum = sum + 1
         return keywords
-    
-    def create_dict(self,data):
 
+    def create_dict(self, data):
         """The create_dict method receives the data-a specific document returned by the API, gets the resources-fields of the document,
           as specified in Mendley documentation, and puts them in a dictionary.
 
@@ -142,7 +137,7 @@ class MendeleyHandler(APIHandler):
         dict["type"] = data.type
         dict["source"] = data.source
         dict["year"] = data.year
-        if data.identifiers!=None:
+        if data.identifiers is not None:
             dict["pmid"] = data.identifiers.get("pmid")
             dict["sgr"] = data.identifiers.get("sgr")
             dict["issn"] = data.identifiers.get("issn")
@@ -150,16 +145,15 @@ class MendeleyHandler(APIHandler):
             dict["doi"] = data.identifiers.get("doi")
             dict["pui"] = data.identifiers.get("pui")
         dict["authors"] = self.get_authors(data)
-        if data.keywords!=None:
+        if data.keywords is not None:
             dict["keywords"] = self.get_keywords(data)
         else:
             dict["keywords"] = None
         dict["link"] = data.link
         dict["id"] = data.id
         return dict
-    
+
     def call_mendeley_api(self, method_name: str, params: Dict) -> pd.DataFrame:
-        
         """The method call_mendeley_api is used to communicate with Mendeley. Depending on the method used there are three different types
         of search conducted.
         The advanced_search results in a CatalogSearch resource, which, depending on the parameters used, could either be a number of different documents (CatalogDocument),
@@ -174,28 +168,28 @@ class MendeleyHandler(APIHandler):
             DataFrame
         """
 
-        self.session= self.connect()
+        self.session = self.connect()
 
         if method_name == 'advanced_search':
             search_params = {
-            'title': params.get("title"),
-            'author': params.get("author"),
-            'source': params.get("source"),
-            'abstract': params.get("abstract"),
-            'min_year': params.get("min_year"),
-            'max_year': params.get("max_year"),
-            'open_access': params.get("open_access")
+                'title': params.get("title"),
+                'author': params.get("author"),
+                'source': params.get("source"),
+                'abstract': params.get("abstract"),
+                'min_year': params.get("min_year"),
+                'max_year': params.get("max_year"),
+                'open_access': params.get("open_access")
             }
             data = self.session.catalog.advanced_search(**search_params)
             sum = 0
             df = pd.DataFrame()
             for x in data.list(page_size=params["limit"]).items:
-                    if sum == 0:
-                        df = pd.DataFrame(self.create_dict(x),index=[0])
-                        sum += 1
-                    else : 
-                        df = df.append(self.create_dict(x),ignore_index = True)
-                        sum += 1
+                if sum == 0:
+                    df = pd.DataFrame(self.create_dict(x), index=[0])
+                    sum += 1
+                else:
+                    df = df.append(self.create_dict(x), ignore_index=True)
+                    sum += 1
             if df.empty:
                 raise NotImplementedError(('Insufficient or wrong input given'))
             else:
@@ -203,23 +197,21 @@ class MendeleyHandler(APIHandler):
 
         elif method_name == 'identifier_search':
             search_params = {
-            'arxiv': params.get("arxiv"),
-            'doi': params.get("doi"),
-            'isbn': params.get("isbn"),
-            'issn': params.get("issn"),
-            'pmid': params.get("pmid"),
-            'scopus': params.get("scopus"),
-            'filehash': params.get("filehash")
+                'arxiv': params.get("arxiv"),
+                'doi': params.get("doi"),
+                'isbn': params.get("isbn"),
+                'issn': params.get("issn"),
+                'pmid': params.get("pmid"),
+                'scopus': params.get("scopus"),
+                'filehash': params.get("filehash")
             }
             data = self.session.catalog.by_identifier(**search_params)
-            df = pd.DataFrame(self.create_dict(data),index=[0])
+            df = pd.DataFrame(self.create_dict(data), index=[0])
             return df
 
         elif method_name == 'get':
             data = self.session.catalog.get(params.get("id"))
-            df = pd.DataFrame(self.create_dict(data),index=[0])
+            df = pd.DataFrame(self.create_dict(data), index=[0])
             return df
 
         raise NotImplementedError('Method name {} not supported by Mendeley API Handler'.format(method_name))
-
-

mindsdb/integrations/handlers/mendeley_handler/mendeley_tables.py

@@ -3,25 +3,25 @@ import pandas as pd
 from mindsdb.integrations.libs.api_handler import APITable
 from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 
+
 class CatalogSearchTable(APITable):
 
     def select(self, query: ast.Select) -> pd.DataFrame:
-
         """The select method implements the mappings from the ast.Select and calls the actual API through the call_mendeley_api.
         Firstly, it is used to put the parameters specified in the query in a dictionary, which is then used when calling the method call_mendeley_api.
         If no conditions are specified, an error is raised since the search cannot be conducted.
 
         Args:
-            query (ast.Select): query used to specify the wanted results 
+            query (ast.Select): query used to specify the wanted results
         Returns:
             result (DataFrame): the result of the query
         """
-       
+
         conditions = extract_comparison_conditions(query.where)
-        
-        params = {} 
 
-        #Since there are three different types of search, and each of them takes different parameters, we use the parameters that lead
+        params = {}
+
+        # Since there are three different types of search, and each of them takes different parameters, we use the parameters that lead
         # to the most specific results. For example, in the case of the user specifying the title and the doi of a document, priority is given to
         # the doi.
 
@@ -30,7 +30,7 @@ class CatalogSearchTable(APITable):
         else:
             params['limit'] = 30
 
-        for op,arg1,arg2 in conditions:
+        for op, arg1, arg2 in conditions:
 
             if arg1 in ['arxiv', 'doi', 'isbn', 'issn', 'pmid', 'scopus', 'filehash']:
 
@@ -39,8 +39,8 @@ class CatalogSearchTable(APITable):
                 params[arg1] = arg2
 
                 result = self.handler.call_mendeley_api(
-                method_name='identifier_search',
-                params=params)
+                    method_name='identifier_search',
+                    params=params)
 
                 break
 
@@ -50,52 +50,50 @@ class CatalogSearchTable(APITable):
                 params['id'] = arg2
 
                 result = self.handler.call_mendeley_api(
-                method_name='get',
-                params=params)
+                    method_name='get',
+                    params=params)
 
                 break
 
-            elif "title" or "author" or"source" or "abstract" or "min_year" or "max_year" or "open_access" or "view" in conditions:
+            elif "title" or "author" or "source" or "abstract" or "min_year" or "max_year" or "open_access" or "view" in conditions:
 
                 if arg1 == 'title':
                     if op != '=':
                         raise NotImplementedError
                     params['title'] = arg2
-                
+
                 elif arg1 == 'author':
                     if op != '=':
                         raise NotImplementedError
                     params['author'] = arg2
-                
+
                 elif arg1 == 'source':
                     if op != '=':
                         raise NotImplementedError
                     params['source'] = arg2
-                
+
                 elif arg1 == 'abstract':
                     if op != '=':
                         raise NotImplementedError
                     params['abstract'] = arg2
-                
+
                 elif arg1 == 'min_year':
                     params['min_year'] = arg2
-                
+
                 elif arg1 == 'max_year':
                     params['max_year'] = arg2
-                
+
                 elif arg1 == 'open_access':
                     if op != '=':
                         raise NotImplementedError
                     params['open_access'] = arg2
-                
-            
+
                 result = self.handler.call_mendeley_api(
-                method_name='advanced_search',
-                params=params)
-        
-        if conditions==[]:
+                    method_name='advanced_search',
+                    params=params)
+
+        if conditions == []:
             raise ValueError('Please give input for the search to be conducted.')
-        
 
         columns = []
 
@@ -107,10 +105,9 @@ class CatalogSearchTable(APITable):
                 columns.append(target.parts[-1])
             else:
                 raise ValueError(f"Unknown query target {type(target)}")
-        
 
         return result[columns]
-    
+
     def get_columns(self):
         """ get_columns method returns the columns returned by the API"""
         return [
@@ -130,5 +127,3 @@ class CatalogSearchTable(APITable):
             'link',
             'id'
         ]
-
-        

mindsdb/integrations/handlers/mendeley_handler/tests/test_mendeley_handler.py

@@ -3,13 +3,14 @@ import unittest
 from mindsdb.integrations.handlers.mendeley_handler.mendeley_handler import MendeleyHandler
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 
+
 class MendeleyHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.kwargs = {
-            "connection_data":{"client_id":15253,"client_secret":"BxmSvbrRW5iYEIQR"}
+            "connection_data": {"client_id": 15253, "client_secret": "BxmSvbrRW5iYEIQR"}
         }
-        cls.handler = MendeleyHandler("test_mendeley_handler",**cls.kwargs)
+        cls.handler = MendeleyHandler("test_mendeley_handler", **cls.kwargs)
 
     def test_0_connect(self):
         self.handler.connect()
@@ -26,56 +27,56 @@ class MendeleyHandlerTest(unittest.TestCase):
         query = "SELECT * FROM catalog_search_data WHERE id='af1a0408-7409-3a8b-ad91-8accd4f8849a'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_4_select(self):
         query = "SELECT * FROM catalog_search_data WHERE title='The American Mineralogist crystal structure database'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_5_select(self):
         query = "SELECT * FROM catalog_search_data WHERE id='8e86b541-84fd-30ef-9eed-e8c9af847ca3' AND doi='10.1093/ajcn/77.1.71'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_6_select(self):
         query = "SELECT * FROM catalog_search_data WHERE issn='15570878'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_7_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_8_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND id='4eeda257-8db4-3dad-80c8-6912356d3887'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_9_select(self):
         query = "SELECT * FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND max_year='2020'"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
-    
+
     def test_10_call_mendeley_api_invalid_method_name(self):
         with self.assertRaises(NotImplementedError):
-            res = self.handler.call_mendeley_api("method1",None)
+            self.handler.call_mendeley_api("method1", None)
 
     def test_11_select_invalid_condition_name(self):
         with self.assertRaises(NotImplementedError):
             query = "SELECT * FROM catalog_search_data WHERE name='American Journal of Clinical Nutrition'"
-            result = self.handler.native_query(query)
+            self.handler.native_query(query)
 
     def test_12_select_invalid_operator(self):
         with self.assertRaises(NotImplementedError):
             query = "SELECT * FROM catalog_search_data WHERE source>'American Journal of Clinical Nutrition'AND max_year='2020' "
-            result = self.handler.native_query(query)
-    
+            self.handler.native_query(query)
+
     def test_13_select_invalid_column_name(self):
         with self.assertRaises(KeyError):
             query = "SELECT name FROM catalog_search_data WHERE source='American Journal of Clinical Nutrition'AND max_year='2020' "
-            result = self.handler.native_query(query)
-    
+            self.handler.native_query(query)
+
     def test_14_get_columns(self):
         columns = self.handler.catalog_search_data.get_columns()
 
@@ -98,11 +99,12 @@ class MendeleyHandlerTest(unittest.TestCase):
         ]
 
         self.assertListEqual(columns, expected_columns)
-    
+
     def test_15_select_invalid_condition_name(self):
         with self.assertRaises(ValueError):
             query = "SELECT * FROM catalog_search_data"
-            result = self.handler.native_query(query)
+            self.handler.native_query(query)
+
 
 if __name__ == "__main__":
     unittest.main()

mindsdb/integrations/handlers/merlion_handler/merlion_handler.py

@@ -14,6 +14,7 @@ from .adapters import BaseMerlionForecastAdapter, DefaultForecasterAdapter, Merl
 
 logger = log.getLogger(__name__)
 
+
 class DetectorModelType(Enum):
     default = DefaultDetectorAdapter
     isolation = IsolationForestDetectorAdapter
@@ -36,7 +37,7 @@ class TaskType(Enum):
 def is_invalid_type(name: str, type_class: Enum) -> bool:
     if name is None:
         return True
-    return not name in type_class._member_names_
+    return name not in type_class._member_names_
 
 
 def enum_to_str(type_class: Enum) -> str:
@@ -194,12 +195,12 @@ class MerlionHandler(BaseMLEngine):
         # check task_type
         try:
             task_enum = TaskType[task]
-        except Exception as e:
+        except Exception:
             raise Exception("wrong using.task: " + task + ", valid options: " + enum_to_str(TaskType))
         # check and get model class
         try:
             adapter_class = task_enum.value[model_type].value
         except Exception as e:
-            raise Exception("Wrong using.model_type: " + model_type + ", valid options: " +
-                            enum_to_str(task_enum.value) + ", " + str(e))
+            raise Exception("Wrong using.model_type: " + model_type + ", valid options: "
+                            + enum_to_str(task_enum.value) + ", " + str(e))
         return adapter_class

mindsdb/integrations/handlers/minds_endpoint_handler/__init__.py

@@ -1,10 +1,10 @@
+from .__about__ import __version__ as version
+from .__about__ import __description__ as description
 from mindsdb.integrations.libs.const import HANDLER_TYPE
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
-from .__about__ import __description__ as description
-from .__about__ import __version__ as version
 
 try:
     from .minds_endpoint_handler import MindsEndpointHandler as Handler
@@ -20,4 +20,4 @@ type = HANDLER_TYPE.ML
 icon_path = 'icon.svg'
 permanent = False
 
-__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]

mindsdb/integrations/handlers/mlflow_handler/mlflow_handler.py

@@ -18,66 +18,88 @@ class MLflowHandler(BaseMLEngine):
         1. Run `mlflow server -p 5001 --backend-store-uri sqlite:////path/to/mlflow.db --default-artifact-root ./artifacts --host 0.0.0.0`
         2. Run `mlflow models serve --model-uri ./model_path`
         3. Run MindsDB
-    
+
     Note: above, `artifacts` is a folder to store artifacts for new experiments that do not specify an artifact store.
     """  # noqa
 
-    name = 'mlflow'
+    name = "mlflow"
 
-    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
-        args = args['using']  # ignore the rest of the problem definition
-        connection = MlflowClient(args['mlflow_server_url'], args['mlflow_server_path'])
-        model_name = args['model_name']
+    def create(
+        self,
+        target: str,
+        df: Optional[pd.DataFrame] = None,
+        args: Optional[Dict] = None,
+    ) -> None:
+        args = args["using"]  # ignore the rest of the problem definition
+        connection = MlflowClient(args["mlflow_server_url"], args["mlflow_server_path"])
+        model_name = args["model_name"]
         mlflow_models = [model.name for model in connection.search_registered_models()]
 
         if model_name not in mlflow_models:
-            raise Exception(f"Error: model '{model_name}' not found in mlflow. Check serving and try again.")
+            raise Exception(
+                f"Error: model '{model_name}' not found in mlflow. Check serving and try again."
+            )
 
-        args['target'] = target
-        self._check_model_url(args['predict_url'])
-        self.model_storage.json_set('args', args)
+        args["target"] = target
+        self._check_model_url(args["predict_url"])
+        self.model_storage.json_set("args", args)
 
     def predict(self, df, args=None):
-        args = self.model_storage.json_get('args')  # override any incoming args for now
-        self._check_model_url(args['predict_url'])
-        resp = requests.post(args['predict_url'],
-                             data=df.to_json(orient='records'),
-                             headers={'content-type': 'application/json; format=pandas-records'})
+        args = self.model_storage.json_get("args")  # override any incoming args for now
+        self._check_model_url(args["predict_url"])
+        resp = requests.post(
+            args["predict_url"],
+            data=df.to_json(orient="records"),
+            headers={"content-type": "application/json; format=pandas-records"},
+        )
         answer = resp.json()
-        predictions = pd.DataFrame({args['target']: answer})
+        predictions = pd.DataFrame({args["target"]: answer})
         return predictions
 
     def describe(self, key: Optional[str] = None) -> pd.DataFrame:
-        if key == 'info':
-            args = self.model_storage.json_get('args')
-            connection = MlflowClient(args['mlflow_server_url'], args['self.mlflow_server_path'])
-            models = {model.name: model for model in connection.search_registered_models()}
+        if key == "info":
+            args = self.model_storage.json_get("args")
+            connection = MlflowClient(
+                args["mlflow_server_url"], args["self.mlflow_server_path"]
+            )
+            models = {
+                model.name: model for model in connection.search_registered_models()
+            }
             model = models[key]
             latest_version = model.latest_versions[-1]
             description = {
-                'NAME': [model.name],
-                'USER_DESCRIPTION': [model.description],
-                'LAST_STATUS': [latest_version.status],
-                'CREATED_AT': [datetime.fromtimestamp(model.creation_timestamp//1000).strftime("%m/%d/%Y, %H:%M:%S")],
-                'LAST_UPDATED': [datetime.fromtimestamp(model.last_updated_timestamp//1000).strftime("%m/%d/%Y, %H:%M:%S")],
-                'TAGS': [model.tags],
-                'LAST_RUN_ID': [latest_version.run_id],
-                'LAST_SOURCE_PATH': [latest_version.source],
-                'LAST_USER_ID': [latest_version.user_id],
-                'LAST_VERSION': [latest_version.version],
+                "NAME": [model.name],
+                "USER_DESCRIPTION": [model.description],
+                "LAST_STATUS": [latest_version.status],
+                "CREATED_AT": [
+                    datetime.fromtimestamp(model.creation_timestamp // 1000).strftime(
+                        "%m/%d/%Y, %H:%M:%S"
+                    )
+                ],
+                "LAST_UPDATED": [
+                    datetime.fromtimestamp(
+                        model.last_updated_timestamp // 1000
+                    ).strftime("%m/%d/%Y, %H:%M:%S")
+                ],
+                "TAGS": [model.tags],
+                "LAST_RUN_ID": [latest_version.run_id],
+                "LAST_SOURCE_PATH": [latest_version.source],
+                "LAST_USER_ID": [latest_version.user_id],
+                "LAST_VERSION": [latest_version.version],
             }
             return pd.DataFrame.from_dict(description)
         else:
-            tables = ['info']
-            return pd.DataFrame(tables, columns=['tables'])
-
+            tables = ["info"]
+            return pd.DataFrame(tables, columns=["tables"])
 
     @staticmethod
     def _check_model_url(url):
-        """ try post without data, check status code not in (not_found, method_not_allowed) """
+        """try post without data, check status code not in (not_found, method_not_allowed)"""
         try:
             resp = requests.post(url)
             if resp.status_code in (404, 405):
-                raise Exception(f'Model url is incorrect, status_code: {resp.status_code}')
+                raise Exception(
+                    f"Model url is incorrect, status_code: {resp.status_code}"
+                )
         except requests.RequestException as e:
-            raise Exception(f'Model url is incorrect: {str(e)}')
+            raise Exception(f"Model url is incorrect: {str(e)}")