code pdate

client.py

-import pdb
-import collections
 import time
-
+import collections
 from datetime import datetime, timedelta
 from factor import factor_growth, historical_value, factor_per_share_indicators, factor_cash_flow, factor_contrarian, factor_earning
 from factor.ttm_fundamental import *
@@ -11,10 +9,8 @@ from vision.file_unit.income import Income
 from vision.file_unit.valuation import Valuation
 from vision.file_unit.industry import Industry
 from vision.file_unit.indicator import Indicator
-
 from factor.utillities.trade_date import TradeDate
 from ultron.cluster.invoke.cache_data import cache_data
-from ultron.utilities.short_uuid import unique_machine, decode
 
 
 def get_trade_date(trade_date, n):
@@ -48,7 +44,6 @@ def get_basic_growth_data(trade_date):
     :param trade_date: 交易日
     :return:
     """
-
     trade_date_pre_year = get_trade_date(trade_date, 1)
     trade_date_pre_year_2 = get_trade_date(trade_date, 2)
     trade_date_pre_year_3 = get_trade_date(trade_date, 3)
@@ -262,7 +257,6 @@ def get_basic_history_value_data(trade_date):
     ttm_factor_sets_5 = ttm_factor_sets_5.drop(columns={"trade_date"})
 
     # ttm_factor_sets_sum = ttm_factor_sets_sum.rename(columns={"net_profit": "net_profit_5"})
-
     ttm_factor_sets = pd.merge(ttm_factor_sets, ttm_factor_sets_3, on='symbol')
     ttm_factor_sets = pd.merge(ttm_factor_sets, ttm_factor_sets_5, on='symbol')
     # ttm_factor_sets = pd.merge(ttm_factor_sets, ttm_factor_sets_sum, on='symbol')
@@ -375,12 +369,12 @@ def get_basic_cash_flow(trade_date):
                                      Income.total_operating_cost, Income.net_profit,
                                      Income.np_parent_company_owners]
                    }
-    ttm_factor_sets = get_ttm_fundamental([], ttm_factors, trade_date).reset_index()
-    ttm_factor_sets = ttm_factor_sets[-ttm_factor_sets.duplicated()]
+    ttm_cash_flow_sets = get_ttm_fundamental([], ttm_factors, trade_date).reset_index()
+    ttm_cash_flow_sets = ttm_cash_flow_sets[-ttm_cash_flow_sets.duplicated()]
     # 合并
-    ttm_factor_sets = pd.merge(ttm_factor_sets, valuation_sets, on="symbol")
+    ttm_cash_flow_sets = pd.merge(ttm_cash_flow_sets, valuation_sets, on="symbol")
 
-    return tp_cash_flow, ttm_factor_sets
+    return tp_cash_flow, ttm_cash_flow_sets
 
 
 def get_basic_constrain(trade_date):
@@ -408,10 +402,10 @@ def get_basic_constrain(trade_date):
                                    Income.administration_expense
                                    ]}
 
-    ttm_factors_sets = get_ttm_fundamental([], ttm_factors, trade_date).reset_index()
-    ttm_factors_sets = ttm_factors_sets[-ttm_factors_sets.duplicated()]
+    ttm_constrain_sets = get_ttm_fundamental([], ttm_factors, trade_date).reset_index()
+    ttm_constrain_sets = ttm_constrain_sets[-ttm_constrain_sets.duplicated()]
 
-    return balance_sets, ttm_factors_sets
+    return balance_sets, ttm_constrain_sets
 
 
 def get_basic_earning(trade_date):
@@ -572,9 +566,9 @@ if __name__ == '__main__':
         print('per_share_cal_time:{}'.format(time3 - time2))
 
         # cash flow
-        tp_cash_flow, ttm_factor_sets = get_basic_cash_flow(date_index)
+        tp_cash_flow, ttm_cash_flow_sets = get_basic_cash_flow(date_index)
         cache_data.set_cache(session4 + "1", date_index, tp_cash_flow.to_json(orient='records'))
-        cache_data.set_cache(session4 + "2", date_index, ttm_factor_sets.to_json(orient='records'))
+        cache_data.set_cache(session4 + "2", date_index, ttm_cash_flow_sets.to_json(orient='records'))
         factor_cash_flow.factor_calculate(date_index=date_index, session=session4)
         time4 = time.time()
         print('cash_flow_cal_time:{}'.format(time4 - time3))

factor/factor_cash_flow.py

@@ -45,7 +45,8 @@ class FactorCashFlow(FactorBase):
         super(FactorCashFlow, self)._create_tables(create_sql, drop_sql)
 
     # 经营活动净现金流（TTM）/负债（TTM）
-    def nocf_to_t_liability_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def nocf_to_t_liability_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_liability']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToLiabilityTTM'] = np.where(
@@ -56,7 +57,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动净现金流（TTM）/带息负债（TTM）
-    def nocf_to_interest_bear_debt_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def nocf_to_interest_bear_debt_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_liability', 'interest_bearing_liability']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToIBDTTM'] = np.where(
@@ -67,7 +69,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动净现金流（TTM）/净负债（TTM）
-    def nocf_to_net_debt_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def nocf_to_net_debt_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'net_liability']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToNetDebtTTM'] = np.where(CalcTools.is_zero(cash_flow.net_liability.values), 0,
@@ -77,7 +80,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 销售商品和提供劳务收到的现金（TTM）/营业收入（TTM）
-    def sale_service_cash_to_or_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def sale_service_cash_to_or_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['goods_sale_and_service_render_cash', 'operating_revenue']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['SaleServCashToOptReTTM'] = np.where(
@@ -88,7 +92,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/营业收入（TTM）
-    def cash_rate_of_sales_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def cash_rate_of_sales_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'operating_revenue']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToRevTTM'] = np.where(
@@ -99,7 +104,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/(营业总收入（TTM）-营业总成本（TTM）)
-    def nocf_to_operating_ni_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def nocf_to_operating_ni_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_operating_revenue', 'total_operating_cost']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToNetIncomeTTM'] = np.where(
@@ -111,7 +117,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/流动负债（TTM）
-    def oper_cash_in_to_current_liability_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def oper_cash_in_to_current_liability_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_current_liability']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptCFToCurrLiabilityTTM'] = np.where(
@@ -122,7 +129,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 期末现金及现金等价物余额（TTM）/流动负债（TTM）
-    def cash_to_current_liability_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def cash_to_current_liability_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['cash_and_equivalents_at_end', 'total_current_assets']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['CashRatioTTM'] = np.where(CalcTools.is_zero(cash_flow.total_current_assets.values),
@@ -133,7 +141,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/（长期借款（TTM）+ 短期借款（TTM）+ 总市值 - 期末现金及现金等价物（TTM）
-    def cfo_to_ev_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def cfo_to_ev_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'longterm_loan', 'shortterm_loan', 'market_cap',
                         'cash_and_equivalents_at_end']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
@@ -147,7 +156,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # （经营活动产生的金流量净额（TTM） - 净利润（TTM）） /总资产（TTM）
-    def acca_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def acca_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'net_profit', 'total_assets']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptOnReToAssetTTM'] = np.where(CalcTools.is_zero(cash_flow.total_assets.values), 0,
@@ -158,7 +168,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/归属于母公司所有者的净利润（TTM）
-    def net_profit_cash_cover_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def net_profit_cash_cover_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'np_parent_company_owners']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['NetProCashCoverTTM'] = np.where(
@@ -169,7 +180,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（TTM）/总资产（TTM）
-    def oper_cash_in_to_asset_ttm(self, ttm_cash_flow, factor_cash_flow):
+    @staticmethod
+    def oper_cash_in_to_asset_ttm(ttm_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_assets']
         cash_flow = ttm_cash_flow.loc[:, columns_list]
         cash_flow['OptToAssertTTM'] = np.where(CalcTools.is_zero(cash_flow.total_assets.values),
@@ -180,7 +192,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 销售商品和提供劳务收到的现金（Latest）/营业收入（Latest）
-    def sales_service_cash_to_or_latest(self, tp_cash_flow, factor_cash_flow):
+    @staticmethod
+    def sales_service_cash_to_or_latest(tp_cash_flow, factor_cash_flow):
         columns_list = ['goods_sale_and_service_render_cash', 'operating_revenue']
         cash_flow = tp_cash_flow.loc[:, columns_list]
         cash_flow['SalesServCashToOR'] = np.where(CalcTools.is_zero(cash_flow.operating_revenue.values),
@@ -191,7 +204,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经验活动产生的现金流量净额 / 营业收入
-    def cash_rate_of_sales_latest(self, tp_cash_flow, factor_cash_flow):
+    @staticmethod
+    def cash_rate_of_sales_latest(tp_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'operating_revenue']
         cash_flow = tp_cash_flow.loc[:, columns_list]
         cash_flow['CashOfSales'] = np.where(CalcTools.is_zero(cash_flow.operating_revenue.values),
@@ -202,7 +216,8 @@ class FactorCashFlow(FactorBase):
         return factor_cash_flow
 
     # 经营活动产生的现金流量净额（Latest）/(营业总收入（Latest）-营业总成本（Latest）)
-    def nocf_to_operating_ni_latest(self, tp_cash_flow, factor_cash_flow):
+    @staticmethod
+    def nocf_to_operating_ni_latest(tp_cash_flow, factor_cash_flow):
         columns_list = ['net_operate_cash_flow', 'total_operating_revenue',
                         'total_operating_cost']
         cash_flow = tp_cash_flow.loc[:, columns_list]
@@ -223,7 +238,6 @@ def calculate(trade_date, cash_flow_dic, cash_flow):  # 计算对应因子
 
     factor_cash_flow = pd.DataFrame()
     factor_cash_flow['symbol'] = tp_cash_flow.index
-    # tp_cash_flow.set_index('symbol', inplace=True)
 
     # 非TTM计算
     factor_cash_flow = cash_flow.nocf_to_operating_ni_latest(tp_cash_flow, factor_cash_flow)
@@ -248,14 +262,6 @@ def calculate(trade_date, cash_flow_dic, cash_flow):  # 计算对应因子
     cash_flow._storage_data(factor_cash_flow, trade_date)
 
 
-def do_update(self, start_date, end_date, count):
-    # 读取本地交易日
-    trade_date_sets = self._trade_date.trade_date_sets_ago(start_date, end_date, count)
-    for trade_date in trade_date_sets:
-        self.calculate(trade_date)
-    print('----->')
-
-
 @app.task()
 def factor_calculate(**kwargs):
     print("cash_flow_kwargs: {}".format(kwargs))

factor/factor_contrarian.py

@@ -45,7 +45,8 @@ class FactorContrarian(FactorBase):
         super(FactorContrarian, self)._create_tables(create_sql, drop_sql)
 
     # 销售成本率=营业成本(TTM)/营业收入(TTM)
-    def sales_cost_ratio_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def sales_cost_ratio_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['operating_cost', 'operating_revenue']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['SalesCostTTM'] = np.where(
@@ -57,7 +58,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 销售税金率=营业税金及附加(TTM)/营业收入(TTM)
-    def tax_ratio_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def tax_ratio_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['operating_tax_surcharges', 'operating_revenue']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['TaxRTTM'] = np.where(
@@ -69,7 +71,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 财务费用与营业总收入之比=财务费用(TTM)/营业总收入(TTM)
-    def financial_expense_rate_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def financial_expense_rate_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['financial_expense', 'total_operating_cost']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['FinExpTTM'] = np.where(
@@ -81,7 +84,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 营业费用与营业总收入之比=销售费用(TTM)/营业总收入(TTM)
-    def operating_expense_rate_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def operating_expense_rate_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['sale_expense', 'total_operating_cost', 'total_operating_revenue']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['OperExpTTM'] = np.where(
@@ -93,7 +97,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 管理费用与营业总收入之比=管理费用/营业总收入
-    def admini_expense_rate_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def admini_expense_rate_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['administration_expense', 'total_operating_revenue']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['AdminExpTTM'] = np.where(
@@ -105,7 +110,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 销售期间费用率 = (财务费用 + 销售费用 + 管理费用) / (营业收入)
-    def period_costs_rate_ttm(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def period_costs_rate_ttm(tp_contrarian, factor_contrarian):
         columns_list = ['financial_expense', 'sale_expense', 'administration_expense', 'operating_revenue']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['PeridCostTTM'] = np.where(
@@ -118,7 +124,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 负债合计/有形资产(流动资产+固定资产)
-    def debt_tangible_equity_ratio_latest(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def debt_tangible_equity_ratio_latest(tp_contrarian, factor_contrarian):
         columns_list = ['total_liability', 'total_current_liability', 'fixed_assets']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['DTE'] = np.where(
@@ -130,7 +137,8 @@ class FactorContrarian(FactorBase):
         return factor_contrarian
 
     # 债务总资产比=负债合计/资产合计
-    def debts_asset_ratio_latest(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def debts_asset_ratio_latest(tp_contrarian, factor_contrarian):
         columns_list = ['total_liability', 'total_assets']
         contrarian = tp_contrarian.loc[:, columns_list]
         contrarian['DA'] = np.where(
@@ -142,7 +150,8 @@ class FactorContrarian(FactorBase):
 
     # InteBearDebtToTotalCapital = 有息负债/总资本   总资本=固定资产+净运营资本  净运营资本=流动资产-流动负债
     # InteBearDebtToTotalCapital = 有息负债/(固定资产 + 流动资产 - 流动负债)
-    def inte_bear_debt_to_total_capital_latest(self, tp_contrarian, factor_contrarian):
+    @staticmethod
+    def inte_bear_debt_to_total_capital_latest(tp_contrarian, factor_contrarian):
         columns_list = ['interest_bearing_liability', 'fixed_assets', 'total_current_assets',
                         'total_current_liability']
         contrarian = tp_contrarian.loc[:, columns_list]

factor/historical_value.py

@@ -60,7 +60,8 @@ class HistoricalValue(FactorBase):
                     )ENGINE=InnoDB DEFAULT CHARSET=utf8;""".format(self._name)
         super(HistoricalValue, self)._create_tables(create_sql, drop_sql)
 
-    def ps_indu(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def ps_indu(tp_historical_value, factor_historical_value):
         """
         PEIndu， 市销率，以及同行业所有的公司的市销率
         # (PS – PS 的行业均值)/PS 的行业标准差
@@ -84,7 +85,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def etop(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def etop(tp_historical_value, factor_historical_value):
         """
         收益市值比
         # 收益市值比= 净利润/总市值
@@ -105,7 +107,8 @@ class HistoricalValue(FactorBase):
         return factor_historical_value
 
     # 5年平均收益市值比 = 近5年净利润 / 近5年总市值
-    def etp5(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def etp5(tp_historical_value, factor_historical_value):
         columns_lists = ['symbol', 'net_profit_5', 'circulating_market_cap_5', 'market_cap_5']
         historical_value = tp_historical_value.loc[:, columns_lists]
 
@@ -117,7 +120,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def pe_indu(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def pe_indu(tp_historical_value, factor_historical_value):
         """
         # (PE – PE 的行业均值)/PE 的行业标准差
         :param tp_historical_value:
@@ -138,7 +142,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def peg_3y(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def peg_3y(tp_historical_value, factor_historical_value):
         """
         # 市盈率/归属于母公司所有者净利润 3 年复合增长率
         :param tp_historical_value:
@@ -157,7 +162,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def peg_5y(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def peg_5y(tp_historical_value, factor_historical_value):
         """
         # 市盈率/归属于母公司所有者净利润 5 年复合增长率
         :param tp_historical_value:
@@ -176,7 +182,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def pb_indu(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def pb_indu(tp_historical_value, factor_historical_value):
         """
         # (PB – PB 的行业均值)/PB 的行业标准差
         :param tp_historical_value:
@@ -198,7 +205,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def lcap(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def lcap(tp_historical_value, factor_historical_value):
         """
         总市值的对数
         # 对数市值 即市值的对数
@@ -213,7 +221,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def lflo(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def lflo(tp_historical_value, factor_historical_value):
         """
         流通总市值的对数
         # 对数市值 即流通市值的对数
@@ -229,7 +238,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def nlsize(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def nlsize(tp_historical_value, factor_historical_value):
         """
         对数市值开立方
         :param tp_historical_value:
@@ -243,7 +253,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def pcf_indu(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def pcf_indu(tp_historical_value, factor_historical_value):
         """
         # (PCF – PCF 的行业均值)/PCF 的行业标准差
         :param tp_historical_value:
@@ -267,7 +278,8 @@ class HistoricalValue(FactorBase):
         factor_historical_value = pd.merge(factor_historical_value, historical_value, on="symbol")
         return factor_historical_value
 
-    def cetop(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def cetop(tp_historical_value, factor_historical_value):
         """
         # 经营活动产生的现金流量净额与市值比
         :param tp_historical_value:
@@ -287,7 +299,8 @@ class HistoricalValue(FactorBase):
         return factor_historical_value
 
     # 现金流市值比 = 每股派现 * 分红前总股本/总市值
-    def ctop(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def ctop(tp_historical_value, factor_historical_value):
         columns_lists = ['symbol', 'pcd', 'sbd', 'circulating_market_cap', 'market_cap']
         historical_value = tp_historical_value.loc[:, columns_lists]
 
@@ -300,7 +313,8 @@ class HistoricalValue(FactorBase):
         return factor_historical_value
 
     # 5 年平均现金流市值比  = 近5年每股派现 * 分红前总股本/近5年总市值
-    def ctop5(self, tp_historical_value, factor_historical_value):
+    @staticmethod
+    def ctop5(tp_historical_value, factor_historical_value):
         columns_lists = ['symbol', 'pcd', 'sbd', 'circulating_market_cap_5', 'market_cap_5']
         historical_value = tp_historical_value.loc[:, columns_lists]
 
@@ -318,14 +332,11 @@ class HistoricalValue(FactorBase):
 
 def calculate(trade_date, valuation_sets, historical_value):
     """
-
+    :param historical_value:
+    :param valuation_sets:
     :param trade_date:
     :return:
     """
-    # valuation_sets, ttm_factor_sets, cash_flow_sets, income_sets = self.get_basic_data(trade_date)
-    # valuation_sets = pd.merge(valuation_sets, income_sets, on='symbol')
-    # valuation_sets = pd.merge(valuation_sets, ttm_factor_sets, on='symbol')
-    # valuation_sets = pd.merge(valuation_sets, cash_flow_sets, on='symbol')
     if len(valuation_sets) <= 0:
         print("%s has no data" % trade_date)
         return
@@ -377,15 +388,6 @@ def calculate(trade_date, valuation_sets, historical_value):
     historical_value._storage_data(factor_historical_value, trade_date)
 
 
-def do_update(self, start_date, end_date, count):
-    # 读取本地交易日
-    trade_date_sets = self._trade_date.trade_date_sets_ago(start_date, end_date, count)
-    for trade_date in trade_date_sets:
-        print('因子计算日期： %s' % trade_date)
-        self.calculate(trade_date)
-    print('----->')
-
-
 @app.task()
 def factor_calculate(**kwargs):
     print("history_value_kwargs: {}".format(kwargs))