dbt-platform-helper 13.4.1__py3-none-any.whl → 14.1.0__py3-none-any.whl

dbt_platform_helper/domain/pipelines.py

@@ -1,3 +1,4 @@
+import os
 from collections.abc import Callable
 from os import makedirs
 from pathlib import Path
@@ -5,6 +6,7 @@ from shutil import rmtree
 
 from dbt_platform_helper.constants import CODEBASE_PIPELINES_KEY
 from dbt_platform_helper.constants import ENVIRONMENT_PIPELINES_KEY
+from dbt_platform_helper.constants import PLATFORM_HELPER_VERSION_OVERRIDE_KEY
 from dbt_platform_helper.constants import SUPPORTED_AWS_PROVIDER_VERSION
 from dbt_platform_helper.constants import SUPPORTED_TERRAFORM_VERSION
 from dbt_platform_helper.providers.config import ConfigProvider
@@ -14,9 +16,6 @@ from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.terraform_manifest import TerraformManifestProvider
 from dbt_platform_helper.utils.application import get_application_name
 from dbt_platform_helper.utils.template import setup_templates
-from dbt_platform_helper.utils.tool_versioning import (
-    get_required_terraform_platform_modules_version,
-)
 
 
 class Pipelines:
@@ -29,6 +28,7 @@ class Pipelines:
         get_codestar_arn: Callable[[str], str],
         io: ClickIOProvider = ClickIOProvider(),
         file_provider: FileProvider = FileProvider(),
+        platform_helper_version_override: str = None,
     ):
         self.config_provider = config_provider
         self.get_git_remote = get_git_remote
@@ -37,8 +37,14 @@ class Pipelines:
         self.ecr_provider = ecr_provider
         self.io = io
         self.file_provider = file_provider
+        self.platform_helper_version_override = platform_helper_version_override or os.environ.get(
+            PLATFORM_HELPER_VERSION_OVERRIDE_KEY
+        )
 
-    def generate(self, cli_terraform_platform_modules_version: str, deploy_branch: str):
+    def generate(
+        self,
+        deploy_branch: str,
+    ):
         platform_config = self.config_provider.load_and_validate_platform_config()
 
         has_codebase_pipelines = CODEBASE_PIPELINES_KEY in platform_config
@@ -48,10 +54,6 @@ class Pipelines:
             self.io.warn("No pipelines defined: nothing to do.")
             return
 
-        platform_config_terraform_modules_default_version = platform_config.get(
-            "default_versions", {}
-        ).get("terraform-platform-modules", "")
-
         app_name = get_application_name()
 
         git_repo = self.get_git_remote()
@@ -67,12 +69,14 @@ class Pipelines:
 
         self._clean_pipeline_config(copilot_pipelines_dir)
 
-        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
-            cli_terraform_platform_modules_version,
-            platform_config_terraform_modules_default_version,
+        platform_helper_version_for_template: str = platform_config.get("default_versions", {}).get(
+            "platform-helper"
         )
 
-        # TODO - this whole code block/if-statement can fall away once the deploy_repository is a required key.
+        if self.platform_helper_version_override:
+            platform_helper_version_for_template = self.platform_helper_version_override
+
+        # TODO: DBTP-1965: - this whole code block/if-statement can fall away once the deploy_repository is a required key.
         deploy_repository = ""
         if "deploy_repository" in platform_config.keys():
             deploy_repository = f"{platform_config['deploy_repository']}"
@@ -95,7 +99,7 @@ class Pipelines:
                     platform_config["application"],
                     deploy_repository,
                     account,
-                    terraform_platform_modules_version,
+                    platform_helper_version_for_template,
                     deploy_branch,
                 )
 
@@ -114,7 +118,7 @@ class Pipelines:
 
             self.terraform_manifest_provider.generate_codebase_pipeline_config(
                 platform_config,
-                terraform_platform_modules_version,
+                platform_helper_version_for_template,
                 ecrs_that_need_importing,
                 deploy_repository,
             )
@@ -129,7 +133,7 @@ class Pipelines:
         application: str,
         deploy_repository: str,
         aws_account: str,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
         deploy_branch: str,
     ):
         env_pipeline_template = setup_templates().get_template("environment-pipelines/main.tf")
@@ -139,7 +143,7 @@ class Pipelines:
                 "application": application,
                 "deploy_repository": deploy_repository,
                 "aws_account": aws_account,
-                "terraform_platform_modules_version": terraform_platform_modules_version,
+                "platform_helper_version": platform_helper_version,
                 "deploy_branch": deploy_branch,
                 "terraform_version": SUPPORTED_TERRAFORM_VERSION,
                 "aws_provider_version": SUPPORTED_AWS_PROVIDER_VERSION,

dbt_platform_helper/domain/terraform_environment.py

@@ -1,9 +1,9 @@
+import os
+
+from dbt_platform_helper.constants import PLATFORM_HELPER_VERSION_OVERRIDE_KEY
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.terraform_manifest import TerraformManifestProvider
-from dbt_platform_helper.utils.tool_versioning import (
-    get_required_terraform_platform_modules_version,
-)
 
 
 class TerraformEnvironmentException(PlatformException):
@@ -20,12 +20,20 @@ class TerraformEnvironment:
         config_provider,
         manifest_provider: TerraformManifestProvider = None,
         io: ClickIOProvider = ClickIOProvider(),
+        platform_helper_version_override: str = None,
     ):
         self.io = io
         self.config_provider = config_provider
         self.manifest_provider = manifest_provider or TerraformManifestProvider()
+        self.platform_helper_version_override = platform_helper_version_override or os.environ.get(
+            PLATFORM_HELPER_VERSION_OVERRIDE_KEY
+        )
+
+    def generate(
+        self,
+        environment_name: str,
+    ):
 
-    def generate(self, environment_name, terraform_platform_modules_version_override=None):
         config = self.config_provider.get_enriched_config()
 
         if environment_name not in config.get("environments").keys():
@@ -33,14 +41,13 @@ class TerraformEnvironment:
                 f"cannot generate terraform for environment {environment_name}.  It does not exist in your configuration"
             )
 
-        platform_config_terraform_modules_default_version = config.get("default_versions", {}).get(
-            "terraform-platform-modules", ""
-        )
-        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
-            terraform_platform_modules_version_override,
-            platform_config_terraform_modules_default_version,
+        platform_helper_version_for_template: str = config.get("default_versions", {}).get(
+            "platform-helper"
         )
 
+        if self.platform_helper_version_override:
+            platform_helper_version_for_template = self.platform_helper_version_override
+
         self.manifest_provider.generate_environment_config(
-            config, environment_name, terraform_platform_modules_version
+            config, environment_name, platform_helper_version_for_template
         )

dbt_platform_helper/domain/versioning.py

@@ -12,14 +12,11 @@ from dbt_platform_helper.providers.semantic_version import (
 from dbt_platform_helper.providers.semantic_version import SemanticVersion
 from dbt_platform_helper.providers.version import AWSCLIInstalledVersionProvider
 from dbt_platform_helper.providers.version import CopilotInstalledVersionProvider
-from dbt_platform_helper.providers.version import DeprecatedVersionFileVersionProvider
 from dbt_platform_helper.providers.version import GithubLatestVersionProvider
 from dbt_platform_helper.providers.version import InstalledVersionProvider
 from dbt_platform_helper.providers.version import PyPiLatestVersionProvider
 from dbt_platform_helper.providers.version import VersionProvider
-from dbt_platform_helper.providers.version_status import PlatformHelperVersionStatus
 from dbt_platform_helper.providers.version_status import VersionStatus
-from dbt_platform_helper.providers.yaml_file import YamlFileProvider
 
 
 def running_as_installed_package():
@@ -31,24 +28,20 @@ def skip_version_checks():
 
 
 class PlatformHelperVersionNotFoundException(PlatformException):
-    def __init__(self):
-        super().__init__(f"""Platform helper version could not be resolved.""")
+    def __init__(self, message=None):
+        super().__init__(message or "Platform helper version could not be resolved.")
 
 
 class PlatformHelperVersioning:
     def __init__(
         self,
         io: ClickIOProvider = ClickIOProvider(),
-        version_file_version_provider: DeprecatedVersionFileVersionProvider = DeprecatedVersionFileVersionProvider(
-            YamlFileProvider
-        ),
         config_provider: ConfigProvider = ConfigProvider(),
         latest_version_provider: VersionProvider = PyPiLatestVersionProvider,
         installed_version_provider: InstalledVersionProvider = InstalledVersionProvider(),
         skip_versioning_checks: bool = None,
     ):
         self.io = io
-        self.version_file_version_provider = version_file_version_provider
         self.config_provider = config_provider
         self.latest_version_provider = latest_version_provider
         self.installed_version_provider = installed_version_provider
@@ -56,10 +49,9 @@ class PlatformHelperVersioning:
             skip_versioning_checks if skip_versioning_checks is not None else skip_version_checks()
         )
 
-    def get_required_version(self, pipeline=None):
-        version_status = self._get_version_status()
-        self.io.process_messages(version_status.validate())
-        required_version = self._resolve_required_version(pipeline, version_status)
+    def get_required_version(self):
+        platform_config = self.config_provider.load_and_validate_platform_config()
+        required_version = platform_config.get("default_versions", {}).get("platform-helper")
         self.io.info(required_version)
         return required_version
 
@@ -68,25 +60,24 @@ class PlatformHelperVersioning:
         if self.skip_versioning_checks:
             return
 
-        version_status = self._get_version_status()
-        self.io.process_messages(version_status.validate())
+        version_status = self.get_version_status()
+        required_version = self.get_required_version()
 
-        required_version = SemanticVersion.from_string(
-            self._resolve_required_version(version_status=version_status)
-        )
+        if SemanticVersion.is_semantic_version(required_version):
+            required_version_semver = SemanticVersion.from_string(required_version)
 
-        if not version_status.installed == required_version:
-            message = (
-                f"WARNING: You are running platform-helper v{version_status.installed} against "
-                f"v{required_version} specified for the project."
-            )
-            self.io.warn(message)
+            if not version_status.installed == required_version_semver:
+                message = (
+                    f"WARNING: You are running platform-helper v{version_status.installed} against "
+                    f"v{required_version_semver} specified for the project."
+                )
+                self.io.warn(message)
 
     def check_if_needs_update(self):
         if self.skip_versioning_checks:
             return
 
-        version_status = self._get_version_status(include_project_versions=False)
+        version_status = self.get_version_status()
 
         message = (
             f"You are running platform-helper v{version_status.installed}, upgrade to "
@@ -101,65 +92,14 @@ class PlatformHelperVersioning:
         except IncompatibleMinorVersionException:
             self.io.warn(message)
 
-    def _get_version_status(
-        self,
-        include_project_versions: bool = True,
-    ) -> PlatformHelperVersionStatus:
+    def get_version_status(self) -> VersionStatus:
         locally_installed_version = self.installed_version_provider.get_semantic_version(
             "dbt-platform-helper"
         )
 
         latest_release = self.latest_version_provider.get_semantic_version("dbt-platform-helper")
 
-        if not include_project_versions:
-            return PlatformHelperVersionStatus(
-                installed=locally_installed_version,
-                latest=latest_release,
-            )
-
-        platform_config_default, pipeline_overrides = None, {}
-
-        platform_config = self.config_provider.load_unvalidated_config_file()
-
-        if platform_config:
-            platform_config_default = SemanticVersion.from_string(
-                platform_config.get("default_versions", {}).get("platform-helper")
-            )
-
-            pipeline_overrides = {
-                name: pipeline.get("versions", {}).get("platform-helper")
-                for name, pipeline in platform_config.get("environment_pipelines", {}).items()
-                if pipeline.get("versions", {}).get("platform-helper")
-            }
-        out = PlatformHelperVersionStatus(
-            installed=locally_installed_version,
-            latest=latest_release,
-            deprecated_version_file=self.version_file_version_provider.get_semantic_version(),
-            platform_config_default=platform_config_default,
-            pipeline_overrides=pipeline_overrides,
-        )
-
-        return out
-
-    def _resolve_required_version(
-        self, pipeline: str = None, version_status: PlatformHelperVersionStatus = None
-    ) -> str:
-        pipeline_version = version_status.pipeline_overrides.get(pipeline)
-        version_precedence = [
-            pipeline_version,
-            version_status.platform_config_default,
-            version_status.deprecated_version_file,
-        ]
-        non_null_version_precedence = [
-            f"{v}" if isinstance(v, SemanticVersion) else v for v in version_precedence if v
-        ]
-
-        out = non_null_version_precedence[0] if non_null_version_precedence else None
-
-        if not out:
-            raise PlatformHelperVersionNotFoundException
-
-        return out
+        return VersionStatus(installed=locally_installed_version, latest=latest_release)
 
 
 class AWSVersioning:

dbt_platform_helper/providers/aws/exceptions.py

@@ -29,7 +29,7 @@ class LogGroupNotFoundException(AWSException):
         super().__init__(f"""No log group called "{log_group_name}".""")
 
 
-# Todo: This should probably be in the AWS Copilot provider, but was causing circular import when we tried it pre refactoring the utils/aws.py
+# TODO: DBTP-1976: This should probably be in the AWS Copilot provider, but was causing circular import when we tried it pre refactoring the utils/aws.py
 class CopilotCodebaseNotFoundException(PlatformException):
     def __init__(self, codebase: str):
         super().__init__(

dbt_platform_helper/providers/cloudformation.py

@@ -8,7 +8,7 @@ from dbt_platform_helper.platform_exception import PlatformException
 
 
 class CloudFormation:
-    # TODO add handling for optional client parameters to handle case of calling boto API with None
+    # TODO: DBTP-1966: add handling for optional client parameters to handle case of calling boto API with None
     def __init__(self, cloudformation_client, iam_client=None, ssm_client=None):
         self.cloudformation_client = cloudformation_client
         self.iam_client = iam_client

dbt_platform_helper/providers/config.py

@@ -1,41 +1,59 @@
 from copy import deepcopy
+from datetime import datetime
 from pathlib import Path
 
 from schema import SchemaError
 
+from dbt_platform_helper.constants import FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
 from dbt_platform_helper.constants import PLATFORM_CONFIG_FILE
+from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
+from dbt_platform_helper.constants import PLATFORM_HELPER_PACKAGE_NAME
 from dbt_platform_helper.providers.config_validator import ConfigValidator
 from dbt_platform_helper.providers.config_validator import ConfigValidatorError
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.platform_config_schema import PlatformConfigSchema
+from dbt_platform_helper.providers.semantic_version import SemanticVersion
+from dbt_platform_helper.providers.version import InstalledVersionProvider
 from dbt_platform_helper.providers.yaml_file import FileNotFoundException
 from dbt_platform_helper.providers.yaml_file import FileProviderException
 from dbt_platform_helper.providers.yaml_file import YamlFileProvider
 
+SCHEMA_VERSION_MESSAGE = """Installed version: platform-helper: {installed_platform_helper_version} (schema version: {installed_schema_version})
+'platform-config.yml' version: platform-helper: {config_platform_helper_version} (schema version: {config_schema_version})"""
+PLEASE_UPGRADE_TO_V13_MESSAGE = """Please ensure that you have already upgraded to platform-helper 13, following the instructions in https://platform.readme.trade.gov.uk/reference/upgrading-platform-helper/.
+
+Then upgrade platform-helper to version {installed_platform_helper_version} and run 'platform-helper config migrate' to upgrade the configuration to the current schema version."""
+
 
 class ConfigProvider:
     def __init__(
         self,
-        config_validator: ConfigValidator = None,
-        file_provider: YamlFileProvider = None,
-        io: ClickIOProvider = None,
+        config_validator: ConfigValidator = ConfigValidator(),
+        file_provider: YamlFileProvider = YamlFileProvider,
+        io: ClickIOProvider = ClickIOProvider(),
+        schema_version_for_installed_platform_helper: int = PLATFORM_CONFIG_SCHEMA_VERSION,
+        installed_version_provider: InstalledVersionProvider = InstalledVersionProvider,
     ):
         self.config = {}
-        self.validator = config_validator or ConfigValidator()
-        self.io = io or ClickIOProvider()
-        self.file_provider = file_provider or YamlFileProvider
-
-    # TODO refactor so that apply_environment_defaults isn't set, discarded and set again
+        self.validator = config_validator
+        self.io = io
+        self.file_provider = file_provider
+        self.schema_version_for_installed_platform_helper = (
+            schema_version_for_installed_platform_helper
+        )
+        self.installed_version_provider = installed_version_provider
+
+    # TODO: DBTP-1964: refactor so that apply_environment_defaults isn't set, discarded and set again
     def get_enriched_config(self):
         return self.apply_environment_defaults(self.load_and_validate_platform_config())
 
     def _validate_platform_config(self):
         PlatformConfigSchema.schema().validate(self.config)
-
-        # TODO= logically this isn't validation but loading + parsing, to move.
+        # TODO: DBTP-1964: = logically this isn't validation but loading + parsing, to move.
         # also, we apply defaults but discard that data.  Should we just apply
         # defaults to config returned by load_and_validate
         enriched_config = ConfigProvider.apply_environment_defaults(self.config)
+
         try:
             self.validator.run_validations(enriched_config)
         except ConfigValidatorError as exc:
@@ -51,6 +69,8 @@ class ConfigProvider:
         except FileProviderException as e:
             self.io.abort_with_error(f"Error loading configuration from {path}: {e}")
 
+        self._validate_schema_version()
+
         try:
             self._validate_platform_config()
         except SchemaError as e:
@@ -58,13 +78,90 @@ class ConfigProvider:
 
         return self.config
 
+    def _abort_due_to_schema_version_error(self, config_description: str, action_required: str):
+        self.io.abort_with_error(
+            "\n".join(
+                [
+                    config_description,
+                    "",
+                    action_required,
+                ]
+            )
+        )
+
+    def _validate_schema_version(self):
+        config_schema_version = self.config.get("schema_version")
+        config_platform_helper_version = self.config.get("default_versions", {}).get(
+            "platform-helper", ""
+        )
+        header = SCHEMA_VERSION_MESSAGE.format(
+            installed_platform_helper_version=self._installed_platform_helper_version(),
+            installed_schema_version=self.schema_version_for_installed_platform_helper,
+            config_platform_helper_version=(
+                config_platform_helper_version if config_platform_helper_version else "N/A"
+            ),
+            config_schema_version=(config_schema_version if config_schema_version else "N/A"),
+        )
+
+        if config_schema_version:
+            self._handle_schema_version_mismatch(config_schema_version, header)
+        else:
+            self._handle_missing_schema_version(config_platform_helper_version, header)
+
+    def _handle_schema_version_mismatch(self, platform_config_schema_version: int, header: str):
+        platform_config_schema_version_is_old = (
+            platform_config_schema_version < self.schema_version_for_installed_platform_helper
+        )
+        installed_platform_helper_is_old = (
+            platform_config_schema_version > self.schema_version_for_installed_platform_helper
+        )
+
+        if platform_config_schema_version_is_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                "Please upgrade your platform-config.yml by running 'platform-helper config migrate'.",
+            )
+        elif installed_platform_helper_is_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                f"Please update your platform-helper to a version that supports schema_version: {platform_config_schema_version}.",
+            )
+        # else the schema_version is the correct one so continue.
+
+    def _handle_missing_schema_version(self, config_platform_helper_version: str, header: str):
+        config_p_h_version_semver = SemanticVersion.from_string(config_platform_helper_version)
+        major_version = config_p_h_version_semver and config_p_h_version_semver.major
+        platform_config_is_old_but_supported_by_migrations = (
+            major_version and major_version == FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
+        )
+        platform_config_is_old = (
+            major_version and major_version < FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION
+        )
+        platform_config_is_really_old = not major_version
+        installed_platform_helper_version = self._installed_platform_helper_version()
+
+        if platform_config_is_old_but_supported_by_migrations:
+            self._abort_due_to_schema_version_error(
+                header,
+                f"Please upgrade your platform-config.yml to be compatible with {installed_platform_helper_version} by running: 'platform-helper config migrate'.",
+            )
+        elif platform_config_is_old or platform_config_is_really_old:
+            self._abort_due_to_schema_version_error(
+                header,
+                PLEASE_UPGRADE_TO_V13_MESSAGE.format(
+                    installed_platform_helper_version=installed_platform_helper_version,
+                ),
+            )
+        # if major_version and major_version > FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION then
+        # the platform-config.yml is malformed and so should progress to validation if appropriate.
+
     def load_unvalidated_config_file(self, path=PLATFORM_CONFIG_FILE):
         try:
             return self.file_provider.load(path)
         except FileProviderException:
             return {}
 
-    # TODO remove function and push logic to where this is called.
+    # TODO: DBTP-1888: remove function and push logic to where this is called.
     # removed usage from config domain, code is very generic and doesn't require the overhead of a function
     def config_file_check(self, path=PLATFORM_CONFIG_FILE):
         if not Path(path).exists():
@@ -86,17 +183,12 @@ class ConfigProvider:
             name: data if data else {} for name, data in environments.items() if name != "*"
         }
 
-        default_versions = config.get("default_versions", {})
+        config.get("default_versions", {})
 
         def combine_env_data(data):
             return {
                 **env_defaults,
                 **data,
-                "versions": {
-                    **default_versions,
-                    **env_defaults.get("versions", {}),
-                    **data.get("versions", {}),
-                },
             }
 
         defaulted_envs = {
@@ -107,3 +199,13 @@ class ConfigProvider:
         enriched_config["environments"] = defaulted_envs
 
         return enriched_config
+
+    def write_platform_config(self, new_platform_config):
+        current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        message = f"# Generated by platform-helper {self._installed_platform_helper_version()} / {current_date}.\n\n"
+        self.file_provider.write(PLATFORM_CONFIG_FILE, new_platform_config, message)
+
+    def _installed_platform_helper_version(self) -> str:
+        return str(
+            self.installed_version_provider.get_semantic_version(PLATFORM_HELPER_PACKAGE_NAME)
+        )

dbt_platform_helper/providers/config_validator.py

@@ -89,16 +89,16 @@ class ConfigValidator:
         return self._validate_extension_supported_versions(
             config=config,
             aws_provider=Redis(self._get_client("elasticache")),
-            extension_type="redis",  # TODO this is information which can live in the RedisProvider
-            version_key="engine",  # TODO this is information which can live in the RedisProvider
+            extension_type="redis",  # TODO: DBTP-1888: this is information which can live in the RedisProvider
+            version_key="engine",  # TODO: DBTP-1888: this is information which can live in the RedisProvider
         )
 
     def validate_supported_opensearch_versions(self, config):
         return self._validate_extension_supported_versions(
             config=config,
             aws_provider=Opensearch(self._get_client("opensearch")),
-            extension_type="opensearch",  # TODO this is information which can live in the OpensearchProvider
-            version_key="engine",  # TODO this is information which can live in the OpensearchProvider
+            extension_type="opensearch",  # TODO: DBTP-1888: this is information which can live in the OpensearchProvider
+            version_key="engine",  # TODO: DBTP-1888: this is information which can live in the OpensearchProvider
         )
 
     def validate_environment_pipelines(self, config):
@@ -180,21 +180,6 @@ class ConfigValidator:
                 from_env = section["from"]
                 to_env = section["to"]
 
-                from_account = (
-                    config.get("environments", {})
-                    .get(from_env, {})
-                    .get("accounts", {})
-                    .get("deploy", {})
-                    .get("id")
-                )
-                to_account = (
-                    config.get("environments", {})
-                    .get(to_env, {})
-                    .get("accounts", {})
-                    .get("deploy", {})
-                    .get("id")
-                )
-
                 if from_env == to_env:
                     errors.append(
                         f"database_copy 'to' and 'from' cannot be the same environment in extension '{extension_name}'."
@@ -215,18 +200,6 @@ class ConfigValidator:
                         f"database_copy 'to' parameter must be a valid environment ({all_envs_string}) but was '{to_env}' in extension '{extension_name}'."
                     )
 
-                # TODO - The from_account and to_account properties are deprecated and will be removed when terraform-platform-modules is merged with platform-tools
-                if from_account != to_account:
-                    if "from_account" in section and section["from_account"] != from_account:
-                        errors.append(
-                            f"Incorrect value for 'from_account' for environment '{from_env}'"
-                        )
-
-                    if "to_account" in section and section["to_account"] != to_account:
-                        errors.append(
-                            f"Incorrect value for 'to_account' for environment '{to_env}'"
-                        )
-
         if errors:
             raise ConfigValidatorError("\n".join(errors))
 

dbt_platform_helper/providers/copilot.py

@@ -53,7 +53,7 @@ def create_addon_client_task(
         # We cannot check for botocore.errorfactory.NoSuchEntityException as botocore generates that class on the fly as part of errorfactory.
         # factory. Checking the error code is the recommended way of handling these exceptions.
         if ex.response.get("Error", {}).get("Code", None) != "NoSuchEntity":
-            # TODO When we are refactoring this, raise an exception to be caught at the command layer
+            # TODO: DBTP-1946: When we are refactoring this, raise an exception to be caught at the command layer
             abort_with_error(
                 f"cannot obtain Role {role_name}: {ex.response.get('Error', {}).get('Message', '')}"
             )
@@ -132,7 +132,7 @@ def connect_to_addon_client_task(
     tries = 0
     while tries < 15 and not running:
         tries += 1
-        # Todo: Use from ECS provider when we refactor this
+        # TODO: DBTP-1946: Use from ECS provider when we refactor this
         if get_ecs_task_arns(ecs_client, cluster_arn, task_name):
             subprocess.call(
                 "copilot task exec "
@@ -154,7 +154,7 @@ def _normalise_secret_name(addon_name: str) -> str:
 
 
 def _get_secrets_provider(application: Application, env: str) -> Secrets:
-    # Todo: We instantiate the secrets provider here to avoid rabbit holing, but something better probably possible when we are refactoring this area
+    # TODO: DBTP-1946: We instantiate the secrets provider here to avoid rabbit holing, but something better probably possible when we are refactoring this area
     return Secrets(
         application.environments[env].session.client("ssm"),
         application.environments[env].session.client("secretsmanager"),

dbt_platform_helper/providers/io.py

@@ -29,7 +29,7 @@ class ClickIOProvider:
         click.secho(f"Error: {message}", err=True, fg="red")
         exit(1)
 
-    # TODO messages will be a ValidationMessages class rather than a free-rein dictionary
+    # TODO: DBTP-1979: messages will be a ValidationMessages class rather than a free-rein dictionary
     def process_messages(self, messages: dict):
         if not messages:
             return