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

atlas_init/__init__.py

@@ -1,12 +1,8 @@
 from pathlib import Path
 
-VERSION = "0.4.2"
+VERSION = "0.4.4"
 
 
 def running_in_repo() -> bool:
-    py_directory = Path(__file__).parent.parent
-    if py_directory.name != "py":
-        return False
-    git_directory = py_directory.parent / ".git"
-    git_config = git_directory / "config"
-    return git_directory.exists() and git_config.exists() and "atlas-init" in git_config.read_text()
+    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,
@@ -137,7 +140,7 @@ def group_commands_for_mode(
 ) -> dict[str, str]:
     commands_to_run: dict[str, str] = {}
     if mode == GoTestMode.package:
-        name_regex = f'^({"|".join(names)})$' if names else "^TestAcc*"
+        name_regex = f"^({'|'.join(names)})$" if names else "^TestAcc*"
         for pkg_url in group.package_url_tests(repo_path):
             command = f"go test {pkg_url} -v -run {name_regex} -timeout {timeout_minutes}m"
             if not group.sequential_tests:
@@ -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/debug_logs.py

@@ -225,7 +225,7 @@ def match_request(
                 step_number=step_number,
             )
     remaining_responses = [resp for i, resp in enumerate(responses_list) if i not in used_responses]
-    err_msg = f"Could not match request {request.path} ({ref}) with any response\n\n{request}\n\n\nThere are #{len(remaining_responses)} responses left that doesn't match\n{'-'*80}\n{'\n'.join(r.text for r in remaining_responses)}"
+    err_msg = f"Could not match request {request.path} ({ref}) with any response\n\n{request}\n\n\nThere are #{len(remaining_responses)} responses left that doesn't match\n{'-' * 80}\n{'\n'.join(r.text for r in remaining_responses)}"
     raise ValueError(err_msg)
 
 
@@ -260,9 +260,9 @@ def parse_raw_req_responses(
             in_response = False
     assert not in_request, "Request not closed"
     assert not in_response, "Response not closed"
-    assert (
-        request_count == response_count
-    ), f"Mismatch in request and response count: {request_count} != {response_count}"
+    assert request_count == response_count, (
+        f"Mismatch in request and response count: {request_count} != {response_count}"
+    )
     parsed_requests = {}
     for ref, request_lines in requests.items():
         parsed_requests[ref] = parse_request(request_lines)

atlas_init/cli_tf/example_update.py

@@ -65,9 +65,9 @@ def update_examples(event_in: UpdateExamples) -> UpdateExamplesOutput:
     if event_in.skip_tf_fmt:
         logger.info("skipping terraform fmt")
     else:
-        assert run_binary_command_is_ok(
-            "terraform", "fmt -recursive", cwd=event_in.examples_base_dir, logger=logger
-        ), "terraform fmt failed"
+        assert run_binary_command_is_ok("terraform", "fmt -recursive", cwd=event_in.examples_base_dir, logger=logger), (
+            "terraform fmt failed"
+        )
     return UpdateExamplesOutput(
         before_var_descriptions=flatten_descriptions(existing_var_descriptions),
         before_output_descriptions=flatten_descriptions(existing_output_descriptions),

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: