def test_iter(foo_extractor):
rs = FeatureSet(
features_names=["foo"],
values={"foo": 1},
timeserie=TIME_SERIE,
extractors={"foo": foo_extractor},
)
feats, values = rs
assert list(feats) == unordered(["foo"])
assert list(values) == unordered([1])
def test_all_required_data():
class A(Extractor):
data = ["magnitude", "time"]
features = ["test_a"]
def fit(self, *args):
pass
assert A.get_optional() == unordered([])
assert A.get_data() == unordered(["magnitude", "time"])
assert A.get_required_data() == unordered(["time", "magnitude"])
def test_should_copy_keys_values_pairs_capacity(hash_table):
copy = hash_table.copy()
assert copy is not hash_table
assert set(hash_table.keys) == set(copy.keys)
assert set(hash_table.pairs) == set(copy.pairs)
assert unordered(hash_table.values) == copy.values
assert hash_table.capacity == copy.capacity
def test_appdirs_config(tmp_chdir, monkeypatch, obj, slug, author, version, files, layers):
import appdirs
class AppDirs:
def __init__(self, slug, author, version):
self.slug = slug
self.author = author
self.version = version
self.user_config_dir = 'user'
self.site_config_dir = 'site'
monkeypatch.setattr(appdirs, 'AppDirs', AppDirs)
for name, content in files.items():
path = tmp_chdir / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content)
assert obj.dirs.slug == slug
assert obj.dirs.author == author
assert obj.dirs.version == version
assert list(obj.config_paths) == unordered([Path(x) for x in files.keys()])
byoc.init(obj)
assert collect_layers(obj)[0] == layers
def test_remove_by_dependencies(mock_extractors_register):
@register_extractor
class A(Extractor):
data = ["magnitude"]
features = ["test_a", "test_a2"]
def fit(self, *args):
pass
@register_extractor
class B1(Extractor):
data = ["magnitude"]
features = ["test_b1"]
dependencies = ["test_a"]
def fit(self, *args):
pass
@register_extractor
class C(Extractor):
data = ["magnitude"]
features = ["test_c"]
def fit(self, *args):
pass
fs = FeatureSpace(exclude=["test_a"])
assert list(fs.features_) == unordered(["test_c", "test_a2"])
def test_should_create_hashtable_from_dict_with_custom_capacity():
dictionary = {"hola": "hello", 98.6: 37, False: True}
hash_table = HashTable.from_dict(dictionary, capacity=100)
assert hash_table.capacity == 100
assert hash_table.keys == set(dictionary.keys())
assert hash_table.pairs == set(dictionary.items())
assert unordered(hash_table.values) == list(dictionary.values())
def test_should_convert_to_dict(hash_table):
dictionary = dict(hash_table.pairs)
assert set(dictionary.keys()) == hash_table.keys
assert set(dictionary.items()) == hash_table.pairs
assert list(dictionary.values()) == unordered(hash_table.values)
def test_should_get_values(hash_table):
assert unordered(hash_table.values) == ["hello", 37, True]
def test_non_iterable_actual(value):
assert not (unordered(1, 2, 3) == value)
assert not (value == unordered(1, 2, 3))
def test_len():
assert len(unordered({1: ["a", "b"]}, 2, 3, 4, 5)) == 5
def test_check_type():
assert not unordered([1]) == {1}
assert not unordered([1], check_type=True) == {1}
assert unordered([1], check_type=False) == {1}
def test_compare_to_non_sequence(value):
assert not unordered("x") == value
assert unordered("x") != value
def test_mapping_expected(value):
with raises(TypeError,
match="cannot make unordered comparisons to mapping"):
unordered(value)
import collections
import pytest
from pytest import raises
from pytest_unordered import UnorderedList
from pytest_unordered import _compare_eq_unordered
from pytest_unordered import unordered
@pytest.mark.parametrize(
["expected", "actual"],
[
(unordered(1, 2, 3), [3, 2, 1]),
(unordered(1, 2, 3), (3, 2, 1)),
(unordered(1, 2, 3), {3, 2, 1}),
(unordered([1, 2, 3]), [3, 2, 1]),
(unordered((1, 2, 3)), (3, 2, 1)),
(unordered({1, 2, 3}), {3, 2, 1}),
(unordered(1, 2, {"a": unordered(4, 5, 6)}), [{
"a": [6, 5, 4]
}, 2, 1]),
(unordered([{
1: unordered(['a', 'b'])
}, 2, 3]), [3, 2, {
1: ['b', 'a']
}]),
(unordered(x for x in range(3)), [2, 1, 0]),
(unordered(x for x in range(3)), (2, 1, 0)),
(unordered(x for x in range(3)), {2, 1, 0}),
(unordered(x for x in range(3)), range(3)),
