backtest_framework(4)/backtest_framework/run_all.py

import inspect, os, logging
import networkx as nx
from wby_utils.path.Path import get_all_files, get_folders
from .strategy_base import StrategyBase
from collections import deque
import threading
import multiprocessing
from multiprocessing import freeze_support
import concurrent.futures


logging.getLogger('matplotlib').setLevel(logging.WARNING)
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
subclasses_obj = {}

def execute_dag(dag, debug=False):
    # 使用拓扑排序算法推导执行层级
    # sorted_nodes = list(nx.topological_sort(dag))
    topology = []
    # 求每个顶点（A,B,C,D,E,F,G）的入度，保存为字典形式
    level = 0
    result = {}
    degree = {n: dag.in_degree(n)  for n in dag.nodes()}
    # 找到入度为0的顶点，存入一个双向列表
    queue = deque(n  for n, d in degree.items() if not d)
    for i in queue:
        if level not in result.keys():
            result[level] = []
        result[level].append(i)

    while queue:
        #从双向列表的左侧取出第一个入度为0的顶点
        n = queue.popleft()
        topology.append(n)
        # 将所有“以刚取出顶点为前置条件”的顶点的入度-1
        f = False
        for m in list(dag[n]):
            degree[m] -= 1
            # 将新产生的入度为0的顶点存入双向列表
            
            if not degree[m]:
                # 同一拨才添加进去
                if f == False:
                    level += 1
                    f = True
                if level not in result.keys():
                    result[level] = []
                result[level].append(m)
                queue.append(m)
                
    #双向列表为空后，判断是不是所有顶点都进入topology列表了，若不是，说明原图有环，也就不存在拓扑排序了
    if len(topology) < len(dag):
        raise ValueError('graph contains cycle')
    if debug:
        print(result)
        input("按任意键继续....")
    return result


def draw_dag(dag):
    import matplotlib.pyplot as plt

    nx.draw(dag,
            pos = nx.circular_layout(dag), # pos 指的是布局,主要有spring_layout,random_layout,circle_layout,shell_layout
            node_color = 'b',   # node_color指节点颜色,有rbykw,同理edge_color 
            edge_color = 'r',
            with_labels = True,  # with_labels指节点是否显示名字
            arrowsize=20,
            font_size =15,  # font_size表示字体大小,font_color表示字的颜色
            node_size =1)  # font_size表示字体大小,font_color表示字的颜色
    # plt.savefig("network.png")
    # nx.write_gexf(G, 'network.gexf')  # gexf格式文件可以导入gephi中进行分析
    plt.show()


def import_all_factors(folder):
    files = get_all_files(folder)
    for file in files:
        if file[-3:] != ".py":
            continue
        folders = get_folders(file)[:-1]
        file_name = os.path.splitext(os.path.basename(file))[0]
        folders.append(file_name)
        import_path = ""
        for folder in folders:
            if import_path != "":
                import_path += "."
            import_path += f"{folder}"
        import_str = f"from {import_path} import *"
        exec(import_str)


def get_subclasses(cls):
    """
    找到一个抽象父类的所有子类
    :param cls: 抽象父类
    :return: 所有子类的列表
    """
    subclasses = []
    for subclass in cls.__subclasses__():
        if not inspect.isabstract(subclass):
            # 如果子类不是抽象类，添加到列表中
            subclasses.append(subclass)
            # print(str(subclass))
        else:
            # 如果子类是抽象类，递归查找其子类
            subclasses.extend(get_subclasses(subclass))
    return subclasses


def exact_class_name(subclass):
    import re

    # 正则表达式，匹配尖括号内的内容
    pattern = r"'(.*?)'"

    # 在文本中查找匹配项
    matches = re.findall(pattern, str(subclass))

    # 如果没有找到匹配项，尝试匹配单引号中的内容
    if not matches:
        pattern = r"<(.*?)>"
        matches = re.findall(pattern, str(subclass))
        matches = [matches[0].split(" ")[0]]
    

    # 输出匹配项
    names = matches[0].split(".")
    # print(matches, names)

    if names[-1] == "Strategy":
        return names[-2]
    # print(matches[0])
    # return matches[0]


def get_node_numbers(path, debug=False):
    # 创建一个DAG并添加节点
    dag = nx.DiGraph()

    import_all_factors(path)
    subclasses = get_subclasses(StrategyBase)
    logging.info(f"子类：{subclasses}")
    nodes = set()
    edges = []
    for subclass in subclasses:
        name = exact_class_name(subclass)
        print(name)
        pre = subclass.get_pre_factor_name()
        for i in pre:
            edges.append((name, i))
        nodes.add(name)

    for node in nodes:
        dag.add_node(node)
    logging.info(f"因子列表：{nodes}")

    for edge in edges:
        dag.add_edge(edge[1], edge[0])
    logging.info(f"依赖关系：{edges}")

    node_numbers = execute_dag(dag, debug=debug)
    logging.info(f"节点编号：{node_numbers}")
    return node_numbers
    

def run_subclass_and_set_empty(subclass_obj):
    subclass_obj.run()
    key = exact_class_name(subclass_obj)
    print("开始回收内存：", key)
    if key is not None:
        subclasses_obj[key] = None
        print(f"回收{key}内存成功")
    else:
        print(f"回收{key}内存失败")


def cal_all_factors(path, config_path, num_cores=1, debug=False):
    threads = []
    if num_cores == -1:
        num_cores = multiprocessing.cpu_count()
    import_all_factors(path)
    subclasses = get_subclasses(StrategyBase)
    # print(subclasses)

    for subclass in subclasses:
        subclasses_obj[exact_class_name(subclass)] = subclass(config_path)
    node_dict = get_node_numbers(path, debug=debug)

    for i in range(1, len(node_dict)):
        # 创建一个包含num_cores个进程的进程池
        with multiprocessing.Pool(num_cores) as pool:
            # 将任务映射到进程池中的进程
            pool.map(run_subclass_and_set_empty, [subclasses_obj[j] for j in node_dict[i]])

            # print(j)
            # print(subclasses_obj[j].run())


def run_script(script_path):
    cmd = f"python {script_path}"
    print(cmd)
    os.system(cmd)


def run_all(path, thread=4):
    with concurrent.futures.ThreadPoolExecutor(max_workers=thread) as executor:
        for i in os.listdir(path):
            full_path = os.path.join(path, i)
            if os.path.isdir(full_path):
                run_all(full_path, thread)
            else:
                if i[-3:] == ".py":
                    executor.submit(run_script, full_path)


if __name__ == "__main__":
    freeze_support()
    cal_all_factors("factor", num_cores=4, debug=True)