def test_can_recycle_for_0row_df():
# test_that("can recyle for zero-row data frame (#167)", {
df = tibble(a=[1.0, 2, 3]).iloc[[], :]
df_new = add_column(df, b=4.0, c=[])
assert_frame_equal(
df_new,
tibble(a=[], b=[], c=[], _dtypes={
'a': float,
'b': float,
'c': object
}))
def test_add_row_works_when_add_0row_input():
# test_that("add_row() works when adding zero row input (#809)", {
x = tibble(x=1, y=2)
y = tibble(y=[])
out = add_row(x, x=[])
assert_frame_equal(out, x)
out = add_row(x, y)
assert_frame_equal(out, x)
out = add_row(x, NULL)
assert_frame_equal(out, x)
out = add_row(x, None)
assert_frame_equal(out, x)
def test_can_safely_add_to_factor_columns_everywhere():
# test_that("can safely add to factor columns everywhere (#296)", {
df = tibble(a=factor(letters[:3]))
out = add_row(df)
exp = tibble(a=factor(c(letters[:3], NA)))
assert_frame_equal(out, exp)
out = add_row(df, _before=0)
exp = tibble(a=factor(c(NA, letters[:3])))
assert_frame_equal(out, exp)
out = add_row(df, _before=1)
exp = tibble(a=factor(c("a", NA, letters[1:3])))
assert_frame_equal(out, exp)
out = add_row(df, a="d")
exp = tibble(a=letters[:4], _dtypes=object)
assert_frame_equal(out, exp)
out = add_row(df, a="d", _before=0)
exp = tibble(a=c("d", letters[:3]), _dtypes=object)
assert_frame_equal(out, exp)
out = add_row(df, a="d", _before=1)
exp = tibble(a=list("adbc"), _dtypes=object)
assert_frame_equal(out, exp)
def test_errors_of_add_row_and_add_column():
with pytest.raises(ValueError):
add_row(tibble(), a=1)
with pytest.raises(ValueError):
add_row(tibble(), a=1, b=2)
with pytest.raises(ValueError):
add_row(tibble(), **dict(zip(letters, letters)))
with pytest.raises(ValueError):
add_row(group_by(tibble(a=1), f.a))
with pytest.raises(ValueError):
add_row(tibble(a=1), a=2, _before=0, _after=0)
with pytest.raises(NameNonUniqueError):
add_column(tibble(a=1), a=1)
with pytest.raises(NameNonUniqueError):
add_column(tibble(a=1, b=2), a=1, b=2)
with pytest.raises(NameNonUniqueError):
add_column(tibble(**dict(zip(letters, letters))), a=1)
with pytest.raises(ValueError):
add_column(tibble(a=[2, 3]), b=[4, 5, 6])
with pytest.raises(ValueError):
add_column(tibble(a=1), b=1, _before=0, _after=0)
def test_can_add_as_first_row_via_after_0():
df = tibble(a=3)
df_new = add_row(df, a=2, _after=-1)
assert df_new.equals(tibble(a=[2, 3]))
def test_can_deframe_1col_data_frame():
out = deframe(tibble(value=seq(3, 1)))
assert out.tolist() == [3, 2, 1]
def test_add_column_for_rowwise_df():
df = tibble(x=[1, 2, 3]) >> group_by(f.x)
df2 = add_column(df, y=[3, 2, 1])
assert isinstance(df2, TibbleGrouped)
assert group_vars(df2) == ["x"]
def test_can_enframe_without_names():
df = enframe(letters, name=None, value="letter")
assert df.equals(tibble(letter=letters))
def test_error_if_both_before_after_are_given():
df = tibble(a=[1, 2, 3])
with pytest.raises(ValueError):
add_column(df, b=[4, 5, 6], _after=1, _before=2)
def test_can_add_column_inbetween():
df = tibble(a=[1, 2, 3], c=[4, 5, 6])
df_new = add_column(df, b=seq(-1, 1), _after=0)
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=seq(-1, 1), c=[4, 5, 6]))
def test_add_column_can_add_to_empty_tibble_or_df():
out = add_column(tibble(_rows=3), a=seq(1, 3))
assert_frame_equal(out, tibble(a=seq(1, 3)))
def test_add_column_works_with_0col_tibbles():
# test_that("add_column() works with 0-col tibbles (#786)", {
out = add_column(tibble(_rows=1), a=1)
assert_frame_equal(out, tibble(a=1))
def test_can_convert_list():
df = enframe(seq(3, 1))
assert df.equals(tibble(name=seq(0, 2), value=seq(3, 1)))
# scalar
df = enframe(1)
assert df.equals(tibble(name=0, value=1))
def test_error_if_both_before_and_after_are_given():
df = tibble(a=seq(1, 3))
with pytest.raises(ValueError):
add_row(df, a=[4, 5], _after=1, _before=2)
def test_can_add_row_inbetween():
df = tibble(a=[1, 2, 3])
df_new = add_row(df, a=[4, 5], _after=1)
assert df_new.equals(tibble(a=[1, 2, 4, 5, 3]))
def test_error_if_add_existing_columns():
with pytest.raises(NameNonUniqueError):
add_column(tibble(a=3), a=5)
def test_can_add_as_first_column_via_after_0():
df = tibble(a=3)
df_new = add_column(df, b=2, _after=-1)
assert_frame_equal(df_new, tibble(b=2, a=3))
def test_can_convert_dict():
df = enframe(dict(a=2, b=1))
assert df.equals(tibble(name=["a", "b"], value=[2, 1]))
df = enframe(dict(a=2, b=1), name=None)
assert df.equals(tibble(value=[2, 1]))
def test_can_add_column_relative_to_named_column():
df = tibble(a=seq(1, 3), c=seq(4, 6))
df_new = add_column(df, b=seq(-1, 1), _before=f.c)
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=seq(-1, 1), c=[4, 5, 6]))
def test_error_if_adding_wrong_number_of_rows_with_add_column():
with pytest.raises(ValueError, match="incompatible"):
add_column(tibble(a=3), b=[4, 5])
def test_error_if_column_named_by_before_or_after_not_found():
df = tibble(a=[1, 2, 3])
with pytest.raises(KeyError):
add_column(df, b=[4, 5, 6], _after="x")
with pytest.raises(KeyError):
add_column(df, b=[4, 5, 6], _before="x")
def test_can_add_multiple_columns():
df = tibble(a=[1, 2, 3])
df_new = add_column(df, b=[4, 5, 6], c=[3, 2, 1])
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=[4, 5, 6], c=[3, 2, 1]))
def test_can_use_custom_names():
df = enframe(letters, name="index", value="letter")
assert df.equals(tibble(index=seq_along(letters) - 1, letter=letters))
def test_can_recycle_when_adding_columns():
df = tibble(a=[1, 2, 3])
df_new = add_column(df, b=4, c=[3, 2, 1])
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=rep(4, 3), c=[3, 2, 1]))
def test_add_row_for_rowwise_df():
df = tibble(x=[1, 2, 3]) >> rowwise()
df2 = add_row(df, x=4)
assert isinstance(df2, TibbleRowwise)
assert_iterable_equal(df2.x.obj, [1, 2, 3, 4])
def test_can_recycle_when_adding_a_column_of_len1():
df = tibble(a=[1, 2, 3])
df_new = add_column(df, b=4)
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=rep(4, 3)))
def test_can_deframe_2col_data_frame():
out = deframe(tibble(name=letters[:3], value=seq(3, 1)))
assert out == {"a": 3, "b": 2, "c": 1}
def test_can_recycle_when_add_multiple_columns_of_len1():
df = tibble(a=[1, 2, 3])
df_new = add_column(df, b=4, c=5)
assert_frame_equal(df_new, tibble(a=[1, 2, 3], b=rep(4, 3), c=rep(5, 3)))
def test_can_deframe_3col_df_with_warning(caplog):
out = deframe(tibble(name=letters[:3], value=seq(3, 1), oops=[1, 2, 3]))
assert out == {"a": 3, "b": 2, "c": 1}
assert "one- or two-column" in caplog.text
def test_can_add_as_first_row_via_before_1():
df = tibble(a=3)
df_new = add_row(df, a=2, _before=0)
assert df_new.equals(tibble(a=[2, 3]))
