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

atlas_init/__init__.py

@@ -1,9 +1,8 @@
 from pathlib import Path
 
-VERSION = "0.4.3"
+VERSION = "0.4.4"
 
 
 def running_in_repo() -> bool:
-    maybe_git_directory = Path(__file__).parent.parent / ".git"
-    git_config = maybe_git_directory / "config"
+    git_config = Path(__file__).parent.parent / ".git/config"
     return git_config.exists() and "atlas-init" in git_config.read_text()

atlas_init/cli.py

@@ -45,6 +45,7 @@ from atlas_init.settings.env_vars import (
     active_suites,
     init_settings,
 )
+from atlas_init.settings.env_vars_generated import AWSSettings, AtlasSettings
 from atlas_init.settings.path import (
     CwdIsNoRepoPathError,
     dump_vscode_dotenv,
@@ -79,7 +80,7 @@ def apply(context: typer.Context, *, skip_outputs: bool = False):
 
 
 def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool) -> list[TestSuite]:  # type: ignore
-    settings = init_settings()
+    settings = init_settings(AtlasSettings, AWSSettings)
     logger.info(f"using the '{command}' command, extra args: {extra_args}")
     try:
         suites = active_suites(settings)

atlas_init/cli_cfn/app.py

@@ -14,9 +14,6 @@ from atlas_init.cli_cfn.aws import (
 from atlas_init.cli_cfn.aws import (
     delete_stack as delete_stack_aws,
 )
-from atlas_init.cli_cfn.cfn_parameter_finder import (
-    read_execution_role,
-)
 from atlas_init.cli_cfn.contract import contract_test_cmd
 from atlas_init.cli_cfn.example import example_cmd
 from atlas_init.cli_cfn.files import (
@@ -31,6 +28,7 @@ from atlas_init.repos.cfn import (
 )
 from atlas_init.repos.path import Repo, current_dir, find_paths, resource_root
 from atlas_init.settings.env_vars import active_suites, init_settings
+from atlas_init.settings.env_vars_modules import TFModuleCfn
 
 app = typer.Typer(no_args_is_help=True)
 app.command(name="example")(example_cmd)
@@ -55,8 +53,8 @@ def reg(
         if local:
             deregister_cfn_resource_type(type_name, deregister=not dry_run, region_filter=region)
     logger.info(f"ready to activate {type_name}")
-    settings = init_settings()
-    cfn_execution_role = read_execution_role(settings.load_env_vars_full())
+    settings = init_settings(TFModuleCfn)
+    cfn_execution_role = settings.env_vars_cls(TFModuleCfn).CFN_EXAMPLE_EXECUTION_ROLE
     last_third_party = get_last_cfn_type(type_name, region, is_third_party=True)
     assert last_third_party, f"no 3rd party extension found for {type_name} in {region}"
     if dry_run:

atlas_init/cli_cfn/cfn_parameter_finder.py

@@ -2,46 +2,19 @@ import logging
 from pathlib import Path
 from typing import Any
 
-from model_lib import Entity, dump, parse_model, parse_payload
+from model_lib import Entity, dump, parse_model
 from mypy_boto3_cloudformation.type_defs import ParameterTypeDef
 from pydantic import ConfigDict, Field
 from rich import prompt
-from zero_3rdparty.dict_nested import read_nested
 from zero_3rdparty.file_utils import clean_dir
 
 from atlas_init.cli_cfn.files import create_sample_file, default_log_group_name
 from atlas_init.cloud.aws import PascalAlias
 from atlas_init.repos.cfn import CfnType, cfn_examples_dir, cfn_type_normalized
-from atlas_init.settings.path import DEFAULT_TF_PATH
 
 logger = logging.getLogger(__name__)
 
 
-def read_execution_role(loaded_env_vars: dict[str, str]) -> str:
-    return loaded_env_vars["CFN_EXAMPLE_EXECUTION_ROLE"]
-
-
-def check_execution_role(repo_path: Path, loaded_env_vars: dict[str, str]) -> str:
-    execution_role = cfn_examples_dir(repo_path) / "execution-role.yaml"
-    execution_raw = parse_payload(execution_role)
-    actions_expected = read_nested(
-        execution_raw,
-        "Resources.ExecutionRole.Properties.Policies.[0].PolicyDocument.Statement.[0].Action",
-    )
-    actions_found = parse_payload(DEFAULT_TF_PATH / "modules/cfn/resource_actions.yaml")
-    if diff := set(actions_expected) ^ set(actions_found):
-        raise ValueError(f"non-matching execution role actions: {sorted(diff)}")
-    services_found = parse_payload(DEFAULT_TF_PATH / "modules/cfn/assume_role_services.yaml")
-    services_expected = read_nested(
-        execution_raw,
-        "Resources.ExecutionRole.Properties.AssumeRolePolicyDocument.Statement.[0].Principal.Service",
-    )
-    if diff := set(services_found) ^ set(services_expected):
-        raise ValueError(f"non-matching execution role services: {sorted(diff)}")
-    logger.info(f"execution role is up to date with {execution_role}")
-    return read_execution_role(loaded_env_vars)
-
-
 class TemplatePathNotFoundError(Exception):
     def __init__(self, type_name: str, examples_dir: Path) -> None:
         self.type_name = type_name

atlas_init/cli_cfn/contract.py

@@ -16,6 +16,7 @@ from atlas_init.cli_helper.run_manager import RunManager
 from atlas_init.cli_root import is_dry_run
 from atlas_init.repos.path import Repo, ResourcePaths, find_paths
 from atlas_init.settings.env_vars import AtlasInitSettings, init_settings
+from atlas_init.settings.env_vars_generated import AWSSettings
 
 logger = logging.getLogger(__name__)
 
@@ -111,7 +112,7 @@ def contract_test(
     resource_paths: ResourcePaths | None = None,
     only_names: list[str] | None = None,
 ):
-    settings = settings or init_settings()
+    settings = settings or init_settings(AWSSettings)
     resource_paths = resource_paths or find_paths(Repo.CFN)
     resource_name = resource_paths.resource_name
     generated_env_vars = settings.load_env_vars_full()
@@ -122,11 +123,12 @@ def contract_test(
     )
     create_response = create_contract_test_inputs(create_inputs)
     create_response.log_input_files(logger)
+    aws_settings = AWSSettings.from_env()
     run_contract_test = RunContractTest(
         resource_path=resource_paths.resource_path,
         repo_path=resource_paths.repo_path,
-        aws_profile=settings.AWS_PROFILE,
-        cfn_region=settings.cfn_region,
+        aws_profile=aws_settings.AWS_PROFILE,
+        cfn_region=settings.cfn_region(aws_settings.AWS_REGION),
         only_names=only_names,
     )
     if run_contract_test.skip_build:

atlas_init/cli_cfn/example.py

@@ -15,7 +15,6 @@ from atlas_init.cli_cfn.aws import (
 from atlas_init.cli_cfn.aws import delete_stack as delete_stack_aws
 from atlas_init.cli_cfn.cfn_parameter_finder import (
     CfnTemplate,
-    check_execution_role,
     decode_parameters,
     dump_resource_to_file,
     dump_sample_file,
@@ -24,6 +23,8 @@ from atlas_init.cli_cfn.cfn_parameter_finder import (
 from atlas_init.repos.cfn import CfnType, Operation, infer_cfn_type_name
 from atlas_init.repos.path import Repo, find_paths
 from atlas_init.settings.env_vars import AtlasInitSettings, init_settings
+from atlas_init.settings.env_vars_generated import AWSSettings
+from atlas_init.settings.env_vars_modules import TFModuleCfn
 
 logger = logging.getLogger(__name__)
 
@@ -99,23 +100,24 @@ def example_cmd(
     ),
     register_all_types_in_example: bool = typer.Option(False, "--reg-all", help="Check all types"),
 ):
-    settings = init_settings()
+    settings = init_settings(TFModuleCfn, AWSSettings)
+    cfn_settings = TFModuleCfn.from_env()
+    aws_settings = AWSSettings.from_env()
     assert settings.tf_vars, "no cfn config found, re-run atlas_init apply with CFN flags"
     repo_path, resource_path, _ = find_paths(Repo.CFN)
-    env_vars_generated = settings.load_env_vars_full()
     inputs = CfnExampleInputs(
         type_name=type_name or infer_cfn_type_name(),
         example_name=example_name,
         delete_stack_first=delete_first,
-        region_filter=region or settings.cfn_region,
-        stack_name=stack_name or f"{settings.cfn_profile}-{example_name or 'atlas-init'}",
+        region_filter=region or settings.cfn_region(aws_settings.AWS_REGION),
+        stack_name=stack_name or f"{cfn_settings.MONGODB_ATLAS_PROFILE}-{example_name or 'atlas-init'}",
         operation=operation,  # type: ignore
         resource_params=resource_params,  # type: ignore
         stack_timeout_s=stack_timeout_s,
         force_deregister=force_deregister,
         reg_version=reg_version,
         force_keep=force_keep,
-        execution_role=execution_role or check_execution_role(repo_path, env_vars_generated),
+        execution_role=execution_role or cfn_settings.CFN_EXAMPLE_EXECUTION_ROLE,
         export_example_to_inputs=export_example_to_inputs,
         export_example_to_samples=export_example_to_samples,
         register_all_types_in_example=register_all_types_in_example,

atlas_init/cli_helper/go.py

@@ -16,7 +16,7 @@ from atlas_init.cli_tf.go_test_run import (
 )
 from atlas_init.settings.config import TestSuite
 from atlas_init.settings.env_vars import AtlasInitSettings
-from atlas_init.settings.path import DEFAULT_DOWNLOADS_DIR
+from atlas_init.settings.path import load_dotenv
 
 logger = logging.getLogger(__name__)
 
@@ -51,6 +51,7 @@ def env_vars_for_capture(mode: GoTestCaptureMode) -> dict[str, str]:
 
 
 class GoTestResult(Entity):
+    logs_dir: Path
     runs: dict[str, list[GoTestRun]] = Field(default_factory=dict)
     failure_names: set[str] = Field(default_factory=set)
 
@@ -66,7 +67,7 @@ class GoTestResult(Entity):
         if prev_test_results:
             logger.warning(f"2nd time test results for {test_name}")
         for result in test_results:
-            log_path = _log_path(test_name)
+            log_path = _log_path(self.logs_dir, test_name)
             result.log_path = log_path
         prev_test_results.extend(test_results)
         return all(run.is_pass for run in test_results)
@@ -95,7 +96,8 @@ def run_go_tests(
     )
     if ci_value := test_env.pop("CI", None):
         logger.warning(f"popped CI={ci_value}")
-    results = GoTestResult()
+    logs_dir = settings.go_test_logs_dir
+    results = GoTestResult(logs_dir=logs_dir)
     commands_to_run: dict[str, str] = {}
     for group in groups:
         if group.sequential_tests:
@@ -118,6 +120,7 @@ def run_go_tests(
     return _run_tests(
         results,
         repo_path,
+        logs_dir,
         commands_to_run,
         test_env,
         test_timeout_s=timeout_minutes * 60,
@@ -170,7 +173,7 @@ def resolve_env_vars(
     if env_vars == GoEnvVars.manual:
         test_env_vars = settings.load_profile_manual_env_vars(skip_os_update=True)
     elif env_vars == GoEnvVars.vscode:
-        test_env_vars = settings.load_env_vars(settings.env_vars_vs_code)
+        test_env_vars = load_dotenv(settings.env_vars_vs_code)
     else:
         raise NotImplementedError(f"don't know how to load env_vars={env_vars}")
     test_env_vars |= {
@@ -188,6 +191,7 @@ def resolve_env_vars(
 def _run_tests(
     results: GoTestResult,
     repo_path: Path,
+    logs_dir: Path,
     commands_to_run: dict[str, str],
     test_env: dict[str, str],
     test_timeout_s: int = 301 * 60,
@@ -199,11 +203,11 @@ def _run_tests(
     actual_workers = min(max_workers, len(commands_to_run)) or 1
     with ThreadPoolExecutor(max_workers=actual_workers) as pool:
         for name, command in sorted(commands_to_run.items()):
-            log_path = _log_path(name)
+            log_path = _log_path(logs_dir, name)
             if log_path.exists() and log_path.read_text():
                 if re_run:
                     logger.info(f"moving existing logs of {name} to old dir")
-                    move_logs_to_dir({name}, dir_name="old")
+                    move_logs_to_dir(logs_dir, {name}, dir_name="old")
                 else:
                     logger.info(f"skipping {name} because log exists")
                     continue
@@ -229,7 +233,7 @@ def _run_tests(
             continue
         context = GoTestContext(
             name=name,
-            html_url=f"file://{_log_path(name)}",
+            html_url=f"file://{_log_path(logs_dir, name)}",
             steps=[GoTestContextStep(name="local-run")],
         )
         try:
@@ -250,14 +254,14 @@ def _run_tests(
         if not results.add_test_results_all_pass(name, parsed_tests):
             results.failure_names.add(name)
     if failure_names := results.failure_names:
-        move_logs_to_dir(failure_names)
+        move_logs_to_dir(logs_dir, failure_names)
         logger.error(f"failed to run tests: {sorted(failure_names)}")
     return results
 
 
-def move_logs_to_dir(names: set[str], dir_name: str = "failures"):
-    new_dir = DEFAULT_DOWNLOADS_DIR / dir_name
-    for log in DEFAULT_DOWNLOADS_DIR.glob("*.log"):
+def move_logs_to_dir(logs_dir: Path, names: set[str], dir_name: str = "failures"):
+    new_dir = logs_dir / dir_name
+    for log in logs_dir.glob("*.log"):
         if log.stem in names:
             text = log.read_text()
             assert "\n" in text
@@ -266,5 +270,5 @@ def move_logs_to_dir(names: set[str], dir_name: str = "failures"):
             log.rename(new_dir / f"{ts}.{log.name}")
 
 
-def _log_path(name: str) -> Path:
-    return DEFAULT_DOWNLOADS_DIR / f"{name}.log"
+def _log_path(logs_dir: Path, name: str) -> Path:
+    return logs_dir / f"{name}.log"

atlas_init/cli_helper/tf_runner.py

@@ -13,6 +13,7 @@ from atlas_init.cli_helper.run import (
 )
 from atlas_init.settings.config import TerraformVars, TestSuite
 from atlas_init.settings.env_vars import AtlasInitSettings
+from atlas_init.settings.env_vars_generated import AWSSettings, AtlasSettings
 
 logger = logging.getLogger(__name__)
 
@@ -20,17 +21,19 @@ logger = logging.getLogger(__name__)
 def get_tf_vars(settings: AtlasInitSettings, active_groups: list[TestSuite]) -> dict[str, Any]:  # type: ignore
     tf_vars = TerraformVars()  # type: ignore
     tf_vars = sum((group.vars for group in active_groups), start=tf_vars)
+    aws_settings = AWSSettings.from_env()
+    atlas_settings = AtlasSettings.from_env()
     return {
-        "atlas_public_key": settings.MONGODB_ATLAS_PUBLIC_KEY,
-        "atlas_private_key": settings.MONGODB_ATLAS_PRIVATE_KEY,
-        "atlas_base_url": settings.MONGODB_ATLAS_BASE_URL,
-        "is_mongodbgov_cloud": settings.is_mongodbgov_cloud,
-        "org_id": settings.MONGODB_ATLAS_ORG_ID,
-        "aws_region": settings.AWS_REGION,
+        "atlas_public_key": atlas_settings.MONGODB_ATLAS_PUBLIC_KEY,
+        "atlas_private_key": atlas_settings.MONGODB_ATLAS_PRIVATE_KEY,
+        "atlas_base_url": atlas_settings.MONGODB_ATLAS_BASE_URL,
+        "is_mongodbgov_cloud": atlas_settings.is_mongodbgov_cloud,
+        "org_id": atlas_settings.MONGODB_ATLAS_ORG_ID,
+        "aws_region": aws_settings.AWS_REGION,
         "project_name": settings.project_name,
         "out_dir": settings.profile_dir,
         "extra_env_vars": settings.manual_env_vars,
-        **settings.tf_vars(),
+        **settings.tf_vars(aws_settings.AWS_REGION),
         **tf_vars.as_configs(),
     }
 
@@ -56,7 +59,7 @@ class state_copier:  # noqa: N801
 
 
 def run_terraform(settings: AtlasInitSettings, command: str, extra_args: list[str]):
-    with state_copier(settings.tf_state_path, settings.tf_path):
+    with state_copier(settings.tf_state_path, settings.atlas_init_tf_src_path):
         _run_terraform(settings, command, extra_args)
 
 
@@ -71,7 +74,7 @@ def _run_terraform(settings: AtlasInitSettings, command: str, extra_args: list[s
         "terraform",
         " ".join(command_parts),
         env=os.environ | {"TF_DATA_DIR": settings.tf_data_dir},
-        cwd=settings.tf_path,
+        cwd=settings.atlas_init_tf_src_path,
         logger=logger,
     )
     if not is_ok:
@@ -88,10 +91,10 @@ def dump_tf_vars(settings: AtlasInitSettings, tf_vars: dict[str, Any]):
 
 
 def export_outputs(settings: AtlasInitSettings) -> None:
-    with state_copier(settings.tf_state_path, settings.tf_path):
+    with state_copier(settings.tf_state_path, settings.atlas_init_tf_src_path):
         result = run_command_receive_result(
             "terraform output -json",
-            settings.tf_path,
+            settings.atlas_init_tf_src_path,
             logger,
             env=os.environ | {"TF_DATA_DIR": settings.tf_data_dir},
         )

atlas_init/cli_root/trigger.py

@@ -6,10 +6,11 @@ from zero_3rdparty.id_creator import simple_id
 
 from atlas_init.settings.env_vars import init_settings
 from atlas_init.settings.env_vars_generated import (
-    EnvVarsGenerated,
+    AtlasSettingsWithProject,
+    AWSSettings,
     RealmSettings,
-    TFModuleCluster,
 )
+from atlas_init.settings.env_vars_modules import TFModuleCluster
 from atlas_init.settings.path import dump_dotenv
 from atlas_init.typer_app import app_command
 
@@ -23,11 +24,14 @@ def trigger_app():
 
 def create_realm_app():
     settings = init_settings()
-    base_url = settings.realm_url
-    project_id = settings.env_vars_cls(EnvVarsGenerated).MONGODB_ATLAS_PROJECT_ID
-    cluster_name = settings.env_vars_cls(TFModuleCluster).MONGODB_ATLAS_CLUSTER_NAME
+    atlas_settings = settings.env_vars_cls(AtlasSettingsWithProject)
+    cluster_settings = settings.env_vars_cls(TFModuleCluster)
+    project_id = atlas_settings.MONGODB_ATLAS_PROJECT_ID
+    base_url = atlas_settings.realm_url
+    cluster_name = cluster_settings.MONGODB_ATLAS_CLUSTER_NAME
     auth_headers = login_to_realm(settings, base_url)
     realm_settings = settings.env_vars_cls_or_none(RealmSettings, path=settings.env_vars_trigger)
+    aws_settings = settings.env_vars_cls(AWSSettings)
     if realm_settings and function_exists(
         base_url,
         auth_headers,
@@ -44,7 +48,7 @@ def create_realm_app():
         app_id = apps[0]["_id"]
     else:
         logger.info("no apps found, creating one")
-        app = create_app(base_url, auth_headers, project_id, cluster_name, settings.AWS_REGION)
+        app = create_app(base_url, auth_headers, project_id, cluster_name, aws_settings.AWS_REGION)
         logger.info(f"created app: {app}")
         app_id = app["_id"]
     logger.info(f"using app_id: {app_id}")
@@ -109,7 +113,11 @@ _cloud_deployment_regions = {
 
 
 def create_app(
-    base_url: str, auth_headers: dict[str, str], project_id: str, cluster_name: str, aws_region: str
+    base_url: str,
+    auth_headers: dict[str, str],
+    project_id: str,
+    cluster_name: str,
+    aws_region: str,
 ) -> dict:
     provider_region = f"aws-{aws_region}"
     location = _cloud_deployment_regions.get(provider_region)
@@ -229,7 +237,12 @@ class _RetryPostRequestError(Exception):
     reraise=True,
 )
 def _request_post_call(
-    url: str, data: dict, headers: dict[str, str], timeout: int, *, log_data_on_failure: bool = False
+    url: str,
+    data: dict,
+    headers: dict[str, str],
+    timeout: int,
+    *,
+    log_data_on_failure: bool = False,
 ) -> dict:
     response = requests.post(url, json=data, headers=headers, timeout=timeout)
     if response.status_code >= 500:  # noqa: PLR2004

atlas_init/cli_tf/app.py

@@ -63,7 +63,7 @@ def schema(
     schema_out_path = settings.schema_out_path_computed
     schema_out_path.mkdir(exist_ok=True)
 
-    schema_parsed = parse_py_terraform_schema(settings.tf_schema_config_path)
+    schema_parsed = parse_py_terraform_schema(settings.atlas_init_tf_schema_config_path)
     generator_config = dump_generator_config(schema_parsed)
     generator_config_path = schema_out_path / "generator_config.yaml"
     generator_config_path.write_text(generator_config)

atlas_init/cli_tf/github_logs.py

@@ -20,17 +20,13 @@ from atlas_init.cli_tf.go_test_run import GoTestRun, parse
 from atlas_init.repos.path import (
     GH_OWNER_TERRAFORM_PROVIDER_MONGODBATLAS,
 )
-from atlas_init.settings.path import (
-    DEFAULT_GITHUB_CI_RUN_LOGS,
-    DEFAULT_GITHUB_SUMMARY_DIR,
-)
+from atlas_init.settings.env_vars import init_settings
 
 logger = logging.getLogger(__name__)
 
 GH_TOKEN_ENV_NAME = "GH_TOKEN"  # noqa: S105 #nosec
-GITHUB_CI_RUN_LOGS_ENV_NAME = "GITHUB_CI_RUN_LOGS"
 GITHUB_CI_SUMMARY_DIR_ENV_NAME = "GITHUB_CI_SUMMARY_DIR_ENV_NAME"
-REQUIRED_GH_ENV_VARS = [GH_TOKEN_ENV_NAME, GITHUB_CI_RUN_LOGS_ENV_NAME]
+REQUIRED_GH_ENV_VARS = [GH_TOKEN_ENV_NAME]
 MAX_DOWNLOADS = 5
 
 
@@ -154,19 +150,11 @@ def download_job_safely(workflow_dir: Path, job: WorkflowJob) -> Path | None:
 
 
 def logs_dir() -> Path:
-    logs_dir_str = os.environ.get(GITHUB_CI_RUN_LOGS_ENV_NAME)
-    if not logs_dir_str:
-        logger.info(f"using {DEFAULT_GITHUB_CI_RUN_LOGS} to store github ci logs!")
-        return DEFAULT_GITHUB_CI_RUN_LOGS
-    return Path(logs_dir_str)
+    return init_settings().github_ci_run_logs
 
 
 def summary_dir(summary_name: str) -> Path:
-    summary_dir_str = os.environ.get(GITHUB_CI_SUMMARY_DIR_ENV_NAME)
-    if not summary_dir_str:
-        logger.info(f"using {DEFAULT_GITHUB_SUMMARY_DIR / summary_name} to store summaries")
-        return DEFAULT_GITHUB_SUMMARY_DIR / summary_name
-    return Path(summary_dir_str) / summary_name
+    return init_settings().github_ci_summary_dir / summary_name
 
 
 def workflow_logs_dir(workflow: WorkflowRun) -> Path:

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}"