code: def backtest_daily(
      start_time: Union[str, pd.Timestamp],
      end_time: Union[str, pd.Timestamp],
      strategy: Union[str, dict, BaseStrategy],
      executor: Union[str, dict, _executor.BaseExecutor] = None,
      account: Union[float, int, position.Position] = 1e8,
      benchmark: str = "SH000300",
      exchange_kwargs: dict = None,
      pos_type: str = "Position",
  ):
      """initialize the strategy and executor, then executor the backtest of daily frequency
  
      Parameters
      ----------
      start_time : Union[str, pd.Timestamp]
          closed start time for backtest
          **NOTE**: This will be applied to the outmost executor's calendar.
      end_time : Union[str, pd.Timestamp]
          closed end time for backtest
          **NOTE**: This will be applied to the outmost executor's calendar.
          E.g. Executor[day](Executor[1min]),   setting `end_time == 20XX0301` will include all the minutes on 20XX0301
      strategy : Union[str, dict, BaseStrategy]
          for initializing outermost portfolio strategy. Please refer to the docs of init_instance_by_config for more information.
  
          E.g.
  
          .. code-block:: python
  
              # dict
              strategy = {
                  "class": "TopkDropoutStrategy",
                  "module_path": "qlib.contrib.strategy.signal_strategy",
                  "kwargs": {
                      "signal": (model, dataset),
                      "topk": 50,
                      "n_drop": 5,
                  },
              }
              # BaseStrategy
              pred_score = pd.read_pickle("score.pkl")["score"]
              STRATEGY_CONFIG = {
                  "topk": 50,
                  "n_drop": 5,
                  "signal": pred_score,
              }
              strategy = TopkDropoutStrategy(**STRATEGY_CONFIG)
              # str example.
              # 1) specify a pickle object
              #     - path like 'file:///<path to pickle file>/obj.pkl'
              # 2) specify a class name
              #     - "ClassName":  getattr(module, "ClassName")() will be used.
              # 3) specify module path with class name
              #     - "a.b.c.ClassName" getattr(<a.b.c.module>, "ClassName")() will be used.
  
      executor : Union[str, dict, BaseExecutor]
          for initializing the outermost executor.
      benchmark: str
          the benchmark for reporting.
      account : Union[float, int, Position]
          information for describing how to creating the account
  
          For `float` or `int`:
  
              Using Account with only initial cash
  
          For `Position`:
  
              Using Account with a Position
      exchange_kwargs : dict
          the kwargs for initializing Exchange
          E.g.
  
          .. code-block:: python
  
              exchange_kwargs = {
                  "freq": freq,
                  "limit_threshold": None, # limit_threshold is None, using C.limit_threshold
                  "deal_price": None, # deal_price is None, using C.deal_price
                  "open_cost": 0.0005,
                  "close_cost": 0.0015,
                  "min_cost": 5,
              }
  
      pos_type : str
          the type of Position.
  
      Returns
      -------
      report_normal: pd.DataFrame
          backtest report
      positions_normal: pd.DataFrame
          backtest positions
  
      """
      freq = "day"
      if executor is None:
          executor_config = {
              "time_per_step": freq,
              "generate_portfolio_metrics": True,
          }
          executor = _executor.SimulatorExecutor(**executor_config)
      _exchange_kwargs = {
          "freq": freq,
          "limit_threshold": None,
          "deal_price": None,
          "open_cost": 0.0005,
          "close_cost": 0.0015,
          "min_cost": 5,
      }
      if exchange_kwargs is not None:
          _exchange_kwargs.update(exchange_kwargs)
  
      portfolio_metric_dict, indicator_dict = backtest_func(
          start_time=start_time,
          end_time=end_time,
          strategy=strategy,
          executor=executor,
          account=account,
          benchmark=benchmark,
          exchange_kwargs=_exchange_kwargs,
          pos_type=pos_type,
      )
      analysis_freq = "{0}{1}".format(*Freq.parse(freq))
  
      report_normal, positions_normal = portfolio_metric_dict.get(
          analysis_freq
      )
  
      return report_normal, positions_normal
  
file_path: qlib/qlib/contrib/evaluate.py
imports: from __future__ import division
  from __future__ import print_function
  import numpy
  import pandas
  import warnings
  from typing import Union
  from ..log import get_module_logger
  from ..utils import get_date_range
  from ..utils.resam import Freq
  from ..strategy.base import BaseStrategy
  from ..backtest import get_exchange, position, backtest, executor
  from ..data import D
  from ..config import C
  from ..data.dataset.utils import get_level_index
label_desc: Use image node_id 3 for calling a global function with example usage: backtest_daily(start_time, end_time, strategy, executor, account, benchmark, exchange_kwargs, pos_type) and returns: report_normal,  positions_normal