ansys-saf-cli 4.1.dev0__py3-none-any.whl

ansys/saf/cli/_config/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ansys/saf/cli/_config/const.py

@@ -0,0 +1,45 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Env vars from other SAF components used to configure them through the CLI options
+from pathlib import Path
+
+GLOW_DEBUG = "GLOW_DEBUG"
+GLOW_LOGGING_LEVEL = "GLOW_LOGGING_LEVEL"
+PORTAL_UI_PORT = "PORTAL_UI_PORT"
+GLOW_API_PORT = "GLOW_API_PORT"
+GLOW_UI_PORT = "GLOW_UI_PORT"
+GLOW_UI_DEBUG = "GLOW_UI_PYTHON_DEBUGGING"
+GLOW_SOLUTION_DEFINITION = "GLOW_SOLUTION_DEFINITION"
+GLOW_UI_MODULE = "GLOW_UI_MODULE"
+
+# Env vars for solution scaffolding
+_root_path = Path(__file__).resolve().parent.parent
+SOLUTION_TEMPLATE_PATH = _root_path / "_solutions" / "templates" / "solution"
+DEFAULT_SOLUTION_NAME = "my_solution"
+DEFAULT_SOLUTION_DISPLAY_NAME = "My Solution"
+DEFAULT_UI_FRAMEWORK = "dash"
+UI_FRAMEWORKS = ["dash", "none"]
+DEFAULT_STEP_NAME = "my_new_step"
+DEFAULT_TEMPLATE_NAME = "calculator-step"
+DEFAULT_SOLUTION_NAMESPACE = "saf.solutions"
+
+# Env vars for solution installation
+WORKSPACE_CLEAR_OPTIONS = ["hard", "soft"]
+
+# Others
+SAF_CLI_EXTERNAL_URL = "https://ansys.github.io/saf-cli-documentation"
+SAF_DESKTOP_LOG_TO_FILES = "SAF_DESKTOP_LOG_TO_FILES"

ansys/saf/cli/_database/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ansys/saf/cli/_database/manager.py

@@ -0,0 +1,94 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+from pathlib import Path
+import platform
+
+import click
+from pydantic import ValidationError
+
+from ansys.saf.cli._database.models import SolutionDatabase, SolutionRegistry
+
+
+class SolutionDatabaseManager:
+    def __init__(self) -> None:
+        self._db_path = self.get_solution_database_path()
+        self._db = self._load_solution_database()
+
+    @classmethod
+    def get_solution_database_path(cls) -> Path:
+        if platform.system() == "Windows":
+            directory = Path(os.environ["APPDATA"])
+        elif platform.system() == "Linux":
+            directory = Path(os.getenv("XDG_DATA_HOME", "~/.local/share")).expanduser()
+        else:
+            raise ValueError("Unsupported operating system")
+        return directory / "ansys" / "saf" / "cli" / "solution_db.json"
+
+    def _load_solution_database(self) -> SolutionDatabase:
+        db_raw = self._db_path.read_text() if self._db_path.is_file() else ""
+        try:
+            return SolutionDatabase.model_validate_json(db_raw or json.dumps({}))
+        except ValidationError:
+            click.secho(
+                "The solution database is invalid.",
+                err=True,
+                fg="red",
+            )
+            click.secho(
+                f"You may need to delete it from '{SolutionDatabaseManager.get_solution_database_path()}'",
+                err=True,
+                fg="red",
+            )
+            raise
+
+    def _save_solution_database(self):
+        if not self._db_path.is_file():
+            self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._db_path.write_text(self._db.model_dump_json())
+
+    def store_solution(self, solution: SolutionRegistry) -> None:
+        if solution not in self._db.solutions:
+            self._db.solutions.append(solution)
+            self._save_solution_database()
+        else:
+            solution_in_db = next(db_solution for db_solution in self._db.solutions if db_solution == solution)
+            if solution_in_db.display_name != solution.display_name:
+                solution_in_db.display_name = solution.display_name
+                self._save_solution_database()
+
+    def get_solutions_grouped_by_name(self) -> dict[str, list[SolutionRegistry]]:
+        solutions_by_name: dict[str, list[SolutionRegistry]] = {}
+        for solution in self._db.solutions:
+            if not solution.is_valid:
+                continue
+            if solution.name not in solutions_by_name:
+                solutions_by_name[solution.name] = []
+            solutions_by_name[solution.name].append(solution)
+        return solutions_by_name
+
+    def get_solutions_by_name(self, solution_name: str) -> list[SolutionRegistry]:
+        return [solution for solution in self._db.solutions if solution.name == solution_name and solution.is_valid]
+
+    def get_solution_by_root_dir(self, solution_root_dir: Path) -> SolutionRegistry | None:
+        solutions = [
+            solution for solution in self._db.solutions if solution.root_dir == solution_root_dir and solution.is_valid
+        ]
+        if len(solutions) > 1:
+            raise ValueError(f"Multiple solutions found with the root directory {solution_root_dir}")
+        return solutions[0] if solutions else None

ansys/saf/cli/_database/models.py

@@ -0,0 +1,53 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import platform
+import re
+
+from pydantic import BaseModel, field_validator
+
+
+class SolutionRegistry(BaseModel):
+    name: str
+    root_dir: Path
+    display_name: str
+
+    @property
+    def is_valid(self) -> bool:
+        return self.root_dir.is_dir()
+
+    @field_validator("name")
+    @classmethod
+    def _validate_solution_name(cls, solution_name: str) -> str:
+        if platform.system() == "Windows":
+            invalid_chars = r'[<>:"/\\|?*\x00-\x1F]'
+        elif platform.system() == "Linux":
+            invalid_chars = r"[/\x00]"
+        else:
+            raise ValueError("Unsupported operating system")
+        if bool(re.search(invalid_chars, solution_name)):
+            raise ValueError(f"Solution name contains invalid characters: {invalid_chars}")
+        return solution_name
+
+    def __eq__(self, other: object):
+        if not isinstance(other, type(self)):
+            return False
+        return self.root_dir == other.root_dir
+
+
+class SolutionDatabase(BaseModel):
+    solutions: list[SolutionRegistry] = []

ansys/saf/cli/_solutions/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

ansys/saf/cli/_solutions/add_step.py

@@ -0,0 +1,256 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import re
+import tempfile
+
+import click
+from cookiecutter.main import cookiecutter  # pyright: ignore[reportMissingTypeStubs, reportUnknownVariableType]
+from packaging.version import Version
+import tomlkit
+
+from ansys.saf.cli._solutions.dependencies import DependencyManager
+from ansys.saf.cli._solutions.plugins import SafTemplate
+from ansys.saf.cli._utilities.conversion import namespace_to_path, to_class_name, to_module_name
+from ansys.saf.cli._utilities.solution_modules import (
+    create_solution_environment,
+    get_exec_from_solution_venv,
+    get_main_module,
+    resolve_solution_main_file,
+)
+
+WRONG_FRAMEWORK_ERROR_MSG = (
+    "The step you are creating is using a different framework than the one you used to create the solution with."
+)
+WRONG_DASH_STRUCTURE_ERROR_MSG = (
+    "The target solution does not use the expected multi-page Dash structure required by 'saf add-step'."
+)
+
+
+def _insert_step_line(pattern: re.Pattern[str], content: str, new_line: str) -> str:
+    content_lines = content.splitlines()
+
+    if new_line not in content_lines:
+        insert_position = 0
+        last_non_empty_line = 0
+
+        for i, line in enumerate(content_lines):
+            if pattern.match(line):
+                insert_position = last_non_empty_line + 1
+                break
+            if line.strip():
+                last_non_empty_line = i
+
+        content_lines.insert(insert_position, new_line)
+
+    return "\n".join(content_lines)
+
+
+def _resolve_solution_namespace_info(
+    solution_root_dir: Path,
+    solution_package_name: str | None = None,
+) -> tuple[str, str, str]:
+    """
+    Resolve namespace information from a solution's main.py file.
+    """
+    solution_main_file = resolve_solution_main_file(solution_root_dir)
+    main_module = get_main_module(solution_main_file)
+    resolved_solution_module = main_module.removesuffix(".main")
+    namespace, resolved_solution_package_name = resolved_solution_module.rsplit(".", 1)
+
+    # Trust the discovered module path; this supports both default and custom namespaces
+    if solution_package_name and solution_package_name != resolved_solution_package_name:
+        resolved_solution_package_name = solution_package_name
+
+    namespace_path = namespace_to_path(namespace)
+
+    return namespace, namespace_path, resolved_solution_package_name
+
+
+def step_name_exists(solution_root_dir: Path, solution_package_name: str, step_name: str) -> bool:
+    """Return True if the step name already exists in the given solution."""
+    step_module_name = to_module_name(step_name, "step")
+
+    _, namespace_path, resolved_solution_package_name = _resolve_solution_namespace_info(
+        solution_root_dir,
+        solution_package_name,
+    )
+
+    solution_definition_path = (
+        solution_root_dir / "src" / namespace_path / resolved_solution_package_name / "solution" / "definition.py"
+    )
+
+    if not solution_definition_path.is_file():
+        raise FileNotFoundError(f"Solution definition not found in expected location: {solution_definition_path}")
+
+    return step_module_name in solution_definition_path.read_text()
+
+
+def check_template_cli_compatibility(
+    solution_root_dir: Path,
+    saf_step_template: SafTemplate,
+) -> None:
+    if saf_step_template.saf_cli_compatibility_range is None:
+        return
+
+    pyproject_path = solution_root_dir / "pyproject.toml"
+    try:
+        pyproject_data = tomlkit.loads(pyproject_path.read_bytes()).unwrap()
+        solution_saf_cli_version = Version(pyproject_data.get("saf-cli-version", {}).get("saf-cli-version"))
+    except Exception:
+        solution_saf_cli_version = None
+
+    if solution_saf_cli_version is None:
+        click.secho(
+            f"Warning: Template '{saf_step_template.name}' declares the saf-cli compatibility constraint "
+            f"'{saf_step_template.saf_cli_compatibility_range}', but the solution does not declare a valid saf-cli "
+            f"version in pyproject.toml. The step might not work as expected.",
+            fg="yellow",
+        )
+        return
+
+    if not saf_step_template.saf_cli_compatibility_range.contains(solution_saf_cli_version, prereleases=True):
+        raise ValueError(
+            f"Template '{saf_step_template.name}' requires a saf-cli version in the range "
+            f"'{saf_step_template.saf_cli_compatibility_range}', "
+            f"but the solution's saf-cli version is {solution_saf_cli_version}.",
+        ) from None
+
+
+def _add_step_to_definition(
+    solution_root_dir: Path,
+    solution_module_name: str,
+    step_module_name: str,
+    step_definition_class_name: str,
+    namespace: str,
+    namespace_path: str,
+) -> None:
+    solution_definition_path = (
+        solution_root_dir / "src" / namespace_path / solution_module_name / "solution" / "definition.py"
+    )
+
+    if not solution_definition_path.is_file():
+        raise FileNotFoundError(f"Solution definition not found in {solution_definition_path}.")
+
+    solution_definition_content = solution_definition_path.read_text()
+
+    new_step_line = f"    {step_module_name}: {step_definition_class_name}"
+
+    solution_definition_content = _insert_step_line(
+        pattern=re.compile(r"^class .*?\(Solution\):$"),
+        content=solution_definition_content,
+        new_line=new_step_line,
+    )
+    solution_definition_content = _insert_step_line(
+        pattern=re.compile(r"^class .*?\(StepsModel\):$"),
+        content=solution_definition_content,
+        new_line=f"from {namespace}.{solution_module_name}.solution.{step_module_name} import {step_definition_class_name}",  # noqa: E501
+    )
+    solution_definition_path.write_text(solution_definition_content)
+
+
+def _validate_multi_page_dash_solution(
+    solution_root_dir: Path,
+    solution_module_name: str,
+    namespace_path: str,
+) -> None:
+    main_page_path = solution_root_dir / "src" / namespace_path / solution_module_name / "ui" / "pages" / "page.py"
+    app_path = solution_root_dir / "src" / namespace_path / solution_module_name / "ui" / "app.py"
+    # temporary fix until saf-cli supports detecting which framework the solution was created with.
+    if not main_page_path.is_file() or not app_path.is_file():
+        raise RuntimeError(WRONG_FRAMEWORK_ERROR_MSG)
+
+    app_content = app_path.read_text(encoding="utf-8")
+    if not re.search(r"\buse_pages\s*=\s*True\b", app_content):
+        raise RuntimeError(WRONG_DASH_STRUCTURE_ERROR_MSG)
+
+
+def add_step_to_solution(
+    solution_name: str,
+    solution_root_dir: Path,
+    solution_module_name: str,
+    step_name: str,
+    ui_type: str,
+    saf_step_template: SafTemplate,
+) -> None:
+    # see docs' glossary for a detailed explanation of every term used in the cookiecutter kwargs
+
+    namespace, namespace_path, resolved_solution_module_name = _resolve_solution_namespace_info(
+        solution_root_dir,
+        solution_module_name,
+    )
+    solution_module_name = resolved_solution_module_name
+
+    solution_definition_class_name = to_class_name(solution_name, "Solution")
+    step_module_name = to_module_name(step_name, "step")
+    step_definition_class_name = to_class_name(step_name, "Step")
+    ui_page_file_name = to_module_name(step_module_name.removesuffix("_step"), "page")
+
+    if ui_type == "dash":
+        _validate_multi_page_dash_solution(
+            solution_root_dir,
+            solution_module_name,
+            namespace_path,
+        )
+
+    # Generate into a temporary directory and then copy generated files to the solution.
+    # This avoids cookiecutter complaining about an existing output directory, and lets the
+    # template hooks enforce that existing step files are not overwritten.
+    with tempfile.TemporaryDirectory() as baking_path:
+        cookiecutter(
+            template=saf_step_template.location.as_posix(),
+            output_dir=baking_path,
+            no_input=True,
+            # overwrite all cookiecutter.json terms
+            extra_context={
+                "__solution_name": solution_name,
+                "__solution_root_dir": solution_root_dir.absolute().as_posix(),
+                "__solution_module_name": solution_module_name,
+                "__solution_namespace": namespace,
+                "__solution_namespace_path": namespace_path,
+                "__solution_definition_class_name": solution_definition_class_name,
+                "__step_name": step_name,
+                "__step_module_name": step_module_name,
+                "__step_definition_class_name": step_definition_class_name,
+                "__ui_page_file_name": ui_page_file_name,
+                "__ui_framework": ui_type,
+            },
+        )
+
+    _add_step_to_definition(
+        solution_root_dir,
+        solution_module_name,
+        step_module_name,
+        step_definition_class_name,
+        namespace,
+        namespace_path,
+    )
+    if saf_step_template.dependencies:
+        click.secho(
+            "Updating solution dependencies. Do not modify solution files until completion.",
+            fg="cyan",
+            bold=True,
+        )
+
+        executable = get_exec_from_solution_venv(solution_root_dir, "poetry")
+        solution_env = create_solution_environment(solution_root_dir)
+
+        dependency_manager = DependencyManager(
+            saf_template=saf_step_template,
+            solution_root_dir=solution_root_dir,
+        )
+        dependency_manager.update_solution_dependencies(executable, solution_env)

ansys/saf/cli/_solutions/dependencies.py

@@ -0,0 +1,162 @@
+# Copyright (C) 2026 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import subprocess
+from typing import Any
+
+import click
+from pydantic import BaseModel
+import tomlkit
+from tomlkit.items import Table
+
+from ansys.saf.cli._solutions.plugins import SafTemplate
+
+
+class ManualDependency(BaseModel):
+    name: str
+    specification: str | dict[str, Any]
+    group: str
+
+
+class DependencyManager:
+    def __init__(
+        self,
+        saf_template: SafTemplate,
+        solution_root_dir: Path,
+    ) -> None:
+        self._saf_template = saf_template
+        self._solution_root_dir = solution_root_dir
+        self._pyproject_path = solution_root_dir / "pyproject.toml"
+        if not self._pyproject_path.is_file():
+            raise FileNotFoundError(f"pyproject.toml not found in solution root directory '{self._solution_root_dir}'.")
+
+    @staticmethod
+    def _create_new_dependency_group() -> Table:
+        new_group = tomlkit.table()
+        new_group.add("optional", True)
+        deps = tomlkit.table()
+        new_group.add("dependencies", deps)
+        new_group.add(tomlkit.nl())
+        return new_group
+
+    def _get_group_str(self, group_name: str) -> str:
+        return "main" if group_name == "main" else f"{group_name} group"
+
+    def _get_solution_dependency_groups(self, poetry_section: dict[str, Any]) -> dict[str, Any]:
+        if "group" not in poetry_section:  # type: ignore
+            if any(step_dep_group != "main" for step_dep_group in self._saf_template.dependencies):
+                poetry_section["group"] = tomlkit.table(is_super_table=True)  # type: ignore
+            else:
+                return {}
+        return poetry_section["group"]  # type: ignore
+
+    def _find_dependency_in_solution(
+        self,
+        dependency_name: str,
+        main_dependencies: dict[str, Any],
+        dependency_groups: dict[str, Any],
+    ) -> bool:
+        if dependency_name in main_dependencies:
+            return True
+        for _, group_dependencies in dependency_groups.items():
+            if dependency_name in group_dependencies.get("dependencies", {}):
+                return True
+        return False
+
+    def _add_dependency_to_solution(
+        self,
+        step_dependency_name: str,
+        step_dependency_spec: str | dict[str, Any],
+        solution_dependencies: dict[str, Any],
+    ) -> None:
+        if isinstance(step_dependency_spec, str):
+            # Dependencies in the format dependency_name: "dependency_specification"
+            solution_dependencies[step_dependency_name] = step_dependency_spec
+        else:
+            # Dependencies in the format dependency_name: { "key": "value", ... }
+            inline_dependency = tomlkit.inline_table()
+            inline_dependency.update(step_dependency_spec)  # pyright: ignore[reportUnknownMemberType]
+            inline_dependency.trivia.trail = "\n"
+            solution_dependencies[step_dependency_name] = inline_dependency
+
+    def _render_manual_dependency_warning(self, manual_dependencies: list[ManualDependency], groups: set[str]) -> None:
+        click.secho(
+            f"WARNING: the step template '{self._saf_template.name}' has some dependencies in common with the "
+            f"solution's pyproject.toml at {self._pyproject_path}. Review the solution's pyproject.toml and manually "
+            f"update it if necessary, to ensure that it is compatible with the step template's dependencies.\n",
+            fg="yellow",
+        )
+        click.secho("Step specification of the common dependencies:", fg="yellow")
+        for manual_dependency in manual_dependencies:
+            click.secho(
+                f"  - {manual_dependency.name} ({self._get_group_str(manual_dependency.group)}): "
+                f"{manual_dependency.specification}",
+                fg="yellow",
+            )
+        install_command = "poetry install"
+        if groups:
+            install_command += f" --with {','.join(sorted(groups))}"
+        click.secho(
+            f"\nAfter reviewing the dependencies, please run:\n"
+            f'  - saf execute {self._solution_root_dir.name} "poetry lock"\n'
+            f'  - saf execute {self._solution_root_dir.name} "{install_command}"',
+            fg="yellow",
+        )
+
+    def update_solution_dependencies(self, executable: Path, solution_env: dict[str, str]) -> None:
+        pyproject_content = tomlkit.loads(self._pyproject_path.read_bytes())
+        if not pyproject_content.get("tool", {}).get("poetry", {}):  # type: ignore
+            raise ValueError(f"No [tool.poetry] section found in pyproject.toml at '{self._pyproject_path}'.")
+        poetry_section = pyproject_content["tool"]["poetry"]  # type: ignore
+        main_deps = poetry_section.get("dependencies", {})  # type: ignore
+        if not main_deps:
+            raise ValueError(f"No main dependencies found in pyproject.toml at '{self._pyproject_path}'.")
+        dep_groups = self._get_solution_dependency_groups(poetry_section)  # type: ignore
+
+        manual_deps: list[ManualDependency] = []
+        for step_dep_group in self._saf_template.dependencies:
+            if step_dep_group != "main" and step_dep_group not in dep_groups:
+                dep_groups[step_dep_group] = self._create_new_dependency_group()
+            group_deps = dep_groups.get(step_dep_group, {}).get("dependencies", {})
+            for step_dep_name, step_dep_spec in self._saf_template.dependencies[step_dep_group].items():
+                if self._find_dependency_in_solution(step_dep_name, main_deps, dep_groups):  # type: ignore
+                    manual_deps.append(
+                        ManualDependency(
+                            name=step_dep_name,
+                            specification=step_dep_spec,
+                            group=step_dep_group,
+                        ),
+                    )
+                else:
+                    self._add_dependency_to_solution(
+                        step_dep_name,
+                        step_dep_spec,
+                        main_deps if step_dep_group == "main" else group_deps,  # type: ignore
+                    )
+
+        self._pyproject_path.write_text(tomlkit.dumps(pyproject_content), newline="")  # type: ignore
+
+        groups = {group for group in self._saf_template.dependencies if group != "main"}
+        if not manual_deps:
+            cmd = [executable.as_posix(), "lock"]
+            subprocess.run(cmd, env=solution_env, cwd=self._solution_root_dir, check=True)
+
+            cmd = [executable.as_posix(), "install"]
+            cmd += ["--with", ",".join(sorted(groups))] if groups else []
+            subprocess.run(cmd, env=solution_env, cwd=self._solution_root_dir, check=True)
+        else:
+            self._render_manual_dependency_warning(manual_deps, groups)