docs: def calculate_affinity(self, username):
          """
          Get the affinity between the "base user" and ``username``.
  
          .. note:: The data returned will be a namedtuple, with the affinity
                    and shared rated anime. This can easily be separated
                    as follows (using the user ``Luna`` as ``username``):
  
                    .. code-block:: python
  
                        affinity, shared = ma.calculate_affinity("Luna")
  
                    Alternatively, the following also works:
  
                    .. code-block:: python
  
                        affinity = ma.calculate_affinity("Luna")
  
                    with the affinity and shared available as
                    ``affinity.affinity`` and ``affinity.shared`` respectively.
  
          .. note:: The final affinity value may or may not be rounded,
                    depending on the value of :attr:`._round`, set at
                    class initialisation.
  
          :param str username: The username to calculate affinity with
          :return: (float affinity, int shared)
          :rtype: tuple
          """
          scores = self.comparison(username)
  
          # Handle cases where the shared scores are <= 10 so
          # affinity can not be accurately calculated.
          if len(scores) <= 10:
              raise NoAffinityError("Shared rated anime count between "
                                    "`{}` and `{}` is less than eleven"
                                    .format(self._base_user, username))
  
          # Sort multiple rows of scores into two arrays for calculations.
          # E.G. [1,2], [3,4], [5,6] to [1,3,5], [2,4,6]
          values = scores.values()
          scores1, scores2 = list(zip(*values))
  
          pearson = calcs.pearson(scores1, scores2)
          pearson *= 100
  
          if self._round is not False:
              pearson = round(pearson, self._round)
  
          return models.Affinity(affinity=pearson, shared=len(scores))