atlas-init 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

atlas_init/cli_tf/hcl/modifier.py

@@ -2,6 +2,7 @@ import logging
 from collections import defaultdict
 from copy import deepcopy
 from pathlib import Path
+from typing import Callable
 
 import hcl2
 from lark import Token, Tree, UnexpectedToken
@@ -51,6 +52,8 @@ def update_description(tree: Tree, new_descriptions: dict[str, str], existing_na
 def token_name(token: Token | Tree) -> str:
     if isinstance(token, Token):
         return token.value.strip('"')
+    if isinstance(token, Tree) and token.data == "identifier":
+        return token.children[0].value.strip('"')  # type: ignore
     err_msg = f"unexpected token type {type(token)} for token name"
     raise ValueError(err_msg)
 
@@ -102,31 +105,46 @@ def create_description_attribute(description_value: str) -> Tree:
     return Tree(Token("RULE", "attribute"), children)
 
 
-def process_descriptions(
+def process_generic(
     node: Tree,
-    name_updates: dict[str, str],
-    existing_names: dict[str, list[str]],
+    tree_match: Callable[[Tree], bool],
+    tree_call: Callable[[Tree], Tree],
     depth=0,
-    *,
-    block_type: str,
-) -> Tree:
+):
     new_children = []
     logger.debug(f"[{depth}] (tree)\t|", " " * depth, node.data)
     for child in node.children:
         if isinstance(child, Tree):
-            if is_block_type(child, block_type):
-                child = update_description(  # noqa: PLW2901
-                    child, name_updates, existing_names
-                )
-            new_children.append(
-                process_descriptions(child, name_updates, existing_names, depth + 1, block_type=block_type)
-            )
+            if tree_match(child):
+                child = tree_call(child)
+            new_children.append(process_generic(child, tree_match, tree_call, depth + 1))
         else:
             new_children.append(process_token(child, depth + 1))
-
     return Tree(node.data, new_children)
 
 
+def process_descriptions(
+    node: Tree,
+    name_updates: dict[str, str],
+    existing_names: dict[str, list[str]],
+    depth=0,
+    *,
+    block_type: str,
+) -> Tree:
+    def tree_match(tree: Tree) -> bool:
+        return is_block_type(tree, block_type)
+
+    def tree_call(tree: Tree) -> Tree:
+        return update_description(tree, name_updates, existing_names)
+
+    return process_generic(
+        node,
+        tree_match,
+        tree_call,
+        depth=depth,
+    )
+
+
 def update_descriptions(tf_path: Path, new_names: dict[str, str], block_type: str) -> tuple[str, dict[str, list[str]]]:
     try:
         tree = hcl2.parses(tf_path.read_text())  # type: ignore
@@ -142,3 +160,86 @@ def update_descriptions(tf_path: Path, new_names: dict[str, str], block_type: st
     )
     new_tf = hcl2.writes(new_tree)  # type: ignore
     return new_tf, existing_descriptions
+
+
+def _block_name_body(tree: Tree) -> tuple[str, Tree]:
+    try:
+        _, name_token, body = tree.children
+        name = token_name(name_token)
+    except (IndexError, AttributeError) as e:
+        raise ValueError("unexpected block structure") from e
+    return name, body
+
+
+def _read_attribute(tree_body: Tree, attribute_name: str) -> Tree | None:
+    for attribute in tree_body.children:
+        if not isinstance(attribute, Tree):
+            continue
+        if attribute.data != "attribute":
+            continue
+        attr_identifier, _, attr_value = attribute.children
+        if token_name(attr_identifier.children[0]) != attribute_name:
+            continue
+        return attr_value
+
+
+def _is_object(tree_body: Tree) -> bool:
+    if not isinstance(tree_body, Tree):
+        return False
+    if len(tree_body.children) != 1:
+        return False
+    if not isinstance(tree_body.children[0], Tree):
+        return False
+    return tree_body.children[0].data == "object"
+
+
+def _read_object_elems(tree_body: Tree) -> list[Tree]:
+    object_elements = []
+    for obj_child in tree_body.children[0].children:
+        if not isinstance(obj_child, Tree):
+            continue
+        if obj_child.data != "object_elem":
+            continue
+        object_elements.append(obj_child)
+    return object_elements
+
+
+def _read_object_elem_key(tree_body: Tree) -> str:
+    name_tree, _, _ = tree_body.children
+    return token_name(name_tree.children[0])
+
+
+def read_block_attribute_object_keys(tf_path: Path, block_type: str, block_name: str, block_key: str) -> list[str]:
+    try:
+        tree = hcl2.parses(tf_path.read_text())  # type: ignore
+    except UnexpectedToken as e:
+        logger.warning(f"failed to parse {tf_path}: {e}")
+        return []
+    env_vars = []
+
+    def extract_env_vars(tree: Tree) -> bool:
+        if not is_block_type(tree, block_type):
+            return False
+        name, body = _block_name_body(tree)
+        if name != block_name:
+            return False
+        attribute_value = _read_attribute(body, block_key)
+        if not attribute_value:
+            return False
+        if not _is_object(attribute_value):
+            return False
+        object_elements = _read_object_elems(attribute_value)
+        for obj_elem in object_elements:
+            key = _read_object_elem_key(obj_elem)
+            env_vars.append(key)
+        return False
+
+    def tree_call(tree: Tree) -> Tree:
+        return tree
+
+    process_generic(
+        tree,
+        extract_env_vars,
+        tree_call,
+    )
+    return env_vars

atlas_init/cli_tf/mock_tf_log.py

@@ -33,7 +33,7 @@ from atlas_init.repos.go_sdk import (
     download_admin_api,
     parse_api_spec_paths,
 )
-from atlas_init.settings.path import DEFAULT_DOWNLOADS_DIR
+from atlas_init.settings.env_vars import init_settings
 
 logger = logging.getLogger(__name__)
 
@@ -164,7 +164,8 @@ def resolve_admin_api_path(sdk_repo_path_str: str, sdk_branch: str, admin_api_pa
         assert sdk_repo_path.exists(), f"not found sdk_repo_path={sdk_repo_path}"
         resolved_admin_api_path = api_spec_path_transformed(sdk_repo_path)
     else:
-        resolved_admin_api_path = DEFAULT_DOWNLOADS_DIR / "atlas-api-transformed.yaml"
+        settings = init_settings()
+        resolved_admin_api_path = settings.atlas_atlas_api_transformed_yaml
         if not is_cache_up_to_date(resolved_admin_api_path, 3600):
             download_admin_api(resolved_admin_api_path, sdk_branch)
     assert resolved_admin_api_path.exists(), f"unable to resolve admin_api_path={resolved_admin_api_path}"

atlas_init/cli_tf/schema_v3.py

@@ -210,12 +210,12 @@ class Schema(BaseModelLocal):
 
 
 class Resource(BaseModelLocal):
-    schema: Schema  # pyright: ignore
+    local_schema: Schema = Field(alias="schema")
     name: SnakeCaseString
 
     @property
     def use_timeout(self) -> bool:
-        return any(a.timeouts for a in self.schema.attributes)
+        return any(a.timeouts for a in self.local_schema.attributes)
 
 
 ResourceSchemaV3 = Resource

atlas_init/cli_tf/schema_v3_sdk_base.py

@@ -41,7 +41,7 @@ def schema_attributes(root: object) -> list[Attribute]:
 
 @schema_attributes.register
 def _resource_attributes(root: Resource) -> list[Attribute]:
-    return root.schema.attributes
+    return root.local_schema.attributes
 
 
 @schema_attributes.register

atlas_init/settings/env_vars.py

@@ -7,11 +7,10 @@ from functools import cached_property
 from pathlib import Path
 from typing import Any, NamedTuple, TypeVar
 
-from model_lib import parse_payload
-from pydantic import ValidationError, field_validator, model_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from model_lib import StaticSettings, parse_payload
+from pydantic import BaseModel, ValidationError, field_validator
+from zero_3rdparty import iter_utils
 
-from atlas_init.cloud.aws import AwsRegion
 from atlas_init.settings.config import (
     AtlasInitConfig,
     TestSuite,
@@ -19,12 +18,10 @@ from atlas_init.settings.config import (
 from atlas_init.settings.config import (
     active_suites as config_active_suites,
 )
-from atlas_init.settings.env_vars_generated import AtlasSettings
 from atlas_init.settings.path import (
-    DEFAULT_CONFIG_PATH,
-    DEFAULT_PROFILES_PATH,
-    DEFAULT_SCHEMA_CONFIG_PATH,
-    DEFAULT_TF_PATH,
+    DEFAULT_ATLAS_INIT_CONFIG_PATH,
+    DEFAULT_ATLAS_INIT_SCHEMA_CONFIG_PATH,
+    DEFAULT_TF_SRC_PATH,
     dump_dotenv,
     load_dotenv,
     repo_path_rel_path,
@@ -33,66 +30,59 @@ from atlas_init.settings.path import (
 logger = logging.getLogger(__name__)
 ENV_PREFIX = "ATLAS_INIT_"
 DEFAULT_PROFILE = "default"
+DEFAULT_PROJECT_NAME = "atlas-init"
 ENV_S3_PROFILE_BUCKET = f"{ENV_PREFIX}S3_PROFILE_BUCKET"
 ENV_PROJECT_NAME = f"{ENV_PREFIX}PROJECT_NAME"
 ENV_PROFILE = f"{ENV_PREFIX}PROFILE"
-ENV_PROFILES_PATH = f"{ENV_PREFIX}PROFILES_PATH"
 ENV_TEST_SUITES = f"{ENV_PREFIX}TEST_SUITES"
 ENV_CLIPBOARD_COPY = f"{ENV_PREFIX}CLIPBOARD_COPY"
-REQUIRED_FIELDS = [
-    "MONGODB_ATLAS_ORG_ID",
-    "MONGODB_ATLAS_PRIVATE_KEY",
-    "MONGODB_ATLAS_PUBLIC_KEY",
-]
 FILENAME_ENV_MANUAL = ".env-manual"
 T = TypeVar("T")
 
 
-class ExternalSettings(AtlasSettings):
-    model_config = SettingsConfigDict(env_prefix="", extra="ignore")
+def read_from_env(env_key: str, default: str = "") -> str:
+    return next(
+        (os.environ[name] for name in [env_key, env_key.lower(), env_key.upper()] if name in os.environ),
+        default,
+    )
 
-    TF_CLI_CONFIG_FILE: str = ""
-    AWS_PROFILE: str = ""
-    AWS_REGION: AwsRegion = "us-east-1"
-    non_interactive: bool = False
 
-    @property
-    def realm_url(self) -> str:
-        assert not self.is_mongodbgov_cloud, "realm_url is not supported for mongodbgov cloud"
-        if "cloud-dev." in self.MONGODB_ATLAS_BASE_URL:
-            return "https://services.cloud-dev.mongodb.com/"
-        return "https://services.cloud.mongodb.com/"
+class AtlasInitSettings(StaticSettings):
+    atlas_init_profile: str = DEFAULT_PROFILE  # override this for different env, e.g. dev, prod
+    atlas_init_project_name: str = DEFAULT_PROJECT_NAME  # used in the atlas cloud
+    atlas_init_config_path: Path = DEFAULT_ATLAS_INIT_CONFIG_PATH  # /atlas_init.yaml
+    atlas_init_tf_src_path: Path = DEFAULT_TF_SRC_PATH  # /tf directory of repo
+    atlas_init_tf_schema_config_path: Path = DEFAULT_ATLAS_INIT_SCHEMA_CONFIG_PATH  # /terraform.yaml
+    atlas_init_schema_out_path: Path | None = None  # override this for the generated schema
+
+    atlas_init_cfn_profile: str = ""
+    atlas_init_cfn_region: str = ""
+    atlas_init_cfn_use_kms_key: bool = False
+    atlas_init_cliboard_copy: str = ""
+    atlas_init_test_suites: str = ""
+    atlas_init_s3_profile_bucket: str = ""
+
+    non_interactive: bool = False
 
     @property
     def is_interactive(self) -> bool:
         return not self.non_interactive
 
     @property
-    def is_mongodbgov_cloud(self) -> bool:
-        return "mongodbgov" in self.MONGODB_ATLAS_BASE_URL
+    def profiles_path(self) -> Path:
+        return self.static_root / "profiles"
 
+    @property
+    def project_name(self) -> str:
+        return self.atlas_init_project_name
 
-def read_from_env(env_key: str, default: str = "") -> str:
-    for name in [env_key, env_key.lower(), env_key.upper()]:
-        if name in os.environ:
-            return os.environ[name]
-    return default
-
-
-class AtlasInitPaths(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix=ENV_PREFIX)
-
-    profile: str = DEFAULT_PROFILE
-    config_path: Path = DEFAULT_CONFIG_PATH
-    tf_path: Path = DEFAULT_TF_PATH
-    profiles_path: Path = DEFAULT_PROFILES_PATH
-    tf_schema_config_path: Path = DEFAULT_SCHEMA_CONFIG_PATH
-    schema_out_path: Path | None = None
-    s3_profile_bucket: str = ""
+    @property
+    def profile(self) -> str:
+        return self.atlas_init_profile
 
     @property
     def schema_out_path_computed(self) -> Path:
-        return self.schema_out_path or self.profile_dir / "schema"
+        return self.atlas_init_schema_out_path or self.static_root / "schema"
 
     @property
     def profile_dir(self) -> Path:
@@ -135,103 +125,42 @@ class AtlasInitPaths(BaseSettings):
     def tf_outputs_path(self) -> Path:
         return self.profile_dir / "tf_outputs.json"
 
-    def load_env_vars(self, path: Path) -> dict[str, str]:
-        return load_dotenv(path)
-
-    def load_env_vars_full(self) -> dict[str, str]:
-        env_path = self.env_vars_vs_code
-        assert env_path.exists(), f"no env-vars exist {env_path} have you forgotten apply?"
-        return load_dotenv(env_path)
-
-    def env_vars_cls_or_none(self, t: type[T], *, path: Path | None = None) -> T | None:
-        with suppress(ValidationError):
-            return self.env_vars_cls(t, path=path)
-
-    def env_vars_cls(self, t: type[T], *, path: Path | None = None) -> T:
-        path = path or self.env_vars_vs_code
-        env_vars = self.load_env_vars(path) if path.exists() else {}
-        return t(**env_vars)
-
-    def load_profile_manual_env_vars(self, *, skip_os_update: bool = False) -> dict[str, str]:
-        # sourcery skip: dict-assign-update-to-union
-        manual_env_vars = self.manual_env_vars
-        if manual_env_vars:
-            if skip_os_update:
-                return manual_env_vars
-            if new_updates := {k: v for k, v in manual_env_vars.items() if k not in os.environ}:
-                logger.info(f"loading manual env-vars {','.join(new_updates)}")
-                os.environ.update(new_updates)
-        else:
-            logger.warning(f"no {self.env_file_manual} exists")
-        return manual_env_vars
+    @property
+    def github_ci_run_logs(self) -> Path:
+        return self.cache_root / "github_ci_run_logs"
+
+    @property
+    def github_ci_summary_dir(self) -> Path:
+        return self.cache_root / "github_ci_summary"
+
+    @property
+    def go_test_logs_dir(self) -> Path:
+        return self.cache_root / "go_test_logs"
+
+    @property
+    def atlas_atlas_api_transformed_yaml(self) -> Path:
+        return self.cache_root / "atlas_api_transformed.yaml"
+
+    def cfn_region(self, default: str) -> str:
+        return self.atlas_init_cfn_region or default
 
     def include_extra_env_vars_in_vscode(self, extra_env_vars: dict[str, str]) -> None:
         extra_name = ", ".join(extra_env_vars.keys())
-        original_env_vars = self.load_env_vars(self.env_vars_vs_code)
+        original_env_vars = load_dotenv(self.env_vars_vs_code)
         new_env_vars = original_env_vars | extra_env_vars
         dump_dotenv(self.env_vars_vs_code, new_env_vars)
         logger.info(f"done {self.env_vars_vs_code} updated with {extra_name} env-vars ✅")
 
-
-class EnvVarsCheck(NamedTuple):
-    missing: list[str]
-    ambiguous: list[str]
-
-
-class AtlasInitSettings(AtlasInitPaths, ExternalSettings):
-    model_config = SettingsConfigDict(env_prefix=ENV_PREFIX)
-
-    cfn_profile: str = ""
-    cfn_region: str = ""
-    cfn_use_kms_key: bool = False
-    project_name: str = ""
-
-    cliboard_copy: str = ""
-    test_suites: str = ""
-
-    @classmethod
-    def check_env_vars(
-        cls,
-        profile: str = DEFAULT_PROFILE,
-        required_env_vars: list[str] | None = None,
-    ) -> EnvVarsCheck:
-        required_env_vars = required_env_vars or []
-        path_settings = AtlasInitPaths(profile=profile)
-        manual_env_vars = path_settings.manual_env_vars
-        ambiguous: list[str] = []
-        for env_name, manual_value in manual_env_vars.items():
-            env_value = read_from_env(env_name)
-            if env_value and manual_value != env_value:
-                ambiguous.append(env_name)
-        missing_env_vars = sorted(
-            env_name
-            for env_name in REQUIRED_FIELDS + required_env_vars
-            if read_from_env(env_name) == "" and env_name not in manual_env_vars
-        )
-        return EnvVarsCheck(missing=missing_env_vars, ambiguous=sorted(ambiguous))
-
-    @classmethod
-    def safe_settings(cls, profile: str, *, ext_settings: ExternalSettings | None = None) -> AtlasInitSettings:
-        """side effect of loading manual env-vars and set profile"""
-        os.environ[ENV_PROFILE] = profile
-        AtlasInitPaths(profile=profile).load_profile_manual_env_vars()
-        ext_settings = ext_settings or ExternalSettings()  # type: ignore
-        path_settings = AtlasInitPaths()
-        return cls(**path_settings.model_dump(), **ext_settings.model_dump())
-
-    @field_validator("test_suites", mode="after")
+    @field_validator(ENV_TEST_SUITES.lower(), mode="after")
     @classmethod
     def ensure_whitespace_replaced_with_commas(cls, value: str) -> str:
         return value.strip().replace(" ", ",")
 
-    @model_validator(mode="after")
-    def post_init(self):
-        self.cfn_region = self.cfn_region or self.AWS_REGION
-        return self
-
     @cached_property
     def config(self) -> AtlasInitConfig:
-        config_path = Path(self.config_path) if self.config_path else DEFAULT_CONFIG_PATH
+        config_path = (
+            Path(self.atlas_init_config_path) if self.atlas_init_config_path else DEFAULT_ATLAS_INIT_CONFIG_PATH
+        )
         assert config_path.exists(), f"no config path found @ {config_path}"
         yaml_parsed = parse_payload(config_path)
         assert isinstance(yaml_parsed, dict), f"config must be a dictionary, got {yaml_parsed}"
@@ -239,30 +168,35 @@ class AtlasInitSettings(AtlasInitPaths, ExternalSettings):
 
     @property
     def test_suites_parsed(self) -> list[str]:
-        return [t for t in self.test_suites.split(",") if t]
+        return [t for t in self.atlas_init_test_suites.split(",") if t]
 
-    def tf_vars(self) -> dict[str, Any]:
+    def tf_vars(self, default_aws_region: str) -> dict[str, Any]:
         variables = {}
-        if self.cfn_profile:
+        if self.atlas_init_cfn_profile:
             variables["cfn_config"] = {
-                "profile": self.cfn_profile,
-                "region": self.cfn_region,
-                "use_kms_key": self.cfn_use_kms_key,
+                "profile": self.atlas_init_cfn_profile,
+                "region": self.atlas_init_cfn_region or default_aws_region,
+                "use_kms_key": self.atlas_init_cfn_use_kms_key,
             }
-        if self.s3_profile_bucket:
+        if self.atlas_init_s3_profile_bucket:
             variables["use_aws_s3"] = True
         return variables
 
 
+class EnvVarsCheck(NamedTuple):
+    missing: list[str]
+    ambiguous: list[str]
+
+    @property
+    def is_ok(self) -> bool:
+        return not self.missing and not self.ambiguous
+
+
 def active_suites(settings: AtlasInitSettings) -> list[TestSuite]:  # type: ignore
     repo_path, cwd_rel_path = repo_path_rel_path()
     return config_active_suites(settings.config, repo_path, cwd_rel_path, settings.test_suites_parsed)
 
 
-_sentinel = object()
-PLACEHOLDER_VALUE = "PLACEHOLDER"
-
-
 class EnvVarsError(Exception):
     def __init__(self, missing: list[str], ambiguous: list[str]):
         self.missing = missing
@@ -273,31 +207,61 @@ class EnvVarsError(Exception):
         return f"missing: {self.missing}, ambiguous: {self.ambiguous}"
 
 
+def collect_required_env_vars(settings_classes: list[type[BaseModel]]) -> list[str]:
+    cls_required_env_vars: dict[str, list[str]] = {}
+    for cls in settings_classes:
+        try:
+            cls()
+        except ValidationError as error:
+            cls_required_env_vars[cls.__name__] = [".".join(str(loc) for loc in e["loc"]) for e in error.errors()]
+    return list(iter_utils.flat_map(cls_required_env_vars.values()))
+
+
+def detect_ambiguous_env_vars(manual_env_vars: dict[str, str]) -> list[str]:
+    ambiguous: list[str] = []
+    for env_name, manual_value in manual_env_vars.items():
+        env_value = read_from_env(env_name)
+        if env_value and manual_value != env_value:
+            ambiguous.append(env_name)
+    return ambiguous
+
+
+def find_missing_env_vars(required_env_vars: list[str], manual_env_vars: dict[str, str]) -> list[str]:
+    return sorted(
+        env_name for env_name in required_env_vars if read_from_env(env_name) == "" and env_name not in manual_env_vars
+    )
+
+
 def init_settings(
-    required_env_vars: list[str] | object = _sentinel,
-    *,
-    non_required: bool = False,
+    *settings_classes: type[BaseModel],
 ) -> AtlasInitSettings:
-    if required_env_vars is _sentinel:
-        required_env_vars = [ENV_PROJECT_NAME]
-    if non_required:
-        required_env_vars = []
-    profile = os.getenv("ATLAS_INIT_PROFILE", DEFAULT_PROFILE)
-    missing_env_vars, ambiguous_env_vars = AtlasInitSettings.check_env_vars(
-        profile,
-        required_env_vars=required_env_vars,  # type: ignore
-    )
-    if missing_env_vars and not non_required:
-        logger.warning(f"missing env_vars: {missing_env_vars}")
-    if ambiguous_env_vars:
+    settings = AtlasInitSettings.from_env()
+    profile_env_vars = settings.manual_env_vars
+    vscode_env_vars = settings.env_vars_vs_code
+    if vscode_env_vars.exists():
+        profile_env_vars |= load_dotenv(vscode_env_vars)
+    required_env_vars = collect_required_env_vars(list(settings_classes))
+    ambiguous = detect_ambiguous_env_vars(profile_env_vars)
+    missing_env_vars = find_missing_env_vars(required_env_vars, profile_env_vars)
+
+    if ambiguous:
         logger.warning(
-            f"amiguous env_vars: {ambiguous_env_vars} (specified both in cli/env & in .env-manual file with different values)"
+            f"ambiguous env_vars: {ambiguous} (specified both in cli/env & in .env-(manual|vscode) file with different values)"
         )
-    ext_settings = None
-    if non_required and missing_env_vars:
-        placeholders = {k: PLACEHOLDER_VALUE for k in missing_env_vars}
-        missing_env_vars = []
-        ext_settings = ExternalSettings(**placeholders)  # type: ignore
-    if missing_env_vars or ambiguous_env_vars:
-        raise EnvVarsError(missing_env_vars, ambiguous_env_vars)
-    return AtlasInitSettings.safe_settings(profile, ext_settings=ext_settings)
+    if missing_env_vars or ambiguous:
+        raise EnvVarsError(missing_env_vars, ambiguous)
+
+    if new_updates := {k: v for k, v in profile_env_vars.items() if k not in os.environ}:
+        logger.info(f"loading env-vars {','.join(sorted(new_updates))}")
+        os.environ |= new_updates
+    for cls in settings_classes:
+        cls()  # ensure any errors are raised
+    return AtlasInitSettings.from_env()
+
+
+def env_vars_cls_or_none(t: type[T], *, dotenv_path: Path | None = None) -> T | None:
+    explicit_vars: dict[str, str] = {}
+    if dotenv_path and dotenv_path.exists():
+        explicit_vars = load_dotenv(dotenv_path)
+    with suppress(ValidationError):
+        return t(**explicit_vars)

atlas_init/settings/env_vars_generated.py

@@ -1,18 +1,55 @@
 import random
+from typing import Self
 
-from pydantic import ConfigDict, Field
+from pydantic import ConfigDict, Field, model_validator
 from pydantic_settings import BaseSettings
 
 
 class _EnvVarsGenerated(BaseSettings):
     model_config = ConfigDict(extra="ignore")  # type: ignore
 
+    @classmethod
+    def from_env(cls) -> Self:
+        return cls()
+
 
 class AtlasSettings(_EnvVarsGenerated):
     MONGODB_ATLAS_ORG_ID: str
     MONGODB_ATLAS_PRIVATE_KEY: str
     MONGODB_ATLAS_PUBLIC_KEY: str
-    MONGODB_ATLAS_BASE_URL: str = "https://cloud-dev.mongodb.com/"
+    MONGODB_ATLAS_BASE_URL: str
+
+    @property
+    def realm_url(self) -> str:
+        assert not self.is_mongodbgov_cloud, "realm_url is not supported for mongodbgov cloud"
+        if "cloud-dev." in self.MONGODB_ATLAS_BASE_URL:
+            return "https://services.cloud-dev.mongodb.com/"
+        return "https://services.cloud.mongodb.com/"
+
+    @property
+    def is_mongodbgov_cloud(self) -> bool:
+        return "mongodbgov" in self.MONGODB_ATLAS_BASE_URL
+
+
+class AWSSettings(_EnvVarsGenerated):
+    AWS_REGION: str
+    AWS_PROFILE: str = ""
+    AWS_ACCESS_KEY_ID: str = ""
+    AWS_SECRET_ACCESS_KEY: str = ""
+
+    @model_validator(mode="after")
+    def ensure_credentials_are_given(self) -> Self:
+        assert self.AWS_PROFILE or (self.AWS_ACCESS_KEY_ID and self.AWS_SECRET_ACCESS_KEY), (
+            "Either AWS_PROFILE or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY must be provided"
+        )
+        assert not (self.AWS_PROFILE and (self.AWS_ACCESS_KEY_ID and self.AWS_SECRET_ACCESS_KEY)), (
+            "Either AWS_PROFILE or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY must be provided, not both"
+        )
+        return self
+
+
+class TerraformSettings(_EnvVarsGenerated):
+    TF_CLI_CONFIG_FILE: str
 
 
 class RealmSettings(_EnvVarsGenerated):
@@ -24,11 +61,5 @@ class RealmSettings(_EnvVarsGenerated):
     RANDOM_INT_100K: str = Field(default_factory=lambda: str(random.randint(0, 100_000)))  # noqa: S311 # not used for cryptographic purposes # nosec
 
 
-class EnvVarsGenerated(AtlasSettings):
+class AtlasSettingsWithProject(AtlasSettings):
     MONGODB_ATLAS_PROJECT_ID: str
-
-
-class TFModuleCluster(_EnvVarsGenerated):
-    MONGODB_ATLAS_CLUSTER_NAME: str
-    MONGODB_ATLAS_CONTAINER_ID: str
-    MONGODB_URL: str