Python GraphProperties.file_output方法代码示例

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_group_benchmark_pnl(self):
        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR
        #gp.color = 'RdYlGn'

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - cumulative).png'

        # plot cumulative line of returns
        pf.plot_line_graph(self.reduce_plot(self._strategy_group_benchmark_pnl), adapter = 'pythalesians', gp = gp)

        # needs write stats flag turned on
        try:
            keys = self._strategy_group_benchmark_tsd.keys()
            ir = []

            for key in keys: ir.append(self._strategy_group_benchmark_tsd[key].inforatio()[0])

            ret_stats = pandas.DataFrame(index = keys, data = ir, columns = ['IR'])
            ret_stats = ret_stats.sort_index()
            gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark PnL - IR).png'

            gp.display_brand_label = False

            # plot ret stats
            pf.plot_bar_graph(ret_stats, adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_signal_proportion(self, strip = None):

        signal = self._strategy_signal

        long = signal[signal > 0].count()
        short = signal[signal < 0].count()
        flat = signal[signal == 0].count()

        keys = long.index

        df = pandas.DataFrame(index = keys, columns = ['Long', 'Short', 'Flat'])

        df['Long'] = long
        df['Short']  = short
        df['Flat'] = flat

        if strip is not None: keys = [k.replace(strip, '') for k in keys]

        df.index = keys
        df = df.sort_index()

        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'

        try:
            pf.plot_bar_graph(self.reduce_plot(df), adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def run_day_of_month_analysis(self, strat):
        from pythalesians.economics.seasonality.seasonality import Seasonality
        from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs

        tsc = TimeSeriesCalcs()
        seas = Seasonality()
        strat.construct_strategy()
        pnl = strat.get_strategy_pnl()

        # get seasonality by day of the month
        pnl = pnl.resample('B').mean()
        rets = tsc.calculate_returns(pnl)
        bus_day = seas.bus_day_of_month_seasonality(rets, add_average = True)

        # get seasonality by month
        pnl = pnl.resample('BM').mean()
        rets = tsc.calculate_returns(pnl)
        month = seas.monthly_seasonality(rets)

        self.logger.info("About to plot seasonality...")
        gp = GraphProperties()
        pf = PlotFactory()

        # Plotting spot over day of month/month of year
        gp.color = 'Blues'
        gp.scale_factor = self.scale_factor
        gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality day of month.png'
        gp.title = strat.FINAL_STRATEGY + ' day of month seasonality'
        gp.display_legend = False
        gp.color_2_series = [bus_day.columns[-1]]
        gp.color_2 = ['red'] # red, pink
        gp.linewidth_2 = 4
        gp.linewidth_2_series = [bus_day.columns[-1]]
        gp.y_axis_2_series = [bus_day.columns[-1]]

        pf.plot_line_graph(bus_day, adapter = 'pythalesians', gp = gp)

        gp = GraphProperties()

        gp.scale_factor = self.scale_factor
        gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' seasonality month of year.png'
        gp.title = strat.FINAL_STRATEGY + ' month of year seasonality'

        pf.plot_line_graph(month, adapter = 'pythalesians', gp = gp)

        return month

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_signal_proportion(self, strip = None):

        signal = self._strategy_signal

        # count number of long, short and flat periods in our sample
        long = signal[signal > 0].count()
        short = signal[signal < 0].count()
        flat = signal[signal == 0].count()

        keys = long.index

        # how many trades have there been (ignore size of the trades)
        trades = abs(signal - signal.shift(-1))
        trades = trades[trades > 0].count()

        df_trades = pandas.DataFrame(index = keys, columns = ['Trades'], data = trades)

        df = pandas.DataFrame(index = keys, columns = ['Long', 'Short', 'Flat'])

        df['Long'] = long
        df['Short']  = short
        df['Flat'] = flat

        if strip is not None: keys = [k.replace(strip, '') for k in keys]

        df.index = keys
        df_trades.index = keys
        # df = df.sort_index()

        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        try:
            gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy signal proportion).png'
            pf.plot_bar_graph(self.reduce_plot(df), adapter = 'pythalesians', gp = gp)

            gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy trade no).png'
            pf.plot_bar_graph(self.reduce_plot(df_trades), adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_group_leverage(self):
        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY + ' Leverage'
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Leverage).png'

        pf.plot_line_graph(self.reduce_plot(self._strategy_group_leverage), adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_individual_leverage(self):
        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY + ' Leverage'
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Individual Leverage).png'

        try:
            pf.plot_line_graph(self.reduce_plot(self._individual_leverage), adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_pnl(self):
        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Strategy PnL).png'

        try:
            pf.plot_line_graph(self.reduce_plot(self._strategy_pnl), adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_group_benchmark_annualised_pnl(self, cols = None):
        # TODO - unfinished, needs checking!

        if cols is None: cols = self._strategy_group_benchmark_annualised_pnl.columns

        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR
        gp.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Group Benchmark Annualised PnL).png'

        pf.plot_line_graph(self.reduce_plot(self._strategy_group_benchmark_annualised_pnl[cols]), adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_group_pnl_trades(self):
        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY + " (bp)"
        gp.display_legend = True
        gp.scale_factor = self.SCALE_FACTOR

        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Individual Trade PnL).png'

        # zero when there isn't a trade exit
        strategy_pnl_trades = self._strategy_pnl_trades.fillna(0) * 100 * 100

        try:
            pf.plot_line_graph(self.reduce_plot(strategy_pnl_trades), adapter = 'pythalesians', gp = gp)
        except: pass

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_single_var_regression(self, y, x, y_variable_names, x_variable_names, statistic,
                                          tag = 'stats',
                                          title = None,
                                          pretty_index = None, output_path = None,
                                          scale_factor = Constants.plotfactory_scale_factor,
                                          silent_plot = False,
                                          shift=[0]):

        if not(isinstance(statistic, list)):
            statistic = [statistic]

        # TODO optimise loop so that we are calculating each regression *once* at present calculating it
        # for each statistic, which is redundant
        for st in statistic:
            stats_df = []

            for sh in shift:
                x_sh = x.shift(sh)
                stats_temp = self.report_single_var_regression(y, x_sh, y_variable_names, x_variable_names, st,
                                                             pretty_index)

                stats_temp.columns = [ x + "_" + str(sh) for x in stats_temp.columns]

                stats_df.append(stats_temp)

            stats_df = pandas.concat(stats_df, axis=1)
            stats_df = stats_df.dropna(how='all')

            if silent_plot: return stats_df

            pf = PlotFactory()
            gp = GraphProperties()

            if title is None: title = statistic

            gp.title = title
            gp.display_legend = True
            gp.scale_factor = scale_factor
            # gp.color = ['red', 'blue', 'purple', 'gray', 'yellow', 'green', 'pink']

            if output_path is not None:
                gp.file_output = output_path + ' (' + tag + ' ' + st + ').png'

            pf.plot_bar_graph(stats_df, adapter = 'pythalesians', gp = gp)

        return stats_df

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def run_arbitrary_sensitivity(self, strat, parameter_list = None, parameter_names = None,
                                  pretty_portfolio_names = None, parameter_type = None):

        asset_df, spot_df, spot_df2, basket_dict = strat.fill_assets()

        port_list = None

        for i in range(0, len(parameter_list)):
            br = strat.fill_backtest_request()

            current_parameter = parameter_list[i]

            # for calculating P&L
            for k in current_parameter.keys():
                setattr(br, k, current_parameter[k])

            strat.br = br   # for calculating signals

            signal_df = strat.construct_signal(spot_df, spot_df2, br.tech_params)

            cash_backtest = CashBacktest()
            self.logger.info("Calculating... " + pretty_portfolio_names[i])

            cash_backtest.calculate_trading_PnL(br, asset_df, signal_df)
            stats = str(cash_backtest.get_portfolio_pnl_desc()[0])

            port = cash_backtest.get_cumportfolio().resample('B')
            port.columns = [pretty_portfolio_names[i] + ' ' + stats]

            if port_list is None:
                port_list = port
            else:
                port_list = port_list.join(port)

        pf = PlotFactory()
        gp = GraphProperties()

        gp.color = 'Blues'
        gp.resample = 'B'
        gp.file_output = self.DUMP_PATH + strat.FINAL_STRATEGY + ' ' + parameter_type + '.png'
        gp.scale_factor = self.scale_factor
        gp.title = strat.FINAL_STRATEGY + ' ' + parameter_type
        pf.plot_line_graph(port_list, adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def g10_line_plot_cpi(self, start_date, finish_date):
        today_root = datetime.date.today().strftime("%Y%m%d") + " "
        country_group = 'g10-ez'
        cpi = self.get_CPI_YoY(start_date, finish_date, country_group)

        from pythalesians.graphics.graphs.plotfactory import PlotFactory
        from pythalesians.graphics.graphs.graphproperties import GraphProperties

        gp = GraphProperties()
        pf = PlotFactory()

        gp.title = "G10 CPI YoY"
        gp.units = '%'
        gp.scale_factor = 3
        gp.file_output = today_root + 'G10 CPI YoY ' + str(gp.scale_factor) + '.png'
        cpi.columns = [x.split('-')[0] for x in cpi.columns]
        gp.linewidth_2 = 3
        gp.linewidth_2_series = ['United States']

        pf.plot_generic_graph(cpi, type = 'line', adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def g10_line_plot_une(self, start_date, finish_date):
        today_root = datetime.date.today().strftime("%Y%m%d") + " "
        country_group = 'g10-ez'
        une = self.get_UNE(start_date, finish_date, country_group)

        from pythalesians.graphics.graphs.plotfactory import PlotFactory
        from pythalesians.graphics.graphs.graphproperties import GraphProperties

        gp = GraphProperties()
        pf = PlotFactory()

        gp.title = "G10 Unemployment Rate (%)"
        gp.units = '%'
        gp.scale_factor = Constants.plotfactory_scale_factor
        gp.file_output = today_root + 'G10 UNE ' + str(gp.scale_factor) + '.png'
        une.columns = [x.split('-')[0] for x in une.columns]
        gp.linewidth_2 = 3
        gp.linewidth_2_series = ['United States']

        pf.plot_generic_graph(une, type = 'line', adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def g10_line_plot_gdp(self, start_date, finish_date):
        today_root = datetime.date.today().strftime("%Y%m%d") + " "
        country_group = 'g10-ez'
        gdp = self.get_GDP_QoQ(start_date, finish_date, country_group)

        from pythalesians.graphics.graphs.plotfactory import PlotFactory
        from pythalesians.graphics.graphs.graphproperties import GraphProperties

        gp = GraphProperties()
        pf = PlotFactory()

        gp.title = "G10 GDP"
        gp.units = 'Rebased'
        gp.scale_factor = Constants.plotfactory_scale_factor
        gp.file_output = today_root + 'G10 UNE ' + str(gp.scale_factor) + '.png'
        gdp.columns = [x.split('-')[0] for x in gdp.columns]
        gp.linewidth_2 = 3
        gp.linewidth_2_series = ['United Kingdom']

        from pythalesians.timeseries.calcs.timeseriescalcs import TimeSeriesCalcs
        tsc = TimeSeriesCalcs()
        gdp = gdp / 100
        gdp = tsc.create_mult_index_from_prices(gdp)
        pf.plot_generic_graph(gdp, type = 'line', adapter = 'pythalesians', gp = gp)

# 需要导入模块: from pythalesians.graphics.graphs.graphproperties import GraphProperties [as 别名]
# 或者: from pythalesians.graphics.graphs.graphproperties.GraphProperties import file_output [as 别名]
    def plot_strategy_signals(self, date = None, strip = None):

        ######## plot signals
        strategy_signal = self._strategy_signal
        strategy_signal = 100 * (strategy_signal)

        if date is None:
            last_day = strategy_signal.ix[-1].transpose().to_frame()
        else:
            last_day = strategy_signal.ix[date].transpose().to_frame()

        if strip is not None:
            last_day.index = [x.replace(strip, '') for x in last_day.index]

        print(last_day)

        pf = PlotFactory()
        gp = GraphProperties()

        gp.title = self.FINAL_STRATEGY + " positions (% portfolio notional)"
        gp.scale_factor = self.SCALE_FACTOR
        gp.file_output = self.DUMP_PATH + self.FINAL_STRATEGY + ' (Positions) ' + str(gp.scale_factor) + '.png'

        pf.plot_generic_graph(last_day, adapter = 'pythalesians', type = 'bar', gp = gp)