예제 #1
0
def test_select_one_from_empty_rel_should_return_empty_if_not_keep_missing():
    empty_relationship = Relationship(seed=1)

    selected = empty_relationship.select_one(from_ids=["non_existing"],
                                             discard_empty=True)
    assert selected.shape == (0, 2)
    assert selected.columns.tolist() == ["from", "to"]
예제 #2
0
def test_select_one_from_all_ids_should_return_one_line_per_id():
    tested = Relationship(seed=1)
    tested.add_relations(from_ids=["a", "b", "b", "c"],
                         to_ids=["b", "c", "a", "b"])

    selected = tested.select_one()

    assert set(selected["from"].unique()) == {"a", "b", "c"}
예제 #3
0
def test_select_one_from_empty_rel_should_return_none_if_keep_missing():
    empty_relationship = Relationship(seed=1)

    selected = empty_relationship.select_one(from_ids=["non_existing"],
                                             discard_empty=False)
    assert selected.shape == (1, 2)
    assert selected.columns.tolist() == ["from", "to"]
    assert selected.iloc[0]["from"] == "non_existing"
    assert selected.iloc[0]["to"] is None
예제 #4
0
def test_select_one_nonexistingids_should_return_empty_if_not_keep_missing():
    tested = Relationship(seed=1)
    tested.add_relations(from_ids=["a", "b", "b", "c"],
                         to_ids=["b", "c", "a", "b"])

    result = tested.select_one(["non_existing_id", "neither"],
                               discard_empty=True)

    assert result.shape[0] == 0
    assert result.columns.tolist() == ["from", "to"]
예제 #5
0
def test_pop_one_relationship_should_remove_element():
    # we're removing relations from this one => working on a copy not to
    # influence other tests
    oneto1_copy = Relationship(seed=1)
    oneto1_copy.add_relations(from_ids=["a", "b", "c", "d", "e"],
                              to_ids=["ta", "tb", "tc", "td", "te"])

    selected = oneto1_copy.select_one(from_ids=["a", "d"],
                                      remove_selected=True)

    # unique "to" value should have been taken
    assert selected.sort_values("from")["to"].tolist() == ["ta", "td"]
    assert selected.columns.tolist() == ["from", "to"]

    # and removed form the relationship
    assert set(oneto1_copy.grouped.keys()) == {"b", "c", "e"}

    # selecting the same again should just return nothing
    selected = oneto1_copy.select_one(from_ids=["a", "d"],
                                      remove_selected=True)

    assert selected.shape[0] == 0
    assert selected.columns.tolist() == ["from", "to"]

    # and have no impact on the relationship
    assert set(oneto1_copy.grouped.keys()) == {"b", "c", "e"}

    # selecting the same again without discarding empty relationship should
    # now return a size 2 dataframe with Nones
    selected = oneto1_copy.select_one(from_ids=["a", "d"],
                                      remove_selected=True,
                                      discard_empty=False)
    assert selected.shape[0] == 2
    assert sorted(selected.columns.tolist()) == ["from", "to"]
    assert selected["to"].tolist() == [None, None]
    assert sorted(selected["from"].tolist()) == ["a", "d"]
예제 #6
0
def test_weighted_relationship_should_take_weights_into_account():

    # a,b and c are all connected to x,y and z, but the weight is 0
    # everywhere except to y
    one_to_three_weighted = Relationship(seed=1234)
    one_to_three_weighted.add_relations(from_ids=["a"] * 3 + ["b"] * 3 +
                                        ["c"] * 3,
                                        to_ids=["x", "y", "z"] * 3,
                                        weights=[0, 1, 0] * 3)

    selected = one_to_three_weighted.select_one()

    # => with those weights, only x should should be selected
    assert selected["to"].tolist() == ["y", "y", "y"]
    assert sorted(selected["from"].tolist()) == ["a", "b", "c"]
예제 #7
0
def test_weighted_relationship_should_take_overridden_weights_into_account():

    # a,b and c are all connected to x,y and z, but the weight is 0
    # everywhere except to y
    one_to_three_weighted = Relationship(seed=1234)
    one_to_three_weighted.add_relations(from_ids=["a"] * 3 + ["b"] * 3 +
                                        ["c"] * 3,
                                        to_ids=["x", "y", "z"] * 3,
                                        weights=[0, 1, 0] * 3)

    # if we override the weight, we can only specify one value per "to" value
    overridden_to_weights = pd.Series(data=[0, 0, 1], index=["x", "y", "z"])
    selected = one_to_three_weighted.select_one(
        overridden_to_weights=overridden_to_weights)

    # the initial weights should have been discarded and the one provided as
    # input should have been joined and used as expected
    assert selected["to"].tolist() == ["z", "z", "z"]
    assert sorted(selected["from"].tolist()) == ["a", "b", "c"]
예제 #8
0
def test_select_one_nonexistingids_should_insert_none_if_keep_missing():
    tested = Relationship(seed=1)
    tested.add_relations(from_ids=["a", "b", "b", "c"],
                         to_ids=["a1", "b1", "b2", "c1"])

    result = tested.select_one(["c", "b_non_existing_id", "a", "neither", "a"],
                               discard_empty=False)

    assert result.shape[0] == 5
    assert result.columns.tolist() == ["from", "to"]

    result_s = result.sort_values("from")

    assert result_s["from"].tolist() == [
        "a", "a", "b_non_existing_id", "c", "neither"
    ]

    assert result_s["to"].tolist() == [
        "a1",
        "a1",
        None,
        "c1",
        None,
    ]
예제 #9
0
def test_seeded_relationship_should_always_return_same_selection():

    from_ids = ["a", "a", "a", "b", "b", "b", "c", "c", "c"]
    to_ids = ["af1", "af2", "af3", "bf1", "bf2", "bf3", "cf1", "cf2", "cf3"]

    # two relationship seeded identically
    tested1 = Relationship(seed=1345)
    tested2 = Relationship(seed=1345)

    tested1.add_relations(from_ids=from_ids, to_ids=to_ids)
    tested2.add_relations(from_ids=from_ids, to_ids=to_ids)

    assert tested1.select_one(from_ids=["a"]).equals(
        tested2.select_one(from_ids=["a"]))

    assert tested1.select_one(from_ids=["b"]).equals(
        tested2.select_one(from_ids=["b"]))

    assert tested1.select_one(from_ids=["a", "b", "d"]).equals(
        tested2.select_one(from_ids=["a", "b", "d"]))
예제 #10
0
def test_select_one_from_empty_relationship_should_return_void():
    tested = Relationship(seed=1)
    result = tested.select_one(pd.Series([]))
    assert result.shape[0] == 0
    assert result.columns.tolist() == ["from", "to"]