docs: def are_equal(a_dt, b_dt, round_sec=1):
      """Determine if two datetimes are equal with fuzz factor.
  
      A naive datetime (no timezone information) is assumed to be in in UTC.
  
      Args:
        a_dt: datetime
          Timestamp to compare.
  
        b_dt: datetime
          Timestamp to compare.
  
        round_sec: int or float
          Round the timestamps to the closest second divisible by this value before
          comparing them.
  
          E.g.:
  
          - ``n_round_sec`` = 0.1: nearest 10th of a second.
          - ``n_round_sec`` = 1: nearest second.
          - ``n_round_sec`` = 30: nearest half minute.
  
          Timestamps may lose resolution or otherwise change slightly as they go through
          various transformations and storage systems. This again may cause timestamps
          that
          have been processed in different systems to fail an exact equality compare even
          if
          they were initially the same timestamp. This rounding avoids such problems as
          long
          as the error introduced to the original timestamp is not higher than the
          rounding
          value. Of course, the rounding also causes a loss in resolution in the values
          compared, so should be kept as low as possible. The default value of 1 second
          should
          be a good tradeoff in most cases.
  
      Returns:
        bool
          - **True**: If the two datetimes are equal after being rounded by
            ``round_sec``.
  
      """
      ra_dt = round_to_nearest(a_dt, round_sec)
      rb_dt = round_to_nearest(b_dt, round_sec)
      logger.debug('Rounded:')
      logger.debug('{} -> {}'.format(a_dt, ra_dt))
      logger.debug('{} -> {}'.format(b_dt, rb_dt))
      return normalize_datetime_to_utc(ra_dt) == normalize_datetime_to_utc(rb_dt)