MAINT: Align fmu init with fmu-settings init behavior

Author: GibranAlfa

pyproject.toml

@@ -31,7 +31,7 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
     "fmu-datamodels",
-    "fmu-settings",
+    "fmu-settings>=0.28.0",
     "fmu-settings-api",
     "fmu-settings-gui",
     "rich",

src/fmu_settings_cli/copy/copy.py

@@ -577,7 +577,7 @@ def log_copy_event_to_target(self: Self) -> None:
         try:
             target_fmu_dir = get_fmu_directory(self.target)
         except FileNotFoundError:
-            target_fmu_dir = init_fmu_directory(self.target)
+            target_fmu_dir = init_fmu_directory(self.target, force=True)
         except Exception as e:
             error("Failed opening project fmu directory.", reason=str(e))
             raise typer.Exit(1) from e

src/fmu_settings_cli/init/cli.py

@@ -1,17 +1,19 @@
 """The 'init' command."""
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Final
+from typing import TYPE_CHECKING, Annotated
 
 import typer
 from fmu.settings._global_config import (
     InvalidGlobalConfigurationError,
     find_global_config,
     load_global_configuration_if_present,
 )
-from fmu.settings._init import init_fmu_directory
+from fmu.settings._init import (
+    InvalidFMUProjectPathError,
+    init_fmu_directory,
+)
 from pydantic import ValidationError
-from rich.table import Table
 
 from fmu_settings_cli.prints import (
     error,
@@ -30,28 +32,6 @@
     add_completion=True,
 )
 
-REQUIRED_FMU_PROJECT_SUBDIRS: Final[list[str]] = ["ert"]
-
-
-def is_fmu_project(path: Path) -> tuple[bool, list[str]]:
-    """Ensures the provided directory looks like an FMU project.
-
-    Args:
-        path: The directory to check
-
-    Returns:
-        Tuple of bool and list of strings, indicating whether the provided path does or
-        does not appear to be a valid FMU project, and what directories are lacking for
-        it to be so, respectively.
-    """
-    missing: list[str] = []
-    for dir_name in REQUIRED_FMU_PROJECT_SUBDIRS:
-        dir_ = path / dir_name
-        if not dir_.exists() or not dir_.is_dir():
-            missing.append(dir_name)
-
-    return len(missing) == 0, missing
-
 
 def _find_global_config_source(base_path: Path) -> Path | None:
     """Find which global config file would have been imported."""
@@ -83,61 +63,35 @@ def init(  # noqa: PLR0912
             show_default=False,
         ),
     ] = False,
-    skip_config_import: Annotated[
-        bool,
-        typer.Option(
-            "--skip-config-import",
-            help=(
-                "Skip searching for and importing masterdata set in the global "
-                "configuration or global variables."
-            ),
-            show_default=False,
-        ),
-    ] = False,
 ) -> None:
     """The main entry point for the init command."""
     if ctx.invoked_subcommand is not None:  # pragma: no cover
         return
 
     cwd = Path.cwd()
 
-    if not force:
-        has_all_fmu_subdirs, missing_dirs = is_fmu_project(cwd)
-        if not has_all_fmu_subdirs:
-            dirs_table = Table("Directory")
-            for dir_ in missing_dirs:
-                dirs_table.add_row(dir_)
-
-            error(
-                f"This directory ({cwd}) does not appear to be an FMU project. "
-                "Expected the following directories:",
-                dirs_table,
-            )
-            raise typer.Abort
-
     global_config: GlobalConfiguration | None = None
-    if not skip_config_import:
-        try:
-            global_config = find_global_config(cwd)
-        except ValidationError as e:
-            validation_warning(
-                e,
-                "Unable to import masterdata.",
-                reason="Validation of the global config/global variables failed.",
-                suggestion=(
-                    "You will need to establish valid SMDA masterdata in FMU "
-                    "Settings by running and opening 'fmu settings'."
-                ),
-            )
-        except InvalidGlobalConfigurationError as e:
-            warning(
-                "Unable to import masterdata.",
-                reason=str(e),
-                suggestion=(
-                    "You will need to establish valid SMDA masterdata in FMU "
-                    "Settings by running and opening 'fmu settings'."
-                ),
-            )
+    try:
+        global_config = find_global_config(cwd)
+    except ValidationError as e:
+        validation_warning(
+            e,
+            "Unable to import masterdata.",
+            reason="Validation of the global config/global variables failed.",
+            suggestion=(
+                "You will need to establish valid SMDA masterdata in FMU "
+                "Settings by running and opening 'fmu settings'."
+            ),
+        )
+    except InvalidGlobalConfigurationError as e:
+        warning(
+            "Unable to import masterdata.",
+            reason=str(e),
+            suggestion=(
+                "You will need to establish valid SMDA masterdata in FMU "
+                "Settings by running and opening 'fmu settings'."
+            ),
+        )
 
     if global_config:
         imported_sections = ", ".join(
@@ -153,7 +107,13 @@ def init(  # noqa: PLR0912
         success(f"Successfully imported {imported_sections}{source_suffix}.")
 
     try:
-        fmu_dir = init_fmu_directory(cwd, global_config=global_config)
+        fmu_dir = init_fmu_directory(cwd, global_config=global_config, force=force)
+    except InvalidFMUProjectPathError as e:
+        error(
+            "Unable to create .fmu directory.",
+            reason=str(e),
+        )
+        raise typer.Abort from e
     except FileExistsError as e:
         error(
             "Unable to create .fmu directory.",

tests/conftest.py

@@ -27,10 +27,9 @@
     StratigraphyElement,
 )
 from fmu.settings import ProjectFMUDirectory
-from fmu.settings._init import init_fmu_directory
+from fmu.settings._init import REQUIRED_FMU_PROJECT_SUBDIRS, init_fmu_directory
 from pytest import MonkeyPatch
 
-from fmu_settings_cli.init.cli import REQUIRED_FMU_PROJECT_SUBDIRS
 from fmu_settings_cli.settings import constants
 
 

tests/test_init/test_init_main.py

@@ -9,21 +9,22 @@
 import yaml
 from fmu.datamodels.fmu_results.global_configuration import GlobalConfiguration
 from fmu.settings import find_nearest_fmu_directory
+from fmu.settings._init import REQUIRED_FMU_PROJECT_SUBDIRS, is_fmu_project
 from pydantic import ValidationError
 from typer.testing import CliRunner
 
 from fmu_settings_cli.__main__ import app
-from fmu_settings_cli.init.cli import REQUIRED_FMU_PROJECT_SUBDIRS, is_fmu_project
+from fmu_settings_cli.init.cli import _find_global_config_source
 
 runner = CliRunner()
 
 
 @pytest.mark.parametrize(
     "dirs, expected",
     [
-        (["foo"], (False, REQUIRED_FMU_PROJECT_SUBDIRS)),
-        (["foo/ert"], (False, REQUIRED_FMU_PROJECT_SUBDIRS)),
-        (["ertt"], (False, REQUIRED_FMU_PROJECT_SUBDIRS)),
+        (["foo"], (False, list(REQUIRED_FMU_PROJECT_SUBDIRS))),
+        (["foo/ert"], (False, list(REQUIRED_FMU_PROJECT_SUBDIRS))),
+        (["ertt"], (False, list(REQUIRED_FMU_PROJECT_SUBDIRS))),
         (REQUIRED_FMU_PROJECT_SUBDIRS, (True, [])),
     ],
 )
@@ -48,8 +49,11 @@ def test_init_creates_user_fmu_if_exist(in_tmp_path: Path) -> None:
 
     assert result.exit_code == 1
     stderr = " ".join(result.stderr.split())
-    assert "does not appear to be an FMU project" in stderr
-    assert "ert" in stderr
+    missing_dirs = ", ".join(
+        f"'{dir_name}'" for dir_name in REQUIRED_FMU_PROJECT_SUBDIRS
+    )
+    assert "Failed initializing .fmu directory." in stderr
+    assert f"Did not find: {missing_dirs}." in stderr
     assert (home / ".fmu").exists()
 
 
@@ -58,8 +62,11 @@ def test_init_checks_if_fmu_dir_fails(in_tmp_path: Path) -> None:
     result = runner.invoke(app, ["init"])
     assert result.exit_code == 1
     stderr = " ".join(result.stderr.split())
-    assert "does not appear to be an FMU project" in stderr
-    assert "ert" in stderr
+    missing_dirs = ", ".join(
+        f"'{dir_name}'" for dir_name in REQUIRED_FMU_PROJECT_SUBDIRS
+    )
+    assert "Failed initializing .fmu directory." in stderr
+    assert f"Did not find: {missing_dirs}." in stderr
 
 
 def test_init_checks_if_fmu_dir_passes(in_tmp_path: Path) -> None:
@@ -148,10 +155,12 @@ def test_init_adds_global_variables_with_masterdata(
     assert result.exit_code == 0
     stdout = " ".join(result.stdout.split())
     assert "Success: Successfully imported access, masterdata, model from" in stdout
-    assert "fmuconfig/output/global_variables.yml" in stdout
     assert "Success: All done!" in stdout
     assert "Info: Project stratigraphy was not imported by 'fmu init'." in stdout
     assert "Open 'fmu settings' to import stratigraphy from RMS" in stdout
+    assert _find_global_config_source(tmp_path) == (
+        fmuconfig_out / "global_variables.yml"
+    )
 
     fmu_dir = find_nearest_fmu_directory()
     fmu_dir_cfg = fmu_dir.config.load()
@@ -180,35 +189,8 @@ def test_init_adds_input_global_config_with_masterdata(
     assert result.exit_code == 0
     stdout = " ".join(result.stdout.split())
     assert "Success: Successfully imported access, masterdata, model from" in stdout
-    assert "fmuconfig/input/global_master_config.yml" in stdout
     assert "Success: All done!" in stdout
-
-
-def test_init_skips_adding_global_variables_with_masterdata(
-    in_fmu_project: Path,
-    generate_strict_valid_globalconfiguration: Callable[[], GlobalConfiguration],
-) -> None:
-    """Tests that 'fmu init' skips adding masterdata with skip flag."""
-    tmp_path = in_fmu_project
-
-    valid_global_cfg = generate_strict_valid_globalconfiguration()
-
-    fmuconfig_out = tmp_path / "fmuconfig/output"
-    fmuconfig_out.mkdir(parents=True, exist_ok=True)
-
-    (fmuconfig_out / "global_variables.yml").write_text(
-        yaml.dump(valid_global_cfg.model_dump(mode="json", by_alias=True))
-    )
-
-    result = runner.invoke(app, ["init", "--skip-config-import"])
-    assert result.exit_code == 0
-    assert "Success: All done!" in result.stdout
-
-    fmu_dir = find_nearest_fmu_directory()
-    fmu_dir_cfg = fmu_dir.config.load()
-    assert fmu_dir_cfg.masterdata is None
-    assert fmu_dir_cfg.access is None
-    assert fmu_dir_cfg.model is None
+    assert _find_global_config_source(tmp_path) == global_config_path
 
 
 def test_init_raises_when_import_drogon_masterdata(
@@ -230,26 +212,6 @@ def test_init_raises_when_import_drogon_masterdata(
     assert "Reason: Invalid name in 'model': Drogon" in result.stderr
     assert "Success: All done!" in result.stdout
 
-
-def test_init_skips_raising_when_import_drogon_masterdata_with_skip(
-    in_fmu_project: Path, global_variables_with_masterdata: dict[str, Any]
-) -> None:
-    """Tests that 'fmu init' skips raising on Drogon masterdata with skip flag."""
-    tmp_path = in_fmu_project
-
-    fmuconfig_out = tmp_path / "fmuconfig/output"
-    fmuconfig_out.mkdir(parents=True, exist_ok=True)
-
-    (fmuconfig_out / "global_variables.yml").write_text(
-        yaml.dump(global_variables_with_masterdata)
-    )
-
-    result = runner.invoke(app, ["init", "--skip-config-import"])
-    assert result.exit_code == 0
-    # _not_ in
-    assert "Reason: Invalid name in 'model': Drogon" not in result.stderr
-    assert "Success: All done!" in result.stdout
-
     fmu_dir = find_nearest_fmu_directory()
     fmu_dir_cfg = fmu_dir.config.load()
     assert fmu_dir_cfg.masterdata is None
@@ -262,7 +224,7 @@ def test_init_fmu_dir_exists_error(in_fmu_project: Path) -> None:
     fmu_dir = in_fmu_project / ".fmu"
     fmu_dir.mkdir()
 
-    result = runner.invoke(app, ["init", "--skip-config-import"])
+    result = runner.invoke(app, ["init"])
     assert result.exit_code == 1
     assert "Error: Unable to create .fmu directory" in result.stderr
     assert ".fmu already exists" in result.stderr
@@ -275,7 +237,7 @@ def test_init_fmu_dir_no_permissions_error(in_fmu_project: Path) -> None:
     with patch(
         "fmu_settings_cli.init.cli.init_fmu_directory", side_effect=PermissionError
     ):
-        result = runner.invoke(app, ["init", "--skip-config-import"])
+        result = runner.invoke(app, ["init"])
     assert result.exit_code == 1
     assert "Error: Unable to create .fmu directory" in result.stderr
     assert "lacking permissions to create" in result.stderr
@@ -291,7 +253,7 @@ def test_init_fmu_dir_validation_error(in_fmu_project: Path) -> None:
         "fmu_settings_cli.init.cli.init_fmu_directory",
         side_effect=ValidationError("Foo", []),
     ):
-        result = runner.invoke(app, ["init", "--skip-config-import"])
+        result = runner.invoke(app, ["init"])
     assert result.exit_code == 1
 
     assert "Error: Unable to create .fmu directory" in result.stderr
@@ -304,7 +266,7 @@ def test_init_fmu_dir_some_error(in_fmu_project: Path) -> None:
         "fmu_settings_cli.init.cli.init_fmu_directory",
         side_effect=ValueError("Foo"),
     ):
-        result = runner.invoke(app, ["init", "--skip-config-import"])
+        result = runner.invoke(app, ["init"])
     assert result.exit_code == 1
 
     assert "Error: Unable to create .fmu directory" in result.stderr