ion-CSP 2.1.5__py3-none-any.whl → 2.1.9__py3-none-any.whl

ion_CSP/gen_opt.py

@@ -7,7 +7,7 @@ import subprocess
 import importlib.resources
 from typing import List
 from ase.io import read
-from dpdispatcher import Machine
+from dpdispatcher import Machine, Resources
 from pyxtal import pyxtal
 from pyxtal.msg import Comp_CompatibilityError, Symm_CompatibilityError
 from ion_CSP.log_and_time import redirect_dpdisp_logging
@@ -17,11 +17,13 @@ class CrystalGenerator:
     def __init__(self, work_dir: str, ion_numbers: List[int], species: List[str]):
         """
         Initialize the class based on the provided ionic crystal composition structure files and corresponding composition numbers.
+
+        :params
+            work_dir: The working directory where the ionic crystal structure files are located.
+            ion_numbers: A list of integers representing the number of each ion in the ionic crystal.
+            species: A list of strings representing the species of ions in the ionic crystal.
         """
         redirect_dpdisp_logging(os.path.join(work_dir, "dpdispatcher.log"))
-        # self.script_dir = os.path.dirname(__file__)
-        # self.mlp_opt_file = os.path.join(self.script_dir, "mlp_opt.py")
-        # self.model_file = os.path.join(self.script_dir, "../../model/model.pt")
         self.mlp_opt_file = importlib.resources.files("ion_CSP").joinpath("mlp_opt.py")
         self.model_file = importlib.resources.files("ion_CSP.model").joinpath("model.pt")
         # 获取当前脚本的路径以及同路径下离子晶体组分的结构文件, 并将这一路径作为工作路径来避免可能的错误
@@ -55,6 +57,10 @@ class CrystalGenerator:
         """
         Private method:
         Extract numbers from file names, convert them to integers, sort them by sequence, and return a list containing both indexes and file names
+
+        :params
+            directory: The directory where the files are located.
+            prefix_name: The prefix of the file names to be processed, e.g., 'POSCAR_'.
         """
         # 获取dir文件夹中所有以prefix_name开头的文件，在此实例中为POSCAR_
         files = [f for f in os.listdir(directory) if f.startswith(prefix_name)]
@@ -72,6 +78,9 @@ class CrystalGenerator:
     ):
         """
         Based on the provided ion species and corresponding numbers, use pyxtal to randomly generate ion crystal structures based on crystal space groups.
+        :params
+            num_per_group: The number of POSCAR files to be generated for each space group, default is 100.
+            space_groups_limit: The maximum number of space groups to be searched, default is 230, which is the total number of space groups.
         """
         # 如果目录不存在，则创建POSCAR_Files文件夹
         os.makedirs(self.POSCAR_dir, exist_ok=True)
@@ -135,7 +144,14 @@ class CrystalGenerator:
         )
 
     def _single_phonopy_processing(self, filename):
-    # 按顺序处理POSCAR文件，首先复制一份无数字后缀的POSCAR文件
+        """
+        Private method: 
+        Process a single POSCAR file using phonopy to generate symmetric primitive cells and conventional cells.
+
+        :params
+            filename: The name of the POSCAR file to be processed.
+        """
+        # 按顺序处理POSCAR文件，首先复制一份无数字后缀的POSCAR文件
         shutil.copy(f"{self.POSCAR_dir}/{filename}", f"{self.POSCAR_dir}/POSCAR")
         try:
             subprocess.run(["nohup", "phonopy", "--symmetry", "POSCAR"], check=True)
@@ -153,7 +169,7 @@ class CrystalGenerator:
         # 检查生成的POSCAR中的原子数，如果不匹配则删除该POSCAR并在日志中记录
         if cell_atoms != self.cell_atoms:
             error_message = f"Atom number mismatch ({cell_atoms} vs {self.cell_atoms})"
-            logging.error(f"{filename} - {error_message}")
+            print(f"{filename} - {error_message}")
             
             # 新增：回溯空间群归属
             poscar_index = int(filename.split('_')[1])  # 提取POSCAR编号
@@ -179,7 +195,15 @@ class CrystalGenerator:
             os.remove(f"{self.primitive_cell_dir}/{filename}")
 
     def _find_space_group(self, poscar_index: int) -> int:
-        """根据POSCAR编号查找对应的空间群"""
+        """
+        Private method:
+        Find the space group for a given POSCAR index based on the group_counts.
+
+        :params
+            poscar_index: The index of the POSCAR file to find the space group for.
+
+        :return: The space group number corresponding to the POSCAR index.
+        """
         cumulative = 0
         for idx, count in enumerate(self.group_counts, start=1):
             if cumulative <= poscar_index < cumulative + count:
@@ -219,6 +243,11 @@ class CrystalGenerator:
     def dpdisp_mlp_tasks(self, machine: str, resources: str, nodes: int = 1):
         """
         Based on the dpdispatcher module, prepare and submit files for optimization on remote server or local machine.
+
+        params:
+            machine: The machine configuration file for dpdispatcher, can be in JSON or YAML format.
+            resources: The resources configuration file for dpdispatcher, can be in JSON or YAML format.
+            nodes: The number of nodes to be used for optimization, default is 1.
         """
         # 调整工作目录，减少错误发生
         os.chdir(self.primitive_cell_dir)
@@ -233,26 +262,31 @@ class CrystalGenerator:
             machine = Machine.load_from_yaml(machine)
         else:
             raise KeyError("Not supported machine file type")
+        if resources.endswith(".json"):
+            resources = Resources.load_from_json(resources)
+        elif resources.endswith(".yaml"):
+            resources = Resources.load_from_yaml(resources)
+        else:
+            raise KeyError("Not supported resources file type")
         # 由于dpdispatcher对于远程服务器以及本地运行的forward_common_files的默认存放位置不同，因此需要预先进行判断，从而不改动优化脚本
         machine_inform = machine.serialize()
+        resources_inform = resources.serialize()
         if machine_inform["context_type"] == "SSHContext":
             # 如果调用远程服务器，则创建二级目录
             parent = "data/"
         elif machine_inform["context_type"] == "LocalContext":
             # 如果在本地运行作业，则只在后续创建一级目录
             parent = ""
-            # 如果是本地运行，则根据显存占用率阈值，等待可用的GPU
-            selected_gpu = wait_for_gpu(memory_percent_threshold=40, wait_time=600)
-            os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu)
+            if (
+                machine_inform["batch_type"] == "Shell"
+                and resources_inform["gpu_per_node"] != 0
+            ):
+                # 如果是本地运行，则根据显存占用率阈值，等待可用的GPU
+                selected_gpu = _wait_for_gpu(memory_percent_threshold=40, wait_time=600)
+                os.environ["CUDA_VISIBLE_DEVICES"] = str(selected_gpu)
 
-        from dpdispatcher import Resources, Task, Submission
+        from dpdispatcher import Task, Submission
 
-        if resources.endswith(".json"):
-            resources = Resources.load_from_json(resources)
-        elif resources.endswith(".yaml"):
-            resources = Resources.load_from_yaml(resources)
-        else:
-            raise KeyError("Not supported resources file type")
         # 依次读取primitive_cell文件夹中的所有POSCAR文件和对应的序号
         primitive_cell_file_index_pairs = self._sequentially_read_files(
             self.primitive_cell_dir, prefix_name="POSCAR_"
@@ -337,8 +371,14 @@ class CrystalGenerator:
         logging.info("Batch optimization completed!!!")
 
 
-def get_available_gpus(memory_percent_threshold=40):
-    """获取可用的 GPU 节点，内存负载低于指定阈值且没有其他用户的任务在运行"""
+def _get_available_gpus(memory_percent_threshold=40):
+    """
+    Private method:
+    Get available GPUs with memory usage below the specified threshold.
+
+    params:
+        memory_percent_threshold (int): The threshold for GPU memory usage percentage.
+    """
     try:
         # 获取 nvidia-smi 的输出
         output = subprocess.check_output(
@@ -368,10 +408,16 @@ def get_available_gpus(memory_percent_threshold=40):
         return []
 
 
-def wait_for_gpu(memory_percent_threshold=40, wait_time=300):
-    """等待直到有可用的 GPU"""
+def _wait_for_gpu(memory_percent_threshold=40, wait_time=300):
+    """
+    Private method:
+    Wait until a GPU is available with memory usage below the specified threshold.
+    params:
+        memory_percent_threshold (int): The threshold for GPU memory usage percentage.
+        wait_time (int): The time to wait before checking again, in seconds.
+    """
     while True:
-        available_gpus = get_available_gpus(memory_percent_threshold)
+        available_gpus = _get_available_gpus(memory_percent_threshold)
         logging.info(f"Available GPU: {available_gpus}")
         if available_gpus:
             selected_gpu = available_gpus[0]

ion_CSP/identify_molecules.py

@@ -7,6 +7,17 @@ from ase.neighborlist import NeighborList, natural_cutoffs
 
 
 def identify_molecules(atoms) -> Tuple[List[Dict[str, int]], bool]:
+    """
+    Identify independent molecules in a given set of atoms.
+    This function uses a depth-first search (DFS) approach to find connected components in the atomic structure,
+    treating each connected component as a separate molecule.
+    params:
+        atoms: ASE Atoms object containing the atomic structure.
+    returns:
+        A tuple containing:
+        - A list of dictionaries, each representing a molecule with element counts.
+        - A boolean flag indicating whether the identified molecules match the initial set of molecules.
+    """
     visited = set()  # 用于记录已经访问过的原子索引
     identified_molecules = []   # 用于存储识别到的独立分子
     # 基于共价半径为每个原子生成径向截止
@@ -63,6 +74,10 @@ def identify_molecules(atoms) -> Tuple[List[Dict[str, int]], bool]:
 def molecules_information(molecules: List[Dict[str, int]], molecules_flag: bool, initial_information: List[Dict[str, int]]):
     """
     Set the output format of the molecule. Output simplified element information in the specified order of C, N, O, H, which may include other elements.
+    params:
+        molecules: A list of dictionaries representing identified molecules with element counts.
+        molecules_flag: A boolean flag indicating whether the identified molecules match the initial set of molecules.
+        initial_information: A list of dictionaries representing the initial set of molecules with element counts.
     """
     # 定义固定顺序的元素
     fixed_order = ['C', 'N', 'O', 'H']

ion_CSP/log_and_time.py

@@ -11,7 +11,14 @@ from dpdispatcher.dlog import dlog
 
 
 def log_and_time(func):
-    """Decorator for recording log information and script runtime"""
+    """
+    Decorator for recording log information and script runtime
+
+    :params
+        func: The function to be decorated
+        
+    :return: The decorated function with logging and timing capabilities
+    """
     @functools.wraps(func)
     def wrapper(work_dir, *args, **kwargs):
         # 使用inspect获取真实脚本文件名
@@ -54,20 +61,49 @@ def log_and_time(func):
 
 
 def merge_config(default_config, user_config, key):
+    """
+    Merge default configuration with user-provided configuration for a specific key.
+
+    :params 
+        default_config: The default configuration dictionary.
+        user_config: The user-provided configuration dictionary.
+        key: The key for which the configuration should be merged.
+
+    :return: A merged configuration dictionary for the specified key.
+    """
+    if key not in default_config:
+        raise KeyError(f"Key '{key}' not found in default configuration.")
+    if key not in user_config:
+        raise KeyError(f"Key '{key}' not found in user configuration.")
+    if not isinstance(default_config[key], dict) or not isinstance(user_config.get(key, {}), dict):
+        raise TypeError(f"Both default and user configurations for '{key}' must be dictionaries.")
+    # 合并两个参数配置，优先使用用户参数配置
     return {**default_config[key], **user_config.get(key, {})}
 
 
 class StatusLogger:
+    """
+    A singleton class to log the status of a workflow, including RUNNING, SUCCESS, FAILURE, and KILLED.
+    It initializes a logger that writes to a log file and a YAML file to record the status of the workflow.
+    The logger captures the process ID and handles termination signals (SIGINT, SIGTERM).
+    """
+    _name = "WorkflowLogger"
     _instance = None
 
     def __new__(cls, *args, **kwargs):
+        """Ensure that only one instance of StatusLogger is created (Singleton Pattern)"""
         if not cls._instance:
             cls._instance = super(StatusLogger, cls).__new__(cls)
             cls._instance.__init__(*args, **kwargs)
         return cls._instance
 
     def __init__(self, work_dir, task_name):
-        """Initialize workflow status logger and generate the .log and .yaml file to record the status"""
+        """
+        Initialize workflow status logger and generate the .log and .yaml file to record the status
+
+        :params
+            work_dir: The working directory where the log and yaml files will be created
+            task_name: The name of the task to be logged"""
         # 使用单例模式，避免重复的日志记录，缺点是再重新给定task_name之后会覆盖原来的实例，只能顺序调用
         self.task_name = task_name
         log_file = os.path.join(work_dir, "workflow_status.log")
@@ -97,12 +133,17 @@ class StatusLogger:
         self._init_yaml()
 
     def set_running(self):
+        """
+        Set the current task status to RUNNING and log the event.
+        This method increments the run count and updates the YAML file.
+        """
         self.current_status = "RUNNING"
         self.logger.info(f"{self.task_name} Status: {self.current_status}")
         self.run_count += 1
         self._update_yaml()
 
     def set_success(self):
+        """Set the current task status to SUCCESS and log the event"""
         self.current_status = "SUCCESS"
         self.logger.info(f"{self.task_name} Status: {self.current_status}\n")
         self._update_yaml()
@@ -112,12 +153,16 @@ class StatusLogger:
         return self.current_status == "SUCCESS"
 
     def set_failure(self):
+        """Set the current task status to FAILURE and log the event"""
         self.current_status = "FAILURE"
         self.logger.error(f"{self.task_name} Status: {self.current_status}\n")
         self._update_yaml()
 
     def _signal_handler(self, signum, _):
-        """Handle termination signals and log the event"""
+        """
+        Handle termination signals and log the event
+        :params
+            signum: The signal number received (e.g., SIGINT, SIGTERM)"""
         if signum == 2:
             self.logger.warning(
                 f"Process {os.getpid()} has been interrupted by 'Ctrl + C'\n"
@@ -134,6 +179,7 @@ class StatusLogger:
         sys.exit(0)
 
     def _set_killed(self):
+        """Set the current task status to KILLED and log the event"""
         self.current_status = "KILLED"
         self.logger.warning(f"{self.task_name} Status: {self.current_status}\n")
         self._update_yaml()
@@ -193,11 +239,12 @@ def redirect_dpdisp_logging(custom_log_path):
 
 
 def get_work_dir_and_config():
-    """获取工作目录并加载配置文件
-    Returns:
-        tuple: (工作目录路径, 合并后的配置字典)
-    Raises:
-        SystemExit: 当输入无效时退出程序
+    """
+    Get the working directory and user configuration from command line arguments or interactive input.
+    If the working directory is not specified, it prompts the user to input it interactively.
+    It also reads the configuration from a 'config.yaml' file in the specified directory.
+    
+    :return: A tuple containing the working directory and the user configuration dictionary.
     """
     parser = argparse.ArgumentParser(
         description="The full workflow of ionic crystal design for a certain ion combination, including generation, mlp optimization, screening, vasp optimization and analysis."

ion_CSP/mlp_opt.py

@@ -14,13 +14,22 @@ base_dir = os.path.dirname(__file__)
 relative_path = './model.pt'
 file_path = os.path.join(base_dir, relative_path)
 calc = DP(file_path)
-'''
+"""
 structure optimization with DP model and ASE
 PSTRESS and fmax should exist in input.dat
-'''
+"""
 
 def get_element_num(elements):
-    '''Using the Atoms.symples to Know Element&Num'''
+    """
+    Using the Atoms.symples to Know Element and Number
+
+    :params
+        elements: list of elements in the structure
+
+    :returns
+        element: list of unique elements in the structure
+        ele: dictionary with elements as keys and their counts as values
+    """
     element = []
     ele = {}
     element.append(elements[0])
@@ -32,7 +41,15 @@ def get_element_num(elements):
     return element, ele 
         
 def write_CONTCAR(element, ele, lat, pos, index):
-    '''Write CONTCAR''' 
+    """
+    Write CONTCAR file in VASP format
+
+    :params
+        element: list of elements in the structure
+        ele: dictionary of element counts
+        lat: lattice vectors
+        pos: atomic positions in direct coordinates
+        index: index for the output file""" 
     f = open(f'{base_dir}/CONTCAR_'+str(index),'w')
     f.write('ASE-DPKit-Optimization\n')
     f.write('1.0\n') 
@@ -51,7 +68,21 @@ def write_CONTCAR(element, ele, lat, pos, index):
         f.write('%15.10f %15.10f %15.10f\n' % tuple(dpos[i]))
         
 def write_OUTCAR(element, ele, masses, volume, lat, pos, ene, force, stress, pstress, index):
-    '''Write OUTCAR'''
+    """
+    Write OUTCAR file in VASP format
+    :params
+        element: list of elements in the structure
+        ele: dictionary of element counts
+        masses: total mass of the atoms
+        volume: volume of the unit cell
+        lat: lattice vectors
+        pos: atomic positions in direct coordinates
+        ene: total energy of the system
+        force: forces on the atoms
+        stress: stress tensor components
+        pstress: external pressure
+        index: index for the output file
+    """
     f = open(f'{base_dir}/OUTCAR_'+str(index),'w')
     for x in element: 
         f.write('VRHFIN =' + str(x) + '\n')
@@ -88,6 +119,13 @@ def write_OUTCAR(element, ele, masses, volume, lat, pos, ene, force, stress, pst
     f.write('enthalpy TOTEN    = %20.6f %20.6f\n' % (enthalpy, enthalpy/na)) 
         
 def get_indexes():
+    """
+    Get the indexes of POSCAR files in the current directory.
+    This function scans the current directory for files starting with 'POSCAR_' and extracts their numeric indexes.
+
+    :returns
+        A sorted list of indexes extracted from the POSCAR files.
+    """
     base_dir = os.path.dirname(__file__)
     POSCAR_files = [f for f in os.listdir(base_dir) if f.startswith('POSCAR_')]
     indexes = []
@@ -100,7 +138,11 @@ def get_indexes():
     return indexes
 
 def run_opt(index: int): 
-    '''Using the ASE&DP to Optimize Configures''' 
+    """
+    Using the ASE&DP to Optimize Configures
+    :params
+        index: index of the POSCAR file to be optimized
+    """
     if os.path.isfile(f'{base_dir}/OUTCAR'):
         os.system(f'mv {base_dir}/OUTCAR {base_dir}/OUTCAR-last')
     fmax, pstress = 0.03, 0
@@ -143,6 +185,10 @@ def run_opt(index: int):
 
 
 def main():
+    """
+    Main function to run the optimization in parallel.
+    It initializes a multiprocessing pool and maps the run_opt function to the indexes of POSCAR files.
+    """
     ctx=multiprocessing.get_context("spawn")
     pool=ctx.Pool(8)
     indexes = get_indexes()

ion_CSP/read_mlp_density.py

@@ -9,6 +9,13 @@ from ion_CSP.identify_molecules import identify_molecules, molecules_information
 class ReadMlpDensity:
     
     def __init__(self, work_dir:str):
+        """
+        This class is designed to read and process MLP optimized files, specifically CONTCAR files, to calculate and sort their densities.
+        The class also provides functionality to process these files using phonopy for symmetry analysis and primitive cell generation.
+
+        :params
+            work_dir: The working directory where the MLP optimized files are located.
+        """
         # 获取脚本的当前目录
         self.base_dir = work_dir
         os.chdir(self.base_dir)
@@ -39,7 +46,10 @@ class ReadMlpDensity:
         """
         Obtain the atomic mass and unit cell volume from the optimized CONTCAR file, and obtain the ion crystal density. Finally, take n CONTCAR files with the highest density and save them separately for viewing.
         
-        :param n_screen: 取前n个最大密度的文件
+        :params
+            n_screen: The number of CONTCAR files with the highest density to be saved.
+            molecules_screen: If True, only consider ionic crystals with original ions.
+            detail_log: If True, print detailed information about the molecules identified in the CONTCAR files.
         """
         os.chdir(self.base_dir)
         # 获取所有以'CONTCAR_'开头的文件，并按数字顺序处理
@@ -135,6 +145,10 @@ class ReadMlpDensity:
     def phonopy_processing_max_density(self, specific_directory :str = None):
         """
         Use phonopy to check and generate symmetric primitive cells, reducing the complexity of subsequent optimization calculations, and preventing pyxtal.from_random from generating double proportioned supercells. 
+        
+        :params
+            specific_directory: If specified, phonopy will process the files in this directory instead of the max_density directory.
+            If not specified, it will process the files in the max_density directory.
         """
         if specific_directory:
             self.phonopy_dir = os.path.join(self.base_dir, specific_directory)

{run → ion_CSP/run}/main_EE.py

@@ -1,4 +1,3 @@
-import os
 import logging
 from ion_CSP.convert_SMILES import SmilesProcessing
 from ion_CSP.empirical_estimate import EmpiricalEstimation
@@ -31,11 +30,10 @@ DEFAULT_CONFIG = {
 @log_and_time
 def main(work_dir, config):
     logging.info(f"Using config: {config}")
-    empirical_estimate_dir = os.path.join(work_dir, "1_2_Gaussian_optimized")
     tasks = {
         "0_convertion": lambda: convertion_task(work_dir, config),
-        "0_estimation": lambda: estimation_task(empirical_estimate_dir, config),
-        "0_update_combo": lambda: combination_task(empirical_estimate_dir, config),
+        "0_estimation": lambda: estimation_task(work_dir, config),
+        "0_update_combo": lambda: combination_task(work_dir, config),
     }
     for task_name, task_func in tasks.items():
         task_logger = StatusLogger(work_dir=work_dir, task_name=task_name)
@@ -52,7 +50,7 @@ def main(work_dir, config):
         task_logger = StatusLogger(work_dir=work_dir, task_name="0_update_combo")
         try:
             task_logger.set_running()
-            combination_task(empirical_estimate_dir, config)
+            combination_task(work_dir, config)
             task_logger.set_success()
         except Exception:
             task_logger.set_failure()
@@ -94,14 +92,6 @@ def estimation_task(work_dir, config):
     estimation.multiwfn_process_fchk_to_json()
     # 由于后续晶体生成不支持 .log 文件，需要将 Gaussian 优化得到的 .log 文件最后一帧转为 .gjf 结构文件
     estimation.gaussian_log_to_optimized_gjf()
-    # 如果依据密度排序，则需要经验公式根据配比生成离子晶体组合，读取 .json 文件并将静电势分析得到的各离子性质代入经验公式
-    if config["empirical_estimate"]["sort_by"] == "density":
-        # 最终将预测的离子晶体密度以及对应的组分输出到 .csv 文件并根据密度从大到小排序
-        estimation.empirical_estimate()
-    # 如果依据氮含量排序，则调用另一套根据 .gjf 文件中化学分布信息
-    elif config["empirical_estimate"]["sort_by"] == "nitrogen":
-        # 最终将预测的离子晶体氮含量以及对应的组分输出到 .csv 文件并根据氮含量从大到小排序
-        estimation.nitrogen_content_estimate()
 
 def combination_task(work_dir, config):
     # 在工作目录下准备 Gaussian 优化处理后具有 .gjf、.fchk 和 .log 文件的文件夹, 并提供对应的离子配比
@@ -111,6 +101,14 @@ def combination_task(work_dir, config):
         ratios=config["empirical_estimate"]["ratios"],
         sort_by=config["empirical_estimate"]["sort_by"],
     )
+    # 如果依据密度排序，则需要经验公式根据配比生成离子晶体组合，读取 .json 文件并将静电势分析得到的各离子性质代入经验公式
+    if config["empirical_estimate"]["sort_by"] == "density":
+        # 最终将预测的离子晶体密度以及对应的组分输出到 .csv 文件并根据密度从大到小排序
+        combination.empirical_estimate()
+    # 如果依据氮含量排序，则调用另一套根据 .gjf 文件中化学分布信息
+    elif config["empirical_estimate"]["sort_by"] == "nitrogen":
+        # 最终将预测的离子晶体氮含量以及对应的组分输出到 .csv 文件并根据氮含量从大到小排序
+        combination.nitrogen_content_estimate()
     # 基于排序依据 sort_by 对应的 .csv 文件创建 combo_n 文件夹，并复制相应的 .gjf 结构文件。
     if config["empirical_estimate"]["make_combo_dir"]:
         combination.make_combo_dir(

ion_CSP/task_manager.py

@@ -31,7 +31,7 @@ class TaskManager:
         try:
             return importlib.metadata.version("ion_CSP")
         except importlib.metadata.PackageNotFoundError:
-            logging.error("Version detection failed")
+            logging.error("Package not found")
             return "unknown"
         except Exception as e:
             logging.error(f"Version detection failed: {e}")
@@ -225,7 +225,7 @@ class TaskManager:
         pid_file = work_dir / "pid.txt"
 
         # 动态加载模块
-        module_name = f"run.main_{module}"
+        module_name = f"ion_CSP.run.main_{module}"
         spec = importlib.util.find_spec(module_name)
         if not spec:
             raise ImportError(f"Module {module_name} not found")

ion_CSP/upload_download.py

@@ -484,4 +484,3 @@ class SSHBatchJob:
     def close_connection(self):
         self.sftp.close()
         self.client.close()
-