def test_size_20(self):
     self.assertEqual(test('Flowers 5--16 × 4--12 cm'), [{
         'part': 'flower',
         'trait': 'part',
         'start': 0,
         'end': 7
     }, {
         'length_low': 5.0,
         'length_high': 16.0,
         'length_units': 'cm',
         'trait': 'size',
         'start': 8,
         'end': 13,
         'part': 'flower'
     }, {
         'width_low': 4.0,
         'width_high': 12.0,
         'width_units': 'cm',
         'trait': 'size',
         'start': 16,
         'end': 21,
         'part': 'flower'
     }, {
         'units': 'cm',
         'trait': 'units',
         'start': 22,
         'end': 24
     }])
Beispiel #2
0
 def test_shape_09(self):
     self.assertEqual(test('Leaf blades lobe apex rounded'),
                      [{
                          'part': 'leaf',
                          'trait': 'part',
                          'start': 0,
                          'end': 11
                      }, {
                          'subpart': 'lobe',
                          'trait': 'subpart',
                          'start': 12,
                          'end': 16,
                          'part': 'leaf'
                      }, {
                          'subpart': 'apex',
                          'trait': 'subpart',
                          'start': 17,
                          'end': 21,
                          'part': 'leaf'
                      }, {
                          'shape': 'orbicular',
                          'trait': 'shape',
                          'start': 22,
                          'end': 29,
                          'part': 'leaf',
                          'subpart': 'apex'
                      }])
Beispiel #3
0
 def test_shape_12(self):
     self.assertEqual(
         test("""
             blade lanceolate to narrowly or broadly lanceolate
             or elliptic-lanceolate,"""), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 5
         }, {
             'shape': 'lanceolate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 6,
             'end': 16
         }, {
             'shape': 'lanceolate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 32,
             'end': 50
         }, {
             'shape': 'elliptic-lanceolate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 54,
             'end': 73
         }])
 def test_margin_02(self):
     self.maxDiff = None
     self.assertEqual(
         test('margins ciliate, apex acute to long-acuminate,'),
         [{
             'subpart': 'margin',
             'trait': 'subpart',
             'start': 0,
             'end': 7
         }, {
             'margin_shape': 'ciliate',
             'trait': 'margin_shape',
             'subpart': 'margin',
             'start': 8,
             'end': 15
         }, {
             'subpart': 'apex',
             'trait': 'subpart',
             'start': 17,
             'end': 21
         }, {
             'shape': 'acute',
             'trait': 'shape',
             'subpart': 'apex',
             'start': 22,
             'end': 27
         }, {
             'shape': 'acuminate',
             'trait': 'shape',
             'subpart': 'apex',
             'start': 31,
             'end': 45
         }])
Beispiel #5
0
 def test_shape_07(self):
     self.assertEqual(
         test("""
             ; blade abaxially, suborbiculate to
             broadly ovate, depressed-ovate, or reniform,"""), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 2,
             'end': 7
         }, {
             'shape': 'orbicular',
             'trait': 'shape',
             'part': 'leaf',
             'start': 19,
             'end': 32
         }, {
             'shape': 'ovate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 36,
             'end': 49
         }, {
             'shape': 'ovate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 51,
             'end': 66
         }, {
             'shape': 'reniform',
             'trait': 'shape',
             'part': 'leaf',
             'start': 71,
             'end': 79
         }])
 def test_count_35(self):
     self.assertEqual(test("""Capsule 2-locular. x = 9."""),
                      [{
                          'part': 'capsule',
                          'trait': 'part',
                          'start': 0,
                          'end': 7
                      }, {
                          'low': 2,
                          'trait': 'count',
                          'start': 8,
                          'end': 9,
                          'part': 'capsule',
                          'subpart': 'locular'
                      }, {
                          'subpart': 'locular',
                          'trait': 'subpart',
                          'start': 10,
                          'end': 17,
                          'part': 'capsule'
                      }, {
                          'part': 'x',
                          'trait': 'part',
                          'start': 19,
                          'end': 22
                      }, {
                          'low': 9,
                          'trait': 'count',
                          'start': 23,
                          'end': 24,
                          'part': 'x'
                      }])
 def test_part_02(self):
     self.assertEqual(
         test('leaflets mostly 1 or 3'),
         [{'part': 'leaflet', 'trait': 'part', 'start': 0, 'end': 8},
          {'low': 1, 'high': 3, 'trait': 'count', 'part': 'leaflet',
           'start': 16, 'end': 22}]
     )
Beispiel #8
0
 def test_color_02(self):
     self.assertEqual(
         test('hypanthium straw-colored to sulphur-yellow or golden-yellow.'
              ), [{
                  'part': 'hypanthium',
                  'trait': 'part',
                  'start': 0,
                  'end': 10
              }, {
                  'color': 'yellow',
                  'trait': 'color',
                  'part': 'hypanthium',
                  'start': 11,
                  'end': 24
              }, {
                  'color': 'yellow',
                  'trait': 'color',
                  'part': 'hypanthium',
                  'start': 28,
                  'end': 42
              }, {
                  'color': 'yellow',
                  'trait': 'color',
                  'part': 'hypanthium',
                  'start': 46,
                  'end': 59
              }])
Beispiel #9
0
 def test_part_01(self):
     self.assertEqual(test('Leaf: number of the pairs'), [{
         'part': 'leaf',
         'trait': 'part',
         'start': 0,
         'end': 5
     }])
 def test_size_30(self):
     self.assertEqual(test('leaflets obovate, 1-2.5 × to 1.6 cm,'),
                      [{
                          'part': 'leaflet',
                          'trait': 'part',
                          'start': 0,
                          'end': 8
                      }, {
                          'shape': 'obovate',
                          'trait': 'shape',
                          'start': 9,
                          'end': 16,
                          'part': 'leaflet'
                      }, {
                          'length_low': 1.0,
                          'length_high': 2.5,
                          'length_units': 'cm',
                          'trait': 'size',
                          'start': 18,
                          'end': 23,
                          'part': 'leaflet'
                      }, {
                          'width_low': 1.6,
                          'width_units': 'cm',
                          'trait': 'size',
                          'start': 29,
                          'end': 32,
                          'part': 'leaflet'
                      }, {
                          'units': 'cm',
                          'trait': 'units',
                          'start': 33,
                          'end': 35
                      }])
Beispiel #11
0
 def test_color_13(self):
     self.assertEqual(
         test('Leaves acaulescent or nearly so, with white hairs.'),
         [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 6
         }, {
             'habit': 'acaulescent',
             'trait': 'habit',
             'part': 'leaf',
             'start': 7,
             'end': 18
         }, {
             'color': 'white',
             'trait': 'color',
             'part': 'leaf',
             'subpart': 'hair',
             'start': 38,
             'end': 43
         }, {
             'subpart': 'hair',
             'part': 'leaf',
             'trait': 'subpart',
             'start': 44,
             'end': 49
         }])
 def test_size_05(self):
     self.assertEqual(test('leaf 4–10 cm wide'), [{
         'part': 'leaf',
         'trait': 'part',
         'start': 0,
         'end': 4
     }, {
         'width_low': 4.0,
         'width_high': 10.0,
         'width_units': 'cm',
         'trait': 'size',
         'start': 5,
         'end': 9,
         'part': 'leaf'
     }, {
         'units': 'cm',
         'trait': 'units',
         'start': 10,
         'end': 12
     }, {
         'dimension': 'width',
         'trait': 'dimension',
         'start': 13,
         'end': 17
     }])
 def test_size_28(self):
     self.assertEqual(
         test(
             'Petals pale violet, with darker keel; standard elliptic, 6-7 × 3-4;'
         ), [{
             'part': 'petal',
             'trait': 'part',
             'start': 0,
             'end': 6
         }, {
             'color': 'purple',
             'trait': 'color',
             'start': 7,
             'end': 18,
             'part': 'petal'
         }, {
             'subpart': 'keel',
             'trait': 'subpart',
             'start': 32,
             'end': 36,
             'part': 'petal'
         }, {
             'shape': 'elliptic',
             'trait': 'shape',
             'start': 47,
             'end': 55,
             'part': 'petal'
         }])
 def test_size_24(self):
     self.assertEqual(test('Petals 15-21 × ca. 8 mm,'), [{
         'part': 'petal',
         'trait': 'part',
         'start': 0,
         'end': 6
     }, {
         'length_low': 15.0,
         'length_high': 21.0,
         'length_units': 'mm',
         'trait': 'size',
         'start': 7,
         'end': 12,
         'part': 'petal'
     }, {
         'width_low': 8.0,
         'width_units': 'mm',
         'trait': 'size',
         'start': 19,
         'end': 20,
         'part': 'petal'
     }, {
         'units': 'mm',
         'trait': 'units',
         'start': 21,
         'end': 23
     }])
 def test_count_03(self):
     self.assertEqual(test('blade 5–10 × 4–9 cm'), [{
         'part': 'leaf',
         'trait': 'part',
         'start': 0,
         'end': 5
     }, {
         'length_low': 5.0,
         'length_high': 10.0,
         'length_units': 'cm',
         'trait': 'size',
         'start': 6,
         'end': 10,
         'part': 'leaf'
     }, {
         'width_low': 4.0,
         'width_high': 9.0,
         'width_units': 'cm',
         'trait': 'size',
         'start': 13,
         'end': 16,
         'part': 'leaf'
     }, {
         'units': 'cm',
         'trait': 'units',
         'start': 17,
         'end': 19
     }])
Beispiel #16
0
 def test_surface_02(self):
     self.assertEqual(
         test("""
             Flower: indumentum of the calyx present;
             indumentum of the corolla absent.
             """), [{
             'part': 'flower',
             'trait': 'part',
             'start': 0,
             'end': 7
         }, {
             'part': 'calyx',
             'subpart': 'indumentum',
             'present': True,
             'trait': 'surface',
             'start': 8,
             'end': 39
         }, {
             'part': 'corolla',
             'subpart': 'indumentum',
             'present': False,
             'trait': 'surface',
             'start': 41,
             'end': 73
         }])
 def test_count_29(self):
     self.assertEqual(test('blade lobes 0 or 1–4(–9) per side'),
                      [{
                          'part': 'leaf',
                          'trait': 'part',
                          'start': 0,
                          'end': 5
                      }, {
                          'subpart': 'lobe',
                          'trait': 'subpart',
                          'start': 6,
                          'end': 11,
                          'part': 'leaf'
                      }, {
                          'min': 0,
                          'low': 1,
                          'high': 4,
                          'max': 9,
                          'count_group': 'per side',
                          'trait': 'count',
                          'start': 12,
                          'end': 24,
                          'part': 'leaf',
                          'subpart': 'lobe'
                      }, {
                          'count_group': 'per side',
                          'trait': 'count_group',
                          'start': 25,
                          'end': 33
                      }])
 def test_count_06(self):
     self.assertEqual(test('Staminate flowers (3–)5–10(–20)'),
                      [{
                          'sex': 'staminate',
                          'part': 'flower',
                          'trait': 'sex',
                          'start': 0,
                          'end': 9
                      }, {
                          'part': 'flower',
                          'trait': 'part',
                          'start': 10,
                          'end': 17,
                          'sex': 'staminate'
                      }, {
                          'min': 3,
                          'low': 5,
                          'high': 10,
                          'max': 20,
                          'trait': 'count',
                          'start': 18,
                          'end': 31,
                          'part': 'flower',
                          'sex': 'staminate'
                      }])
 def test_part_01(self):
     self.assertEqual(
         test('with thick, woody rootstock.'),
         [{'woodiness': 'woody', 'trait': 'woodiness', 'part': 'rootstock',
           'start': 12, 'end': 17},
          {'part': 'rootstock', 'trait': 'part', 'start': 18, 'end': 27}]
     )
 def test_count_10(self):
     self.assertEqual(test('leaf (12-)23-34 × 45-56'), [{
         'part': 'leaf',
         'trait': 'part',
         'start': 0,
         'end': 4
     }])
 def test_margin_02(self):
     self.assertEqual(
         test('Fruit: margin moniliform.'),
         [{'part': 'fruit', 'trait': 'part', 'start': 0, 'end': 6},
          {'subpart': 'margin', 'margin': 'moniliform', 'part': 'fruit',
           'trait': 'margin', 'start': 7, 'end': 24}]
     )
 def test_count_11(self):
     self.assertEqual(test('stigma papillose on 1 side,'), [{
         'part': 'stigma',
         'trait': 'part',
         'start': 0,
         'end': 6
     }])
 def test_margin_05(self):
     self.assertEqual(
         test("""
             margins coarsely toothed or remotely sinuate-dentate
             to serrate,"""), [{
             'subpart': 'margin',
             'trait': 'subpart',
             'start': 0,
             'end': 7
         }, {
             'margin_shape': 'toothed',
             'trait': 'margin_shape',
             'subpart': 'margin',
             'start': 8,
             'end': 24
         }, {
             'margin_shape': 'sinuate-dentate',
             'trait': 'margin_shape',
             'subpart': 'margin',
             'start': 28,
             'end': 52
         }, {
             'margin_shape': 'serrate',
             'trait': 'margin_shape',
             'subpart': 'margin',
             'start': 56,
             'end': 63
         }])
 def test_count_12(self):
     self.assertEqual(test('Male flowers with 2-8(-20) stamens;'),
                      [{
                          'sex': 'male',
                          'trait': 'sex',
                          'start': 0,
                          'end': 4,
                          'part': 'flower'
                      }, {
                          'part': 'flower',
                          'trait': 'part',
                          'start': 5,
                          'end': 12,
                          'sex': 'male'
                      }, {
                          'low': 2,
                          'high': 8,
                          'max': 20,
                          'trait': 'count',
                          'start': 18,
                          'end': 26,
                          'part': 'stamen',
                          'sex': 'male'
                      }, {
                          'part': 'stamen',
                          'trait': 'part',
                          'start': 27,
                          'end': 34,
                          'sex': 'male'
                      }])
Beispiel #25
0
 def test_shape_08(self):
     self.assertEqual(
         test("""
             blade broadly ovate-cordate to triangular-cordate or
             reniform, shallowly to deeply palmately"""), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 5
         }, {
             'shape': 'ovate-cordate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 6,
             'end': 27
         }, {
             'shape': 'triangular-cordate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 31,
             'end': 49
         }, {
             'shape': 'reniform',
             'trait': 'shape',
             'part': 'leaf',
             'start': 53,
             'end': 61
         }])
 def test_count_16(self):
     self.assertEqual(test('plants weigh up to 200 pounds'), [{
         'part': 'plant',
         'trait': 'part',
         'start': 0,
         'end': 6
     }])
Beispiel #27
0
 def test_shape_11(self):
     self.assertEqual(
         test("""
             Leaves: petiole blade pentagonal-angulate to
             reniform-angulate or shallowly 5-angulate."""), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 6
         }, {
             'part': 'petiole',
             'trait': 'part',
             'start': 8,
             'end': 21
         }, {
             'shape': 'polygonal',
             'trait': 'shape',
             'part': 'petiole',
             'start': 22,
             'end': 41
         }, {
             'shape': 'reniform-polygonal',
             'trait': 'shape',
             'part': 'petiole',
             'start': 45,
             'end': 62
         }, {
             'shape': 'polygonal',
             'trait': 'shape',
             'part': 'petiole',
             'start': 66,
             'end': 86
         }])
 def test_count_17(self):
     self.assertEqual(
         test("""
             Pistillate flowers: hyaline bristle at apex of hypanthial
             aculei 0.5–1 times as long as opaque base."""),
         [{
             'sex': 'pistillate',
             'trait': 'sex',
             'start': 0,
             'end': 10,
             'part': 'flower'
         }, {
             'part': 'flower',
             'trait': 'part',
             'start': 11,
             'end': 18,
             'sex': 'pistillate'
         }, {
             'part_as_loc': 'at apex of hypanthial aculei',
             'trait': 'part_as_loc',
             'start': 36,
             'end': 64,
             'part': 'flower',
             'sex': 'pistillate'
         }, {
             'subpart': 'base',
             'trait': 'subpart',
             'start': 95,
             'end': 99,
             'part': 'flower',
             'sex': 'pistillate'
         }])
Beispiel #29
0
 def test_shape_13(self):
     self.assertEqual(
         test(
             'blade broadly ovate to rounded-cordate, subreniform, or deltate'
         ), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 5
         }, {
             'shape': 'ovate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 6,
             'end': 19
         }, {
             'shape': 'orbicular-cordate',
             'trait': 'shape',
             'part': 'leaf',
             'start': 23,
             'end': 38
         }, {
             'shape': 'reniform',
             'trait': 'shape',
             'part': 'leaf',
             'start': 40,
             'end': 51
         }, {
             'shape': 'deltoid',
             'trait': 'shape',
             'part': 'leaf',
             'start': 56,
             'end': 63
         }])
 def test_size_13(self):
     self.assertEqual(
         test("""
             Leaves 3-foliolate, lateral pair of leaflets
             deeply lobed, petiolules 2–5 mm,"""), [{
             'part': 'leaf',
             'trait': 'part',
             'start': 0,
             'end': 6
         }, {
             'low': 3,
             'trait': 'count',
             'start': 7,
             'end': 8,
             'part': 'leaf',
             'subpart': 'foliolate'
         }, {
             'subpart': 'foliolate',
             'trait': 'subpart',
             'start': 9,
             'end': 18,
             'part': 'leaf'
         }, {
             'location': 'lateral',
             'trait': 'location',
             'start': 20,
             'end': 27,
             'part': 'leaflet',
             'subpart': 'foliolate'
         }, {
             'part': 'leaflet',
             'trait': 'part',
             'start': 36,
             'end': 44
         }, {
             'subpart': 'lobe',
             'trait': 'subpart',
             'start': 52,
             'end': 57,
             'part': 'leaflet'
         }, {
             'part': 'petiolule',
             'trait': 'part',
             'start': 59,
             'end': 69
         }, {
             'length_low': 2.0,
             'length_high': 5.0,
             'length_units': 'mm',
             'trait': 'size',
             'start': 70,
             'end': 73,
             'part': 'petiolule',
             'subpart': 'lobe'
         }, {
             'units': 'mm',
             'trait': 'units',
             'start': 74,
             'end': 76
         }])