code: def coveredPairs(self, blocker, records_1, records_2):
      cover: dict[
          Predicate, dict[str, tuple[set[RecordID], set[RecordID]]]
      ] = {}
      pair_cover = {}
      n_records_1 = len(records_1)
      n_records_2 = len(records_2)
  
      for predicate in blocker.predicates:
          cover[predicate] = collections.defaultdict(
              lambda: (set(), set())
          )
          for id, record in records_2.items():
              blocks = predicate(record, target=True)
              for block in blocks:
                  cover[predicate][block][1].add(id)
  
          current_blocks = set(cover[predicate])
          for id, record in records_1.items():
              blocks = set(predicate(record))
              for block in blocks & current_blocks:
                  cover[predicate][block][0].add(id)
  
      cover = {
          predicate: blocks
          for predicate, blocks in cover.items()
          if not any(
              len(A) == n_records_1 and len(B) == n_records_2
              for A, B in blocks.values()
          )
      }
  
      for predicate, blocks in cover.items():
          pairs = frozenset(
              pair
              for A, B in blocks.values()
              for pair in itertools.product(A, B)
          )
          if pairs:
              pair_cover[predicate] = pairs
  
      return pair_cover
  
imports: from __future__ import annotations
  import collections
  import functools
  import itertools
  import logging
  import math
  import random
  from abc import ABC
  from typing import TYPE_CHECKING, overload
  from warnings import warn
  from .None import blocking, branch_and_bound
label_desc: Use image node_id 6 for calling the RecordLinkBlockLearner obj's underlying member method code with example usage: obj.coveredPairs(blocker, records_1, records_2) and returns: pair_cover