castor-extractor 0.17.3__py3-none-any.whl → 0.18.2__py3-none-any.whl

castor_extractor/visualization/looker/api/client.py

@@ -22,7 +22,7 @@ from looker_sdk.sdk.api40.models import (
 from looker_sdk.sdk.constants import sdk_version
 
 from ....utils import Pager, PagerLogger, SafeMode, past_date, safe_mode
-from ..env import page_size
+from ..constants import DEFAULT_LOOKER_PAGE_SIZE
 from ..fields import format_fields
 from .constants import (
     CONNECTION_FIELDS,
@@ -39,7 +39,8 @@ from .constants import (
     USER_FIELDS,
     USERS_ATTRIBUTES_FIELDS,
 )
-from .sdk import CastorApiSettings, Credentials, has_admin_permissions
+from .credentials import LookerCredentials
+from .sdk import CastorApiSettings, has_admin_permissions
 
 logger = logging.getLogger(__name__)
 
@@ -78,9 +79,10 @@ class ApiClient:
 
     def __init__(
         self,
-        credentials: Credentials,
+        credentials: LookerCredentials,
         on_api_call: OnApiCall = lambda: None,
         safe_mode: Optional[SafeMode] = None,
+        page_size: int = DEFAULT_LOOKER_PAGE_SIZE,
     ):
         settings = CastorApiSettings(
             credentials=credentials, sdk_version=sdk_version
@@ -92,7 +94,7 @@ class ApiClient:
             self._sdk = sdk
         self._on_api_call = on_api_call
         self._logger = ApiPagerLogger(on_api_call)
-        self.per_page = page_size()
+        self.per_page = page_size
         self._safe_mode = safe_mode
 
     def folders(self) -> List[Folder]:

castor_extractor/visualization/looker/api/client_test.py

@@ -2,9 +2,11 @@ import datetime
 from unittest.mock import patch
 
 import pytest
-from castor_extractor.visualization.looker import (  # type: ignore
+from castor_extractor.visualization.looker.api.client import (  # type: ignore
     ApiClient,
-    Credentials,
+)
+from castor_extractor.visualization.looker.api.credentials import (  # type: ignore
+    LookerCredentials,
 )
 from dateutil.utils import today
 from freezegun import freeze_time
@@ -13,7 +15,7 @@ from .client import _mondays
 
 
 def _credentials():
-    return Credentials(  # noqa: S106
+    return LookerCredentials(  # noqa: S106
         base_url="base_url",
         client_id="client_id",
         client_secret="secret",

castor_extractor/visualization/looker/api/credentials.py

@@ -0,0 +1,33 @@
+from looker_sdk.rtl.api_settings import SettingsConfig
+from pydantic import Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from ..constants import DEFAULT_LOOKER_TIMEOUT_SECOND, LOOKER_ENV_PREFIX
+
+KEY_LOOKER_TIMEOUT_SECOND = f"{LOOKER_ENV_PREFIX}TIMEOUT_SECOND"
+
+
+class LookerCredentials(BaseSettings):
+    """ValueObject for the credentials"""
+
+    model_config = SettingsConfigDict(
+        env_prefix=LOOKER_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    base_url: str
+    client_id: str
+    client_secret: str = Field(repr=False)
+    timeout: int = Field(
+        validation_alias=KEY_LOOKER_TIMEOUT_SECOND,
+        default=DEFAULT_LOOKER_TIMEOUT_SECOND,
+    )
+
+    def to_settings_config(self) -> SettingsConfig:
+        return SettingsConfig(
+            base_url=self.base_url,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            timeout=str(self.timeout),
+        )

castor_extractor/visualization/looker/api/extraction_parameters.py

@@ -0,0 +1,38 @@
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from ..constants import (
+    DEFAULT_LOOKER_PAGE_SIZE,
+    DEFAULT_LOOKER_THREAD_POOL_SIZE,
+    LOOKER_ENV_PREFIX,
+    MAX_THREAD_POOL_SIZE,
+    MIN_THREAD_POOL_SIZE,
+)
+
+
+class ExtractionParameters(BaseSettings):
+    """
+    Class holding all the parameters needed for the extraction of
+    Looker metadata
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix=LOOKER_ENV_PREFIX,
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    is_safe_mode: bool = False
+    log_to_stdout: bool
+    output_directory: str
+    search_per_folder: bool
+    page_size: int = Field(default=DEFAULT_LOOKER_PAGE_SIZE)
+    thread_pool_size: int = Field(default=DEFAULT_LOOKER_THREAD_POOL_SIZE)
+
+    @field_validator("thread_pool_size", mode="before")
+    @classmethod
+    def _check_thread_pool_size(cls, thread_pool_size: int) -> int:
+        thread_pool_size = thread_pool_size or DEFAULT_LOOKER_THREAD_POOL_SIZE
+        if MIN_THREAD_POOL_SIZE <= thread_pool_size <= MAX_THREAD_POOL_SIZE:
+            return thread_pool_size
+        raise ValueError("Thread pool size must be between 1 and 200 inclusive")

castor_extractor/visualization/looker/api/sdk.py

@@ -8,33 +8,7 @@ from looker_sdk.rtl import transport
 from looker_sdk.rtl.api_settings import ApiSettings, SettingsConfig
 from looker_sdk.sdk.api40 import methods as methods40
 
-from ..env import timeout_second
-
-
-class Credentials:
-    """ValueObject for the credentials"""
-
-    def __init__(
-        self,
-        *,
-        base_url: str,
-        client_id: str,
-        client_secret: str,
-        timeout: Optional[int] = None,
-        **_kwargs,
-    ):
-        self.base_url = base_url
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.timeout: int = timeout or timeout_second()
-
-    def to_settings_config(self) -> SettingsConfig:
-        return SettingsConfig(
-            base_url=self.base_url,
-            client_id=self.client_id,
-            client_secret=self.client_secret,
-            timeout=str(self.timeout),
-        )
+from .credentials import LookerCredentials
 
 
 def has_admin_permissions(sdk_: methods40.Looker40SDK) -> bool:
@@ -54,7 +28,7 @@ class CastorApiSettings(ApiSettings):
     """SDK settings with initialisation using a credential object instead of a path to a .ini file"""
 
     def __init__(
-        self, credentials: Credentials, sdk_version: Optional[str] = ""
+        self, credentials: LookerCredentials, sdk_version: Optional[str] = ""
     ):
         """Configure using a config dict"""
         self.config = credentials.to_settings_config()

castor_extractor/visualization/looker/constant.py

@@ -1,25 +1,8 @@
 """
-Request timeout in seconds for Looker API
+Safe mode parameters
 """
 
-DEFAULT_LOOKER_TIMEOUT_SECOND = 120
-KEY_LOOKER_TIMEOUT_SECOND = "CASTOR_LOOKER_TIMEOUT_SECOND"
+from looker_sdk.error import SDKError
 
-"""
-Number of items per page when requesting Looker API
-"""
-DEFAULT_LOOKER_PAGE_SIZE = 500
-KEY_LOOKER_PAGE_SIZE = "CASTOR_LOOKER_PAGE_SIZE"
-
-"""
-Maximum concurrent threads to run when fetching
-"""
-DEFAULT_LOOKER_THREAD_POOL_SIZE = 20
-KEY_LOOKER_THREAD_POOL_SIZE = "CASTOR_LOOKER_THREAD_POOL_SIZE"
-
-# env variables
-BASE_URL = "CASTOR_LOOKER_BASE_URL"
-CLIENT_ID = "CASTOR_LOOKER_CLIENT_ID"
-CLIENT_SECRET = "CASTOR_LOOKER_CLIENT_SECRET"  # noqa: S105
-SEARCH_PER_FOLDER = "CASTOR_LOOKER_SEARCH_PER_FOLDER"
-LOG_TO_STDOUT = "CASTOR_LOOKER_LOG_TO_STDOUT"
+SAFE_MODE_MAX_ERRORS = 3
+SAFE_MODE_EXCEPTIONS = (SDKError,)

castor_extractor/visualization/looker/constants.py

@@ -0,0 +1,17 @@
+"""
+Request timeout in seconds for Looker API
+"""
+
+LOOKER_ENV_PREFIX = "CASTOR_LOOKER_"
+
+DEFAULT_LOOKER_TIMEOUT_SECOND = 120
+"""
+Number of items per page when requesting Looker API
+"""
+DEFAULT_LOOKER_PAGE_SIZE = 500
+"""
+Maximum concurrent threads to run when fetching
+"""
+DEFAULT_LOOKER_THREAD_POOL_SIZE = 20
+MIN_THREAD_POOL_SIZE = 1
+MAX_THREAD_POOL_SIZE = 200

castor_extractor/visualization/looker/extract.py

@@ -13,10 +13,14 @@ from ...utils import (
     write_json,
     write_summary,
 )
-from .api import ApiClient, Credentials, lookml_explore_names
+from .api import (
+    ApiClient,
+    ExtractionParameters,
+    LookerCredentials,
+    lookml_explore_names,
+)
 from .assets import LookerAsset
 from .multithreading import MultithreadingFetcher
-from .parameters import get_parameters
 
 logger = logging.getLogger(__name__)
 
@@ -30,25 +34,23 @@ def _extract_explores_by_name(
         yield deep_serialize(explore)  # type: ignore
 
 
-def _safe_mode(directory: str) -> SafeMode:
-    add_logging_file_handler(directory)
+def _safe_mode(
+    extraction_parameters: ExtractionParameters,
+) -> Optional[SafeMode]:
+    if extraction_parameters.is_safe_mode:
+        return None
+    add_logging_file_handler(extraction_parameters.output_directory)
     return SafeMode((Exception,), float("inf"))
 
 
 def _client(
-    base_url: str,
-    client_id: str,
-    client_secret: str,
-    timeout: Optional[int],
+    credentials: LookerCredentials,
     safe_mode: Optional[SafeMode],
+    page_size: int,
 ) -> ApiClient:
-    credentials = Credentials(
-        base_url=base_url,
-        client_id=client_id,
-        client_secret=client_secret,
-        timeout=timeout,
+    return ApiClient(
+        credentials=credentials, safe_mode=safe_mode, page_size=page_size
     )
-    return ApiClient(credentials=credentials, safe_mode=safe_mode)
 
 
 def iterate_all_data(
@@ -56,7 +58,7 @@ def iterate_all_data(
     search_per_folder: bool,
     thread_pool_size: int,
     log_to_stdout: bool,
-) -> Union[StreamableList, Iterable[Tuple[LookerAsset, list]]]:
+) -> Iterable[Union[StreamableList, Tuple[LookerAsset, list]]]:
     """Iterate over the extracted Data From looker"""
 
     logger.info("Extracting users from Looker API")
@@ -124,33 +126,32 @@ def extract_all(**kwargs) -> None:
     Extract Data From looker and store it locally in files under the
     output_directory
     """
-    parameters = get_parameters(**kwargs)
-    output_directory = parameters.output_directory
-    base_url = parameters.base_url
+    args = {arg: value for arg, value in kwargs.items() if value is not None}
+    extraction_parameters = ExtractionParameters(**args)
+    output_directory = extraction_parameters.output_directory
+
+    credentials = LookerCredentials(**args)
 
-    if parameters.log_to_stdout:
+    if extraction_parameters.log_to_stdout:
         set_stream_handler_to_stdout()
 
-    is_safe_mode = parameters.is_safe_mode
-    safe_mode = _safe_mode(output_directory) if is_safe_mode else None
+    safe_mode = _safe_mode(extraction_parameters)
     client = _client(
-        base_url=base_url,
-        client_id=parameters.client_id,
-        client_secret=parameters.client_secret,
-        timeout=parameters.timeout,
+        credentials=credentials,
         safe_mode=safe_mode,
+        page_size=extraction_parameters.page_size,
     )
 
     ts = current_timestamp()
 
     data = iterate_all_data(
         client=client,
-        search_per_folder=parameters.search_per_folder,
-        thread_pool_size=parameters.thread_pool_size,
-        log_to_stdout=parameters.log_to_stdout,
+        search_per_folder=extraction_parameters.search_per_folder,
+        thread_pool_size=extraction_parameters.thread_pool_size,
+        log_to_stdout=extraction_parameters.log_to_stdout,
     )
     for asset, data in data:
         filename = get_output_filename(asset.value, output_directory, ts)
         write_json(filename, data)
 
-    write_summary(output_directory, ts, base_url=base_url)
+    write_summary(output_directory, ts, base_url=credentials.base_url)

castor_extractor/visualization/metabase/__init__.py

@@ -1,3 +1,8 @@
 from .assets import MetabaseAsset
-from .client import ApiClient, DbClient
+from .client import (
+    ApiClient,
+    DbClient,
+    MetabaseApiCredentials,
+    MetabaseDbCredentials,
+)
 from .extract import extract_all, iterate_all_data

castor_extractor/visualization/metabase/client/__init__.py

@@ -1,2 +1,2 @@
-from .api import ApiClient
-from .db import DbClient
+from .api import ApiClient, MetabaseApiCredentials
+from .db import DbClient, MetabaseDbCredentials

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

@@ -1 +1,2 @@
 from .client import ApiClient
+from .credentials import MetabaseApiCredentials

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]