ScriptCollection 3.5.16__py3-none-any.whl → 4.0.78__py3-none-any.whl

ScriptCollection/TFCPS/TFCPS_CodeUnit_BuildCodeUnits.py

@@ -0,0 +1,136 @@
+import os
+from datetime import datetime, timedelta
+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_Other: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_Other: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 __save_lines_of_code(self, repository_folder: str, project_version: str) -> None:
+        loc = self.sc.get_lines_of_code_with_default_excluded_patterns(repository_folder)
+        loc_metric_folder = os.path.join(repository_folder, "Other", "Metrics")
+        GeneralUtilities.ensure_directory_exists(loc_metric_folder)
+        loc_metric_file = os.path.join(loc_metric_folder, "LinesOfCode.csv")
+        GeneralUtilities.ensure_file_exists(loc_metric_file)
+        old_lines = GeneralUtilities.read_lines_from_file(loc_metric_file)
+        new_lines = []
+        for line in old_lines:
+            if not line.startswith(f"v{project_version};"):
+                new_lines.append(line)
+        new_lines.append(f"v{project_version};{loc}")
+        GeneralUtilities.write_lines_to_file(loc_metric_file, new_lines)
+
+    @GeneralUtilities.check_arguments
+    def build_codeunits(self) -> None:
+        self.sc.log.log(GeneralUtilities.get_line())
+        self.sc.log.log(f"Start building codeunits. (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_Other.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
+        if  os.path.isfile( os.path.join(self.repository,"Other","Scripts","PrepareBuildCodeunits.py")):
+            arguments:str=f"--targetenvironmenttype {self.target_environment_type} --additionalargumentsfile {self.additionalargumentsfile} --verbosity {int(self.sc.log.loglevel)}"
+            if not self.__use_cache:
+                arguments=f"{arguments} --nocache"
+                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:
+                    self.sc.run_program("git","clean -dfx",self.repository)
+
+            self.sc.log.log("Prepare build codeunits...")
+            self.sc.run_program("python", f"PrepareBuildCodeunits.py {arguments}", os.path.join(self.repository,"Other","Scripts"),print_live_output=True)
+
+        #mark current version as supported
+        now = GeneralUtilities.get_now()
+        project_version:str=self.tFCPS_Other.get_version_of_project(self.repository)
+        if not self.tFCPS_Other.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_Other.mark_current_version_as_supported(self.repository,project_version,from_day,until_day)
+
+        codeunits:list[str]=self.tFCPS_Other.get_codeunits(self.repository)        
+        self.sc.log.log("Codeunits will be built in the following order:")
+        for codeunit_name in codeunits:
+            self.sc.log.log("  - "+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()
+
+        #TODO run static code analysis tool to search for vulnerabilities
+        #TODO self.__search_for_secrets()
+        self.__save_lines_of_code(self.repository,self.tFCPS_Other.get_version_of_project(self.repository))
+
+        self.sc.log.log(GeneralUtilities.get_line())
+        self.sc.log.log("Finished building codeunits.")
+        self.sc.log.log(GeneralUtilities.get_line())
+
+    def __search_for_secrets(self):#pylint:disable=unused-private-member
+        exe_paths=self.tFCPS_Other.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)
+
+        enabled:bool=False
+        if enabled:
+            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:
+        self.update_year_in_license_file()
+
+        #TODO update project-wide-dependencies here
+        codeunits:list[str]=self.tFCPS_Other.get_codeunits(self.repository)
+        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())
+            tFCPS_CodeUnit_BuildCodeUnit.update_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,95 @@
+import os
+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)
+
+    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))
+
+    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,43 @@
+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('-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,122 @@
+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)
+
+        GeneralUtilities.assert_condition(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),"Source- and target-branch must not be the same commit.")
+
+        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)
+
+        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)
+        try:
+            tfcps_CodeUnit_BuildCodeUnits.build_codeunits()
+        except Exception:
+            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
+    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