kspl 0.1.0__tar.gz

kspl-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2023 Cuinixam
+
+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.

kspl-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: kspl
+Version: 0.1.0
+Summary: KConfig GUI for Software Product Lines with multiple variants.
+Home-page: https://github.com/cuinixam/kspl
+License: MIT
+Author: Cuinixam
+Author-email: cuinixam@me.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: customtkinter (>=5.2.0,<6.0.0)
+Requires-Dist: kconfiglib (>=14.1.0,<15.0.0)
+Requires-Dist: py-app-dev (>=1.0.0,<2.0.0)
+Project-URL: Bug Tracker, https://github.com/cuinixam/kspl/issues
+Project-URL: Changelog, https://github.com/cuinixam/kspl/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://kspl.readthedocs.io
+Project-URL: Repository, https://github.com/cuinixam/kspl
+Description-Content-Type: text/markdown
+
+# SPL KConfig GUI
+
+<p align="center">
+  <a href="https://github.com/cuinixam/kspl/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/cuinixam/kspl/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://kspl.readthedocs.io">
+    <img src="https://img.shields.io/readthedocs/kspl.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
+  </a>
+  <a href="https://codecov.io/gh/cuinixam/kspl">
+    <img src="https://img.shields.io/codecov/c/github/cuinixam/kspl.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://python-poetry.org/">
+    <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
+  </a>
+  <a href="https://github.com/ambv/black">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/kspl/">
+    <img src="https://img.shields.io/pypi/v/kspl.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/kspl.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/kspl.svg?style=flat-square" alt="License">
+</p>
+
+KConfig GUI for Software Product Lines with multiple variants.
+
+## Installation
+
+Install this via pip (or your favourite package manager):
+
+`pip install kspl`
+
+## Start developing
+
+The project uses Poetry for dependencies management and packaging.
+If you do not have Poetry installed, you can run the `boostrap.ps1` script.
+This will install Python and Poetry as configured in `scoopfile.json`.
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope CurrentUser -Force
+.\bootstrap.ps1
+```
+
+To install the development dependencies in a virtual environment, type:
+
+```shell
+poetry install
+```
+
+This will also generate a `poetry.lock` file, you should track this file in version control. To execute the test suite, call pytest inside Poetry's virtual environment via `poetry run`:
+
+```shell
+poetry run pytest
+```
+
+Check out the Poetry documentation for more information on the available commands.
+
+For those using [VS Code](https://code.visualstudio.com/) there are tasks defined for the most common commands:
+
+- install development dependencies
+- run tests
+- run all checks configured for pre-commit
+- generate documentation
+
+See the `.vscode/tasks.json` for more details.
+
+## Committing changes
+
+This repository uses [commitlint](https://github.com/conventional-changelog/commitlint) for checking if the commit message meets the [conventional commit format](https://www.conventionalcommits.org/en).
+
+## Contributors ✨
+
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- prettier-ignore-start -->
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- markdownlint-disable -->
+<!-- markdownlint-enable -->
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+<!-- prettier-ignore-end -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+## Credits
+
+This package was created with
+[Copier](https://copier.readthedocs.io/) and the
+[browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
+project template.
+

kspl-0.1.0/README.md

@@ -0,0 +1,97 @@
+# SPL KConfig GUI
+
+<p align="center">
+  <a href="https://github.com/cuinixam/kspl/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/cuinixam/kspl/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://kspl.readthedocs.io">
+    <img src="https://img.shields.io/readthedocs/kspl.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
+  </a>
+  <a href="https://codecov.io/gh/cuinixam/kspl">
+    <img src="https://img.shields.io/codecov/c/github/cuinixam/kspl.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://python-poetry.org/">
+    <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
+  </a>
+  <a href="https://github.com/ambv/black">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/kspl/">
+    <img src="https://img.shields.io/pypi/v/kspl.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/kspl.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/kspl.svg?style=flat-square" alt="License">
+</p>
+
+KConfig GUI for Software Product Lines with multiple variants.
+
+## Installation
+
+Install this via pip (or your favourite package manager):
+
+`pip install kspl`
+
+## Start developing
+
+The project uses Poetry for dependencies management and packaging.
+If you do not have Poetry installed, you can run the `boostrap.ps1` script.
+This will install Python and Poetry as configured in `scoopfile.json`.
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope CurrentUser -Force
+.\bootstrap.ps1
+```
+
+To install the development dependencies in a virtual environment, type:
+
+```shell
+poetry install
+```
+
+This will also generate a `poetry.lock` file, you should track this file in version control. To execute the test suite, call pytest inside Poetry's virtual environment via `poetry run`:
+
+```shell
+poetry run pytest
+```
+
+Check out the Poetry documentation for more information on the available commands.
+
+For those using [VS Code](https://code.visualstudio.com/) there are tasks defined for the most common commands:
+
+- install development dependencies
+- run tests
+- run all checks configured for pre-commit
+- generate documentation
+
+See the `.vscode/tasks.json` for more details.
+
+## Committing changes
+
+This repository uses [commitlint](https://github.com/conventional-changelog/commitlint) for checking if the commit message meets the [conventional commit format](https://www.conventionalcommits.org/en).
+
+## Contributors ✨
+
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- prettier-ignore-start -->
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- markdownlint-disable -->
+<!-- markdownlint-enable -->
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+<!-- prettier-ignore-end -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+## Credits
+
+This package was created with
+[Copier](https://copier.readthedocs.io/) and the
+[browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
+project template.

kspl-0.1.0/pyproject.toml

@@ -0,0 +1,113 @@
+[tool.poetry]
+name = "kspl"
+version = "0.1.0"
+description = "KConfig GUI for Software Product Lines with multiple variants."
+authors = ["Cuinixam <cuinixam@me.com>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/cuinixam/kspl"
+documentation = "https://kspl.readthedocs.io"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+]
+packages = [
+    { include = "kspl", from = "src" },
+]
+
+[tool.poetry.scripts]
+kspl = "kspl.main:main"
+
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/cuinixam/kspl/issues"
+"Changelog" = "https://github.com/cuinixam/kspl/blob/main/CHANGELOG.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+customtkinter = "^5.2.0"
+kconfiglib = "^14.1.0"
+py-app-dev = "^1.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.0"
+pytest-cov = "^4.0"
+black = "^23.1.0"
+pre-commit = "^3.1.1"
+
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.docs.dependencies]
+myst-parser = ">=0.16"
+sphinx = ">=4.0"
+sphinx-rtd-theme = ">=1.0"
+m2r = "^0.3.1"
+sphinxcontrib-mermaid = "^0.8.1"
+
+[tool.semantic_release]
+branch = "main"
+version_toml = "pyproject.toml:tool.poetry.version"
+version_variable = "src/kspl/__init__.py:__version__"
+build_command = "pip install poetry && poetry build"
+
+[tool.semantic_release.changelog]
+exclude_commit_patterns = [
+    "chore*",
+    "ci*",
+]
+
+[tool.semantic_release.changelog.environment]
+keep_trailing_newline = true
+
+[tool.pytest.ini_options]
+addopts = "-v -Wdefault --cov=kspl --cov-report=term-missing:skip-covered -s"
+pythonpath = ["src"]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "@overload",
+    "if TYPE_CHECKING",
+    "raise NotImplementedError",
+    'if __name__ == "__main__":',
+]
+
+[tool.isort]
+profile = "black"
+known_first_party = ["kspl", "tests"]
+
+[tool.mypy]
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+mypy_path = "src/"
+no_implicit_optional = true
+show_error_codes = true
+warn_unreachable = true
+warn_unused_ignores = true
+exclude = [
+    'docs/.*',
+    'setup.py',
+]
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+allow_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = "docs.*"
+ignore_errors = true
+
+[tool.codespell]
+skip = '*.lock'
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

kspl-0.1.0/src/kspl/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

kspl-0.1.0/src/kspl/_run.py

@@ -0,0 +1,9 @@
+"""Used to run main from the command line when run from this repository.
+This is required because kspl module is not visible when running
+from the repository."""
+import runpy
+import sys
+from pathlib import Path
+
+sys.path.insert(0, Path(__file__).parent.parent.absolute().as_posix())
+runpy.run_module("kspl.main", run_name="__main__")

kspl-0.1.0/src/kspl/generate.py

@@ -0,0 +1,194 @@
+import json
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+import kconfiglib
+from mashumaro import DataClassDictMixin
+from py_app_dev.core.cmd_line import Command, register_arguments_for_config_dataclass
+from py_app_dev.core.logging import logger, time_it
+
+from kspl.kconfig import ConfigElementType, ConfigurationData, KConfig, TriState
+
+
+class GeneratedFile:
+    def __init__(
+        self, path: Path, content: str = "", skip_writing_if_unchanged: bool = False
+    ) -> None:
+        self.path = path
+
+        self.content = content
+
+        self.skip_writing_if_unchanged = skip_writing_if_unchanged
+
+    def to_string(self) -> str:
+        return self.content
+
+    def to_file(self) -> None:
+        """Only write to file if the content has changed.
+        The directory of the file is created if it does not exist."""
+
+        content = self.to_string()
+
+        if (
+            not self.path.exists()
+            or not self.skip_writing_if_unchanged
+            or self.path.read_text() != content
+        ):
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(content)
+
+
+class FileWriter(ABC):
+    """- writes the ConfigurationData to a file"""
+
+    def __init__(self, output_file: Path):
+        self.output_file = output_file
+
+    def write(self, configuration_data: ConfigurationData) -> None:
+        """- writes the ConfigurationData to a file
+        The file shall not be modified if the content is the same as the existing one"""
+        content = self.generate_content(configuration_data)
+        GeneratedFile(
+            self.output_file, content, skip_writing_if_unchanged=True
+        ).to_file()
+
+    @abstractmethod
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        """- generates the content of the file from the ConfigurationData"""
+
+
+class HeaderWriter(FileWriter):
+    """Writes the ConfigurationData as pre-processor defines in a C Header file"""
+
+    config_prefix = "CONFIG_"  # Prefix for all configuration defines
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        """This method does exactly what the kconfiglib.write_autoconf() method does.
+        We had to implemented here because we refactor the file writers to use the ConfigurationData
+        instead of the KConfig configuration. ConfigurationData has variable substitution already done.
+        """
+        result: List[str] = [
+            "/** @file */",
+            "#ifndef __autoconf_h__",
+            "#define __autoconf_h__",
+            "",
+        ]
+
+        def add_define(define_decl: str, description: str) -> None:
+            result.append(f"/** {description} */")
+            result.append(define_decl)
+
+        for element in configuration_data.elements:
+            val = element.value
+            if element.type in [ConfigElementType.BOOL, ConfigElementType.TRISTATE]:
+                if val == TriState.Y:
+                    add_define(
+                        f"#define {self.config_prefix}{element.name} 1",
+                        element.name,
+                    )
+                elif val == TriState.M:
+                    add_define(
+                        "#define {}{}_MODULE 1".format(
+                            self.config_prefix, element.name
+                        ),
+                        element.name,
+                    )
+
+            elif element.type is ConfigElementType.STRING:
+                add_define(
+                    '#define {}{} "{}"'.format(
+                        self.config_prefix, element.name, kconfiglib.escape(val)
+                    ),
+                    element.name,
+                )
+
+            else:  # element.type in [INT, HEX]:
+                if element.type is ConfigElementType.HEX:
+                    val = hex(val)
+                add_define(
+                    f"#define {self.config_prefix}{element.name} {val}",
+                    element.name,
+                )
+        result.extend(["", "#endif /* __autoconf_h__ */", ""])
+        return "\n".join(result)
+
+
+class JsonWriter(FileWriter):
+    """Writes the ConfigurationData in json format"""
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        result = {}
+        for element in configuration_data.elements:
+            if element.type is ConfigElementType.BOOL:
+                result[element.name] = True if element.value == TriState.Y else False
+            else:
+                result[element.name] = element.value
+        return json.dumps({"features": result}, indent=4)
+
+
+class CMakeWriter(FileWriter):
+    """Writes the ConfigurationData as CMake variables"""
+
+    def generate_content(self, configuration_data: ConfigurationData) -> str:
+        result: List[str] = []
+        add = result.append
+        for element in configuration_data.elements:
+            val = element.value
+            if element.type is ConfigElementType.BOOL:
+                val = True if element.value == TriState.Y else False
+            add(f'set({element.name} "{val}")')
+
+        return "\n".join(result)
+
+
+@dataclass
+class GenerateCommandConfig(DataClassDictMixin):
+    kconfig_model_file: Path = field(metadata={"help": "KConfig model file (KConfig)."})
+    kconfig_config_file: Optional[Path] = field(
+        default=None, metadata={"help": "KConfig user configuration file (config.txt)."}
+    )
+    out_header_file: Optional[Path] = field(
+        default=None, metadata={"help": "File to write the configuration as C header."}
+    )
+    out_json_file: Optional[Path] = field(
+        default=None,
+        metadata={"help": "File to write the configuration in JSON format."},
+    )
+    out_cmake_file: Optional[Path] = field(
+        default=None,
+        metadata={"help": "File to write the configuration in CMake format."},
+    )
+
+    @classmethod
+    def from_namespace(cls, namespace: Namespace) -> "GenerateCommandConfig":
+        return cls.from_dict(vars(namespace))
+
+
+class GenerateCommand(Command):
+    def __init__(self) -> None:
+        super().__init__(
+            "generate", "Generate the KConfig configuration in the specified formats."
+        )
+        self.logger = logger.bind()
+
+    @time_it("Build")
+    def run(self, args: Namespace) -> int:
+        self.logger.info(f"Running {self.name} with args {args}")
+        cmd_config = GenerateCommandConfig.from_namespace(args)
+        config = KConfig(
+            cmd_config.kconfig_model_file, cmd_config.kconfig_config_file
+        ).config
+
+        if cmd_config.out_header_file:
+            HeaderWriter(cmd_config.out_header_file).write(config)
+        if cmd_config.out_json_file:
+            JsonWriter(cmd_config.out_json_file).write(config)
+        if cmd_config.out_cmake_file:
+            CMakeWriter(cmd_config.out_cmake_file).write(config)
+        return 0
+
+    def _register_arguments(self, parser: ArgumentParser) -> None:
+        register_arguments_for_config_dataclass(parser, GenerateCommandConfig)

kspl-0.1.0/src/kspl/gui.py

@@ -0,0 +1,338 @@
+import tkinter
+from abc import abstractmethod
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from pathlib import Path
+from tkinter import simpledialog, ttk
+from typing import Any, Dict, List
+
+import customtkinter
+from mashumaro import DataClassDictMixin
+from py_app_dev.core.cmd_line import Command, register_arguments_for_config_dataclass
+from py_app_dev.core.logging import logger, time_it
+from py_app_dev.mvp.event_manager import EventID, EventManager
+from py_app_dev.mvp.presenter import Presenter
+from py_app_dev.mvp.view import View
+
+from kspl.kconfig import KConfig
+
+
+class ConfigElementType(Enum):
+    MENU = auto()
+    CONFIG = auto()
+
+
+@dataclass
+class ConfigElementViewData:
+    name: str
+    level: int
+    type: ConfigElementType
+
+
+@dataclass
+class VariantViewData:
+    """A variant is a set of configuration values for a KConfig model."""
+
+    name: str
+    config_dict: Dict[str, int | str | bool]
+
+
+class KSplEvents(EventID):
+    EDIT = auto()
+
+
+class CTkView(View):
+    @abstractmethod
+    def mainloop(self) -> None:
+        pass
+
+
+class MainView(CTkView):
+    def __init__(
+        self,
+        event_manager: EventManager,
+        elements: List[ConfigElementViewData],
+        variants: List[VariantViewData],
+    ) -> None:
+        self.event_manager = event_manager
+        self.elements = elements
+        self.variants = variants
+        self.root = customtkinter.CTk()
+
+        # Configure the main window
+        self.root.title("K-SPL")
+        self.root.geometry(f"{1080}x{580}")
+
+        # ========================================================
+        # create tabview and populate with frames
+        tabview = customtkinter.CTkTabview(self.root)
+        self.tree = self.create_tree_view(tabview.add("Configuration"))
+        self.tree["columns"] = tuple(variant.name for variant in self.variants)
+        self.tree.heading("#0", text="Configuration")
+        for variant in self.variants:
+            self.tree.heading(variant.name, text=variant.name)
+        # Keep track of the mapping between the tree view items and the config elements
+        self.tree_view_items_mapping = self.populate_tree_view()
+        self.tree.pack(fill="both", expand=True)
+        self.tree.bind("<Double-1>", self.double_click_handler)
+
+        # ========================================================
+        # put all together
+        self.root.grid_columnconfigure(0, weight=1)
+        self.root.grid_rowconfigure(0, weight=1)
+        tabview.grid(row=0, column=0, sticky="nsew")
+
+    def mainloop(self) -> None:
+        self.root.mainloop()
+
+    def create_tree_view(self, frame: customtkinter.CTkFrame) -> ttk.Treeview:
+        frame.grid_rowconfigure(0, weight=10)
+        frame.grid_rowconfigure(1, weight=1)
+        frame.grid_columnconfigure(0, weight=1)
+
+        columns = [var.name for var in self.variants]
+
+        style = ttk.Style()
+        style.configure(
+            "mystyle.Treeview", highlightthickness=0, bd=0, font=("Calibri", 14)
+        )  # Modify the font of the body
+        style.configure(
+            "mystyle.Treeview.Heading", font=("Calibri", 14, "bold")
+        )  # Modify the font of the headings
+
+        # create a Treeview widget
+        config_treeview = ttk.Treeview(
+            frame,
+            columns=columns,
+            show="tree headings",
+            style="mystyle.Treeview",
+        )
+        config_treeview.grid(row=0, column=0, sticky="nsew")
+        return config_treeview
+
+    def populate_tree_view(self) -> Dict[str, str]:
+        """
+        Populates the tree view with the configuration elements.
+        :return: a mapping between the tree view items and the configuration elements
+        """
+        stack = []  # To keep track of the parent items
+        last_level = -1
+        mapping: Dict[str, str] = {}
+
+        for element in self.elements:
+            values = self.collect_values_for_element(element)
+            if element.level == 0:
+                # Insert at the root level
+                item_id = self.tree.insert("", "end", text=element.name, values=values)
+                stack = [item_id]  # Reset the stack with the root item
+            elif element.level > last_level:
+                # Insert as a child of the last inserted item
+                item_id = self.tree.insert(
+                    stack[-1], "end", text=element.name, values=values
+                )
+                stack.append(item_id)
+            elif element.level == last_level:
+                # Insert at the same level as the last item
+                item_id = self.tree.insert(
+                    stack[-2], "end", text=element.name, values=values
+                )
+                stack[-1] = item_id  # Replace the top item in the stack
+            else:
+                # Go up in the hierarchy and insert at the appropriate level
+                item_id = self.tree.insert(
+                    stack[element.level - 1], "end", text=element.name, values=values
+                )
+                stack = stack[: element.level] + [item_id]
+
+            last_level = element.level
+            mapping[item_id] = element.name
+        return mapping
+
+    def collect_values_for_element(
+        self, element: ConfigElementViewData
+    ) -> List[int | str]:
+        return (
+            [
+                self.prepare_value_to_be_displayed(
+                    variant.config_dict.get(element.name, None)
+                )
+                for variant in self.variants
+            ]
+            if element.type == ConfigElementType.CONFIG
+            else []
+        )
+
+    def prepare_value_to_be_displayed(self, value: Any) -> str:
+        if value is None:
+            return "N/A"
+        elif isinstance(value, bool):
+            return "✅" if value else "⛔"
+        else:
+            return str(value)
+
+    def double_click_handler(self, event: tkinter.Event) -> None:  # type: ignore
+        current_selection = self.tree.selection()
+        if not current_selection:
+            return
+
+        selected_item = current_selection[0]
+        elem_name = self.tree_view_items_mapping[selected_item]
+
+        variant_idx_str = self.tree.identify_column(event.x)  # Get the clicked column
+        variant_idx = (
+            int(variant_idx_str.split("#")[-1]) - 1
+        )  # Convert to 0-based index
+
+        if variant_idx < 0 or variant_idx >= len(self.variants):
+            return
+
+        selected_variant = self.variants[variant_idx]
+        selected_value = selected_variant.config_dict[elem_name]
+
+        if selected_value is not None:
+            new_value = selected_value
+            if isinstance(selected_value, bool):
+                # Toggle the boolean value
+                new_value = not selected_value
+            elif isinstance(selected_value, int):
+                tmp_int_value = simpledialog.askinteger(
+                    "Enter new value", "Enter new value", initialvalue=selected_value
+                )
+                if tmp_int_value is not None:
+                    new_value = tmp_int_value
+            elif isinstance(selected_value, str):
+                # Prompt the user to enter a new string value using messagebox
+                tmp_str_value = simpledialog.askstring(
+                    "Enter new value", "Enter new value", initialvalue=selected_value
+                )
+                if tmp_str_value is not None:
+                    new_value = tmp_str_value
+
+            selected_variant.config_dict[elem_name] = new_value
+
+            # Update the Treeview
+            values = list(
+                self.tree.item(selected_item, "values")
+            )  # Get the current values of the selected item
+            values[variant_idx] = self.prepare_value_to_be_displayed(new_value)
+            self.tree.item(selected_item, values=values)
+
+
+@dataclass
+class VariantData:
+    name: str
+    config: KConfig
+
+
+class SPLKConfigData:
+    def __init__(self, project_root_dir: Path) -> None:
+        self.project_root_dir = project_root_dir.absolute()
+        variant_config_files = self._search_variant_config_file(self.project_root_dir)
+        self.model = KConfig(self.kconfig_model_file)
+        if variant_config_files:
+            self.variant_configs: List[VariantData] = [
+                VariantData(
+                    self._get_variant_name(file), KConfig(self.kconfig_model_file, file)
+                )
+                for file in variant_config_files
+            ]
+        else:
+            self.variant_configs = [VariantData("Default", self.model)]
+
+    @property
+    def kconfig_model_file(self) -> Path:
+        return self.project_root_dir / "KConfig"
+
+    def get_elements(self) -> List[ConfigElementViewData]:
+        elements = []
+        for elem in self.model.elements:
+            elements.append(
+                ConfigElementViewData(
+                    elem.name,
+                    elem.level,
+                    ConfigElementType.MENU
+                    if elem.is_menu
+                    else ConfigElementType.CONFIG,
+                )
+            )
+        return elements
+
+    def get_variants(self) -> List[VariantViewData]:
+        variants = []
+
+        for variant in self.variant_configs:
+            variants.append(
+                VariantViewData(
+                    variant.name,
+                    {
+                        config_elem.name: config_elem.raw_value
+                        for config_elem in variant.config.elements
+                        if not config_elem.is_menu
+                    },
+                )
+            )
+        return variants
+
+    def _get_variant_name(self, file: Path) -> str:
+        return file.relative_to(self.project_root_dir / "variants").parent.name
+
+    def _search_variant_config_file(self, project_dir: Path) -> List[Path]:
+        """
+        Finds all files called 'config.txt' in the variants directory
+        and returns a list with their paths.
+        """
+        return list((project_dir / "variants").glob("**/config.txt"))
+
+
+class KSPL(Presenter):
+    def __init__(self, event_manager: EventManager, project_dir: Path) -> None:
+        self.event_manager = event_manager
+        self.event_manager.subscribe(KSplEvents.EDIT, self.edit)
+        self.counter = 0
+        self.logger = logger.bind()
+        self.kconfig_data = SPLKConfigData(project_dir)
+        self.view = MainView(
+            self.event_manager,
+            self.kconfig_data.get_elements(),
+            self.kconfig_data.get_variants(),
+        )
+
+    def edit(self) -> None:
+        self.counter += 1
+        self.logger.info(f"Counter: {self.counter}")
+
+    def run(self) -> None:
+        self.view.mainloop()
+
+
+@dataclass
+class GuiCommandConfig(DataClassDictMixin):
+    project_dir: Path = field(
+        default=Path(".").absolute(),
+        metadata={
+            "help": "Project root directory. "
+            "Defaults to the current directory if not specified."
+        },
+    )
+
+    @classmethod
+    def from_namespace(cls, namespace: Namespace) -> "GuiCommandConfig":
+        return cls.from_dict(vars(namespace))
+
+
+class GuiCommand(Command):
+    def __init__(self) -> None:
+        super().__init__("gui", "Start the GUI for SPL configuration.")
+        self.logger = logger.bind()
+
+    @time_it("Build")
+    def run(self, args: Namespace) -> int:
+        self.logger.info(f"Running {self.name} with args {args}")
+        config = GuiCommandConfig.from_namespace(args)
+        event_manager = EventManager()
+        KSPL(event_manager, config.project_dir.absolute()).run()
+        return 0
+
+    def _register_arguments(self, parser: ArgumentParser) -> None:
+        register_arguments_for_config_dataclass(parser, GuiCommandConfig)

kspl-0.1.0/src/kspl/kconfig.py

@@ -0,0 +1,221 @@
+import os
+import re
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, Generator, List, Optional
+
+import kconfiglib
+from kconfiglib import MenuNode
+
+
+class TriState(Enum):
+    Y = auto()
+    M = auto()
+    N = auto()
+
+
+class ConfigElementType(Enum):
+    UNKNOWN = auto()
+    BOOL = auto()
+    TRISTATE = auto()
+    STRING = auto()
+    INT = auto()
+    HEX = auto()
+    MENU = auto()
+
+
+@dataclass
+class ConfigElement:
+    type: ConfigElementType
+    name: str
+    value: Any
+
+    @property
+    def is_menu(self) -> bool:
+        return self.type == ConfigElementType.MENU
+
+    @property
+    def raw_value(self) -> int | str | bool:
+        value = self.value
+        if self.type == ConfigElementType.BOOL:
+            value = self.value == TriState.Y
+        elif self.type == ConfigElementType.TRISTATE:
+            value = str(self.value)
+        elif self.type == ConfigElementType.HEX:
+            value = hex(self.value)
+        return value
+
+
+@dataclass
+class EditableConfigElement(ConfigElement):
+    original_value: Any
+
+    #: The level of the menu this element is in. 0 is the top level.
+    level: int = 0
+    #: Is determined when the value is calculated. This is a hidden function call due to property magic.
+    write_to_conf: bool = True
+
+    @property
+    def id(self) -> str:
+        return self.name
+
+    @property
+    def has_been_changed(self) -> bool:
+        return self.original_value != self.value
+
+
+@dataclass
+class ConfigurationData:
+    """Holds the variant configuration data which is relevant for the code generation
+    Requires no variable substitution (this should have been already done)"""
+
+    elements: List[ConfigElement]
+
+
+@contextmanager
+def working_directory(some_directory: Path) -> Generator[None, Any, None]:
+    current_directory = Path().absolute()
+    try:
+        os.chdir(some_directory)
+        yield
+    finally:
+        os.chdir(current_directory)
+
+
+class KConfig:
+    def __init__(
+        self,
+        k_config_model_file: Path,
+        k_config_file: Optional[Path] = None,
+        k_config_root_directory: Optional[Path] = None,
+    ):
+        """
+        :param k_config_model_file: Feature model definition (KConfig format)
+        :param k_config_file: User feature selection configuration file
+        :param k_config_root_directory: all paths for the included configuration paths shall be relative to this folder
+        """
+        if not k_config_model_file.is_file():
+            raise FileNotFoundError(f"File {k_config_model_file} does not exist.")
+        with working_directory(k_config_root_directory or k_config_model_file.parent):
+            self._config = kconfiglib.Kconfig(k_config_model_file.absolute().as_posix())
+        if k_config_file:
+            if not k_config_file.is_file():
+                raise FileNotFoundError(f"File {k_config_file} does not exist.")
+            self._config.load_config(k_config_file, replace=False)
+        self.elements = self._collect_elements()
+        self.config = self._create_config_data()
+
+    def _create_config_data(self) -> ConfigurationData:
+        """- creates the ConfigurationData from the KConfig configuration"""
+        elements = self.elements
+        elements_dict = {element.id: element for element in elements}
+
+        # replace text in KConfig with referenced variables (string type only)
+        # KConfig variables get replaced like: ${VARIABLE_NAME}, e.g. ${CONFIG_FOO}
+        for element in elements:
+            if element.type == ConfigElementType.STRING:
+                element.value = re.sub(
+                    r"\$\{([A-Za-z0-9_]+)\}",
+                    lambda m: str(elements_dict[m.group(1)].value),
+                    element.value,
+                )
+                element.value = re.sub(
+                    r"\$\{ENV:([A-Za-z0-9_]+)\}",
+                    lambda m: str(os.environ.get(m.group(1), "")),
+                    element.value,
+                )
+
+        return ConfigurationData(
+            [
+                ConfigElement(elem.type, elem.name, elem.value)
+                for elem in elements
+                if elem.type != ConfigElementType.MENU
+            ]
+        )
+
+    def _collect_elements(self) -> List[EditableConfigElement]:
+        elements: List[EditableConfigElement] = []
+
+        def convert_to_element(
+            node: MenuNode, level: int
+        ) -> Optional[EditableConfigElement]:
+            # TODO: Symbols like 'choice' and 'comment' shall be ignored.
+            element = None
+            sym = node.item
+            if isinstance(sym, kconfiglib.Symbol):
+                if sym.config_string:
+                    val = sym.str_value
+                    type = ConfigElementType.STRING
+                    if sym.type in [kconfiglib.BOOL, kconfiglib.TRISTATE]:
+                        val = getattr(TriState, str(val).upper())
+                        type = (
+                            ConfigElementType.BOOL
+                            if sym.type == kconfiglib.BOOL
+                            else ConfigElementType.TRISTATE
+                        )
+                    elif sym.type == kconfiglib.HEX:
+                        val = int(str(val), 16)
+                        type = ConfigElementType.HEX
+                    elif sym.type == kconfiglib.INT:
+                        val = int(val)
+                        type = ConfigElementType.INT
+                    element = EditableConfigElement(
+                        type=type,
+                        name=sym.name,
+                        value=val,
+                        original_value=val,
+                        level=level,
+                        write_to_conf=sym._write_to_conf,
+                    )
+            else:
+                if isinstance(node, kconfiglib.MenuNode):
+                    element = EditableConfigElement(
+                        type=ConfigElementType.MENU,
+                        name=node.prompt[0],
+                        value=None,
+                        original_value=None,
+                        level=level,
+                        write_to_conf=False,
+                    )
+            return element
+
+        def _shown_full_nodes(node: MenuNode) -> List[MenuNode]:
+            # Returns the list of menu nodes shown in 'menu' (a menu node for a menu)
+            # for full-tree mode. A tricky detail is that invisible items need to be
+            # shown if they have visible children.
+
+            def rec(node: MenuNode) -> List[MenuNode]:
+                res = []
+
+                while node:
+                    res.append(node)
+                    if node.list and isinstance(node.item, kconfiglib.Symbol):
+                        # Nodes from menu created from dependencies
+                        res += rec(node.list)
+                    node = node.next
+
+                return res
+
+            return rec(node.list)
+
+        def create_elements_tree(
+            node: MenuNode, collected_nodes: List[EditableConfigElement], level: int = 0
+        ) -> None:
+            # Updates the tree starting from menu.list, in full-tree mode. To speed
+            # things up, only open menus are updated. The menu-at-a-time logic here is
+            # to deal with invisible items that can show up outside show-all mode (see
+            # _shown_full_nodes()).
+
+            for node in _shown_full_nodes(node):
+                element = convert_to_element(node, level)
+                if element:
+                    collected_nodes.append(element)
+                # _shown_full_nodes() includes nodes from menus rooted at symbols, so
+                # we only need to check "real" menus/choices here
+                if node.list and not isinstance(node.item, kconfiglib.Symbol):
+                    create_elements_tree(node, collected_nodes, level + 1)
+
+        create_elements_tree(self._config.top_node, elements)
+        return elements

kspl-0.1.0/src/kspl/main.py

@@ -0,0 +1,38 @@
+import sys
+from argparse import ArgumentParser
+from sys import argv
+
+from py_app_dev.core.cmd_line import CommandLineHandlerBuilder
+from py_app_dev.core.exceptions import UserNotificationException
+from py_app_dev.core.logging import logger, setup_logger
+
+from kspl import __version__
+from kspl.generate import GenerateCommand
+from kspl.gui import GuiCommand
+
+
+def do_run() -> None:
+    parser = ArgumentParser(
+        prog="kspl", description="kconfig for SPL", exit_on_error=False
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    builder = CommandLineHandlerBuilder(parser)
+    builder.add_commands([GuiCommand(), GenerateCommand()])
+    handler = builder.create()
+    handler.run(argv[1:])
+
+
+def main() -> int:
+    try:
+        setup_logger()
+        do_run()
+    except UserNotificationException as e:
+        logger.error(f"{e}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())