docs: def items(*args, **kwargs):
      '''
      Calls the master for a fresh pillar and generates the pillar data on the
      fly
  
      Contrast with :py:func:`raw` which returns the pillar data that is
      currently loaded into the minion.
  
      pillar
          If specified, allows for a dictionary of pillar data to be made
          available to pillar and ext_pillar rendering. these pillar variables
          will also override any variables of the same name in pillar or
          ext_pillar.
  
          .. versionadded:: 2015.5.0
  
      pillar_enc
          If specified, the data passed in the ``pillar`` argument will be passed
          through this renderer to decrypt it.
  
          .. note::
              This will decrypt on the minion side, so the specified renderer
              must be set up on the minion for this to work. Alternatively,
              pillar data can be decrypted master-side. For more information, see
              the :ref:`Pillar Encryption <pillar-encryption>` documentation.
              Pillar data that is decrypted master-side, is not decrypted until
              the end of pillar compilation though, so minion-side decryption
              will be necessary if the encrypted pillar data must be made
              available in an decrypted state pillar/ext_pillar rendering.
  
          .. versionadded:: 2017.7.0
  
      pillarenv
          Pass a specific pillar environment from which to compile pillar data.
          If not specified, then the minion's :conf_minion:`pillarenv` option is
          not used, and if that also is not specified then all configured pillar
          environments will be merged into a single pillar dictionary and
          returned.
  
          .. versionadded:: 2016.11.2
  
      saltenv
          Included only for compatibility with
          :conf_minion:`pillarenv_from_saltenv`, and is otherwise ignored.
  
      CLI Example:
  
      .. code-block:: bash
  
          salt '*' pillar.items
      '''
      # Preserve backwards compatibility
      if args:
          return item(*args)
  
      pillarenv = kwargs.get('pillarenv')
      if pillarenv is None:
          if __opts__.get('pillarenv_from_saltenv', False):
              pillarenv = kwargs.get('saltenv') or __opts__['saltenv']
          else:
              pillarenv = __opts__['pillarenv']
  
      pillar_override = kwargs.get('pillar')
      pillar_enc = kwargs.get('pillar_enc')
  
      if pillar_override and pillar_enc:
          try:
              pillar_override = salt.utils.crypt.decrypt(
                  pillar_override,
                  pillar_enc,
                  translate_newlines=True,
                  opts=__opts__,
                  valid_rend=__opts__['decrypt_pillar_renderers'])
          except Exception as exc:
              raise CommandExecutionError(
                  'Failed to decrypt pillar override: {0}'.format(exc)
              )
  
      pillar = salt.pillar.get_pillar(
          __opts__,
          __grains__,
          __opts__['id'],
          pillar_override=pillar_override,
          pillarenv=pillarenv)
  
      return pillar.compile_pillar()