lf-pollywog 0.1.1__py3-none-any.whl

tests/test_core.py

@@ -0,0 +1,274 @@
+def test_query_with_external_variable():
+    from pollywog.core import CalcSet, Variable, Number
+
+    a = Variable(name="a", children=["foo"])
+    b = Number(name="b1", children=["[a] + 1"])
+    c = Number(name="b2", children=["[b1] + 2"])
+    cs = CalcSet([a, b, c])
+    prefix = "b"
+    # Should select items whose name starts with prefix
+    result = cs.query("name.startswith(@prefix)")
+    names = [item.name for item in result.items]
+    assert set(names) == {"b1", "b2"}
+
+
+def test_query_with_multiple_external_vars():
+    from pollywog.core import CalcSet, Variable, Number
+
+    a = Variable(name="a", children=["foo"])
+    b = Number(name="b1", children=["[a] + 1"])
+    c = Number(name="b2", children=["[b1] + 2"])
+    cs = CalcSet([a, b, c])
+    prefix = "b"
+    suffix = "2"
+    # Should select items whose name starts with prefix and ends with suffix
+    result = cs.query("name.startswith(@prefix) and name.endswith(@suffix)")
+    names = [item.name for item in result.items]
+    assert names == ["b2"]
+
+
+def test_topological_sort_simple():
+    from pollywog.core import Number, Variable, CalcSet
+
+    a = Variable(name="a", children=["foo"])
+    b = Number(name="b", children=["[a] + 1"])
+    c = Number(name="c", children=["[b] + 2"])
+    cs = CalcSet([c, b, a])
+    sorted_cs = cs.topological_sort()
+    names = [item.name for item in sorted_cs.items]
+    assert names == ["a", "b", "c"]
+
+
+def test_topological_sort_external_dep():
+    from pollywog.core import Number, Variable, CalcSet
+
+    a = Variable(name="a", children=["foo"])
+    b = Number(name="b", children=["[external] + 1"])
+    cs = CalcSet([b, a])
+    sorted_cs = cs.topological_sort()
+    names = [item.name for item in sorted_cs.items]
+    assert set(names) == {"a", "b"}
+
+
+def test_topological_sort_cycle():
+    from pollywog.core import Number, CalcSet
+
+    a = Number(name="a", children=["[b] + 1"])
+    b = Number(name="b", children=["[a] + 2"])
+    cs = CalcSet([a, b])
+    import pytest
+
+    with pytest.raises(ValueError):
+        cs.topological_sort()
+
+
+def test_item_rename():
+    num = Number(name="n1", children=["[x] + 1"])
+    # Rename item name only
+    num2 = num.rename(name="n2")
+    assert num2.name == "n2"
+    assert num2.children == ["[x] + 1"]
+    # Rename variable inside children
+    num3 = num.rename(variables={"x": "y"})
+    assert num3.children == ["[y] + 1"]
+    # Rename both name and variable
+    num4 = num.rename(name="n3", variables={"x": "z"})
+    assert num4.name == "n3"
+    assert num4.children == ["[z] + 1"]
+
+
+def test_calcset_rename_items_and_variables():
+    num = Number(name="n1", children=["[x] + 1"])
+    var = Variable(name="x", children=["foo"])
+    filt = Filter(name="f1", children=["[x] > 0"])
+    cs = CalcSet([num, var, filt])
+    # Rename item names
+    cs2 = cs.rename(items={"n1": "n2", "f1": "f2"})
+    assert cs2.items[0].name == "n2"
+    assert cs2.items[2].name == "f2"
+    # Rename variable references in children
+    cs3 = cs.rename(variables={"x": "y"})
+    assert cs3.items[0].children == ["[y] + 1"]
+    assert cs3.items[2].children == ["[y] > 0"]
+    # Rename both items and variables
+    cs4 = cs.rename(items={"n1": "n3"}, variables={"x": "z"})
+    assert cs4.items[0].name == "n3"
+    assert cs4.items[0].children == ["[z] + 1"]
+    assert cs4.items[2].children == ["[z] > 0"]
+
+
+def test_rename_with_regex():
+    num = Number(name="prefix_n1", children=["[var_x] + 1"])
+    var = Variable(name="var_x", children=["foo"])
+    cs = CalcSet([num, var])
+    # Rename with regex
+    cs2 = cs.rename(
+        items={r"^prefix_": "renamed_"}, variables={r"^var_": "newvar_"}, regex=True
+    )
+    assert cs2.items[0].name == "renamed_n1"
+    assert cs2.items[0].children == ["[newvar_x] + 1"]
+    assert cs2.items[1].name == "newvar_x"
+
+
+def test_rename_nested_if():
+    ifrow = IfRow(condition=["[x] > 0"], value=["[x] + 1"])
+    ifexpr = If(rows=[ifrow], otherwise=["[x] - 1"])
+    num = Number(name="n1", children=[ifexpr])
+    cs = CalcSet([num])
+    cs2 = cs.rename(variables={"x": "y"})
+    nested_if = cs2.items[0].children[0]
+    assert isinstance(nested_if, If)
+    assert nested_if.rows[0].condition == ["[y] > 0"]
+    assert nested_if.rows[0].value == ["[y] + 1"]
+    assert nested_if.otherwise == ["[y] - 1"]
+
+
+import pytest
+from pollywog.core import CalcSet, Number
+
+from pollywog.core import Variable, Filter, If, IfRow, Category
+
+
+def test_number_to_dict_and_from_dict():
+    num = Number(name="n1", children=["1+2"])
+    d = num.to_dict()
+    num2 = Number.from_dict(d)
+    assert num2.name == "n1"
+    assert num2.children == ["1+2"]
+
+
+def test_variable_and_filter():
+    var = Variable(name="v1", children=["foo"])
+    filt = Filter(name="f1", children=["bar"])
+    assert var.to_dict()["type"] == "variable"
+    assert filt.to_dict()["type"] == "filter"
+
+
+def test_category():
+    cat = Category(name="cat1", children=["'A'"])
+    d = cat.to_dict()
+    assert d["calculation_type"] == "string"
+
+
+def test_ifrow_and_if():
+    ifrow = IfRow(condition=["[x] > 0"], value=["1"])
+    d = ifrow.to_dict()
+    ifrow2 = IfRow.from_dict(d)
+    assert ifrow2.condition == ["[x] > 0"]
+    assert ifrow2.value == ["1"]
+
+    ifexpr = If(rows=[ifrow], otherwise=["0"])
+    d2 = ifexpr.to_dict()
+    ifexpr2 = If.from_dict(d2)
+    assert isinstance(ifexpr2, If)
+    assert isinstance(ifexpr2.rows[0], IfRow)
+    assert ifexpr2.otherwise == ["0"]
+
+
+def test_calcset_serialization():
+    num = Number(name="n1", children=["1+2"])
+    var = Variable(name="v1", children=["foo"])
+    cs = CalcSet([num, var])
+    json_str = cs.to_json()
+    cs2 = CalcSet.from_dict(cs.to_dict())
+    assert isinstance(cs2, CalcSet)
+    assert len(cs2.items) == 2
+
+
+def test_calcset_repr():
+    num = Number(name="n1", children=["1+2"])
+    cs = CalcSet([num])
+    s = repr(cs)
+    assert s.startswith("{")
+
+
+def test_calcset_add_multiple():
+    num1 = Number(name="a", children=["2"])
+    num2 = Number(name="b", children=["3"])
+    var = Variable(name="v", children=["foo"])
+    cs1 = CalcSet([num1])
+    cs2 = CalcSet([num2, var])
+    cs3 = cs1 + cs2
+    assert len(cs3.items) == 3
+    assert cs3.items[2].name == "v"
+
+
+def test_copy_independence():
+    num = Number(name="n1", children=["1+2"])
+    num_copy = num.copy()
+    assert isinstance(num_copy, Number)
+    assert num_copy.name == num.name
+    assert num_copy.children == num.children
+    num_copy.name = "n2"
+    num_copy.children[0] = "3+4"
+    assert num.name == "n1"
+    assert num.children[0] == "1+2"
+
+    var = Variable(name="v1", children=["foo"])
+    var_copy = var.copy()
+    var_copy.name = "v2"
+    assert var.name == "v1"
+
+    filt = Filter(name="f1", children=["bar"])
+    filt_copy = filt.copy()
+    filt_copy.name = "f2"
+    assert filt.name == "f1"
+
+    cat = Category(name="cat1", children=["'A'"])
+    cat_copy = cat.copy()
+    cat_copy.name = "cat2"
+    assert cat.name == "cat1"
+
+    ifrow = IfRow(condition=["[x] > 0"], value=["1"])
+    ifrow_copy = ifrow.copy()
+    ifrow_copy.condition[0] = "[x] < 0"
+    assert ifrow.condition[0] == "[x] > 0"
+
+    ifexpr = If(rows=[ifrow], otherwise=["0"])
+    ifexpr_copy = ifexpr.copy()
+    ifexpr_copy.rows[0].condition[0] = "[x] == 0"
+    assert ifexpr.rows[0].condition[0] == "[x] > 0"
+
+    cs = CalcSet([num, var, filt, cat, ifrow, ifexpr])
+    cs_copy = cs.copy()
+    cs_copy.items[0].name = "changed"
+    assert cs.items[0].name == "n1"
+
+
+def test_error_handling():
+    # Wrong type for CalcSet.from_dict
+    with pytest.raises(ValueError):
+        CalcSet.from_dict({"type": "not-calcset", "items": []})
+    # Unknown item type
+    with pytest.raises(ValueError):
+        CalcSet.from_dict({"type": "calculation-set", "items": [{"type": "unknown"}]})
+
+
+def test_ifrow_invalid_type():
+    with pytest.raises(ValueError):
+        IfRow.from_dict({"type": "not_if_row"})
+
+
+def test_if_invalid_type():
+    with pytest.raises(ValueError):
+        If.from_dict({"type": "not_if"})
+
+
+def test_calcset_to_dict():
+    num = Number(name="test_num", children=["1+1"])
+    calcset = CalcSet([num])
+    d = calcset.to_dict()
+    assert d["type"] == "calculation-set"
+    assert isinstance(d["items"], list)
+    assert d["items"][0]["name"] == "test_num"
+
+
+def test_calcset_add():
+    num1 = Number(name="a", children=["2"])
+    num2 = Number(name="b", children=["3"])
+    cs1 = CalcSet([num1])
+    cs2 = CalcSet([num2])
+    cs3 = cs1 + cs2
+    assert len(cs3.items) == 2
+    assert cs3.items[0].name == "a"
+    assert cs3.items[1].name == "b"

tests/test_display.py

@@ -0,0 +1,60 @@
+import pollywog.display
+import pytest
+
+# Dummy CalcSet and Item for testing
+class DummyItem:
+    def __init__(self, name, typ, calc_type=None):
+        self.name = name
+        self.item_type = typ
+        self.calculation_type = calc_type
+    def to_dict(self):
+        d = {"name": self.name, "type": self.item_type}
+        if self.calculation_type:
+            d["calculation_type"] = self.calculation_type
+        return d
+
+class DummyCalcSet:
+    def __init__(self, items):
+        self.items = items
+
+# Test set_theme and theme switching
+def test_set_theme():
+    pollywog.display.set_theme("dark")
+    assert pollywog.display._DISPLAY_THEME == "dark"
+    pollywog.display.set_theme("light")
+    assert pollywog.display._DISPLAY_THEME == "light"
+    with pytest.raises(ValueError):
+        pollywog.display.set_theme("unknown")
+
+# Test display_calcset does not error and produces HTML
+@pytest.mark.parametrize("theme", ["light", "dark"])
+def test_display_calcset_html(theme):
+    pollywog.display.set_theme(theme)
+    items = [
+        DummyItem("A", "variable"),
+        DummyItem("B", "calculation", "number"),
+        DummyItem("C", "calculation", "string"),
+        DummyItem("D", "filter"),
+    ]
+    calcset = DummyCalcSet(items)
+    # Should not raise
+    pollywog.display.display_calcset(calcset)
+    # Should produce HTML output (not None)
+    # (We can't check the actual rendering, but can check no error)
+
+# Optionally, test that the HTML contains expected labels
+@pytest.mark.parametrize("theme,label", [("light", "number"), ("dark", "string")])
+def test_display_calcset_label(theme, label):
+    pollywog.display.set_theme(theme)
+    items = [DummyItem("B", "calculation", label)]
+    calcset = DummyCalcSet(items)
+    # Monkeypatch display to capture HTML
+    import IPython.display
+    captured = {}
+    def fake_display(obj):
+        captured["html"] = obj.data if hasattr(obj, "data") else str(obj)
+    orig_display = IPython.display.display
+    IPython.display.display = fake_display
+    pollywog.display.display_calcset(calcset)
+    IPython.display.display = orig_display
+    assert label in captured["html"]

tests/test_helpers.py

@@ -0,0 +1,72 @@
+from pollywog.helpers import Average, Sum, Product, Normalize, WeightedAverage, Scale, IfElse, CategoryFromThresholds
+from pollywog.core import Number
+
+def test_average_helper():
+    n = Average("Au", "Ag", name="avg_Au_Ag")
+    assert isinstance(n, Number)
+    assert n.name == "avg_Au_Ag"
+    assert "/ 2" in n.children[0]
+    assert "[Au]" in n.children[0] and "[Ag]" in n.children[0]
+
+def test_sum_helper():
+    n = Sum("Au", "Ag", name="sum_Au_Ag")
+    assert isinstance(n, Number)
+    assert n.name == "sum_Au_Ag"
+    assert "[Au]" in n.children[0] and "[Ag]" in n.children[0]
+    assert "+" in n.children[0]
+
+def test_product_helper():
+    n = Product("Au", "Ag", name="prod_Au_Ag")
+    assert isinstance(n, Number)
+    assert n.name == "prod_Au_Ag"
+    assert "[Au]" in n.children[0] and "[Ag]" in n.children[0]
+    assert "*" in n.children[0]
+
+def test_normalize_helper():
+    n = Normalize("Au", 0, 10, name="norm_Au")
+    assert isinstance(n, Number)
+    assert n.name == "norm_Au"
+    assert "[Au]" in n.children[0]
+    assert "/ (10 - 0)" in n.children[0]
+
+def test_weighted_average_helper():
+    # Test with constant weights
+    n = WeightedAverage(["Au", "Ag"], [0.7, 0.3], name="wavg_Au_Ag")
+    assert isinstance(n, Number)
+    assert n.name == "wavg_Au_Ag"
+    assert "[Au] * 0.7" in n.children[0]
+    assert "[Ag] * 0.3" in n.children[0]
+    assert "/ (0.7 + 0.3)" in n.children[0] or "/ (1.0)" in n.children[0]
+
+    # Test with variable weights
+    n2 = WeightedAverage(["Au", "Ag"], ["w1", "w2"], name="wavg_Au_Ag_varw")
+    assert isinstance(n2, Number)
+    assert n2.name == "wavg_Au_Ag_varw"
+    assert "[Au] * [w1]" in n2.children[0]
+    assert "[Ag] * [w2]" in n2.children[0]
+    assert "/ ([w1] + [w2])" in n2.children[0]
+
+def test_scale_helper():
+    n = Scale("Au", 2, name="Au_scaled")
+    assert isinstance(n, Number)
+    assert n.name == "Au_scaled"
+    assert "[Au] * 2" in n.children[0]
+
+    n2 = Scale("Ag", "factor", name="Ag_scaled")
+    assert isinstance(n2, Number)
+    assert n2.name == "Ag_scaled"
+    assert "[Ag] * [factor]" in n2.children[0]
+
+def test_ifelse_helper():
+    n = IfElse("[Au] > 1", 2, 0, name="Au_ifelse")
+    assert n.name == "Au_ifelse"
+    # Should contain If block
+    assert hasattr(n, "children")
+    assert "If [Au] > 1 then 2 else 0" in n.comment_equation
+
+def test_category_from_thresholds_helper():
+    n = CategoryFromThresholds("Au", [0.5, 1.0], ["Low", "Medium", "High"], name="Au_class")
+    assert n.name == "Au_class"
+    # Should contain If block
+    assert hasattr(n, "children")
+    assert "Classify Au by thresholds [0.5, 1.0]" in n.comment_equation

tests/test_run.py

@@ -0,0 +1,71 @@
+import pytest
+from pollywog.core import CalcSet, Variable, Number, If, IfRow
+from pollywog.run import run_calcset
+
+
+def test_import_run():
+    # Just test that run.py imports without error
+    assert True
+
+
+def test_run_calcset_with_dict():
+    a = Variable(name="a", children=[""])
+    b = Number(name="b", children=["[a] + 1"])
+    c = Number(name="c", children=["[b] * 2"])
+    cs = CalcSet([a, b, c])
+    inputs = {"a": 3}
+    results = run_calcset(cs, inputs=inputs)
+    assert "a" not in results  # Variable should not be in output by default
+    assert results["b"] == 4
+    assert results["c"] == 8
+    # Debug mode: output_variables=True
+    debug_results = run_calcset(cs, inputs=inputs, output_variables=True)
+    assert debug_results["a"] == 3
+    assert debug_results["b"] == 4
+    assert debug_results["c"] == 8
+
+
+def test_run_calcset_with_if():
+    a = Variable(name="a", children=[""])
+    ifrow1 = IfRow(condition=["[a] > 0"], value=["1"])
+    ifrow2 = IfRow(condition=["[a] <= 0"], value=["-1"])
+    ifexpr = If(rows=[ifrow1, ifrow2], otherwise=["0"])
+    b = Number(name="b", children=[ifexpr])
+    cs = CalcSet([a, b])
+    results = run_calcset(cs, inputs={"a": 2})
+    assert "a" not in results
+    assert results["b"] == 1
+    results = run_calcset(cs, inputs={"a": -2})
+    assert results["b"] == -1
+    results = run_calcset(cs, inputs={"a": 0})
+    assert results["b"] == -1
+    # Debug mode
+    debug_results = run_calcset(cs, inputs={"a": 2}, output_variables=True)
+    assert debug_results["a"] == 2
+    assert debug_results["b"] == 1
+
+
+def test_run_calcset_with_dataframe():
+    import pandas as pd
+
+    a = Variable(name="a", children=[""])
+    b = Number(name="b", children=["[a] + 1"])
+    cs = CalcSet([a, b])
+    df = pd.DataFrame({"a": [1, 2, 3]})
+    result_df = run_calcset(cs, dataframe=df)
+    assert list(result_df["b"]) == [2, 3, 4]
+    assert "a" not in result_df.columns  # Variable column should be dropped
+    # Debug mode
+    debug_df = run_calcset(cs, dataframe=df, output_variables=True)
+    assert "a" in debug_df.columns
+    assert list(debug_df["a"]) == [1, 2, 3]
+
+
+def test_pw_accessor():
+    import pandas as pd
+
+    b = Number(name="b", children=["[a] + 1"])
+    cs = CalcSet([b])
+    df = pd.DataFrame({"a": [10, 20]})
+    result_df = df.pw.run(cs)
+    assert list(result_df["b"]) == [11, 21]

tests/test_utils.py

@@ -0,0 +1,32 @@
+from pollywog.utils import ensure_list, ensure_str_list, to_dict
+
+
+class Dummy:
+    def to_dict(self):
+        return {"dummy": True}
+
+
+def test_ensure_list():
+    assert ensure_list(1) == [1]
+    assert ensure_list([1, 2]) == [1, 2]
+
+
+def test_ensure_str_list():
+    assert ensure_str_list("foo") == ["foo"]
+    assert ensure_str_list(["foo"]) == ["foo"]
+    assert ensure_str_list([1]) == ["", 1, ""]
+    assert ensure_str_list(["foo", 1]) == ["foo", 1, ""]
+    assert ensure_str_list(["foo", "bar"]) == ["foo", "bar"]
+
+
+def test_to_dict():
+    d = Dummy()
+    assert to_dict(d) == [{"dummy": True}]
+    assert to_dict([d, d]) == [{"dummy": True}, {"dummy": True}]
+    assert to_dict(["a", "b"]) == ["a", "b"]
+    assert to_dict(["a", d]) == ["a", {"dummy": True}]
+    # guard_strings True
+    assert to_dict([d], guard_strings=True) == ["", {"dummy": True}, ""]
+    assert to_dict(["a", d], guard_strings=True) == ["a", {"dummy": True}, ""]
+    assert to_dict([d, "a"], guard_strings=True) == ["", {"dummy": True}, "a"]
+    assert to_dict(["a", "b"], guard_strings=True) == ["a", "b"]