docs: def _serialize(
          self, obj, fields_dict, error_store, many=False,
          accessor=None, dict_class=dict, index_errors=True,
          index=None,
      ):
          """Takes raw data (a dict, list, or other object) and a dict of
          fields to output and serializes the data based on those fields.
  
          :param obj: The actual object(s) from which the fields are taken from
          :param dict fields_dict: Mapping of field names to :class:`Field` objects.
          :param ErrorStore error_store: Structure to store errors.
          :param bool many: Set to `True` if ``data`` should be serialized as
              a collection.
          :param callable accessor: Function to use for getting values from ``obj``.
          :param type dict_class: Dictionary class used to construct the output.
          :param bool index_errors: Whether to store the index of invalid items in
              ``self.errors`` when ``many=True``.
          :param int index: Index of the item being serialized (for storing errors) if
              serializing a collection, otherwise `None`.
          :return: A dictionary of the marshalled data
  
          .. versionchanged:: 1.0.0
              Renamed from ``marshal``.
          """
          index = index if index_errors else None
          if many and obj is not None:
              self._pending = True
              ret = [
                  self._serialize(
                      d, fields_dict, error_store, many=False,
                      dict_class=dict_class, accessor=accessor,
                      index=idx, index_errors=index_errors,
                  )
                  for idx, d in enumerate(obj)
              ]
              self._pending = False
              return ret
          items = []
          for attr_name, field_obj in iteritems(fields_dict):
              if getattr(field_obj, 'load_only', False):
                  continue
              key = field_obj.data_key or attr_name
              getter = lambda d: field_obj.serialize(attr_name, d, accessor=accessor)
              value = self._call_and_store(
                  getter_func=getter,
                  data=obj,
                  field_name=key,
                  error_store=error_store,
                  index=index,
              )
              if value is missing:
                  continue
              items.append((key, value))
          ret = dict_class(items)
          return ret