PipeGraphPy 0.0.25a1__tar.gz → 0.0.26a1__tar.gz

{PipeGraphPy-0.0.25a1/src/PipeGraphPy.egg-info → PipeGraphPy-0.0.26a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PipeGraphPy
-Version: 0.0.25a1
+Version: 0.0.26a1
 Summary: 核心算法框架
 Home-page: https://gitee.com/zsq_tee/pipe-graph-py
 Author: zhengshuiqing

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/README.md

@@ -1,14 +1,5 @@
  # Python 三方库 PipeGraphPy 使用手册
-## 1. 简介
-本文档为您介绍一款实用的 Python 三方库 PipeGraphPy，旨在帮助您快速上手并熟练使用该库。库名称：**PipeGraphPy**。本文档将分为以下几个部分进行介绍：
-- 软件介绍
-- 安装
-- 基本使用  
-- 高级功能  
-- 示例代码  
-- 常见问题与解决方案  
-- 参考文献
-## 软件介绍
+## 1. 软件介绍
 
 ### 软件简介
 
@@ -19,26 +10,6 @@ PipeGraphPy是一个Python三方库，主要功能是构建一种可用于训练
 - 图模型：一种有向无环图模型，可执行训练、预测、保存、载入等一般模型的操作。
 - 模型节点：组装图模型的节点，可以看做是模型组件的实例化对象，模型节点和模型节点之间可以执行连接操作。
 - 模型组件：图模型节点的种类，本软件把软件的种类分为一下几种：
-    - 数据导入(ImportData)
-    - 前处理(Preprocessor)
-    - 特征选择(Selector)
-    - 特征转换(Transformer)
-    - 回归算法(Regressor)
-    - 分类算法(Classifier)
-    - 深度学习(Deeplearning)
-    - 集成学习()
-    - 后处理(Postprocessor)
-    1、数据导入(ImportData)：导入模型训练预测评估使用的数据。
-    2、前处理(Preprocessor)：数据清洗：缺失值处理，异常值处理，降噪、过滤等方法。
-    3、特征选择(Selector)：从原始特征中选择出对目标变量有重要影响的特征。例如：SKlearn中的feature_selection或XGB中的feature_importances_
-    4、特征转换(Transformer)：训练特征发生了转变。例如：主成分分析（PCA）或线性判别分析（LDA）
-    5、回归算法(Regressor)：sklearn, xgboost, 在组件内部可以使用交叉验证，网格搜索， 常用的有：MLP，SVM（SVR），随机森林，GridSearch。
-    6、分类算法(Classifier): 
-    6、深度学习(Deeplearning)：pytouch,tensorflow,keras, 常用的GRU,LSTM,ConLSTM,CNN。
-    7、集成学习()：多模型数据替换，数据平均法、加权平均法，甚至可以实现stacking功能。
-    8、后处理(Postprocessor)：预测数据的后处理，例如：装机容量的限制，数据入库，数据发送。
-    9、数据拆分(Split): 一个数据拆分成多个数据。
-    10、数据合并(Merge)：多个数据合并为一个数据。
 - 模型连线: 模型节点和模型节点之间的连线，代表着模型中数据的流向，模型数据是pandas库提供的DataFrame格式
 
 ### 图模型框架
@@ -49,16 +20,40 @@ PipeGraphPy是一个Python三方库，主要功能是构建一种可用于训练
 
 #### 简单结构
 
+简单的模型结构只包含，数据导入、前处理(可省略)、算法、后处理(可省略)节点，如下图所示：
+
+![简单模型](./简单模型.png)
+
 #### 复杂结构
 
+复杂的模型可有多个数据导入、前处理、算法和后处理节点，复杂模型还需要包含一个集成学习节点，集成学习节点下还可以连接后处理或集成学习节点，结构如下图所示：
+
+![复杂模型](./复杂模型.png)
+
 
 ## 2. 安装
 ### 2.1 安装
 安装 PipeGraphPy 需要有Python的环境，以及Python的pip包管理工具
 使用以下命令安装 PipeGraphPy：
+
+(1) 使用程序源码安装
+
+```bash  
+python setup.py install
+```
+
+(2) 使用程序安装包安装
+
 ```bash  
-pip install PipeGraphPy
+pip install PipeGraphPy-0.0.25.tar.gz
 ```
+
+(3) 使用pypi官方库联网安装
+
+```bash  
+pip install PipeGraphPy -i https://pypi.org/simple
+```
+
 ## 3. 基本使用
 ### 3.1 库导入
 在使用PipeGraphPy库时，主要使用其三个子类，导入方式如下：
@@ -73,6 +68,8 @@ from PipeGraphPy import Graph, Node, Module
 - test_data.py
 
 ```
+import pandas ad pd
+
 class ImportExample():
     __version__ = "v1"
     TEMPLATE = [
@@ -221,7 +218,7 @@ model.print()
 # 训练模型
 model.run()
 # 保存模型
-clone_model.save("svm_model.pkl")
+clone_model.save("/home/name/svm_model.pkl")
 
 ```
 
@@ -232,7 +229,7 @@ clone_model.save("svm_model.pkl")
 
 ```
 # 载入模型
-model = Graph.load("svm_model.pkl")
+model = Graph.load("/home/name/svm_model.pkl")
 # 模型预测
 predict_res = model.predict()
 # 查看预测结果
@@ -245,13 +242,12 @@ print(predict_res)
 
 - 1、创建自定义模型
 ```python
-help(Graph.create)
-custom_model = Graph.create(instance_id="电场id", name="模型名称")
+custom_model = Graph.create(name="模型名称")
 ```
 
 - 2、克隆已有模型
 ```
-clone_model = Graph(760).clone()
+clone_model = custom_model.clone()
 clone_model.print()
 ```
 
@@ -282,7 +278,7 @@ pred_res = reload_model.predict()
 #### 3.3.2 Module 模块
 
 - 1、新建组件
- `help(Module.create)`
+ `module = Module.create(mtype="ImportData", mcls=ImportExample)`
 
 图模型节点的种类，本软件把软件的种类分为一下几种：
     1、数据导入(ImportData)：导入模型训练预测评估使用的数据。
@@ -319,27 +315,26 @@ class ImportDataExample():
     __version__ = "v1.1"
     def __init__(self,**kw):
         self.params = kw
-        self.farm_info = kw.get('biz info')
     def run(self):
         train_df = pd.DataFrame({
-            "dtime":["2022-08-25 08:19:00","2022-08-25 08:19:15"],
-            "EC_wspd_70_001":[12,8],
-            "r_apower":[2300,1200],
+            "time":["2022-08-25 08:19:00","2022-08-25 08:19:15"],
+            "ws":[12,8],
+            "power":[2300,1200],
         })
         train_df = train_df.set_index("dtime")
         return train_df
     def evaluate(self):
         evaluate_df = pd.DataFrame({
-            "dtime": ["2022-08-26 08:19:00","2022-08-26 08:19:15"],
-            "EC_wspd_70_001":[24,12],
-            "r_apower":[200,800],
+            "time": ["2022-08-26 08:19:00","2022-08-26 08:19:15"],
+            "ws":[24,12],
+            "power":[200,800],
         })
         evaluate_df = evaluate_df.set_index("dtime")
         return evaluate_df
     def predict(self):
         predict_df = pd.DataFrame({
-            "dtime": ["2022-09-09 08:19:00","2022-09-09 08:19:15"],
-            "EC_wspd_70_001":[11,18],
+            "time": ["2022-09-09 08:19:00","2022-09-09 08:19:15"],
+            "ws":[11,18],
         })
         predict_df = predict_df.set_index("dtime")
         return predict_df
@@ -368,52 +363,33 @@ class ImportDataExample():
 代码示例:
 
 ```python
+
 import pandas as pd
-import numpy as np
-import algo_data
-from scipy import interpolate
+from pandasql import sqldf
 
-class FilterManual():
+class SqlFilter():
+    __version__ = '0.0.2'
     def __init__(self, **kw):
         self.params = kw
-        self.farm_info = kw.get('farm_info')
+        self.farm_info = kw.get('biz_info')
 
-    def transform(self, X):
+    def _sqlfilter(self, sql, X, y=None):
+        X, y = X, pd.DataFrame() if y is None else y
+        if sql:
+            filter_X = sqldf(sql, locals())
+            self.print(X.index.name)
+            filter_X = filter_X.set_index(X.index.name)
+            filter_X.index = filter_X.index.astype(X.index.dtype)
+            X = filter_X
         return X
 
+    def transform(self, X):
+        sql = self.params.get('predict_sql') or self.params.get('sql')
+        return self._sqlfilter(sql, X)
+
     def fit_transform(self, X, y=None):
-        data = X
-        fl = algo_data.filter_config(wfid=self.farm_info.get('wfid'))
-        if not fl.empty:
-            df = data.copy()
-            df.loc[df['r_wspd'].values < 0, 'r_wspd']=0
-            df.loc[df['r_apower'].values < 0, 'r_apower']=0
-            indexs = list(df[np.isnan(df['r_wspd'])].index)
-            df = df.drop(indexs)
-            indexs = list(df[np.isnan(df['r_apower'])].index)
-            df = df.drop(indexs)
-            wspd=df['r_wspd'].values
-            wspd_max=np.max(wspd)
-            if wspd_max>25:
-                u_add=np.linspace(25+10**-10,wspd_max,20)
-                add_values = pd.DataFrame(columns = ["Num", "speed_u","power_u","speed_d","power_d"])
-                add_values['speed_u'],add_values['speed_d']=u_add,u_add
-                add_values['power_u'],add_values['power_d']=fl['power_u'][999],fl['power_d'][999]
-                add_values['Num']=np.linspace(1001,1020,20)
-                fl = fl.append(add_values,ignore_index=True)
-
-            f_up = interpolate.interp1d(fl['speed_u'].values,fl['power_u'].values,kind='quadratic')
-            f_down = interpolate.interp1d(fl['speed_d'].values,fl['power_d'].values,kind='quadratic')
-            df['up_power']=f_up(df['r_wspd'])
-            df['down_power']=f_down(df['r_wspd'])
-            df.loc[df['r_apower'].values > df['up_power'].values, 'flag']=1
-            df.loc[df['r_apower'].values < df['down_power'].values, 'flag']=1
-            df.loc[df['r_apower'].values > df['up_power'].values, 'r_apower']=(df['up_power']+df['down_power'])/2
-            df.loc[df['r_apower'].values < df['down_power'].values, 'r_apower']=(df['up_power']+df['down_power'])/2
-            del df['up_power'],df['down_power']
-            return df
-        else:
-            return data
+        sql = self.params.get('fit_sql') or self.params.get('sql')
+        return self._sqlfilter(sql, X, y)
 
 ```
 #### 3、回归算法（Regressor）、分类算法（Classifier）、深度学习(Deeplearning)代码规范：
@@ -435,7 +411,6 @@ class SVM():
     def __init__(self, **kw):
         self.params = kw
         self.algo_param = kw.get('algo_param', dict())
-        self.__author__ = 'Song Dian'
         self.model = SVR(**self.algo_param)
         self.scaler_x = StandardScaler()
         self.scaler_y = StandardScaler()
@@ -468,15 +443,11 @@ class zeroToCap():
     __version__ = "v1.1"
     def __init__(self, **kw):
         self.params = kw
-        self.farm_info = kw.get('biz_info')
 
     def transform(self, df):
-        assert self.farm_info['powercap'], '场站没有配置装机容量powercap'
-        # 取装机容量
-        powercap = self.farm_info['powercap']
-        # 对预测值处理
-        if 'r_apower_predict' in df.columns:
-            df.loc[:, 'r_apower_predict'] = df['r_apower_predict'].apply(
+        powercap = 50
+        if 'power_predict' in df.columns:
+            df.loc[:, 'power_predict'] = df['power_predict'].apply(
                 lambda x: 0 if x < 0 else int(
                     powercap) if x > int(powercap) else x
             )
@@ -525,7 +496,6 @@ params_rules = {
 #### 3.3.3 Node 模块
 - 1、创建新的节点
 ```python
-help(Node.create)
 # 线上组件节点
 import_node = Node.create(online_module, graph=custom_graph, name="线上模型节点") # name可省略
 # 自定义组件节点
@@ -546,7 +516,7 @@ reg_node.run(train_data)  # 传递上一节点数据
 - 3、节点参数设置
 ```python
 # 默认参数
-import_node.default_params
+default_params = import_node.default_params
 # 修改默认参数
 import_node.params = {
     'data_length': 4,
@@ -556,55 +526,3 @@ import_node.params = {
 import_node.run()
 ```
 
-
-以下为您介绍库中的常用功能：
-- 功能 1：
-  ```python  
-  xxx 库。功能 1()  
-  ```
-- 功能 2：
-  ```python  
-  xxx 库。功能 2(参数 1, 参数 2)  
-  ```
-## 4. 组件开发规范
-以下为您介绍库的高级功能：
-- 高级功能 1：
-  ```python  
-  xxx 库。高级功能 1(参数 1, 参数 2)  
-  ```
-- 高级功能 2：
-  ```python  
-  xxx 库。高级功能 2(参数 1, 参数 2)  
-  ```
-## 5. 示例代码
-以下是一个完整的示例代码：
-```python  
-# 导入库  
-import xxx 库
-# 功能 1 示例  
-xxx 库。功能 1()
-# 功能 2 示例  
-xxx 库。功能 2(参数 1, 参数 2)
-# 高级功能 1 示例  
-xxx 库。高级功能 1(参数 1, 参数 2)
-# 高级功能 2 示例  
-xxx 库。高级功能 2(参数 1, 参数 2)  
-```
-## 6. 常见问题与解决方案
-### 6.1 问题 1
-描述：在使用过程中，可能会遇到问题 1。
-解决方案：
-1. 检查库版本，确保与您的 Python 版本兼容。  
-2. 检查导入语句，确保正确导入库。  
-3. 检查参数传递，确保符合函数参数要求。
-### 6.2 问题 2
-描述：在使用过程中，可能会遇到问题 2。
-解决方案：
-1. 更新库版本，确保使用最新功能。  
-2. 查阅文档，了解详细使用方法。  
-3. 在官方论坛或社区寻求帮助。
-## 7. 参考文献
-- [Python 官方文档](https://docs.python.org/3/index.html)  
-- [库官方文档](https://www.example.com/doc/xxx 库)  
-- [Python 教程](https://www.runoob.com/python/python-tutorial.html)
-本文档仅供参考，具体使用过程中遇到的问题，请随时查阅相关文献或与开发者联系。感谢您的使用和支持！

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/src/PipeGraphPy/__init__.py

@@ -1,6 +1,6 @@
 # coding:utf-8
 
-__version__ = "0.0.25a1"
+__version__ = "0.0.26a01"
 
 from PipeGraphPy.core.graph import Graph, graph_predict, graph_evaluate, online_graph_evaluate, online_graph_predict, graph_run, graph_backtest
 from PipeGraphPy.core.module import Module

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/src/PipeGraphPy/storage/__init__.py

@@ -1,9 +1,9 @@
-from . import redis_backend
+# from . import redis_backend
 from . import file_backend
 from PipeGraphPy.config import settings
 
 storage_backend = {
-    'redis': redis_backend,
+    # 'redis': redis_backend,
     'file': file_backend
 }
 

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/src/PipeGraphPy/storage/file_backend.py

@@ -14,7 +14,6 @@ from PipeGraphPy.constants import (
         NODE_OUTPUT_KEY, MOD_RETURN_RESULT,
         ALGO_MOD_TYPE, MODULES, SCENETYPE)
 from PipeGraphPy.logger import rlog
-from PipeGraphPy.db.models import AlgoModTypeTB
 
 ttl = 7
 
@@ -320,8 +319,8 @@ def trans_deeplearning_algo_model(graph, folder_path=None, is_load=False):
     for k, v in graph.a.nodes_dict.items():
         if v.module.parent.info["cls_name"] == MODULES.DEEPLEARNING:
             if v.module.info.get("algo_type_id"):
-                algo_mod_type = AlgoModTypeTB.find_one(id=v.module.info['algo_type_id'])
-                if algo_mod_type and hasattr(v.algo_instance, "model"):
+                algo_mod_type_name = v.module.info.get('algo_mod_type_name')
+                if algo_mod_type_name and hasattr(v.algo_instance, "model"):
                     func = None
                     if is_load:
                         if isinstance(v.algo_instance.model, str):
@@ -333,7 +332,7 @@ def trans_deeplearning_algo_model(graph, folder_path=None, is_load=False):
                         v.algo_instance.model = func(
                             graph.id,
                             v.info['id'],
-                            algo_mod_type['mod_name'],
+                            algo_mod_type_name,
                             v.algo_instance.model,
                             folder_path,
                         )

PipeGraphPy-0.0.26a1/src/PipeGraphPy/storage/redis_backend.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# import redis
+# import pickle
+# import traceback
+# from PipeGraphPy.storage.base import ParamsPoolBase
+# from PipeGraphPy.utils.format import binary_to_utf8
+# from collections import defaultdict
+# from PipeGraphPy.config import settings
+# from PipeGraphPy.utils.redis_operate import pickle_dumps, pickle_loads
+# from PipeGraphPy.constants import (NODE_STATUS_KEY, NODE_OUTPUT_KEY,
+#                             GRAPH_STATUS_KEY, GRAPH_KEY, MOD_RETURN_RESULT)
+#
+# from PipeGraphPy.logger import rlog
+# redis_conf = dict(
+#     host=settings.REDIS_HOST,
+#     port=settings.REDIS_PORT,
+#     db=settings.REDIS_DB,
+# )
+# redis_key_ttl = settings.REDIS_KEY_TTL
+#
+#
+# redis_conn = redis.Redis(
+#     host=redis_conf['host'], port=redis_conf['port'], db=redis_conf['db'])
+#
+#
+# class ParamsPool(ParamsPoolBase):
+#     '''传参池'''
+#
+#     def __init__(self, graph_id, is_predict=False):
+#         self.graph_id = graph_id
+#         self.is_predict = is_predict
+#
+#     def add_params(self, node, idx, data):
+#         '''添加传参值'''
+#         save_params(self.graph_id, node.id, idx, data, self.is_predict)
+#
+#     def get_params(self, node, idx):
+#         '''获取传参值'''
+#         res = get_params(self.graph_id, node.id, idx,
+#                          is_pd=True, is_predict=self.is_predict)
+#         return res
+#
+#     def add_params_by_list(self, node, data_list):
+#         '''通过数据列表添加传参'''
+#         for idx, data in enumerate(data_list):
+#             self.add_params(node, idx, data)
+#
+#     def is_end(self, node):
+#         '''判断节点是否已运行完'''
+#         return True if self.get_params(node, 0) is not None else False
+#
+#     def check_pass_params(self, node):
+#         '''循环父节点判断父节点是否已结束'''
+#         return all([self.is_end(i) for i in node.fathers])
+#
+#     def gen_pass_params(self, edges_dict, node):
+#         '''生成节点要传入的参数'''
+#         input_output_dict = defaultdict(list)
+#         input_output_list = list()
+#         # 循环所有父节点, 组合node和idx值
+#         for n in node.fathers:
+#             pass_idx = edges_dict[(n.id, node.id)]
+#             out_idx_str, input_idx_str = pass_idx.split('-')
+#             input_output_list.extend(zip(input_idx_str.split(
+#                 ','), [(n, int(i)) for i in out_idx_str.split(',')]))
+#
+#         for i, o in input_output_list:
+#             input_output_dict[int(i)].append(o)
+#
+#         # 根据node和idx获取节点,识别列表，把接口是列表类型的数据放入一个列表中
+#         input_params_list = list()
+#         for k, v in input_output_dict.items():
+#             if len(v) > 1:
+#                 input_params_list.append((k, [self.get_params(*i) for i in v]))
+#             elif len(v) == 1:
+#                 input_params_list.append((k, self.get_params(*v[0])))
+#             else:
+#                 raise Exception('传参错误')
+#         # 参数排序
+#         input_params_list.sort(key=lambda x: x[0])
+#         arg = [i[1] for i in input_params_list]
+#         # 当list输入为1个元素时要转成list
+#         for i, item in enumerate(node.input_data_type):
+#             if item.startswith('list') and not isinstance(arg[i], list):
+#                 arg[i] = [arg[i]]
+#         return arg
+#
+#
+# def save_node_status(node, is_predict=False):
+#     '''保存节点到redis'''
+#     key = NODE_STATUS_KEY.format(graph_id=node.info['graph_id'],
+#                                  node_id=node.id)
+#     redis_conn.hmset(key, node.to_dict())
+#
+#
+# def get_node_status(graph_id, node_id, is_predict=False):
+#     '''获取节点状态到从redis'''
+#     fields = ['val', 'is_pass', 'status', 'run_log']
+#     key = NODE_STATUS_KEY.format(graph_id=graph_id, node_id=node_id)
+#     res = redis_conn.hmget(key, fields)
+#     return dict(zip(fields, binary_to_utf8(res)))
+#
+#
+# def save_graph_status(graph_id, is_predict=False):
+#     '''保存图的状态到redis'''
+#     key = GRAPH_STATUS_KEY.format(graph_id=graph_id)
+#     redis_conn.hmset(key, graph_id)
+#
+#
+# def get_graph_status(graph_id, is_predict=False):
+#     '''获取图状态到从redis'''
+#     fields = ['pid', 'status', 'run_log']
+#     key = GRAPH_STATUS_KEY.format(graph_id=graph_id)
+#     res = redis_conn.hmget(key, fields)
+#     return dict(zip(fields, binary_to_utf8(res)))
+#
+#
+# def save_params(graph_id, node_id, idx, data, is_predict=False):
+#     '''保存图模块输出结果到redis'''
+#     key = NODE_OUTPUT_KEY.format(graph_id=graph_id,
+#                                  node_id=node_id,
+#                                  idx=idx)
+#     pickle_dumps(redis_conn, key, data)
+#
+#
+# def get_params(graph_id, node_id, idx, is_pd=False, is_predict=False):
+#     '''获取图模块输出结果从redis'''
+#     key = NODE_OUTPUT_KEY.format(graph_id=graph_id,
+#                                  node_id=node_id,
+#                                  idx=idx)
+#     return pickle_loads(redis_conn, key)
+#
+#
+# def delete_params(graph_id, is_predict=False):
+#     '''删除所有模块输出结果从redis'''
+#     try:
+#         pattern_key = 'graph_output_%s_*' % graph_id
+#         key_list = redis_conn.keys(pattern=pattern_key)
+#         if key_list:
+#             res = redis_conn.delete(*key_list)
+#             return res
+#         return 1
+#     except Exception:
+#         rlog.error(
+#             traceback.format_exc(),
+#             graph_id=graph_id)
+#
+#
+# def save_graph(graph_id, data, is_predict=False):
+#     '''保存图到redis'''
+#     key = GRAPH_KEY.format(graph_id=graph_id)
+#     pickle_dumps(redis_conn, key, data)
+#
+#
+# def get_graph(graph_id, is_predict=False):
+#     '''获取图从redis'''
+#     key = GRAPH_KEY.format(graph_id=graph_id)
+#     return pickle_loads(redis_conn, key)
+#
+#
+# def push_result(graph_id, data, is_predict=False):
+#     '''增加模块进行结果到redis'''
+#     key = MOD_RETURN_RESULT.format(graph_id=graph_id)
+#     pd_bytes = pickle.dumps(data)
+#     res = redis_conn.lpush(key, pd_bytes)
+#     if not res:
+#         raise Exception('保存数据到redis发生错误')
+#     return res
+#
+#
+# def pop_result(graph_id, is_predict=False):
+#     '''从redis获取模块运行结果'''
+#     try:
+#         key = MOD_RETURN_RESULT.format(graph_id=graph_id)
+#         res = redis_conn.rpop(name=key)
+#         if not res:
+#             return None
+#         res = pickle.loads(res)
+#         return res
+#     except Exception:
+#         rlog.error(traceback.format_exc(), graph_id=graph_id)

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/src/PipeGraphPy/utils/celery_control.py

@@ -5,8 +5,8 @@
 # from PipeGraphPy.asyn.celery import app
 # from celery.app.control import Control
 # from PipeGraphPy.logger import log
-# 
-# 
+#
+#
 # def terminate(task_id):
 #     """停止任务
 #     parameters:

{PipeGraphPy-0.0.25a1 → PipeGraphPy-0.0.26a1}/src/PipeGraphPy/utils/file_operate.py

@@ -4,7 +4,6 @@ import shutil
 import joblib
 import os
 from datetime import datetime, timedelta
-# from celery.exceptions import SoftTimeLimitExceeded
 from PipeGraphPy.db.models import PredictRecordTB