docs: def _check_cell_methods_paren_info(self, paren_contents, var):
          """
          Checks that the spacing and/or comment info contained inside the
          parentheses in cell_methods is well-formed
          """
          valid_info = TestCtx(BaseCheck.MEDIUM,
                               self.section_titles['7.3'])
          # if there are no colons, this is a simple comment
          # TODO: are empty comments considered valid?
          if ':' not in paren_contents:
              valid_info.out_of += 1
              valid_info.score += 1
              return valid_info
          # otherwise, split into k/v pairs
          kv_pair_pat = r'(\S+:)\s+(.*(?=\s+\w+:)|[^:]+$)\s*'
          # otherwise, we must split further with intervals coming
          # first, followed by non-standard comments
          # we need the count of the matches, and re.findall() only returns
          # groups if they are present and we wish to see if the entire match
          # object concatenated together is the same as the original string
          pmatches = [m for m in regex.finditer(kv_pair_pat, paren_contents)]
          for i, pmatch in enumerate(pmatches):
              keyword, val = pmatch.groups()
              if keyword == 'interval:':
                  valid_info.out_of += 2
                  interval_matches = regex.match(r'^\s*(?P<interval_number>\S+)\s+(?P<interval_units>\S+)\s*$', val)
                  # attempt to get the number for the interval
                  if not interval_matches:
                      valid_info.messages.append('§7.3.3 {}:cell_methods contains an interval specification that does not parse: "{}". Should be in format "interval: <number> <units>"'.format(var.name, val))
                  else:
                      try:
                          float(interval_matches.group('interval_number'))
                      except ValueError:
                          valid_info.messages.append('§7.3.3 {}:cell_methods contains an interval value that does not parse as a numeric value: "{}".'.format(var.name, interval_matches.group('interval_number')))
                      else:
                          valid_info.score += 1
  
                      # then the units
                      try:
                          Unit(interval_matches.group('interval_units'))
                      except ValueError:
                          valid_info.messages.append('§7.3.3 {}:cell_methods interval units "{}" is not parsable by UDUNITS.'.format(var.name, interval_matches.group('interval_units')))
                      else:
                          valid_info.score += 1
              elif keyword == 'comment:':
                  # comments can't really be invalid, except
                  # if they come first or aren't last, and
                  # maybe if they contain colons embedded in the
                  # comment string
                  valid_info.out_of += 1
                  if len(pmatches) == 1:
                      valid_info.messages.append('§7.3.3 If there is no standardized information, the keyword comment: should be omitted for variable {}'.format(var.name))
                  # otherwise check that the comment is the last
                  # item in the parentheses
                  elif i != len(pmatches) - 1:
                      valid_info.messages.append('§7.3.3 The non-standard "comment:" element must come after any standard elements in cell_methods for variable {}'.format(var.name))
                  #
                  else:
                      valid_info.score += 1
              else:
                  valid_info.out_of += 1
                  valid_info.messages.append('§7.3.3 Invalid cell_methods keyword "{}" for variable {}. Must be one of [interval, comment]'.format(keyword, var.name))
  
  
          # Ensure concatenated reconstructed matches are the same as the
          # original string.  If they're not, there's likely a formatting error
          valid_info.assert_true(''.join(m.group(0)
                                         for m in pmatches) == paren_contents,
                     "§7.3.3 Parenthetical content inside {}:cell_methods is not well formed: {}".format(var.name, paren_contents))
  
          return valid_info