def verify_examples(self, examples_filename, region, options,
                        verify_labels):
        # Do some simple structural checks on the tf.Examples in the file.
        expected_labels = [
            'variant/encoded', 'locus', 'image/format', 'image/encoded',
            'alt_allele_indices/encoded'
        ]
        if verify_labels:
            expected_labels += ['label', 'truth_variant/encoded']

        examples = list(io_utils.read_tfrecords(examples_filename))
        for example in examples:
            for label_feature in expected_labels:
                self.assertIn(label_feature, example.features.feature)
            # pylint: disable=g-explicit-length-test
            self.assertGreater(
                len(tf_utils.example_alt_alleles_indices(example)), 0)

            if verify_labels:
                # Check that our variant and our truth_variant both have the same start.
                self.assertEqual(
                    variantutils.variant_position(
                        tf_utils.example_variant(example)),
                    variantutils.variant_position(
                        tf_utils.example_truth_variant(example)))

        # Check that the variants in the examples are good.
        variants = [tf_utils.example_variant(x) for x in examples]
        self.verify_variants(variants, region, options, is_gvcf=False)

        return examples
 def test_variant_position_and_range(self):
     v1 = test_utils.make_variant(chrom='1', alleles=['A', 'C'], start=10)
     v2 = test_utils.make_variant(chrom='1',
                                  alleles=['AGCT', 'C'],
                                  start=10)
     pos = ranges.make_range('1', 10, 11)
     range_ = ranges.make_range('1', 10, 14)
     self.assertEqual(pos, variantutils.variant_position(v1))
     self.assertEqual(pos, variantutils.variant_position(v2))
     self.assertEqual(pos, variantutils.variant_range(v1))
     self.assertEqual(range_, variantutils.variant_range(v2))
Ejemplo n.º 3
0
  def _find_matching_variant_in_reader(self, variant):
    """Finds a variant in vcf_reader compatible with variant, if one exists."""

    def _usable_truth(truth_variant):
      return (variant.start == truth_variant.start and
              not variantutils.is_filtered(truth_variant))

    region = variantutils.variant_position(variant)
    matches = [m for m in self._vcf_reader.query(region) if _usable_truth(m)]
    if not matches:
      return None
    elif len(matches) > 1:
      logging.warning(
          'Multiple matches detected, keeping first, for variant %s: %s',
          variant, matches)
    return matches[0]