MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/api/http/namespaces/chatbots.py

@@ -16,42 +16,37 @@ from mindsdb.utilities.exception import EntityNotExistsError
 
 def create_chatbot(project_name, name, chatbot):
     if name is None:
-        return http_error(
-            HTTPStatus.BAD_REQUEST,
-            'Missing field',
-            'Missing "name" field for chatbot'
-        )
+        return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for chatbot')
 
-    model_name = chatbot.get('model_name', None)
-    agent_name = chatbot.get('agent_name', None)
+    if not name.islower():
+        return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
+
+    model_name = chatbot.get("model_name", None)
+    agent_name = chatbot.get("agent_name", None)
     if model_name is None and agent_name is None:
         return http_error(
             HTTPStatus.BAD_REQUEST,
-            'Missing field',
-            'Must include either "model_name" or "agent_name" field for chatbot'
+            "Missing field",
+            'Must include either "model_name" or "agent_name" field for chatbot',
         )
 
     session_controller = SessionController()
 
-    if 'database_id' in chatbot or 'database_name' in chatbot or ('db_engine' in chatbot and 'db_params' in chatbot):
+    if "database_id" in chatbot or "database_name" in chatbot or ("db_engine" in chatbot and "db_params" in chatbot):
         try:
             database_id = get_or_create_database_for_chatbot(chatbot, session_controller)
         except ValueError as value_error:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Database not found',
-                str(value_error)
-            )
+            return http_error(HTTPStatus.NOT_FOUND, "Database not found", str(value_error))
 
     else:
         return http_error(
             HTTPStatus.BAD_REQUEST,
-            'Missing field',
-            'Missing "database_id" or ("db_engine" and "database_param") fields for chatbot'
+            "Missing field",
+            'Missing "database_id" or ("db_engine" and "database_param") fields for chatbot',
         )
 
-    is_running = chatbot.get('is_running', False)
-    params = chatbot.get('params', {})
+    is_running = chatbot.get("is_running", False)
+    params = chatbot.get("params", {})
 
     chatbot_controller = ChatBotController()
 
@@ -62,36 +57,26 @@ def create_chatbot(project_name, name, chatbot):
         existing_chatbot = chatbot_controller.get_chatbot(name, project_name=project_name)
     except EntityNotExistsError:
         # Project must exist.
-        return http_error(
-            HTTPStatus.NOT_FOUND,
-            'Project not found',
-            f'Project with name {project_name} does not exist')
+        return http_error(HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist")
     if existing_chatbot is not None:
         return http_error(
             HTTPStatus.CONFLICT,
-            'Chatbot already exists',
-            f'Chatbot with name {name} already exists. Please use a different name'
+            "Chatbot already exists",
+            f"Chatbot with name {name} already exists. Please use a different name",
         )
 
     # Model and agent need to exist.
     if agent_name is not None:
         agent = AgentsController().get_agent(agent_name, project_name)
         if agent is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Agent not found',
-                f'Agent with name {agent_name} not found'
-            )
+            return http_error(HTTPStatus.NOT_FOUND, "Agent not found", f"Agent with name {agent_name} not found")
         model_name = agent.model_name
 
     model_name_no_version, version = Predictor.get_name_and_version(model_name)
     try:
         session_controller.model_controller.get_model(model_name_no_version, version=version, project_name=project_name)
     except PredictorRecordNotFound:
-        return http_error(
-            HTTPStatus.NOT_FOUND,
-            'Model not found',
-            f'Model with name {model_name} not found')
+        return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
     created_chatbot = chatbot_controller.add_chatbot(
         name,
@@ -100,7 +85,7 @@ def create_chatbot(project_name, name, chatbot):
         agent_name=agent_name,
         database_id=database_id,
         is_running=is_running,
-        params=params
+        params=params,
     )
     return created_chatbot.as_dict(), HTTPStatus.CREATED
 
@@ -116,22 +101,22 @@ def get_or_create_database_for_chatbot(chatbot: dict, session_controller: Sessio
     Returns:
         int: The database ID.
     """
-    if 'database_id' in chatbot:
-        database_record = session_controller.integration_controller.get_by_id(chatbot['database_id'])
+    if "database_id" in chatbot:
+        database_record = session_controller.integration_controller.get_by_id(chatbot["database_id"])
         if database_record:
-            return database_record['id']
+            return database_record["id"]
         else:
             raise ValueError(f"Database with ID {chatbot['database_id']} not found")
 
-    elif 'database_name' in chatbot:
-        database_record = session_controller.integration_controller.get(chatbot['database_name'])
+    elif "database_name" in chatbot:
+        database_record = session_controller.integration_controller.get(chatbot["database_name"])
         if database_record:
-            return database_record['id']
+            return database_record["id"]
         else:
             raise ValueError(f"Database with name {chatbot['database_name']} not found")
 
-    if 'db_params' in chatbot and 'db_engine' in chatbot:
-        db_name = chatbot['name'] + '_db'
+    if "db_params" in chatbot and "db_engine" in chatbot:
+        db_name = chatbot["name"] + "_db"
 
         # try to drop
         existing_db = session_controller.integration_controller.get(db_name)
@@ -139,84 +124,75 @@ def get_or_create_database_for_chatbot(chatbot: dict, session_controller: Sessio
             # drop
             session_controller.integration_controller.delete(db_name)
 
-        return session_controller.integration_controller.add(db_name, chatbot['db_engine'], chatbot['db_params'])
+        return session_controller.integration_controller.add(db_name, chatbot["db_engine"], chatbot["db_params"])
 
     return None
 
 
-@ns_conf.route('/<project_name>/chatbots')
+@ns_conf.route("/<project_name>/chatbots")
 class ChatBotsResource(Resource):
-    @ns_conf.doc('list_chatbots')
-    @api_endpoint_metrics('GET', '/chatbots')
+    @ns_conf.doc("list_chatbots")
+    @api_endpoint_metrics("GET", "/chatbots")
     def get(self, project_name):
-        ''' List all chatbots '''
+        """List all chatbots"""
         chatbot_controller = ChatBotController()
         try:
             all_bots = chatbot_controller.get_chatbots(project_name)
         except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project with name {project_name} does not exist')
+                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
+            )
         return all_bots
 
-    @ns_conf.doc('create_chatbot')
-    @api_endpoint_metrics('POST', '/chatbots')
+    @ns_conf.doc("create_chatbot")
+    @api_endpoint_metrics("POST", "/chatbots")
     def post(self, project_name):
-        '''Create a chatbot'''
+        """Create a chatbot"""
 
         # Check for required parameters.
-        if 'chatbot' not in request.json:
+        if "chatbot" not in request.json:
             return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Missing parameter',
-                'Must provide "chatbot" parameter in POST body'
+                HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "chatbot" parameter in POST body'
             )
 
-        chatbot = request.json['chatbot']
+        chatbot = request.json["chatbot"]
 
-        name = chatbot.get('name')
+        name = chatbot.get("name")
         return create_chatbot(project_name, name, chatbot)
 
 
-@ns_conf.route('/<project_name>/chatbots/<chatbot_name>')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('chatbot_name', 'Name of the chatbot')
+@ns_conf.route("/<project_name>/chatbots/<chatbot_name>")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("chatbot_name", "Name of the chatbot")
 class ChatBotResource(Resource):
-    @ns_conf.doc('get_chatbot')
-    @api_endpoint_metrics('GET', '/chatbots/chatbot')
+    @ns_conf.doc("get_chatbot")
+    @api_endpoint_metrics("GET", "/chatbots/chatbot")
     def get(self, project_name, chatbot_name):
-        '''Gets a chatbot by name'''
+        """Gets a chatbot by name"""
         chatbot_controller = ChatBotController()
         try:
             existing_chatbot = chatbot_controller.get_chatbot(chatbot_name, project_name=project_name)
             if existing_chatbot is None:
                 return http_error(
-                    HTTPStatus.NOT_FOUND,
-                    'Chatbot not found',
-                    f'Chatbot with name {chatbot_name} does not exist'
+                    HTTPStatus.NOT_FOUND, "Chatbot not found", f"Chatbot with name {chatbot_name} does not exist"
                 )
             return existing_chatbot
         except (ValueError, EntityNotExistsError):
             # Project needs to exist.
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project with name {project_name} does not exist'
+                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
 
-    @ns_conf.doc('update_chatbot')
-    @api_endpoint_metrics('PUT', '/chatbots/chatbot')
+    @ns_conf.doc("update_chatbot")
+    @api_endpoint_metrics("PUT", "/chatbots/chatbot")
     def put(self, project_name, chatbot_name):
-        '''Updates a chatbot by name, creating one if it doesn't exist'''
+        """Updates a chatbot by name, creating one if it doesn't exist"""
 
         # Check for required parameters.
-        if 'chatbot' not in request.json:
+        if "chatbot" not in request.json:
             return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Missing parameter',
-                'Must provide "chatbot" parameter in POST body'
+                HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "chatbot" parameter in POST body'
             )
         chatbot_controller = ChatBotController()
 
@@ -225,27 +201,21 @@ class ChatBotResource(Resource):
         except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project with name {project_name} does not exist'
+                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
 
         session = SessionController()
 
-        chatbot = request.json['chatbot']
-        name = chatbot.get('name', None)
-        agent_name = chatbot.get('agent_name', None)
-        model_name = chatbot.get('model_name', None)
+        chatbot = request.json["chatbot"]
+        name = chatbot.get("name", None)
+        agent_name = chatbot.get("agent_name", None)
+        model_name = chatbot.get("model_name", None)
         try:
             database_id = get_or_create_database_for_chatbot(chatbot, session)
         except ValueError as value_error:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Database not found',
-                str(value_error)
-            )
-        is_running = chatbot.get('is_running', None)
-        params = chatbot.get('params', None)
+            return http_error(HTTPStatus.NOT_FOUND, "Database not found", str(value_error))
+        is_running = chatbot.get("is_running", None)
+        params = chatbot.get("params", None)
 
         # Model needs to exist.
         if model_name is not None:
@@ -253,29 +223,26 @@ class ChatBotResource(Resource):
             try:
                 session.model_controller.get_model(model_name_no_version, version=version, project_name=project_name)
             except PredictorRecordNotFound:
-                return http_error(
-                    HTTPStatus.NOT_FOUND,
-                    'Model not found',
-                    f'Model with name {model_name} not found')
+                return http_error(HTTPStatus.NOT_FOUND, "Model not found", f"Model with name {model_name} not found")
 
         # Agent needs to exist.
         if agent_name is not None:
             agent = session.agents_controller.get_agent(agent_name, project_name)
             if agent is None:
-                return http_error(
-                    HTTPStatus.NOT_FOUND,
-                    'Agent not found',
-                    f'Agent with name {agent_name} not found')
+                return http_error(HTTPStatus.NOT_FOUND, "Agent not found", f"Agent with name {agent_name} not found")
 
         # Chatbot must not exist with new name.
-        if name is not None and name != chatbot_name:
-            chatbot_with_new_name = chatbot_controller.get_chatbot(name, project_name=project_name)
-            if chatbot_with_new_name is not None:
-                return http_error(
-                    HTTPStatus.CONFLICT,
-                    'Chatbot already exists',
-                    f'Chatbot with name {name} already exists. Please choose a different one.'
-                )
+        if name is not None:
+            if name != chatbot_name:
+                chatbot_with_new_name = chatbot_controller.get_chatbot(name, project_name=project_name)
+                if chatbot_with_new_name is not None:
+                    return http_error(
+                        HTTPStatus.CONFLICT,
+                        "Chatbot already exists",
+                        f"Chatbot with name {name} already exists. Please choose a different one.",
+                    )
+            if not name.islower():
+                return http_error(HTTPStatus.BAD_REQUEST, "Wrong name", f"The name must be in lower case: {name}")
 
         if existing_chatbot is None:
             # Create
@@ -290,30 +257,26 @@ class ChatBotResource(Resource):
             agent_name=agent_name,
             database_id=database_id,
             is_running=is_running,
-            params=params
+            params=params,
         )
         return updated_chatbot.as_dict()
 
-    @ns_conf.doc('delete_chatbot')
-    @api_endpoint_metrics('DELETE', '/chatbots/chatbot')
+    @ns_conf.doc("delete_chatbot")
+    @api_endpoint_metrics("DELETE", "/chatbots/chatbot")
     def delete(self, project_name, chatbot_name):
-        '''Deletes a chatbot by name'''
+        """Deletes a chatbot by name"""
         chatbot_controller = ChatBotController()
         try:
             existing_chatbot = chatbot_controller.get_chatbot(chatbot_name, project_name=project_name)
             if existing_chatbot is None:
                 return http_error(
-                    HTTPStatus.NOT_FOUND,
-                    'Chatbot not found',
-                    f'Chatbot with name {chatbot_name} does not exist'
+                    HTTPStatus.NOT_FOUND, "Chatbot not found", f"Chatbot with name {chatbot_name} does not exist"
                 )
         except EntityNotExistsError:
             # Project needs to exist.
             return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Project not found',
-                f'Project with name {project_name} does not exist'
+                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
 
         chatbot_controller.delete_chatbot(chatbot_name, project_name=project_name)
-        return '', HTTPStatus.NO_CONTENT
+        return "", HTTPStatus.NO_CONTENT

mindsdb/api/http/namespaces/file.py

@@ -47,7 +47,7 @@ class File(Resource):
         """
 
         data = {}
-        mindsdb_file_name = name
+        mindsdb_file_name = name.lower()
 
         existing_file_names = ca.file_controller.get_files_names()
 

mindsdb/api/http/namespaces/jobs.py

@@ -1,99 +1,77 @@
 from http import HTTPStatus
 
-from flask import request
+from flask import request, current_app as ca
 from flask_restx import Resource
 
 from mindsdb.api.http.namespaces.configs.projects import ns_conf
 from mindsdb.api.http.utils import http_error
 from mindsdb.metrics.metrics import api_endpoint_metrics
 
-from mindsdb.interfaces.jobs.jobs_controller import JobsController, parse_job_date
+from mindsdb.interfaces.jobs.jobs_controller import parse_job_date
 
 
-@ns_conf.route('/<project_name>/jobs')
+@ns_conf.route("/<project_name>/jobs")
 class JobsResource(Resource):
-    @ns_conf.doc('list_jobs')
-    @api_endpoint_metrics('GET', '/jobs')
+    @ns_conf.doc("list_jobs")
+    @api_endpoint_metrics("GET", "/jobs")
     def get(self, project_name):
-        """ List all jobs in a project """
-        jobs_controller = JobsController()
+        """List all jobs in a project"""
+        return ca.jobs_controller.get_list(project_name)
 
-        return jobs_controller.get_list(project_name)
-
-    @ns_conf.doc('create_job')
-    @api_endpoint_metrics('POST', '/jobs')
+    @ns_conf.doc("create_job")
+    @api_endpoint_metrics("POST", "/jobs")
     def post(self, project_name):
         """Create a job in a project"""
 
         # Check for required parameters.
-        if 'job' not in request.json:
-            return http_error(
-                HTTPStatus.BAD_REQUEST,
-                'Missing parameter',
-                'Must provide "job" parameter in POST body'
-            )
-
-        job = request.json['job']
+        if "job" not in request.json:
+            return http_error(HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "job" parameter in POST body')
 
-        name = job.pop('name')
-        if job['start_at'] is not None:
-            job['start_at'] = parse_job_date(job['start_at'])
-        if job['end_at'] is not None:
-            job['end_at'] = parse_job_date(job['end_at'])
+        job = request.json["job"]
 
-        jobs_controller = JobsController()
+        name = job.pop("name")
+        if job["start_at"] is not None:
+            job["start_at"] = parse_job_date(job["start_at"])
+        if job["end_at"] is not None:
+            job["end_at"] = parse_job_date(job["end_at"])
 
-        create_job_name = jobs_controller.add(name, project_name, **job)
+        create_job_name = ca.jobs_controller.add(name, project_name, **job)
 
-        return jobs_controller.get(create_job_name, project_name)
+        return ca.jobs_controller.get(create_job_name, project_name)
 
 
-@ns_conf.route('/<project_name>/jobs/<job_name>')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('job_name', 'Name of the job')
+@ns_conf.route("/<project_name>/jobs/<job_name>")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("job_name", "Name of the job")
 class JobResource(Resource):
-    @ns_conf.doc('get_job')
-    @api_endpoint_metrics('GET', '/jobs/job')
+    @ns_conf.doc("get_job")
+    @api_endpoint_metrics("GET", "/jobs/job")
     def get(self, project_name, job_name):
         """Gets a job by name"""
-
-        jobs_controller = JobsController()
-        job_info = jobs_controller.get(job_name, project_name)
+        job_info = ca.jobs_controller.get(job_name, project_name)
         if job_info is not None:
             return job_info
 
-        return http_error(
-            HTTPStatus.NOT_FOUND,
-            'Job not found',
-            f'Job with name {job_name} does not exist'
-        )
+        return http_error(HTTPStatus.NOT_FOUND, "Job not found", f"Job with name {job_name} does not exist")
 
-    @ns_conf.doc('delete_job')
-    @api_endpoint_metrics('DELETE', '/jobs/job')
+    @ns_conf.doc("delete_job")
+    @api_endpoint_metrics("DELETE", "/jobs/job")
     def delete(self, project_name, job_name):
         """Deletes a job by name"""
+        ca.jobs_controller.delete(job_name, project_name)
 
-        jobs_controller = JobsController()
-        jobs_controller.delete(job_name, project_name)
+        return "", HTTPStatus.NO_CONTENT
 
-        return '', HTTPStatus.NO_CONTENT
 
-
-@ns_conf.route('/<project_name>/jobs/<job_name>/history')
-@ns_conf.param('project_name', 'Name of the project')
-@ns_conf.param('job_name', 'Name of the job')
+@ns_conf.route("/<project_name>/jobs/<job_name>/history")
+@ns_conf.param("project_name", "Name of the project")
+@ns_conf.param("job_name", "Name of the job")
 class JobsHistory(Resource):
-    @ns_conf.doc('job_history')
-    @api_endpoint_metrics('GET', '/jobs/job/history')
+    @ns_conf.doc("job_history")
+    @api_endpoint_metrics("GET", "/jobs/job/history")
     def get(self, project_name, job_name):
         """Get history of job calls"""
+        if ca.jobs_controller.get(job_name, project_name) is None:
+            return http_error(HTTPStatus.NOT_FOUND, "Job not found", f"Job with name {job_name} does not exist")
 
-        jobs_controller = JobsController()
-        if jobs_controller.get(job_name, project_name) is None:
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                'Job not found',
-                f'Job with name {job_name} does not exist'
-            )
-
-        return jobs_controller.get_history(job_name, project_name)
+        return ca.jobs_controller.get_history(job_name, project_name)