castor-extractor 0.17.4__py3-none-any.whl → 0.18.5__py3-none-any.whl

castor_extractor/visualization/metabase/client/api/client.py

@@ -9,7 +9,7 @@ from ...assets import EXPORTED_FIELDS, MetabaseAsset
 from ...errors import MetabaseLoginError, SuperuserCredentialsRequired
 from ...types import IdsType
 from ..shared import DETAILS_KEY, get_dbname_from_details
-from .credentials import CredentialsApi, CredentialsApiKey, get_value
+from .credentials import MetabaseApiCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -30,13 +30,11 @@ class ApiClient:
 
     def __init__(
         self,
-        **kwargs,
+        credentials: MetabaseApiCredentials,
     ):
-        self._credentials = CredentialsApi(
-            base_url=get_value(CredentialsApiKey.BASE_URL, kwargs),
-            user=get_value(CredentialsApiKey.USER, kwargs),
-            password=get_value(CredentialsApiKey.PASSWORD, kwargs),
-        )
+        self.base_url = credentials.base_url
+
+        self._credentials = credentials
         self._session = requests.Session()
         self._session_id = self._login()
         self._check_permissions()  # verify that the given user is superuser
@@ -46,13 +44,9 @@ class ApiClient:
         """return the name of the client"""
         return "Metabase/API"
 
-    def base_url(self) -> str:
-        """Return base_url from credentials"""
-        return self._credentials.base_url
-
     def _url(self, endpoint: str) -> str:
         return URL_TEMPLATE.format(
-            base_url=self._credentials.base_url,
+            base_url=self.base_url,
             endpoint=endpoint,
         )
 
@@ -85,7 +79,7 @@ class ApiClient:
         except HTTPError as err:
             if err.response.status_code == 403:  # forbidden
                 raise SuperuserCredentialsRequired(
-                    credentials_info=self._credentials.to_dict(hide=True),
+                    credentials_info=self._credentials,
                     error_details=err.args,
                 )
             raise
@@ -101,7 +95,7 @@ class ApiClient:
 
         if not response.json().get("id"):
             raise MetabaseLoginError(
-                credentials_info=self._credentials.to_dict(hide=True),
+                credentials_info=self._credentials,
                 error_details=response.json(),
             )
 

castor_extractor/visualization/metabase/client/api/credentials.py

@@ -1,45 +1,18 @@
-from enum import Enum
-from typing import Dict
+from pydantic import Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from .....utils import from_env
+METABASE_API_ENV_PREFIX = "CASTOR_METABASE_API_"
 
 
-class CredentialsApiKey(Enum):
-    BASE_URL = "base_url"
-    USER = "user"
-    PASSWORD = "password"  # noqa: S105
+class MetabaseApiCredentials(BaseSettings):
+    """Metabase's credentials to connect to Metabase API"""
 
+    model_config = SettingsConfigDict(
+        env_prefix=METABASE_API_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
 
-CREDENTIALS_ENV: Dict[CredentialsApiKey, str] = {
-    CredentialsApiKey.BASE_URL: "CASTOR_METABASE_API_BASE_URL",
-    CredentialsApiKey.USER: "CASTOR_METABASE_API_USERNAME",
-    CredentialsApiKey.PASSWORD: "CASTOR_METABASE_API_PASSWORD",
-}
-
-
-def get_value(key: CredentialsApiKey, kwargs: dict) -> str:
-    """
-    Returns the value of the given key:
-    - from kwargs in priority
-    - from ENV if not provided (raises an error if not found in ENV)
-    """
-    env_key = CREDENTIALS_ENV[key]
-    return str(kwargs.get(key.value) or from_env(env_key))
-
-
-class CredentialsApi:
-    """ValueObject for the credentials"""
-
-    def __init__(self, base_url: str, user: str, password: str):
-        self.base_url = base_url
-        self.user = user
-        self.password = password
-
-    def to_dict(self, hide: bool = False) -> Dict[str, str]:
-        safe = (CredentialsApiKey.BASE_URL, CredentialsApiKey.USER)
-        unsafe = (CredentialsApiKey.PASSWORD,)
-
-        def val(k: CredentialsApiKey, v: str) -> str:
-            return "*" + v[-4:] if hide and k in unsafe else v
-
-        return {a.value: val(a, getattr(self, a.value)) for a in safe + unsafe}
+    base_url: str
+    user: str = Field(validation_alias="CASTOR_METABASE_API_USERNAME")
+    password: str = Field(repr=False)

castor_extractor/visualization/metabase/client/db/__init__.py

@@ -1 +1,2 @@
 from .client import DbClient
+from .credentials import MetabaseDbCredentials

castor_extractor/visualization/metabase/client/db/client.py

@@ -1,23 +1,15 @@
 import json
 import logging
 import os
-from typing import Optional
 
-from sqlalchemy import create_engine
-from sqlalchemy.engine import Engine
 from sqlalchemy.exc import OperationalError
 
-from .....utils import (
-    ExtractionQuery,
-    PostgresClient,
-    SerializedAsset,
-    from_env,
-)
+from .....utils import ExtractionQuery, PostgresClient, SerializedAsset
 from ...assets import EXPORTED_FIELDS, MetabaseAsset
 from ...errors import EncryptionSecretKeyRequired, MetabaseLoginError
 from ..decryption import decrypt
 from ..shared import DETAILS_KEY, get_dbname_from_details
-from .credentials import CredentialsDb, CredentialsDbKey, get_value
+from .credentials import MetabaseDbCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -25,16 +17,6 @@ CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
 SQL_FILE_PATH = "queries/{name}.sql"
 
-ENCRYPTION_SECRET_KEY = "CASTOR_METABASE_ENCRYPTION_SECRET_KEY"  # noqa: S105
-REQUIRE_SSL_KEY = "CASTOR_METABASE_REQUIRE_SSL_KEY"  # noqa: S105
-
-
-def _optional_arg(args: dict, client_key: str, env_key: str) -> Optional[str]:
-    arg_value = args.get(client_key)
-    if arg_value is not None:
-        return arg_value
-    return from_env(env_key, allow_missing=True)
-
 
 class DbClient(PostgresClient):
     """
@@ -52,20 +34,15 @@ class DbClient(PostgresClient):
 
     def __init__(
         self,
-        **kwargs,
+        credentials: MetabaseDbCredentials,
     ):
-        self._credentials = CredentialsDb.from_env(kwargs)
-        self.encryption_secret_key = _optional_arg(
-            kwargs, "encryption_secret_key", ENCRYPTION_SECRET_KEY
-        )
-        self.require_ssl = bool(
-            _optional_arg(kwargs, "require_ssl", REQUIRE_SSL_KEY)
-        )
+        self._credentials = credentials
+        self.require_ssl = self._credentials.require_ssl
         try:
-            super().__init__(self._credentials.to_dict())
+            super().__init__(self._credentials.dict())
         except OperationalError as err:
             raise MetabaseLoginError(
-                credentials_info=self._credentials.to_dict(hide=True),
+                credentials_info=self._credentials,
                 error_details=err.args,
             )
 
@@ -75,9 +52,10 @@ class DbClient(PostgresClient):
         path = os.path.join(CURRENT_DIR, filename)
         with open(path, "r") as f:
             content = f.read()
-            statement = content.format(schema=self._credentials.schema)
+            statement = content.format(schema=self._credentials.schema_)
             return ExtractionQuery(statement=statement, params={})
 
+    @property
     def base_url(self) -> str:
         """Fetches the `base_url` of the Metabase instance"""
         query = self._load_query(name="base_url")
@@ -94,12 +72,13 @@ class DbClient(PostgresClient):
             try:
                 details = json.loads(db[DETAILS_KEY])
             except json.decoder.JSONDecodeError as err:
-                if not self.encryption_secret_key:
+                encryption_key = self._credentials.encryption_secret_key
+                if not encryption_key:
                     raise EncryptionSecretKeyRequired(
-                        credentials_info=self._credentials.to_dict(hide=True),
+                        credentials_info=self._credentials,
                         error_details=err.args,
                     )
-                decrypted = decrypt(db[DETAILS_KEY], self.encryption_secret_key)
+                decrypted = decrypt(db[DETAILS_KEY], encryption_key)
                 details = json.loads(decrypted)
 
             db["dbname"] = get_dbname_from_details(details)

castor_extractor/visualization/metabase/client/db/credentials.py

@@ -1,80 +1,26 @@
-from enum import Enum
-from typing import Dict
+from typing import Optional
 
-from .....utils import from_env
+from pydantic import Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
+METABASE_DB_ENV_PREFIX = "CASTOR_METABASE_DB_"
 
-class CredentialsDbKey(Enum):
-    HOST = "host"
-    PORT = "port"
-    DATABASE = "database"
-    SCHEMA = "schema"
-    USER = "user"
-    PASSWORD = "password"  # noqa: S105
 
+class MetabaseDbCredentials(BaseSettings):
+    """Metabase's credentials to connect to Metabase DB"""
 
-CREDENTIALS_ENV: Dict[CredentialsDbKey, str] = {
-    CredentialsDbKey.HOST: "CASTOR_METABASE_DB_HOST",
-    CredentialsDbKey.PORT: "CASTOR_METABASE_DB_PORT",
-    CredentialsDbKey.DATABASE: "CASTOR_METABASE_DB_DATABASE",
-    CredentialsDbKey.SCHEMA: "CASTOR_METABASE_DB_SCHEMA",
-    CredentialsDbKey.USER: "CASTOR_METABASE_DB_USERNAME",
-    CredentialsDbKey.PASSWORD: "CASTOR_METABASE_DB_PASSWORD",  # noqa: S105
-}
+    model_config = SettingsConfigDict(
+        env_prefix=METABASE_DB_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
 
+    host: str
+    port: str
+    database: str
+    schema_: str = Field(validation_alias=f"{METABASE_DB_ENV_PREFIX}SCHEMA")
+    user: str = Field(validation_alias=f"{METABASE_DB_ENV_PREFIX}USERNAME")
+    password: str = Field(repr=False)
 
-def get_value(key: CredentialsDbKey, kwargs: dict) -> str:
-    """
-    Returns the value of the given key:
-    - from kwargs in priority
-    - from ENV if not provided (raises an error if not found in ENV)
-    """
-    env_key = CREDENTIALS_ENV[key]
-    return str(kwargs.get(key.value) or from_env(env_key))
-
-
-class CredentialsDb:
-    """ValueObject for the credentials"""
-
-    def __init__(
-        self,
-        host: str,
-        port: str,
-        database: str,
-        schema: str,
-        user: str,
-        password: str,
-    ):
-        self.host = host
-        self.port = port
-        self.database = database
-        self.schema = schema
-        self.user = user
-        self.password = password
-
-    @classmethod
-    def from_env(cls, env: dict) -> "CredentialsDb":
-        """returns a new CredentialsDb with values from ENV"""
-        return CredentialsDb(
-            host=get_value(CredentialsDbKey.HOST, env),
-            port=get_value(CredentialsDbKey.PORT, env),
-            database=get_value(CredentialsDbKey.DATABASE, env),
-            schema=get_value(CredentialsDbKey.SCHEMA, env),
-            user=get_value(CredentialsDbKey.USER, env),
-            password=get_value(CredentialsDbKey.PASSWORD, env),
-        )
-
-    def to_dict(self, hide: bool = False) -> Dict[str, str]:
-        safe = (
-            CredentialsDbKey.HOST,
-            CredentialsDbKey.PORT,
-            CredentialsDbKey.DATABASE,
-            CredentialsDbKey.SCHEMA,
-            CredentialsDbKey.USER,
-        )
-        unsafe = (CredentialsDbKey.PASSWORD,)
-
-        def val(k: CredentialsDbKey, v: str) -> str:
-            return "*" + v[-4:] if hide and k in unsafe else v
-
-        return {a.value: val(a, getattr(self, a.value)) for a in safe + unsafe}
+    encryption_secret_key: Optional[str] = Field(repr=False)
+    require_ssl: Optional[str]

castor_extractor/visualization/metabase/errors.py

@@ -1,8 +1,10 @@
 from typing import Any
 
+from pydantic_settings import BaseSettings
+
 
 class MetabaseLoginError(ConnectionError):
-    def __init__(self, credentials_info: dict, error_details: Any):
+    def __init__(self, credentials_info: BaseSettings, error_details: Any):
         msg = "Connection to Metabase failed!\n"
         msg += f"Credentials: {credentials_info}\n"
         msg += f"Details: {error_details}\n"
@@ -10,7 +12,7 @@ class MetabaseLoginError(ConnectionError):
 
 
 class SuperuserCredentialsRequired(AssertionError):
-    def __init__(self, credentials_info: dict, error_details: Any):
+    def __init__(self, credentials_info: BaseSettings, error_details: Any):
         msg = "Superuser credentials are required!\n"
         msg += f"Credentials: {credentials_info}\n"
         msg += f"Details: {error_details}\n"
@@ -22,7 +24,7 @@ class EncryptionSecretKeyRequired(AssertionError):
     Raised when missing the encryption secret key while it was required.
     """
 
-    def __init__(self, credentials_info: dict, error_details: Any):
+    def __init__(self, credentials_info: BaseSettings, error_details: Any):
         msg = "Encryption secret key is required!\n"
         msg += f"Credentials: {credentials_info}\n"
         msg += f"Details: {error_details}\n"

castor_extractor/visualization/metabase/extract.py

@@ -40,12 +40,12 @@ def iterate_all_data(
     )
 
 
-def extract_all(client: ClientMetabase, **kwargs: str) -> None:
+def extract_all(client: ClientMetabase, **kwargs) -> None:
     """
     Extract Data From metabase
     Store the output files locally under the given output_directory
     """
-    output_directory = kwargs.get("output_directory") or from_env(OUTPUT_DIR)
+    output_directory = kwargs.get("output") or from_env(OUTPUT_DIR)
     ts = current_timestamp()
 
     for key, data in iterate_all_data(client):
@@ -55,6 +55,6 @@ def extract_all(client: ClientMetabase, **kwargs: str) -> None:
     write_summary(
         output_directory,
         ts,
-        base_url=client.base_url(),
+        base_url=client.base_url,
         client_name=client.name(),
     )

castor_extractor/visualization/mode/__init__.py

@@ -1,3 +1,3 @@
 from .assets import ModeAnalyticsAsset
-from .client import Client
+from .client import Client, ModeCredentials as Credentials
 from .extract import extract_all, iterate_all_data

castor_extractor/visualization/mode/client/__init__.py

@@ -1 +1,2 @@
 from .client import Client
+from .credentials import ModeCredentials

castor_extractor/visualization/mode/client/client.py

@@ -2,6 +2,7 @@ import logging
 from typing import Dict, List, Optional, cast
 
 import requests
+from requests.auth import HTTPBasicAuth
 
 from ....utils import retry
 from ..assets import (
@@ -22,7 +23,7 @@ from .constants import (
     RETRY_JITTER_MS,
     RETRY_STRATEGY,
 )
-from .credentials import Credentials, CredentialsKey, get_value
+from .credentials import ModeCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -40,20 +41,16 @@ class Client:
 
     def __init__(
         self,
-        **kwargs,
+        credentials: ModeCredentials,
     ):
-        self._credentials = Credentials(
-            host=get_value(CredentialsKey.HOST, kwargs).rstrip("/"),
-            workspace=get_value(CredentialsKey.WORKSPACE, kwargs),
-            token=get_value(CredentialsKey.TOKEN, kwargs),
-            secret=get_value(CredentialsKey.SECRET, kwargs),
-        )
+        self._credentials = credentials
         self._session = requests.Session()
-        if not kwargs.get("no_checks"):
-            self._check_connection()
+
+    def authenticate(self) -> HTTPBasicAuth:
+        return HTTPBasicAuth(self._credentials.token, self._credentials.secret)
 
     def _check_connection(self):
-        authentication = self._credentials.authentication()
+        authentication = self.authenticate()
         url = self._url(with_workspace=False) + "/account"
         response = self._session.get(url, auth=authentication)
         self._handle_response(response)
@@ -121,7 +118,7 @@ class Client:
         report: Optional[str] = None,
         resource_name: Optional[str] = None,
     ) -> RawData:
-        authentication = self._credentials.authentication()
+        authentication = self.authenticate()
         url = self._url(with_workspace, space, report, resource_name)
         logger.info(f"Calling {url}")
         response = self._session.get(url, auth=authentication)

castor_extractor/visualization/mode/client/client_test.py

@@ -2,20 +2,20 @@ import json
 
 from ....utils import load_file
 from ..assets import EXPORTED_FIELDS, ModeAnalyticsAsset
-from .client import Client
+from .client import Client, ModeCredentials
 
 _HOST = "https://mode.com"
 _WORKSPACE = "castor"
 
 
 def _dummy_client() -> Client:
-    return Client(  # noqa: S106
+    credentials = ModeCredentials(
         host=_HOST,
         workspace=_WORKSPACE,
         token="dummy-token",
         secret="******",
-        no_checks=True,
     )
+    return Client(credentials=credentials)
 
 
 def test__url():

castor_extractor/visualization/mode/client/credentials.py

@@ -1,57 +1,24 @@
-from enum import Enum
-from typing import Dict
+from pydantic import Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from requests.auth import HTTPBasicAuth
+MODE_ENV_PREFIX = "CASTOR_MODE_ANALYTICS_"
 
-from ....utils import from_env
 
+class ModeCredentials(BaseSettings):
+    """Class holding Mode credentials attributes"""
 
-class CredentialsKey(Enum):
-    HOST = "host"
-    WORKSPACE = "workspace"
-    TOKEN = "token"  # noqa: S105
-    SECRET = "secret"  # noqa: S105
+    model_config = SettingsConfigDict(
+        env_prefix=MODE_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
 
+    host: str
+    secret: str = Field(repr=False)
+    token: str
+    workspace: str
 
-CREDENTIALS_ENV: Dict[CredentialsKey, str] = {
-    CredentialsKey.HOST: "CASTOR_MODE_ANALYTICS_HOST",
-    CredentialsKey.WORKSPACE: "CASTOR_MODE_ANALYTICS_WORKSPACE",
-    CredentialsKey.TOKEN: "CASTOR_MODE_ANALYTICS_TOKEN",
-    CredentialsKey.SECRET: "CASTOR_MODE_ANALYTICS_SECRET",
-}
-
-
-def get_value(key: CredentialsKey, kwargs: dict) -> str:
-    """
-    Returns the value of the given key:
-    - from kwargs in priority
-    - from ENV if not provided (raises an error if not found in ENV)
-    """
-    env_key = CREDENTIALS_ENV[key]
-    return str(kwargs.get(key.value) or from_env(env_key))
-
-
-class Credentials:
-    """ValueObject for the credentials"""
-
-    def __init__(self, host: str, workspace: str, token: str, secret: str):
-        self.host = host
-        self.workspace = workspace
-        self.token = token
-        self.secret = secret
-
-    def to_dict(self, hide: bool = False) -> Dict[str, str]:
-        safe = (
-            CredentialsKey.HOST,
-            CredentialsKey.WORKSPACE,
-            CredentialsKey.TOKEN,
-        )
-        unsafe = (CredentialsKey.SECRET,)
-
-        def val(k: CredentialsKey, v: str) -> str:
-            return "*" + v[-4:] if hide and k in unsafe else v
-
-        return {a.value: val(a, getattr(self, a.value)) for a in safe + unsafe}
-
-    def authentication(self) -> HTTPBasicAuth:
-        return HTTPBasicAuth(self.token, self.secret)
+    @field_validator("host", mode="before")
+    @classmethod
+    def _check_base_url(cls, host: str) -> str:
+        return host.rstrip("/")

castor_extractor/visualization/mode/extract.py

@@ -11,7 +11,7 @@ from ...utils import (
     write_summary,
 )
 from .assets import ModeAnalyticsAsset as Asset
-from .client import Client
+from .client import Client, ModeCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -37,9 +37,12 @@ def iterate_all_data(
     yield Asset.MEMBER, deep_serialize(members)
 
 
-def extract_all(client: Client, **kwargs: str) -> None:
+def extract_all(**kwargs) -> None:
     """Extract Data From Mode Analytics and store it locally in files under the output_directory"""
-    output_directory = kwargs.get("output_directory") or from_env(OUTPUT_DIR)
+    output_directory = kwargs.get("output") or from_env(OUTPUT_DIR)
+    credentials = ModeCredentials(**kwargs)
+    client = Client(credentials)
+
     ts = current_timestamp()
 
     for key, data in iterate_all_data(client):

castor_extractor/visualization/powerbi/__init__.py

@@ -1,3 +1,3 @@
 from .assets import PowerBiAsset
-from .client import Client, Credentials
+from .client import Client, PowerbiCredentials, Urls
 from .extract import extract_all

castor_extractor/visualization/powerbi/client/__init__.py

@@ -1,2 +1,3 @@
-from .credentials import Credentials
+from .constants import Urls
+from .credentials import PowerbiCredentials
 from .rest import Client

castor_extractor/visualization/powerbi/client/credentials.py

@@ -1,20 +1,28 @@
-from dataclasses import field
 from typing import List, Optional
 
-from pydantic.dataclasses import dataclass
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from .constants import Urls
 
+POWERBI_ENV_PREFIX = "CASTOR_POWERBI_"
 
-@dataclass
-class Credentials:
+
+class PowerbiCredentials(BaseSettings):
     """Class to handle PowerBI rest API permissions"""
 
+    model_config = SettingsConfigDict(
+        env_prefix=POWERBI_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
+
     client_id: str
     tenant_id: str
-    secret: str = field(metadata={"sensitive": True})
-    scopes: Optional[List[str]] = None
+    secret: str = Field(repr=False)
+    scopes: List[str] = [Urls.DEFAULT_SCOPE]
 
-    def __post_init__(self):
-        if self.scopes is None:
-            self.scopes = [Urls.DEFAULT_SCOPE]
+    @field_validator("scopes", mode="before")
+    @classmethod
+    def _check_scopes(cls, scopes: Optional[List[str]]) -> List[str]:
+        return scopes if scopes is not None else [Urls.DEFAULT_SCOPE]

castor_extractor/visualization/powerbi/client/credentials_test.py

@@ -1,5 +1,5 @@
 from .constants import Urls
-from .credentials import Credentials
+from .credentials import PowerbiCredentials
 
 
 def test_credentials():
@@ -8,15 +8,23 @@ def test_credentials():
     secret = "🤫"
 
     # no scopes provided
-    credentials = Credentials(
+    credentials = PowerbiCredentials(
         tenant_id=tenant_id,
         client_id=client_id,
         secret=secret,
     )
     assert credentials.scopes == [Urls.DEFAULT_SCOPE]
 
+    credentials = PowerbiCredentials(
+        tenant_id=tenant_id,
+        client_id=client_id,
+        secret=secret,
+        scopes=None,
+    )
+    assert credentials.scopes == [Urls.DEFAULT_SCOPE]
+
     # empty scopes
-    credentials = Credentials(
+    credentials = PowerbiCredentials(
         tenant_id=tenant_id,
         client_id=client_id,
         secret=secret,
@@ -26,7 +34,7 @@ def test_credentials():
 
     # with scopes
     scopes = ["foo"]
-    credentials = Credentials(
+    credentials = PowerbiCredentials(
         tenant_id=tenant_id,
         client_id=client_id,
         secret=secret,

castor_extractor/visualization/powerbi/client/rest.py

@@ -18,7 +18,7 @@ from .constants import (
     QueryParams,
     Urls,
 )
-from .credentials import Credentials
+from .credentials import PowerbiCredentials
 from .utils import batch_size_is_valid_or_assert, datetime_is_recent_or_assert
 
 logger = logging.getLogger(__name__)
@@ -62,7 +62,7 @@ class Client:
     https://learn.microsoft.com/en-us/rest/api/power-bi/admin
     """
 
-    def __init__(self, credentials: Credentials):
+    def __init__(self, credentials: PowerbiCredentials):
         self.creds = credentials
         client_app = f"{Urls.CLIENT_APP_BASE}{self.creds.tenant_id}"
         self.app = msal.ConfidentialClientApplication(