code: def jacard_similarity_from_nested_dicts(self, nested_dictionaries):
          
          sims = {}
          overlaps = {}
          weights = {}
          for a, column_dict_a in nested_dictionaries.items():
              row_set_a = set(column_dict_a.keys())
              for b, column_dict_b in nested_dictionaries.items():
                  row_set_b = set(column_dict_b.keys())
                  common_rows = row_set_a.intersection(row_set_b)
                  n_overlap = len(common_rows)
                  overlaps[(a, b)] = n_overlap
                  total = 0.0
                  weight = 0.0
                  for row_name in common_rows:
                      value_a = column_dict_a[row_name]
                      value_b = column_dict_b[row_name]
                      minval = min(value_a, value_b)
                      maxval = max(value_a, value_b)
                      total += minval
                      weight += maxval
                  weights[(a, b)] = weight
                  if weight < self.min_weight_for_similarity:
                      continue
                  if n_overlap < self.min_count_for_similarity:
                      continue
                  sims[(a, b)] = total / weight
          return sims, overlaps, weights
docs: Compute the continuous Jacard similarity between all pairs
          of keys in dictionary-of-dictionaries given as an input.
  
          Returns three element tuple:
              - similarity dictionary: (key, key) -> float
              - overlap count dictionary: key -> key -> int
              - weight dictionary: key -> key -> float