atlas-init 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

atlas_init/cli_tf/hcl/modifier.py

@@ -1,8 +1,9 @@
+from __future__ import annotations
 import logging
 from collections import defaultdict
 from copy import deepcopy
 from pathlib import Path
-from typing import Callable
+from typing import Callable, Protocol
 
 import hcl2
 from lark import Token, Tree
@@ -40,14 +41,16 @@ def is_block_type(tree: Tree, block_type: str) -> bool:
         return False
 
 
-def update_description(tree: Tree, new_descriptions: dict[str, str], existing_names: dict[str, list[str]]) -> Tree:
+def update_description(
+    path: Path, tree: Tree, get_new_description: NewDescription, existing_names: dict[str, list[str]]
+) -> Tree:
     new_children = tree.children.copy()
     variable_body = new_children[2]
     assert variable_body.data == "body"
     name = token_name(new_children[1])
     old_description = read_description_attribute(variable_body)
     existing_names[name].append(old_description)
-    new_description = new_descriptions.get(name, "")
+    new_description = get_new_description(name, old_description, path)
     if not new_description:
         debug_log(f"no description found for variable {name}", 0)
         return tree
@@ -60,6 +63,8 @@ def token_name(token: Token | Tree) -> str:
         return token.value.strip('"')
     if isinstance(token, Tree) and token.data == "identifier":
         return token.children[0].value.strip('"')  # type: ignore
+    if isinstance(token, Tree) and isinstance(token.data, Token) and token.data.value == "heredoc_template_trim":
+        return token.children[0].value.strip('"')  # type: ignore
     err_msg = f"unexpected token type {type(token)} for token name"
     raise ValueError(err_msg)
 
@@ -103,10 +108,11 @@ def read_description_attribute(tree: Tree) -> str:
 
 
 def create_description_attribute(description_value: str) -> Tree:
+    token_value = f"<<-EOT\n{description_value}\nEOT\n" if "\n" in description_value else f'"{description_value}"'
     children = [
         Tree(Token("RULE", "identifier"), [Token("NAME", "description")]),
         Token("EQ", " ="),
-        Tree(Token("RULE", "expr_term"), [Token("STRING_LIT", f'"{description_value}"')]),
+        Tree(Token("RULE", "expr_term"), [Token("STRING_LIT", token_value)]),
     ]
     return Tree(Token("RULE", "attribute"), children)
 
@@ -129,9 +135,14 @@ def process_generic(
     return Tree(node.data, new_children)
 
 
+class NewDescription(Protocol):
+    def __call__(self, name: str, old_description: str, path: Path) -> str: ...
+
+
 def process_descriptions(
+    path: Path,
     node: Tree,
-    name_updates: dict[str, str],
+    new_description: NewDescription,
     existing_names: dict[str, list[str]],
     depth=0,
     *,
@@ -141,7 +152,7 @@ def process_descriptions(
         return is_block_type(tree, block_type)
 
     def tree_call(tree: Tree) -> Tree:
-        return update_description(tree, name_updates, existing_names)
+        return update_description(path, tree, new_description, existing_names)
 
     return process_generic(
         node,
@@ -151,14 +162,17 @@ def process_descriptions(
     )
 
 
-def update_descriptions(tf_path: Path, new_names: dict[str, str], block_type: str) -> tuple[str, dict[str, list[str]]]:
+def update_descriptions(
+    tf_path: Path, new_description: NewDescription, block_type: str
+) -> tuple[str, dict[str, list[str]]]:
     tree = safe_parse(tf_path)
     if tree is None:
         return "", {}
     existing_descriptions = defaultdict(list)
     new_tree = process_descriptions(
+        tf_path,
         tree,
-        new_names,
+        new_description,
         existing_descriptions,
         block_type=block_type,
     )

atlas_init/cli_tf/hcl/modifier2.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 import logging
 from contextlib import suppress
 from pathlib import Path
@@ -57,6 +58,110 @@ def attribute_transfomer(attr_name: str, obj_key: str, new_value: str) -> tuple[
     return AttributeTransformer(with_meta=True), changes
 
 
+def variable_reader(tree: Tree) -> dict[str, str | None]:
+    """
+    Reads the variable names from a parsed HCL2 tree.
+    Returns a variable_name -> description, None if no description is found.
+    """
+    variables: dict[str, str | None] = {}
+
+    class DescriptionReader(DictTransformer):
+        def __init__(self, with_meta: bool = False, *, name: str):
+            super().__init__(with_meta)
+            self.name = name
+            self.description: str | None = None
+
+        def attribute(self, args: list) -> Attribute:
+            name = args[0]
+            if name == "description":
+                description = _parse_attribute_value(args)
+                self.description = description
+            return super().attribute(args)
+
+    class BlockReader(Transformer):
+        @v_args(tree=True)
+        def block(self, block_tree: Tree) -> Tree:
+            current_block_name = _identifier_name(block_tree)
+            if current_block_name == "variable":
+                variable_name = token_name(block_tree.children[1])
+                reader = DescriptionReader(name=variable_name)
+                reader.transform(block_tree)
+                variables[variable_name] = reader.description
+            return block_tree
+
+    BlockReader().transform(tree)
+    return variables
+
+
+def _parse_attribute_value(args: list) -> str:
+    description = args[-1]
+    return token_name(description) if isinstance(description, Token) else description.strip('"')
+
+
+def resource_types_vars_usage(tree: Tree) -> dict[str, dict[str, str]]:
+    """
+    Reads the resource types and their variable usages from a parsed HCL2 tree.
+    Returns a dictionary where keys are resource type names and values are dictionaries
+    of variable names and the attribute paths they are used in.
+    """
+    resource_types: dict[str, dict[str, str]] = defaultdict(dict)
+
+    class ResourceBlockAttributeReader(DictTransformer):
+        def __init__(self, with_meta: bool = False, resource_type: str = ""):
+            self.resource_type = resource_type
+            resource_types.setdefault(self.resource_type, {})
+            super().__init__(with_meta)
+
+        def attribute(self, args: list) -> Attribute:
+            try:
+                value = _parse_attribute_value(args)
+            except AttributeError:
+                return super().attribute(args)
+            if value.startswith("var."):
+                variable_name = value[4:]
+                resource_types[self.resource_type][variable_name] = args[0]
+            return super().attribute(args)
+
+    class BlockReader(Transformer):
+        @v_args(tree=True)
+        def block(self, block_tree: Tree) -> Tree:
+            block_resource_name = _block_resource_name(block_tree)
+            if block_resource_name is not None:
+                ResourceBlockAttributeReader(with_meta=True, resource_type=block_resource_name).transform(block_tree)
+            return block_tree
+
+    BlockReader().transform(tree)
+    return resource_types
+
+
+def variable_usages(variable_names: set[str], tree: Tree) -> dict[str, set[str]]:
+    usages = defaultdict(set)
+    current_resource_type = None
+
+    class ResourceBlockAttributeReader(DictTransformer):
+        def attribute(self, args: list) -> Attribute:
+            attr_value = args[-1]
+            if isinstance(attr_value, str) and attr_value.startswith("var."):
+                variable_name = attr_value[4:]
+                if variable_name in variable_names:
+                    assert current_resource_type is not None, "current_resource_type should not be None"
+                    usages[variable_name].add(current_resource_type)
+            return super().attribute(args)
+
+    class BlockReader(Transformer):
+        @v_args(tree=True)
+        def block(self, block_tree: Tree) -> Tree:
+            block_resource_name = _block_resource_name(block_tree)
+            if block_resource_name is not None and block_resource_name.startswith("mongodbatlas_"):
+                nonlocal current_resource_type
+                current_resource_type = block_resource_name
+                ResourceBlockAttributeReader().transform(block_tree)
+            return block_tree
+
+    BlockReader().transform(tree)
+    return usages
+
+
 def _identifier_name(tree: Tree) -> str | None:
     with suppress(Exception):
         identifier_tree = tree.children[0]
@@ -67,6 +172,21 @@ def _identifier_name(tree: Tree) -> str | None:
             return name_token.value
 
 
+def _block_resource_name(tree: Tree) -> str | None:
+    block_name = _identifier_name(tree)
+    if block_name != "resource":
+        return None
+    token = tree.children[1]
+    return token_name(token)
+
+
+def token_name(token):
+    assert isinstance(token, Token)
+    token_value = token.value
+    assert isinstance(token_value, str)
+    return token_value.strip('"')
+
+
 def write_tree(tree: Tree) -> str:
     return writes(tree)
 

atlas_init/cli_tf/openapi.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import logging
 import re
 from collections.abc import Iterable
@@ -76,7 +77,7 @@ class OpenapiSchema(Entity):
     def create_method(self, path: str) -> dict | None:
         return self.paths.get(path, {}).get("post")
 
-    def read_method(self, path: str) -> dict | None:
+    def get_method(self, path: str) -> dict | None:
         return self.paths.get(path, {}).get("get")
 
     def delete_method(self, path: str) -> dict | None:
@@ -88,10 +89,13 @@ class OpenapiSchema(Entity):
     def put_method(self, path: str) -> dict | None:
         return self.paths.get(path, {}).get("patch")
 
-    def methods(self, path: str) -> Iterable[dict]:
+    def methods_with_name(self, path: str) -> Iterable[tuple[str, dict]]:
         for method_name in ["post", "get", "delete", "patch", "put"]:
             if method := self.paths.get(path, {}).get(method_name):
-                yield method
+                yield method_name, method
+
+    def methods(self, path: str) -> Iterable[dict]:
+        yield from (method for _, method in self.methods_with_name(path))
 
     def method_refs(self, path: str) -> Iterable[str]:
         for method in self.methods(path):
@@ -145,7 +149,7 @@ class OpenapiSchema(Entity):
             if ref := value.get("schema", {}).get("$ref"):
                 yield ref
 
-    def _unpack_schema_versions(self, response: dict) -> list[str]:
+    def _unpack_schema_versions(self, response: dict) -> list[datetime.date]:
         content: dict[str, dict] = {**response.get("content", {})}
         versions = []
         while content:
@@ -159,7 +163,7 @@ class OpenapiSchema(Entity):
                 versions.append(version)
         return versions
 
-    def path_method_api_versions(self) -> Iterable[tuple[PathMethodCode, list[str]]]:
+    def path_method_api_versions(self) -> Iterable[tuple[PathMethodCode, list[datetime.date]]]:
         for path, methods in self.paths.items():
             for method_name, method_dict in methods.items():
                 if not isinstance(method_dict, dict):
@@ -302,7 +306,7 @@ def add_api_spec_info(schema: SchemaV2, api_spec_path: Path, *, minimal_refs: bo
                 for property_dict in api_spec.schema_properties(req_ref):
                     parse_api_spec_param(api_spec, property_dict, resource)
         for path in resource.paths:
-            read_method = api_spec.read_method(path)
+            read_method = api_spec.get_method(path)
             if not read_method:
                 continue
             for param in read_method.get("parameters", []):

atlas_init/html_out/md_export.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+import logging
+from concurrent.futures import Future
+from contextlib import suppress
+from datetime import datetime
+from typing import ClassVar
+from ask_shell import ShellRun, confirm, kill, run, run_and_wait
+from ask_shell.models import ShellRunEventT, ShellRunStdOutput
+from zero_3rdparty import str_utils
+from zero_3rdparty.file_utils import copy, ensure_parents_write_text
+from zero_3rdparty.future import chain_future
+from atlas_init.settings.env_vars import AtlasInitSettings
+from pathlib import Path
+from model_lib import Event
+
+logger = logging.getLogger(__name__)
+
+
+class MonthlyReportPaths(Event):
+    summary_path: Path
+    error_only_path: Path
+    details_dir: Path
+    summary_name: str
+    daily_path: Path
+
+    ERROR_ONLY_SUFFIX: ClassVar[str] = "_error-only.md"
+    DAILY_SUFFIX: ClassVar[str] = "_daily.md"
+
+    def export_to_dir(self, out_dir: Path) -> None:
+        for path in [self.summary_path, self.error_only_path, self.daily_path]:
+            if path.exists():
+                ensure_parents_write_text(out_dir / path.name, path.read_text())
+        if self.details_dir.exists():
+            copy(self.details_dir, out_dir / self.details_dir.name, clean_dest=True)
+
+    @classmethod
+    def from_settings(cls, settings: AtlasInitSettings, summary_name: str) -> MonthlyReportPaths:
+        summary_path = settings.github_ci_summary_dir / str_utils.ensure_suffix(summary_name, ".md")
+        return cls(
+            summary_path=summary_path,
+            error_only_path=settings.github_ci_summary_dir
+            / str_utils.ensure_suffix(summary_name, MonthlyReportPaths.ERROR_ONLY_SUFFIX),
+            details_dir=settings.github_ci_summary_details_path(summary_name, "dummy").parent,
+            summary_name=summary_name,
+            daily_path=settings.github_ci_summary_dir / f"{summary_path.stem}{MonthlyReportPaths.DAILY_SUFFIX}",
+        )
+
+
+CI_TESTS_DIR_NAME = "ci-tests"
+MKDOCS_SERVE_TIMEOUT = 120
+MKDOCS_SERVE_URL = "http://127.0.0.1:8000"
+
+
+def export_ci_tests_markdown_to_html(settings: AtlasInitSettings, report_paths: MonthlyReportPaths) -> None:
+    html_out = settings.atlas_init_static_html_path
+    if not html_out or not html_out.exists():
+        return
+    ci_tests_dir = html_out / CI_TESTS_DIR_NAME
+    docs_out_dir = ci_tests_dir / "docs"
+    report_paths.export_to_dir(docs_out_dir)
+    index_md_content = create_index_md(docs_out_dir)
+    ensure_parents_write_text(docs_out_dir / "index.md", index_md_content)
+    server_url, run_event = start_mkdocs_serve(ci_tests_dir)
+    try:
+        if confirm(f"do you want to open the html docs? {server_url}", default=False):
+            run_and_wait(f'open -a "Google Chrome" {server_url}')
+        if confirm("Finished testing html docs?", default=False):
+            pass
+    except BaseException as e:
+        raise e
+    finally:
+        kill(run_event, reason="Done with html docs check")
+    if confirm("Are docs ok to build and push?", default=False):
+        build_and_push(ci_tests_dir, report_paths.summary_name)
+
+
+def create_index_md(docs_out_dir: Path) -> str:
+    """
+    tree -L 1 docs
+    docs
+    ├── 2025-06-26_details
+    ├── 2025-06-26_.md
+    ├── 2025-06-26.md
+    ├── 2025-06-26_error-only.md
+    ├── index.md
+    ├── javascript
+    └── stylesheets
+    """
+    md_files = {f.name: f for f in docs_out_dir.glob("*.md") if f.name != "index.md"}
+    parsed_dates = []
+    for md_file in md_files.values():
+        with suppress(ValueError):
+            parsed_dates.append(datetime.strptime(md_file.stem, "%Y-%m-%d"))
+    parsed_dates.sort(reverse=True)
+
+    def date_row(date: datetime) -> str:
+        summary_filename = f"{date.strftime('%Y-%m-%d')}.md"
+        error_only_filename = f"{date.strftime('%Y-%m-%d')}{MonthlyReportPaths.ERROR_ONLY_SUFFIX}"
+        daily_filename = f"{date.strftime('%Y-%m-%d')}{MonthlyReportPaths.DAILY_SUFFIX}"
+        line_links = [f"[{date.strftime('%Y-%m-%d')}](./{summary_filename})"]
+        if error_only_filename in md_files:
+            line_links.append(f"[{date.strftime('%Y-%m-%d')} Error Only](./{error_only_filename})")
+        if daily_filename in md_files:
+            line_links.append(f"[{date.strftime('%Y-%m-%d')} Daily Errors](./{daily_filename})")
+        return f"- {', '.join(line_links)}"
+
+    md_content = [
+        "# Welcome to CI Tests",
+        "",
+        *[date_row(dt) for dt in parsed_dates],
+        "",
+    ]
+    return "\n".join(md_content)
+
+
+def start_mkdocs_serve(ci_tests_dir: Path) -> tuple[str, ShellRun]:
+    future = Future()
+
+    def on_message(event: ShellRunEventT) -> bool:
+        match event:
+            case ShellRunStdOutput(_, content) if f"Serving on {MKDOCS_SERVE_URL}" in content:
+                logger.info(f"Docs server ready @ {MKDOCS_SERVE_URL}")
+                future.set_result(None)
+                return True
+        return False
+
+    run_event = run(
+        "uv run mkdocs serve", cwd=ci_tests_dir, message_callbacks=[on_message], print_prefix="mkdocs serve"
+    )
+    chain_future(run_event._complete_flag, future)
+    try:
+        future.result(timeout=MKDOCS_SERVE_TIMEOUT)
+    except BaseException as e:
+        kill(run_event, reason=f"Failed to start mkdocs serve, timeout after {MKDOCS_SERVE_TIMEOUT} seconds")
+        raise e
+    return MKDOCS_SERVE_URL, run_event
+
+
+def build_and_push(ci_tests_dir: Path, summary_name: str) -> None:
+    run_and_wait("uv run mkdocs build", cwd=ci_tests_dir, print_prefix="build")
+    run_and_wait("git add .", cwd=ci_tests_dir, print_prefix="add")
+    run_and_wait(f"git commit -m 'update ci tests {summary_name}'", cwd=ci_tests_dir, print_prefix="commit")
+    run_and_wait("git push", cwd=ci_tests_dir, print_prefix="push")

atlas_init/sdk_ext/go.py

@@ -0,0 +1,102 @@
+from contextlib import suppress
+import logging
+from pathlib import Path
+from ask_shell import confirm, run_and_wait
+from model_lib import dump, parse_model
+import typer
+from zero_3rdparty.file_utils import clean_dir, copy, ensure_parents_write_text
+from atlas_init.cli_args import ParsedPaths, option_sdk_repo_path, option_mms_repo_path
+from atlas_init.cli_tf.openapi import OpenapiSchema
+
+_go_mod_line = "replace go.mongodb.org/atlas-sdk/v20250312005 v20250312005.0.0 => ../atlas-sdk-go"
+logger = logging.getLogger(__name__)
+
+
+def go(
+    mms_path_str: str = option_mms_repo_path,
+    sdk_repo_path_str: str = option_sdk_repo_path,
+    mms_branch: str = typer.Option("master", "--mms-branch", help="Branch to use for mms"),
+    skip_mms_openapi: bool = typer.Option(
+        False, "-smms", "--skip-mms-openapi", help="Skip mms openapi generation, use existing file instead"
+    ),
+):
+    paths = ParsedPaths.from_strings(sdk_repo_path_str=sdk_repo_path_str, mms_path=mms_path_str)
+    mms_path = paths.mms_repo_path
+    assert mms_path, "mms_path is required"
+    sdk_path = paths.sdk_repo_path
+    assert sdk_path, "sdk_path is required"
+    openapi_path = safe_openapi_path(mms_path) if skip_mms_openapi else generate_openapi_spec(mms_path, mms_branch)
+    openapi_path = transform_openapi(openapi_path, sdk_path / "openapi/openapi-mms.yaml")
+    generate_go_sdk(sdk_path, openapi_path)
+    confirm(f"Have you remembered to add to your go.mod file: {_go_mod_line}")
+
+
+def transform_openapi(old: Path, dest_path: Path) -> Path:
+    api_spec = parse_model(old, t=OpenapiSchema)
+    new_api_spec = api_spec.model_dump()
+    for path in api_spec.paths.keys():
+        for method_name, method in api_spec.methods_with_name(path):
+            responses = method.get("responses", {})
+            for code, multi_responses in responses.items():
+                with suppress(AlreadySingleVersion):
+                    new_api_spec["paths"][path][method_name]["responses"][code]["content"] = use_a_single_version(
+                        multi_responses, api_spec, path
+                    )
+            if request_body := method.get("requestBody", {}):
+                with suppress(AlreadySingleVersion):
+                    new_api_spec["paths"][path][method_name]["requestBody"]["content"] = use_a_single_version(
+                        request_body, api_spec, path
+                    )
+    dest_yaml = dump(new_api_spec, "yaml")
+    ensure_parents_write_text(dest_path, dest_yaml)
+    return dest_path
+
+
+class AlreadySingleVersion(Exception):
+    pass
+
+
+def use_a_single_version(multi_content: dict, api_spec: OpenapiSchema, path: str) -> dict[str, dict]:
+    if api_versions := api_spec._unpack_schema_versions(multi_content):
+        if len(api_versions) > 1:
+            latest_version = max(api_versions)
+            last_header = f"application/vnd.atlas.{latest_version}+json"
+            old_content = multi_content["content"]
+            assert last_header in old_content, f"failed to find {last_header} for {path} in {old_content.keys()}"
+            return {last_header: old_content[last_header]}
+    raise AlreadySingleVersion
+
+
+def generate_openapi_spec(mms_path: Path, mms_branch: str) -> Path:
+    run_and_wait(f"git stash && git checkout {mms_branch}", cwd=mms_path)
+    bazelisk_bin_run = run_and_wait("mise which bazelisk", cwd=mms_path)
+    bazelisk_bin = bazelisk_bin_run.stdout_one_line
+    assert Path(bazelisk_bin).exists(), f"not found {bazelisk_bin}"
+    openapi_run = run_and_wait(f"{bazelisk_bin} run //server:mms-openapi", cwd=mms_path, print_prefix="mms-openapi")
+    assert openapi_run.clean_complete, f"failed to run {openapi_run}"
+    return safe_openapi_path(mms_path)
+
+
+def safe_openapi_path(mms_path: Path) -> Path:
+    openapi_path = mms_path / "server/openapi/services/openapi-mms.json"
+    assert openapi_path.exists(), f"not found {openapi_path}"
+    return openapi_path
+
+
+def generate_go_sdk(repo_path: Path, openapi_path: Path) -> None:
+    SDK_FOLDER = repo_path / "admin"
+    clean_dir(SDK_FOLDER, recreate=True)
+    generate_script = repo_path / "tools/scripts/generate.sh"
+    assert generate_script.exists(), f"not found {generate_script}"
+    openapi_folder = repo_path / "openapi"
+    openapi_dest_path = openapi_folder / openapi_path.name
+    if openapi_path != openapi_dest_path:
+        copy(openapi_path, openapi_dest_path)
+    generate_env = {
+        "OPENAPI_FOLDER": str(openapi_folder),
+        "OPENAPI_FILE_NAME": openapi_path.name,
+        "SDK_FOLDER": str(SDK_FOLDER),
+    }
+    run_and_wait(f"{generate_script}", cwd=repo_path / "tools", env=generate_env, print_prefix="go sdk create")
+    mockery_script = repo_path / "tools/scripts/generate_mocks.sh"
+    run_and_wait(f"{mockery_script}", cwd=repo_path / "tools", print_prefix="go sdk mockery")

atlas_init/sdk_ext/typer_app.py

@@ -0,0 +1,18 @@
+from ask_shell import configure_logging
+from typer import Typer
+
+
+def typer_main():
+    from atlas_init.sdk_ext import go
+
+    app = Typer(
+        name="sdk-ext",
+        help="SDK extension commands for Atlas Init",
+    )
+    app.command(name="go")(go.go)
+    configure_logging(app)
+    app()
+
+
+if __name__ == "__main__":
+    typer_main()

atlas_init/settings/env_vars.py

@@ -9,7 +9,7 @@ from typing import Any, NamedTuple, TypeVar
 
 from model_lib import StaticSettings, parse_payload
 from pydantic import BaseModel, ValidationError, field_validator
-from zero_3rdparty import iter_utils
+from zero_3rdparty import iter_utils, str_utils
 
 from atlas_init.settings.config import (
     AtlasInitConfig,
@@ -54,6 +54,7 @@ class AtlasInitSettings(StaticSettings):
     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_static_html_path: Path | None = None
 
     atlas_init_cfn_profile: str = ""
     atlas_init_cfn_region: str = ""
@@ -136,6 +137,17 @@ class AtlasInitSettings(StaticSettings):
     def github_ci_summary_dir(self) -> Path:
         return self.cache_root / "github_ci_summary"
 
+    def github_ci_summary_path(self, summary_name: str) -> Path:
+        return self.github_ci_summary_dir / str_utils.ensure_suffix(summary_name, ".md")
+
+    def github_ci_summary_details_path(self, summary_name: str, test_name: str) -> Path:
+        return self.github_ci_summary_path(summary_name).parent / self.github_ci_summary_details_rel_path(
+            summary_name, test_name
+        )
+
+    def github_ci_summary_details_rel_path(self, summary_name: str, test_name: str) -> str:
+        return f"{summary_name.removesuffix('.md')}_details/{test_name}.md"
+
     @property
     def go_test_logs_dir(self) -> Path:
         return self.cache_root / "go_test_logs"
@@ -231,7 +243,9 @@ def detect_ambiguous_env_vars(manual_env_vars: dict[str, str]) -> list[str]:
 
 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
+        env_name
+        for env_name in required_env_vars
+        if read_from_env(env_name) == "" and env_name not in manual_env_vars and env_name
     )
 
 
@@ -243,7 +257,15 @@ def init_settings(
     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)
+        skip_generated_vars: set[str] = set()
+        if "AWS_PROFILE" in profile_env_vars:
+            skip_generated_vars |= {
+                "AWS_ACCESS_KEY_ID",
+                "AWS_SECRET_ACCESS_KEY",
+            }  # avoid generated env-vars overwriting AWS PROFILE
+        profile_env_vars |= {
+            key: value for key, value in load_dotenv(vscode_env_vars).items() if key not in skip_generated_vars
+        }
     required_env_vars = collect_required_env_vars(list(settings_classes))
     ambiguous = [] if skip_ambiguous_check else detect_ambiguous_env_vars(profile_env_vars)
     missing_env_vars = find_missing_env_vars(required_env_vars, profile_env_vars)

atlas_init/settings/env_vars_generated.py

@@ -63,3 +63,5 @@ class RealmSettings(_EnvVarsGenerated):
 
 class AtlasSettingsWithProject(AtlasSettings):
     MONGODB_ATLAS_PROJECT_ID: str
+    MONGODB_ATLAS_PROJECT_OWNER_ID: str = ""
+    MONGODB_ATLAS_USER_EMAIL: str = ""