def test_propagate_family(self):
   for cb, fname in manifest_reader():
     family, genotyped = read_ped_file(os.path.join(DATA_DIR, fname))
     founders, non_founders, dangling, couples, children = ped.analyze(family)
     for i in family:
       new_family = ped.propagate_family([i], children)
       self.assertEqualFamilies(family, new_family)
 def test_split_disjoint(self):
   family, genotyped = read_ped_file(os.path.join(DATA_DIR, 'ped_soup.ped'))
   self.assertEqual(len(family), 7711)
   founders, non_founders, dangling, couples, children = ped.analyze(family)
   splits = ped.split_disjoint(family, children)
   self.assertEqual(sum(map(len, splits)), len(family))
   self.assertEqual(set(family), set().union(*map(set, splits)))
Exemple #3
0
 def test_propagate_family(self):
     for cb, fname in manifest_reader():
         family, genotyped = read_ped_file(os.path.join(DATA_DIR, fname))
         founders, non_founders, dangling, couples, children = ped.analyze(
             family)
         for i in family:
             new_family = ped.propagate_family([i], children)
             self.assertEqualFamilies(family, new_family)
Exemple #4
0
 def test_split_disjoint(self):
     family, genotyped = read_ped_file(
         os.path.join(DATA_DIR, 'ped_soup.ped'))
     self.assertEqual(len(family), 7711)
     founders, non_founders, dangling, couples, children = ped.analyze(
         family)
     splits = ped.split_disjoint(family, children)
     self.assertEqual(sum(map(len, splits)), len(family))
     self.assertEqual(set(family), set().union(*map(set, splits)))
 def test_grow_family(self):
   for cb, fname in manifest_reader():
     family, genotyped = read_ped_file(os.path.join(DATA_DIR, fname))
     founders, non_founders, dangling, couples, children = ped.analyze(family)
     for i in family:
       new_family = ped.grow_family([i], children, genotyped, cb)
       self.assertEqualFamilies(family, new_family)
     for i in family:
       new_family = ped.grow_family([i], children, genotyped, max(0, cb-2))
       self.assertTrue(len(new_family) <= len(family))
Exemple #6
0
def get_all_families(kb):
  inds = kb.get_objects(kb.Individual)
  not_one_parent = [i for i in inds if not
                    (((i.mother is None) or (i.father is None)) and
                     not (i.mother is None and i.father is None))
                    ]
  founders, non_founders, dangling, couples, children = ped.analyze(
    not_one_parent
    )
  return ped.split_disjoint(not_one_parent, children)
Exemple #7
0
 def test_grow_family(self):
     for cb, fname in manifest_reader():
         family, genotyped = read_ped_file(os.path.join(DATA_DIR, fname))
         founders, non_founders, dangling, couples, children = ped.analyze(
             family)
         for i in family:
             new_family = ped.grow_family([i], children, genotyped, cb)
             self.assertEqualFamilies(family, new_family)
         for i in family:
             new_family = ped.grow_family([i], children, genotyped,
                                          max(0, cb - 2))
             self.assertTrue(len(new_family) <= len(family))
 def test_split_family(self):
   family, genotyped = read_ped_file(os.path.join(DATA_DIR, 'ped_soup.ped'))
   self.assertEqual(len(family), 7711)
   founders, non_founders, dangling, couples, children = ped.analyze(family)
   splits = ped.split_disjoint(family, children)
   fams = []
   max_complexity = ped.MAX_COMPLEXITY
   for f in splits:
     cbn = ped.compute_bit_complexity(f, genotyped)
     if cbn > max_complexity:
       subfs = ped.split_family(f, genotyped, max_complexity)
       subfs_i = set().union(*map(set, subfs))
       self.assertTrue(len(f) >= len(subfs_i))
       self.assertTrue(len(set(f) - subfs_i) >= 0)
       for s in subfs:
         self.assertTrue(
           ped.compute_bit_complexity(s, genotyped) <= max_complexity
           )
  def test_analyze(self):
    Male, Female = ['male', 'female']
    founders = [
      Ind(0, Male, None, None),
      Ind(1, Female, None, None),
      Ind(2, Male, None, None),
      Ind(3, Female, None, None),
      ]
    outsiders = [
      Ind(100, Male, None, None),
      Ind(101, Female, None, None),
      ]
    non_founders = [
      Ind(4, Male, founders[0], founders[1]),
      Ind(5, Female, founders[0], founders[1]),
      Ind(6, Male, founders[2], founders[3]),
      Ind(7, Female, founders[2], founders[3]),
      Ind(8, Male, outsiders[0], outsiders[1]),
      Ind(9, Female, outsiders[0], outsiders[1]),
      ]
    couples = [(founders[0], founders[1]),
               (founders[2], founders[3]),
               (outsiders[0], outsiders[1])]

    family = founders + non_founders
    F, NF, D, C, CH = ped.analyze(family)
    self.assertEqual(len(F), len(founders))
    self.assertEqual(set(F), set(founders))
    #
    self.assertEqual(len(NF), len(non_founders))
    self.assertEqual(set(NF), set(non_founders))
    #
    self.assertEqual(len(D), len(outsiders))
    self.assertEqual(set(D), set(outsiders))
    #
    self.assertEqual(len(C), len(couples))
    self.assertEqual(set(C), set(couples))
    #
    self.assertEqual(len(CH[0]), len(CH[1]))
    self.assertEqual(set(CH[0]), set(CH[1]))
    self.assertEqual(len(CH[2]), len(CH[3]))
    self.assertEqual(set(CH[2]), set(CH[3]))
    self.assertEqual(len(CH[100]), len(CH[101]))
    self.assertEqual(set(CH[100]), set(CH[101]))
Exemple #10
0
    def test_analyze(self):
        Male, Female = ['male', 'female']
        founders = [
            Ind(0, Male, None, None),
            Ind(1, Female, None, None),
            Ind(2, Male, None, None),
            Ind(3, Female, None, None),
        ]
        outsiders = [
            Ind(100, Male, None, None),
            Ind(101, Female, None, None),
        ]
        non_founders = [
            Ind(4, Male, founders[0], founders[1]),
            Ind(5, Female, founders[0], founders[1]),
            Ind(6, Male, founders[2], founders[3]),
            Ind(7, Female, founders[2], founders[3]),
            Ind(8, Male, outsiders[0], outsiders[1]),
            Ind(9, Female, outsiders[0], outsiders[1]),
        ]
        couples = [(founders[0], founders[1]), (founders[2], founders[3]),
                   (outsiders[0], outsiders[1])]

        family = founders + non_founders
        F, NF, D, C, CH = ped.analyze(family)
        self.assertEqual(len(F), len(founders))
        self.assertEqual(set(F), set(founders))
        #
        self.assertEqual(len(NF), len(non_founders))
        self.assertEqual(set(NF), set(non_founders))
        #
        self.assertEqual(len(D), len(outsiders))
        self.assertEqual(set(D), set(outsiders))
        #
        self.assertEqual(len(C), len(couples))
        self.assertEqual(set(C), set(couples))
        #
        self.assertEqual(len(CH[0]), len(CH[1]))
        self.assertEqual(set(CH[0]), set(CH[1]))
        self.assertEqual(len(CH[2]), len(CH[3]))
        self.assertEqual(set(CH[2]), set(CH[3]))
        self.assertEqual(len(CH[100]), len(CH[101]))
        self.assertEqual(set(CH[100]), set(CH[101]))
Exemple #11
0
 def test_split_family(self):
     family, genotyped = read_ped_file(
         os.path.join(DATA_DIR, 'ped_soup.ped'))
     self.assertEqual(len(family), 7711)
     founders, non_founders, dangling, couples, children = ped.analyze(
         family)
     splits = ped.split_disjoint(family, children)
     fams = []
     max_complexity = ped.MAX_COMPLEXITY
     for f in splits:
         cbn = ped.compute_bit_complexity(f, genotyped)
         if cbn > max_complexity:
             subfs = ped.split_family(f, genotyped, max_complexity)
             subfs_i = set().union(*map(set, subfs))
             self.assertTrue(len(f) >= len(subfs_i))
             self.assertTrue(len(set(f) - subfs_i) >= 0)
             for s in subfs:
                 self.assertTrue(
                     ped.compute_bit_complexity(s, genotyped) <=
                     max_complexity)