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

dbt_platform_helper/providers/load_balancers.py

@@ -48,7 +48,7 @@ class LoadBalancerProvider:
             ResourceTypeFilters=[
                 "elasticloadbalancing:targetgroup",
             ],
-        )  # TODO should be paginated
+        )  # TODO: DBTP-1942: should be paginated
         for resource in response["ResourceTagMappingList"]:
             tags = {tag["Key"]: tag["Value"] for tag in resource["Tags"]}
 
@@ -73,7 +73,7 @@ class LoadBalancerProvider:
         listener_arn = self.get_https_listener_for_application(app, env)
         certificates = self.evlb_client.describe_listener_certificates(ListenerArn=listener_arn)[
             "Certificates"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         try:
             certificate_arn = next(c["CertificateArn"] for c in certificates if c["IsDefault"])
@@ -87,7 +87,7 @@ class LoadBalancerProvider:
 
         listeners = self.evlb_client.describe_listeners(LoadBalancerArn=load_balancer_arn)[
             "Listeners"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         listener_arn = None
 
@@ -114,7 +114,7 @@ class LoadBalancerProvider:
 
         for lb in tag_descriptions:
             tags = {t["Key"]: t["Value"] for t in lb["Tags"]}
-            # TODO copilot hangover, creates coupling to specific tags could update to check application and environment
+            # TODO: DBTP-1967: copilot hangover, creates coupling to specific tags could update to check application and environment
             if tags.get("copilot-application") == app and tags.get("copilot-environment") == env:
                 return lb["ResourceArn"]
 
@@ -123,7 +123,7 @@ class LoadBalancerProvider:
     def get_host_header_conditions(self, listener_arn: str, target_group_arn: str) -> list:
         rules = self.evlb_client.describe_rules(ListenerArn=listener_arn)[
             "Rules"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
 
         conditions = []
 
@@ -152,7 +152,7 @@ class LoadBalancerProvider:
     def get_rules_tag_descriptions_by_listener_arn(self, listener_arn: str) -> list:
         rules = self.evlb_client.describe_rules(ListenerArn=listener_arn)[
             "Rules"
-        ]  # TODO should be paginated
+        ]  # TODO: DBTP-1942: should be paginated
         return self.get_rules_tag_descriptions(rules)
 
     def get_rules_tag_descriptions(self, rules: list) -> list:

dbt_platform_helper/providers/platform_config_schema.py

@@ -8,15 +8,18 @@ from schema import Regex
 from schema import Schema
 from schema import SchemaError
 
+from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
+
 
 class PlatformConfigSchema:
     @staticmethod
     def schema() -> Schema:
         return Schema(
             {
+                "schema_version": PLATFORM_CONFIG_SCHEMA_VERSION,
                 "application": str,
                 Optional("deploy_repository"): str,
-                Optional("default_versions"): PlatformConfigSchema.__default_versions_schema(),
+                "default_versions": PlatformConfigSchema.__default_versions_schema(),
                 Optional("environments"): PlatformConfigSchema.__environments_schema(),
                 Optional("codebase_pipelines"): PlatformConfigSchema.__codebase_pipelines_schema(),
                 Optional(
@@ -55,7 +58,7 @@ class PlatformConfigSchema:
             "subscription-filter": PlatformConfigSchema.__no_configuration_required_schema(
                 "subscription-filter"
             ),
-            # Todo: The next three are no longer relevant. Remove them.
+            # TODO: DBTP-1943: The next three are no longer relevant. Remove them.
             "monitoring": Schema(PlatformConfigSchema.__monitoring_schema()),
             "vpc": PlatformConfigSchema.__no_configuration_required_schema("vpc"),
             "xray": PlatformConfigSchema.__no_configuration_required_schema("xray"),
@@ -166,16 +169,11 @@ class PlatformConfigSchema:
     @staticmethod
     def __default_versions_schema() -> dict:
         return {
-            Optional("terraform-platform-modules"): str,
-            Optional("platform-helper"): str,
+            "platform-helper": str,
         }
 
     @staticmethod
     def __environments_schema() -> dict:
-        _valid_environment_specific_version_overrides = {
-            Optional("terraform-platform-modules"): str,
-        }
-
         return {
             str: Or(
                 None,
@@ -190,9 +188,8 @@ class PlatformConfigSchema:
                             "id": str,
                         },
                     },
-                    # Todo: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
+                    # TODO: DBTP-1943: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
                     Optional("requires_approval"): bool,
-                    Optional("versions"): _valid_environment_specific_version_overrides,
                     Optional("vpc"): str,
                 },
             )
@@ -250,7 +247,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __opensearch_schema() -> dict:
-        # Todo: Move to OpenSearch provider?
+        # TODO: DBTP-1943: Move to OpenSearch provider?
         _valid_opensearch_plans = Or(
             "tiny",
             "small",
@@ -288,7 +285,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __postgres_schema() -> dict:
-        # Todo: Move to Postgres provider?
+        # TODO: DBTP-1943: Move to Postgres provider?
         _valid_postgres_plans = Or(
             "tiny",
             "small",
@@ -311,14 +308,12 @@ class PlatformConfigSchema:
             "4x-large-high-io",
         )
 
-        # Todo: Move to Postgres provider?
+        # TODO: DBTP-1943: Move to Postgres provider?
         _valid_postgres_storage_types = Or("gp2", "gp3", "io1", "io2")
 
         _valid_postgres_database_copy = {
             "from": PlatformConfigSchema.__valid_environment_name(),
             "to": PlatformConfigSchema.__valid_environment_name(),
-            Optional("from_account"): str,
-            Optional("to_account"): str,
             Optional("pipeline"): {Optional("schedule"): str},
         }
 
@@ -366,7 +361,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __redis_schema() -> dict:
-        # Todo move to Redis provider?
+        # TODO: DBTP-1943: move to Redis provider?
         _valid_redis_plans = Or(
             "micro",
             "micro-ha",
@@ -400,7 +395,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def valid_s3_bucket_name(name: str):
-        # Todo: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
+        # TODO: DBTP-1943: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
         errors = []
         if not (2 < len(name) < 64):
             errors.append("Length must be between 3 and 63 characters inclusive.")
@@ -429,9 +424,9 @@ class PlatformConfigSchema:
                 errors.append(f"Names cannot be suffixed '{suffix}'.")
 
         if errors:
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(
-                "Bucket name '{}' is invalid:\n{}".format(name, "\n".join(f"  {e}" for e in errors))
+                f"Bucket name '{name}' is invalid:\n" + "\n".join(f"  {e}" for e in errors)
             )
 
         return True
@@ -557,10 +552,10 @@ class PlatformConfigSchema:
 
     @staticmethod
     def string_matching_regex(regex_pattern: str) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(string):
             if not re.match(regex_pattern, string):
-                # Todo: Raise suitable PlatformException?
+                # TODO: DBTP-1943: Raise suitable PlatformException?
                 raise SchemaError(
                     f"String '{string}' does not match the required pattern '{regex_pattern}'."
                 )
@@ -570,11 +565,11 @@ class PlatformConfigSchema:
 
     @staticmethod
     def is_integer_between(lower_limit, upper_limit) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(value):
             if isinstance(value, int) and lower_limit <= value <= upper_limit:
                 return True
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(f"should be an integer between {lower_limit} and {upper_limit}")
 
         return validate
@@ -588,7 +583,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __valid_branch_name() -> Callable:
-        # Todo: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
+        # TODO: DBTP-1943: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
         return PlatformConfigSchema.string_matching_regex(r"^((?!\*).)*(\*)?$")
 
     @staticmethod
@@ -634,10 +629,10 @@ class PlatformConfigSchema:
 
 
 class ConditionalOpensSearchSchema(Schema):
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_min_volume_size: int = 10
 
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_max_volume_size: dict = {
         "tiny": 100,
         "small": 200,
@@ -671,11 +666,11 @@ class ConditionalOpensSearchSchema(Schema):
 
                 if volume_size:
                     if not plan:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(f"Missing key: 'plan'")
 
                     if volume_size < self._valid_opensearch_min_volume_size:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(
                             f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer greater than {self._valid_opensearch_min_volume_size}"
                         )
@@ -685,7 +680,7 @@ class ConditionalOpensSearchSchema(Schema):
                             plan == key
                             and not volume_size <= self._valid_opensearch_max_volume_size[key]
                         ):
-                            # Todo: Raise suitable PlatformException?
+                            # TODO: DBTP-1943: Raise suitable PlatformException?
                             raise SchemaError(
                                 f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer between {self._valid_opensearch_min_volume_size} and {self._valid_opensearch_max_volume_size[key]} for plan {plan}"
                             )

dbt_platform_helper/providers/schema_migrations/schema_v0_to_v1_migration.py

@@ -0,0 +1,43 @@
+from copy import deepcopy
+
+
+class SchemaV0ToV1Migration:
+    def from_version(self) -> int:
+        return 0
+
+    def migrate(self, platform_config: dict) -> dict:
+        migrated_config = deepcopy(platform_config)
+
+        self._remove_terraform_platform_modules_default_version(migrated_config)
+        self._remove_versions_from_env_config(migrated_config)
+        self._remove_to_account_and_from_account_from_database_copy(migrated_config)
+        self._remove_pipeline_platform_helper_override(migrated_config)
+
+        return migrated_config
+
+    def _remove_versions_from_env_config(self, migrated_config: dict) -> None:
+        for env_name, env in migrated_config.get("environments", {}).items():
+            if env and "versions" in env:
+                del env["versions"]
+
+    def _remove_terraform_platform_modules_default_version(self, migrated_config: dict) -> None:
+        if "default_versions" in migrated_config:
+            default_versions = migrated_config["default_versions"]
+            if "terraform-platform-modules" in default_versions:
+                del default_versions["terraform-platform-modules"]
+
+    def _remove_to_account_and_from_account_from_database_copy(self, migrated_config: dict) -> None:
+        for extension_name, extension in migrated_config.get("extensions", {}).items():
+            if extension.get("type") == "postgres" and "database_copy" in extension:
+                for database_copy_block in extension["database_copy"]:
+                    if "from_account" in database_copy_block:
+                        del database_copy_block["from_account"]
+                    if "to_account" in database_copy_block:
+                        del database_copy_block["to_account"]
+
+    def _remove_pipeline_platform_helper_override(self, migrated_config: dict) -> None:
+        for pipeline_name, pipeline_config in migrated_config.get(
+            "environment_pipelines", {}
+        ).items():
+            if "versions" in pipeline_config:
+                del pipeline_config["versions"]

dbt_platform_helper/providers/schema_migrator.py

@@ -0,0 +1,77 @@
+from collections import Counter
+from collections import OrderedDict
+from copy import deepcopy
+from typing import Protocol
+
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.schema_migrations.schema_v0_to_v1_migration import (
+    SchemaV0ToV1Migration,
+)
+from dbt_platform_helper.providers.version import InstalledVersionProvider
+
+
+class InvalidMigrationConfigurationException(PlatformException):
+    pass
+
+
+class SchemaMigrationProtocol(Protocol):
+    def from_version(self) -> int: ...
+
+    def migrate(self, platform_config: dict) -> dict: ...
+
+
+# TODO: Possibly get this programmatically?
+ALL_MIGRATIONS = [SchemaV0ToV1Migration()]
+
+
+class Migrator:
+    def __init__(
+        self,
+        migrations: list[SchemaMigrationProtocol],
+        installed_version_provider: InstalledVersionProvider = InstalledVersionProvider,
+        io_provider: ClickIOProvider = ClickIOProvider(),
+    ):
+        self.migrations = sorted(migrations, key=lambda m: m.from_version())
+        self.installed_version_provider = installed_version_provider
+        self.io_provider = io_provider
+        from_version_counts = Counter([migration.from_version() for migration in self.migrations])
+        duplicate_from_versions = [count for count in from_version_counts.values() if count > 1]
+
+        if duplicate_from_versions:
+            raise InvalidMigrationConfigurationException(
+                "`from_version` parameters must be unique amongst migrations"
+            )
+
+    def migrate(self, platform_config: dict) -> dict:
+        out = OrderedDict(deepcopy(platform_config))
+        if "schema_version" not in out:
+            out["schema_version"] = 0
+
+        if "default_versions" in out:
+            out.move_to_end("default_versions", last=False)
+        if "schema_version" in out:
+            out.move_to_end("schema_version", last=False)
+        if "application" in out:
+            out.move_to_end("application", last=False)
+
+        for migration in self.migrations:
+            migration_can_be_applied = migration.from_version() == out["schema_version"]
+            if migration_can_be_applied:
+                out = migration.migrate(out)
+                schema_version = out["schema_version"]
+                self.io_provider.info(
+                    f"Migrating from platform config schema version {schema_version} to version {schema_version + 1}"
+                )
+                out["schema_version"] += 1
+
+        if "default_versions" not in out:
+            out["default_versions"] = {}
+
+        out["default_versions"]["platform-helper"] = str(
+            self.installed_version_provider.get_semantic_version("dbt-platform-helper")
+        )
+
+        self.io_provider.info("\nMigration complete")
+
+        return dict(out)

dbt_platform_helper/providers/secrets.py

@@ -41,7 +41,7 @@ class Secrets:
 
         raise SecretNotFoundException(secret_name)
 
-    # Todo: This probably does not belong in the secrets provider. When it moves, take the Todoed exceptions from below
+    # TODO: DBTP-1946: This probably does not belong in the secrets provider. When it moves, take the Todoed exceptions from below
     def get_addon_type(self, addon_name: str) -> str:
         addon_type = None
         try:
@@ -82,18 +82,18 @@ class Secrets:
         return addon_name.replace("-", "_").upper()
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonException(PlatformException):
     pass
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonNotFoundException(AddonException):
     def __init__(self, addon_name: str):
         super().__init__(f"""Addon "{addon_name}" does not exist.""")
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonTypeMissingFromConfigException(AddonException):
     def __init__(self, addon_name: str):
         super().__init__(
@@ -101,7 +101,7 @@ class AddonTypeMissingFromConfigException(AddonException):
         )
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class InvalidAddonTypeException(AddonException):
     def __init__(self, addon_type):
         self.addon_type = addon_type

dbt_platform_helper/providers/semantic_version.py

@@ -19,7 +19,7 @@ class IncompatibleMinorVersionException(ValidationException):
 
 
 class SemanticVersion:
-    def __init__(self, major, minor, patch):
+    def __init__(self, major: int, minor: int, patch: int):
         self.major = major
         self.minor = minor
         self.patch = patch
@@ -74,3 +74,8 @@ class SemanticVersion:
         major, minor, patch = [self._cast_to_int_with_fallback(s) for s in version_segments]
 
         return SemanticVersion(major, minor, patch)
+
+    @staticmethod
+    def is_semantic_version(version_string):
+        valid_semantic_string_regex = r"(?i)^v?[0-9]+[.-][0-9]+[.-][0-9]+$"
+        return re.match(valid_semantic_string_regex, version_string)

dbt_platform_helper/providers/slack_channel_notifier.py

@@ -0,0 +1,62 @@
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+from slack_sdk.models import blocks
+
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class SlackChannelNotifierException(PlatformException):
+    pass
+
+
+class SlackChannelNotifier:
+    def __init__(self, slack_token: str, slack_channel_id: str):
+        self.client = WebClient(slack_token)
+        self.slack_channel_id = slack_channel_id
+
+    def post_update(self, message_ref, message, context=None):
+        args = {
+            "channel": self.slack_channel_id,
+            "blocks": self._build_message_blocks(message, context),
+            "text": message,
+            "unfurl_links": False,
+            "unfurl_media": False,
+        }
+
+        try:
+            response = self.client.chat_update(ts=message_ref, **args)
+            return response["ts"]
+        except SlackApiError as e:
+            raise SlackChannelNotifierException(f"Slack notification unsuccessful: {e}")
+
+    def post_new(self, message, context=None, title=None, reply_broadcast=None, thread_ref=None):
+        args = {
+            "channel": self.slack_channel_id,
+            "blocks": self._build_message_blocks(message, context),
+            "text": title if title else message,
+            "reply_broadcast": reply_broadcast,
+            "unfurl_links": False,
+            "unfurl_media": False,
+            "thread_ts": thread_ref,
+        }
+
+        try:
+            response = self.client.chat_postMessage(ts=None, **args)
+            return response["ts"]
+        except SlackApiError as e:
+            raise SlackChannelNotifierException(f"Slack notification unsuccessful: {e}")
+
+    def _build_message_blocks(self, message, context):
+        message_blocks = [
+            blocks.SectionBlock(
+                text=blocks.TextObject(type="mrkdwn", text=message),
+            ),
+        ]
+
+        if context:
+            message_blocks.append(
+                blocks.ContextBlock(
+                    elements=[blocks.TextObject(type="mrkdwn", text=element) for element in context]
+                )
+            )
+        return message_blocks

dbt_platform_helper/providers/terraform_manifest.py

@@ -20,7 +20,7 @@ class TerraformManifestProvider:
     def generate_codebase_pipeline_config(
         self,
         platform_config: dict,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
         ecr_imports: dict[str, str],
         deploy_repository: str,
     ):
@@ -32,9 +32,7 @@ class TerraformManifestProvider:
         self._add_codebase_pipeline_locals(terraform)
         self._add_provider(terraform, default_account)
         self._add_backend(terraform, platform_config, default_account, state_key_suffix)
-        self._add_codebase_pipeline_module(
-            terraform, terraform_platform_modules_version, deploy_repository
-        )
+        self._add_codebase_pipeline_module(terraform, platform_helper_version, deploy_repository)
         self._add_imports(terraform, ecr_imports)
         self._write_terraform_json(terraform, "terraform/codebase-pipelines")
 
@@ -42,7 +40,7 @@ class TerraformManifestProvider:
         self,
         platform_config: dict,
         env: str,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
     ):
         platform_config = ConfigProvider.apply_environment_defaults(platform_config)
         account = self._get_account_for_env(env, platform_config)
@@ -55,7 +53,7 @@ class TerraformManifestProvider:
         self._add_header(terraform)
         self._add_environment_locals(terraform, application_name)
         self._add_backend(terraform, platform_config, account, state_key_suffix)
-        self._add_extensions_module(terraform, terraform_platform_modules_version, env)
+        self._add_extensions_module(terraform, platform_helper_version, env)
         self._add_moved(terraform, platform_config)
         self._ensure_no_hcl_manifest_file(env_dir)
         self._write_terraform_json(terraform, env_dir)
@@ -117,9 +115,9 @@ class TerraformManifestProvider:
 
     @staticmethod
     def _add_codebase_pipeline_module(
-        terraform: dict, terraform_platform_modules_version: str, deploy_repository: str
+        terraform: dict, platform_helper_version: str, deploy_repository: str
     ):
-        source = f"git::https://github.com/uktrade/terraform-platform-modules.git//codebase-pipelines?depth=1&ref={terraform_platform_modules_version}"
+        source = f"git::https://github.com/uktrade/platform-tools.git//terraform/codebase-pipelines?depth=1&ref={platform_helper_version}"
         terraform["module"] = {
             "codebase-pipelines": {
                 "source": source,
@@ -139,8 +137,8 @@ class TerraformManifestProvider:
         }
 
     @staticmethod
-    def _add_extensions_module(terraform: dict, terraform_platform_modules_version: str, env: str):
-        source = f"git::https://github.com/uktrade/terraform-platform-modules.git//extensions?depth=1&ref={terraform_platform_modules_version}"
+    def _add_extensions_module(terraform: dict, platform_helper_version: str, env: str):
+        source = f"git::https://github.com/uktrade/platform-tools.git//terraform/extensions?depth=1&ref={platform_helper_version}"
         terraform["module"] = {
             "extensions": {"source": source, "args": "${local.args}", "environment": env}
         }

dbt_platform_helper/providers/version.py

@@ -4,19 +4,15 @@ from abc import ABC
 from abc import abstractmethod
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
-from pathlib import Path
 from typing import Union
 
 from requests import Session
 from requests.adapters import HTTPAdapter
 from urllib3.util import Retry
 
-from dbt_platform_helper.constants import PLATFORM_HELPER_VERSION_FILE
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.semantic_version import SemanticVersion
-from dbt_platform_helper.providers.yaml_file import FileProviderException
-from dbt_platform_helper.providers.yaml_file import YamlFileProvider
 
 
 def set_up_retry():
@@ -49,6 +45,7 @@ class InstalledVersionProvider:
     def get_semantic_version(tool_name: str) -> SemanticVersion:
         try:
             return SemanticVersion.from_string(version(tool_name))
+
         except PackageNotFoundError:
             raise InstalledToolNotFoundException(tool_name)
 
@@ -95,20 +92,6 @@ class PyPiLatestVersionProvider(VersionProvider):
         return semantic_version
 
 
-class DeprecatedVersionFileVersionProvider(VersionProvider):
-    def __init__(self, file_provider: YamlFileProvider):
-        self.file_provider = file_provider or YamlFileProvider
-
-    def get_semantic_version(self) -> Union[SemanticVersion, None]:
-        deprecated_version_file = Path(PLATFORM_HELPER_VERSION_FILE)
-        try:
-            loaded_version = self.file_provider.load(deprecated_version_file)
-            version_from_file = SemanticVersion.from_string(loaded_version)
-        except FileProviderException:
-            version_from_file = None
-        return version_from_file
-
-
 class AWSCLIInstalledVersionProvider(VersionProvider):
     @staticmethod
     def get_semantic_version() -> Union[SemanticVersion, None]: