solarwindpy 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

solarwindpy/plotting/hist2d.py

@@ -240,9 +240,9 @@ class Hist2D(base.PlotWithZdata, base.CbarMaker, AggPlot):
         if axnorm is None:
             pass
         elif axnorm == "c":
-            agg = agg.divide(agg.max(level="x"), level="x")
+            agg = agg.divide(agg.groupby(level="x").max(), level="x")
         elif axnorm == "r":
-            agg = agg.divide(agg.max(level="y"), level="y")
+            agg = agg.divide(agg.groupby(level="y").max(), level="y")
         elif axnorm == "t":
             agg = agg.divide(agg.max())
         elif axnorm == "d":
@@ -265,7 +265,7 @@ class Hist2D(base.PlotWithZdata, base.CbarMaker, AggPlot):
 
         elif axnorm == "cd":
             #             raise NotImplementedError("Need to verify data alignment, especially `dx` values and index")
-            N = agg.sum(level="x")
+            N = agg.groupby(level="x").sum()
             dy = pd.IntervalIndex(
                 agg.index.get_level_values("y").unique()
             ).sort_values()
@@ -275,7 +275,7 @@ class Hist2D(base.PlotWithZdata, base.CbarMaker, AggPlot):
 
         elif axnorm == "rd":
             #             raise NotImplementedError("Need to verify data alignment, especially `dx` values and index")
-            N = agg.sum(level="y")
+            N = agg.groupby(level="y").sum()
             dx = pd.IntervalIndex(
                 agg.index.get_level_values("x").unique()
             ).sort_values()
@@ -286,9 +286,9 @@ class Hist2D(base.PlotWithZdata, base.CbarMaker, AggPlot):
         elif hasattr(axnorm, "__iter__"):
             kind, fcn = axnorm
             if kind == "c":
-                agg = agg.divide(agg.agg(fcn, level="x"), level="x")
+                agg = agg.divide(agg.groupby(level="x").agg(fcn), level="x")
             elif kind == "r":
-                agg = agg.divide(agg.agg(fcn, level="y"), level="y")
+                agg = agg.divide(agg.groupby(level="y").agg(fcn), level="y")
             else:
                 raise ValueError(f"Unrecognized axnorm with function ({kind}, {fcn})")
         else:

{solarwindpy-0.1.2.dist-info → solarwindpy-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solarwindpy
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python package for solar wind data analysis.
 Author-email: "B. L. Alterman" <blaltermanphd@gmail.com>
 License: LICENSE
@@ -90,6 +90,23 @@ SolarWindPy
 
 Python data analysis tools for solar wind measurements.
 
+Quick Start
+-----------
+
+After installation, import the package and create a plasma object:
+
+.. code-block:: python
+
+   import solarwindpy as swp
+   
+   # Load plasma data (example with sample data)
+   plasma = swp.Plasma()
+   
+   # Access ion species and magnetic field data
+   print(plasma.data.columns)  # View available measurements
+
+See the documentation for detailed usage examples and API reference.
+
 Installation
 ============
 
@@ -116,17 +133,17 @@ Development
 
    .. code-block:: bash
 
-      conda env create -f solarwindpy-20250403.yml  # Python 3.10+
-      conda activate solarwindpy-20250403
+      conda env create -f solarwindpy.yml  # Python 3.10+
+      conda activate solarwindpy
       pip install -e .
 
    Alternatively generate the environment from ``requirements-dev.txt``:
 
    .. code-block:: bash
 
-      python scripts/requirements_to_conda_env.py --name solarwindpy-dev
-      conda env create -f solarwindpy-dev.yml
-      conda activate solarwindpy-dev
+      python scripts/requirements_to_conda_env.py --name solarwindpy
+      conda env create -f solarwindpy.yml
+      conda activate solarwindpy
       pip install -e .
 
 3. Run the test suite with ``pytest``:
@@ -171,8 +188,8 @@ See `CITATION.rst`_ for instructions on citing SolarWindPy.
 .. _LICENSE.rst: ./LICENSE.rst
 .. _CITATION.rst: ./CITATION.rst
 
-.. |Build Status| image:: https://github.com/blalterman/SolarWindPy/actions/workflows/continuous-integration.yml/badge.svg?branch=master
-   :target: https://github.com/blalterman/SolarWindPy/actions/workflows/continuous-integration.yml
+.. |Build Status| image:: https://github.com/blalterman/SolarWindPy/actions/workflows/ci-master.yml/badge.svg?branch=master
+   :target: https://github.com/blalterman/SolarWindPy/actions/workflows/ci-master.yml
 .. |Docs Status| image:: https://readthedocs.org/projects/solarwindpy/badge/?version=latest
    :target: https://solarwindpy.readthedocs.io/en/latest/?badge=latest
 .. |License| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg

{solarwindpy-0.1.2.dist-info → solarwindpy-0.1.4.dist-info}/RECORD

@@ -202,10 +202,13 @@ plans/documentation-workflow-fix/2-Configuration-Setup.md,sha256=alGWMMObb3aQp_k
 plans/documentation-workflow-fix/3-Pre-commit-Integration.md,sha256=7M-iyg1ifPikuWLYG8-M5EN9U6EnQektoD8J0tjTKfI,9066
 plans/documentation-workflow-fix/4-Workflow-Improvements.md,sha256=xs3dU5OCWksszqmXX44Y6qrLCNpoK_Q6b756Rsyqa1E,13130
 plans/documentation-workflow-fix/5-Documentation-and-Training.md,sha256=adnQVs7IhiAj6zNlzl_xjIfSVT35N95fDLlFEwlFdKQ,12725
-plans/github-issues-migration/0-Overview.md,sha256=KN7ig_ryX4zjc6xbJT8XuKXk9HJOdlGRvtVYU4xD4Fk,21939
-plans/github-issues-migration/1-Foundation-Label-System.md,sha256=fMrFDUGl82f2X7ceOYaTf5ajwrltoh6uU8FuNsn3_zY,8497
+plans/github-issues-migration/0-Overview.md,sha256=u5-VQp8mE7zOOwixP6Z2ktXJC2HkaQ6BwKGQIGTmkvk,26114
+plans/github-issues-migration/1-Foundation-Label-System.md,sha256=QVMyHVzj3xYQOmWBKdAVk-zYAOHJgG9-GYVUC3POJDE,11066
 plans/github-issues-migration/2-Migration-Tool-Rewrite.md,sha256=vXztSKQHKILm3IDgmvND1GgPqwfpXyGMA8lBfXiqY3E,11398
+plans/github-issues-migration/2-Plan-Creation-System.md,sha256=uk8mLFSVCQO45AErRzwb_K0vJXf2yfX5lM1Tj4CFXnE,9612
 plans/github-issues-migration/3-CLI-Integration-Automation.md,sha256=PBvyP41Oa2lP7LBGMSkLXD0wfbZh1H1wyykRH-fZtCg,7504
+plans/github-issues-migration/3-CLI-Integration-Documentation.md,sha256=0-YtPNYCEMUMtdoQob15-H7KTA3wOccTjE5rXgJDR2k,12117
+plans/github-issues-migration/4-Plan-Closeout-Validation.md,sha256=SSLeNdAhgxYQAFzvt2PnQjrdkqO2q0cJem1JJa8flGI,10366
 plans/github-issues-migration/4-Validated-Migration.md,sha256=A0F6ybse7_OXUdJNAi49QDIkw8GoIBfFnhagyDZbI3Q,12036
 plans/github-issues-migration/5-Documentation-Training.md,sha256=1s6fSOZxe9SmAotH9xdZzUrd1iLTHm1LN92s46rIBqw,7967
 plans/github-issues-migration/6-Closeout.md,sha256=hrk93iv6AUPFULRx_YavqaJGQfn5vjhu-eAGBtpsYlo,7466
@@ -281,7 +284,6 @@ plans/tests-audit/artifacts/TEST_INVENTORY.md,sha256=fU4HaDHXsOPYMm41Jw4g9oG5OsT
 plans/tests-audit/artifacts/test_discovery_analysis.py,sha256=W57F6dZE8SVBmuoiQ7ccyNpoYE3OmgeOAZ-Z57gYpF0,9739
 plans/tests-audit/artifacts/test_parser.py,sha256=74PhaairFxZYgPFhPNe0Xgc_rj7mCOpNfYz4p9kKLiI,15910
 solarwindpy/README.md,sha256=54qoMZ3EDkwYIthS_fgolKE63_t5h6tl1fAu8W6sPWQ,63
-solarwindpy/Untitled.ipynb,sha256=25BEnYCUG4OiVgZjGRdJQBQRb7oUtl0R7mkZGiTkvfs,1589
 solarwindpy/__init__.py,sha256=41v4M-8UGLsWvG-y-QW1x6BBYYtHxi3WwhKyoW6eyuE,1490
 solarwindpy/core/__init__.py,sha256=gNQSJd3_NGaVg1cqgYEmP7a4AxcfJpEBB_9qEqcxwZM,489
 solarwindpy/core/alfvenic_turbulence.py,sha256=l2EChzYpAuuUFys1robjx9CEV9qY6eboIxIOTYXmosw,25730
@@ -298,7 +300,7 @@ solarwindpy/fitfunctions/exponentials.py,sha256=5NtpKMcns9BpD3jpLszw2Kn86Dt9Uhv4
 solarwindpy/fitfunctions/gaussians.py,sha256=db3yj89taBgHCjMF_GoxUlwJlJBjAfgH37rbCtZQZxc,8217
 solarwindpy/fitfunctions/lines.py,sha256=crs5CbdtMpz6liTeKcBW2_2o9dQClYPV5QXSrd5YXc8,2806
 solarwindpy/fitfunctions/moyal.py,sha256=cfoNGJ4-0tHjJUMKoVf7WXo4Zf_UwtYIa9b8WZd385k,2043
-solarwindpy/fitfunctions/plots.py,sha256=wMfQ_l9oBmIoEUFKtNe-7w8V-naz5cPVOTZXQ-rEE24,24487
+solarwindpy/fitfunctions/plots.py,sha256=nnu1zLxkmHOe0HqDD_yZWIRhvZ6rvVG0hZakxsPvELk,24615
 solarwindpy/fitfunctions/power_laws.py,sha256=rEt-eO8k5HwFhqN1WKLF4fb-ADsQzFiFi6RfK-i-y90,6065
 solarwindpy/fitfunctions/tex_info.py,sha256=UXI-JFe6oIn4wNmknm6woyJzNVYolW4OiWHvaSCApHg,18919
 solarwindpy/fitfunctions/trend_fits.py,sha256=ZAsHGpMf5ATcCTHkaLglsTqDsTA6wcY2UoWlN3YKv3U,15353
@@ -309,7 +311,7 @@ solarwindpy/plotting/__init__.py,sha256=xcyOoL2mt9uO0HBgtyXbZMF2pWP1OvL9EbG8fl5P
 solarwindpy/plotting/agg_plot.py,sha256=NhEx2Kh4dDGxBdMjJVsCuMwRyIvtWS5lNi-TlbbFrnM,16381
 solarwindpy/plotting/base.py,sha256=FhyLeQnAgLOyjdJAWLIswusCLvFlyQQxTSufnMEw_cQ,14345
 solarwindpy/plotting/hist1d.py,sha256=tynZSnFfjw53pVFki6EXbti3NP5q62zp8xQD6NFhDrE,12721
-solarwindpy/plotting/hist2d.py,sha256=Z8kr4RPqAZ1gA9G9reJd1zzRs6fHecY_z1oKMOHTkDA,33901
+solarwindpy/plotting/hist2d.py,sha256=AEDcotXoWsGrojr6GsvGCRMClZzXGu7j79eXqkJ0hqs,33957
 solarwindpy/plotting/histograms.py,sha256=vlViwlEohbWmnyXyEkaS5SW33NhCwz_WGsg5p4UgMsE,60538
 solarwindpy/plotting/orbits.py,sha256=s7kTtaWSD6fDKjtLnfIgAHOoNtAQc_1NR8a-Rj9d7-w,17011
 solarwindpy/plotting/scatter.py,sha256=m8tCkOwapRppOREfR8Gvw6UZxRxmWgclkjaxbKPIYUI,2746
@@ -337,7 +339,7 @@ solarwindpy/solar_activity/sunspot_number/sidc.py,sha256=zTktSZxPSNtdQ1jrRl7V76k
 solarwindpy/solar_activity/sunspot_number/ssn_extrema.csv,sha256=5OJ5iEMLWIYYnBqihYpDBAOV9oiwE3hLmVzEsUUlfr4,2101
 solarwindpy/solar_activity/sunspot_number/ssn_extrema.csv.silso,sha256=iQq8Ea0EMU1LZj2wtJQeRd2Sw-PW58wGSJtVpR8hgmE,2102
 solarwindpy/tools/__init__.py,sha256=hoLkvWMHNcDFlxdjKF8wov4MNzHVCayheiRcrYCZ7RM,4602
-solarwindpy-0.1.2.dist-info/licenses/LICENSE.rst,sha256=LnFDisrg2iF2g1WG7hg3UyezM7BHvixBj5u-KJy7HqI,1531
+solarwindpy-0.1.4.dist-info/licenses/LICENSE.rst,sha256=LnFDisrg2iF2g1WG7hg3UyezM7BHvixBj5u-KJy7HqI,1531
 tests/__init__.py,sha256=QMXatjFn0cwLVfV0syJuu_di6qEr8qYe-WwhwUBssLg,32
 tests/conftest.py,sha256=sPZrGyQIdS6-i9LGbXOors23BId5p7TCoyJaF8whxOw,441
 tests/test_circular_imports.py,sha256=S94K4RRKggn_9rJutfyTXBTMtPxbG3DQNcR6HMHOHdU,14664
@@ -353,7 +355,7 @@ tests/core/test_ions.py,sha256=AXBhG5ANI2cKr1rfzbbFwKFGBghznAXdi3jfOsIZq4M,10434
 tests/core/test_plasma.py,sha256=bI_rDyWpnM2G78M4KRqEfwi82i_xRuqPx4WaNSKTGHA,103241
 tests/core/test_plasma_io.py,sha256=j0TrV5T2rPMcKX7tbIzWO_DWTwmJ96hnwrmazFOGL4k,384
 tests/core/test_quantities.py,sha256=_9cP3HdVr0JMUDABZiwTSnBokSpZbWagqFQ-OSrL2F8,16955
-tests/core/test_spacecraft.py,sha256=jYh1VivdkL4ZnC72WlVamHJr4D_8t8KiY4lrpWqGejE,6815
+tests/core/test_spacecraft.py,sha256=sYXtPVgGaGZoRHP6rgoE8jv-ZdBfbPtYH0Ft0WgNkWM,6855
 tests/core/test_units_constants.py,sha256=Yelx_3F6Q1IH-yOLJDgcsF4khYu6nZhVY7svm3xnHAk,511
 tests/data/epoch.csv,sha256=ILnMSC8BUwtYzOedeldDFOtB4MYEvZgumCT8LZLoa90,72
 tests/data/plasma.csv,sha256=jtT4msNHX_muY7YWRQkWIrqU140nmnLLLstHSoAhs_w,652
@@ -373,6 +375,7 @@ tests/plotting/__init__.py,sha256=5R4PdTYEQvYbU0yuz2a1EcFlzic8QUHnl_ojA9tmFzY,24
 tests/plotting/test_agg_plot.py,sha256=lBrNSgwEHcDtCD6YM8_yV_hFdxlOCCWaxIV_dnF-ZJI,21156
 tests/plotting/test_base.py,sha256=vyHl4vSn71B7BvcFcLNCjc1FCCvELFKcBkbt1PhXSu4,24618
 tests/plotting/test_fixtures_utilities.py,sha256=SvjOixxm-eXvSkEtjOAMVn_UmHKkEB2Kc9W0fI7ZzlU,25483
+tests/plotting/test_hist2d_pandas_compat.py,sha256=RYm9xCc7XyHv8AJffcfH3Kqrr9Y3bg2dEMYD5rIqsO0,15205
 tests/plotting/test_histograms.py,sha256=QSyA0lgc8x8t5Niwtuqveco8DV8kGHfEoV5ZhAjNfRk,20007
 tests/plotting/test_integration.py,sha256=_YNuQ2x_7gx_m2-8JWOmMBrJimalFll53-phEtb1yjU,22964
 tests/plotting/test_orbits.py,sha256=AjS5mk-69LjmJvnrIcX3NcQW6dyVGEy0ZmeoYhQ79Ws,16381
@@ -381,7 +384,7 @@ tests/plotting/test_scatter.py,sha256=Neco0LuCsRfDB7nwyMSQsnqxlvpUi2lCRZlkXGQZ2u
 tests/plotting/test_select_data_from_figure.py,sha256=Ndz-mtsB8FZXrzOb8IWhMynWhpt8CqaQSOKVpugK_co,42427
 tests/plotting/test_spiral.py,sha256=GrKRxjdIa5f9wnS0EZtkjS13h5OW8mvBIlgZY7UtSfY,20494
 tests/plotting/test_tools.py,sha256=fptKZFwCMq5vOIeoZikTqoXI87dGr_kiOwAEXTVX_vE,20383
-tests/plotting/test_visual_validation.py,sha256=Sp7IMBaGKQM6ja4cIuGDa9MPhmwlmRJfPEOPIOjTYkQ,14692
+tests/plotting/test_visual_validation.py,sha256=rRu_Fj1d22GIG6k1ByC2-nCKgO5ONuETsaLcSaSDEE8,14700
 tests/plotting/labels/__init__.py,sha256=p1Ttswdbhq9cxnuaQlQ1LSPbb-92OBwzLlWcCz5ACFg,24
 tests/plotting/labels/test_chemistry.py,sha256=AawZXmN3f72NKrkgybDm342NvepKLS55-jaNDRsjjmE,7950
 tests/plotting/labels/test_composition.py,sha256=ps1Mnmey8UfxvCs-mNR1P-1j9kgf2ImLO7gX3PmuEw0,11939
@@ -403,7 +406,7 @@ tests/solar_activity/sunspot_number/test_sidc.py,sha256=VDTC3KIZNrs8HqSp7qNnz1K4
 tests/solar_activity/sunspot_number/test_sidc_id.py,sha256=xP_dLw99dPxAKhW-YqcextUAvNNLrRC9VgWVm0JxBPo,8153
 tests/solar_activity/sunspot_number/test_sidc_loader.py,sha256=4LmOmyt9OLas2oUT9iOa7TQ8bn5iyB9a_HqupIH05OQ,10271
 tests/solar_activity/sunspot_number/test_ssn_extrema.py,sha256=KOliGq5ErhKYWp_qbXmBqZU4EmHS-bOgmBcAngIkQfQ,14747
-solarwindpy-0.1.2.dist-info/METADATA,sha256=d1glzMiPkgHzEoWLcDCZOkn4V5eRRKSyYhb5Co2Mkj8,6336
-solarwindpy-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-solarwindpy-0.1.2.dist-info/top_level.txt,sha256=kKjGFlQvA-UE4SpU-m7df_Y1_eGhtRs_eqy6Gq96v8c,24
-solarwindpy-0.1.2.dist-info/RECORD,,
+solarwindpy-0.1.4.dist-info/METADATA,sha256=8QgE83e8dUPDpgXWvvit0dxiwmc-Gmx7BoEorRfCjXA,6688
+solarwindpy-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+solarwindpy-0.1.4.dist-info/top_level.txt,sha256=kKjGFlQvA-UE4SpU-m7df_Y1_eGhtRs_eqy6Gq96v8c,24
+solarwindpy-0.1.4.dist-info/RECORD,,

tests/core/test_spacecraft.py

@@ -16,7 +16,7 @@ from solarwindpy import spacecraft
 pd.set_option("mode.chained_assignment", "raise")
 
 
-class TestBase(ABC):
+class SpacecraftTestBase(ABC):
     @classmethod
     def setUpClass(cls):
         data = base.TestData()
@@ -47,7 +47,7 @@ class TestBase(ABC):
     #         cls.set_object_testing()
     #         print("Done with TestBase", flush=True)
 
-    #         super(TestBase, cls).setUpClass()
+    #         super(SpacecraftTestBase, cls).setUpClass()
     #         # print(cls.data.iloc[:, :7])
     #         # print(cls.data.columns.values)
     #         cls.data = cls.spacecraft_data
@@ -127,7 +127,7 @@ class TestBase(ABC):
         pdt.assert_series_equal(dist, ot.distance2sun)
 
 
-class TestWind(TestBase, TestCase):
+class TestWind(SpacecraftTestBase, TestCase):
     @classmethod
     def set_object_testing(cls):
         data = cls.data.xs("gse", axis=1, level="M")
@@ -164,7 +164,7 @@ class TestWind(TestBase, TestCase):
             self.object_testing.carrington
 
 
-class TestPSP(TestBase, TestCase):
+class TestPSP(SpacecraftTestBase, TestCase):
     @classmethod
     def set_object_testing(cls):
         p = cls.data.xs("pos_HCI", axis=1, level="M")

tests/plotting/test_hist2d_pandas_compat.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python
+"""Regression tests for pandas 2.3.1+ compatibility in hist2d.py.
+
+These tests verify that the axis normalization methods work correctly
+after replacing deprecated .max(level=...) syntax with .groupby(level=...).max().
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from solarwindpy.plotting.hist2d import Hist2D
+
+
+class TestHist2DPandasCompatibility:
+    """Test pandas 2.3.1+ compatibility for Hist2D axis normalization."""
+
+    def setup_method(self):
+        """Set up test data for each test."""
+        np.random.seed(42)
+        n = 1000
+
+        # Create test data with known distributions
+        self.x_data = pd.Series(np.random.normal(0, 1, n), name="x")
+        self.y_data = pd.Series(np.random.normal(0, 1, n), name="y")
+        self.z_data = pd.Series(np.random.uniform(0, 10, n), name="z")
+
+    def test_column_normalize(self):
+        """Test column normalize (axnorm='c')."""
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("c")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+        agg_unstacked = agg.unstack("x")
+
+        # Check that max value in each column is 1.0 (or NaN)
+        for col in agg_unstacked.columns:
+            col_max = agg_unstacked[col].max()
+            if not pd.isna(col_max):
+                assert np.isclose(
+                    col_max, 1.0, atol=1e-10
+                ), f"Column {col} max is {col_max}, expected 1.0"
+
+        # Check that all non-NaN values are between 0 and 1
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after column normalization"
+        assert (
+            non_nan_values <= 1.0001
+        ).all(), "Found values > 1 after column normalization"
+
+    def test_row_normalize(self):
+        """Test row normalize (axnorm='r')."""
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("r")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+        agg_unstacked = agg.unstack("x")
+
+        # Check that max value in each row is 1.0 (or NaN)
+        for row_idx in agg_unstacked.index:
+            row_max = agg_unstacked.loc[row_idx].max()
+            if not pd.isna(row_max):
+                assert np.isclose(
+                    row_max, 1.0, atol=1e-10
+                ), f"Row {row_idx} max is {row_max}, expected 1.0"
+
+        # Check that all non-NaN values are between 0 and 1
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after row normalization"
+        assert (
+            non_nan_values <= 1.0001
+        ).all(), "Found values > 1 after row normalization"
+
+    def test_total_normalize(self):
+        """Test total normalize (axnorm='t')."""
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("t")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+
+        # Check that max value overall is 1.0
+        max_val = agg.max()
+        assert np.isclose(
+            max_val, 1.0, atol=1e-10
+        ), f"Total max is {max_val}, expected 1.0"
+
+        # Check that all non-NaN values are between 0 and 1
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after total normalization"
+        assert (
+            non_nan_values <= 1.0001
+        ).all(), "Found values > 1 after total normalization"
+
+    def test_density_normalize(self):
+        """Test density normalize (axnorm='d').
+
+        This should create a true 2D probability density function where
+        the integral over the entire domain equals 1.
+        """
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("d")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+
+        # Get bin widths for integration
+        x_intervals = hist.intervals["x"]
+        y_intervals = hist.intervals["y"]
+
+        # Calculate dx and dy for each bin
+        dx_values = pd.Series(
+            [interval.length for interval in x_intervals], index=x_intervals
+        )
+        dy_values = pd.Series(
+            [interval.length for interval in y_intervals], index=y_intervals
+        )
+
+        # Compute the integral: sum(agg * dx * dy)
+        agg_unstacked = agg.unstack("x")
+        total_integral = 0
+        for y_idx, y_interval in enumerate(agg_unstacked.index):
+            for x_idx, x_interval in enumerate(agg_unstacked.columns):
+                value = agg_unstacked.iloc[y_idx, x_idx]
+                if not pd.isna(value):
+                    dx = dx_values[x_interval]
+                    dy = dy_values[y_interval]
+                    total_integral += value * dx * dy
+
+        # The integral should be close to 1
+        assert np.isclose(
+            total_integral, 1.0, atol=0.01
+        ), f"Density integral is {total_integral}, expected 1.0"
+
+        # Values should be non-negative
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after density normalization"
+
+    def test_pdfs_in_each_column(self):
+        """Test PDFs in each column (axnorm='cd').
+
+        This creates PDFs in each column, so integrating over y for each x should give 1.
+        """
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("cd")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+        agg_unstacked = agg.unstack("x")
+
+        # Get y bin widths for integration
+        y_intervals = hist.intervals["y"]
+        dy_values = pd.Series(
+            [interval.length for interval in y_intervals], index=y_intervals
+        )
+
+        # For each column, integrate over y
+        for col in agg_unstacked.columns:
+            col_data = agg_unstacked[col]
+            integral = 0
+            for y_idx, y_interval in enumerate(col_data.index):
+                value = col_data.iloc[y_idx]
+                if not pd.isna(value):
+                    dy = dy_values[y_interval]
+                    integral += value * dy
+
+            # Each column should integrate to 1 (if it has data)
+            if integral > 0:  # Only check columns with data
+                assert np.isclose(
+                    integral, 1.0, atol=0.01
+                ), f"Column {col} PDF integral is {integral}, expected 1.0"
+
+        # Values should be non-negative
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after PDFs in each column"
+
+    def test_pdfs_in_each_row(self):
+        """Test PDFs in each row (axnorm='rd').
+
+        This creates PDFs in each row, so integrating over x for each y should give 1.
+        """
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm("rd")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+        agg_unstacked = agg.unstack("x")
+
+        # Get x bin widths for integration
+        x_intervals = hist.intervals["x"]
+        dx_values = pd.Series(
+            [interval.length for interval in x_intervals], index=x_intervals
+        )
+
+        # For each row, integrate over x
+        for row in agg_unstacked.index:
+            row_data = agg_unstacked.loc[row]
+            integral = 0
+            for x_idx, x_interval in enumerate(row_data.index):
+                value = row_data.iloc[x_idx]
+                if not pd.isna(value):
+                    dx = dx_values[x_interval]
+                    integral += value * dx
+
+            # Each row should integrate to 1 (if it has data)
+            if integral > 0:  # Only check rows with data
+                assert np.isclose(
+                    integral, 1.0, atol=0.01
+                ), f"Row {row} PDF integral is {integral}, expected 1.0"
+
+        # Values should be non-negative
+        non_nan_values = agg.dropna()
+        assert (
+            non_nan_values >= 0
+        ).all(), "Found negative values after PDFs in each row"
+
+    def test_no_normalization(self):
+        """Test that no normalization (axnorm=None) works correctly."""
+        hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+        hist.set_axnorm(None)
+
+        # Get aggregation without normalization
+        agg = hist.agg()
+
+        # Values should be the raw aggregated z values
+        assert agg is not None
+        assert not agg.isna().all(), "All values are NaN without normalization"
+
+        # Check that values are in reasonable range for raw z data (0-10)
+        non_nan_values = agg.dropna()
+        assert non_nan_values.min() >= 0, "Found negative values in raw aggregation"
+        assert (
+            non_nan_values.max() <= 10.1
+        ), "Found unexpectedly large values in raw aggregation"
+
+    def test_edge_case_single_bin(self):
+        """Test normalization with data that falls into a single bin."""
+        # Create data that falls into one bin
+        x_single = pd.Series([0.5] * 100, name="x")
+        y_single = pd.Series([0.5] * 100, name="y")
+        z_single = pd.Series(np.random.uniform(1, 2, 100), name="z")
+
+        hist = Hist2D(x_single, y_single, z_single, nbins=10)
+        hist.set_axnorm("c")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+
+        # Should have mostly NaN except for the single bin
+        non_nan_count = agg.notna().sum()
+        assert non_nan_count == 1, f"Expected 1 non-NaN value, got {non_nan_count}"
+
+        # The single value should be 1.0 after normalization
+        non_nan_value = agg.dropna().iloc[0]
+        assert np.isclose(
+            non_nan_value, 1.0, atol=1e-10
+        ), f"Single bin value is {non_nan_value}, expected 1.0"
+
+    def test_edge_case_with_nans(self):
+        """Test normalization with NaN values in input data."""
+        # Add some NaN values to the data
+        x_with_nan = self.x_data.copy()
+        y_with_nan = self.y_data.copy()
+        z_with_nan = self.z_data.copy()
+
+        # Insert NaNs at random positions
+        nan_indices = np.random.choice(len(x_with_nan), 50, replace=False)
+        x_with_nan.iloc[nan_indices] = np.nan
+        y_with_nan.iloc[nan_indices[:25]] = np.nan
+        z_with_nan.iloc[nan_indices[25:]] = np.nan
+
+        hist = Hist2D(x_with_nan, y_with_nan, z_with_nan, nbins=10)
+        hist.set_axnorm("c")
+
+        # Should handle NaNs gracefully
+        agg = hist.agg()
+        assert agg is not None
+
+        # Check that non-NaN values are properly normalized
+        non_nan_values = agg.dropna()
+        if len(non_nan_values) > 0:
+            assert (non_nan_values >= 0).all(), "Found negative values with NaN input"
+            assert (non_nan_values <= 1.0001).all(), "Found values > 1 with NaN input"
+
+    def test_count_aggregation_with_column_normalize(self):
+        """Test column normalize with count aggregation (no z values)."""
+        # Create hist2d without z values (count aggregation)
+        hist = Hist2D(self.x_data, self.y_data, nbins=10)
+        hist.set_axnorm("c")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+        agg_unstacked = agg.unstack("x")
+
+        # Check that max value in each column is 1.0 (or NaN)
+        for col in agg_unstacked.columns:
+            col_max = agg_unstacked[col].max()
+            if not pd.isna(col_max):
+                assert np.isclose(
+                    col_max, 1.0, atol=1e-10
+                ), f"Column {col} max is {col_max}, expected 1.0"
+
+    def test_log_scale_with_normalization(self):
+        """Test normalization with log-scaled data."""
+        # Use positive data for log scale
+        x_positive = pd.Series(np.random.uniform(1, 100, 1000), name="x")
+        y_positive = pd.Series(np.random.uniform(1, 100, 1000), name="y")
+        z_positive = pd.Series(np.random.uniform(1, 10, 1000), name="z")
+
+        hist = Hist2D(
+            x_positive, y_positive, z_positive, nbins=10, logx=True, logy=True
+        )
+        hist.set_axnorm("c")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+
+        # Check normalization works with log scale
+        assert agg is not None
+        assert not agg.isna().all(), "All values are NaN with log scale"
+
+        # Check that values are properly normalized
+        non_nan_values = agg.dropna()
+        assert (non_nan_values >= 0).all(), "Found negative values with log scale"
+        assert (non_nan_values <= 1.0001).all(), "Found values > 1 with log scale"
+
+    def test_all_documented_normalizations(self):
+        """Test that all documented normalization options work without error."""
+        documented_options = [
+            (None, "no normalization"),
+            ("c", "column normalize"),
+            ("r", "row normalize"),
+            ("t", "total normalize"),
+            ("d", "density normalize"),
+            ("cd", "PDFs in each column"),
+            ("rd", "PDFs in each row"),
+        ]
+
+        for option, description in documented_options:
+            hist = Hist2D(self.x_data, self.y_data, self.z_data, nbins=10)
+            hist.set_axnorm(option)
+
+            # Should be able to get aggregation without error
+            agg = hist.agg()
+            assert (
+                agg is not None
+            ), f"Failed to get aggregation with axnorm={option} ({description})"
+
+            # Should have at least some non-NaN values
+            if option is not None:  # None means no normalization
+                non_nan_count = agg.notna().sum()
+                assert (
+                    non_nan_count > 0
+                ), f"No non-NaN values with axnorm={option} ({description})"
+
+    def test_density_normalize_with_counts(self):
+        """Test density normalize with count data (no z values).
+
+        This should create a proper 2D probability density where integral = 1.
+        """
+        hist = Hist2D(self.x_data, self.y_data, nbins=10)
+        hist.set_axnorm("d")
+
+        # Get normalized aggregation
+        agg = hist.agg()
+
+        # Get bin widths for integration
+        x_intervals = hist.intervals["x"]
+        y_intervals = hist.intervals["y"]
+
+        # Calculate dx and dy for each bin
+        dx_values = pd.Series(
+            [interval.length for interval in x_intervals], index=x_intervals
+        )
+        dy_values = pd.Series(
+            [interval.length for interval in y_intervals], index=y_intervals
+        )
+
+        # Compute the integral
+        agg_unstacked = agg.unstack("x")
+        total_integral = 0
+        for y_idx, y_interval in enumerate(agg_unstacked.index):
+            for x_idx, x_interval in enumerate(agg_unstacked.columns):
+                value = agg_unstacked.iloc[y_idx, x_idx]
+                if not pd.isna(value):
+                    dx = dx_values[x_interval]
+                    dy = dy_values[y_interval]
+                    total_integral += value * dx * dy
+
+        # The integral should be close to 1
+        assert np.isclose(
+            total_integral, 1.0, atol=0.01
+        ), f"Count density integral is {total_integral}, expected 1.0"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/plotting/test_visual_validation.py

@@ -22,7 +22,7 @@ class TestVisualValidationFramework:
     def test_matplotlib_backend(self):
         """Test matplotlib backend is properly configured."""
         backend = matplotlib.get_backend()
-        assert backend == "Agg", f"Expected Agg backend, got {backend}"
+        assert backend.lower() == "agg", f"Expected Agg backend, got {backend}"
 
     def test_matplotlib_interactive_mode(self):
         """Test matplotlib interactive mode is disabled."""