truefoundry 0.3.4rc1__py3-none-any.whl → 0.4.0__py3-none-any.whl

truefoundry/deploy/lib/clients/servicefoundry_client.py

@@ -1,39 +1,41 @@
 from __future__ import annotations
 
-import functools
 import json
 import os
 import time
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
-from urllib.parse import urljoin, urlparse
+from urllib.parse import urljoin
 
 import requests
 import socketio
 from dateutil.tz import tzlocal
-from packaging import version
 from rich.status import Status
 from tqdm import tqdm
 from tqdm.utils import CallbackIOWrapper
 
+from truefoundry.common.constants import VERSION_PREFIX
+from truefoundry.common.request_utils import request_handling
+from truefoundry.common.servicefoundry_client import (
+    ServiceFoundryServiceClient as BaseServiceFoundryServiceClient,
+)
+from truefoundry.common.servicefoundry_client import (
+    check_min_cli_version,
+    session_with_retries,
+)
+from truefoundry.deploy.auto_gen import models as auto_gen_models
 from truefoundry.deploy.io.output_callback import OutputCallBack
 from truefoundry.deploy.lib.auth.servicefoundry_session import ServiceFoundrySession
-from truefoundry.deploy.lib.clients.utils import request_handling
-from truefoundry.deploy.lib.const import API_SERVER_RELATIVE_PATH, VERSION_PREFIX
 from truefoundry.deploy.lib.model.entity import (
     Application,
     CreateDockerRepositoryResponse,
     Deployment,
     DockerRegistryCredentials,
     JobRun,
-    PythonSDKConfig,
-    TenantInfo,
-    Token,
     TriggerJobResult,
     Workspace,
     WorkspaceResources,
 )
-from truefoundry.deploy.lib.util import timed_lru_cache
 from truefoundry.deploy.lib.win32 import allow_interrupt
 from truefoundry.deploy.v2.lib.models import (
     AppDeploymentStatusResponse,
@@ -43,7 +45,6 @@ from truefoundry.deploy.v2.lib.models import (
 )
 from truefoundry.logger import logger
 from truefoundry.pydantic_v1 import parse_obj_as
-from truefoundry.version import __version__
 
 DEPLOYMENT_LOGS_SUBSCRIBE_MESSAGE = "DEPLOYMENT_LOGS"
 BUILD_LOGS_SUBSCRIBE_MESSAGE = "BUILD_LOGS"
@@ -74,46 +75,7 @@ def _upload_packaged_code(metadata, package_file):
                 raise RuntimeError(f"Failed to upload code {http_response.content}")
 
 
-def check_min_cli_version(fn):
-    @functools.wraps(fn)
-    def inner(*args, **kwargs):
-        if __version__ != "0.0.0":
-            client: "ServiceFoundryServiceClient" = args[0]
-            # "0.0.0" indicates dev version
-            # noinspection PyProtectedMember
-            min_cli_version_required = client._min_cli_version_required
-            if version.parse(__version__) < version.parse(min_cli_version_required):
-                raise Exception(
-                    "You are using an outdated version of `truefoundry`.\n"
-                    f"Run `pip install truefoundry>={min_cli_version_required}` to install the supported version.",
-                )
-        else:
-            logger.debug("Ignoring minimum cli version check")
-
-        return fn(*args, **kwargs)
-
-    return inner
-
-
-@timed_lru_cache(seconds=30 * 60)
-def _cached_get_tenant_info(api_server_url: str) -> TenantInfo:
-    res = requests.get(
-        url=f"{api_server_url}/v1/tenant-id",
-        params={"hostName": urlparse(api_server_url).netloc},
-    )
-    res = request_handling(res)
-    return TenantInfo.parse_obj(res)
-
-
-@timed_lru_cache(seconds=30 * 60)
-def _cached_get_python_sdk_config(api_server_url: str) -> PythonSDKConfig:
-    url = f"{api_server_url}/v1/min-cli-version"
-    res = requests.get(url)
-    res = request_handling(res)
-    return PythonSDKConfig.parse_obj(res)
-
-
-class ServiceFoundryServiceClient:
+class ServiceFoundryServiceClient(BaseServiceFoundryServiceClient):
     def __init__(self, init_session: bool = True, base_url: Optional[str] = None):
         self._session: Optional[ServiceFoundrySession] = None
         if init_session:
@@ -123,27 +85,7 @@ class ServiceFoundryServiceClient:
             base_url = self._session.base_url
         elif not base_url:
             raise Exception("Neither session, not base_url provided")
-
-        self._base_url = base_url.strip("/")
-        self._api_server_url = f"{self._base_url}/{API_SERVER_RELATIVE_PATH}"
-
-    @property
-    def base_url(self) -> str:
-        return self._base_url
-
-    @property
-    def tenant_info(self) -> TenantInfo:
-        return _cached_get_tenant_info(self._api_server_url)
-
-    @property
-    def python_sdk_config(self) -> PythonSDKConfig:
-        return _cached_get_python_sdk_config(self._api_server_url)
-
-    @functools.cached_property
-    def _min_cli_version_required(self) -> str:
-        return _cached_get_python_sdk_config(
-            self._api_server_url
-        ).truefoundry_cli_min_version
+        super().__init__(base_url=base_url)
 
     def _get_header(self):
         if not self._session:
@@ -153,14 +95,16 @@ class ServiceFoundryServiceClient:
     @check_min_cli_version
     def get_id_from_fqn(self, fqn_type: str, fqn: str):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/fqn/{fqn_type}"
-        res = requests.get(url, headers=self._get_header(), params={"fqn": fqn})
-        return request_handling(res)
+        response = session_with_retries().get(
+            url, headers=self._get_header(), params={"fqn": fqn}
+        )
+        return request_handling(response)
 
     @check_min_cli_version
     def list_workspace(self):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workspace"
-        res = requests.get(url, headers=self._get_header())
-        return request_handling(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        return request_handling(response)
 
     @check_min_cli_version
     def list_workspaces(
@@ -177,8 +121,10 @@ class ServiceFoundryServiceClient:
             params["workspaceName"] = workspace_name
         if workspace_fqn:
             params["workspaceFqn"] = workspace_fqn
-        res = requests.get(url, params=params, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().get(
+            url, params=params, headers=self._get_header()
+        )
+        response = request_handling(response)
         return parse_obj_as(List[Workspace], response)
 
     @check_min_cli_version
@@ -189,7 +135,7 @@ class ServiceFoundryServiceClient:
         resources: WorkspaceResources,
     ) -> Workspace:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workspace"
-        res = requests.post(
+        response = session_with_retries().post(
             url,
             json={
                 "manifest": {
@@ -200,8 +146,8 @@ class ServiceFoundryServiceClient:
             },
             headers=self._get_header(),
         )
-        res = request_handling(res)
-        return Workspace.parse_obj(res)
+        response_data = request_handling(response)
+        return Workspace.parse_obj(response_data)
 
     @check_min_cli_version
     def remove_workspace(self, workspace_id, force=False) -> Workspace:
@@ -209,35 +155,37 @@ class ServiceFoundryServiceClient:
         force = json.dumps(
             force
         )  # this dumb conversion is required because `params` just casts as str
-        res = requests.delete(url, headers=self._get_header(), params={"force": force})
-        response = request_handling(res)
+        response = session_with_retries().delete(
+            url, headers=self._get_header(), params={"force": force}
+        )
+        response = request_handling(response)
         return Workspace.parse_obj(response["workspace"])
 
     @check_min_cli_version
     def get_workspace_by_name(self, workspace_name, cluster_id):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workspace"
-        res = requests.get(
+        response = session_with_retries().get(
             url,
             headers=self._get_header(),
             params={"name": workspace_name, "clusterId": cluster_id},
         )
-        return request_handling(res)
+        return request_handling(response)
 
     @check_min_cli_version
     def get_workspace(self, workspace_id):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workspace/{workspace_id}"
-        res = requests.get(url, headers=self._get_header())
-        return request_handling(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        return request_handling(response)
 
     @check_min_cli_version
     def get_workspace_by_fqn(self, workspace_fqn: str) -> List[Workspace]:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workspace"
-        res = requests.get(
+        response = session_with_retries().get(
             url,
             headers=self._get_header(),
             params={"fqn": workspace_fqn},
         )
-        response = request_handling(res)
+        response = request_handling(response)
         return parse_obj_as(List[Workspace], response)
 
     @check_min_cli_version
@@ -246,25 +194,27 @@ class ServiceFoundryServiceClient:
         params = {}
         if workspace_id:
             params["workspaceId"] = workspace_id
-        res = requests.get(url=url, params=params, headers=self._get_header())
-        return request_handling(res)
+        response = session_with_retries().get(
+            url=url, params=params, headers=self._get_header()
+        )
+        return request_handling(response)
 
     @check_min_cli_version
     def list_cluster(self):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/cluster"
-        res = requests.get(url, headers=self._get_header())
-        return request_handling(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        return request_handling(response)
 
     @check_min_cli_version
     def get_cluster(self, cluster_id):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/cluster/{cluster_id}"
-        res = requests.get(url, headers=self._get_header())
-        return request_handling(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        return request_handling(response)
 
     @check_min_cli_version
     def get_presigned_url(self, space_name, service_name, env):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/deployment/code-upload-url"
-        res = requests.post(
+        response = session_with_retries().post(
             url,
             json={
                 "workspaceFqn": space_name,
@@ -273,7 +223,7 @@ class ServiceFoundryServiceClient:
             },
             headers=self._get_header(),
         )
-        return request_handling(res)
+        return request_handling(response)
 
     @check_min_cli_version
     def upload_code_package(
@@ -288,7 +238,7 @@ class ServiceFoundryServiceClient:
 
     @check_min_cli_version
     def deploy_application(
-        self, workspace_id: str, application: Application
+        self, workspace_id: str, application: auto_gen_models.Workflow
     ) -> Deployment:
         data = {
             "workspaceId": workspace_id,
@@ -297,7 +247,9 @@ class ServiceFoundryServiceClient:
         }
         logger.debug(json.dumps(data))
         url = f"{self._api_server_url}/{VERSION_PREFIX}/deployment"
-        deploy_response = requests.post(url, json=data, headers=self._get_header())
+        deploy_response = session_with_retries().post(
+            url, json=data, headers=self._get_header()
+        )
         response = request_handling(deploy_response)
         return Deployment.parse_obj(response["deployment"])
 
@@ -359,27 +311,27 @@ class ServiceFoundryServiceClient:
     @check_min_cli_version
     def get_deployment(self, application_id: str, deployment_id: str) -> Deployment:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/app/{application_id}/deployments/{deployment_id}"
-        res = requests.get(url, headers=self._get_header())
-        res = request_handling(res)
-        return Deployment.parse_obj(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        response_data = request_handling(response)
+        return Deployment.parse_obj(response_data)
 
     @check_min_cli_version
     def get_deployment_statuses(
         self, application_id: str, deployment_id: str
     ) -> List[AppDeploymentStatusResponse]:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/app/{application_id}/deployments/{deployment_id}/statuses"
-        res = requests.get(url, headers=self._get_header())
-        res = request_handling(res)
-        return parse_obj_as(List[AppDeploymentStatusResponse], res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        response_data = request_handling(response)
+        return parse_obj_as(List[AppDeploymentStatusResponse], response_data)
 
     @check_min_cli_version
     def get_deployment_build_response(
         self, application_id: str, deployment_id: str
     ) -> List[BuildResponse]:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/app/{application_id}/deployments/{deployment_id}/builds"
-        res = requests.get(url, headers=self._get_header())
-        res = request_handling(res)
-        return parse_obj_as(List[BuildResponse], res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        response_data = request_handling(response)
+        return parse_obj_as(List[BuildResponse], response_data)
 
     def _get_deployment_logs(
         self,
@@ -408,9 +360,11 @@ class ServiceFoundryServiceClient:
             data["jobRunName"] = job_run_name
 
         url = f"{self._api_server_url}/{VERSION_PREFIX}/logs/{workspace_id}"
-        res = requests.get(url=url, params=data, headers=self._get_header())
-        res = request_handling(res)
-        return list(res["logs"])
+        response = session_with_retries().get(
+            url=url, params=data, headers=self._get_header()
+        )
+        response_data = request_handling(response)
+        return list(response_data["logs"])
 
     @check_min_cli_version
     def tail_build_logs(
@@ -546,8 +500,8 @@ class ServiceFoundryServiceClient:
     ) -> None:
         callback = callback or OutputCallBack()
         url = build_response.getLogsUrl
-        res = requests.get(url=url, headers=self._get_header())
-        logs_list = request_handling(res)
+        response = session_with_retries().get(url=url, headers=self._get_header())
+        logs_list = request_handling(response)
         for log in logs_list["logs"]:
             # TODO: Have to establish a log line format that includes timestamp, level, message
             callback.print_line(self._get_log_print_line(log))
@@ -555,36 +509,36 @@ class ServiceFoundryServiceClient:
     @check_min_cli_version
     def get_deployment_info_by_fqn(self, deployment_fqn: str) -> DeploymentFqnResponse:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/fqn/deployment"
-        res = requests.get(
+        response = session_with_retries().get(
             url, headers=self._get_header(), params={"fqn": deployment_fqn}
         )
-        res = request_handling(res)
-        return DeploymentFqnResponse.parse_obj(res)
+        response_data = request_handling(response)
+        return DeploymentFqnResponse.parse_obj(response_data)
 
     @check_min_cli_version
     def get_application_info_by_fqn(
         self, application_fqn: str
     ) -> ApplicationFqnResponse:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/fqn/app"
-        res = requests.get(
+        response = session_with_retries().get(
             url, headers=self._get_header(), params={"fqn": application_fqn}
         )
-        res = request_handling(res)
-        return ApplicationFqnResponse.parse_obj(res)
+        response_data = request_handling(response)
+        return ApplicationFqnResponse.parse_obj(response_data)
 
     @check_min_cli_version
     def remove_application(self, application_id: str):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/app/{application_id}"
-        res = requests.delete(url, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().delete(url, headers=self._get_header())
+        response = request_handling(response)
         # TODO: Add pydantic here.
         return response
 
     @check_min_cli_version
     def get_application_info(self, application_id: str) -> Application:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/app/{application_id}"
-        res = requests.get(url, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        response = request_handling(response)
         return Application.parse_obj(response)
 
     def list_job_runs(
@@ -602,9 +556,11 @@ class ServiceFoundryServiceClient:
             params["offset"] = offset
         if search_prefix:
             params["searchPrefix"] = search_prefix
-        res = requests.get(url, headers=self._get_header(), params=params)
-        res = request_handling(res)
-        return parse_obj_as(List[JobRun], res["data"])
+        response = session_with_retries().get(
+            url, headers=self._get_header(), params=params
+        )
+        response_data = request_handling(response)
+        return parse_obj_as(List[JobRun], response_data["data"])
 
     def get_job_run(
         self,
@@ -612,9 +568,9 @@ class ServiceFoundryServiceClient:
         job_run_name: str,
     ):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/jobs/{application_id}/runs/{job_run_name}"
-        res = requests.get(url, headers=self._get_header())
-        res = request_handling(res)
-        return parse_obj_as(JobRun, res)
+        response = session_with_retries().get(url, headers=self._get_header())
+        response_data = request_handling(response)
+        return parse_obj_as(JobRun, response_data)
 
     def trigger_job(
         self,
@@ -631,14 +587,18 @@ class ServiceFoundryServiceClient:
             body["input"]["command"] = command
         if params:
             body["input"]["params"] = params
-        res = requests.post(url, json=body, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().post(
+            url, json=body, headers=self._get_header()
+        )
+        response = request_handling(response)
         return TriggerJobResult.parse_obj(response)
 
     def trigger_workflow(self, application_id: str, inputs: Dict[str, Any]):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/workflow/{application_id}/executions"
-        res = requests.post(url, json=inputs, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().post(
+            url, json=inputs, headers=self._get_header()
+        )
+        response = request_handling(response)
         return response
 
     @check_min_cli_version
@@ -646,7 +606,7 @@ class ServiceFoundryServiceClient:
         self, docker_registry_fqn: str, cluster_id: str
     ) -> DockerRegistryCredentials:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/docker-registry/creds"
-        res = requests.get(
+        response = session_with_retries().get(
             url,
             headers=self._get_header(),
             params={
@@ -654,7 +614,7 @@ class ServiceFoundryServiceClient:
                 "clusterId": cluster_id,
             },
         )
-        response = request_handling(res)
+        response = request_handling(response)
         return DockerRegistryCredentials.parse_obj(response)
 
     @check_min_cli_version
@@ -662,7 +622,7 @@ class ServiceFoundryServiceClient:
         self, docker_registry_fqn: str, workspace_fqn: str, application_name: str
     ) -> CreateDockerRepositoryResponse:
         url = f"{self._api_server_url}/{VERSION_PREFIX}/docker-registry/create-repo"
-        res = requests.post(
+        response = session_with_retries().post(
             url,
             headers=self._get_header(),
             data={
@@ -671,7 +631,7 @@ class ServiceFoundryServiceClient:
                 "applicationName": application_name,
             },
         )
-        response = request_handling(res)
+        response = request_handling(response)
         return CreateDockerRepositoryResponse.parse_obj(response)
 
     @check_min_cli_version
@@ -689,8 +649,10 @@ class ServiceFoundryServiceClient:
             params["workspaceId"] = workspace_id
         if application_name:
             params["applicationName"] = application_name
-        res = requests.get(url, params=params, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().get(
+            url, params=params, headers=self._get_header()
+        )
+        response = request_handling(response)
         return parse_obj_as(List[Application], response)
 
     @check_min_cli_version
@@ -708,39 +670,38 @@ class ServiceFoundryServiceClient:
             params["version"] = deployment_version
         if deployment_id:
             params["deploymentId"] = deployment_id
-        res = requests.get(url, params=params, headers=self._get_header())
-        response = request_handling(res)
+        response = session_with_retries().get(
+            url, params=params, headers=self._get_header()
+        )
+        response = request_handling(response)
         return parse_obj_as(List[Deployment], response)
 
     @check_min_cli_version
-    def get_token_from_api_key(self, api_key: str) -> Token:
-        url = f"{self._api_server_url}/{VERSION_PREFIX}/oauth/api-key/token"
-        data = {"apiKey": api_key}
-        res = requests.get(url, params=data)
-        res = request_handling(res)
-        return Token.parse_obj(res)
-
-    @check_min_cli_version
-    def apply(self, manifest: Dict[str, Any]) -> None:
+    def apply(self, manifest: Dict[str, Any]):
         url = f"{self._api_server_url}/{VERSION_PREFIX}/apply"
         body = {"manifest": manifest}
-        res = requests.put(url, headers=self._get_header(), json=body)
-        res = request_handling(res)
-        return res
+        response = session_with_retries().put(
+            url, headers=self._get_header(), json=body
+        )
+        response_data = request_handling(response)
+        return response_data
 
     def terminate_job_run(
         self,
         deployment_id: str,
         job_run_name: str,
-        callback=None,
     ):
-        callback = callback or OutputCallBack()
-        url = f"{self._api_server_url}/{VERSION_PREFIX}/jobs/terminate?deploymentId={deployment_id}&jobRunName={job_run_name}"
+        url = f"{self._api_server_url}/{VERSION_PREFIX}/jobs/terminate"
         body = {
             "deploymentId": deployment_id,
             "jobRunName": job_run_name,
         }
-        res = requests.post(url, json=body, headers=self._get_header())
-        res = request_handling(res)
-
-        return res
+        response = session_with_retries().post(
+            url,
+            # TODO (chiragjn): Check if this is supposed to be params or json
+            params=body,
+            json=body,
+            headers=self._get_header(),
+        )
+        response_data = request_handling(response)
+        return response_data

truefoundry/deploy/lib/const.py

@@ -1,43 +1,9 @@
-from pathlib import Path
-
 from truefoundry.deploy.io.rich_output_callback import RichOutputCallBack
 
-DEFAULT_BASE_URL = "https://app.truefoundry.com"
-API_SERVER_RELATIVE_PATH = "api/svc"
-DEFAULT_API_SERVER = f"{DEFAULT_BASE_URL.rstrip('/')}/{API_SERVER_RELATIVE_PATH}"
-DEFAULT_AUTH_UI = DEFAULT_BASE_URL
-DEFAULT_AUTH_SERVER = (
-    "https://auth-server.tfy-ctl-euwe1-production.production.truefoundry.com"
-)
-DEFAULT_TENANT_NAME = "truefoundry"
-DEFAULT_PROFILE_NAME = "default"
-HOST_ENV_NAME = "TFY_HOST"
-API_KEY_ENV_NAME = "TFY_API_KEY"
-
-_SFY_CONFIG_DIR = Path.home() / ".truefoundry"
-SFY_CONFIG_DIR = str(_SFY_CONFIG_DIR)  # as a directory
-CREDENTIAL_FILEPATH = _SFY_CONFIG_DIR / "credentials.json"
-
-OLD_SFY_PROFILES_FILEPATH = _SFY_CONFIG_DIR / "profiles.json"  # as a directory
-OLD_SFY_SESSIONS_FILEPATH = _SFY_CONFIG_DIR / "sessions.json"  # as a directory
-OLD_SESSION_FILEPATH = str(
-    Path.home() / ".truefoundry"
-)  # as a filepath, to be removed in future versions
-
-# Polling during login redirect
-MAX_POLLING_RETRY = 100
-POLLING_SLEEP_TIME_IN_SEC = 4
-
-# Refresh access token cutoff
-REFRESH_ACCESS_TOKEN_IN_SEC = 10 * 60
-
 ENTITY_JSON_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
 RICH_OUTPUT_CALLBACK = RichOutputCallBack()
 
-VERSION_PREFIX = "v1"
-
 SFY_DEBUG_ENV_KEY = "SFY_DEBUG"
-SFY_INTERNAL_ENV_KEY = "SFY_INTERNAL"
-
 TFY_DEBUG_ENV_KEY = "TFY_DEBUG"
+SFY_INTERNAL_ENV_KEY = "SFY_INTERNAL"
 TFY_INTERNAL_ENV_KEY = "TFY_INTERNAL"

truefoundry/deploy/lib/exceptions.py

@@ -1,19 +1,6 @@
 from typing import Optional
 
 
-class BadRequestException(Exception):
-    def __init__(self, status_code: int, message: Optional[str] = None):
-        super().__init__()
-        self.status_code = status_code
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-    def __repr__(self):
-        return self.message
-
-
 class ConfigurationException(Exception):
     def __init__(self, message: Optional[str] = None):
         super().__init__()
@@ -21,6 +8,3 @@ class ConfigurationException(Exception):
 
     def __str__(self):
         return self.message
-
-    def __repr__(self):
-        return self.message