atlas-init 0.4.3__tar.gz

atlas_init-0.4.3/.gitignore

@@ -0,0 +1,28 @@
+*.tfstate*
+*.code-workspace
+*.auto.tfvars
+dev*.tfrc
+*.env-generated
+*.env
+*.env_manual
+profiles/
+tf/modules/playground/
+tf/playground_caller.tf
+schema/
+tf_debug/
+dist
+.ruff_cache
+.coverage
+coverage.xml
+profiles_ci/
+.venv
+.sourcery.yaml
+github_ci_run_logs
+tf_bug_files
+github_ci_summary
+*.pyc
+demo/
+.env*
+tf_log/
+downloads
+htmlcov

atlas_init-0.4.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Espen Albert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atlas_init-0.4.3/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: atlas-init
+Version: 0.4.3
+Project-URL: Documentation, https://github.com/EspenAlbert/atlas-init#readme
+Project-URL: Issues, https://github.com/EspenAlbert/atlas-init/issues
+Project-URL: Source, https://github.com/EspenAlbert/atlas-init
+Author-email: EspenAlbert <albertespen@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: appdirs==1.4.4
+Requires-Dist: boto3==1.35.92
+Requires-Dist: gitpython==3.1.42
+Requires-Dist: humanize==4.9.0
+Requires-Dist: model-lib[toml]==1.0.0b3
+Requires-Dist: mypy-boto3-cloudformation==1.37.22
+Requires-Dist: orjson==3.10.13
+Requires-Dist: pydantic-settings==2.7.1
+Requires-Dist: pygithub==2.6.1
+Requires-Dist: python-hcl2==6.1.0
+Requires-Dist: requests==2.32.2
+Requires-Dist: rich==14.0.0
+Requires-Dist: stringcase==1.2.0
+Requires-Dist: tenacity==9.0.0
+Requires-Dist: typer==0.15.1
+Requires-Dist: zero-3rdparty==1.0.0b2
+Description-Content-Type: text/markdown
+
+# Atlas Init - A CLI for developing integrations with MongoDB Atlas
+<p align="center">
+    <a href="https://pypi.org/project/atlas-init/" target="_blank">
+        <img src="https://img.shields.io/pypi/v/atlas-init.svg">
+    </a>
+    <a href="https://pypi.org/project/atlas-init/" target="_blank">
+        <img src="https://img.shields.io/pypi/pyversions/atlas-init.svg">
+    </a>
+    <a href="https://github.com/EspenAlbert/py-libs/blob/main/LICENSE" target="_blank">
+            <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License">
+    </a>
+    <a href="https://codecov.io/github/EspenAlbert/atlas-init" target="_blank">
+            <img src="https://codecov.io/github/EspenAlbert/atlas-init/graph/badge.svg?token=DR7FDJXNZY" alt="Coverage">
+    </a>
+</p>
+
+Currently, used with
+- <https://github.com/mongodb/terraform-provider-mongodbatlas>
+- <https://github.com/mongodb/mongodb/mongodbatlas-cloudformation-resources>
+- see [atlas_init#repo_aliases](atlas_init.yaml) for an up-to-date list
+
+## Quickstart
+Recommended as a tool with [uvx](https://docs.astral.sh/uv/guides/tools/#running-tools)
+```shell
+uvx atlas-init # help info
+uvx atlas-init tf # help for tf specific commands
+uvx atlas-init cfn # help for cfn specific commands
+```
+
+## Profile Configuration
+1. [Create an organization](https://cloud-dev.mongodb.com/v2#/preferences/organizations)
+2. Go to `access_manager` and click `Create Api Key`: <https://cloud-dev.mongodb.com/v2#/org/{ORG_ID_IN_URL_FROM_1}/access/apiKeys>
+   - Tick all permissions
+3. create directories and store a file in `profiles/default/.env-manual` (`ATLAS_INIT_PROFILES_PATH/{profile_name}/.env-manual`)
+
+```env
+AWS_PROFILE=REPLACE_ME # your AWS profile used to create resources or other env-vars supported by AWS TF provider
+MONGODB_ATLAS_ORG_ID=REPLACE_ME # ORG_ID_IN_URL_FROM_1
+MONGODB_ATLAS_PUBLIC_KEY=REPLACE_ME # with 2
+MONGODB_ATLAS_PRIVATE_KEY=REPLACE_ME # with 2
+ATLAS_INIT_PROJECT_NAME=YOUR_NAME # the name of the project
+MONGODB_ATLAS_BASE_URL=https://cloud-dev.mongodb.com/ # replace with https://cloud.mongodb.com/ if you are not a MongoDB Employe
+
+# optional
+TF_VAR_federated_settings_id=REPLACE_ME # will need to add organization: <https://cloud-dev.mongodb.com/v2#/federation/{FEDERATION_SETTINGS_ID}/organizations> (see internal testing wiki)
+
+# if you want to use your locally built MongoDB atlas provider
+# see appendix for details on the content
+TF_CLI_CONFIG_FILE=REPLACE_ME/dev.tfrc
+
+# if you plan developing with cloudformation
+ATLAS_INIT_CFN_PROFILE=YOUR_NAME
+ATLAS_INIT_CFN_REGION=eu-south-2 # find a region with few other profiles
+```
+
+## Local development
+
+```shell
+git clone https://github.com/EspenAlbert/atlas-init
+cd atlas-init
+brew install pre-commit uv hatch
+# https://github.com/astral-sh/uv <-- python packaging lightning fast
+# https://hatch.pypa.io/latest/ <-- uv compatible build system for python
+
+pre-commit install
+
+# check that everything works
+pre-commit run --all-files
+
+# configure your virtualenv and validate the tests are working
+cd py
+hatch test
+export VENV_DIR=$(hatch env find hatch-test | grep py3.12) # hatch venv path for env=hatch-test
+export VENV_PYTHON=$VENV_DIR/bin/python
+$VENV_PYTHON # ensure you are in shell with python3.12 (cmd+d to exit)
+cd .. # back to repo root
+
+# open in your IDE with virtualenv enabled
+code .
+# select venv path from $VENV_PYTHON output as python interpreter
+# in vs code: use cmd+p and `Python: select interpreter` command
+
+# to make it easy to invoke from any terminal (replace .zprofile with your terminal)
+export pypath=$(git rev-parse --show-toplevel)/py
+echo "alias atlas_init='export PYTHONPATH=$pypath && \"$VENV_PYTHON\" -m atlas_init'" >> ~/.zprofile
+
+# test that it works
+atlas_init # should show how to use the cli
+```
+
+### CI Installation Tests (`pip install` local wheel)
+- `uv sync`
+  - creates a local `.venv` builds the wheel from this repo and installs it
+- use `export ATLAS_INIT_PROFILES_PATH=/somewhere/to/store/your/env-vars/and/tf/state`
+
+
+## Appendix
+
+### Configuring vscode to use your env vars
+- add to your `settings.json`
+
+```json
+{
+    "go.testEnvFile": "/{SOME_PREFIX}/atlas-init/profiles/default/.env-vscode",
+}
+```
+
+### Content of `dev.tfrc`
+usually, it will look something like this:
+
+```hcl
+
+provider_installation {
+ 
+  dev_overrides {
+ 
+    "mongodb/mongodbatlas" = "REPO_PATH_TF_PROVIDER/bin"
+ 
+  }
+ 
+  direct {}
+ 
+}
+```
+
+### Re-generating the lock files
+
+```shell
+terraform providers lock \
+    -platform=darwin_amd64 \
+    -platform=linux_amd64 \
+    -platform=darwin_arm64 \
+    -platform=linux_arm64
+    # -platform=windows_amd64 \
+```

atlas_init-0.4.3/atlas_init/__init__.py

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

atlas_init-0.4.3/atlas_init/__main__.py

@@ -0,0 +1,3 @@
+from atlas_init.cli import typer_main
+
+typer_main()

atlas_init-0.4.3/atlas_init/atlas_init.yaml

@@ -0,0 +1,105 @@
+repo_aliases:
+  mongodb/terraform-provider-mongodbatlas: tf
+  mongodb/mongodbatlas-cloudformation-resources: cfn
+test_suites:
+- name: cluster
+  repo_go_packages:
+    cfn:
+    - cfn-resources/cluster
+- name: cluster_sdk
+  repo_go_packages:
+    tf:
+    - internal/service/advancedcluster
+- name: clusterm10
+  vars:
+    cluster_info_m10: true
+- name: encryption_at_rest
+  vars:
+    use_encryption_at_rest: true
+- name: federated
+  repo_go_packages:
+    tf:
+    - internal/service/federatedsettingsorgrolemapping
+  vars:
+    use_federated_vars: true
+- name: network
+  repo_go_packages:
+    tf:
+    - internal/service/privatelinkendpointservicedatafederationonlinearchive
+  vars:
+    use_private_link: true
+- name: network_peering
+  repo_go_packages:
+    tf:
+    - internal/service/networkpeering
+  vars:
+    use_vpc_peering: true
+    use_aws_vars: true
+    use_aws_vpc: true
+- name: private_endpoint_regional_mode
+  repo_go_packages:
+    tf:
+    - internal/service/privateendpointregionalmode
+  vars:
+    use_aws_vars: true
+- name: privatelink
+  repo_go_packages:
+    cfn:
+    - cfn-resources/cfn-private-endpoint-aws
+    tf:
+    - internal/service/privatelinkendpointservice
+  vars:
+    use_aws_vars: true
+    use_aws_vpc: true
+- name: project
+  repo_go_packages:
+    cfn:
+    - cfn-resources/project
+    tf:
+    - internal/service/project
+  vars:
+    use_project_extra: true
+- name: resource_policy
+  sequential_tests: true
+  repo_go_packages:
+    cfn:
+    - cfn-resources/resource-policy
+    tf:
+    - internal/service/resourcepolicy
+- name: s3
+  repo_go_packages:
+    tf:
+    - internal/service/cloudbackupsnapshotexportbucket
+  vars:
+    use_aws_s3: true
+- name: s3_with_cluster
+  repo_go_packages:
+    tf:
+    - internal/service/cloudbackupsnapshotexportjob
+  vars:
+    cluster_info_m10: true
+    use_aws_s3: true
+- name: search_index
+  repo_go_packages:
+    tf:
+    - internal/service/searchindex
+  vars:
+    cluster_info: true
+- name: stream_connection
+  repo_go_packages:
+    tf:
+    - internal/service/streamconnection
+    cfn:
+    - cfn-resources/stream-connection
+  vars:
+    cluster_info_m10: true
+    stream_instance: true
+- name: trigger
+  repo_go_packages:
+    cfn:
+    - cfn-resources/trigger
+  vars:
+    cluster_info_m10: true
+  post_apply_hooks:
+  - name: create_realm_resources
+    locate: atlas_init.cli_root.trigger.create_realm_app

atlas_init-0.4.3/atlas_init/cli.py

@@ -0,0 +1,261 @@
+import logging
+from collections.abc import Callable
+from pathlib import Path
+from pydoc import locate
+from typing import Literal
+
+import typer
+from model_lib import dump, parse_payload
+from zero_3rdparty.file_utils import iter_paths
+
+from atlas_init.cli_helper import sdk_auto_changes
+from atlas_init.cli_helper.run import (
+    run_binary_command_is_ok,
+    run_command_exit_on_failure,
+    run_command_receive_result,
+)
+from atlas_init.cli_helper.sdk import (
+    SDK_VERSION_HELP,
+    SdkVersion,
+    SdkVersionUpgrade,
+    find_breaking_changes,
+    find_latest_sdk_version,
+    format_breaking_changes,
+    is_removed,
+    parse_breaking_changes,
+)
+from atlas_init.cli_helper.tf_runner import (
+    TerraformRunError,
+    dump_tf_vars,
+    export_outputs,
+    get_tf_vars,
+    run_terraform,
+)
+from atlas_init.repos.go_sdk import go_sdk_breaking_changes
+from atlas_init.repos.path import (
+    Repo,
+    current_repo,
+    current_repo_path,
+    find_go_mod_dir,
+    find_paths,
+    resource_name,
+)
+from atlas_init.settings.config import RepoAliasNotFoundError, TestSuite
+from atlas_init.settings.env_vars import (
+    active_suites,
+    init_settings,
+)
+from atlas_init.settings.path import (
+    CwdIsNoRepoPathError,
+    dump_vscode_dotenv,
+    repo_path_rel_path,
+)
+from atlas_init.typer_app import app, app_command, extra_root_commands
+
+logger = logging.getLogger(__name__)
+
+
+@app_command()
+def init(context: typer.Context):
+    settings = init_settings()
+    extra_args = context.args
+    logger.info(f"in the init command: {extra_args}")
+    run_terraform(settings, "init", extra_args)
+
+
+@app_command()
+def plan(context: typer.Context, *, skip_outputs: bool = False):
+    _plan_or_apply(context.args, "plan", skip_outputs=skip_outputs)
+
+
+@app_command()
+def apply(context: typer.Context, *, skip_outputs: bool = False):
+    suites = _plan_or_apply(context.args, "apply", skip_outputs=skip_outputs)
+    for suite in suites:
+        for hook in suite.post_apply_hooks:
+            logger.info(f"running post apply hook: {hook.name}")
+            hook_func = locate(hook.locate)
+            hook_func()  # type: ignore
+
+
+def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool) -> list[TestSuite]:  # type: ignore
+    settings = init_settings()
+    logger.info(f"using the '{command}' command, extra args: {extra_args}")
+    try:
+        suites = active_suites(settings)
+    except (CwdIsNoRepoPathError, RepoAliasNotFoundError) as e:
+        logger.warning(repr(e))
+        suites = []
+
+    tf_vars = get_tf_vars(settings, suites)
+    dump_tf_vars(settings, tf_vars)
+
+    try:
+        run_terraform(settings, command, extra_args)
+    except TerraformRunError as e:
+        logger.error(repr(e))  # noqa: TRY400
+        raise typer.Exit(1) from e
+
+    if not skip_outputs:
+        export_outputs(settings)
+
+    if settings.env_vars_generated.exists():
+        dump_vscode_dotenv(settings.env_vars_generated, settings.env_vars_vs_code)
+        logger.info(f"your .env file is ready @ {settings.env_vars_vs_code}")
+    return suites
+
+
+@app_command()
+def destroy(context: typer.Context):
+    extra_args = context.args
+    settings = init_settings()
+    if not settings.tf_state_path.exists():
+        logger.warning(f"no terraform state found  {settings.tf_state_path}, exiting")
+        return
+    tf_vars = get_tf_vars(settings, [])
+    dump_tf_vars(settings, tf_vars)
+    try:
+        run_terraform(settings, "destroy", extra_args)
+    except TerraformRunError as e:
+        logger.error(repr(e))  # noqa: TRY400
+        return
+
+
+@app_command()
+def sdk_upgrade(
+    old: SdkVersion = typer.Argument(help=SDK_VERSION_HELP),
+    new: SdkVersion = typer.Argument(
+        default_factory=find_latest_sdk_version,
+        help=SDK_VERSION_HELP + "\nNo Value=Latest",
+    ),
+    resource: str = typer.Option("", help="for only upgrading a single resource"),
+    dry_run: bool = typer.Option(False, help="only log out the changes"),
+    auto_change_name: str = typer.Option("", help="any extra replacements done in the file"),
+):
+    SdkVersionUpgrade(old=old, new=new)
+    repo_path, _ = repo_path_rel_path()
+    logger.info(f"bumping from {old} -> {new} @ {repo_path}")
+
+    sdk_breaking_changes_path = go_sdk_breaking_changes(repo_path)
+    all_breaking_changes = parse_breaking_changes(sdk_breaking_changes_path, old, new)
+    replacements = {
+        f"go.mongodb.org/atlas-sdk/{old}/mockadmin": f"go.mongodb.org/atlas-sdk/{new}/mockadmin",
+        f"go.mongodb.org/atlas-sdk/{old}/admin": f"go.mongodb.org/atlas-sdk/{new}/admin",
+    }
+    auto_modifier: Callable[[str, str], str] | None = None
+    if auto_change_name:
+        func_path = f"{sdk_auto_changes.__name__}.{auto_change_name}"
+        auto_modifier = locate(func_path)  # type: ignore
+
+    change_count = 0
+    resources: set[str] = set()
+    resources_breaking_changes: set[str] = set()
+    for path in iter_paths(repo_path, "*.go", ".mockery.yaml"):
+        text_old = path.read_text()
+        if all(replace_in not in text_old for replace_in in replacements):
+            continue
+        r_name = resource_name(repo_path, path)
+        if resource and resource != r_name:
+            continue
+        resources.add(r_name)
+        logger.info(f"updating sdk version in {path}")
+        if breaking_changes := find_breaking_changes(text_old, all_breaking_changes):
+            changes_formatted = format_breaking_changes(text_old, breaking_changes)
+            logger.warning(f"found breaking changes: {changes_formatted}")
+            if is_removed(breaking_changes):
+                resources_breaking_changes.add(r_name)
+        text_new = text_old
+        for replace_in, replace_out in replacements.items():
+            text_new = text_new.replace(replace_in, replace_out)
+        if not dry_run:
+            if auto_modifier:
+                text_new = auto_modifier(text_new, old)
+            path.write_text(text_new)
+        change_count += 1
+    if change_count == 0:
+        logger.warning("no changes found")
+        return
+    logger.info(f"changed in total: {change_count} files")
+    resources_str = "\n".join(
+        f"- {r} 💥" if r in resources_breaking_changes else f"- {r}" for r in sorted(resources) if r
+    )
+    logger.info(f"resources changed: \n{resources_str}")
+    if dry_run:
+        logger.warning("dry-run, no changes to go.mod")
+        return
+    go_mod_parent = find_go_mod_dir(repo_path)
+    if not run_binary_command_is_ok("go", "mod tidy", cwd=go_mod_parent, logger=logger):
+        logger.critical(f"failed to run go mod tidy in {go_mod_parent}")
+        raise typer.Exit(1)
+
+
+@app_command()
+def pre_commit(
+    skip_build: bool = typer.Option(default=False),
+    skip_lint: bool = typer.Option(default=False),
+    max_issues: int = typer.Option(1000, "-m", "--max"),
+):
+    golang_ci_lint_args = f"--max-same-issues {max_issues} --max-issues-per-linter {max_issues}"
+    match current_repo():
+        case Repo.CFN:
+            repo_path, resource_path, r_name = find_paths()
+            build_cmd = f"cd {resource_path} && make build"
+            # TODO: understand why piping to grep doesn't work
+            # f"golangci-lint run --path-prefix=./cfn-resources | grep {r_name}"
+            format_cmd_str = (
+                f"cd cfn-resources && golangci-lint run --path-prefix=./cfn-resources {golang_ci_lint_args}"
+            )
+        case Repo.TF:
+            repo_path = current_repo_path()
+            build_cmd = "make build"
+            format_cmd_str = f"golangci-lint run {golang_ci_lint_args}"
+        case _:
+            raise NotImplementedError
+    if skip_build:
+        logger.warning("skipping build")
+    else:
+        run_command_exit_on_failure(build_cmd, cwd=repo_path, logger=logger)
+    if skip_lint:
+        logger.warning("skipping formatting")
+    else:
+        run_command_exit_on_failure(format_cmd_str, cwd=repo_path, logger=logger)
+
+
+@app_command()
+def repo_dump():
+    code_root = Path.home() / "code"
+    path_urls = {}
+    for repo_git_path in iter_paths(code_root, ".git", exclude_folder_names=[".terraform"]):
+        repo_path = repo_git_path.parent
+        logger.info(f"repo: {repo_path}")
+        url = run_command_receive_result("git remote get-url origin", cwd=repo_path, logger=logger, can_fail=True)
+        if url.startswith("FAIL:"):
+            continue
+        path_urls[str(repo_path)] = url
+    out_path = code_root / "repos.json"
+    repos_json = dump(path_urls, "pretty_json")
+    out_path.write_text(repos_json)
+
+
+@app_command()
+def repo_clone():
+    repos_file = Path.home() / "code" / "repos.json"
+    repo_path_json: dict[str, str] = parse_payload(repos_file)  # type: ignore
+    for repo_path_str, url in repo_path_json.items():
+        logger.info(f"cloning {url} @ {repo_path_str}")
+        repo_path = Path(repo_path_str)
+        parent_dir = repo_path.parent
+        parent_dir.mkdir(parents=True, exist_ok=True)
+        if repo_path.exists():
+            logger.warning(f"skipping {repo_path}, already exists")
+            continue
+        run_command_exit_on_failure(f"git clone {url} {repo_path.name}", cwd=parent_dir, logger=logger)
+
+
+def typer_main():
+    extra_root_commands()
+    app()
+
+
+if __name__ == "__main__":
+    typer_main()

atlas_init-0.4.3/atlas_init/cli_args.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+import typer
+from model_lib import parse_payload
+from zero_3rdparty.iter_utils import key_equal_value_to_dict
+
+option_sdk_repo_path = typer.Option("", "-sdk", "--sdk-repo-path", help="the path to the sdk repo")
+
+
+def parse_key_values(params: list[str]) -> dict[str, str]:
+    return key_equal_value_to_dict(params)
+
+
+def parse_key_values_any(params: list[str]) -> dict[str, Any]:
+    str_dict = parse_key_values(params)
+    return {k: parse_payload(v) if v.startswith(("{", "[")) else v for k, v in str_dict.items()}