MindsDB 25.3.4.0__py3-none-any.whl → 25.3.4.2__py3-none-any.whl

mindsdb/integrations/handlers/ms_teams_handler/ms_teams_tables.py

@@ -33,10 +33,10 @@ class TeamsTable(APIResource):
             targets (List[str]): The list of target columns to return.
         """
         client: MSGraphAPITeamsDelegatedPermissionsClient = self.handler.connect()
-        teams = client.get_all_groups()
+        teams = client.get_teams()
 
         teams_df = pd.json_normalize(teams, sep="_")
-        teams_df = teams_df[self.get_columns()]
+        teams_df = teams_df.reindex(columns=self.get_columns(), fill_value=None)
 
         return teams_df
 
@@ -114,18 +114,7 @@ class ChannelsTable(APIResource):
 
                 condition.applied = True
 
-        if team_id:
-            if channel_ids:
-                channels = client.get_channels_in_group_by_ids(team_id, channel_ids)
-
-            else:
-                channels = client.get_all_channels_in_group(team_id)
-
-        elif channel_ids:
-            channels = client.get_channels_across_all_groups_by_ids(channel_ids)
-
-        else:
-            channels = client.get_all_channels_across_all_groups()
+        channels = client.get_channels(team_id, channel_ids)
 
         channels_df = pd.json_normalize(channels, sep="_")
         channels_df = channels_df[self.get_columns()]
@@ -218,11 +207,7 @@ class ChannelMessagesTable(APIResource):
         if not group_id or not channel_id:
             raise ValueError("The 'channelIdentity_teamId' and 'channelIdentity_channelId' columns are required.")
         
-        if message_ids:
-            messages = client.get_messages_in_channel_by_ids(group_id, channel_id, message_ids)
-
-        else:
-            messages = client.get_all_messages_in_channel(group_id, channel_id, limit)
+        messages = client.get_channel_messages(group_id, channel_id, message_ids)
 
         messages_df = pd.json_normalize(messages, sep="_")
         messages_df = messages_df[self.get_columns()]
@@ -304,11 +289,7 @@ class ChatsTable(APIResource):
 
                 condition.applied = True
 
-        if chat_ids:
-            chats = client.get_chats_by_ids(chat_ids)
-
-        else:
-            chats = client.get_all_chats(limit)
+        chats = client.get_chats(chat_ids)
 
         chats_df = pd.json_normalize(chats, sep="_")
         chats_df = chats_df[self.get_columns()]
@@ -387,11 +368,7 @@ class ChatMessagesTable(APIResource):
         if not chat_id:
             raise ValueError("The 'chatId' column is required.")
         
-        if message_ids:
-            messages = client.get_messages_in_chat_by_ids(chat_id, message_ids)
-
-        else:
-            messages = client.get_all_messages_in_chat(chat_id, limit)
+        messages = client.get_chat_messages(chat_id, message_ids)
 
         messages_df = pd.json_normalize(messages, sep="_")
         messages_df = messages_df[self.get_columns()]

mindsdb/integrations/handlers/mssql_handler/mssql_handler.py

@@ -13,10 +13,43 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+
 
 logger = log.getLogger(__name__)
 
 
+def _map_type(mssql_type_text: str) -> MYSQL_DATA_TYPE:
+    """ Map MSSQL text types names to MySQL types as enum.
+
+    Args:
+        mssql_type_text (str): The name of the MSSQL type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type enum that corresponds to the MSSQL text type name.
+    """
+    internal_type_name = mssql_type_text.lower()
+    types_map = {
+        ('tinyint', 'smallint', 'int', 'bigint'): MYSQL_DATA_TYPE.INT,
+        ('bit',): MYSQL_DATA_TYPE.BOOL,
+        ('money', 'smallmoney', 'float', 'real'): MYSQL_DATA_TYPE.FLOAT,
+        ('decimal', 'numeric'): MYSQL_DATA_TYPE.DECIMAL,
+        ('date',): MYSQL_DATA_TYPE.DATE,
+        ('time',): MYSQL_DATA_TYPE.TIME,
+        ('datetime2', 'datetimeoffset', 'datetime', 'smalldatetime'): MYSQL_DATA_TYPE.DATETIME,
+        ('varchar', 'nvarchar'): MYSQL_DATA_TYPE.VARCHAR,
+        ('char', 'text', 'nchar', 'ntext'): MYSQL_DATA_TYPE.TEXT,
+        ('binary', 'varbinary', 'image'): MYSQL_DATA_TYPE.BINARY
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"MSSQL handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class SqlServerHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Microsoft SQL Server statements.
@@ -215,4 +248,7 @@ class SqlServerHandler(DatabaseHandler):
             WHERE
                 table_name = '{table_name}'
         """
-        return self.native_query(query)
+        result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
+        return result

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -13,10 +13,27 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE
 )
 from mindsdb.integrations.handlers.mysql_handler.settings import ConnectionConfig
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 logger = log.getLogger(__name__)
 
 
+def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
+    """ Map MySQL text types names to MySQL types as enum.
+
+    Args:
+        mysql_type_text (str): The name of the MySQL type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type enum that corresponds to the MySQL text type name.
+    """
+    try:
+        return MYSQL_DATA_TYPE(mysql_type_text.upper())
+    except Exception:
+        logger.warning(f'MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback.')
+        return MYSQL_DATA_TYPE.TEXT
+
+
 class MySQLHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the MySQL statements.
@@ -94,6 +111,8 @@ class MySQLHandler(DatabaseHandler):
                 config["ssl_key"] = ssl_key
         if 'collation' not in config:
             config['collation'] = 'utf8mb4_general_ci'
+        if 'use_pure' not in config:
+            config['use_pure'] = True
         try:
             connection = mysql.connector.connect(**config)
             connection.autocommit = True
@@ -209,6 +228,16 @@ class MySQLHandler(DatabaseHandler):
         """
         Show details about the table
         """
-        q = f"DESCRIBE `{table_name}`;"
+        q = f"""
+            select
+                COLUMN_NAME AS FIELD, DATA_TYPE AS TYPE
+            from
+                information_schema.columns
+            where
+                table_name = '{table_name}'
+        """
         result = self.native_query(q)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
         return result

mindsdb/integrations/handlers/oracle_handler/oracle_handler.py

@@ -1,10 +1,9 @@
 from typing import Text, Dict, Optional
 
-from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 import oracledb
-from oracledb import connect, Connection, DatabaseError
 import pandas as pd
+from oracledb import connect, Connection, DatabaseError
+from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.integrations.libs.response import (
@@ -13,12 +12,52 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE,
 )
 from mindsdb.utilities import log
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
 oracledb.defaults.fetch_lobs = False  # Return LOBs directly as strings or bytes.
 logger = log.getLogger(__name__)
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """ Map Oracle types to MySQL types.
+        List of types: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+
+    Args:
+        internal_type_name (str): The name of the Oracle type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Oracle type.
+    """
+    internal_type_name = internal_type_name.upper()
+    types_map = {
+        (
+            'VARCHAR2', 'NVARCHAR2', 'CHARACTER VARYING', 'CHAR VARYING', 'NATIONAL CHARACTER', 'NATIONAL CHAR',
+            'VARCHAR', 'NCHAR', 'NATIONAL CHARACTER VARYING', 'NATIONAL CHAR VARYING', 'NCHAR VARYING', 'LONG VARCHAR'
+        ): MYSQL_DATA_TYPE.VARCHAR,
+        ('INTEGER', 'INT'): MYSQL_DATA_TYPE.INT,
+        ('SMALLINT',): MYSQL_DATA_TYPE.SMALLINT,
+        ('NUMBER', 'DECIMAL'): MYSQL_DATA_TYPE.DECIMAL,
+        ('FLOAT', 'BINARY_FLOAT', 'REAL'): MYSQL_DATA_TYPE.FLOAT,
+        ('BINARY_DOUBLE',): MYSQL_DATA_TYPE.DOUBLE,
+        ('LONG',): MYSQL_DATA_TYPE.BIGINT,
+        ('DATE',): MYSQL_DATA_TYPE.DATE,
+        ('HOUR', 'MINUTE', 'SECOND', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE'): MYSQL_DATA_TYPE.SMALLINT,
+        ('TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE'): MYSQL_DATA_TYPE.TIMESTAMP,
+        ('RAW', 'LONG RAW', 'BLOB', 'BFILE'): MYSQL_DATA_TYPE.BINARY,
+        ('ROWID', 'UROWID'): MYSQL_DATA_TYPE.TEXT,
+        ('CHAR', 'NCHAR', 'CLOB', 'NCLOB', 'CHARACTER'): MYSQL_DATA_TYPE.CHAR,
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Oracle handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class OracleHandler(DatabaseHandler):
     """
     This handler handles connection and execution of SQL queries on Oracle.
@@ -94,6 +133,12 @@ class OracleHandler(DatabaseHandler):
             connection = connect(
                 **config,
             )
+
+            if 'session_variables' in self.connection_data:
+                with connection.cursor() as cur:
+                    for key, value in self.connection_data['session_variables'].items():
+                        cur.execute(f"ALTER SESSION SET {key} = {repr(value)}")
+
         except DatabaseError as database_error:
             logger.error(f'Error connecting to Oracle, {database_error}!')
             raise
@@ -237,10 +282,13 @@ class OracleHandler(DatabaseHandler):
         """
         query = f"""
             SELECT
-                column_name,
-                data_type
+                column_name AS field,
+                data_type AS type
             FROM USER_TAB_COLUMNS
             WHERE table_name = '{table_name}'
         """
         result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
+            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
         return result

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -20,12 +20,44 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE
 )
 import mindsdb.utilities.profiler as profiler
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 logger = log.getLogger(__name__)
 
 SUBSCRIBE_SLEEP_INTERVAL = 1
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """Map Postgres types to MySQL types.
+
+    Args:
+        internal_type_name (str): The name of the Postgres type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Postgres type.
+    """
+    internal_type_name = internal_type_name.lower()
+    types_map = {
+        ('smallint', 'integer', 'bigint', 'int', 'smallserial', 'serial', 'bigserial'): MYSQL_DATA_TYPE.INT,
+        ('real', 'money', 'float'): MYSQL_DATA_TYPE.FLOAT,
+        ('numeric', 'decimal'): MYSQL_DATA_TYPE.DECIMAL,
+        ('double precision',): MYSQL_DATA_TYPE.DOUBLE,
+        ('character varying', 'varchar', 'character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
+        ('timestamp', 'timestamp without time zone', 'timestamp with time zone'): MYSQL_DATA_TYPE.DATETIME,
+        ('date', ): MYSQL_DATA_TYPE.DATE,
+        ('time', 'time without time zone', 'time with time zone'): MYSQL_DATA_TYPE.TIME,
+        ('boolean',): MYSQL_DATA_TYPE.BOOL,
+        ('bytea',): MYSQL_DATA_TYPE.BINARY,
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Postgres handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class PostgresHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the PostgreSQL statements.
@@ -314,7 +346,11 @@ class PostgresHandler(DatabaseHandler):
             AND
                 table_schema = {schema_name}
         """
-        return self.native_query(query)
+        result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
+            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
+        return result
 
     def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
         config = self._make_connection_args()

mindsdb/integrations/handlers/ray_serve_handler/ray_serve_handler.py

@@ -81,27 +81,29 @@ class RayServeHandler(BaseMLEngine):
             resp = requests.post(args['predict_url'],
                                  json={'df': df.to_json(orient='records'), 'pred_args': pred_args},
                                  headers={'content-type': 'application/json; format=pandas-records'})
-        try:
-            if args.get('is_parquet', False):
+        content_type = resp.headers.get("Content-Type", "")
+        if "application/octet-stream" in content_type:
+            try:
                 buffer = io.BytesIO(resp.content)
                 table = pq.read_table(buffer)
                 response = table.to_pandas()
-            else:
+            except Exception:
+                error = 'Could not decode parquet.'
+        else:
+            try:
                 response = resp.json()
-        except json.JSONDecodeError:
-            error = resp.text
-        except Exception:
-            error = 'Could not decode parquet.'
+            except json.JSONDecodeError:
+                error = resp.text
+
+        if 'prediction' in response:
+            target = args['target']
+            if target != 'prediction':
+                # rename prediction to target
+                response[target] = response.pop('prediction')
+            return pd.DataFrame(response)
         else:
-            if 'prediction' in response:
-                target = args['target']
-                if target != 'prediction':
-                    # rename prediction to target
-                    response[target] = response.pop('prediction')
-                return pd.DataFrame(response)
-            else:
-                # something wrong
-                error = response
+            # something wrong
+            error = response
 
         raise RayServeException(f"Error: {error}")
 

mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -7,6 +7,8 @@ from snowflake.connector.errors import NotSupportedError
 
 from mindsdb.utilities import log
 from mindsdb_sql_parser.ast.base import ASTNode
+from mindsdb_sql_parser.ast import Select, Identifier
+
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.response import (
@@ -14,6 +16,7 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 try:
     import pyarrow as pa
@@ -25,6 +28,43 @@ except Exception:
 logger = log.getLogger(__name__)
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """ Map Snowflake types to MySQL types.
+
+    Args:
+        internal_type_name (str): The name of the Snowflake type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Snowflake type.
+    """
+    internal_type_name = internal_type_name.upper()
+    types_map = {
+        ('NUMBER', 'DECIMAL', 'DEC', 'NUMERIC'): MYSQL_DATA_TYPE.DECIMAL,
+        ('INT , INTEGER , BIGINT , SMALLINT , TINYINT , BYTEINT'): MYSQL_DATA_TYPE.INT,
+        ('FLOAT', 'FLOAT4', 'FLOAT8'): MYSQL_DATA_TYPE.FLOAT,
+        ('DOUBLE', 'DOUBLE PRECISION', 'REAL'): MYSQL_DATA_TYPE.DOUBLE,
+        ('VARCHAR'): MYSQL_DATA_TYPE.VARCHAR,
+        ('CHAR', 'CHARACTER', 'NCHAR'): MYSQL_DATA_TYPE.CHAR,
+        ('STRING', 'TEXT', 'NVARCHAR'): MYSQL_DATA_TYPE.TEXT,
+        ('NVARCHAR2', 'CHAR VARYING', 'NCHAR VARYING'): MYSQL_DATA_TYPE.VARCHAR,
+        ('BINARY', 'VARBINARY'): MYSQL_DATA_TYPE.BINARY,
+        ('BOOLEAN',): MYSQL_DATA_TYPE.BOOL,
+        ('TIMESTAMP_NTZ', 'DATETIME'): MYSQL_DATA_TYPE.DATETIME,
+        ('DATE',): MYSQL_DATA_TYPE.DATE,
+        ('TIME',): MYSQL_DATA_TYPE.TIME,
+        ('TIMESTAMP_LTZ'): MYSQL_DATA_TYPE.DATETIME,
+        ('TIMESTAMP_TZ'): MYSQL_DATA_TYPE.DATETIME,
+        ('VARIANT', 'OBJECT', 'ARRAY', 'MAP', 'GEOGRAPHY', 'GEOMETRY', 'VECTOR'): MYSQL_DATA_TYPE.VARCHAR
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Snowflake handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class SnowflakeHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Snowflake statements.
@@ -234,7 +274,30 @@ class SnowflakeHandler(DatabaseHandler):
 
         query_str = self.renderer.get_string(query, with_failback=True)
         logger.debug(f"Executing SQL query: {query_str}")
-        return self.native_query(query_str)
+        result = self.native_query(query_str)
+        return self.lowercase_columns(result, query)
+
+    def lowercase_columns(self, result, query):
+        if not isinstance(query, Select) or result.data_frame is None:
+            return result
+
+        quoted_columns = []
+        if query.targets is not None:
+            for column in query.targets:
+                if hasattr(column, 'alias') and column.alias is not None:
+                    if column.alias.is_quoted[-1]:
+                        quoted_columns.append(column.alias.parts[-1])
+                elif isinstance(column, Identifier):
+                    if column.is_quoted[-1]:
+                        quoted_columns.append(column.parts[-1])
+
+        rename_columns = {}
+        for col in result.data_frame.columns:
+            if col.isupper() and col not in quoted_columns:
+                rename_columns[col] = col.lower()
+        if rename_columns:
+            result.data_frame = result.data_frame.rename(columns=rename_columns)
+        return result
 
     def get_tables(self) -> Response:
         """
@@ -261,6 +324,7 @@ class SnowflakeHandler(DatabaseHandler):
 
         Returns:
             Response: A response object containing the column details, formatted as per the `Response` class.
+
         Raises:
             ValueError: If the 'table_name' is not a valid string.
         """
@@ -275,6 +339,8 @@ class SnowflakeHandler(DatabaseHandler):
               AND TABLE_SCHEMA = current_schema()
         """
         result = self.native_query(query)
-        result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
 
         return result

mindsdb/integrations/utilities/handlers/auth_utilities/__init__.py

@@ -1,2 +1,2 @@
 from .google import GoogleUserOAuth2Manager, GoogleServiceAccountOAuth2Manager
-from .microsoft import MSGraphAPIDelegatedPermissionsManager
+from .microsoft import MSGraphAPIApplicationPermissionsManager, MSGraphAPIDelegatedPermissionsManager

mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/__init__.py

@@ -1 +1 @@
-from .ms_graph_api_auth_utilities import MSGraphAPIDelegatedPermissionsManager
+from .ms_graph_api_auth_utilities import MSGraphAPIApplicationPermissionsManager, MSGraphAPIDelegatedPermissionsManager

mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/ms_graph_api_auth_utilities.py

@@ -1,3 +1,4 @@
+from abc import ABC, abstractmethod
 from typing import Dict, List, Text
 
 from flask import request
@@ -6,12 +7,13 @@ import msal
 from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 from mindsdb.utilities import log
 
+
 logger = log.getLogger(__name__)
 
 
-class MSGraphAPIDelegatedPermissionsManager:
+class MSGraphAPIPermissionsManager(ABC):
     """
-    The class for managing the delegated permissions for the Microsoft Graph API.
+    The base class for managing the delegated permissions for the Microsoft Graph API.
     """
     def __init__(
         self,
@@ -20,10 +22,9 @@ class MSGraphAPIDelegatedPermissionsManager:
         tenant_id: Text,
         cache: msal.SerializableTokenCache,
         scopes: List = ["https://graph.microsoft.com/.default"],
-        code: Text = None,
     ) -> None:
         """
-        Initializes the delegated permissions manager.
+        Initializes the permissions manager.
 
         Args:
             client_id (Text): The client ID of the application registered in Microsoft Entra ID.
@@ -38,8 +39,68 @@ class MSGraphAPIDelegatedPermissionsManager:
         self.tenant_id = tenant_id
         self.cache = cache
         self.scopes = scopes
+
+    @abstractmethod
+    def get_access_token(self) -> Text:
+        """
+        Retrieves an access token for the Microsoft Graph API.
+
+        Returns:
+            Text: The access token for the Microsoft Graph API.
+        """
+        pass
+
+    def _get_msal_app(self) -> msal.ConfidentialClientApplication:
+        """
+        Returns an instance of the MSAL ConfidentialClientApplication.
+
+        Returns:
+            msal.ConfidentialClientApplication: An instance of the MSAL ConfidentialClientApplication.
+        """
+        return msal.ConfidentialClientApplication(
+            self.client_id,
+            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
+            client_credential=self.client_secret,
+            token_cache=self.cache,
+        )
+
+
+class MSGraphAPIDelegatedPermissionsManager(MSGraphAPIPermissionsManager):
+    """
+    The class for managing the delegated permissions for the Microsoft Graph API.
+    """
+    def __init__(
+        self,
+        client_id: Text,
+        client_secret: Text,
+        tenant_id: Text,
+        cache: msal.SerializableTokenCache,
+        scopes: List = ["https://graph.microsoft.com/.default"],
+        code: Text = None,
+    ) -> None:
+        """
+        Initializes the delegated permissions manager.
+
+        Args:
+            client_id (Text): The client ID of the application registered in Microsoft Entra ID.
+            client_secret (Text): The client secret of the application registered in Microsoft Entra ID.
+            tenant_id (Text): The tenant ID of the application registered in Microsoft Entra ID.
+            cache (msal.SerializableTokenCache): The token cache for storing the access token.
+            scopes (List): The scopes for the Microsoft Graph API.
+            code (Text): The authentication code for acquiring the access token.
+        """
+        super().__init__(client_id, client_secret, tenant_id, cache, scopes)
         self.code = code
+        self.redirect_uri = None
+        self._set_redirect_uri()
+
+    def _set_redirect_uri(self) -> None:
+        """
+        Sets the redirect URI based on the request origin.
 
+        Raises:
+            AuthException: If the request origin could not be determined.
+        """
         # Set the redirect URI based on the request origin.
         # If the request origin is 127.0.0.1 (localhost), replace it with localhost.
         # This is done because the only HTTP origin allowed in Microsoft Entra ID app registration is localhost.
@@ -85,20 +146,6 @@ class MSGraphAPIDelegatedPermissionsManager:
                 auth_url=response.get('auth_url')
             )
 
-    def _get_msal_app(self) -> msal.ConfidentialClientApplication:
-        """
-        Returns an instance of the MSAL ConfidentialClientApplication.
-
-        Returns:
-            msal.ConfidentialClientApplication: An instance of the MSAL ConfidentialClientApplication.
-        """
-        return msal.ConfidentialClientApplication(
-            self.client_id,
-            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
-            client_credential=self.client_secret,
-            token_cache=self.cache,
-        )
-
     def _execute_ms_graph_api_auth_flow(self) -> Dict:
         """
         Executes the authentication flow for the Microsoft Graph API.
@@ -131,3 +178,35 @@ class MSGraphAPIDelegatedPermissionsManager:
             )
 
             raise AuthException(f'Authorisation required. Please follow the url: {auth_url}', auth_url=auth_url)
+
+
+class MSGraphAPIApplicationPermissionsManager(MSGraphAPIPermissionsManager):
+    """
+    The class for managing application permissions for the Microsoft Graph API.
+    """
+
+    def get_access_token(self) -> Text:
+        """
+        Retrieves an access token for the Microsoft Graph API using the client credentials flow.
+
+        Returns:
+            Text: The access token for the Microsoft Graph API.
+        """
+        msal_app = self._get_msal_app()
+
+        # Check if a valid access token is already in the cache.
+        accounts = msal_app.get_accounts()
+        if accounts:
+            response = msal_app.acquire_token_silent(self.scopes, account=accounts[0])
+            if "access_token" in response:
+                return response["access_token"]
+
+        # If no valid access token is found in the cache, acquire a new token using client credentials.
+        response = msal_app.acquire_token_for_client(scopes=self.scopes)
+
+        if "access_token" in response:
+            return response["access_token"]
+        else:
+            raise AuthException(
+                f"Error getting access token: {response.get('error_description')}"
+            )