kspl 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

kspl/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.1"
+__version__ = "1.2.0"

kspl/_run.py

@@ -1,9 +1,13 @@
-"""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__")
+"""
+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/config_slurper.py

@@ -1,85 +1,71 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from py_app_dev.core.exceptions import UserNotificationException
-from py_app_dev.core.logging import logger
-
-from kspl.kconfig import EditableConfigElement, KConfig
-
-
-@dataclass
-class VariantViewData:
-    """A variant is a set of configuration values for a KConfig model."""
-
-    name: str
-    config_dict: Dict[str, Any]
-
-
-@dataclass
-class VariantData:
-    name: str
-    config: KConfig
-
-    def find_element(self, element_name: str) -> Optional[EditableConfigElement]:
-        return self.config.find_element(element_name)
-
-
-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)
-        if not self.kconfig_model_file.is_file():
-            raise UserNotificationException(
-                f"File {self.kconfig_model_file} does not exist."
-            )
-        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)]
-        self.logger = logger.bind()
-
-    @property
-    def kconfig_model_file(self) -> Path:
-        return self.project_root_dir / "KConfig"
-
-    def get_elements(self) -> List[EditableConfigElement]:
-        return self.model.elements
-
-    def get_variants(self) -> List[VariantViewData]:
-        variants = []
-
-        for variant in self.variant_configs:
-            variants.append(
-                VariantViewData(
-                    variant.name,
-                    {
-                        config_elem.name: config_elem.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.as_posix()
-
-    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"))
-
-    def find_variant_config(self, variant_name: str) -> Optional[VariantData]:
-        for variant in self.variant_configs:
-            if variant.name == variant_name:
-                return variant
-        return None
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from py_app_dev.core.exceptions import UserNotificationException
+from py_app_dev.core.logging import logger
+
+from kspl.kconfig import EditableConfigElement, KConfig
+
+
+@dataclass
+class VariantViewData:
+    """A variant is a set of configuration values for a KConfig model."""
+
+    name: str
+    config_dict: dict[str, Any]
+
+
+@dataclass
+class VariantData:
+    name: str
+    config: KConfig
+
+    def find_element(self, element_name: str) -> EditableConfigElement | None:
+        return self.config.find_element(element_name)
+
+
+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)
+        if not self.kconfig_model_file.is_file():
+            raise UserNotificationException(f"File {self.kconfig_model_file} does not exist.")
+        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)]
+        self.logger = logger.bind()
+
+    @property
+    def kconfig_model_file(self) -> Path:
+        return self.project_root_dir / "KConfig"
+
+    def get_elements(self) -> list[EditableConfigElement]:
+        return self.model.elements
+
+    def get_variants(self) -> list[VariantViewData]:
+        variants = []
+
+        for variant in self.variant_configs:
+            variants.append(
+                VariantViewData(
+                    variant.name,
+                    {config_elem.name: config_elem.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.as_posix()
+
+    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"))
+
+    def find_variant_config(self, variant_name: str) -> VariantData | None:
+        for variant in self.variant_configs:
+            if variant.name == variant_name:
+                return variant
+        return None

kspl/edit.py

@@ -1,84 +1,71 @@
-from argparse import ArgumentParser, Namespace
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import List, Optional
-
-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 .config_slurper import SPLKConfigData
-from .kconfig import KConfig
-
-
-@dataclass
-class EditCommandConfig(DataClassDictMixin):
-    project_dir: Path = field(
-        default=Path(".").absolute(),
-        metadata={
-            "help": "Project root directory. "
-            "Defaults to the current directory if not specified."
-        },
-    )
-    kconfig_model_file: Optional[Path] = field(
-        default=None, metadata={"help": "KConfig model file (KConfig)."}
-    )
-    kconfig_config_file: Optional[Path] = field(
-        default=None, metadata={"help": "KConfig user configuration file (config.txt)."}
-    )
-
-    @classmethod
-    def from_namespace(cls, namespace: Namespace) -> "EditCommandConfig":
-        return cls.from_dict(vars(namespace))
-
-
-class EditCommand(Command):
-    def __init__(self) -> None:
-        super().__init__("edit", "Edit KConfig configuration.")
-        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 = EditCommandConfig.from_namespace(args)
-        if cmd_config.kconfig_model_file is None:
-            kconfig_data = SPLKConfigData(cmd_config.project_dir)
-            variants = kconfig_data.get_variants()
-            variant_names = [variant.name for variant in variants]
-            selected_variant = self._select_variant(variant_names)
-            if selected_variant is not None:
-                variant_data = kconfig_data.find_variant_config(selected_variant)
-                if variant_data is not None:
-                    variant_data.config.menu_config()
-                else:
-                    self.logger.error(f"Variant {selected_variant} not found.")
-        else:
-            KConfig(
-                cmd_config.kconfig_model_file, cmd_config.kconfig_config_file
-            ).menu_config()
-        return 0
-
-    def _select_variant(self, variant_names: List[str]) -> Optional[str]:
-        """Print the list of variants to choose from and let the user choose one"""
-        selected_variant = None
-        self.logger.info("Select a variant:")
-        for index, variant_name in enumerate(variant_names):
-            self.logger.info(f" [{index + 1}] {variant_name}")
-        while True:
-            try:
-                selected_variant = variant_names[
-                    int(input(f"Select a variant (1-{len(variant_names)}): ")) - 1
-                ]
-                break
-            except (ValueError, IndexError):
-                self.logger.error(
-                    "Invalid input. Please try again or press CTRL+C to abort."
-                )
-            # In case of KeyboardInterrupt (CTRL+C) we want to abort
-            except KeyboardInterrupt:
-                self.logger.warning("Aborted by user.")
-                break
-        return selected_variant
-
-    def _register_arguments(self, parser: ArgumentParser) -> None:
-        register_arguments_for_config_dataclass(parser, EditCommandConfig)
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+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 .config_slurper import SPLKConfigData
+from .kconfig import KConfig
+
+
+@dataclass
+class EditCommandConfig(DataClassDictMixin):
+    project_dir: Path = field(
+        default=Path(".").absolute(),
+        metadata={"help": "Project root directory. Defaults to the current directory if not specified."},
+    )
+    kconfig_model_file: Optional[Path] = field(default=None, metadata={"help": "KConfig model file (KConfig)."})
+    kconfig_config_file: Optional[Path] = field(default=None, metadata={"help": "KConfig user configuration file (config.txt)."})
+
+    @classmethod
+    def from_namespace(cls, namespace: Namespace) -> "EditCommandConfig":
+        return cls.from_dict(vars(namespace))
+
+
+class EditCommand(Command):
+    def __init__(self) -> None:
+        super().__init__("edit", "Edit KConfig configuration.")
+        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 = EditCommandConfig.from_namespace(args)
+        if cmd_config.kconfig_model_file is None:
+            kconfig_data = SPLKConfigData(cmd_config.project_dir)
+            variants = kconfig_data.get_variants()
+            variant_names = [variant.name for variant in variants]
+            selected_variant = self._select_variant(variant_names)
+            if selected_variant is not None:
+                variant_data = kconfig_data.find_variant_config(selected_variant)
+                if variant_data is not None:
+                    variant_data.config.menu_config()
+                else:
+                    self.logger.error(f"Variant {selected_variant} not found.")
+        else:
+            KConfig(cmd_config.kconfig_model_file, cmd_config.kconfig_config_file).menu_config()
+        return 0
+
+    def _select_variant(self, variant_names: list[str]) -> str | None:
+        """Print the list of variants to choose from and let the user choose one."""
+        selected_variant = None
+        self.logger.info("Select a variant:")
+        for index, variant_name in enumerate(variant_names):
+            self.logger.info(f" [{index + 1}] {variant_name}")
+        while True:
+            try:
+                selected_variant = variant_names[int(input(f"Select a variant (1-{len(variant_names)}): ")) - 1]
+                break
+            except (ValueError, IndexError):
+                self.logger.error("Invalid input. Please try again or press CTRL+C to abort.")
+            # In case of KeyboardInterrupt (CTRL+C) we want to abort
+            except KeyboardInterrupt:
+                self.logger.warning("Aborted by user.")
+                break
+        return selected_variant
+
+    def _register_arguments(self, parser: ArgumentParser) -> None:
+        register_arguments_for_config_dataclass(parser, EditCommandConfig)

kspl/generate.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from argparse import ArgumentParser, Namespace
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import kconfiglib
 from mashumaro import DataClassDictMixin
@@ -14,9 +14,7 @@ from kspl.kconfig import ConfigElementType, ConfigurationData, KConfig, TriState
 
 
 class GeneratedFile:
-    def __init__(
-        self, path: Path, content: str = "", skip_writing_if_unchanged: bool = False
-    ) -> None:
+    def __init__(self, path: Path, content: str = "", skip_writing_if_unchanged: bool = False) -> None:
         self.path = path
 
         self.content = content
@@ -27,50 +25,43 @@ class GeneratedFile:
         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."""
-
+        """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
-        ):
+        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"""
+    """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"""
+        """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()
+        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"""
+        """- generates the content of the file from the ConfigurationData."""
 
 
 class HeaderWriter(FileWriter):
-    """Writes the ConfigurationData as pre-processor defines in a C Header file"""
+    """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.
+        """
+        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] = [
+        result: list[str] = [
             "/** @file */",
             "#ifndef __autoconf_h__",
             "#define __autoconf_h__",
@@ -91,17 +82,13 @@ class HeaderWriter(FileWriter):
                     )
                 elif val == TriState.M:
                     add_define(
-                        "#define {}{}_MODULE 1".format(
-                            self.config_prefix, element.name
-                        ),
+                        f"#define {self.config_prefix}{element.name}_MODULE 1",
                         element.name,
                     )
 
             elif element.type is ConfigElementType.STRING:
                 add_define(
-                    '#define {}{} "{}"'.format(
-                        self.config_prefix, element.name, kconfiglib.escape(val)
-                    ),
+                    f'#define {self.config_prefix}{element.name} "{kconfiglib.escape(val)}"',
                     element.name,
                 )
 
@@ -117,7 +104,7 @@ class HeaderWriter(FileWriter):
 
 
 class JsonWriter(FileWriter):
-    """Writes the ConfigurationData in json format"""
+    """Writes the ConfigurationData in json format."""
 
     def generate_content(self, configuration_data: ConfigurationData) -> str:
         result = {}
@@ -130,10 +117,10 @@ class JsonWriter(FileWriter):
 
 
 class CMakeWriter(FileWriter):
-    """Writes the ConfigurationData as CMake variables"""
+    """Writes the ConfigurationData as CMake variables."""
 
     def generate_content(self, configuration_data: ConfigurationData) -> str:
-        result: List[str] = []
+        result: list[str] = []
         add = result.append
         for element in configuration_data.elements:
             val = element.value
@@ -147,12 +134,8 @@ class CMakeWriter(FileWriter):
 @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."}
-    )
+    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."},
@@ -169,18 +152,14 @@ class GenerateCommandConfig(DataClassDictMixin):
 
 class GenerateCommand(Command):
     def __init__(self) -> None:
-        super().__init__(
-            "generate", "Generate the KConfig configuration in the specified formats."
-        )
+        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
-        ).collect_config_data()
+        config = KConfig(cmd_config.kconfig_model_file, cmd_config.kconfig_config_file).collect_config_data()
 
         if cmd_config.out_header_file:
             HeaderWriter(cmd_config.out_header_file).write(config)