atlas-init 0.1.0__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

@@ -3,10 +3,12 @@ from __future__ import annotations
 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
 
-from model_lib import Entity
+from model_lib import Entity, dump_ignore_falsy
 from pydantic import Field, model_validator
 
 from atlas_init.repos.path import owner_project_name
@@ -14,6 +16,7 @@ from atlas_init.repos.path import owner_project_name
 logger = logging.getLogger(__name__)
 
 
+@dump_ignore_falsy
 class TerraformVars(Entity):
     cluster_info: bool = False
     cluster_info_m10: bool = False
@@ -26,8 +29,8 @@ class TerraformVars(Entity):
     use_aws_s3: bool = False
     use_federated_vars: bool = False
 
-    def __add__(self, other: TerraformVars):
-        assert isinstance(other, TerraformVars)
+    def __add__(self, other: TerraformVars):  # type: ignore
+        assert isinstance(other, TerraformVars)  # type: ignore
         kwargs = {k: v or getattr(other, k) for k, v in self}
         return type(self)(**kwargs)
 
@@ -57,10 +60,13 @@ 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
 
 
+@dump_ignore_falsy
+@total_ordering
 class TestSuite(Entity):
     __test__ = False
 
@@ -68,7 +74,12 @@ class TestSuite(Entity):
     sequential_tests: bool = False
     repo_go_packages: dict[str, list[str]] = Field(default_factory=dict)
     repo_globs: dict[str, list[str]] = Field(default_factory=dict)
-    vars: TerraformVars = Field(default_factory=TerraformVars)
+    vars: TerraformVars = Field(default_factory=TerraformVars)  # type: ignore
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, TestSuite):  # type: ignore
+            raise TypeError
+        return self.name < other.name
 
     def all_globs(self, repo_alias: str) -> list[str]:
         go_packages = self.repo_go_packages.get(repo_alias, [])
@@ -95,8 +106,8 @@ class RepoAliasNotFoundError(ValueError):
 
 
 class AtlasInitConfig(Entity):
-    test_suites: list[TestSuite] = Field(default_factory=list)
     repo_aliases: dict[str, str] = Field(default_factory=dict)
+    test_suites: list[TestSuite] = Field(default_factory=list)  # type: ignore
 
     def repo_alias(self, repo_url_path: str) -> str:
         alias = self.repo_aliases.get(repo_url_path)
@@ -115,7 +126,7 @@ class AtlasInitConfig(Entity):
         alias: str | None,
         change_paths: Iterable[str],
         forced_test_suites: list[str],
-    ) -> list[TestSuite]:
+    ) -> list[TestSuite]:  # type: ignore
         forced_suites = set(forced_test_suites)
         if forced_test_suites:
             logger.warning(f"using forced test suites: {forced_test_suites}")
@@ -143,12 +154,20 @@ def active_suites(
     repo_path: Path,
     cwd_rel_path: str,
     forced_test_suites: list[str],
-) -> list[TestSuite]:
+) -> 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

@@ -47,11 +47,15 @@ class ExternalSettings(BaseSettings):
     MONGODB_ATLAS_PRIVATE_KEY: str
     MONGODB_ATLAS_PUBLIC_KEY: str
     MONGODB_ATLAS_BASE_URL: str = "https://cloud-dev.mongodb.com/"
-    ci: bool = False
+    non_interactive: bool = False
 
     @property
     def is_interactive(self) -> bool:
-        return not self.ci
+        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:
@@ -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"
@@ -145,6 +153,17 @@ class AtlasInitPaths(BaseSettings):
     def tf_vars_path(self) -> Path:
         return self.tf_data_dir / "vars.auto.tfvars.json"
 
+    @property
+    def tf_state_path(self) -> Path:
+        return self.profile_dir / "tf_state"
+
+    @property
+    def tf_outputs_path(self) -> Path:
+        return self.profile_dir / "tf_outputs.json"
+
+    def load_env_vars(self, path: Path) -> dict[str, str]:
+        return load_dotenv(path)
+
     def load_env_vars_generated(self) -> dict[str, str]:
         env_path = self.env_vars_generated
         assert env_path.exists(), f"no env-vars exist {env_path} have you forgotten apply?"
@@ -170,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
@@ -235,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 {}