def test_dict_keys(self):
        label_a = Label('label_a')
        label_b = Label('label_b', parent=label_a)

        dictionary_labels = {label_a: 0, label_b: 1}
        dictionary_names = {'label_a': 2, 'label_b': 3}

        assert label_a in dictionary_labels
        assert label_a in dictionary_names
        assert label_b in dictionary_labels
        assert label_b in dictionary_names

        assert 'label_a' in dictionary_labels
        assert 'label_a' in dictionary_names
        assert 'label_b' in dictionary_labels
        assert 'label_b' in dictionary_names

        assert dictionary_labels[label_a] == 0
        assert dictionary_labels[label_b] == 1
        assert dictionary_names[label_a] == 2
        assert dictionary_names[label_b] == 3

        assert dictionary_labels['label_a'] == 0
        assert dictionary_labels['label_b'] == 1
        assert dictionary_names['label_a'] == 2
        assert dictionary_names['label_b'] == 3
    def test_properties(self, tree_a, tree_b):
        tree_d = Label('#05-0*+"0560&&45')  # Invalid true root label name !
        tree_e = Label('#05-valid name-overall')
        with pytest.raises(ValueError, match='Invalid name'):
            invalid_taxo = Taxonomy(tree_e, tree_d)

        tree_c = Label('#-*65623&}-5_44tree c-with 3 Invalid$chAr')
        taxo = Taxonomy(tree_a, tree_b, tree_c)

        assert tree_a in taxo.properties
        assert hasattr(taxo, tree_a.name)
        assert isinstance(getattr(taxo, tree_a.name), Tree)
        assert isinstance(taxo.properties[tree_a], Tree)

        assert tree_b in taxo.properties
        assert hasattr(taxo, tree_b.name)
        assert isinstance(getattr(taxo, tree_b.name), Tree)
        assert isinstance(taxo.properties[tree_b], Tree)

        # Using cleaned name ex-nihilo here. If one wants to do it programmatically, use the clean() function.
        assert '_44tree_c_with_3_invalid_char' in taxo.properties
        assert hasattr(taxo, '_44tree_c_with_3_invalid_char')
        assert isinstance(getattr(taxo, '_44tree_c_with_3_invalid_char'), Tree)
        assert isinstance(taxo.properties['_44tree_c_with_3_invalid_char'],
                          Tree)

        assert 'tree_d' not in taxo.properties
        assert not hasattr(taxo, 'tree_d')
    def test_set(self):
        label_a = Label('label_a')
        label_b = Label('label_b', parent=label_a)

        set_labels = {label_a, label_b}
        set_names = {'label_a', 'label_b'}

        assert label_a in set_labels
        assert label_a in set_names
        assert label_b in set_labels
        assert label_b in set_names

        assert 'label_a' in set_labels
        assert 'label_a' in set_names
        assert 'label_b' in set_labels
        assert 'label_b' in set_names

        assert {label_a} & set_labels == {label_a}
        assert {label_a} & set_names == {'label_a'}
        assert {'label_a'} & set_labels == {label_a}
        assert {'label_a'} & set_names == {'label_a'}

        assert {label_b} & set_labels == {label_b}
        assert {label_b} & set_names == {'label_b'}
        assert {'label_b'} & set_labels == {label_b}
        assert {'label_b'} & set_names == {'label_b'}
    def test_contains(self, tree_a):
        tree = Tree(tree_a)

        assert Label('a_a_c_a_b') in tree
        assert not Label('c_a_c_a_b') in tree

        assert Label('a') in tree
        assert not Label('c') in tree
    def test_depth_wise(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        tree_a = Tree(a)
        tree_a_a = Tree(a_a)
        tree_a_a_b = Tree(a_a_b)

        assert tree_a.depth_wise == {
            0: (a, ),
            1: (a_a, ),
            2: (a_a_a, a_a_b, a_a_c),
            3: (a_a_b_a, a_a_b_b)
        }

        assert tree_a_a.depth_wise == {
            0: (a_a, ),
            1: (a_a_a, a_a_b, a_a_c),
            2: (a_a_b_a, a_a_b_b)
        }

        assert tree_a_a_b.depth_wise == {0: (a_a_b, ), 1: (a_a_b_a, a_a_b_b)}
Beispiel #6
0
    def test_record_collection_without_taxonomy(self):
        import geojson

        r = data.Record([0, 1, 2], ['car', 'road vehicle'],
                        some_property='some property',
                        another_property=45)
        rc = data.RecordCollection(r)
        mixin_suite(rc)  # Base validity tests

        assert hasattr(rc, 'id')
        assert re.match(
            r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z',
            rc.id)

        assert len(rc) == 1
        assert rc[0] == r
        r2 = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]], ['car', 'truck'],
                         some_property='some property',
                         another_property=45)
        rc.append(r2)

        assert len(rc) == 2
        assert rc[1] == r2

        assert geojson.dumps(rc, sort_keys=True) == '{"features": [' \
                                                    '{"geometry": {"coordinates": [0, 1, 2], "type": "Point"}, ' \
                                                    '"properties": {"another_property": 45, ' \
                                                    '"category": ["car", "road vehicle"], ' \
                                                    '"confidence": null, "some_property": "some property"}, ' \
                                                    '"type": "Feature"}, ' \
                                                    '{"geometry": {"coordinates": [[[0, 0], [0, 1], [1, 1], [0, 0]]], '\
                                                    '"type": "Polygon"}, ' \
                                                    '"properties": {"another_property": 45, ' \
                                                    '"category": ["car", "truck"], ' \
                                                    '"confidence": null, ' \
                                                    '"some_property": "some property"}, "type": "Feature"}], ' \
                                                    '"type": "FeatureCollection"}'

        assert 'car' in rc.taxonomy
        assert rc.taxonomy['car'].parent == rc.taxonomy.root
        assert 'truck' in rc.taxonomy
        assert rc.taxonomy['truck'].parent == rc.taxonomy.root
        assert 'road vehicle' in rc.taxonomy
        assert rc.taxonomy['road vehicle'].parent == rc.taxonomy.root

        rc[1] = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]], ['trucks'],
                            some_property='some property',
                            another_property=45)
        assert rc[1].labels == (Label('trucks'), )
        assert 'trucks' in rc.taxonomy
        assert rc.taxonomy['trucks'].parent == rc.taxonomy.root

        rc = data.RecordCollection(r)
    def test_creation(self):
        label_a = Label('label')
        label_b = Label('label')
        label_c = Label('label', some_property='some_value')
        mixin_suite(label_b)  # Base validity tests
        mixin_suite(label_c)  # Base validity tests

        # Some individual base testing
        assert label_a.name == 'label'
        assert label_a.parent is None
        assert not label_a.children
        assert not label_a.ancestors
        assert label_a.depth == 0
        assert not label_a.descendants
        assert hash(label_a) == hash('label')

        # Some individual base testing
        assert label_b.name == 'label'
        assert label_b.parent is None
        assert not label_b.children
        assert not label_b.ancestors
        assert label_b.depth == 0
        assert not label_b.descendants
        assert hash(label_b) == hash('label')

        # Some individual base testing
        assert label_c.name == 'label'
        assert label_c.parent is None
        assert not label_c.children
        assert not label_c.ancestors
        assert label_c.depth == 0
        assert not label_c.descendants
        assert hash(label_c) == hash('label')
        assert label_c.some_property == 'some_value'

        assert label_a.id != label_b.id != label_c.id
        assert label_a == label_b == label_c
        assert not label_a != label_b != label_c
    def test_ancestors(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        tree_a_a = Tree(a_a)
        tree_a_a_b = Tree(a_a_b)

        assert a_a_b_a.ancestors == (a_a_b, a_a, a)
        assert tree_a_a.ancestors(a_a_b_a) == (a_a_b, a_a)
        assert tree_a_a_b.ancestors(a_a_b_a) == (a_a_b, )
    def test_siblings(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        tree_a = Tree(a)
        tree_a_a = Tree(a_a)
        tree_a_a_b = Tree(a_a_b)

        assert set(tree_a.siblings(a_a_b)) == {a_a_a, a_a_c}
        assert set(tree_a_a.siblings(a_a_b)) == {a_a_a, a_a_c}
        assert set(tree_a_a_b.siblings(a_a_b)) == set()
    def test_depth(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        tree_a_a = Tree(a_a)
        tree_a_a_b = Tree(a_a_b)

        assert a_a_b_a.depth > tree_a_a.depth(a_a_b_a) > tree_a_a_b.depth(
            a_a_b_a)
        assert a_a_b_a.depth == 3
        assert tree_a_a.depth(a_a_b_a) == 2
        assert tree_a_a_b.depth(a_a_b_a) == 1
    def test_equality(self):
        label_a = Label('label_a')
        label_b = Label('label_b', parent=label_a)
        label_c = Label('label_c',
                        children=(label_a, ),
                        some_property='some_value')

        label_d = Label('label_d')
        label_e = Label('label_e', parent=label_d)
        label = Label('label_a', parent=label_d, some_property='some_value')

        assert label_a == label_a
        assert label_a != label_b != label_c != label_d != label_e
        assert label_a == label

        assert label_a == 'label_a'
        assert 'label_a' == label_a
        assert label_a != 'label_b'
        assert 'label_a' != label_b
        assert 'label_a' == label
        assert label == 'label_a'
    def test_attach_add_detach(self):
        label_a = Label('label_a')
        label_b = Label('label_b')
        label_c = Label('label_c', some_property='some_value')

        fake_label_a = Label('label_a')

        # Generic link testing
        label_a.attach(label_b)
        self._test_label_link(label_b, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_b, )
        assert label_b.descendants == {'label_a': label_a}

        # Not fake attach created ?
        assert label_b.parent is None
        assert not label_b.ancestors
        assert label_b.depth == 0
        assert not label_a.children
        assert not label_a.descendants

        # Assert label_c was a simple witness
        self._test_label_no_link(label_c, label_a)
        self._test_label_no_link(label_c, label_b)

        # Add another node
        label_a.add(label_c)
        self._test_label_link(label_a, label_c)

        # More exact testing here
        assert label_a.ancestors == (label_b, )
        assert label_c.ancestors == (label_a, label_b)
        assert label_a.descendants == {'label_c': label_c}
        assert label_b.descendants == {'label_a': label_a, 'label_c': label_c}

        # Not fake attach created ?
        assert label_b.parent is None
        assert not label_b.ancestors
        assert not label_c.children
        assert not label_c.descendants

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.add(label_b)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.attach(label_c)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            label_c.add(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(ValueError,
                           match=r'Invalid tree: Overlapping tree '
                           r'(?:{|set\(\[)\'label_a\'[}\])]+ found in'):
            fake_label_a.add(label_c)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            label_a.add(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            label_a.attach(fake_label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            fake_label_a.add(label_a)

        # Test name duplicate sanity checks
        with pytest.raises(
                ValueError,
                match=
                r'Invalid tree: adding label_a to label_a\'s tree is impossible.'
        ):
            fake_label_a.attach(label_a)

        # Test name collision is inefficient for add or attach
        label_b.add(fake_label_a)
        assert label_a.id in set([label.id for label in label_b.children])
        assert fake_label_a.id not in set(
            [label.id for label in label_b.children])

        label_c.attach(fake_label_a)
        assert label_c.parent.id != fake_label_a.id
        assert label_c.parent.id == label_a.id

        fake_label_a.attach(label_b)
        assert label_a.id in set([label.id for label in label_b.children])
        assert fake_label_a.id not in set(
            [label.id for label in label_b.children])

        # Remove the a -> b link upward
        label_a.detach(label_b)
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_a, label_c)

        assert label_a.parent is None
        assert not label_a.ancestors
        assert label_a.depth == 0
        assert not label_b.children
        assert not label_b.descendants

        # Remove the c -> a link downward
        label_a.detach(label_c)
        self._test_label_no_link(label_a, label_c)

        assert label_c.parent is None
        assert not label_c.ancestors
        assert label_c.depth == 0
        assert not label_a.children
        assert not label_a.descendants

        # Test silent ignore of dubious detach
        label_a.detach(label_c, label_b)

        # Test properties
        label_a.parent = label_b
        self._test_label_link(label_b, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_b, )
        assert label_b.descendants == {'label_a': label_a}

        # Test properties
        label_a.parent = label_c
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_c, label_a)

        # More exact testing here
        assert label_a.depth == 1
        assert label_a.ancestors == (label_c, )
        assert label_c.descendants == {'label_a': label_a}

        label_c.detach(label_a)
        # Test properties
        label_a.children = (label_b, )
        self._test_label_link(label_a, label_b)

        # More exact testing here
        assert label_b.depth == 1
        assert label_b.ancestors == (label_a, )
        assert label_a.descendants == {'label_b': label_b}

        # Test properties
        label_a.children = (label_c, )
        self._test_label_no_link(label_a, label_b)
        self._test_label_link(label_a, label_c)

        # More exact testing here
        assert label_c.depth == 1
        assert label_c.ancestors == (label_a, )
        assert label_a.descendants == {'label_c': label_c}

        # Test constructor
        label_d = Label('label_d', parent=label_a)
        self._test_label_link(label_a, label_c)
        self._test_label_link(label_a, label_d)

        # More exact testing here
        assert label_d.depth == 1
        assert label_d.ancestors == (label_a, )
        assert label_a.descendants == {'label_c': label_c, 'label_d': label_d}

        label_e = Label('label_e', children=(label_a, label_b))
        self._test_label_link(label_e, label_b)
        self._test_label_link(label_e, label_a)
        self._test_label_link(label_a, label_c)
        self._test_label_link(label_a, label_d)

        # More exact testing here
        assert label_b.depth == 1
        assert label_b.ancestors == (label_e, )
        assert label_d.depth == 2
        assert label_d.ancestors == (label_a, label_e)
        assert label_e.descendants == {
            'label_a': label_a,
            'label_b': label_b,
            'label_c': label_c,
            'label_d': label_d
        }
    def test_accessor(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        tree_a = Tree(a)
        tree_a_a_b = Tree(a_a_b)

        assert tree_a['a_a_b_a'] == tree_a_a_b['a_a_b_a'] == a_a_b_a
        assert tree_a['a_a_b_a'].id == tree_a_a_b['a_a_b_a'].id == a_a_b_a.id

        assert tree_a.get()['a_a_b_a'] == tree_a_a_b.get(
        )['a_a_b_a'] == a_a_b_a
        assert tree_a.get()['a_a_b_a'].id == tree_a_a_b.get(
        )['a_a_b_a'].id == a_a_b_a.id

        assert tree_a.get(max_depth=1)['a_a_b_a'] == a_a
        assert tree_a.get(max_depth=1)['a_a_b_a'].id == a_a.id

        assert tree_a_a_b.get(max_depth=0)['a_a_b_a'] == a_a_b
        assert tree_a_a_b.get(max_depth=0)['a_a_b_a'].id == a_a_b.id

        assert tree_a.get().name['a_a_b_a'] == tree_a_a_b.get(
        )['a_a_b_a'] == a_a_b_a
        assert tree_a.get().name['a_a_b_a'].id == tree_a_a_b.get(
        )['a_a_b_a'].id == a_a_b_a.id

        assert tree_a.get(max_depth=1).name['a_a_b_a'] == a_a
        assert tree_a.get(max_depth=1).name['a_a_b_a'].id == a_a.id

        assert tree_a_a_b.get(max_depth=0).name['a_a_b_a'] == a_a_b
        assert tree_a_a_b.get(max_depth=0).name['a_a_b_a'].id == a_a_b.id

        assert tree_a.get().id[a_a_b_a.id] == tree_a_a_b.get().id[
            a_a_b_a.id] == a_a_b_a
        assert tree_a.get().id[a_a_b_a.id].id == tree_a_a_b.get().id[
            a_a_b_a.id].id == a_a_b_a.id

        assert tree_a.get(max_depth=1).id[a_a_b_a.id] == a_a
        assert tree_a.get(max_depth=1).id[a_a_b_a.id].id == a_a.id

        assert tree_a_a_b.get(max_depth=0).id[a_a_b_a.id] == a_a_b
        assert tree_a_a_b.get(max_depth=0).id[a_a_b_a.id].id == a_a_b.id

        new_a_a_b = Label("new_a_a_b")
        new_a_a_b_name = Label("new_a_a_b_name")
        new_a_a_b_id = Label("new_a_a_b_id")
        c = Label("c")

        tree_a.get()['a_a_b'] = new_a_a_b
        assert new_a_a_b in a_a.children
        assert a_a_b_a.parent == new_a_a_b
        assert a_a_b_b.parent == new_a_a_b
        assert a_a_b.parent is None
        assert not a_a_b.children

        tree_a.get().name['new_a_a_b'] = new_a_a_b_name
        assert new_a_a_b_name in a_a.children
        assert a_a_b_a.parent == new_a_a_b_name
        assert a_a_b_b.parent == new_a_a_b_name
        assert new_a_a_b.parent is None
        assert not new_a_a_b.children

        tree_a.get().id[new_a_a_b_name.id] = new_a_a_b_id
        assert new_a_a_b_id in a_a.children
        assert a_a_b_a.parent == new_a_a_b_id
        assert a_a_b_b.parent == new_a_a_b_id
        assert new_a_a_b_name.parent is None
        assert not new_a_a_b_name.children

        tree_a['new_a_a_b_id'] = new_a_a_b
        assert new_a_a_b in a_a.children
        assert a_a_b_a.parent == new_a_a_b
        assert a_a_b_b.parent == new_a_a_b
        assert new_a_a_b_id.parent is None
        assert not new_a_a_b_id.children

        tree_a.get()['label'] = c
        assert c in a.children
        assert c.parent == a

        with pytest.raises(
                KeyError,
                match=
                'Invalid identifier: label does not correspond to any label in the tree.'
        ):
            print(tree_a.get()['label'])

        with pytest.raises(
                KeyError,
                match=
                'Invalid identifier: label does not correspond to any label in the tree.'
        ):
            print(tree_a.get().name['label'])

        with pytest.raises(
                KeyError,
                match=
                'Invalid identifier: label does not correspond to any label in the tree.'
        ):
            print(tree_a.get().id['label'])
    def test_equality(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)

        # Unordered
        b = Label("a")
        b_a = Label("a_a", parent=b)

        b_a_c = Label("a_a_c", parent=b_a)

        b_a_b_b = Label("a_a_b_b")
        b_a_b_a = Label("a_a_b_a")
        b_a_b = Label("a_a_b", parent=b_a, children=(b_a_b_b, b_a_b_a))
        b_a_a = Label("a_a_a", parent=b_a)

        assert Tree(a) == Tree(b)
        assert not Tree(a) != Tree(b)

        # Structure change
        b = Label("a")
        b_a = Label("a_a", parent=b)

        b_a_c = Label("a_a_c", parent=b_a)
        b_a_a = Label("a_a_a", parent=b_a)

        b_a_b_b = Label("a_a_b_b")
        b_a_b = Label("a_a_b", parent=b_a, children=(b_a_b_b, ))

        assert not Tree(a) == Tree(b)
        assert Tree(a) != Tree(b)

        # Content change
        b = Label("a")
        b_a = Label("a_a", parent=b)

        b_a_c = Label("a_a_c", parent=b_a)
        b_a_a = Label("a_a_e", parent=b_a)

        b_a_b_b = Label("a_a_b_b")
        b_a_b_a = Label("a_a_b_a")
        b_a_b = Label("a_a_b", parent=b_a, children=(b_a_b_b, b_a_b_a))

        assert not Tree(a) == Tree(b)
        assert Tree(a) != Tree(b)
 def test_to_dict(self, tree_a):
     results = {
         Label('a'): {
             Label('a_a'): {
                 Label('a_a_a'): {},
                 Label('a_a_b'): {
                     Label('a_a_b_a'): {},
                     Label('a_a_b_b'): {}
                 },
                 Label('a_a_c'): {
                     Label('a_a_c_a'): {
                         Label('a_a_c_a_a'): {},
                         Label('a_a_c_a_b'): {
                             Label('a_a_c_a_b_a'): {}
                         }
                     },
                     Label('a_a_c_b'): {
                         Label('a_a_c_b_a'): {}
                     }
                 }
             },
             Label('a_b'): {
                 Label('a_b_a'): {
                     Label('a_b_a_a'): {},
                     Label('a_b_a_b'): {}
                 }
             }
         }
     }
     assert Tree(tree_a).to_dict() == results
Beispiel #16
0
    def test_record(self):
        import geojson

        taxonomy = Taxonomy(Label('road vehicle', children=(Label('car'), )))
        incomplete_taxonomy = Taxonomy(Label('road vehicle'))

        with pytest.raises(ValueError, match='Expected at least 1 label'):
            r = data.Record([0, 2, 3], [])

        r = data.Record([0, 1, 2], ['car', 'road vehicle'],
                        some_property='some property',
                        another_property=45)
        mixin_suite(r)  # Base validity tests

        assert hasattr(r, 'id')
        assert re.match(
            r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z',
            r.id)

        # Check label fetch w/o taxonomy
        assert all(isinstance(n, Label) for n in r.labels)
        with pytest.raises(
                ValueError,
                match=
                'No taxonomy exists for this record but a max_depth was provided'
        ):
            r.get_labels(max_depth=1)
        assert all(isinstance(n, Label) for n in r.get_labels())

        # Check label fetch w/ incomplete taxonomy
        r.taxonomy = incomplete_taxonomy
        with pytest.raises(KeyError):
            assert all(isinstance(n, Label) for n in r.labels)

        # Check label fetch w/ taxonomy
        r.taxonomy = taxonomy
        assert all(isinstance(n, Label) for n in r.labels)
        assert r.labels[0].parent.id == taxonomy.road_vehicle.root.id
        assert r.labels[1].id == taxonomy.road_vehicle.root.id

        assert hasattr(r, 'some_property')
        assert hasattr(r, 'another_property')

        assert r.is_valid
        assert r.type == 'Point'

        assert geojson.dumps(r, sort_keys=True) == '{"geometry": {"coordinates": [0, 1, 2], "type": "Point"}, ' \
                                                   '"properties": {"another_property": 45, ' \
                                                   '"category": ["car", "road vehicle"], ' \
                                                   '"confidence": null, "some_property": "some property"}, ' \
                                                   '"type": "Feature"}'

        assert geojson.dumps(r.to_geojson(style='export-service'), sort_keys=True) \
            == '{"geometry": {"coordinates": [0, 1, 2], "type": "Point"}, ' \
               '"properties": {"another_property": 45, ' \
               '"score": null, ' \
               '"some_property": "some property", ' \
               '"tags": "car,road vehicle"}, ' \
               '"type": "Feature"}'

        r = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]],
                        ['car', 'road vehicle'],
                        some_property='some property',
                        another_property=45)

        assert hasattr(r, 'some_property')
        assert hasattr(r, 'another_property')

        assert r.is_valid
        assert r.type == 'Polygon'

        assert geojson.dumps(r, sort_keys=True) == '{"geometry": {"coordinates": [[[0, 0], [0, 1], [1, 1], [0, 0]]], ' \
                                                   '"type": "Polygon"}, ' \
                                                   '"properties": {"another_property": 45, ' \
                                                   '"category": ["car", "road vehicle"], ' \
                                                   '"confidence": null, "some_property": "some property"}, ' \
                                                   '"type": "Feature"}'

        assert geojson.dumps(r.to_geojson(style='export-service'), sort_keys=True) \
            == '{"geometry": {"coordinates": [[[0, 0], [0, 1], [1, 1], [0, 0]]], ' \
               '"type": "Polygon"}, ' \
               '"properties": {"another_property": 45, ' \
               '"score": null, ' \
               '"some_property": "some property", ' \
               '"tags": "car,road vehicle"}, ' \
               '"type": "Feature"}'
def tree_b():
    b = Label('b')
    b_a = Label('b_a', parent=b)
    b_b = Label('b_b', parent=b)

    return b
def tree_a():
    a = Label("a")
    a_a = Label("a_a", parent=a)

    a_a_a = Label("a_a_a", parent=a_a)

    a_a_b = Label("a_a_b", parent=a_a)
    a_a_b_a = Label("a_a_b_a", parent=a_a_b)
    a_a_b_b = Label("a_a_b_b", parent=a_a_b)

    a_a_c = Label("a_a_c", parent=a_a)
    a_a_c_a = Label("a_a_c_a")
    a_a_c_b_a = Label("a_a_c_b_a")
    a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
    a_a_c_a_a = Label("a_a_c_a_a")
    a_a_c_a_b = Label("a_a_c_a_b")
    a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

    a_a_c.add(a_a_c_a, a_a_c_b)
    a_a_c_a_a.attach(a_a_c_a)
    a_a_c_a_b.attach(a_a_c_a)

    a_b = Label("a_b", parent=a)
    a_b_a = Label("a_b_a", parent=a_b)
    a_b_a_a = Label("a_b_a_a", parent=a_b_a)
    a_b_a_b = Label("a_b_a_b", parent=a_b_a)

    return a
    def test_last_common_ancestor(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)
        a_a_c_a = Label("a_a_c_a")
        a_a_c_b_a = Label("a_a_c_b_a")
        a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
        a_a_c_a_a = Label("a_a_c_a_a")
        a_a_c_a_b = Label("a_a_c_a_b")
        a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

        a_a_c.add(a_a_c_a, a_a_c_b)
        a_a_c_a_a.attach(a_a_c_a)
        a_a_c_a_b.attach(a_a_c_a)

        a_b = Label("a_b", parent=a)
        a_b_a = Label("a_b_a", parent=a_b)
        a_b_a_a = Label("a_b_a_a", parent=a_b_a)
        a_b_a_b = Label("a_b_a_b", parent=a_b_a)

        assert a_a_c_b.last_common_ancestor(a_a_c_a_b_a) == a_a_c
        assert a_a_c_a_b_a.last_common_ancestor(a_a_c_b) == a_a_c

        assert a_a_c_a_b_a.last_common_ancestor(a_a_b_a) == a_a
        assert a_a_b_a.last_common_ancestor(a_a_c_a_b_a) == a_a

        assert a_a.last_common_ancestor(a_a) == a_a

        for label_name in a_a.descendants:
            assert a_a.last_common_ancestor(a_a.descendants[label_name]) == a_a
    def test_clade(self):
        a = Label("a")
        a_a = Label("a_a", parent=a)

        a_a_a = Label("a_a_a", parent=a_a)

        a_a_b = Label("a_a_b", parent=a_a)
        a_a_b_a = Label("a_a_b_a", parent=a_a_b)
        a_a_b_b = Label("a_a_b_b", parent=a_a_b)

        a_a_c = Label("a_a_c", parent=a_a)
        a_a_c_a = Label("a_a_c_a")
        a_a_c_b_a = Label("a_a_c_b_a")
        a_a_c_b = Label("a_a_c_b", children=(a_a_c_b_a, ))
        a_a_c_a_a = Label("a_a_c_a_a")
        a_a_c_a_b = Label("a_a_c_a_b")
        a_a_c_a_b_a = Label("a_a_c_a_b_a", parent=a_a_c_a_b)

        a_a_c.add(a_a_c_a, a_a_c_b)
        a_a_c_a_a.attach(a_a_c_a)
        a_a_c_a_b.attach(a_a_c_a)

        a_b = Label("a_b", parent=a)
        a_b_a = Label("a_b_a", parent=a_b)
        a_b_a_a = Label("a_b_a_a", parent=a_b_a)
        a_b_a_b = Label("a_b_a_b", parent=a_b_a)

        assert a_a_c_b.clade(a_a_c_a_b_a) == Tree(a_a_c)
        assert a_a_c_a_b_a.clade(a_a_c_b) == Tree(a_a_c)

        assert a_a_c_a_b_a.clade(a_a_b_a) == Tree(a_a)
        assert a_a_b_a.clade(a_a_c_a_b_a) == Tree(a_a)

        assert a_a.clade(a_a) == Tree(a_a)

        for label_name in a_a.descendants:
            assert a_a.clade(a_a.descendants[label_name]) == Tree(a_a)
 def test_creation(self, tree_a, tree_b):
     taxo = Taxonomy(tree_a, tree_b)
     mixin_suite(taxo)  # Base validity tests
     assert taxo.root == Label('__root__')
     assert taxo.root.children == {tree_a, tree_b}
    def test_iteration(self, tree_a):
        tree = Tree(tree_a)

        assert tuple(tree.iterate()) == tuple(tree.iterate().top_down())
        assert tuple(tree.iterate()) == (Label('a'), Label('a_a'),
                                         Label('a_a_a'), Label('a_a_b'),
                                         Label('a_a_b_a'), Label('a_a_b_b'),
                                         Label('a_a_c'), Label('a_a_c_a'),
                                         Label('a_a_c_a_a'),
                                         Label('a_a_c_a_b'),
                                         Label('a_a_c_a_b_a'),
                                         Label('a_a_c_b'), Label('a_a_c_b_a'),
                                         Label('a_b'), Label('a_b_a'),
                                         Label('a_b_a_a'), Label('a_b_a_b'))

        assert tuple(
            tree.iterate().bottom_up()) == (Label('a'), Label('a_a'),
                                            Label('a_a_a'), Label('a_a_b'),
                                            Label('a_a_b_a'), Label('a_a_b_b'),
                                            Label('a_a_c'), Label('a_a_c_a'),
                                            Label('a_a_c_a_a'),
                                            Label('a_a_c_a_b'),
                                            Label('a_a_c_a_b_a'),
                                            Label('a_a_c_b'),
                                            Label('a_a_c_b_a'), Label('a_b'),
                                            Label('a_b_a'), Label('a_b_a_a'),
                                            Label('a_b_a_b'))[::-1]

        assert tuple(tuple(e)
                     for e in tree.iterate().depth_wise_top_down()) == (
                         (Label('a'), ), (Label('a_a'), Label('a_b')),
                         (Label('a_a_a'), Label('a_a_b'), Label('a_a_c'),
                          Label('a_b_a')), (Label('a_a_b_a'), Label('a_a_b_b'),
                                            Label('a_a_c_a'), Label('a_a_c_b'),
                                            Label('a_b_a_a'),
                                            Label('a_b_a_b')),
                         (Label('a_a_c_a_a'), Label('a_a_c_a_b'),
                          Label('a_a_c_b_a')), (Label('a_a_c_a_b_a'), ))

        assert tuple(tuple(e)
                     for e in tree.iterate().depth_wise_bottom_up()) == (
                         (Label('a'), ), (Label('a_a'), Label('a_b')),
                         (Label('a_a_a'), Label('a_a_b'), Label('a_a_c'),
                          Label('a_b_a')), (Label('a_a_b_a'), Label('a_a_b_b'),
                                            Label('a_a_c_a'), Label('a_a_c_b'),
                                            Label('a_b_a_a'),
                                            Label('a_b_a_b')),
                         (Label('a_a_c_a_a'), Label('a_a_c_a_b'),
                          Label('a_a_c_b_a')), (Label('a_a_c_a_b_a'), ))[::-1]

        assert tuple(tree.iterate(max_depth=3)) == tuple(
            tree.iterate(max_depth=3).top_down())
        assert tuple(
            tree.iterate(max_depth=3)) == (Label('a'), Label('a_a'),
                                           Label('a_a_a'), Label('a_a_b'),
                                           Label('a_a_b_a'), Label('a_a_b_b'),
                                           Label('a_a_c'), Label('a_a_c_a'),
                                           Label('a_a_c_b'), Label('a_b'),
                                           Label('a_b_a'), Label('a_b_a_a'),
                                           Label('a_b_a_b'))

        assert tuple(tree.iterate(
            max_depth=3).bottom_up()) == (Label('a'), Label('a_a'),
                                          Label('a_a_a'), Label('a_a_b'),
                                          Label('a_a_b_a'), Label('a_a_b_b'),
                                          Label('a_a_c'), Label('a_a_c_a'),
                                          Label('a_a_c_b'), Label('a_b'),
                                          Label('a_b_a'), Label('a_b_a_a'),
                                          Label('a_b_a_b'))[::-1]

        assert tuple(
            tuple(e) for e in tree.iterate(
                max_depth=3).depth_wise_top_down()) == ((Label('a'), ),
                                                        (Label('a_a'),
                                                         Label('a_b')),
                                                        (Label('a_a_a'),
                                                         Label('a_a_b'),
                                                         Label('a_a_c'),
                                                         Label('a_b_a')),
                                                        (Label('a_a_b_a'),
                                                         Label('a_a_b_b'),
                                                         Label('a_a_c_a'),
                                                         Label('a_a_c_b'),
                                                         Label('a_b_a_a'),
                                                         Label('a_b_a_b')))

        assert tuple(
            tuple(e)
            for e in tree.iterate(max_depth=3).depth_wise_bottom_up()) == (
                (Label('a'), ), (Label('a_a'), Label('a_b')),
                (Label('a_a_a'), Label('a_a_b'), Label('a_a_c'),
                 Label('a_b_a')), (Label('a_a_b_a'), Label('a_a_b_b'),
                                   Label('a_a_c_a'), Label('a_a_c_b'),
                                   Label('a_b_a_a'), Label('a_b_a_b')))[::-1]

        assert tuple(
            tree.iterate(max_depth=3).floor(4)) == (Label('a_a_c_a_a'),
                                                    Label('a_a_c_a_b'),
                                                    Label('a_a_c_b_a'))

        assert tuple(tree.iterate().floor(3)) == (Label('a_a_b_a'),
                                                  Label('a_a_b_b'),
                                                  Label('a_a_c_a'),
                                                  Label('a_a_c_b'),
                                                  Label('a_b_a_a'),
                                                  Label('a_b_a_b'))
    def test_validate(self, tree_a, tree_b):
        taxo = Taxonomy(tree_a, tree_b)

        with pytest.raises(ValueError,
                           match=r'Invalid label tuple: Empty tuple'):
            taxo.validate()

        with pytest.raises(ValueError, match=r'Expected at most \d+ labels'):
            taxo.validate(Label(''), Label(''), Label(''))

        with pytest.raises(
                ValueError,
                match=
                r'(?:{|set\(\[)Label\(name=label_a\)[}\])]+ are not part of the taxonomy'
        ):
            taxo.validate(Label('label_a'), Label('a_a'))

        with pytest.raises(
                ValueError,
                match=
                r'(?:{|set\(\[)Label\(name=label_a\)[}\])]+ are not part of the taxonomy'
        ):
            taxo.validate(Label('a_a'), Label('label_a'))

        with pytest.raises(
                ValueError,
                match=
                r'Some labels are part of the same true-root subtree: a_a_c'):
            taxo.validate(Label('a_a'), Label('a_a_c'))

        with pytest.raises(
                ValueError,
                match=
                r'Some labels are part of the same true-root subtree: a_a_c'):
            taxo.validate(Label('a_a_b_a'), Label('a_a_c'))

        taxo.validate(Label('a_a_b_a'), Label('b_b'))
        taxo.validate(Label('b_a'), Label('a_a_b'))
        taxo.validate(Label('b_a'))
        taxo.validate(Label('a_a_b_a'))

        # Verify that taxonomies validation is pickle compatible
        import pickle
        from pickle import loads, dumps
        taxo_pickle = loads(
            dumps(taxo,
                  protocol=max(2, getattr(pickle, 'DEFAULT_PROTOCOL', 0))))

        with pytest.raises(ValueError,
                           match=r'Invalid label tuple: Empty tuple'):
            taxo_pickle.validate()

        with pytest.raises(ValueError, match=r'Expected at most \d+ labels'):
            taxo_pickle.validate(Label(''), Label(''), Label(''))

        with pytest.raises(
                ValueError,
                match=
                r'(?:{|set\(\[)Label\(name=label_a\)[}\])]+ are not part of the taxonomy'
        ):
            taxo_pickle.validate(Label('label_a'), Label('a_a'))

        with pytest.raises(
                ValueError,
                match=
                r'(?:{|set\(\[)Label\(name=label_a\)[}\])]+ are not part of the taxonomy'
        ):
            taxo_pickle.validate(Label('a_a'), Label('label_a'))

        with pytest.raises(
                ValueError,
                match=
                r'Some labels are part of the same true-root subtree: a_a_c'):
            taxo_pickle.validate(Label('a_a'), Label('a_a_c'))

        with pytest.raises(
                ValueError,
                match=
                r'Some labels are part of the same true-root subtree: a_a_c'):
            taxo_pickle.validate(Label('a_a_b_a'), Label('a_a_c'))

        taxo_pickle.validate(Label('a_a_b_a'), Label('b_b'))
        taxo_pickle.validate(Label('b_a'), Label('a_a_b'))
        taxo_pickle.validate(Label('b_a'))
        taxo_pickle.validate(Label('a_a_b_a'))
Beispiel #24
0
    def test_record_collection_with_taxonomy_add(self):  # noqa: R701
        import geojson

        taxonomy = Taxonomy(Label('road vehicle'), Label('car'))
        invalid_taxonomy = Taxonomy(
            Label('road vehicle', children=(Label('car'), )), Label('other'))
        different_taxonomy = Taxonomy(Label('road vehicle'), Label('other'))
        incomplete_taxonomy = Taxonomy(Label('road vehicle'))

        r = data.Record([0, 1, 2], ['car', 'road vehicle'],
                        some_property='some property',
                        another_property=45)
        rc = data.RecordCollection(r)
        mixin_suite(rc)  # Base validity tests

        assert hasattr(rc, 'id')
        assert re.match(
            r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z',
            rc.id)

        with pytest.raises(ValueError, match='Expected at most'):
            rc.taxonomy = incomplete_taxonomy

        with pytest.raises(ValueError, match='are not part of the taxonomy'):
            rc.taxonomy = different_taxonomy

        with pytest.raises(
                ValueError,
                match='Some labels are part of the same true-root subtree'):
            rc.taxonomy = invalid_taxonomy

        rc.taxonomy = taxonomy

        assert len(rc) == 1
        assert rc[0] == r
        r2 = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]], ['car', 'truck'],
                         some_property='some property',
                         another_property=45)

        with pytest.raises(ValueError, match='are not part of the taxonomy'):
            rc.append(r2)

        rc.taxonomy = Taxonomy(
            Label('road vehicle', children=(Label('truck'), )), Label('car'))
        rc.append(r2)

        assert rc.get()[0].labels == (Label('car'), Label('road vehicle'))
        assert rc.get()[1].labels == (Label('car'), Label('truck'))
        assert tuple(label.labels
                     for label in rc.get()[0:]) == (rc.get()[0].labels,
                                                    rc.get()[1].labels)

        assert rc.get(max_depth=1)[0].labels == (Label('car'),
                                                 Label('road vehicle'))
        assert rc.get(max_depth=1)[1].labels == (Label('car'),
                                                 Label('road vehicle'))
        assert tuple(label.labels
                     for label in rc.get(max_depth=1)[0:]) == (rc.get(
                         max_depth=1)[0].labels, rc.get(max_depth=1)[1].labels)

        assert rc.get(
            max_depth={'road vehicle': 0})[0].labels == (Label('car'),
                                                         Label('road vehicle'))
        assert rc.get(
            max_depth={'road vehicle': 0})[1].labels == (Label('car'),
                                                         Label('road vehicle'))
        assert tuple(label.labels for label in rc.get(max_depth={'road vehicle': 0})[0:]) \
            == (rc.get(max_depth={'road vehicle': 0})[0].labels,
                rc.get(max_depth={'road vehicle': 0})[1].labels)

        assert rc.get(
            max_depth={'car': 0})[0].labels == (Label('car'),
                                                Label('road vehicle'))
        assert rc.get(max_depth={'car': 0})[1].labels == (Label('car'),
                                                          Label('truck'))
        assert tuple(label.labels for label in rc.get(max_depth={'car': 0})[0:]) \
            == (rc.get(max_depth={'car': 0})[0].labels,
                rc.get(max_depth={'car': 0})[1].labels)

        assert len(rc) == 2
        assert rc[1] == r2

        assert geojson.dumps(rc, sort_keys=True) == '{"features": [' \
                                                    '{"geometry": {"coordinates": [0, 1, 2], "type": "Point"}, ' \
                                                    '"properties": {"another_property": 45, ' \
                                                    '"category": ["car", "road vehicle"], ' \
                                                    '"confidence": null, "some_property": "some property"}, ' \
                                                    '"type": "Feature"}, ' \
                                                    '{"geometry": {"coordinates": [[[0, 0], [0, 1], [1, 1], [0, 0]]], '\
                                                    '"type": "Polygon"}, ' \
                                                    '"properties": {"another_property": 45, ' \
                                                    '"category": ["car", "truck"], ' \
                                                    '"confidence": null, ' \
                                                    '"some_property": "some property"}, "type": "Feature"}], ' \
                                                    '"type": "FeatureCollection"}'

        with pytest.raises(ValueError, match='are not part of'):
            rc[1] = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]],
                                ['car', 'trucks'],
                                some_property='some property',
                                another_property=45)

        with pytest.raises(
                ValueError,
                match='Some labels are part of the same true-root subtree'):
            rc[1] = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]],
                                ['road vehicle', 'truck'],
                                some_property='some property',
                                another_property=45)

        rc[1] = data.Record([[[0, 0], [0, 1], [1, 1], [0, 0]]], ['car'],
                            some_property='some property',
                            another_property=45)
        assert rc[1].labels == (Label('car'), )