code: async def analysis(self, board: chess.Board, limit: Optional[Limit] = None, *, multipv: Optional[int] = None, game: object = None, info: Info = INFO_ALL, root_moves: Optional[Iterable[chess.Move]] = None, options: ConfigMapping = {}) -> "AnalysisResult":
          
docs: Starts analysing a position.
  
          :param board: The position to analyse. The entire move stack will be
              sent to the engine.
          :param limit: Optional. An instance of :class:`chess.engine.Limit`
              that determines when to stop the analysis. Analysis is infinite
              by default.
          :param multipv: Optional. Analyse multiple root moves.
          :param game: Optional. An arbitrary object that identifies the game.
              Will automatically inform the engine if the object is not equal
              to the previous game (e.g. ``ucinewgame``, ``new``).
          :param info: Selects which information to retrieve from the
              engine. ``INFO_NONE``, ``INFO_BASE`` (basic information that is
              trivial to obtain), ``INFO_SCORE``, ``INFO_PV``,
              ``INFO_REFUTATION``, ``INFO_CURRLINE``, ``INFO_ALL`` or any
              bitwise combination. Some overhead is associated with parsing
              extra information.
          :param root_moves: Optional. Limit analysis to a list of root moves.
          :param options: Optional. A dictionary of engine options for the
              analysis. The previous configuration will be restored after the
              analysis is complete. You can permanently apply a configuration
              with :func:`~chess.engine.EngineProtocol.configure()`.
  
          Returns :class:`~chess.engine.AnalysisResult`, a handle that allows
          asynchronously iterating over the information sent by the engine
          and stopping the the analysis at any time.