scriptcollection 4.2.81__py3-none-any.whl

ScriptCollection/TFCPS/TFCPS_CodeUnit_BuildCodeUnits.py

@@ -0,0 +1,301 @@
+import os
+import json
+from datetime import datetime, timedelta,timezone
+import yaml
+from ..GeneralUtilities import GeneralUtilities
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import  LogLevel
+from .TFCPS_CodeUnit_BuildCodeUnit import TFCPS_CodeUnit_BuildCodeUnit
+from .TFCPS_Tools_General import TFCPS_Tools_General
+
+class TFCPS_CodeUnit_BuildCodeUnits:
+    repository:str=None
+    tfcps_tools_general:TFCPS_Tools_General=None 
+    sc:ScriptCollectionCore=None
+    target_environment_type:str=None
+    additionalargumentsfile:str=None
+    __use_cache:bool
+    __is_pre_merge:bool
+
+    def __init__(self,repository:str,loglevel:LogLevel,target_environment_type:str,additionalargumentsfile:str,use_cache:bool,is_pre_merge:bool):
+        self.sc=ScriptCollectionCore()
+        self.sc.log.loglevel=loglevel
+        self.__use_cache=use_cache
+        self.sc.assert_is_git_repository(repository)
+        self.repository=repository
+        self.tfcps_tools_general:TFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+        allowed_target_environment_types=["Development","QualityCheck","Productive"]
+        GeneralUtilities.assert_condition(target_environment_type in allowed_target_environment_types,"Unknown target-environment-type. Allowed values are: "+", ".join(allowed_target_environment_types))
+        self.target_environment_type=target_environment_type
+        self.additionalargumentsfile=additionalargumentsfile
+        self.__is_pre_merge=is_pre_merge
+
+    @GeneralUtilities.check_arguments
+    def build_codeunits(self) -> None:
+        self.sc.log.log(GeneralUtilities.get_line())
+        start_time:datetime=GeneralUtilities.get_now()
+        self.sc.log.log(f"Start building codeunits at {GeneralUtilities.datetime_to_string_for_readable_entry(start_time,False)}. (Target environment-type: {self.target_environment_type})")
+
+        #check if changelog exists
+        changelog_file=os.path.join(self.repository,"Other","Resources","Changelog",f"v{self.tfcps_tools_general.get_version_of_project(self.repository)}.md")
+        GeneralUtilities.assert_file_exists(changelog_file,f"Changelogfile \"{changelog_file}\" does not exist. Try to create it for example using \"sccreatechangelogentry -m ...\".") 
+        
+        #run prepare-script
+        self.run_prepare_script()
+
+        #mark current version as supported
+        now = GeneralUtilities.get_now()
+        project_version:str=self.tfcps_tools_general.get_version_of_project(self.repository)
+        if not self.tfcps_tools_general.suport_information_exists(self.repository, project_version):
+            amount_of_years_for_support:int=1
+            support_time = timedelta(days=365*amount_of_years_for_support+30*3+1) 
+            until = now + support_time
+            until_day = datetime(until.year, until.month, until.day, 0, 0, 0)
+            from_day = datetime(now.year, now.month, now.day, 0, 0, 0)
+            self.tfcps_tools_general.mark_current_version_as_supported(self.repository,project_version,from_day,until_day)
+
+        codeunits:list[str]=self.tfcps_tools_general.get_codeunits(self.repository)
+        GeneralUtilities.assert_condition(0<len(codeunits),f"No codeunits found in repository {self.repository}.")
+        self.sc.log.log("Codeunits will be built in the following order:")
+        for codeunit_name in codeunits:
+            self.sc.log.log(f"  - {codeunit_name}")
+        for codeunit_name in codeunits:
+            tFCPS_CodeUnit_BuildCodeUnit:TFCPS_CodeUnit_BuildCodeUnit = TFCPS_CodeUnit_BuildCodeUnit(os.path.join(self.repository,codeunit_name),self.sc.log.loglevel,self.target_environment_type,self.additionalargumentsfile,self.use_cache(),self.is_pre_merge())
+            self.sc.log.log(GeneralUtilities.get_line())
+            tFCPS_CodeUnit_BuildCodeUnit.build_codeunit()
+
+        self.sc.log.log(GeneralUtilities.get_line())
+        self.__search_for_vulnerabilities()
+        self.__search_for_secrets()
+        if self.is_pre_merge():
+            self.__translate()
+            self.__collect_metrics()
+            self.__generate_loc_diagram()
+        end_time:datetime=GeneralUtilities.get_now()
+        duration=end_time-start_time
+        self.sc.log.log(f"Finished building codeunits at {GeneralUtilities.datetime_to_string_for_readable_entry(end_time,False)}. (Duration: {GeneralUtilities.timedelta_to_simple_string(duration)})")
+        self.sc.log.log(GeneralUtilities.get_line())
+
+    @GeneralUtilities.check_arguments
+    def run_prepare_script(self):
+        args=["--repository",self.repository,"--targetenvironmenttype",self.target_environment_type,"--verbosity",str(int(self.sc.log.loglevel))]
+        if GeneralUtilities.string_has_content(self.additionalargumentsfile):
+            args=args+["--additionalargumentsfile", self.additionalargumentsfile]
+        if not self.__use_cache:
+            if self.sc.git_repository_has_uncommitted_changes(self.repository):
+                self.sc.log.log("No-cache-option can not be applied because there are uncommited changes in the repository.",LogLevel.Warning)
+            else:
+                args=args+["--nocache"]
+
+        if  os.path.isfile( os.path.join( self.sc.get_scriptcollection_configuration_folder(),"TFCPS","CustomPreCodeUnitBuildScript.py")):
+            self.sc.log.log("Run custom pre-codeunitbuild script...")
+            self.sc.run_program_argsasarray(GeneralUtilities.get_python_executable(),["CustomPreCodeUnitBuildScript.py"]+args, os.path.join( self.sc.get_scriptcollection_configuration_folder(),"TFCPS"),print_live_output=True)
+
+        if  os.path.isfile( os.path.join(self.repository,"Other","Scripts","PrepareBuildCodeunits.py")):
+            self.sc.log.log("Prepare build codeunits...")
+            self.sc.run_program_argsasarray(GeneralUtilities.get_python_executable(),["PrepareBuildCodeunits.py"]+args, os.path.join(self.repository,"Other","Scripts"),print_live_output=True)
+
+    @GeneralUtilities.check_arguments
+    def build_codeunits_in_container(self) -> None:
+        raise ValueError("Not implemented.")
+
+    @GeneralUtilities.check_arguments
+    def __translate(self) -> None:
+        for taskfile_name in ("Taskfile.yml", "Taskfile.yaml"):
+            taskfile = os.path.join(self.repository, taskfile_name)
+            if os.path.isfile(taskfile):
+                with open(taskfile, "r", encoding="utf-8") as f:
+                    taskfile_content = yaml.safe_load(f)
+                if isinstance(taskfile_content.get("tasks"), dict) and "Translate" in taskfile_content["tasks"]:
+                    self.sc.run_program("task", "Translate", self.repository, print_live_output=self.sc.log.loglevel == LogLevel.Debug)
+                break
+
+    @GeneralUtilities.check_arguments
+    def __collect_metrics(self) -> None:
+        project_version: str=self.tfcps_tools_general.get_version_of_project(self.repository)
+        self.sc.log.log("Collect metrics...")
+        loc = self.sc.get_lines_of_code_with_default_excluded_patterns(self.repository)
+        loc_metric_folder = os.path.join(self.repository, "Other", "Metrics")
+        GeneralUtilities.ensure_directory_exists(loc_metric_folder)
+        loc_metric_file = os.path.join(loc_metric_folder, "RepositoryStatisticsPerCommit.csv")
+        GeneralUtilities.ensure_file_exists(loc_metric_file)
+
+        #remove legacy metrics-file. the following 2 lines should be removed after 2026-12-31
+        legacy_metrics_file = os.path.join(loc_metric_folder, "LinesOfCode.csv")
+        GeneralUtilities.ensure_file_does_not_exist(legacy_metrics_file)
+
+        old_lines = GeneralUtilities.read_nonempty_lines_from_file(loc_metric_file)
+        header_line="Version;Timestamp;LinesOfCode"
+        new_lines = [header_line]
+        current_version_string=f"v{project_version}"
+        for old_line in old_lines:
+            if not old_line.startswith(current_version_string+";") and old_line!=header_line:
+                new_lines.append(old_line)
+        c_date:datetime=GeneralUtilities.get_now().astimezone(timezone.utc)
+        commit_date=GeneralUtilities.datetime_to_string_for_logfile_entry(c_date,False)
+        new_lines.append(f"{current_version_string};{commit_date};{loc}")
+        GeneralUtilities.write_lines_to_file(loc_metric_file, new_lines)
+
+
+    @GeneralUtilities.check_arguments
+    def __generate_loc_diagram(self):
+        self.sc.log.log("Generate LoC-diagram...")
+        loc_metric_folder = os.path.join(self.repository, "Other", "Metrics")
+        GeneralUtilities.ensure_directory_exists(loc_metric_folder)
+        loc_metric_file = os.path.join(loc_metric_folder, "RepositoryStatisticsPerCommit.csv")
+        GeneralUtilities.ensure_file_exists(loc_metric_file)
+
+        filenamebase="LoC-Diagram"
+
+        diagram_definition_folder=os.path.join(self.repository, "Other", "Reference","Technical","Diagrams")
+        GeneralUtilities.ensure_directory_exists(diagram_definition_folder)
+
+        diagram_definition_file=os.path.join(diagram_definition_folder,f"{filenamebase}.json")
+        GeneralUtilities.ensure_file_exists(diagram_definition_file)
+        GeneralUtilities.write_text_to_file(diagram_definition_file,GeneralUtilities.empty_string)
+
+        loc_data_file=os.path.join(diagram_definition_folder,f"{filenamebase}.csv")
+        GeneralUtilities.ensure_file_exists(loc_data_file)
+        csv_lines=[]
+        for line in GeneralUtilities.read_lines_from_file(loc_metric_file):
+            if GeneralUtilities.string_has_content(line):
+                splitted=line.split(";")
+                v=splitted[0]
+                t=splitted[1]
+                loc=splitted[2]
+                csv_lines.append(f"{v},{t},{loc}")
+        GeneralUtilities.write_lines_to_file(loc_data_file,csv_lines)
+        diagram_json = {
+    "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
+    "description": "Lines of Code over time",
+    "width": 800,
+    "height": 400,
+    "data": {
+        "url": f"./{filenamebase}.csv",
+        "format": {
+            "type": "csv"
+        }
+    },
+    "mark": {
+        "type": "line",
+        "point": True
+    },
+    "encoding": {
+        "x": {
+            "field": "Timestamp",
+            "type": "temporal",
+            "title": "Date"
+        },
+        "y": {
+            "field": "LinesOfCode",
+            "type": "quantitative",
+            "title": "Lines of Code"
+        },
+        "tooltip": [
+            {
+                "field": "Version",
+                "type": "ordinal"
+            },
+            {
+                "field": "LinesOfCode",
+                "type": "quantitative"
+            },
+            {
+                "field": "Timestamp",
+                "type": "temporal"
+            }
+        ]
+    }
+}
+
+        with open(diagram_definition_file, "w", encoding="utf-8") as f:
+            json.dump(
+                diagram_json,
+                f,
+                indent=2,
+                sort_keys=False,
+                ensure_ascii=False
+            )
+        diagram_svg_file=os.path.join(self.repository,"Other","Reference","Technical","Diagrams",f"{filenamebase}.svg")
+        GeneralUtilities.ensure_file_exists(diagram_svg_file)
+        GeneralUtilities.assert_condition(not self.sc.file_is_git_ignored(f"Other/Reference/Technical/Diagrams/{filenamebase}.svg",self.repository),f"Other/Reference/Technical/Diagrams/{filenamebase}.svg must not be git-ignored")#because it should be referencable in markdown-files and viewable without building the codeunits.
+        self.sc.generate_chart_diagram(diagram_definition_file,os.path.basename(diagram_svg_file))
+        self.sc.format_xml_file(diagram_svg_file)
+
+    @GeneralUtilities.check_arguments
+    def __search_for_vulnerabilities(self):
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def __search_for_secrets(self):
+        enabled:bool=False#TODO reenable when a solution is found to ignore false positives
+        if enabled:
+            exe_paths=self.tfcps_tools_general.ensure_trufflehog_is_available()
+            exe_path:str=None
+            if GeneralUtilities.current_system_is_windows():
+                exe_path=exe_paths["Windows"]
+            elif GeneralUtilities.current_system_is_linux():
+                exe_path=exe_paths["Linux"]
+            else:
+                raise ValueError("unsupported")#TODO check for macos
+            result=self.sc.run_program(exe_path,"filesystem . --json",self.repository)
+
+            self.sc.log.log("Secret-scan-result:")#TODO replace this by real analysis
+            for line in GeneralUtilities.string_to_lines(result[1]):
+                self.sc.log.log(line)
+            for line in GeneralUtilities.string_to_lines(result[2]):
+                self.sc.log.log(line,LogLevel.Error)
+
+    @GeneralUtilities.check_arguments
+    def use_cache(self) -> bool:
+        return self.__use_cache
+
+
+    @GeneralUtilities.check_arguments
+    def is_pre_merge(self) -> bool:
+        return self.__is_pre_merge
+
+    @GeneralUtilities.check_arguments
+    def update_dependencies(self) -> None:
+        repository=self.repository
+        self.sc.log.log("Update dependencies...")
+        self.update_year_in_license_file()
+        self.sc.assert_is_git_repository(repository)
+        self.sc.assert_no_uncommitted_changes(repository)
+        self.run_prepare_script()
+        if os.path.isfile(os.path.join(repository,"Other","Scripts","UpdateDependencies.py")):
+            self.sc.run_program(GeneralUtilities.get_python_executable(),"UpdateDependencies.py",os.path.join(repository,"Other","Scripts"))
+        codeunits:list[str]=self.tfcps_tools_general.get_codeunits(repository)   
+        for codeunit_name in codeunits:
+            self.sc.log.log(f"Update dependencies of codeunit {codeunit_name}...")
+            codeunit_folder=os.path.join(repository,codeunit_name)
+            tFCPS_CodeUnit_BuildCodeUnit:TFCPS_CodeUnit_BuildCodeUnit = TFCPS_CodeUnit_BuildCodeUnit(codeunit_folder,self.sc.log.loglevel,"QualityCheck",None,True,False)
+            tFCPS_CodeUnit_BuildCodeUnit.build_codeunit()#ensure requirements for updating are there (some programming-languages needs this)
+            if self.tfcps_tools_general.codeunit_has_updatable_dependencies(os.path.join(codeunit_folder,f"{codeunit_name}.codeunit.xml")):
+                self.sc.run_program(GeneralUtilities.get_python_executable(),"UpdateDependencies.py",os.path.join(codeunit_folder,"Other"))
+            tFCPS_CodeUnit_BuildCodeUnit.build_codeunit()#check if codeunit is still buildable
+        if self.sc.git_repository_has_uncommitted_changes(repository):
+            changelog_folder = os.path.join(repository, "Other", "Resources", "Changelog")
+            project_version:str=self.tfcps_tools_general.get_version_of_project(repository)
+            changelog_file = os.path.join(changelog_folder, f"v{project_version}.md")
+            if not os.path.isfile(changelog_file):
+                self.__ensure_changelog_file_is_added(repository, project_version)
+            t=TFCPS_CodeUnit_BuildCodeUnits(repository,self.sc.log.loglevel,"QualityCheck",None,True,False)
+            t.build_codeunits()#check codeunits are buildable at all
+            self.sc.git_commit(repository, "Updated dependencies", stage_all_changes=True) 
+
+    @GeneralUtilities.check_arguments
+    def __ensure_changelog_file_is_added(self, repository_folder: str, version_of_project: str):
+        changelog_file = os.path.join(repository_folder, "Other", "Resources", "Changelog", f"v{version_of_project}.md")
+        if not os.path.isfile(changelog_file):
+            GeneralUtilities.ensure_file_exists(changelog_file)
+            GeneralUtilities.write_text_to_file(changelog_file, """# Release notes
+
+## Changes
+
+- Updated dependencies.
+""")
+
+    @GeneralUtilities.check_arguments
+    def update_year_in_license_file(self) -> None:
+        self.sc.update_year_in_first_line_of_file(os.path.join(self.repository, "License.txt"))

ScriptCollection/TFCPS/TFCPS_CreateRelease.py

@@ -0,0 +1,98 @@
+import os
+from ..GeneralUtilities import GeneralUtilities
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import LogLevel
+from .TFCPS_Tools_General import TFCPS_Tools_General
+from .TFCPS_MergeToMain import TFCPS_MergeToMain,MergeToMainConfiguration
+from .TFCPS_MergeToStable import TFCPS_MergeToStable,MergeToStableConfiguration
+ 
+
+class TFCPS_CreateReleaseConfiguration:
+    
+    product_name: str
+    branch_to_be_released:str
+    additional_arguments_file:str
+    log_level:LogLevel
+    main_branch:str
+    stable_branch:str
+    build_repository:str
+    repository:str
+    reference_repository:str
+    common_remote_name:str
+    build_repo_main_branch_name:str
+    reference_repo_main_branch_name:str
+    reference_remote_name:str
+    build_repo_remote_name:str
+    artifacts_target_folder:str
+    common_remote_url:str
+    
+    def __init__(self, current_file: str, product_name: str,branch_to_be_released:str,log_level:LogLevel,additional_arguments_file:str,main_branch:str,stable_branch:str,common_remote_name:str,build_repo_main_branch_name:str,reference_repo_main_branch_name:str,reference_remote_name:str,build_repo_remote_name:str,artifacts_target_folder:str,common_remote_url:str):
+        self.product_name = product_name
+        self.branch_to_be_released=branch_to_be_released
+        self.additional_arguments_file=additional_arguments_file
+        self.log_level=log_level
+        self.main_branch=main_branch
+        self.stable_branch=stable_branch
+        self.build_repository=ScriptCollectionCore().search_repository_folder(current_file)
+        self.repository=os.path.join(self.build_repository,"Submodules",product_name)
+        self.reference_repository=os.path.join(self.build_repository,"Submodules",product_name+"Reference")
+        self.common_remote_name=common_remote_name
+        self.build_repo_main_branch_name=build_repo_main_branch_name
+        self.reference_repo_main_branch_name=reference_repo_main_branch_name
+        self.reference_remote_name=reference_remote_name
+        self.build_repo_remote_name=build_repo_remote_name
+        self.artifacts_target_folder=artifacts_target_folder
+        self.common_remote_url=common_remote_url
+
+class TFCPS_CreateRelease:
+
+    sc:ScriptCollectionCore
+    tFCPS_Tools_General:TFCPS_Tools_General
+
+    def __init__(self):
+        self.sc=ScriptCollectionCore()
+        self.tFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+
+    @GeneralUtilities.check_arguments
+    def do_release(self,tfcps_CreateReleaseConfiguration:TFCPS_CreateReleaseConfiguration)->bool:
+        self.sc.log.loglevel=tfcps_CreateReleaseConfiguration.log_level
+        return self.sc.do_and_log_task(f"Release {tfcps_CreateReleaseConfiguration.product_name}",lambda : self.__do(tfcps_CreateReleaseConfiguration))
+
+    @GeneralUtilities.check_arguments
+    def __do(self,tfcps_CreateReleaseConfiguration:TFCPS_CreateReleaseConfiguration)->bool:
+        self.sc.log.log("Do checks...",LogLevel.Information)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.build_repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.build_repository)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.repository)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.reference_repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.reference_repository)
+
+        release_was_done:bool=False
+        
+        branch_to_be_released_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.branch_to_be_released)
+        main_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.main_branch)
+        if branch_to_be_released_commit_id == main_branch_commit_id:
+            self.sc.log.log("Merge to main-branch will not be done because there are no changed which can be merged.")
+        else:
+            self.sc.log.log("Merge to main-branch...",LogLevel.Information)
+            mergeToMainConfiguration:MergeToMainConfiguration=MergeToMainConfiguration(tfcps_CreateReleaseConfiguration.current_file,tfcps_CreateReleaseConfiguration.product_name,tfcps_CreateReleaseConfiguration.product_name,tfcps_CreateReleaseConfiguration.branch_to_be_released,tfcps_CreateReleaseConfiguration.log_level,tfcps_CreateReleaseConfiguration.additional_arguments_file,tfcps_CreateReleaseConfiguration.main_branch,tfcps_CreateReleaseConfiguration.common_remote_name,tfcps_CreateReleaseConfiguration.build_repository)
+            tFCPS_MergeToMain:TFCPS_MergeToMain=TFCPS_MergeToMain(mergeToMainConfiguration)
+            tFCPS_MergeToMain.merge_to_main_branch()
+
+        main_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.main_branch)
+        stable_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.stable_branch)
+        if main_branch_commit_id == stable_branch_commit_id:
+            self.sc.log.log("Merge to stable-branch will not be done because there are no changed which can be released.")
+        else:
+            self.sc.log.log("Merge to stable-branch...",LogLevel.Information) 
+            mergeToStableConfiguration:MergeToStableConfiguration=MergeToStableConfiguration(tfcps_CreateReleaseConfiguration.log_level,tfcps_CreateReleaseConfiguration.main_branch,tfcps_CreateReleaseConfiguration.stable_branch,tfcps_CreateReleaseConfiguration.repository,tfcps_CreateReleaseConfiguration.build_repository,tfcps_CreateReleaseConfiguration.common_remote_name,tfcps_CreateReleaseConfiguration.build_repo_main_branch_name,tfcps_CreateReleaseConfiguration.reference_repo_main_branch_name,tfcps_CreateReleaseConfiguration.reference_remote_name,tfcps_CreateReleaseConfiguration.build_repo_remote_name,tfcps_CreateReleaseConfiguration.artifacts_target_folder,tfcps_CreateReleaseConfiguration.common_remote_url,tfcps_CreateReleaseConfiguration.additional_arguments_file)
+            tFCPS_MergeToStable:TFCPS_MergeToStable=TFCPS_MergeToStable(mergeToStableConfiguration)
+            tFCPS_MergeToStable.merge_to_stable_branch()
+            
+            release_was_done=True
+
+        return release_was_done

ScriptCollection/TFCPS/TFCPS_Generic.py

@@ -0,0 +1,44 @@
+import argparse
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import  LogLevel
+from .TFCPS_Tools_General import TFCPS_Tools_General
+
+class TFCPS_Generic_Functions:
+    script_file:str
+    repository_folder:str=None
+    targetenvironmenttype:str
+    additionalargumentsfile:str
+    verbosity:LogLevel
+    sc:ScriptCollectionCore
+    tfcps_Tools_General:TFCPS_Tools_General
+    __use_cache:bool
+    
+    def __init__(self,script_file:str,targetenvironmenttype:str,additionalargumentsfile:str,verbosity:LogLevel,use_cache:bool):
+        self.verbosity=verbosity
+        self.script_file=script_file
+        self.sc=ScriptCollectionCore()
+        self.sc.log.loglevel=self.verbosity
+        self.tfcps_Tools_General=TFCPS_Tools_General(self.sc)
+        self.repository_folder=self.sc.search_repository_folder(script_file)
+        self.targetenvironmenttype=targetenvironmenttype
+        self.__use_cache=use_cache
+        self.additionalargumentsfile=additionalargumentsfile
+
+    def use_cache(self)->bool:
+        return self.__use_cache
+
+
+class TFCPS_Generic_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_Generic_Functions:
+        parser = argparse.ArgumentParser()
+        verbosity_values = ", ".join(f"{lvl.value}={lvl.name}" for lvl in LogLevel)
+        parser.add_argument('-r', '--repository', required=False, default=None)
+        parser.add_argument('-e', '--targetenvironmenttype', required=False, default="QualityCheck")
+        parser.add_argument('-a', '--additionalargumentsfile', required=False, default=None)
+        parser.add_argument('-v', '--verbosity', required=False, default=3, help=f"Sets the loglevel. Possible values: {verbosity_values}")
+        parser.add_argument('-c', '--nocache',  action='store_true', required=False, default=False)
+        args=parser.parse_args()
+        result:TFCPS_Generic_Functions=TFCPS_Generic_Functions(file,args.targetenvironmenttype,args.additionalargumentsfile,LogLevel(int(args.verbosity)),not args.nocache)
+        return result 

ScriptCollection/TFCPS/TFCPS_MergeToMain.py

@@ -0,0 +1,128 @@
+import argparse
+import os
+from ..GeneralUtilities import GeneralUtilities
+from ..SCLog import LogLevel
+from ..ScriptCollectionCore import ScriptCollectionCore
+from .TFCPS_Tools_General import TFCPS_Tools_General
+from .TFCPS_CodeUnit_BuildCodeUnits import TFCPS_CodeUnit_BuildCodeUnits
+from .TFCPS_Generic import TFCPS_Generic_Functions
+
+class MergeToMainConfiguration:
+    product_name: str
+    merge_source_branch:str
+    additional_arguments_file:str
+    log_level:LogLevel
+    main_branch:str
+    repository_folder:str
+    tFCPS_Generic_Functions:TFCPS_Generic_Functions
+    common_remote_name:str
+    build_repo:str
+    sc:ScriptCollectionCore=ScriptCollectionCore()
+
+    def __init__(self, current_file: str,repository:str, product_name: str,merge_source_branch:str,log_level:LogLevel,additional_arguments_file:str,main_branch:str,common_remote_name:str,build_repo:str):
+        self.sc.log.loglevel=log_level
+        self.repository_folder = repository
+        self.product_name = product_name
+        self.merge_source_branch=merge_source_branch
+        self.additional_arguments_file=additional_arguments_file
+        self.log_level=log_level
+        self.main_branch=main_branch
+        self.common_remote_name=common_remote_name
+        self.build_repo=build_repo
+
+class TFCPS_MergeToMain:
+
+    sc:ScriptCollectionCore
+    tFCPS_Tools_General:TFCPS_Tools_General
+    generic_prepare_new_release_arguments:MergeToMainConfiguration=None
+
+    def __init__(self,generic_prepare_new_release_arguments:MergeToMainConfiguration):
+        self.sc=ScriptCollectionCore()
+        self.tFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+        self.generic_prepare_new_release_arguments=generic_prepare_new_release_arguments
+
+    @GeneralUtilities.check_arguments
+    def merge_to_main_branch(self ) -> None:
+        self.sc.log.loglevel=self.generic_prepare_new_release_arguments.log_level
+        self.sc.log.log("Merge to main-branch...")
+        fast_forward_source_branch: bool=True
+        source_branch: str=self.generic_prepare_new_release_arguments.merge_source_branch
+        target_branch: str=self.generic_prepare_new_release_arguments.main_branch
+        self.sc.assert_is_git_repository(self.generic_prepare_new_release_arguments.repository_folder)
+
+        if self.sc.git_get_commit_id(self.generic_prepare_new_release_arguments.repository_folder,source_branch)==self.sc.git_get_commit_id(self.generic_prepare_new_release_arguments.repository_folder,target_branch):
+            self.sc.log.log("Source- and target-branch are on the same commit.")
+            return
+
+        self.sc.assert_no_uncommitted_changes(self.generic_prepare_new_release_arguments.repository_folder)
+        self.sc.git_checkout(self.generic_prepare_new_release_arguments.repository_folder, source_branch)
+        self.sc.assert_no_uncommitted_changes(self.generic_prepare_new_release_arguments.repository_folder)
+
+        #premerge-build
+        #TODO the premerge-build is now supposed to be in MergeToStable
+        try:
+            tfcps_CodeUnit_BuildCodeUnits:TFCPS_CodeUnit_BuildCodeUnits=TFCPS_CodeUnit_BuildCodeUnits(self.generic_prepare_new_release_arguments.repository_folder,self.sc.log.loglevel,"QualityCheck",self.generic_prepare_new_release_arguments.additional_arguments_file,False,True)
+            tfcps_CodeUnit_BuildCodeUnits.build_codeunits()
+        except Exception:
+            self.sc.log.log(f"Branch {source_branch} is not buildable.",LogLevel.Error)
+            self.sc.git_undo_all_changes(self.generic_prepare_new_release_arguments.repository_folder)
+            raise
+        self.sc.git_commit(self.generic_prepare_new_release_arguments.repository_folder, 'Pre-merge-commit', stage_all_changes=True, no_changes_behavior=0)
+
+
+        if fast_forward_source_branch:
+            self.sc.git_checkout(self.generic_prepare_new_release_arguments.repository_folder, source_branch)
+            project_version:str=self.tFCPS_Tools_General.get_version_of_project(self.generic_prepare_new_release_arguments.repository_folder)
+            self.sc.git_merge(self.generic_prepare_new_release_arguments.repository_folder, source_branch, target_branch, False, True)
+            self.sc.git_merge(self.generic_prepare_new_release_arguments.repository_folder, target_branch, source_branch, True, True)
+            self.sc.git_create_tag(self.generic_prepare_new_release_arguments.repository_folder,target_branch,f"v{project_version}")
+
+        self.sc.log.log("Push branches...")
+        self.sc.git_push_with_retry(self.generic_prepare_new_release_arguments.repository_folder,self.generic_prepare_new_release_arguments.common_remote_name,source_branch,source_branch)
+        self.sc.git_push_with_retry(self.generic_prepare_new_release_arguments.repository_folder,self.generic_prepare_new_release_arguments.common_remote_name,target_branch,target_branch)
+        self.sc.git_commit(self.generic_prepare_new_release_arguments.build_repo,"Updated submodule")
+
+class TFCPS_MergeToMain_CLI:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def get_with_overwritable_defaults(file:str,default_merge_source_branch:str=None,default_loglevel:LogLevel=None,default_additionalargumentsfile:str=None,default_main_branch:str=None,default_common_remote_name:str=None)->TFCPS_MergeToMain:
+        parser = argparse.ArgumentParser()
+        verbosity_values = ", ".join(f"{lvl.value}={lvl.name}" for lvl in LogLevel)
+        parser.add_argument('-s', '--mergesourcebranch', required=False)
+        parser.add_argument('-a', '--additionalargumentsfile', required=False)
+        parser.add_argument('-t', '--mainbranch', required=False)
+        parser.add_argument('-r', '--commonremotename', required=False)
+        parser.add_argument('-v', '--verbosity', required=False, help=f"Sets the loglevel. Possible values: {verbosity_values}")
+        args=parser.parse_args()
+
+        sc:ScriptCollectionCore=ScriptCollectionCore()
+
+        build_repo=GeneralUtilities.resolve_relative_path("../../..",file)
+        sc.assert_is_git_repository(build_repo)
+
+        default_product_name=os.path.basename(build_repo)[:-len("Build")]
+
+        if args.mergesourcebranch is not None: 
+            default_merge_source_branch=args.mergesourcebranch#other/next-release
+        GeneralUtilities.assert_not_null(default_merge_source_branch,"mergesourcebranch is not set")
+
+        if args.verbosity is not None:
+            default_loglevel=LogLevel(int( args.verbosity))
+        GeneralUtilities.assert_not_null(default_loglevel,"verbosity is not set")
+
+        if args.additionalargumentsfile is not None:
+            default_additionalargumentsfile=args.additionalargumentsfile
+
+        if args.mainbranch is not None: 
+            default_main_branch=args.mainbranch#main
+        GeneralUtilities.assert_not_null(default_main_branch,"mainbranch is not set")
+
+        if args.commonremotename is not None:
+            default_common_remote_name=args.commonremotename
+        GeneralUtilities.assert_not_null(default_common_remote_name,"commonremotename is not set")
+
+        repository=os.path.join(build_repo,"Submodules",default_product_name)
+        config:MergeToMainConfiguration=MergeToMainConfiguration(file,repository,default_product_name,default_merge_source_branch,default_loglevel,default_additionalargumentsfile,default_main_branch,default_common_remote_name,build_repo)
+        tFCPS_MergeToMain:TFCPS_MergeToMain=TFCPS_MergeToMain(config)
+        return tFCPS_MergeToMain