powertrain-build 1.13.1__py3-none-any.whl → 1.13.3.dev3__py3-none-any.whl

powertrain_build/xlrd_csv.py

@@ -1,87 +1,87 @@
-# Copyright 2024 Volvo Car Corporation
-# Licensed under Apache 2.0.
-
-"""Module for providing an xlrd interface for csv files.
-
-TODO: Handle sheet names in a better way!
-"""
-
-import csv
-import os
-import re
-
-
-class WorkBook:
-    """Emulate xlrd of csv files."""
-
-    def __init__(self, csv_files):
-        """Init."""
-        self._worksheets = {}
-        self._read_csv_files_to_worksheets(csv_files)
-
-    def _read_csv_files_to_worksheets(self, csv_files):
-        """Read CSV-files, and store them as worksheets."""
-        csv_files = [csv_files] if isinstance(csv_files, str) else csv_files
-        if len(csv_files) > 1:
-            for file_ in csv_files:
-                sheet_name = re.match(r'.*?\w*_([\w\$]+)\.\w+', file_).group(1)
-                self._worksheets[sheet_name] = WorkSheet(sheet_name, file_)
-        else:
-            _, sheet_name = os.path.split(csv_files[0])
-            self._worksheets[sheet_name] = WorkSheet(sheet_name, csv_files[0])
-
-    def sheet_by_name(self, name):
-        """Get a worksheet name from a workbook class."""
-        return self._worksheets[name]
-
-    def single_sheet(self):
-        """Get single worksheet if only one file was read."""
-        return next(iter(self._worksheets.values())) if len(self._worksheets) == 1 else None
-
-
-class WorkSheet:
-    """Emulate xlrd for csv files."""
-
-    def __init__(self, sheet_name, file_name):
-        """Init."""
-        self._sheet_name = sheet_name
-        self._read_work_sheet(file_name)
-
-    def _read_work_sheet(self, file_name):
-        """Read csv-file as a worksheet."""
-        with open(file_name, 'r', encoding="ISO-8859-1") as csvfile:
-            reader = csv.reader(csvfile, delimiter=';')
-            self._rows = [[Data(elem) for elem in row] for row in reader]
-            self._nrows = len(self._rows)
-
-    @property
-    def nrows(self):
-        """Get number of rows in a worksheet."""
-        return self._nrows
-
-    def row(self, row):
-        """Get row from sheet."""
-        return self._rows[row]
-
-
-class Data:
-    """Class for wrapping data in a worksheet."""
-
-    def __init__(self, value):
-        """Init."""
-        # TODO: Investigate quoting string values when exporting to CSV
-        if re.fullmatch('[+-]?[0-9]+', value):
-            self._value = int(value)
-        elif re.fullmatch('[+-]?[0-9.]+', value):
-            self._value = float(value)
-        else:
-            self._value = value
-
-    def __repr__(self):
-        """Get representation of object."""
-        return self._value
-
-    @property
-    def value(self):
-        """Provide the value of the data object."""
-        return self._value
+# Copyright 2024 Volvo Car Corporation
+# Licensed under Apache 2.0.
+
+"""Module for providing an xlrd interface for csv files.
+
+TODO: Handle sheet names in a better way!
+"""
+
+import csv
+import os
+import re
+
+
+class WorkBook:
+    """Emulate xlrd of csv files."""
+
+    def __init__(self, csv_files):
+        """Init."""
+        self._worksheets = {}
+        self._read_csv_files_to_worksheets(csv_files)
+
+    def _read_csv_files_to_worksheets(self, csv_files):
+        """Read CSV-files, and store them as worksheets."""
+        csv_files = [csv_files] if isinstance(csv_files, str) else csv_files
+        if len(csv_files) > 1:
+            for file_ in csv_files:
+                sheet_name = re.match(r'.*?\w*_([\w\$]+)\.\w+', file_).group(1)
+                self._worksheets[sheet_name] = WorkSheet(sheet_name, file_)
+        else:
+            _, sheet_name = os.path.split(csv_files[0])
+            self._worksheets[sheet_name] = WorkSheet(sheet_name, csv_files[0])
+
+    def sheet_by_name(self, name):
+        """Get a worksheet name from a workbook class."""
+        return self._worksheets[name]
+
+    def single_sheet(self):
+        """Get single worksheet if only one file was read."""
+        return next(iter(self._worksheets.values())) if len(self._worksheets) == 1 else None
+
+
+class WorkSheet:
+    """Emulate xlrd for csv files."""
+
+    def __init__(self, sheet_name, file_name):
+        """Init."""
+        self._sheet_name = sheet_name
+        self._read_work_sheet(file_name)
+
+    def _read_work_sheet(self, file_name):
+        """Read csv-file as a worksheet."""
+        with open(file_name, 'r', encoding="ISO-8859-1") as csvfile:
+            reader = csv.reader(csvfile, delimiter=';')
+            self._rows = [[Data(elem) for elem in row] for row in reader]
+            self._nrows = len(self._rows)
+
+    @property
+    def nrows(self):
+        """Get number of rows in a worksheet."""
+        return self._nrows
+
+    def row(self, row):
+        """Get row from sheet."""
+        return self._rows[row]
+
+
+class Data:
+    """Class for wrapping data in a worksheet."""
+
+    def __init__(self, value):
+        """Init."""
+        # TODO: Investigate quoting string values when exporting to CSV
+        if re.fullmatch('[+-]?[0-9]+', value):
+            self._value = int(value)
+        elif re.fullmatch('[+-]?[0-9.]+', value):
+            self._value = float(value)
+        else:
+            self._value = value
+
+    def __repr__(self):
+        """Get representation of object."""
+        return self._value
+
+    @property
+    def value(self):
+        """Provide the value of the data object."""
+        return self._value

powertrain_build/zone_controller/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Volvo Car Corporation
-# Licensed under Apache 2.0.
-
-"""powertrain_build.zone_controller."""
+# Copyright 2024 Volvo Car Corporation
+# Licensed under Apache 2.0.
+
+"""powertrain_build.zone_controller."""

powertrain_build/zone_controller/calibration.py

@@ -1,176 +1,176 @@
-# Copyright 2024 Volvo Car Corporation
-# Licensed under Apache 2.0.
-
-"""Module for handling ZoneController calibration."""
-
-import re
-from pathlib import Path
-from powertrain_build.problem_logger import ProblemLogger
-
-
-class ZoneControllerCalibration(ProblemLogger):
-    """Class for handling ZoneController calibration."""
-
-    calibration_function_init_template = '{swc_name}_ZcCalibrationInit'
-    calibration_function_step_template = '{swc_name}_ZcCalibrationStep'
-    trigger_read_rte_cdata_signal = {
-        'name_template': 'c{swc_name}_TriggerReadRteCData',
-        'data_type': 'Float32'
-    }
-
-    def __init__(self, build_cfg, calib_data):
-        """Init.
-
-        Args:
-            build_cfg (BuildProjConfig): Object with build configuration settings.
-            calib_data (dict): Dictionary containing calibration data for a ZoneController project.
-        """
-        self.swc_name = build_cfg.get_composition_config("softwareComponentName")
-        self.asil_level = re.sub("ASIL(?=[^_])", "ASIL_", build_cfg.get_composition_config("asil"))
-        self.src_code_dst_dir = build_cfg.get_src_code_dst_dir()
-        self.calibration_variables = calib_data['class_info']
-        cal_interface_filename = f"calibration_interface_{build_cfg.get_scheduler_prefix()}".rstrip("_")
-        self.calibration_interface_header = f'{cal_interface_filename}.h'
-        self.calibration_interface_source = f'{cal_interface_filename}.c'
-        self.trigger_read_rte_cdata_signal_name = self.trigger_read_rte_cdata_signal['name_template'].format(
-            swc_name=self.swc_name
-        )
-
-    def _get_header_guard(self):
-        header_guard_tmp = Path(self.calibration_interface_header).stem
-        return header_guard_tmp.upper() + '_H'
-
-    def _get_calibration_variables_write_string_list(self, indent=4):
-        write_string_list = []
-        for signal_name, signal_data in self.calibration_variables.items():
-            rte_call = f'Rte_CData_{self.swc_name}_{signal_name}()'
-            if isinstance(signal_data["width"], list):
-                write_string_list.append(f'{"":{indent}}memcpy({signal_name}, {rte_call}, sizeof({signal_name}));\n')
-            else:
-                write_string_list.append(f'{"":{indent}}{signal_name} = {rte_call};\n')
-        return write_string_list
-
-    def _get_source_file_init_content(self):
-        start_include = "CVC_CODE_START.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_START.h"
-        stop_include = "CVC_CODE_END.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_END.h"
-        header = [f'#include "{start_include}"\n']
-        footer = [f'#include "{stop_include}"\n', '\n']
-
-        body = [
-            f'void {self.calibration_function_init_template.format(swc_name=self.swc_name)}(void)\n',
-            '{\n',
-        ]
-        body.extend(self._get_calibration_variables_write_string_list())
-        body.append('}\n')
-
-        return header + body + footer
-
-    def _get_source_file_step_content(self):
-        start_include = "CVC_CODE_START.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_START.h"
-        stop_include = "CVC_CODE_END.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_END.h"
-        header = [f'#include "{start_include}"\n']
-        footer = [f'#include "{stop_include}"\n']
-
-        trigger_read_calibration_function = f'Rte_CData_{self.swc_name}_{self.trigger_read_rte_cdata_signal_name}()'
-        body = [
-            f'void {self.calibration_function_step_template.format(swc_name=self.swc_name)}(void)\n',
-            '{\n',
-            f'    if ({self.trigger_read_rte_cdata_signal_name} != {trigger_read_calibration_function})\n'
-        ]
-        body.append('    {\n')
-        body.extend(self._get_calibration_variables_write_string_list(indent=8))
-        body.append('    }\n')
-        body.append('}\n')
-
-        return header + body + footer
-
-    def get_header_file_content(self):
-        """Get content for the calibration header file.
-
-        Returns:
-            (list(str)): List of lines to write to calibration header file.
-        """
-        lines_to_write = []
-        start_include = "CVC_CAL_START.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_START.h"
-        stop_include = "CVC_CAL_END.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_END.h"
-        header = [
-            f'#ifndef {self._get_header_guard()}\n',
-            f'#define {self._get_header_guard()}\n',
-            '#define CVC_CAL\n',
-            '#include <string.h>\n',
-            '#include "tl_basetypes.h"\n',
-            f'#include "Rte_{self.swc_name}.h"\n',
-            '\n'
-        ]
-        footer = [
-            '\n',
-            f'#endif /* {self._get_header_guard()} */\n'
-        ]
-
-        lines_to_write.append(f'#include "{start_include}"\n')
-        for signal_name, signal_data in self.calibration_variables.items():
-            if isinstance(signal_data["width"], list):
-                rows, cols = signal_data["width"]
-                if rows > 1:
-                    declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name}[{rows}][{cols}];\n'
-                else:
-                    declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name}[{cols}];\n'
-            else:
-                declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name};\n'
-            lines_to_write.append(declaration)
-        lines_to_write.append(f'#include "{stop_include}"\n')
-
-        lines_to_write.append('\n')
-        for signal_name, signal_data in self.calibration_variables.items():
-            if isinstance(signal_data["width"], list):
-                # MAPs get typedef:ed to structs and need special data type mapping in calibration.py
-                if signal_name.startswith("m") and signal_name[-2:] not in ["_r", "_c"]:
-                    return_type = f'const {signal_data["autosar_type"]}*'
-                else:
-                    return_type = f'const {signal_data["type"]}*'
-            else:
-                return_type = f'{signal_data["type"]}'
-            lines_to_write.append(f'extern {return_type} Rte_CData_{self.swc_name}_{signal_name}(void);\n')
-
-        lines_to_write.extend([
-            '\n',
-            f'void {self.calibration_function_init_template.format(swc_name=self.swc_name)}(void);\n',
-            f'void {self.calibration_function_step_template.format(swc_name=self.swc_name)}(void);\n'
-        ])
-
-        return header + lines_to_write + footer
-
-    def get_source_file_content(self):
-        """Get content for the calibration source file.
-
-        Returns:
-            (list(str)): List of lines to write to calibration source file.
-        """
-        start_include = "CVC_CAL_START.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_START.h"
-        stop_include = "CVC_CAL_END.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_END.h"
-        header = [
-            f'#include "{self.calibration_interface_header}"\n',
-            '\n',
-            f'#include "{start_include}"\n',
-            f'CVC_CAL {self.trigger_read_rte_cdata_signal["data_type"]} '
-            f'{self.trigger_read_rte_cdata_signal_name} = 0;\n',
-            f'#include "{stop_include}"\n',
-            '\n',
-        ]
-
-        body = self._get_source_file_init_content()
-        body.extend(self._get_source_file_step_content())
-
-        return header + body
-
-    def generate_calibration_interface_files(self):
-        """Generate calibration interface files."""
-        header_file_content = self.get_header_file_content()
-        calibration_interface_header_path = Path(self.src_code_dst_dir, self.calibration_interface_header)
-        with calibration_interface_header_path.open(mode='w', encoding='utf-8') as file_handler:
-            file_handler.writelines(header_file_content)
-
-        source_file_content = self.get_source_file_content()
-        calibration_interface_source_path = Path(self.src_code_dst_dir, self.calibration_interface_source)
-        with calibration_interface_source_path.open(mode='w', encoding='utf-8') as file_handler:
-            file_handler.writelines(source_file_content)
+# Copyright 2024 Volvo Car Corporation
+# Licensed under Apache 2.0.
+
+"""Module for handling ZoneController calibration."""
+
+import re
+from pathlib import Path
+from powertrain_build.problem_logger import ProblemLogger
+
+
+class ZoneControllerCalibration(ProblemLogger):
+    """Class for handling ZoneController calibration."""
+
+    calibration_function_init_template = '{swc_name}_ZcCalibrationInit'
+    calibration_function_step_template = '{swc_name}_ZcCalibrationStep'
+    trigger_read_rte_cdata_signal = {
+        'name_template': 'c{swc_name}_TriggerReadRteCData',
+        'data_type': 'Float32'
+    }
+
+    def __init__(self, build_cfg, calib_data):
+        """Init.
+
+        Args:
+            build_cfg (BuildProjConfig): Object with build configuration settings.
+            calib_data (dict): Dictionary containing calibration data for a ZoneController project.
+        """
+        self.swc_name = build_cfg.get_composition_config("softwareComponentName")
+        self.asil_level = re.sub("ASIL(?=[^_])", "ASIL_", build_cfg.get_composition_config("asil"))
+        self.src_code_dst_dir = build_cfg.get_src_code_dst_dir()
+        self.calibration_variables = calib_data['class_info']
+        cal_interface_filename = f"calibration_interface_{build_cfg.get_scheduler_prefix()}".rstrip("_")
+        self.calibration_interface_header = f'{cal_interface_filename}.h'
+        self.calibration_interface_source = f'{cal_interface_filename}.c'
+        self.trigger_read_rte_cdata_signal_name = self.trigger_read_rte_cdata_signal['name_template'].format(
+            swc_name=self.swc_name
+        )
+
+    def _get_header_guard(self):
+        header_guard_tmp = Path(self.calibration_interface_header).stem
+        return header_guard_tmp.upper() + '_H'
+
+    def _get_calibration_variables_write_string_list(self, indent=4):
+        write_string_list = []
+        for signal_name, signal_data in self.calibration_variables.items():
+            rte_call = f'Rte_CData_{self.swc_name}_{signal_name}()'
+            if isinstance(signal_data["width"], list):
+                write_string_list.append(f'{"":{indent}}memcpy({signal_name}, {rte_call}, sizeof({signal_name}));\n')
+            else:
+                write_string_list.append(f'{"":{indent}}{signal_name} = {rte_call};\n')
+        return write_string_list
+
+    def _get_source_file_init_content(self):
+        start_include = "CVC_CODE_START.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_START.h"
+        stop_include = "CVC_CODE_END.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_END.h"
+        header = [f'#include "{start_include}"\n']
+        footer = [f'#include "{stop_include}"\n', '\n']
+
+        body = [
+            f'void {self.calibration_function_init_template.format(swc_name=self.swc_name)}(void)\n',
+            '{\n',
+        ]
+        body.extend(self._get_calibration_variables_write_string_list())
+        body.append('}\n')
+
+        return header + body + footer
+
+    def _get_source_file_step_content(self):
+        start_include = "CVC_CODE_START.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_START.h"
+        stop_include = "CVC_CODE_END.h" if self.asil_level == "QM" else f"CVC_CODE_{self.asil_level}_END.h"
+        header = [f'#include "{start_include}"\n']
+        footer = [f'#include "{stop_include}"\n']
+
+        trigger_read_calibration_function = f'Rte_CData_{self.swc_name}_{self.trigger_read_rte_cdata_signal_name}()'
+        body = [
+            f'void {self.calibration_function_step_template.format(swc_name=self.swc_name)}(void)\n',
+            '{\n',
+            f'    if ({self.trigger_read_rte_cdata_signal_name} != {trigger_read_calibration_function})\n'
+        ]
+        body.append('    {\n')
+        body.extend(self._get_calibration_variables_write_string_list(indent=8))
+        body.append('    }\n')
+        body.append('}\n')
+
+        return header + body + footer
+
+    def get_header_file_content(self):
+        """Get content for the calibration header file.
+
+        Returns:
+            (list(str)): List of lines to write to calibration header file.
+        """
+        lines_to_write = []
+        start_include = "PREDECL_CAL_START.h" if self.asil_level == "QM" else f"PREDECL_CAL_{self.asil_level}_START.h"
+        stop_include = "PREDECL_CAL_END.h" if self.asil_level == "QM" else f"PREDECL_CAL_{self.asil_level}_END.h"
+        header = [
+            f'#ifndef {self._get_header_guard()}\n',
+            f'#define {self._get_header_guard()}\n',
+            '#define CVC_CAL\n',
+            '#include <string.h>\n',
+            '#include "tl_basetypes.h"\n',
+            f'#include "Rte_{self.swc_name}.h"\n',
+            '\n'
+        ]
+        footer = [
+            '\n',
+            f'#endif /* {self._get_header_guard()} */\n'
+        ]
+
+        lines_to_write.append(f'#include "{start_include}"\n')
+        for signal_name, signal_data in self.calibration_variables.items():
+            if isinstance(signal_data["width"], list):
+                rows, cols = signal_data["width"]
+                if rows > 1:
+                    declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name}[{rows}][{cols}];\n'
+                else:
+                    declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name}[{cols}];\n'
+            else:
+                declaration = f'extern CVC_CAL {signal_data["type"]} {signal_name};\n'
+            lines_to_write.append(declaration)
+        lines_to_write.append(f'#include "{stop_include}"\n')
+
+        lines_to_write.append('\n')
+        for signal_name, signal_data in self.calibration_variables.items():
+            if isinstance(signal_data["width"], list):
+                # MAPs get typedef:ed to structs and need special data type mapping in calibration.py
+                if signal_name.startswith("m") and signal_name[-2:] not in ["_r", "_c"]:
+                    return_type = f'const {signal_data["autosar_type"]}*'
+                else:
+                    return_type = f'const {signal_data["type"]}*'
+            else:
+                return_type = f'{signal_data["type"]}'
+            lines_to_write.append(f'extern {return_type} Rte_CData_{self.swc_name}_{signal_name}(void);\n')
+
+        lines_to_write.extend([
+            '\n',
+            f'void {self.calibration_function_init_template.format(swc_name=self.swc_name)}(void);\n',
+            f'void {self.calibration_function_step_template.format(swc_name=self.swc_name)}(void);\n'
+        ])
+
+        return header + lines_to_write + footer
+
+    def get_source_file_content(self):
+        """Get content for the calibration source file.
+
+        Returns:
+            (list(str)): List of lines to write to calibration source file.
+        """
+        start_include = "CVC_CAL_START.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_START.h"
+        stop_include = "CVC_CAL_END.h" if self.asil_level == "QM" else f"CVC_CAL_{self.asil_level}_END.h"
+        header = [
+            f'#include "{self.calibration_interface_header}"\n',
+            '\n',
+            f'#include "{start_include}"\n',
+            f'CVC_CAL {self.trigger_read_rte_cdata_signal["data_type"]} '
+            f'{self.trigger_read_rte_cdata_signal_name} = 0;\n',
+            f'#include "{stop_include}"\n',
+            '\n',
+        ]
+
+        body = self._get_source_file_init_content()
+        body.extend(self._get_source_file_step_content())
+
+        return header + body
+
+    def generate_calibration_interface_files(self):
+        """Generate calibration interface files."""
+        header_file_content = self.get_header_file_content()
+        calibration_interface_header_path = Path(self.src_code_dst_dir, self.calibration_interface_header)
+        with calibration_interface_header_path.open(mode='w', encoding='utf-8') as file_handler:
+            file_handler.writelines(header_file_content)
+
+        source_file_content = self.get_source_file_content()
+        calibration_interface_source_path = Path(self.src_code_dst_dir, self.calibration_interface_source)
+        with calibration_interface_source_path.open(mode='w', encoding='utf-8') as file_handler:
+            file_handler.writelines(source_file_content)