MindsDB 1.3.1__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/api/http/namespaces/auth.py

@@ -0,0 +1,167 @@
+import base64
+import secrets
+import time
+import urllib
+
+import requests
+from flask import redirect, request, session, url_for
+from flask_restx import Resource
+
+from mindsdb.api.http.namespaces.configs.auth import ns_conf
+from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.utilities.config import Config
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+def get_access_token() -> str:
+    """return current access token
+
+    Returns:
+        str: token
+    """
+    return (
+        Config().get("auth", {}).get("oauth", {}).get("tokens", {}).get("access_token")
+    )
+
+
+def request_user_info(access_token: str = None) -> dict:
+    """request user info from cloud
+
+    Args:
+        access_token (str, optional): token that used to get user data
+
+    Returns:
+        dict: user data
+    """
+    if access_token is None:
+        access_token = get_access_token()
+    if access_token is None:
+        raise KeyError()
+
+    auth_server = Config()["auth"]["oauth"]["server_host"]
+
+    response = requests.get(
+        f"https://{auth_server}/auth/userinfo",
+        headers={"Authorization": f"Bearer {access_token}"},
+        timeout=5,
+    )
+    if response.status_code != 200:
+        raise Exception(f"Wrong response: {response.status_code}, {response.text}")
+
+    return response.json()
+
+
+@ns_conf.route("/callback", methods=["GET"])
+@ns_conf.route("/callback/cloud_home", methods=["GET"])
+@ns_conf.hide
+class Auth(Resource):
+    @ns_conf.doc(params={"code": "authentification code"})
+    @api_endpoint_metrics('GET', '/auth/code')
+    def get(self):
+        """callback from auth server if authentification is successful"""
+        config = Config()
+        code = request.args.get("code")
+
+        aws_meta_data = config["aws_meta_data"]
+        public_hostname = aws_meta_data["public-hostname"]
+        instance_id = aws_meta_data["instance-id"]
+
+        oauth_meta = config["auth"]["oauth"]
+        client_id = oauth_meta["client_id"]
+        client_secret = oauth_meta["client_secret"]
+        auth_server = oauth_meta["server_host"]
+        client_basic = base64.b64encode(
+            f"{client_id}:{client_secret}".encode()
+        ).decode()
+
+        redirect_uri = f"https://{public_hostname}{request.path}"
+        response = requests.post(
+            f"https://{auth_server}/auth/token",
+            data={
+                "code": code,
+                "grant_type": "authorization_code",
+                "redirect_uri": redirect_uri,
+            },
+            headers={"Authorization": f"Basic {client_basic}"},
+        )
+        tokens = response.json()
+        if "expires_in" in tokens:
+            tokens["expires_at"] = round(time.time() + tokens["expires_in"] - 1)
+            del tokens["expires_in"]
+
+        user_data = request_user_info(tokens["access_token"])
+
+        previous_username = config["auth"]["oauth"].get("username")
+        new_username = user_data["name"]
+        if previous_username is not None and new_username != previous_username:
+            return redirect("/forbidden")
+
+        config.update(
+            {
+                "auth": {
+                    "provider": "cloud",
+                    "oauth": {"username": new_username, "tokens": tokens},
+                }
+            }
+        )
+
+        try:
+            resp = requests.put(
+                f"https://{auth_server}/cloud/instance",
+                json={
+                    "instance_id": instance_id,
+                    "public_hostname": public_hostname,
+                    "ami_id": aws_meta_data.get("ami-id"),
+                },
+                headers={"Authorization": f'Bearer {tokens["access_token"]}'},
+                timeout=5,
+            )
+            if resp.status_code != 200:
+                logger.warning(f"Wrong response from cloud server: {resp.status_code}")
+        except Exception as e:
+            logger.warning(f"Cant't send request to cloud server: {e}")
+
+        session["username"] = user_data["name"]
+        session["auth_provider"] = "cloud"
+        session.permanent = True
+
+        if request.path.endswith("/auth/callback/cloud_home"):
+            return redirect(f"https://{auth_server}")
+        else:
+            return redirect(url_for("root_index"))
+
+
+@ns_conf.route("/cloud_login", methods=["GET"])
+@ns_conf.hide
+class CloudLoginRoute(Resource):
+    @ns_conf.doc(
+        responses={302: "Redirect to auth server"},
+        params={"location": "final redirection should lead to that location"},
+    )
+    @api_endpoint_metrics('GET', '/auth/cloud_login')
+    def get(self):
+        """redirect to cloud login form"""
+        location = request.args.get("location")
+        config = Config()
+
+        aws_meta_data = config["aws_meta_data"]
+        public_hostname = aws_meta_data["public-hostname"]
+        auth_server = config["auth"]["oauth"]["server_host"]
+
+        if location == "cloud_home":
+            redirect_uri = f"https://{public_hostname}/api/auth/callback/cloud_home"
+        else:
+            redirect_uri = f"https://{public_hostname}/api/auth/callback"
+
+        args = urllib.parse.urlencode(
+            {
+                "client_id": config["auth"]["oauth"]["client_id"],
+                "scope": "openid profile aws_marketplace",
+                "response_type": "code",
+                "nonce": secrets.token_urlsafe(),
+                "redirect_uri": redirect_uri,
+            }
+        )
+        return redirect(f"https://{auth_server}/auth/authorize?{args}")

mindsdb/api/http/namespaces/chatbots.py

@@ -0,0 +1,318 @@
+from http import HTTPStatus
+
+from flask import request
+from flask_restx import Resource
+
+from mindsdb.api.http.namespaces.configs.projects import ns_conf
+from mindsdb.interfaces.agents.agents_controller import AgentsController
+from mindsdb.api.executor.controllers.session_controller import SessionController
+from mindsdb.api.http.utils import http_error
+from mindsdb.metrics.metrics import api_endpoint_metrics
+from mindsdb.interfaces.chatbot.chatbot_controller import ChatBotController
+from mindsdb.interfaces.model.functions import PredictorRecordNotFound
+from mindsdb.interfaces.storage.db import Predictor
+
+
+def create_chatbot(project_name, name, chatbot):
+    if name is None:
+        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 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'
+        )
+
+    session_controller = SessionController()
+
+    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)
+            )
+
+    else:
+        return http_error(
+            HTTPStatus.BAD_REQUEST,
+            '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', {})
+
+    chatbot_controller = ChatBotController()
+
+    # Chatbot can't already exist.
+    # TODO all checks should be inside of controller
+
+    try:
+        existing_chatbot = chatbot_controller.get_chatbot(name, project_name=project_name)
+    except ValueError:
+        # Project must 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'
+        )
+
+    # 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'
+            )
+        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')
+
+    created_chatbot = chatbot_controller.add_chatbot(
+        name,
+        project_name,
+        model_name=model_name,
+        agent_name=agent_name,
+        database_id=database_id,
+        is_running=is_running,
+        params=params
+    )
+    return created_chatbot.as_dict(), HTTPStatus.CREATED
+
+
+def get_or_create_database_for_chatbot(chatbot: dict, session_controller: SessionController) -> int:
+    """
+    Get or create a database for a chatbot, based on the chatbot configuration provided in the request.
+
+    Args:
+        chatbot (dict): The chatbot configuration.
+        session_controller (SessionController): The session controller.
+
+    Returns:
+        int: The 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']
+        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'])
+        if database_record:
+            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'
+
+        # try to drop
+        existing_db = session_controller.integration_controller.get(db_name)
+        if existing_db:
+            # drop
+            session_controller.integration_controller.delete(db_name)
+
+        return session_controller.integration_controller.add(db_name, chatbot['db_engine'], chatbot['db_params'])
+
+    return None
+
+
+@ns_conf.route('/<project_name>/chatbots')
+class ChatBotsResource(Resource):
+    @ns_conf.doc('list_chatbots')
+    @api_endpoint_metrics('GET', '/chatbots')
+    def get(self, project_name):
+        ''' List all chatbots '''
+        chatbot_controller = ChatBotController()
+        try:
+            all_bots = chatbot_controller.get_chatbots(project_name)
+        except ValueError:
+            # Project needs to exist.
+            return http_error(
+                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')
+    def post(self, project_name):
+        '''Create a chatbot'''
+
+        # Check for required parameters.
+        if 'chatbot' not in request.json:
+            return http_error(
+                HTTPStatus.BAD_REQUEST,
+                'Missing parameter',
+                'Must provide "chatbot" parameter in POST body'
+            )
+
+        chatbot = request.json['chatbot']
+
+        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')
+class ChatBotResource(Resource):
+    @ns_conf.doc('get_chatbot')
+    @api_endpoint_metrics('GET', '/chatbots/chatbot')
+    def get(self, project_name, chatbot_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'
+                )
+            return existing_chatbot
+        except ValueError:
+            # Project needs to exist.
+            return http_error(
+                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')
+    def put(self, project_name, chatbot_name):
+        '''Updates a chatbot by name, creating one if it doesn't exist'''
+
+        # Check for required parameters.
+        if 'chatbot' not in request.json:
+            return http_error(
+                HTTPStatus.BAD_REQUEST,
+                'Missing parameter',
+                'Must provide "chatbot" parameter in POST body'
+            )
+        chatbot_controller = ChatBotController()
+
+        try:
+            existing_chatbot = chatbot_controller.get_chatbot(chatbot_name, project_name=project_name)
+        except ValueError:
+            # Project needs to exist.
+            return http_error(
+                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)
+        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)
+
+        # Model needs to exist.
+        if model_name is not None:
+            model_name_no_version, version = Predictor.get_name_and_version(model_name)
+            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')
+
+        # 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')
+
+        # 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 existing_chatbot is None:
+            # Create
+            return create_chatbot(project_name, name, chatbot)
+
+        # Update
+        updated_chatbot = chatbot_controller.update_chatbot(
+            chatbot_name,
+            project_name=project_name,
+            name=name,
+            model_name=model_name,
+            agent_name=agent_name,
+            database_id=database_id,
+            is_running=is_running,
+            params=params
+        )
+        return updated_chatbot.as_dict()
+
+    @ns_conf.doc('delete_chatbot')
+    @api_endpoint_metrics('DELETE', '/chatbots/chatbot')
+    def delete(self, project_name, chatbot_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'
+                )
+        except ValueError:
+            # Project needs to exist.
+            return http_error(
+                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