Python plotfactory.PlotFactory类代码示例

    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

    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

    def g10_plot_gdp_cpi_une(self, start_date, finish_date, data_type = 'cpi'):
        country_group = 'g10'

        if data_type == 'cpi':
            df = self.get_CPI_YoY(start_date, finish_date, country_group)
        elif data_type == 'gdp':
            df = self.get_GDP_YoY(start_date, finish_date, country_group)
        elif data_type == 'une':
            df = self.get_UNE(start_date, finish_date, country_group)

        df = self.hist_econ_data_factory.grasp_coded_entry(df, -1)

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

        gp = GraphProperties()
        pf = PlotFactory()

        gp.plotly_location_mode = 'world'
        gp.plotly_choropleth_field = 'Val'
        gp.plotly_scope = 'world'
        gp.plotly_projection = 'Mercator'

        gp.plotly_world_readable = False

        gp.plotly_url = country_group + "-" + data_type
        gp.title = "G10 " + data_type
        gp.units = '%'

        pf.plot_generic_graph(df, type = 'choropleth', adapter = 'plotly', gp = gp)

    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)

    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

    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

    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

    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)

    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

    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

    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)

    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)

    def europe_plot_une(self, start_date, finish_date):
        country_group = 'all-europe'

        une = self.get_UNE(start_date, finish_date, country_group)
        une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)

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

        gp = GraphProperties()
        pf = PlotFactory()

        gp.plotly_location_mode = 'europe'
        gp.plotly_choropleth_field = 'Val'
        gp.plotly_scope = 'europe'
        gp.plotly_projection = 'Mercator'

        gp.plotly_world_readable = False

        gp.plotly_url = country_group + "-unemployment"; gp.title = "Europe Unemployment"
        gp.units = '%'

        pf.plot_generic_graph(une, type = 'choropleth', adapter = 'plotly', gp = gp)

    def usa_plot_une(self, start_date, finish_date):
        country_group = 'usa-states'; source = 'bloomberg'

        une = self.get_UNE(start_date, finish_date, country_group, source = 'bloomberg')
        une = self.hist_econ_data_factory.grasp_coded_entry(une, -1)

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

        gp = GraphProperties()
        pf = PlotFactory()

        gp.plotly_location_mode = 'USA-states'
        gp.plotly_choropleth_field = 'Val'
        gp.plotly_scope = 'usa'
        gp.plotly_projection = 'albers usa'
        gp.plotly_world_readable = False
        gp.plotly_url = country_group + "-unemployment"

        gp.title = "USA Unemployment"
        gp.units = 'pc'

        pf.plot_generic_graph(une, type = 'choropleth', adapter = 'plotly', gp = gp)

    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)