result_service_v2.py 36.5 KB
Newer Older
赵杰's avatar
赵杰 committed
1 2 3 4 5 6 7 8 9 10 11 12
#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
# @Time    : 2020/11/23 15:29
# @Author  : Jie. Z
# @Email   : zhaojiestudy@163.com
# @File    : result_service.py
# @Software: PyCharm

import pandas as pd
import numpy as np
import datetime
from decimal import Decimal
13
from app.service.data_service_v2_1 import UserCustomerDataAdaptor
14
from app.utils.fund_rank import get_frequency
15
from app.service.portfolio_diagnose import cal_correlation, get_fund_name, get_frequency
赵杰's avatar
赵杰 committed
16
from app.utils.week_evaluation import *
17
from app.service.substrategy_dict import get_substrategy_name
赵杰's avatar
赵杰 committed
18 19 20 21 22 23


class UserCustomerResultAdaptor(UserCustomerDataAdaptor):
    total_result_data = {}
    group_result_data = {}

赵杰's avatar
赵杰 committed
24 25
    def __init__(self, user_id, customer_id, end_date=str(datetime.datetime.now().date())):
        super().__init__(user_id, customer_id, end_date=end_date)
赵杰's avatar
赵杰 committed
26 27 28 29 30 31 32 33

    # 组合结果数据
    def calculate_group_result_data(self):

        for folio in self.group_data.keys():
            folio_report_data = {}

            cur_folio_result_cnav_data = self.group_data[folio]["result_cnav_data"]
赵杰's avatar
赵杰 committed
34 35
            cur_folio_order_data = self.group_data[folio]["order_df"].copy()

36 37 38 39 40
            # freq_max = cur_folio_order_data["freq"].max()
            freq_list = [get_frequency(cur_folio_result_cnav_data[[p_nav]]) for p_nav in
                         cur_folio_result_cnav_data.columns]
            freq_dict = {250: 1, 52: 2, 24: 4, 12: 3, 4: 5}
            freq_max = freq_dict[min(freq_list)]
赵杰's avatar
赵杰 committed
41 42 43 44 45 46
            first_trade_date = cur_folio_order_data["confirm_share_date"].min()

            fund_id_list = list(cur_folio_order_data["fund_id"].unique())
            fund_id_list_earn = [i + "_earn" for i in fund_id_list]
            # fund_id_list_amount = [i + "_amount" for i in fund_id_list]
            profit_df = cur_folio_result_cnav_data[fund_id_list_earn]
赵杰's avatar
赵杰 committed
47
            folio_report_data["fund_id_list"] = fund_id_list
赵杰's avatar
赵杰 committed
48 49 50 51 52

            # 组合收益率数组
            # return_ratio_df, contribution_decomposition= self.combination_yield(cur_folio_result_cnav_data, fund_id_list)
            # resample_df = resample(return_ratio_df, self.trade_cal_date, freq_max)
            resample_cur_folio_result_cnav_data = resample(cur_folio_result_cnav_data, self.trade_cal_date, freq_max)
53 54 55 56 57
            if resample_cur_folio_result_cnav_data.index.values[-1] > self.end_date:
                last = resample_cur_folio_result_cnav_data.index.values[-1]
                resample_cur_folio_result_cnav_data["index_date"] = resample_cur_folio_result_cnav_data.index
                resample_cur_folio_result_cnav_data.loc[last, "index_date"] = self.end_date
                resample_cur_folio_result_cnav_data.set_index("index_date", inplace=True)
赵杰's avatar
赵杰 committed
58 59 60 61
            resample_cur_folio_result_cnav_data = resample_cur_folio_result_cnav_data[resample_cur_folio_result_cnav_data.index <= self.end_date]
            return_ratio_df, month_return_ratio_df, contribution_decomposition = self.combination_yield(resample_cur_folio_result_cnav_data,
                                                                                 fund_id_list)
            resample_df = resample(return_ratio_df, self.trade_cal_date, freq_max)
62 63 64 65 66
            if resample_df.index.values[-1] > self.end_date:
                last = resample_df.index.values[-1]
                resample_df["index_date"] = resample_df.index
                resample_df.loc[last, "index_date"] = self.end_date
                resample_df.set_index("index_date", inplace=True)
赵杰's avatar
赵杰 committed
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
            resample_df = resample_df[resample_df.index <= self.end_date]

            # 收益分解df
            contribution_decomposition_df = contribution_decomposition.fillna(0)*100
            p_plot_data = []
            for a_fund_id in list(contribution_decomposition_df.columns):
                a_name = cur_folio_order_data[cur_folio_order_data["fund_id"]==a_fund_id]["fund_name"].values[0]
                plot_data = {'name': a_name, 'data': contribution_decomposition_df[a_fund_id].astype(np.float64).values}
                p_plot_data.append(plot_data)
            x_lables_data = list(contribution_decomposition_df.index)
            cumulative_data = {'name': '总收益', 'data': ((month_return_ratio_df["cum_return_ratio"] - 1)*100).values}
            folio_report_data["contribution_decomposition"] = {"xlabels": x_lables_data, "product_list": p_plot_data,
                                                               "cumulative": cumulative_data}

            # 总成本
82
            total_cost = round(float(round(float(cur_folio_result_cnav_data[[i + "_amount" for i in fund_id_list]].tail(1).sum().sum()), 0)), 0)
赵杰's avatar
赵杰 committed
83 84 85 86 87 88 89 90 91 92 93 94 95
            folio_report_data["total_cost"] = total_cost

            # 累积盈利
            cumulative_profit = profit_df.sum().sum()
            folio_report_data["cumulative_profit"] = float(cumulative_profit)

            # 区间年化收益率
            n_freq = freq_days(int(freq_max))
            return_ratio_year = annual_return((resample_df["cum_return_ratio"].values[-1]-1), resample_df, n_freq)
            folio_report_data["return_ratio_year"] = float(return_ratio_year)

            # 波动率
            volatility_ = volatility(resample_df["cum_return_ratio"], n_freq)
96
            folio_report_data["volatility"] = float(volatility_) if not math.isnan(volatility_) else 0.0
赵杰's avatar
赵杰 committed
97 98 99 100 101 102 103 104

            # 最大回撤
            drawdown = max_drawdown(resample_df["cum_return_ratio"])
            folio_report_data["max_drawdown"] = drawdown

            # 夏普比率
            sim = simple_return(resample_df["cum_return_ratio"])
            exc = excess_return(sim, BANK_RATE, n_freq)
105 106 107 108
            try:
                sharpe = sharpe_ratio(exc, sim, n_freq)
            except ZeroDivisionError:
                sharpe = 0.0
109
            folio_report_data["sharpe"] = float(sharpe) if not math.isnan(sharpe) else 0.0
赵杰's avatar
赵杰 committed
110 111

            # 期末资产
112 113
            ending_assets = round(float(cur_folio_result_cnav_data[[i + "_net_amount" for i in fund_id_list]].tail(1).sum().sum()), 0)
            folio_report_data["ending_assets"] = ending_assets
赵杰's avatar
赵杰 committed
114 115 116 117 118 119 120 121

            # 本月收益
            cur_month_profit_df = profit_df.loc[self.month_start_date:self.end_date+datetime.timedelta(days=1), fund_id_list_earn]
            cur_month_profit = cur_month_profit_df.sum().sum()
            folio_report_data["cur_month_profit"] = float(cur_month_profit)

            # 本月累积收益率
            last_profit_ratio = return_ratio_df.loc[:self.month_start_date, "cum_return_ratio"].values
赵杰's avatar
赵杰 committed
122
            cur_profit_ratio = return_ratio_df.loc[self.month_start_date - datetime.timedelta(days=1):, "cum_return_ratio"].values
赵杰's avatar
赵杰 committed
123 124 125
            if len(last_profit_ratio) <= 0:
                cur_month_profit_ratio = cur_profit_ratio[-1] - 1
            else:
赵杰's avatar
赵杰 committed
126 127 128 129
                if len(cur_profit_ratio) < 1:
                    cur_month_profit_ratio = 0
                else:
                    cur_month_profit_ratio = (cur_profit_ratio[-1] - last_profit_ratio[-1]) / last_profit_ratio[-1]
赵杰's avatar
赵杰 committed
130 131 132 133 134 135 136 137 138 139 140 141 142 143
            folio_report_data["cur_month_profit_ratio"] = float(cur_month_profit_ratio)

            # 今年累积收益
            cur_year_date = pd.to_datetime(str(datetime.date(year=self.end_date.year, month=1, day=1)))
            cur_year_profit_df = profit_df.loc[cur_year_date:self.end_date + datetime.timedelta(days=1), fund_id_list_earn]
            cur_year_profit = cur_year_profit_df.sum().sum()
            folio_report_data["cur_year_profit"] = float(cur_year_profit)

            # 今年累积收益率
            last_profit_ratio = return_ratio_df.loc[:cur_year_date, "cum_return_ratio"].values
            cur_profit_ratio = return_ratio_df.loc[cur_year_date:, "cum_return_ratio"].values
            if len(last_profit_ratio) <= 0:
                cur_year_profit_ratio = cur_profit_ratio[-1] - 1
            else:
144 145 146 147
                if len(cur_profit_ratio) < 1:
                    cur_year_profit_ratio = 0
                else:
                    cur_year_profit_ratio = (cur_profit_ratio[-1] - last_profit_ratio[-1]) / last_profit_ratio[-1]
赵杰's avatar
赵杰 committed
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
            folio_report_data["cur_year_profit_ratio"] = float(cur_year_profit_ratio)

            # 累积收益率
            cumulative_return= return_ratio_df["cum_return_ratio"].values[-1]
            folio_report_data["cumulative_return"] = float(cumulative_return)

            # 月度分组
            def year_month(x):
                a = x.year
                b = x.month
                return str(a) + "/" + str(b)

            profit_df_cp = profit_df.copy()
            profit_df_cp["date"] = profit_df_cp.index
            grouped = profit_df_cp.groupby(profit_df_cp["date"].apply(year_month))
            sum_group = grouped.agg(np.sum)
            month_sum = sum_group.sum(axis=1)

            # 贡献分解
            month_earn = sum_group.div(month_sum, axis='rows')
            month_earn["datetime"] = pd.to_datetime(month_earn.index)
            month_earn.sort_values(by="datetime", inplace=True)
            del month_earn["datetime"]
            col = list(month_earn.columns)
            col_ = {x: x.replace('_earn', '') for x in list(col)}
            month_earn.rename(columns=col_, inplace=True)
            # folio_report_data["contribution_decomposition"] = month_earn

            # 组合内单个基金净值数据  组合内基金持仓数据
赵杰's avatar
赵杰 committed
177 178
            result_fund_nav_info, result_fund_hoding_info, weight_res = self.group_fund_basic_info_data(cur_folio_order_data, cur_folio_result_cnav_data, cumulative_profit, total_cost)
            folio_report_data["weight_result"] = weight_res
赵杰's avatar
赵杰 committed
179 180 181 182 183

            # 拼接组合以及综合结果数据
            folio_report_data["group_nav_info"] = result_fund_nav_info
            folio_report_data["group_hoding_info"] = result_fund_hoding_info
            folio_report_data["group_hoding_info_total"] = \
赵杰's avatar
赵杰 committed
184 185 186 187
                {"total_cost": "%.2f" % round(float(total_cost)/10000.0, 2),
                 "cur_month_profit": "%.2f" % round(cur_month_profit/10000.0, 2),
                 "cur_month_profit_ratio": "%.2f" % round(cur_month_profit_ratio*100, 2),
                 "ending_assets": "%.2f" % round(ending_assets/10000.0, 2),
赵杰's avatar
赵杰 committed
188
                 "weight": 100,
赵杰's avatar
赵杰 committed
189 190 191
                 "cumulative_profit": "%.2f" % round(cumulative_profit/10000.0, 2),
                 "cumulative_return": "%.2f" % round((cumulative_return-1)*100, 2),
                 "return_ratio_year": "%.2f" % round(return_ratio_year*100, 2)}
赵杰's avatar
赵杰 committed
192 193

            # 对应指数数据
赵杰's avatar
赵杰 committed
194
            index_df = self.get_customer_index_nav_data().dropna()
赵杰's avatar
赵杰 committed
195 196 197 198
            index_result = self.signal_fund_profit_result(index_df[index_df.index >= pd.to_datetime(first_trade_date)],
                                                          "index")
            folio_report_data["index_result"] = index_result
            folio_report_data["return_df"] = resample_df
199 200 201 202 203 204 205

            # 对应组合相关性
            min_date = cur_folio_order_data["confirm_share_date"].min()
            df_ = self.total_customer_order_cnav_df[fund_id_list]
            df_ = df_[df_.index >= min_date]
            correlation = self.old_correlation(df_)
            folio_report_data["correlation"] = correlation
赵杰's avatar
赵杰 committed
206
            self.group_result_data[folio] = folio_report_data
207 208 209 210 211 212 213 214 215 216 217 218 219 220
        folio_name = list(self.group_data.keys())[0]
        if len(self.group_data) == 1 and len(self.group_result_data[folio_name]["group_hoding_info"]) == 1:
            self.total_result_data["cur_month_profit_ratio"] = float(self.group_result_data[folio_name]["group_hoding_info"][0]["month_return_ratio"])/100.0
            self.total_result_data["cumulative_return"] = float(
                self.group_result_data[folio_name]["group_hoding_info"][0]["cum_profit_ratio"]) / 100.0 + 1
            self.total_result_data["return_ratio_year"] = float(
                self.group_result_data[folio_name]["group_hoding_info"][0]["return_ratio_year"]) / 100.0

            self.group_result_data[folio_name]["group_hoding_info_total"]["cur_month_profit_ratio"] = \
            self.group_result_data[folio_name]["group_hoding_info"][0]["month_return_ratio"]
            self.group_result_data[folio_name]["group_hoding_info_total"]["cumulative_return"] = \
            self.group_result_data[folio_name]["group_hoding_info"][0]["cum_profit_ratio"]
            self.group_result_data[folio_name]["group_hoding_info_total"]["return_ratio_year"] = \
            self.group_result_data[folio_name]["group_hoding_info"][0]["return_ratio_year"]
赵杰's avatar
赵杰 committed
221 222 223 224 225 226
        return self.group_result_data

    # 综述数据
    def calculate_total_data(self):
        report_data = {}

赵杰's avatar
赵杰 committed
227
        cur_folio_result_cnav_data = self.total_customer_order_cnav_df.copy()
赵杰's avatar
赵杰 committed
228
        cur_folio_order_data = self.user_customer_order_df.copy()
229 230 231 232 233
        # freq_max = cur_folio_order_data["freq"].max()
        freq_list = [get_frequency(cur_folio_result_cnav_data[[p_nav]]) for p_nav in
                     cur_folio_result_cnav_data.columns]
        freq_dict = {250: 1, 52: 2, 24: 4, 12: 3, 4: 5}
        freq_max = freq_dict[min(freq_list)]
赵杰's avatar
赵杰 committed
234 235 236
        #
        fund_id_list = list(cur_folio_order_data["fund_id"].unique())
        fund_id_list_earn = [i + "_earn" for i in fund_id_list]
赵杰's avatar
赵杰 committed
237
        fund_id_list_amount = [i + "_net_amount" for i in fund_id_list]
赵杰's avatar
赵杰 committed
238
        profit_df = cur_folio_result_cnav_data[fund_id_list_earn]
赵杰's avatar
赵杰 committed
239
        amount_df = cur_folio_result_cnav_data[fund_id_list_amount].copy()
赵杰's avatar
赵杰 committed
240 241 242 243 244 245 246 247 248 249 250

        # 持仓周期
        first_trade_date = cur_folio_order_data["confirm_share_date"].min()
        hold_days = (self.end_date - pd.to_datetime(first_trade_date)).days
        report_data["hold_days"] = hold_days

        # 组合收益率数组
        # return_ratio_df = self.combination_yield(cur_folio_result_cnav_data, fund_id_list)
        # resample_df = resample(return_ratio_df, self.trade_cal_date, freq_max)

        resample_cur_folio_result_cnav_data = resample(cur_folio_result_cnav_data, self.trade_cal_date, freq_max)
251 252 253 254 255
        if resample_cur_folio_result_cnav_data.index.values[-1] > self.end_date:
            last = resample_cur_folio_result_cnav_data.index.values[-1]
            resample_cur_folio_result_cnav_data["index_date"] = resample_cur_folio_result_cnav_data.index
            resample_cur_folio_result_cnav_data.loc[last, "index_date"] = self.end_date
            resample_cur_folio_result_cnav_data.set_index("index_date", inplace=True)
赵杰's avatar
赵杰 committed
256 257 258
        resample_cur_folio_result_cnav_data = resample_cur_folio_result_cnav_data[resample_cur_folio_result_cnav_data.index <=self.end_date]
        return_ratio_df, month_return_ratio_df, contribution_decomposition = self.combination_yield(resample_cur_folio_result_cnav_data, fund_id_list)
        resample_df = resample(return_ratio_df, self.trade_cal_date, freq_max)
259 260 261 262 263
        if resample_df.index.values[-1] > self.end_date:
            last = resample_df.index.values[-1]
            resample_df["index_date"] = resample_df.index
            resample_df.loc[last, "index_date"] = self.end_date
            resample_df.set_index("index_date", inplace=True)
赵杰's avatar
赵杰 committed
264 265 266
        resample_df = resample_df[resample_df.index <= self.end_date]

        # 总成本
267
        total_cost = round(float(cur_folio_result_cnav_data[[i + "_amount" for i in fund_id_list]].tail(1).sum().sum()), 0)
赵杰's avatar
赵杰 committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
        report_data["total_cost"] = total_cost

        # 累积盈利
        cumulative_profit = profit_df.sum().sum()
        report_data["cumulative_profit"] = float(cumulative_profit)

        # 区间年化收益
        n_freq = freq_days(int(freq_max))
        return_ratio_year = annual_return((resample_df["cum_return_ratio"].values[-1] - 1), resample_df, n_freq)
        report_data["return_ratio_year"] = float(return_ratio_year)

        # # 波动率
        # volatility_ = volatility(resample_df["cum_return_ratio"], n_freq)
        # report_data["volatility"] = float(volatility_)

        # 最大回撤
        drawdown = max_drawdown(resample_df["cum_return_ratio"])
        report_data["max_drawdown"] = drawdown
        #
        # # 夏普比率
        # sim = simple_return(resample_df["cum_return_ratio"])
        # exc = excess_return(sim, BANK_RATE, n_freq)
        # sharpe = sharpe_ratio(exc, sim, n_freq)
        # report_data["sharpe"] = float(sharpe)

        # 期末资产
294 295
        ending_assets = round(float(cur_folio_result_cnav_data[[i + "_net_amount" for i in fund_id_list]].tail(1).sum().sum()), 0)
        report_data["ending_assets"] = ending_assets
赵杰's avatar
赵杰 committed
296 297 298 299 300 301 302 303 304 305 306 307 308

        # 本月收益
        cur_month_profit_df = profit_df.loc[self.month_start_date:self.end_date + datetime.timedelta(days=1),
                              fund_id_list_earn]
        cur_month_profit = cur_month_profit_df.sum().sum()
        report_data["cur_month_profit"] = float(cur_month_profit)

        # 本月累积收益率
        last_profit_ratio = return_ratio_df.loc[:self.month_start_date, "cum_return_ratio"].values
        cur_profit_ratio = return_ratio_df.loc[self.month_start_date:, "cum_return_ratio"].values
        if len(last_profit_ratio) <= 0:
            cur_month_profit_ratio = cur_profit_ratio[-1] - 1
        else:
赵杰's avatar
赵杰 committed
309 310 311 312
            if len(cur_profit_ratio) < 1:
                cur_month_profit_ratio = 0
            else:
                cur_month_profit_ratio = (cur_profit_ratio[-1] - last_profit_ratio[-1]) / last_profit_ratio[-1]
赵杰's avatar
赵杰 committed
313 314 315 316 317 318 319 320 321 322 323 324 325 326
        report_data["cur_month_profit_ratio"] = float(cur_month_profit_ratio)

        # 今年累积收益
        cur_year_date = pd.to_datetime(str(datetime.date(year=self.end_date.year, month=1, day=1)))
        cur_year_profit_df = profit_df.loc[cur_year_date:self.end_date + datetime.timedelta(days=1), fund_id_list_earn]
        cur_year_profit = cur_year_profit_df.sum().sum()
        report_data["cur_year_profit"] = float(cur_year_profit)

        # 今年累积收益率
        last_profit_ratio = return_ratio_df.loc[:cur_year_date, "cum_return_ratio"].values
        cur_profit_ratio = return_ratio_df.loc[cur_year_date:, "cum_return_ratio"].values
        if len(last_profit_ratio) <= 0:
            cur_year_profit_ratio = cur_profit_ratio[-1] - 1
        else:
327 328 329 330 331 332 333
            if len(cur_profit_ratio) < 1:
                cur_year_profit_ratio = 0.0
            else:
                if len(cur_profit_ratio) < 1:
                    cur_year_profit_ratio = 0
                else:
                    cur_year_profit_ratio = (cur_profit_ratio[-1] - last_profit_ratio[-1]) / last_profit_ratio[-1]
赵杰's avatar
赵杰 committed
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
        report_data["cur_year_profit_ratio"] = float(cur_year_profit_ratio)

        # 月度回报
        def year_month(x):
            a = x.year
            b = x.month
            return str(a) + "/" + str(b)

        profit_df_cp = profit_df.copy()
        profit_df_cp["date"] = profit_df_cp.index
        grouped = profit_df_cp.groupby(profit_df_cp["date"].apply(year_month))
        sum_group = grouped.agg(np.sum)
        month_sum = sum_group.sum(axis=1)

        return_ratio_df["date"] = return_ratio_df.index
        return_group = return_ratio_df.groupby(return_ratio_df["date"].apply(year_month))
        month_last_return_ratio = return_group.last()["cum_return_ratio"]
351 352

        month_sum = month_sum[month_sum.index.isin(month_last_return_ratio.index.values)]
赵杰's avatar
赵杰 committed
353 354 355 356 357
        month_result = pd.DataFrame({"date": month_sum.index, "profit": month_sum.values, "ratio": month_last_return_ratio.values})
        month_result["datetime"] = pd.to_datetime(month_result["date"])
        month_result.sort_values(by="datetime", inplace=True)
        report_data["month_return"] = month_result

赵杰's avatar
赵杰 committed
358 359 360 361 362 363 364 365 366
        #
        amount_df["date"] = amount_df.index
        grouped_amount = amount_df.groupby(amount_df["date"].apply(year_month))
        month_amount = grouped_amount.last()
        del month_amount["date"]
        month_amount_sum = month_amount.sum(axis=1)

        # 月度回报表格数据
        start_year = self.start_date.year
赵杰's avatar
赵杰 committed
367
        now_year = self.end_date.year
赵杰's avatar
赵杰 committed
368 369
        month_return_data_dict = {}
        for i in range(now_year-start_year+1):
赵杰's avatar
赵杰 committed
370
            month_return_data_dict[str(start_year+i)] = {str(j+1): {"profit": "-", "net_amount": "-"} for j in range(12)}
赵杰's avatar
赵杰 committed
371
        for d_index, d_row in month_sum.items():
赵杰's avatar
赵杰 committed
372 373
            cur_year = str(int(d_index[:4]))
            cur_month = str(int(d_index[5:]))
赵杰's avatar
赵杰 committed
374 375
            cur_profit = round(d_row/10000.0, 2)
            cur_net_amount = round(month_amount_sum.loc[d_index]/10000, 2)
赵杰's avatar
赵杰 committed
376 377
            month_return_data_dict[cur_year][cur_month]["profit"] = "%.2f"%cur_profit
            month_return_data_dict[cur_year][cur_month]["net_amount"] = "%.2f"%cur_net_amount
赵杰's avatar
赵杰 committed
378 379
        # 组合月度回报表
        report_data["month_return_data_dict"] = month_return_data_dict
赵杰's avatar
赵杰 committed
380 381 382 383 384 385 386 387 388 389

        # # 贡献分解
        # month_earn = sum_group.div(month_sum, axis='rows')
        # report_data["contribution_decomposition"] = month_earn

        # 累积收益率
        cumulative_return = return_ratio_df["cum_return_ratio"].values[-1]
        report_data["cumulative_return"] = float(cumulative_return)

        # 对应指数数据
赵杰's avatar
赵杰 committed
390
        index_df = self.get_customer_index_nav_data().dropna()
赵杰's avatar
赵杰 committed
391 392 393 394 395 396 397 398 399 400 401 402 403
        index_result = self.signal_fund_profit_result(index_df[index_df.index >= pd.to_datetime(first_trade_date)], "index")
        report_data["index_result"] = index_result

        self.total_result_data = report_data
        return report_data

    # 基金净值数据,持仓数据
    def group_fund_basic_info_data(self, p_order_df, p_result_cnav_data, p_sum_profit, p_total_amount):
        group_fund_basic_info = []
        group_fund_hoding_info = []
        freq_max = p_order_df["freq"].max()
        n_freq = freq_days(int(freq_max))
        resample_df = resample(p_result_cnav_data, self.trade_cal_date, freq_max)
404
        # for index, row in p_order_df.iterrows():
赵杰's avatar
赵杰 committed
405
        fund_weight = {}
406 407 408 409
        for hold_fund_id in p_order_df["fund_id"].unique():
            order = p_order_df[(p_order_df["fund_id"] == hold_fund_id)]
            row = order[order["order_type"] == 1].iloc[0]

赵杰's avatar
赵杰 committed
410 411
            cur_fund_id = str(row["fund_id"])
            cur_fund_performance = self.all_fund_performance[cur_fund_id]
412
            if len(cur_fund_performance) <= 0:
赵杰's avatar
赵杰 committed
413 414 415 416 417 418 419 420 421 422 423 424 425
                fund_basic_info = {"fund_name": row["fund_name"], "confirm_nav": round(row["nav"], 4)}
                fund_basic_info["cur_nav"] = round(float(self.fund_nav_total[cur_fund_id].dropna().values[-1]), 4)
                fund_basic_info["cur_cnav"] = round(float(self.fund_cnav_total[cur_fund_id].dropna().values[-1]), 4)
                fund_basic_info["ret_1w"] = "-"  # 上周
                fund_basic_info["ret_cum_1m"] = "-"  # 最近一个月
                fund_basic_info["ret_cum_6m"] = "-"  # 最近半年
                fund_basic_info["ret_cum_1y"] = "-"  # 最近一年
                fund_basic_info["ret_cum_ytd"] = "-"  # 今年以来
                fund_basic_info["ret_cum_incep"] = "-"  # 成立以来

                # 申购以来
                confirm_date = pd.to_datetime(row["confirm_share_date"])
                confirm_cnav = float(p_result_cnav_data.loc[confirm_date, cur_fund_id])
426 427
                fund_basic_info["ret_after_confirm"] = str(round(
                    (fund_basic_info["cur_cnav"] - confirm_cnav) / confirm_cnav * 100, 2)) + "%"
赵杰's avatar
赵杰 committed
428 429 430 431 432 433 434 435 436
                # 分红
                distribution_df = self.all_fund_distribution[cur_fund_id]
                if distribution_df.empty:
                    fund_basic_info["distribution"] = "-"
                else:
                    distribution_df["price_date"] = pd.to_datetime(distribution_df["price_date"])
                    distribution = float(
                        distribution_df[distribution_df["price_date"] > confirm_date]["distribution"].sum())
                    fund_basic_info["distribution"] = round(distribution, 4) if distribution != 0 else "-"
赵杰's avatar
赵杰 committed
437
            else:
赵杰's avatar
赵杰 committed
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
                cur_fund_info_series = cur_fund_performance.iloc[-1]
                # 基金净值数据
                fund_basic_info = {"fund_name": row["fund_name"], "confirm_nav": round(row["nav"],4)}
                fund_basic_info["cur_nav"] = round(float(self.fund_nav_total[cur_fund_id].dropna().values[-1]), 4)
                fund_basic_info["cur_cnav"] = round(float(self.fund_cnav_total[cur_fund_id].dropna().values[-1]), 4)
                fund_basic_info["ret_1w"] = str(round(cur_fund_info_series["ret_1w"]*100, 2)) + "%" if cur_fund_info_series["ret_1w"] is not None else "-"    # 上周
                fund_basic_info["ret_cum_1m"] = str(round(cur_fund_info_series["ret_cum_1m"]*100, 2)) + "%" if cur_fund_info_series["ret_cum_1m"] is not None else "-"  # 最近一个月
                fund_basic_info["ret_cum_6m"] = str(round(cur_fund_info_series["ret_cum_6m"]*100, 2)) + "%" if cur_fund_info_series["ret_cum_6m"] is not None else "-"  # 最近半年
                fund_basic_info["ret_cum_1y"] = str(round(cur_fund_info_series["ret_cum_1y"]*100, 2)) + "%" if cur_fund_info_series["ret_cum_1y"] is not None else "-"  # 最近一年
                fund_basic_info["ret_cum_ytd"] = str(round(cur_fund_info_series["ret_cum_ytd"]*100, 2)) + "%" if cur_fund_info_series["ret_cum_ytd"] is not None else "-"    # 今年以来
                fund_basic_info["ret_cum_incep"] = str(round(cur_fund_info_series["ret_cum_incep"]*100, 2)) + "%" if cur_fund_info_series["ret_cum_incep"] is not None else "-"    # 成立以来
                # 申购以来
                confirm_date = pd.to_datetime(row["confirm_share_date"])
                confirm_cnav = float(p_result_cnav_data.loc[confirm_date, cur_fund_id])
                fund_basic_info["ret_after_confirm"] = str(round((fund_basic_info["cur_cnav"] - confirm_cnav)/confirm_cnav*100, 2)) + "%"
                # 分红
                distribution_df = self.all_fund_distribution[cur_fund_id]
                if distribution_df.empty:
                    fund_basic_info["distribution"] = "-"
                else:
                    distribution_df["price_date"] = pd.to_datetime(distribution_df["price_date"])
                    distribution = float(distribution_df[distribution_df["price_date"] > confirm_date]["distribution"].sum())
                    fund_basic_info["distribution"] = round(distribution, 4) if distribution != 0 else "-"
赵杰's avatar
赵杰 committed
461 462 463 464 465

            group_fund_basic_info.append(fund_basic_info)

            # 基金持仓数据
            total_market_values = p_sum_profit + p_total_amount #   月末总市值
466
            fund_strategy_name = get_substrategy_name(row["substrategy"])
467
            if "长富" in row["fund_name"] or "盈沛" in row["fund_name"]:
赵杰's avatar
赵杰 committed
468 469
                fund_strategy_name = "FOF"
            fund_hoding_info = {"fund_strategy_name": fund_strategy_name, "fund_name": row["fund_name"]}
470
            fund_hoding_info["confirm_date"] = row["confirm_share_date"].strftime("%Y-%m-%d")
赵杰's avatar
赵杰 committed
471
            fund_hoding_info["hold_year"] = "%.2f" % round((self.end_date - pd.to_datetime(row["confirm_share_date"])).days/365.0, 2)    # 存续年数
472 473
            # fund_hoding_info["market_values"] = round((float(row["confirm_share"]) * (fund_basic_info["cur_cnav"] - confirm_cnav) + float(row["confirm_amount"]))/10000, 2)
            temp_market_values = float(p_result_cnav_data[cur_fund_id + "_net_amount"].values[-1])
wang zhengwei's avatar
wang zhengwei committed
474
            fund_hoding_info["market_values"] = round(temp_market_values / 10000.0, 2)
赵杰's avatar
赵杰 committed
475 476
            temp_weight = float(fund_hoding_info["market_values"]) / total_market_values * 10000.0
            fund_hoding_info["weight"] = "%.2f" % round(temp_weight * 100, 2)  # 月末占比
477
            temp_cost = float(p_result_cnav_data[cur_fund_id + "_amount"].values[-1])
赵杰's avatar
赵杰 committed
478 479
            fund_hoding_info["cost"] = "%.2f" % round(temp_cost / 10000, 2)  # 投资本金
            fund_weight[cur_fund_id] = round(temp_weight, 4)
赵杰's avatar
赵杰 committed
480
            # 当月收益
赵杰's avatar
赵杰 committed
481 482 483 484 485
            if row['confirm_share_date'] > self.month_start_date:
                cal_month_start_date = row['confirm_share_date']
                last_month_cnav_serise = p_result_cnav_data[p_result_cnav_data.index == pd.to_datetime(cal_month_start_date)][
                    row["fund_id"]].dropna()
            else:
wang zhengwei's avatar
wang zhengwei committed
486
                cal_month_start_date = self.month_start_date
赵杰's avatar
赵杰 committed
487
                last_month_cnav_serise = p_result_cnav_data[p_result_cnav_data.index<pd.to_datetime(cal_month_start_date)][row["fund_id"]].dropna()
488
            cal_month_cnav_result = p_result_cnav_data[p_result_cnav_data.index >= pd.to_datetime(cal_month_start_date)]
赵杰's avatar
赵杰 committed
489
            if len(last_month_cnav_serise) == 0:
490 491 492
                temp_profit = 0
                fund_hoding_info["profit"] = temp_profit
                temp_profit_ratio = 0
赵杰's avatar
赵杰 committed
493 494
            else:
                last_month_cnav = float(last_month_cnav_serise.values[-1])
495
                temp_profit = float(cal_month_cnav_result[cur_fund_id + "_earn"].sum())
赵杰's avatar
赵杰 committed
496
                fund_hoding_info["profit"] = round(temp_profit/10000, 2)
赵杰's avatar
赵杰 committed
497
                temp_profit_ratio = (fund_basic_info["cur_cnav"] - last_month_cnav) / last_month_cnav
赵杰's avatar
赵杰 committed
498
            # 当月收益率
赵杰's avatar
赵杰 committed
499
            fund_hoding_info["month_return_ratio"] = "%.2f" % round(temp_profit / temp_cost*100, 2)
500
            # fund_hoding_info["month_return_ratio"] = "%.2f" % round(temp_profit_ratio * 100, 2)
赵杰's avatar
赵杰 committed
501
            # 累积收益
502 503
            cum_profit = float(p_result_cnav_data[cur_fund_id + "_earn"].sum())
            fund_hoding_info["cum_profit"] = "%.2f" % round(cum_profit / 10000, 2)
赵杰's avatar
赵杰 committed
504
            # 累积收益率
505 506
            fund_hoding_info["cum_profit_ratio"] = "%.2f" % round(cum_profit / temp_cost *100, 2)
            cum_profit_ratio_temp = cum_profit / temp_cost
赵杰's avatar
赵杰 committed
507
            # 累积年化收益率
508
            cur_resample_df = resample_df[[row["fund_id"]]]
赵杰's avatar
赵杰 committed
509
            return_ratio_year = annual_return(float(cum_profit_ratio_temp), cur_resample_df, n_freq)
赵杰's avatar
赵杰 committed
510
            fund_hoding_info["return_ratio_year"] = "%.2f" % round(float(return_ratio_year)*100, 2)
赵杰's avatar
赵杰 committed
511
            group_fund_hoding_info.append(fund_hoding_info)
赵杰's avatar
赵杰 committed
512
        return group_fund_basic_info, group_fund_hoding_info, fund_weight
赵杰's avatar
赵杰 committed
513 514 515 516 517 518 519 520 521 522

    @staticmethod
    def combination_yield(p_combina_df, fund_id_list):
        fund_id_list_amount = [i + "_net_amount" for i in fund_id_list]
        fund_id_list_profit_ratio = [i + "_profit_ratio" for i in fund_id_list]

        nav_net_amount_df = p_combina_df[fund_id_list + fund_id_list_amount+fund_id_list_profit_ratio].copy()
        # nav_net_amount_df = resample(return_ratio_df, self.trade_cal_date, freq_max)
        nav_net_amount_df["sum_net_amount"] = nav_net_amount_df[fund_id_list_amount].sum(axis=1).apply(lambda x: Decimal.from_float(x))
        for amount_name in fund_id_list:
523 524 525 526 527 528 529 530
            # price = nav_net_amount_df[amount_name].dropna()
            # profit = price.diff().fillna(Decimal(0))
            # profit_ratio_new = profit / price.shift(1)
            # profit_ratio_old = nav_net_amount_df[amount_name+"_profit_ratio"]
            # nan_index = profit_ratio_new[pd.isna(profit_ratio_new)].index
            # profit_ratio_new[nan_index] = profit_ratio_old[nan_index]
            #
            # nav_net_amount_df[amount_name + "_profit_ratio"] = profit_ratio_new
赵杰's avatar
赵杰 committed
531
            nav_net_amount_df[amount_name+"_amount_ratio"] = nav_net_amount_df[amount_name+"_net_amount"]/(nav_net_amount_df["sum_net_amount"])
532

赵杰's avatar
赵杰 committed
533
            fund_profit_ratio = nav_net_amount_df[amount_name + "_profit_ratio"].dropna() + 1
534
            amount_ratio_shift = nav_net_amount_df[amount_name + "_amount_ratio"].shift(1)
535
            num_va = len(amount_ratio_shift[amount_ratio_shift.values == 0])
赵杰's avatar
赵杰 committed
536
            if num_va+1 >= len(amount_ratio_shift):
赵杰's avatar
赵杰 committed
537 538 539
                amount_ratio_shift.iloc[num_va] = 0
            else:
                amount_ratio_shift.iloc[num_va] = amount_ratio_shift.values[num_va+1]
540
            nav_net_amount_df[amount_name + "_profit_ratio_weight"] = amount_ratio_shift * nav_net_amount_df[amount_name + "_profit_ratio"]
541
            nav_net_amount_df[amount_name + "_profit_cum_ratio_weight"] = (fund_profit_ratio.cumprod()-1)*amount_ratio_shift # enter_date = nav_net_amount_df[amount_name+"_profit_ratio"].dropna()
赵杰's avatar
赵杰 committed
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558

        fund_id_list_profit_ratio_weight = [i + "_profit_ratio_weight" for i in fund_id_list]
        nav_profit_ratio_weight = nav_net_amount_df[fund_id_list_profit_ratio_weight].copy().fillna(method='ffill')

        # 组合收益率
        return_ratio = nav_profit_ratio_weight.sum(axis=1)

        # 组合累积收益率
        # return_ratio_list = list(return_ratio.values)
        cum_return_ratio = (return_ratio + 1).fillna(0).cumprod()

        # 收益率df
        cum_return_ratio_df = pd.DataFrame(return_ratio.values, columns=["return_ratio"])
        cum_return_ratio_df["cum_return_ratio"] = cum_return_ratio.values
        cum_return_ratio_df.index = return_ratio.index

        # 单个基金累计收益分解df
559
        weight_name_list = [i + "_profit_cum_ratio_weight" for i in fund_id_list]
赵杰's avatar
赵杰 committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
        signal_fund_cum_weight = nav_net_amount_df[weight_name_list]
        re_name = {x: x.replace("_profit_cum_ratio_weight", "") for x in weight_name_list}
        signal_fund_cum_weight.rename(columns=re_name, inplace=True)

        # 月度分组
        def year_month(x):
            a = x.year
            b = x.month
            return str(a) + "/" + str(b)

        profit_df_cp = signal_fund_cum_weight.copy()
        profit_df_cp["date"] = list(profit_df_cp.index)
        grouped = profit_df_cp.groupby(profit_df_cp["date"].apply(year_month))
        month_signal_fund_cum = grouped.last()
        month_signal_fund_cum.rename(columns={"date": "datetime"}, inplace=True)
        month_signal_fund_cum.sort_values(by="datetime", inplace=True)
        del month_signal_fund_cum["datetime"]

        p_cum_df = cum_return_ratio_df.copy()
        p_cum_df["date"] = list(p_cum_df.index)
        cum_grouped = p_cum_df.groupby(p_cum_df["date"].apply(year_month))
        month_fund_cum = cum_grouped.last()
        month_fund_cum.rename(columns={"date": "datetime"}, inplace=True)
        month_fund_cum.sort_values(by="datetime", inplace=True)
        del month_fund_cum["datetime"]

        return cum_return_ratio_df, month_fund_cum, month_signal_fund_cum

    @staticmethod
    def signal_fund_profit_result(p_fund_nav_df, cur_fund_id):
        result = {"fund_id": cur_fund_id}
        fund_nav_df = p_fund_nav_df.copy()
        profit = fund_nav_df[cur_fund_id].dropna() - fund_nav_df[cur_fund_id].dropna().shift(1)
        fund_nav_df[cur_fund_id + "_profit"] = profit
        fund_nav_df[cur_fund_id + "_profit_ratio"] = profit / fund_nav_df[cur_fund_id].dropna().shift(1)

        # 累积收益率
        return_ratio_list = list(fund_nav_df[cur_fund_id + "_profit_ratio"].astype("float64").values)
        cum_return_ratio = []
        last_ratio = 0
        for i in range(len(return_ratio_list)):
            if i == 0:
                last_ratio = 1 + return_ratio_list[i] if str(return_ratio_list[0]) != 'nan' else 1
                cum_return_ratio.append(last_ratio)
                continue

            cur_ratio = (1 + return_ratio_list[i]) * last_ratio
            cum_return_ratio.append(cur_ratio)
            last_ratio = cur_ratio

        fund_nav_df['cum_return_ratio'] = cum_return_ratio

        # 区间收益率
        result["return_ratio"] = cum_return_ratio[-1]

        # 区间年化收益
        n_freq = freq_days(1)
        return_ratio_year = annual_return((fund_nav_df["cum_return_ratio"].values[-1] - 1), fund_nav_df, n_freq)
        result["return_ratio_year"] = float(return_ratio_year)

        # 波动率
        volatility_ = volatility(fund_nav_df["cum_return_ratio"], n_freq)
622
        result["volatility"] = float(volatility_) if not math.isnan(volatility_) else 0.0
赵杰's avatar
赵杰 committed
623 624 625 626 627 628 629 630

        # 最大回撤
        drawdown = max_drawdown(fund_nav_df["cum_return_ratio"])
        result["max_drawdown"] = drawdown

        # 夏普比率
        sim = simple_return(fund_nav_df["cum_return_ratio"])
        exc = excess_return(sim, BANK_RATE, n_freq)
631 632 633 634
        try:
            sharpe = sharpe_ratio(exc, sim, n_freq)
        except ZeroDivisionError:
            sharpe = 0.0
赵杰's avatar
赵杰 committed
635 636 637 638 639 640 641
        result["sharpe"] = float(sharpe)

        return result

    def get_month_return_chart(self):
        res = self.total_result_data["month_return"]
        xlabels = res["date"].values
赵杰's avatar
赵杰 committed
642
        res["profit"] = res["profit"].apply(lambda x: round(x/10000.0, 2))
赵杰's avatar
赵杰 committed
643 644 645 646 647 648 649 650 651 652 653 654
        res["ratio"] = res["ratio"].apply(lambda x: round((x-1)*100, 2))
        product_list = {'name': '月度回报', 'data': res["profit"].values}
        cumulative = {'name': '累积收益', 'data': res["ratio"].values}

        return xlabels, [product_list], cumulative

    def get_total_basic_data(self):
        return self.total_result_data

    def get_group_data(self):
        return self.group_result_data

655 656 657 658 659 660 661 662
    def old_correlation(self, cnav_data):
        folio_cnav_data = cnav_data.copy()
        folio_cnav_data = folio_cnav_data.fillna(method="bfill")
        old_correlation = cal_correlation(folio_cnav_data)
        old_correlation = old_correlation.fillna(1).round(2)
        old_correlation.columns = old_correlation.columns.map(lambda x: get_fund_name(x, self.all_fund_type_dict[x]).values[0][0])
        old_correlation.index = old_correlation.index.map(lambda x: get_fund_name(x, self.all_fund_type_dict[x]).values[0][0])
        return old_correlation