atlas-init 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

atlas_init/cli_tf/schema_v3_sdk_create.py

@@ -0,0 +1,216 @@
+import logging
+from functools import singledispatch
+from queue import Queue
+
+from atlas_init.cli_tf.schema_v2 import (
+    extend_import_urls,
+    go_fmt,
+    import_lines,
+    package_name,
+)
+from atlas_init.cli_tf.schema_v2_sdk import GoVarName, SDKAttribute, SDKModel
+from atlas_init.cli_tf.schema_v3 import (
+    TF_MODEL_NAME,
+    Attribute,
+    ComputedOptionalRequired,
+    ListNestedAttribute,
+    Resource,
+    SingleNestedAttribute,
+)
+from atlas_init.cli_tf.schema_v3_sdk_base import (
+    SDKAndSchemaAttribute,
+    find_attribute,
+    name_schema_struct,
+    name_struct_attribute,
+    schema_attributes,
+)
+from atlas_init.humps import pascalize
+
+logger = logging.getLogger(__name__)
+
+
+def generate_schema_to_model(resource: Resource, sdk_model: SDKModel) -> str:
+    func_lines = tf_to_sdk_create_func(resource, sdk_model)
+    import_urls = set()
+    extend_import_urls(import_urls, func_lines)
+    unformatted = "\n".join(
+        [
+            f"package {package_name(resource.name)}",
+            "",
+            *import_lines(import_urls),
+            "",
+            *func_lines,
+        ]
+    )
+    return go_fmt(resource.name, unformatted)
+
+
+def tf_to_sdk_create_func(resource: Resource, sdk_model: SDKModel) -> list[str]:
+    lines = [
+        f"func NewAtlasReq({GoVarName.CTX} context.Context, {GoVarName.INPUT} *{TF_MODEL_NAME}, {GoVarName.DIAGS} *diag.Diagnostics) *admin.{sdk_model.name} {{"
+        f"  return &admin.{sdk_model.name}{{"
+    ]
+    nested_attributes, call_lines = convert_or_call_lines(resource, sdk_model)
+    lines.extend(call_lines)
+    lines.extend(
+        [
+            "  }"  # end struct
+            "}"  # end function
+        ]
+    )
+    lines.extend(process_nested_attributes(nested_attributes))
+    return lines
+
+
+_tf_to_sdk_funcs = {
+    ("string", "string"): lambda tf_ref: f"{tf_ref}.ValueString()",
+    ("string", "*string"): lambda tf_ref: f"{tf_ref}.ValueStringPointer()",
+    ("*string", "*string"): lambda tf_ref: f"{tf_ref}.ValueStringPointer()",
+    (
+        "*string",
+        "*time.Time",
+    ): lambda tf_ref: f"conversion.StringPtrToTimePtr({tf_ref}.ValueStringPointer())",
+    ("*bool", "*bool"): lambda tf_ref: f"{tf_ref}.ValueBoolPointer()",
+    (
+        "int64",
+        "*int",
+    ): lambda tf_ref: f"conversion.Int64PtrToIntPtr({tf_ref}.ValueInt64Pointer())",
+    (
+        "*int64",
+        "*int",
+    ): lambda tf_ref: f"conversion.Int64PtrToIntPtr({tf_ref}.ValueInt64Pointer())",
+    ("*float64", "*float64"): lambda tf_ref: f"{tf_ref}.ValueFloat64Pointer()",
+    ("*int64", "*int64"): lambda tf_ref: f"{tf_ref}.ValueInt64Pointer()",
+}
+
+
+def tf_to_sdk_attribute_value(
+    schema_attribute: Attribute,
+    sdk_attribute: SDKAttribute,
+    variable_name: GoVarName = GoVarName.INPUT,
+) -> str:
+    key = (schema_attribute.go_type_optional, sdk_attribute.go_type)
+    if key in _tf_to_sdk_funcs:
+        return _tf_to_sdk_funcs[key](f"{variable_name}.{pascalize(schema_attribute.name)}")
+    raise ValueError(f"Could not find conversion function for {key} for attribute: {schema_attribute.name}")
+
+
+def convert_or_call_lines(
+    root: Resource | Attribute,
+    sdk_model: SDKModel,
+    variable_name: GoVarName = GoVarName.INPUT,
+) -> tuple[list[SDKAndSchemaAttribute], list[str]]:
+    call_lines = []
+    nested_attributes: list[SDKAndSchemaAttribute] = []
+    tf_attributes = schema_attributes(root)
+    for sdk_attr in sorted(sdk_model.attributes.values()):
+        try:
+            tf_attribute = find_attribute(tf_attributes, sdk_attr.tf_name, root.name)
+        except ValueError as e:
+            logger.warning(e)
+            continue
+        if tf_attribute.computed_optional_required == ComputedOptionalRequired.computed:
+            continue
+        if sdk_attr.is_nested:
+            call_lines.append(
+                f"  {sdk_attr.struct_name}: new{sdk_attr.struct_type_name}({GoVarName.CTX}, {variable_name}.{name_struct_attribute(tf_attribute.name)}, {GoVarName.DIAGS}),"
+            )
+            nested_attributes.append(SDKAndSchemaAttribute(sdk_attribute=sdk_attr, schema_attribute=tf_attribute))
+        elif tf_attribute.is_required:
+            call_lines.append(
+                f"  {sdk_attr.struct_name}: {tf_to_sdk_attribute_value(tf_attribute, sdk_attr, variable_name)},"
+            )
+        else:
+            call_lines.append(
+                f"  {sdk_attr.struct_name}: conversion.NilForUnknown({variable_name}.{tf_attribute.name_pascal}, {tf_to_sdk_attribute_value(tf_attribute, sdk_attr, variable_name)}),"
+            )
+    return nested_attributes, call_lines
+
+
+def process_nested_attributes(
+    nested_attributes: list[SDKAndSchemaAttribute],
+) -> list[str]:
+    lines = []
+    queue = Queue()
+
+    def add_nested_to_queue(attributes: list[SDKAndSchemaAttribute]):
+        for nested in attributes:
+            logger.info(f"found nested attribute: {nested.schema_attribute.name}")
+            queue.put(nested)
+
+    add_nested_to_queue(nested_attributes)
+    while not queue.empty():
+        sdk_attribute, schema_attribute = queue.get()
+        more_nested_attributes, nested_lines = convert_nested_attribute(
+            schema_attribute.nested_model, schema_attribute, sdk_attribute
+        )
+        lines.extend(nested_lines)
+        add_nested_to_queue(more_nested_attributes)
+    return lines
+
+
+@singledispatch
+def convert_nested_attribute(
+    nested_model: object, schema_attribute: Attribute, _: SDKAttribute
+) -> tuple[list[SDKAndSchemaAttribute], list[str]]:
+    raise NotImplementedError(f"unsupported nested attribute: {schema_attribute.name} of type {type(nested_model)}")
+
+
+@convert_nested_attribute.register
+def _convert_single_nested_attribute(
+    _: SingleNestedAttribute,
+    schema_attribute: Attribute,
+    sdk_attribute: SDKAttribute,
+) -> tuple[list[SDKAndSchemaAttribute], list[str]]:
+    sdk_model = sdk_attribute.as_sdk_model()
+    lines: list[str] = [
+        f"func new{sdk_model.name}(ctx context.Context, {GoVarName.INPUT} types.Object, diags *diag.Diagnostics) *admin.{sdk_model.name} {{",
+        f"  var resp *admin.{sdk_model.name}",
+        f"  if {GoVarName.INPUT}.IsUnknown() || {GoVarName.INPUT}.IsNull() {{",
+        "    return resp",
+        "  }",
+        f"  {GoVarName.ITEM} := &{name_schema_struct(schema_attribute.name)}{{}}",
+        f"  if localDiags := {GoVarName.INPUT}.As({GoVarName.CTX}, {GoVarName.ITEM}, basetypes.ObjectAsOptions{{}}); len(localDiags) > 0 {{",
+        f"    {GoVarName.DIAGS}.Append(localDiags...)",
+        "    return resp",
+        "  }",
+        f"  return &admin.{sdk_model.name}{{",
+    ]
+    nested_attributes, call_lines = convert_or_call_lines(schema_attribute, sdk_model, GoVarName.ITEM)
+    lines.extend([*call_lines, "  }", "}"])  # end struct  # end function
+    return nested_attributes, lines
+
+
+@convert_nested_attribute.register
+def _convert_list_nested_attriute(
+    _: ListNestedAttribute,
+    schema_attribute: Attribute,
+    sdk_attribute: SDKAttribute,
+) -> tuple[list[SDKAndSchemaAttribute], list[str]]:
+    sdk_model = sdk_attribute.as_sdk_model()
+    lines: list[str] = [
+        f"func new{sdk_model.name}(ctx context.Context, {GoVarName.INPUT} types.List, diags *diag.Diagnostics) *[]admin.{sdk_model.name} {{",
+        f"  if {GoVarName.INPUT}.IsUnknown() || {GoVarName.INPUT}.IsNull() {{",
+        "    return nil",
+        "  }",
+        f"  {GoVarName.ELEMENTS} := make([]{name_schema_struct(schema_attribute.name)}, len({GoVarName.INPUT}.Elements()))",
+        f"  if localDiags := {GoVarName.INPUT}.ElementsAs({GoVarName.CTX}, &{GoVarName.ELEMENTS}, false); len(localDiags) > 0 {{",
+        f"    {GoVarName.DIAGS}.Append(localDiags...)",
+        "    return nil",
+        "  }",
+        f"  {GoVarName.RESP} := make([]admin.{sdk_model.name}, len({GoVarName.INPUT}.Elements()))",
+        f"  for i := range {GoVarName.ELEMENTS} {{",
+        f"    {GoVarName.ITEM} := &{GoVarName.ELEMENTS}[i]",
+        f"    resp[i] = admin.{sdk_model.name}{{",
+    ]
+    nested_attributes, call_lines = convert_or_call_lines(schema_attribute, sdk_model, GoVarName.ITEM)
+    lines.extend(
+        [
+            *[f"    {line}" for line in call_lines],
+            "    }",  # end struct
+            "  }",  # end loop
+            "  return &resp",
+            "}",  # end function
+        ]
+    )
+    return nested_attributes, lines

atlas_init/humps.py

@@ -0,0 +1,253 @@
+"""
+# https://raw.githubusercontent.com/nficano/humps/master/humps/main.py
+This module contains all the core logic for humps.
+"""
+import re
+from collections.abc import Mapping
+from typing import TypeVar  # pylint: disable-msg=E0611
+
+ACRONYM_RE = re.compile(r"([A-Z\d]+)(?=[A-Z\d]|$)")
+PASCAL_RE = re.compile(r"([^\-_]+)")
+SPLIT_RE = re.compile(r"([\-_]*(?<=[^0-9])(?=[A-Z])[^A-Z]*[\-_]*)")
+UNDERSCORE_RE = re.compile(r"(?<=[^\-_])[\-_]+[^\-_]")
+T = TypeVar("T")
+
+def pascalize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to pascal case.
+
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        pascalized string, dictionary, or list of dictionaries.
+    """
+    if isinstance(str_or_iter, (list, Mapping)):
+        return _process_keys(str_or_iter, pascalize)
+
+    s = _is_none(str_or_iter)
+    if s.isupper() or s.isnumeric():
+        return str_or_iter
+
+    def _replace_fn(match):
+        """
+        :rtype: str
+        """
+        return match.group(1)[0].upper() + match.group(1)[1:]
+
+    s = camelize(PASCAL_RE.sub(_replace_fn, s))
+    return s[0].upper() + s[1:] if len(s) != 0 else s
+
+
+def camelize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to camel case.
+
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        camelized string, dictionary, or list of dictionaries.
+    """
+    if isinstance(str_or_iter, (list, Mapping)):
+        return _process_keys(str_or_iter, camelize)
+
+    s = _is_none(str_or_iter)
+    if s.isupper() or s.isnumeric():
+        return str_or_iter
+
+    if len(s) != 0 and not s[:2].isupper():
+        s = s[0].lower() + s[1:]
+
+    # For string "hello_world", match will contain
+    #             the regex capture group for "_w".
+    return UNDERSCORE_RE.sub(lambda m: m.group(0)[-1].upper(), s)
+
+
+def kebabize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to kebab case.
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        kebabized string, dictionary, or list of dictionaries.
+    """
+    if isinstance(str_or_iter, (list, Mapping)):
+        return _process_keys(str_or_iter, kebabize)
+
+    s = _is_none(str_or_iter)
+    if s.isnumeric():
+        return str_or_iter
+
+    if not (s.isupper()) and (is_camelcase(s) or is_pascalcase(s)):
+        return (
+            _separate_words(
+                string=_fix_abbreviations(s),
+                separator="-"
+            ).lower()
+        )
+
+    return UNDERSCORE_RE.sub(lambda m: "-" + m.group(0)[-1], s)
+
+
+def decamelize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to snake case.
+
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        snake cased string, dictionary, or list of dictionaries.
+    """
+    if isinstance(str_or_iter, (list, Mapping)):
+        return _process_keys(str_or_iter, decamelize)
+
+    s = _is_none(str_or_iter)
+    if s.isupper() or s.isnumeric():
+        return str_or_iter
+
+    return _separate_words(_fix_abbreviations(s)).lower()
+
+
+def depascalize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to snake case.
+
+    :param str_or_iter: A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        snake cased string, dictionary, or list of dictionaries.
+    """
+    return decamelize(str_or_iter)
+
+
+def dekebabize(str_or_iter: T) -> T:
+    """
+    Convert a string, dict, or list of dicts to snake case.
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: Union[list, dict, str]
+    :returns:
+        snake cased string, dictionary, or list of dictionaries.
+    """
+    if isinstance(str_or_iter, (list, Mapping)):
+        return _process_keys(str_or_iter, dekebabize)
+
+    s = _is_none(str_or_iter)
+    if s.isnumeric():
+        return str_or_iter
+
+    return s.replace("-", "_")
+
+
+def is_camelcase(str_or_iter: T) -> T:
+    """
+    Determine if a string, dict, or list of dicts is camel case.
+
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: bool
+    :returns:
+        True/False whether string or iterable is camel case
+    """
+    return str_or_iter == camelize(str_or_iter)
+
+
+def is_pascalcase(str_or_iter: T) -> T:
+    """
+    Determine if a string, dict, or list of dicts is pascal case.
+
+    :param str_or_iter: A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: bool
+    :returns:
+        True/False whether string or iterable is pascal case
+    """
+    return str_or_iter == pascalize(str_or_iter)
+
+
+def is_kebabcase(str_or_iter: T) -> T:
+    """
+    Determine if a string, dict, or list of dicts is camel case.
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: bool
+    :returns:
+        True/False whether string or iterable is camel case
+    """
+    return str_or_iter == kebabize(str_or_iter)
+
+
+def is_snakecase(str_or_iter: T) -> T:
+    """
+    Determine if a string, dict, or list of dicts is snake case.
+
+    :param str_or_iter:
+        A string or iterable.
+    :type str_or_iter: Union[list, dict, str]
+    :rtype: bool
+    :returns:
+        True/False whether string or iterable is snake case
+    """
+    if is_kebabcase(str_or_iter) and not is_camelcase(str_or_iter):
+        return False
+
+    return str_or_iter == decamelize(str_or_iter)
+
+
+def _is_none(_in):
+    """
+    Determine if the input is None
+    and returns a string with white-space removed
+    :param _in: input
+    :return:
+        an empty sting if _in is None,
+        else the input is returned with white-space removed
+    """
+    return "" if _in is None else re.sub(r"\s+", "", str(_in))
+
+
+def _process_keys(str_or_iter, fn):
+    if isinstance(str_or_iter, list):
+        return [_process_keys(k, fn) for k in str_or_iter]
+    if isinstance(str_or_iter, Mapping):
+        return {fn(k): _process_keys(v, fn) for k, v in str_or_iter.items()}
+    return str_or_iter
+
+
+def _fix_abbreviations(string):
+    """
+    Rewrite incorrectly cased acronyms, initialisms, and abbreviations,
+    allowing them to be decamelized correctly. For example, given the string
+    "APIResponse", this function is responsible for ensuring the output is
+    "api_response" instead of "a_p_i_response".
+
+    :param string: A string that may contain an incorrectly cased abbreviation.
+    :type string: str
+    :rtype: str
+    :returns:
+        A rewritten string that is safe for decamelization.
+    """
+    return ACRONYM_RE.sub(lambda m: m.group(0).title(), string)
+
+
+def _separate_words(string, separator="_"):
+    """
+    Split words that are separated by case differentiation.
+    :param string: Original string.
+    :param separator: String by which the individual
+        words will be put back together.
+    :returns:
+        New string.
+    """
+    return separator.join(s for s in SPLIT_RE.split(string) if s)

atlas_init/repos/cfn.py

@@ -9,6 +9,7 @@ from zero_3rdparty.dict_nested import read_nested_or_none
 from zero_3rdparty.str_utils import ensure_prefix
 
 from atlas_init.cloud.aws import REGIONS, AwsRegion
+from atlas_init.humps import pascalize
 from atlas_init.repos.path import current_dir
 
 logger = logging.getLogger(__name__)
@@ -41,9 +42,13 @@ class CfnType(Entity):
 
     @model_validator(mode="after")
     def ensure_type_name_prefix(self):
-        self.type_name = ensure_prefix(self.type_name.capitalize(), self.MONGODB_ATLAS_CFN_TYPE_PREFIX)
+        self.type_name = ensure_prefix(pascalize(self.type_name), self.MONGODB_ATLAS_CFN_TYPE_PREFIX)
         return self
 
+    @classmethod
+    def resource_name(cls, type_name: str) -> str:
+        return type_name.removeprefix(cls.MONGODB_ATLAS_CFN_TYPE_PREFIX).lower()
+
 
 class Operation(StrEnum):
     DELETE = "delete"

atlas_init/repos/path.py

@@ -29,11 +29,11 @@ _resource_roots = {
 }
 
 
-def _default_is_resource(_: Path) -> Callable[[Path], bool]:
-    raise NotImplementedError
+def _default_is_resource(p: Path) -> bool:
+    return "internal/service" in str(p)
 
 
-_resource_is_resource = {
+_resource_is_resource: dict[str, Callable[[Path], bool]] = {
     GH_OWNER_MONGODBATLAS_CLOUDFORMATION_RESOURCES: lambda p: (p / "cmd/main.go").exists(),
     GH_OWNER_TERRAFORM_PROVIDER_MONGODBATLAS: _default_is_resource,
 }

atlas_init/settings/config.py

@@ -4,6 +4,7 @@ import fnmatch
 import logging
 from collections.abc import Iterable
 from functools import total_ordering
+from os import getenv
 from pathlib import Path
 from typing import Any
 
@@ -59,7 +60,8 @@ class TerraformVars(Entity):
         if self.use_federated_vars:
             config["use_federated_vars"] = True
         if self.stream_instance:
-            config["stream_instance_config"] = {"name": "atlas-init"}
+            # hack until backend bug with stream instance is fixed
+            config["stream_instance_config"] = {"name": getenv("ATLAS_STREAM_INSTANCE_NAME", "atlas-init")}
         return config
 
 
@@ -154,10 +156,18 @@ def active_suites(
     forced_test_suites: list[str],
 ) -> list[TestSuite]:  # type: ignore
     repo_url_path = owner_project_name(repo_path)
-    repo_alias = config.repo_alias(repo_url_path)
-    logger.info(f"repo_alias={repo_alias}, repo_path={repo_path}, repo_url_path={repo_url_path}")
+    try:
+        repo_alias = config.repo_alias(repo_url_path)
+    except RepoAliasNotFoundError:
+        if forced_test_suites:
+            # still want to use the forced test suites
+            repo_alias = None
+        else:
+            raise
+    logger.info(
+        f"repo_alias={repo_alias}, repo_path={repo_path}, repo_url_path={repo_url_path}, cwd_rel_path={cwd_rel_path}"
+    )
     change_paths = [cwd_rel_path]
-
     active_suites = config.active_test_suites(repo_alias, change_paths, forced_test_suites)
     logger.info(f"active_suites: {[s.name for s in active_suites]}")
     return active_suites

atlas_init/settings/env_vars.py

@@ -53,6 +53,10 @@ class ExternalSettings(BaseSettings):
     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 as_env_var_name(field_name: str) -> str:
     names = set(field_names(AtlasInitSettings))
@@ -137,6 +141,10 @@ class AtlasInitPaths(BaseSettings):
     def env_vars_vs_code(self) -> Path:
         return self.profile_dir / ".env-vscode"
 
+    @property
+    def env_vars_trigger(self) -> Path:
+        return self.profile_dir / ".env-trigger"
+
     @property
     def tf_data_dir(self) -> Path:
         return self.profile_dir / ".terraform"
@@ -181,6 +189,7 @@ class AtlasInitSettings(AtlasInitPaths, ExternalSettings):
 
     cfn_profile: str = ""
     cfn_region: str = ""
+    cfn_use_kms_key: bool = False
     project_name: str = ""
 
     skip_copy: bool = False
@@ -246,7 +255,13 @@ class AtlasInitSettings(AtlasInitPaths, ExternalSettings):
 
     def cfn_config(self) -> dict[str, Any]:
         if self.cfn_profile:
-            return {"cfn_config": {"profile": self.cfn_profile, "region": self.cfn_region}}
+            return {
+                "cfn_config": {
+                    "profile": self.cfn_profile,
+                    "region": self.cfn_region,
+                    "use_kms_key": self.cfn_use_kms_key,
+                }
+            }
         return {}
 
 

atlas_init/settings/path.py

@@ -1,4 +1,5 @@
 import os
+from collections.abc import Callable
 from pathlib import Path
 
 import dotenv
@@ -21,15 +22,18 @@ DEFAULT_PROFILES_PATH.mkdir(exist_ok=True, parents=True)
 DEFAULT_TF_PATH = ROOT_PATH / "tf"
 DEFAULT_CONFIG_PATH = ROOT_PATH / "atlas_init.yaml"
 DEFAULT_SCHEMA_CONFIG_PATH = ROOT_PATH / "terraform.yaml"
+DEFAULT_GITHUB_CI_RUN_LOGS = ROOT_PATH / "github_ci_run_logs"
+DEFAULT_GITHUB_SUMMARY_DIR = ROOT_PATH / "github_ci_summary"
 
 
 def load_dotenv(env_path: Path) -> dict[str, str]:
     return {k: v for k, v in dotenv.dotenv_values(env_path).items() if v}
 
 
-def dump_vscode_dotenv(generated_path: Path, vscode_env_path: Path) -> None:
+def dump_vscode_dotenv(generated_path: Path, vscode_env_path: Path, **extras: str) -> None:
     vscode_env_vars = load_dotenv(generated_path)
     vscode_env_vars.pop("TF_CLI_CONFIG_FILE", None)  # migration tests will use local provider instead of online
+    vscode_env_vars.update(extras)
     dump_dotenv(vscode_env_path, vscode_env_vars)
 
 
@@ -43,6 +47,13 @@ def current_dir():
     return Path(os.path.curdir).absolute()
 
 
+def default_factory_cwd(rel_path: str) -> Callable[[], Path]:
+    def default_factory():
+        return current_dir() / rel_path
+
+    return default_factory
+
+
 def repo_path_rel_path() -> tuple[Path, str]:
     cwd = current_dir()
     rel_path = []

atlas_init/settings/rich_utils.py

@@ -35,6 +35,8 @@ def hide_secrets(handler: logging.Handler, secrets_dict: dict[str, str]) -> None
         if not isinstance(value, str):
             continue
         key_lower = key.lower()
+        if key_lower in {"true", "false"}:
+            continue
         if any(safe in key_lower for safe in safe_keys):
             continue
         if any(danger in key_lower for danger in dangerous_keys):