code: def create_full_tear_sheet(
      returns,
      positions=None,
      transactions=None,
      market_data=None,
      benchmark_rets=None,
      slippage=None,
      live_start_date=None,
      sector_mappings=None,
      round_trips=False,
      estimate_intraday="infer",
      hide_positions=False,
      cone_std=(1.0, 1.5, 2.0),
      bootstrap=False,
      unadjusted_returns=None,
      turnover_denom="AGB",
      set_context=True,
      factor_returns=None,
      factor_loadings=None,
      pos_in_dollars=True,
      header_rows=None,
      factor_partitions=FACTOR_PARTITIONS,
  ):
      """
      Generate a number of tear sheets that are useful
      for analyzing a strategy's performance.
  
      - Fetches benchmarks if needed.
      - Creates tear sheets for returns, and significant events.
          If possible, also creates tear sheets for position analysis
          and transaction analysis.
  
      Parameters
      ----------
      returns : pd.Series
          Daily returns of the strategy, noncumulative.
           - Time series with decimal returns.
           - Example:
              2015-07-16    -0.012143
              2015-07-17    0.045350
              2015-07-20    0.030957
              2015-07-21    0.004902
      positions : pd.DataFrame, optional
          Daily net position values.
           - Time series of dollar amount invested in each position and cash.
           - Days where stocks are not held can be represented by 0 or NaN.
           - Non-working capital is labelled 'cash'
           - Example:
              index         'AAPL'         'MSFT'          cash
              2004-01-09    13939.3800     -14012.9930     711.5585
              2004-01-12    14492.6300     -14624.8700     27.1821
              2004-01-13    -13853.2800    13653.6400      -43.6375
      transactions : pd.DataFrame, optional
          Executed trade volumes and fill prices.
          - One row per trade.
          - Trades on different names that occur at the
            same time will have identical indicies.
          - Example:
              index                  amount   price    symbol
              2004-01-09 12:18:01    483      324.12   'AAPL'
              2004-01-09 12:18:01    122      83.10    'MSFT'
              2004-01-13 14:12:23    -75      340.43   'AAPL'
      market_data : pd.DataFrame, optional
          Daily market_data
          - DataFrame has a multi-index index, one level is dates and another is
          market_data contains volume & price, equities as columns
      slippage : int/float, optional
          Basis points of slippage to apply to returns before generating
          tearsheet stats and plots.
          If a value is provided, slippage parameter sweep
          plots will be generated from the unadjusted returns.
          Transactions and positions must also be passed.
          - See txn.adjust_returns_for_slippage for more details.
      live_start_date : datetime, optional
          The point in time when the strategy began live trading,
          after its backtest period. This datetime should be normalized.
      hide_positions : bool, optional
          If True, will not output any symbol names.
      round_trips: boolean, optional
          If True, causes the generation of a round trip tear sheet.
      sector_mappings : dict or pd.Series, optional
          Security identifier to sector mapping.
          Security ids as keys, sectors as values.
      estimate_intraday: boolean or str, optional
          Instead of using the end-of-day positions, use the point in the day
          where we have the most $ invested. This will adjust positions to
          better approximate and represent how an intraday strategy behaves.
          By default, this is 'infer', and an attempt will be made to detect
          an intraday strategy. Specifying this value will prevent detection.
      cone_std : float, or tuple, optional
          If float, The standard deviation to use for the cone plots.
          If tuple, Tuple of standard deviation values to use for the cone plots
           - The cone is a normal distribution with this standard deviation
               centered around a linear regression.
      bootstrap : boolean (optional)
          Whether to perform bootstrap analysis for the performance
          metrics. Takes a few minutes longer.
      turnover_denom : str
          Either AGB or portfolio_value, default AGB.
          - See full explanation in txn.get_turnover.
      factor_returns : pd.Dataframe, optional
          Returns by factor, with date as index and factors as columns
      factor_loadings : pd.Dataframe, optional
          Factor loadings for all days in the date range, with date and
          ticker as index, and factors as columns.
      pos_in_dollars : boolean, optional
          indicates whether positions is in dollars
      header_rows : dict or OrderedDict, optional
          Extra rows to display at the top of the perf stats table.
      set_context : boolean, optional
          If True, set default plotting style context.
           - See plotting.context().
      factor_partitions : dict, optional
          dict specifying how factors should be separated in perf attrib
          factor returns and risk exposures plots
          - See create_perf_attrib_tear_sheet().
      """
  
      if (
          (unadjusted_returns is None)
          and (slippage is not None)
          and (transactions is not None)
      ):
          unadjusted_returns = returns.copy()
          returns = txn.adjust_returns_for_slippage(
              returns, positions, transactions, slippage
          )
  
      positions = utils.check_intraday(
          estimate_intraday, returns, positions, transactions
      )
  
      create_returns_tear_sheet(
          returns,
          positions=positions,
          transactions=transactions,
          live_start_date=live_start_date,
          cone_std=cone_std,
          benchmark_rets=benchmark_rets,
          bootstrap=bootstrap,
          turnover_denom=turnover_denom,
          header_rows=header_rows,
          set_context=set_context,
      )
  
      create_interesting_times_tear_sheet(
          returns,
          benchmark_rets=benchmark_rets,
          set_context=set_context,
      )
  
      if positions is not None:
          create_position_tear_sheet(
              returns,
              positions,
              hide_positions=hide_positions,
              set_context=set_context,
              sector_mappings=sector_mappings,
              estimate_intraday=False,
          )
  
          if transactions is not None:
              create_txn_tear_sheet(
                  returns,
                  positions,
                  transactions,
                  unadjusted_returns=unadjusted_returns,
                  estimate_intraday=False,
                  set_context=set_context,
              )
              if round_trips:
                  create_round_trip_tear_sheet(
                      returns=returns,
                      positions=positions,
                      transactions=transactions,
                      sector_mappings=sector_mappings,
                      estimate_intraday=False,
                  )
  
              if market_data is not None:
                  create_capacity_tear_sheet(
                      returns,
                      positions,
                      transactions,
                      market_data,
                      liquidation_daily_vol_limit=0.2,
                      last_n_days=125,
                      estimate_intraday=False,
                  )
  
          if factor_returns is not None and factor_loadings is not None:
              create_perf_attrib_tear_sheet(
                  returns,
                  positions,
                  factor_returns,
                  factor_loadings,
                  transactions,
                  pos_in_dollars=pos_in_dollars,
                  factor_partitions=factor_partitions,
              )
  
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 2 for calling a global function with example usage: create_full_tear_sheet(returns, positions, transactions, market_data, benchmark_rets, slippage, live_start_date, sector_mappings, round_trips, estimate_intraday, hide_positions, cone_std, bootstrap, unadjusted_returns, turnover_denom, set_context, factor_returns, factor_loadings, pos_in_dollars, header_rows, factor_partitions) without return types