solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.1__py3-none-any.whl

tests/fitfunctions/test_tex_info.py

@@ -0,0 +1,183 @@
+import warnings
+
+from types import SimpleNamespace
+
+import matplotlib
+import pytest
+from solarwindpy.fitfunctions.tex_info import TeXinfo
+
+matplotlib.use("Agg")
+warnings.filterwarnings("ignore")
+
+
+@pytest.fixture
+def texinfo():
+    popt = {"a": 1.23, "b": 4.56}
+    psigma = {"a": 0.01, "b": 0.02}
+    func = "f(x)=a x + b"
+    chisq = SimpleNamespace(linear=1.0, robust=2.0)
+    rsq = 0.99
+    initial_guess_info = {
+        "a": SimpleNamespace(p0=0.5, bounds=(-1, 1)),
+        "b": SimpleNamespace(p0=2.0, bounds=(0, 5)),
+    }
+    tex = TeXinfo(popt, psigma, func, chisq, rsq, initial_guess_info, 10)
+    tex.set_TeX_argnames(a="\\alpha", b="\\beta")
+    return tex
+
+
+def test_properties_and_str(texinfo):
+    assert texinfo.popt == {"a": 1.23, "b": 4.56}
+    assert texinfo.psigma == {"a": 0.01, "b": 0.02}
+    assert texinfo.chisq_dof.linear == 1.0
+    assert texinfo.rsq == 0.99
+    assert texinfo.npts == 10
+    assert texinfo.TeX_function == "f(x)=a x + b"
+    assert texinfo.TeX_argnames == {"a": "\\alpha", "b": "\\beta"}
+    assert "\\alpha" in texinfo.initial_guess_info
+    assert texinfo.TeX_popt["\\alpha"].startswith("1.23")
+    assert "\\sigma(X)/X" in texinfo.TeX_relative_error
+    info = texinfo.build_info(rsq=True, npts=True)
+    assert "R^2 = 0.99" in info
+    assert str(texinfo) == info
+
+
+def test_constructor_and_setters_errors():
+    with pytest.raises(ValueError):
+        TeXinfo({"a": 1}, {"b": 1}, "f", SimpleNamespace(), 0, None, None)
+    with pytest.raises(TypeError):
+        TeXinfo({"a": 1}, {"a": 1}, "f", SimpleNamespace(), 0, "bad", None)
+    tex = TeXinfo({"a": 1}, {"a": 1}, "f", SimpleNamespace(), 0, None, None)
+    with pytest.raises(TypeError):
+        tex.set_npts("ten")
+    with pytest.raises(TypeError):
+        tex.set_initial_guess_info("bad")
+    with pytest.raises(ValueError):
+        tex.set_TeX_argnames(c="\\gamma")
+
+
+def test_set_popt_psigma_errors(texinfo):
+    with pytest.raises(
+        ValueError
+    ):  # Function actually raises ValueError when iterating over string
+        texinfo.set_popt_psigma("bad", {"a": 1})
+    with pytest.raises(AttributeError):  # String doesn't have .items() method
+        texinfo.set_popt_psigma({"a": 1}, "bad")
+    with pytest.raises(ValueError):
+        texinfo.set_popt_psigma({"a": 1}, {"b": 1})
+
+
+def test_set_chisq_dof_type_error(texinfo):
+    # The function doesn't actually do type checking, just sets the value
+    texinfo.set_chisq_dof("bad")  # This should succeed
+    assert texinfo._chisq_dof == "bad"
+
+
+def test_set_rsq_type_error(texinfo):
+    # The function doesn't actually do type checking, just sets the value
+    texinfo.set_rsq("bad")  # This should succeed
+    assert texinfo._rsq == "bad"
+
+
+def test_set_TeX_function_type_error(texinfo):
+    # The function doesn't actually do type checking, just sets the value
+    texinfo.set_TeX_function(5)  # This should succeed
+    assert texinfo._TeX_function == 5
+
+
+def test_check_and_add_math_escapes():
+    f = TeXinfo._check_and_add_math_escapes
+    assert f("x") == "$x$"
+    assert f("$x$") == "$x$"
+    with pytest.raises(ValueError):
+        f("$x$$")
+
+
+def test_calc_precision():
+    f = TeXinfo._calc_precision
+    assert f(0.00123) == -3
+    assert f(123.0) == 2
+
+
+def test_simplify_for_paper():
+    assert TeXinfo._simplify_for_paper(["$a=1.2300$", "$text$"]) == [
+        "a = 1.23",
+        "text",
+    ]
+
+
+def test_add_additional_info_with_str(texinfo):
+    base = "base"
+    result = texinfo._add_additional_info(base, "extra")
+    # The function actually returns "base\nextra" format
+    assert "extra" in result
+    assert "base" in result
+
+
+def test_add_additional_info(texinfo):
+    base = "base"
+    result = texinfo._add_additional_info(base, ["x", "y"])
+    assert "$x$" in result and "$y$" in result
+    with pytest.raises(TypeError):
+        texinfo._add_additional_info(base, 5)
+
+
+def test_build_fit_parameter_info(texinfo):
+    info = texinfo._build_fit_parameter_info(
+        chisq_dof=True,
+        rsq=True,
+        convert_pow_10=True,
+        strip_uncertainties=True,
+        simplify_info_for_paper=True,
+        npts=True,
+        relative_error=True,
+    )
+    assert "chi" in info and "R^2" in info
+    assert "N_\\mathrm{pts}" in info and "sigma(X)/X" in info
+
+
+def test_build_fit_parameter_info_errors(texinfo):
+    """_build_fit_parameter_info should reject unknown kwargs."""
+    with pytest.raises(
+        TypeError
+    ):  # Function actually raises TypeError for unknown kwargs
+        texinfo._build_fit_parameter_info(bogus=True)
+
+
+def test_annotate_info(texinfo):
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots()
+    texinfo.annotate_info(ax)
+    assert texinfo.info in ax.texts[0].get_text()
+    plt.close(fig)
+
+
+def test_build_info_and_val_uncert(texinfo):
+    info = texinfo.build_info(additional_info="extra")
+    assert "extra" in info
+    with pytest.raises(ValueError):
+        texinfo.build_info(bogus=True)
+    s = texinfo.val_uncert_2_string(1.234, 0.01)
+    assert "\\pm" in s and s.startswith("1.23")
+
+
+def test_build_info_with_initial_guess(texinfo):
+    info = texinfo.build_info(add_initial_guess=True)
+    assert "\\alpha" in info and "5.000e-01" in info
+    assert str(texinfo) == info
+
+
+def test_build_info_relative_error_e_format(texinfo):
+    info = texinfo.build_info(relative_error=True, convert_pow_10=False)
+    assert "sigma(X)/X" in info and "e+00" in info
+    assert "10^" not in info
+    assert str(texinfo) == info
+
+
+def test_build_info_strip_uncert_simplify(texinfo):
+    info = texinfo.build_info(strip_uncertainties=True, simplify_info_for_paper=True)
+    assert "\\pm" not in info
+    assert "\\alpha = 1.23" in info
+    assert "e+" not in info
+    assert str(texinfo) == info

tests/fitfunctions/test_trend_fit_properties.py

@@ -0,0 +1,31 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from solarwindpy.fitfunctions import trend_fits, lines
+
+
+@pytest.fixture
+def agged():
+    xbins = pd.interval_range(0, 5, periods=5)
+    ybins = pd.interval_range(0, 2, periods=2)
+    data = {
+        ybins[0]: np.array([1, 2, 3, 4, 5]),
+        ybins[1]: np.array([2, 3, 4, 5, 6]),
+    }
+    return pd.DataFrame(data, index=xbins)
+
+
+def test_popt1d_keys_property(agged):
+    trend_fit = trend_fits.TrendFit(agged, lines.Line)
+    assert trend_fit.popt1d_keys == trend_fits.Popt1DKeys("mu", "sigma")
+
+
+def test_trend_logx_true_make_trend_func(agged):
+    """Ensure ``trend_logx`` propagates to the trend function."""
+    trend_fit = trend_fits.TrendFit(agged, lines.Line, trend_logx=True)
+    assert trend_fit.trend_logx is True
+    trend_fit.make_ffunc1ds()
+    trend_fit.make_1dfits()
+    trend_fit.make_trend_func()
+    assert isinstance(trend_fit.trend_func, lines.Line)

tests/fitfunctions/test_trend_fits.py

@@ -0,0 +1,244 @@
+import warnings
+from types import SimpleNamespace
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy.optimize import OptimizeWarning
+
+from solarwindpy.fitfunctions import core, gaussians, trend_fits, lines
+from solarwindpy.fitfunctions.plots import AxesLabels
+
+
+@pytest.fixture
+def agged():
+    xbins = pd.interval_range(0, 5, periods=5)
+    ybins = pd.interval_range(0, 2, periods=2)
+    data = {
+        ybins[0]: np.array([1, 2, 3, 4, 5]),
+        ybins[1]: np.array([2, 3, 4, 5, 6]),
+    }
+    return pd.DataFrame(data, index=xbins)
+
+
+@pytest.fixture
+def agged_empty():
+    xbins = pd.interval_range(0, 5, periods=5)
+    return pd.DataFrame({}, index=xbins)
+
+
+@pytest.fixture
+def trend_fit(agged):
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    tf.make_ffunc1ds()
+    tf.make_1dfits()
+    tf.make_trend_func()
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=OptimizeWarning)
+        tf.trend_func.make_fit()
+    return tf
+
+
+@pytest.fixture
+def trend_fit_all_ffuncs(monkeypatch, agged):
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    tf.make_ffunc1ds()
+    tf.make_1dfits()
+    tf.make_trend_func()
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=OptimizeWarning)
+        tf.trend_func.make_fit()
+    monkeypatch.setattr(
+        tf.trend_func.plotter,
+        "_labels",
+        SimpleNamespace(x=SimpleNamespace(tex="", units="")),
+    )
+    calls = {}
+    hax = SimpleNamespace(legend_=SimpleNamespace(set_title=lambda *_: None))
+    rax = SimpleNamespace()
+    for k, ff in tf.ffuncs.items():
+
+        def stub(*_, _key=k, **__):
+            calls[_key] = calls.get(_key, 0) + 1
+            return hax, rax
+
+        monkeypatch.setattr(ff.plotter, "plot_raw_used_fit_resid", stub)
+    return tf, calls, hax, rax
+
+
+def test_type_enforcement_and_properties(agged):
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    assert tf.agged.equals(agged)
+    assert tf.ffunc1d_class is gaussians.Gaussian
+    assert tf.trendfunc_class is lines.Line
+    assert str(tf) == "TrendFit"
+    with pytest.raises(TypeError):
+        trend_fits.TrendFit(agged, int)
+    with pytest.raises(TypeError):
+        tf.set_fitfunctions(int, lines.Line)
+    with pytest.raises(TypeError):
+        tf.set_fitfunctions(gaussians.Gaussian, int)
+
+
+def test_make_ffunc1ds_make_1dfits(agged):
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    tf.make_ffunc1ds()
+    assert isinstance(tf.ffuncs.iloc[0], gaussians.Gaussian)
+    tf.make_1dfits()
+    assert tf.bad_fits.empty
+    assert not tf.popt_1d.empty
+    assert not tf.psigma_1d.empty
+
+
+def test_make_1dfits_moves_bad_fit(monkeypatch):
+    xbins = pd.interval_range(0, 5, periods=5)
+    ybins = pd.interval_range(0, 2, periods=2)
+    data = {
+        ybins[0]: np.array([1, 2, 3, 4, 5]),
+        ybins[1]: np.array([np.nan, np.nan, np.nan, 5, 6]),
+    }
+    agged = pd.DataFrame(data, index=xbins)
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    tf.make_ffunc1ds()
+
+    orig_make_fit = gaussians.Gaussian.make_fit
+
+    def fail_on_small_n(self, *args, **kwargs):
+        if self.nobs < len(self.argnames):
+            return ValueError("insufficient data")
+        return orig_make_fit(self, *args, **kwargs)
+
+    monkeypatch.setattr(gaussians.Gaussian, "make_fit", fail_on_small_n)
+    tf.make_1dfits()
+    bad_bin = ybins[1]
+    assert bad_bin in tf.bad_fits.index
+    assert bad_bin not in tf.ffuncs.index
+
+
+def test_make_trend_func_success_and_failure(trend_fit, agged_empty):
+    assert isinstance(trend_fit.trend_func, lines.Line)
+    tf = trend_fits.TrendFit(agged_empty, lines.Line)
+    tf.make_ffunc1ds()
+    with pytest.raises(ValueError):
+        tf.make_trend_func()
+
+
+def test_plotting_methods_return_axes(monkeypatch, trend_fit):
+    class DummyAx:
+        def set_xscale(self, *_):
+            pass
+
+        def errorbar(self, *_, **__):
+            line = SimpleNamespace(set_linestyle=lambda *_: None)
+            return "pl", "cl", [line]
+
+        def legend(self, *_, **__):
+            pass
+        
+        def plot(self, *args, **kwargs):
+            return None
+        
+        def fill_between(self, *args, **kwargs):
+            return None
+
+    ax1, ax2 = DummyAx(), DummyAx()
+    monkeypatch.setattr(
+        trend_fit.trend_func.plotter,
+        "plot_raw_used_fit_resid",
+        lambda *_, **__: (ax1, ax2),
+    )
+    h, r = trend_fit.plot_trend_fit_resid()
+    assert h is ax1 and r is ax2
+
+    monkeypatch.setattr(trend_fit, "plot_all_popt_1d", lambda *_, **__: (1, 2, 3))
+    h2, r2 = trend_fit.plot_trend_and_resid_on_ffuncs()
+    assert h2 is ax1 and r2 is ax2
+
+    monkeypatch.setattr(
+        trend_fit.trend_func.plotter, "plot_raw_used_fit", lambda *_, **__: None
+    )
+    monkeypatch.setattr(
+        trend_fits, "subplots", lambda *_, **__: (None, DummyAx())
+    )
+    ax = trend_fit.plot_1d_popt_and_trend()
+    assert isinstance(ax, DummyAx)
+
+
+def test_plot_all_popt_1d_returns_errorbar_artists(agged):
+    class StubAx:
+        def __init__(self):
+            self.calls = {}
+            line = SimpleNamespace(set_linestyle=lambda *_: None)
+            self.ret = ("pl", "cl", [line])
+
+        def errorbar(self, *args, **kwargs):
+            self.calls["errorbar"] = {"args": args, "kwargs": kwargs}
+            return self.ret
+
+        def set_xscale(self, *args, **kwargs):  # pragma: no cover - not used here
+            self.calls["set_xscale"] = {"args": args, "kwargs": kwargs}
+        
+        def plot(self, *args, **kwargs):
+            self.calls["plot"] = {"args": args, "kwargs": kwargs}
+            return None
+        
+        def fill_between(self, *args, **kwargs):
+            self.calls["fill_between"] = {"args": args, "kwargs": kwargs}
+            return None
+
+    tf = trend_fits.TrendFit(agged, lines.Line)
+    tf.make_ffunc1ds()
+    tf.make_1dfits()
+    tf.make_trend_func()
+
+    ax = StubAx()
+    pl, cl, bl = tf.plot_all_popt_1d(ax, color="magenta", label="1D Fits", plot_window=False)
+
+    assert (pl, cl, bl) == ax.ret
+
+    kwargs = ax.calls["errorbar"]["kwargs"]
+    expected_x = pd.IntervalIndex(tf.popt_1d.index).mid
+    np.testing.assert_allclose(kwargs["x"], expected_x)
+    ykey, wkey = tf.popt1d_keys
+    assert kwargs["y"] == ykey
+    assert kwargs["yerr"] == wkey
+    assert kwargs["color"] == "magenta"
+    assert kwargs["linestyle"] == "--"  # Default linestyle
+    assert kwargs["label"] == "1D Fits"
+    pd.testing.assert_frame_equal(kwargs["data"], tf.popt_1d)
+
+
+def test_plot_all_ffuncs(trend_fit_all_ffuncs):
+    tf, calls, hax, rax = trend_fit_all_ffuncs
+    axes = tf.plot_all_ffuncs()
+    assert isinstance(axes, pd.DataFrame)
+    for key in tf.ffuncs.index:
+        assert axes.loc[key, "hax"] is hax
+        assert axes.loc[key, "rax"] is rax
+        assert calls[key] == 1
+
+
+def test_set_agged_set_fitfunctions_set_shared_labels(trend_fit, agged):
+    new_agged = agged * 2
+    trend_fit.set_agged(new_agged)
+    assert trend_fit.agged.equals(new_agged)
+    trend_fit.set_fitfunctions(gaussians.GaussianNormalized, lines.Line)
+    assert trend_fit.ffunc1d_class is gaussians.GaussianNormalized
+    trend_fit.set_fitfunctions(gaussians.Gaussian, lines.Line)
+    trend_fit.set_shared_labels(x="time", y="density", z="counts")
+    assert trend_fit.trend_func.plotter.labels.x == "time"
+    first_ff = trend_fit.ffuncs.iloc[0]
+    assert first_ff.plotter.labels.x == "density"
+    assert first_ff.plotter.labels.y == "counts"
+
+
+def test_set_agged_rejects_non_dataframe(trend_fit):
+    with pytest.raises(AssertionError):
+        trend_fit.set_agged(42)
+
+
+def test_labels_instance_and_update(trend_fit):
+    # Labels are stored in the trend_func's plotter, not in TrendFit itself
+    assert isinstance(trend_fit.trend_func.plotter.labels, AxesLabels)
+    trend_fit.set_shared_labels(x="time", y="density", z="counts")
+    assert trend_fit.trend_func.plotter.labels == AxesLabels("time", "density", "counts")

tests/plotting/__init__.py

@@ -0,0 +1 @@
+# Plotting module tests

tests/plotting/labels/__init__.py

@@ -0,0 +1 @@
+# Plotting labels tests