code: def create_position_tear_sheet(
      returns,
      positions,
      show_and_plot_top_pos=2,
      hide_positions=False,
      sector_mappings=None,
      transactions=None,
      estimate_intraday="infer",
      return_fig=False,
  ):
      """
      Generate a number of plots for analyzing a
      strategy's positions and holdings.
  
      - Plots: gross leverage, exposures, top positions, and holdings.
      - Will also print the top positions held.
  
      Parameters
      ----------
      returns : pd.Series
          Daily returns of the strategy, noncumulative.
           - See full explanation in create_full_tear_sheet.
      positions : pd.DataFrame
          Daily net position values.
           - See full explanation in create_full_tear_sheet.
      show_and_plot_top_pos : int, optional
          By default, this is 2, and both prints and plots the
          top 10 positions.
          If this is 0, it will only plot; if 1, it will only print.
      hide_positions : bool, optional
          If True, will not output any symbol names.
          Overrides show_and_plot_top_pos to 0 to suppress text output.
      sector_mappings : dict or pd.Series, optional
          Security identifier to sector mapping.
          Security ids as keys, sectors as values.
      transactions : pd.DataFrame, optional
          Prices and amounts of executed trades. One row per trade.
           - See full explanation in create_full_tear_sheet.
      estimate_intraday: boolean or str, optional
          Approximate returns for intraday strategies.
          See description in create_full_tear_sheet.
      return_fig : boolean, optional
          If True, returns the figure that was plotted on.
      """
  
      positions = utils.check_intraday(
          estimate_intraday, returns, positions, transactions
      )
  
      if hide_positions:
          show_and_plot_top_pos = 0
      vertical_sections = 7 if sector_mappings is not None else 6
  
      fig = plt.figure(figsize=(14, vertical_sections * 6))
      gs = gridspec.GridSpec(
          vertical_sections, 3, wspace=0.5, hspace=0.5
      )
      ax_exposures = plt.subplot(gs[0, :])
      ax_top_positions = plt.subplot(gs[1, :], sharex=ax_exposures)
      ax_max_median_pos = plt.subplot(gs[2, :], sharex=ax_exposures)
      ax_holdings = plt.subplot(gs[3, :], sharex=ax_exposures)
      ax_long_short_holdings = plt.subplot(gs[4, :])
      ax_gross_leverage = plt.subplot(gs[5, :], sharex=ax_exposures)
  
      positions_alloc = pos.get_percent_alloc(positions)
  
      plotting.plot_exposures(returns, positions, ax=ax_exposures)
  
      plotting.show_and_plot_top_positions(
          returns,
          positions_alloc,
          show_and_plot=show_and_plot_top_pos,
          hide_positions=hide_positions,
          ax=ax_top_positions,
      )
  
      plotting.plot_max_median_position_concentration(
          positions, ax=ax_max_median_pos
      )
  
      plotting.plot_holdings(returns, positions_alloc, ax=ax_holdings)
  
      plotting.plot_long_short_holdings(
          returns, positions_alloc, ax=ax_long_short_holdings
      )
  
      plotting.plot_gross_leverage(
          returns, positions, ax=ax_gross_leverage
      )
  
      if sector_mappings is not None:
          sector_exposures = pos.get_sector_exposures(
              positions, sector_mappings
          )
          if len(sector_exposures.columns) > 1:
              sector_alloc = pos.get_percent_alloc(sector_exposures)
              sector_alloc = sector_alloc.drop("cash", axis="columns")
              ax_sector_alloc = plt.subplot(
                  gs[6, :], sharex=ax_exposures
              )
              plotting.plot_sector_allocations(
                  returns, sector_alloc, ax=ax_sector_alloc
              )
  
      for ax in fig.axes:
          plt.setp(ax.get_xticklabels(), visible=True)
  
      if return_fig:
          return fig
  
imports: from __future__ import division
  import warnings
  from time import time
  import empyrical
  from IPython.display import display, Markdown
  import matplotlib.gridspec
  import matplotlib.pyplot
  import pandas
  from .None import _seaborn
  from .None import capacity
  from .None import perf_attrib
  from .None import plotting
  from .None import pos
  from .None import round_trips
  from .None import timeseries
  from .None import txn
  from .None import utils
label_desc: Use image node_id 5 for calling a global function with example usage: create_position_tear_sheet(returns, positions, show_and_plot_top_pos, hide_positions, sector_mappings, transactions, estimate_intraday, return_fig) and returns: fig