def test_pack():
df = pd.DataFrame()
df["A"] = [1, 2]
w = Wrap(df)
w = w.extend("B = pack('a', A)")
w = w.extend("C = B['a']")
assert 1 == w.df["B"][0]["a"]
assert 2 == w.df["B"][1]["a"]
assert [1, 2] == list(w.df["C"])
def test_log2():
df = create_df()
w = Wrap(df)
c = w.extend("F = log2(A)")
assert list(np.log2([0, 1, 2, 3, 4])) == list(c.df["F"])
def test_sqrt():
df = create_df()
w = Wrap(df)
c = w.extend("F = sqrt(A)")
assert list(np.sqrt([0, 1, 2, 3, 4])) == list(c.df["F"])
def test_exp10():
df = create_df()
w = Wrap(df)
c = w.extend("F = exp10(A)")
assert list(np.power(10, [0, 1, 2, 3, 4])) == list(c.df["F"])
def test_not():
df = pd.DataFrame()
df["A"] = [True, False, False]
w = Wrap(df)
wnew = w.extend("B = not(A)")
assert ["A", "B"] == list(wnew.df.columns)
assert [False, True, True] == list(wnew.df["B"])
def test_toint_str(self):
df = create_df()
w = Wrap(df)
w = w.extend("D = toint('5')")
self.assertListEqual([5]*5, list(w.df["D"]))
def test_extend_noname(self):
df = create_df()
df = df[["B"]]
w = Wrap(df)
wnew = w.extend("B*2, B+1")
assert ["B", "Column1", "Column2"] == list(wnew.df.columns)
def test_dynamic_bag_squarebrackets():
df = pd.DataFrame()
df["A"] = ['{ "k": "v0", "k2": { "k3": 3 } }', '{ "k": "v", "k2": { "k3": 13 } }']
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d['k'], f1 = d['k2']['k3']")
assert ["v0", "v"] == list(w.df["f"])
assert [3, 13] == list(w.df["f1"])
def test_parse_json():
df = pd.DataFrame()
df["A"] = ["[1, 2]", '{ "a" : 7 }', '{ "b" : "val" }']
w = Wrap(df)
w = w.extend("d = todynamic(A), p = parse_json(A)")
assert list(w.df["d"]) == list(w.df["p"])
def test_dynamic_dot():
df = pd.DataFrame()
df["A"] = ['{ "k": "v0", "k2": { "k3": 3 } }', '{ "k": "v", "k2": { "k3": 13 } }', "[1, 2]"]
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d.k, f1 = d.k2.k3")
assert ["v0", "v", None] == list(w.df["f"])
assert [3, 13, None] == replace_nan(w.df["f1"], None)
def test_isnotempty(self):
df = create_df()
df["A"] = [1, "hi", None, np.nan, ""]
w = Wrap(df)
w = w.extend("D = isnotempty(A)")
self.assertListEqual([True, True, False, False, False], list(w.df["D"]))
def test_base64_encode_tostring_series():
df = pd.DataFrame()
df["A"] = ["hello", "There "]
w = Wrap(df)
w = w.extend("B = base64_encode_tostring(A)")
assert [_encode_base64("hello"), _encode_base64("There ")] == list(w.df["B"])
def test_todynamic(self):
df = pd.DataFrame()
df["A"] = ['{"k1":"v1"}', '{"k1" : "v2"}']
w = Wrap(df)
w = w.extend("D = todynamic(A)")
self.assertEqual("v1", w.df["D"][0]["k1"])
def test_extend(self):
df = create_df()
w = Wrap(df)
w = w.extend("z =B*2")
z = w.df["z"]
expected = [0, 2, 4, 6, 8]
self.assertListEqual(expected, list(z))
def test_tostring(self):
df = create_df()
df["A"] = [1, "HI", np.nan, "", None]
w = Wrap(df)
w = w.extend("D = tostring(A)")
assert ["1", "HI", "", "", ""] == list(w.df["D"])
def test_isinf():
df = create_df()
df["D"] = [1.0, -np.inf, np.inf, None, np.nan]
w = Wrap(df)
c = w.extend("F = isinf(D)")
assert list([False, True, True, False, False]) == list(c.df["F"])
def test_toupper(self):
df = create_df()
df["A"] = ["hi", "HI", " Hi", "", None]
w = Wrap(df)
w = w.extend("D = toupper(A)")
self.assertListEqual(["HI", "HI", " HI", "", None], list(w.df["D"]))
def test_dynamic_array_index_negative():
df = pd.DataFrame()
df["A"] = ["[1, 2]", "[3, 4]"]
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d[-2], f1 = d[-1]")
assert [1, 3] == list(w.df["f"])
assert [2, 4] == list(w.df["f1"])
def test_dynamic_squarebrackets_does_not_throw():
df = pd.DataFrame()
df["A"] = ['{ "k": "v0", "k2": { "k3": 3 } }', '{ "k": "v", "k2": { "k3": 13 } }', "[1, 2]"]
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d['k'], f1 = d['k2']['k3'], f2=d[0]")
assert ["v0", "v", None] == list(w.df["f"])
assert [3, 13, None] == replace_nan(w.df["f1"], None)
assert [None, None, 1] == replace_nan(w.df["f2"], None)
def test_ceiling():
df = create_df()
df["D"] = [1.0, 1.1, 2.2, 3.0, 4.4]
w = Wrap(df)
c = w.extend("F = ceiling(D)")
expected = [1, 2, 3, 3, 5]
assert list(expected) == list(c.df["F"])
def test_toint(self):
df = create_df()
df["A"] = [1.2, "1", 2.0, 4, 5]
w = Wrap(df)
w = w.extend("D = toint(A), D2 = tolong(A)")
self.assertListEqual([1, 1, 2, 4, 5], list(w.df["D"]))
self.assertListEqual([1, 1, 2, 4, 5], list(w.df["D2"]))
def test_totimespan():
df = pd.DataFrame()
df["A"] = ["1m", "1d"]
w = Wrap(df)
w = w.extend("B = totimespan(A), C = totimespan('1d'), D = totimespan(1d)")
assert [pd.to_timedelta("1m"), pd.to_timedelta("1d")] == list(w.df["B"])
assert [pd.to_timedelta("1d")]*2 == list(w.df["C"])
assert [pd.to_timedelta("1d")]*2 == list(w.df["D"])
def test_todynamic():
df = pd.DataFrame()
df["A"] = ["[1, 2]", '{ "a" : 7 }', '{ "b" : "val" }']
w = Wrap(df)
w = w.extend("d = todynamic(A)")
assert [1, 2] == list(w.df["d"][0])
assert 7 == w.df["d"][1]["a"]
assert "val" == w.df["d"][2]["b"]
def test_dynamic_squarebrackets_variable_index():
df = pd.DataFrame()
df["A"] = ['{ "k": "v0", "k2": { "k3": 3 } }', '{ "k4": "v", "k2": { "k3": 13 } }', "[1, 2]"]
df["B"] = ["k", "k4", 0]
df["C"] = ["0", "0", "1"]
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d[B], f1 = d[toint(C)]")
assert ["v0", "v", 1] == list(w.df["f"])
assert [None, None, 2] == replace_nan(w.df["f1"], None)
def test_floor_number():
df = create_df()
df["D"] = [1.0, 1.1, 2.2, 3.0, 4.4]
w = Wrap(df)
c = w.extend("F = floor(D, 1)")
expected = [1.0, 1.0, 2.0, 3.0, 4.0]
assert list(expected) == list(c.df["F"])
def test_floor():
df = create_df()
df["D"] = pd.to_datetime(["2009-01-01T10", "2009-01-02", "2009-01-05T01", "2009-01-06", "2009-01-07T03"])
w = Wrap(df)
c = w.extend("F = floor(D, 1d)")
expected = pd.to_datetime(["2009-01-01", "2009-01-02", "2009-01-05", "2009-01-06", "2009-01-07"])
assert list(expected) == list(c.df["F"])
def test_todouble(self):
df = create_df()
df["A"] = [1.2, "1", "2.7", 4, 5]
w = Wrap(df)
w = w.extend("D = todouble(A), D1 = toreal(A), D4 = todouble('1.3')")
expected = [float(x) for x in df["A"]]
self.assertListEqual(expected, list(w.df["D"]))
self.assertListEqual(expected, list(w.df["D1"]))
self.assertListEqual([1.3]*5, list(w.df["D4"]))
def test_let_new_method_overrides_old_one():
df = pd.DataFrame()
df["A"] = [1, 2]
w = Wrap(df)
w = w.let(b=1)
w = w.let(b=2)
wnew = w.extend("B = A + b")
assert ["A", "B"] == list(wnew.df.columns)
assert [3, 4] == list(wnew.df["B"])
def test_strlen():
df = create_df()
df["A"] = ["hi", "", None, " ", "hi "]
w = Wrap(df)
c = w.extend("F = strlen(A)")
# comparing is annoying because np.nan == np.nan evaluates to false
result = np.where(np.isnan(c.df["F"]), -1, c.df["F"])
assert list([2.0, 0.0, -1, 1.0, 3.0]) == list(result)
def test_dynamic_squarebrackets_index_arithmatic():
df = pd.DataFrame()
df["A"] = ["[1, 2, 3]", "[4, 5, 6]"]
df["B"] = [0, 0]
w = Wrap(df)
w = w.extend("d = todynamic(A)").extend("f = d[B], f1 = d[B+1], f2 = d[B-1], f3 = d[(B-1)], f4 = d[(-1)]")
assert [1, 4] == list(w.df["f"])
assert [2, 5] == list(w.df["f1"])
assert [3, 6] == list(w.df["f2"])
assert [3, 6] == list(w.df["f3"])
assert [3, 6] == list(w.df["f4"])
