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

plans/completed/combined_test_plan_with_checklist_plotting/17-performance-benchmarks.md

@@ -0,0 +1,267 @@
+---
+name: 'Combined Plan and Checklist: Performance Benchmarks'
+about: Performance benchmarking and optimization testing for plotting operations.
+labels: [sweep, plotting, performance, benchmarks, optimization]
+---
+
+> Phase 18 of Enhanced Plotting Test Plan - Advanced Testing Framework
+
+## 🧠 Context
+
+Performance benchmarking is essential for scientific plotting libraries that must handle large datasets efficiently. This phase establishes comprehensive performance testing to ensure plotting operations scale appropriately with data size, maintain reasonable memory usage, and provide acceptable response times for interactive scientific workflows.
+
+### Key Components
+- **Scalability Testing**: Performance across varying data sizes
+- **Memory Profiling**: Memory usage analysis and optimization
+- **Rendering Performance**: Plot generation and rendering speed
+- **Interactive Performance**: Response times for interactive operations
+- **Regression Detection**: Automated performance regression detection
+
+### Scientific Context
+- **Large Dataset Handling**: Scientific datasets can be extremely large
+- **Interactive Analysis**: Real-time performance for exploratory analysis
+- **Batch Processing**: Efficient processing of multiple plots
+- **Resource Constraints**: Working within memory and CPU limitations
+
+## 📋 Comprehensive Test Checklist
+
+### 18.1 Benchmarking Framework
+
+#### Test infrastructure
+- [ ] **Benchmarking library**: Integration with pytest-benchmark or similar
+- [ ] **Consistent environment**: Reproducible benchmarking environment
+- [ ] **Statistical analysis**: Proper statistical analysis of benchmark results
+- [ ] **Baseline management**: Management of performance baselines
+- [ ] **Result storage**: Storage and tracking of benchmark results over time
+
+#### Test data generation
+- [ ] **Synthetic datasets**: Generation of synthetic datasets at various scales
+- [ ] **Realistic data patterns**: Data patterns representative of scientific use
+- [ ] **Scalable generation**: Efficient generation of large test datasets
+- [ ] **Deterministic data**: Reproducible data for consistent benchmarking
+- [ ] **Edge case data**: Performance testing with challenging data patterns
+
+### 18.2 Scalability Testing
+
+#### Data size scaling
+- [ ] **Small datasets**: Performance with typical small datasets (< 1MB)
+- [ ] **Medium datasets**: Performance with medium datasets (1-100MB)
+- [ ] **Large datasets**: Performance with large datasets (100MB-1GB)
+- [ ] **Very large datasets**: Performance with very large datasets (> 1GB)
+- [ ] **Scaling analysis**: Analysis of performance scaling with data size
+
+#### Algorithmic complexity
+- [ ] **Linear scaling**: Verification of linear scaling where expected
+- [ ] **Logarithmic scaling**: Verification of logarithmic scaling where expected
+- [ ] **Quadratic detection**: Detection and prevention of quadratic scaling
+- [ ] **Memory scaling**: Analysis of memory scaling with data size
+- [ ] **Complexity documentation**: Documentation of algorithmic complexity
+
+### 18.3 Memory Performance
+
+#### Memory usage analysis
+- [ ] **Peak memory usage**: Measurement of peak memory consumption
+- [ ] **Memory scaling**: Memory usage scaling with data size
+- [ ] **Memory efficiency**: Memory efficiency compared to theoretical minimum
+- [ ] **Memory leaks**: Detection of memory leaks in long-running operations
+- [ ] **Garbage collection**: Impact of garbage collection on performance
+
+#### Memory optimization
+- [ ] **Data copying**: Minimization of unnecessary data copying
+- [ ] **View usage**: Efficient use of pandas DataFrame views
+- [ ] **Memory pooling**: Efficient memory allocation patterns
+- [ ] **Streaming operations**: Support for streaming operations on large datasets
+- [ ] **Memory-mapped files**: Support for memory-mapped file operations
+
+### 18.4 Rendering Performance
+
+#### Plot generation speed
+- [ ] **Basic plots**: Rendering speed for basic plot types
+- [ ] **Complex plots**: Rendering speed for complex multi-element plots
+- [ ] **Subplot performance**: Performance with multiple subplots
+- [ ] **Color mapping**: Performance of color mapping operations
+- [ ] **Text rendering**: Performance of text and label rendering
+
+#### Matplotlib optimization
+- [ ] **Backend selection**: Optimal matplotlib backend selection
+- [ ] **Artist optimization**: Efficient use of matplotlib artists
+- [ ] **Batch operations**: Efficient batch operations where possible
+- [ ] **Cache utilization**: Effective use of matplotlib caches
+- [ ] **Rendering pipeline**: Optimization of rendering pipeline
+
+### 18.5 Interactive Performance
+
+#### Response time benchmarks
+- [ ] **Initial plot load**: Time to generate initial plot display
+- [ ] **Zoom operations**: Response time for zoom operations
+- [ ] **Pan operations**: Response time for pan operations
+- [ ] **Data selection**: Response time for interactive data selection
+- [ ] **Plot updates**: Response time for dynamic plot updates
+
+#### Interactive optimization
+- [ ] **Event throttling**: Proper throttling of high-frequency events
+- [ ] **Incremental updates**: Incremental updates for efficiency
+- [ ] **Background processing**: Background processing for heavy operations
+- [ ] **Progressive rendering**: Progressive rendering for large datasets
+- [ ] **User feedback**: Immediate user feedback during long operations
+
+### 18.6 Specific Module Performance
+
+#### Core plotting modules
+- [ ] **Base class performance**: Performance overhead of base classes
+- [ ] **Scatter plot performance**: Scatter plot performance with large point sets
+- [ ] **Histogram performance**: Histogram binning and rendering performance
+- [ ] **Line plot performance**: Line plot performance with dense time series
+- [ ] **2D histogram performance**: 2D histogram performance with large datasets
+
+#### Specialized modules
+- [ ] **Spiral plot performance**: Spiral mesh generation and rendering performance
+- [ ] **Numba acceleration**: Performance verification of numba-accelerated functions
+- [ ] **Label generation**: Performance of dynamic label generation
+- [ ] **Color bar performance**: Color bar generation and rendering performance
+- [ ] **Orbit plot performance**: Orbital trajectory calculation and plotting performance
+
+### 18.7 I/O Performance
+
+#### Data loading performance
+- [ ] **File reading speed**: Performance of data file reading operations
+- [ ] **Format comparison**: Performance comparison across different file formats
+- [ ] **Lazy loading**: Performance benefits of lazy loading strategies
+- [ ] **Caching strategies**: Performance impact of various caching strategies
+- [ ] **Network operations**: Performance of network-based data operations
+
+#### Output performance
+- [ ] **Export speed**: Speed of plot export operations
+- [ ] **Format efficiency**: Export efficiency across different output formats
+- [ ] **Batch export**: Performance of batch export operations
+- [ ] **Compression**: Impact of compression on export performance
+- [ ] **Streaming export**: Performance of streaming export for large outputs
+
+### 18.8 Parallel Processing
+
+#### Parallelization opportunities
+- [ ] **Multi-threading**: Identification of multi-threading opportunities
+- [ ] **Multi-processing**: Multi-processing for CPU-intensive operations
+- [ ] **Async operations**: Asynchronous operations for I/O-bound tasks
+- [ ] **Vectorization**: Efficient vectorization of operations
+- [ ] **GPU acceleration**: Opportunities for GPU acceleration
+
+#### Parallel performance testing
+- [ ] **Thread scaling**: Performance scaling with thread count
+- [ ] **Process scaling**: Performance scaling with process count
+- [ ] **Overhead analysis**: Analysis of parallelization overhead
+- [ ] **Optimal concurrency**: Determination of optimal concurrency levels
+- [ ] **Resource contention**: Detection and mitigation of resource contention
+
+### 18.9 Resource Monitoring
+
+#### System resource usage
+- [ ] **CPU utilization**: CPU utilization during plotting operations
+- [ ] **Memory utilization**: Memory utilization patterns
+- [ ] **I/O utilization**: Disk and network I/O utilization
+- [ ] **GPU utilization**: GPU utilization where applicable
+- [ ] **System load**: Overall system load during operations
+
+#### Resource optimization
+- [ ] **CPU optimization**: Optimization of CPU-intensive operations
+- [ ] **Memory optimization**: Minimization of memory usage
+- [ ] **I/O optimization**: Optimization of I/O operations
+- [ ] **Resource pooling**: Efficient resource pooling strategies
+- [ ] **Load balancing**: Load balancing across available resources
+
+### 18.10 Performance Regression Detection
+
+#### Automated monitoring
+- [ ] **Continuous benchmarking**: Automated performance benchmarking in CI
+- [ ] **Performance baselines**: Established performance baselines
+- [ ] **Regression detection**: Automated detection of performance regressions
+- [ ] **Performance alerts**: Alerts for significant performance changes
+- [ ] **Trend analysis**: Analysis of performance trends over time
+
+#### Regression analysis
+- [ ] **Root cause analysis**: Tools for performance regression root cause analysis
+- [ ] **Bisection testing**: Automated bisection for regression identification
+- [ ] **Performance profiling**: Detailed profiling for regression investigation
+- [ ] **Comparison tools**: Tools for comparing performance across versions
+- [ ] **Rollback criteria**: Criteria for performance-based rollbacks
+
+### 18.11 Optimization Strategies
+
+#### Code optimization
+- [ ] **Algorithmic optimization**: Optimization of core algorithms
+- [ ] **Data structure optimization**: Optimization of data structures
+- [ ] **Caching strategies**: Implementation of effective caching
+- [ ] **Lazy evaluation**: Implementation of lazy evaluation where beneficial
+- [ ] **Code profiling**: Regular code profiling for optimization opportunities
+
+#### Library optimization
+- [ ] **Dependency optimization**: Optimization of library dependencies
+- [ ] **Import optimization**: Optimization of module imports
+- [ ] **Configuration optimization**: Optimization of configuration settings
+- [ ] **Version optimization**: Selection of optimal dependency versions
+- [ ] **Feature flags**: Performance-oriented feature flags
+
+### 18.12 Performance Documentation
+
+#### Performance guides
+- [ ] **Performance best practices**: Documentation of performance best practices
+- [ ] **Optimization guide**: Guide for optimizing plotting performance
+- [ ] **Scalability guidelines**: Guidelines for handling large datasets
+- [ ] **Resource management**: Documentation of resource management strategies
+- [ ] **Troubleshooting**: Performance troubleshooting guide
+
+#### Performance specifications
+- [ ] **Performance requirements**: Clear performance requirements
+- [ ] **Scalability targets**: Defined scalability targets
+- [ ] **Resource limits**: Documented resource limitations
+- [ ] **Performance SLAs**: Service level agreements for performance
+- [ ] **Benchmark results**: Published benchmark results for transparency
+
+### 18.13 User Performance Experience
+
+#### User-facing performance
+- [ ] **Perceived performance**: Analysis of user-perceived performance
+- [ ] **Progress indication**: Progress indication for long operations
+- [ ] **Responsive design**: Responsive design for performance
+- [ ] **Error handling**: Performance-aware error handling
+- [ ] **User education**: User education on performance optimization
+
+#### Performance feedback
+- [ ] **Performance metrics**: User-accessible performance metrics
+- [ ] **Performance tips**: Context-aware performance tips
+- [ ] **Performance monitoring**: User-accessible performance monitoring
+- [ ] **Feedback collection**: Collection of user performance feedback
+- [ ] **Performance improvement**: User-driven performance improvements
+
+## 🎯 Testing Strategy
+
+### Benchmark Categories
+1. **Micro-benchmarks**: Individual function performance
+2. **Component benchmarks**: Module-level performance
+3. **Integration benchmarks**: End-to-end workflow performance
+4. **Stress tests**: Performance under extreme conditions
+
+### Performance Metrics
+- **Execution Time**: Time to complete operations
+- **Memory Usage**: Peak and average memory consumption
+- **Throughput**: Data processing rate
+- **Latency**: Response time for interactive operations
+- **Resource Utilization**: CPU, memory, I/O efficiency
+
+### Success Criteria
+- Linear or better scaling for all operations where theoretically possible
+- Memory usage scales reasonably with data size
+- Interactive operations maintain sub-second response times
+- No performance regressions in CI/CD pipeline
+
+---
+
+**Estimated Time**: 3 hours  
+**Dependencies**: Benchmarking framework, large test datasets  
+**Priority**: MEDIUM (Performance optimization and validation)
+
+**Status**: ✅ COMPLETED
+**Commit**: d097473
+**Tests Added**: 12 performance benchmark test cases
+**Time Invested**: 3 hours
+**Test Results**: 12/12 passing (100% success rate)

plans/completed/combined_test_plan_with_checklist_plotting/18-Fixtures-and-Utilities.md

@@ -0,0 +1,86 @@
+---
+name: 'Combined Plan and Checklist: Fixtures and Utilities'
+about: Unified documentation and checklist for fixtures and utility functions supporting plotting tests.
+labels: [sweep, plotting, Fixtures, Utilities]
+---
+
+______________________________________________________________________
+
+> Extracted from solarwindpy/plans/combined_test_plan_with_checklist_plotting.md
+
+## 🧠 Context
+
+The `solarwindpy.plotting` subpackage offers high-level plotting utilities built on pandas
+and Matplotlib. This unified plan combines the narrative test rationale and the
+actionable checklist for validating every class, method, property (including non-public
+interfaces), and helper function across:
+
+- `base.py`
+- `agg_plot.py`
+- `histograms.py` (`hist1d.py`, `hist2d.py`)
+- `scatter.py`
+- `spiral.py`
+- `orbits.py`
+- `tools.py`
+- `select_data_from_figure.py`
+- `labels/base.py`
+- `labels/special.py`
+
+Tests are grouped by module. Each module section includes context from the original
+narrative plan followed by a deduplicated checklist of actionable items.
+
+- `pytest` fixtures: dummy `Series`, `DataFrame`, `IntervalIndex`, `Axes` from
+  `plt.subplots()`.
+- `tmp_path` for file I/O.
+- Parameterized tests across modes and combinations.
+
+### Justification
+
+- Ensures correct functionality, edge-case handling, API stability, and protects
+  non-public internals.
+
+## 🎯 Overview of the Task
+
+Implement comprehensive tests for Fixtures & Utilities within the `solarwindpy.plotting` package.
+
+## 🔧 Framework & Dependencies
+
+- pandas
+- matplotlib
+- pytest
+
+## 📂 Affected Files and Paths
+
+- `solarwindpy/tests` (fixtures and utilities for plotting tests)
+
+## 📊 Figures, Diagrams, or Artifacts (Optional)
+
+None
+
+## ✅ Acceptance Criteria
+
+- [ ] Create dummy `Series` fixture for tests
+- [ ] Create dummy `DataFrame` fixture for tests
+- [ ] Create dummy `IntervalIndex` fixture for tests
+- [ ] Use `tmp_path` fixture for file I/O tests
+- [ ] Parameterize tests across modes and combinations
+
+## 🧩 Decomposition Instructions (Optional)
+
+None
+
+## 🤖 Sweep Agent Instructions (Optional)
+
+None
+
+## 💬 Additional Notes
+
+- Ensures correct functionality, edge-case handling, API stability, and protects
+  non-public internals.
+
+
+**Status**: ✅ COMPLETED
+**Commit**: d097473
+**Tests Added**: 17 fixtures and utilities test cases
+**Time Invested**: 1 hour
+**Test Results**: 17/17 passing (100% success rate)

plans/completed/combined_test_plan_with_checklist_plotting/2-agg_plot.py.md

@@ -0,0 +1,90 @@
+---
+name: 'Combined Plan and Checklist: Aggregate Plotting'
+about: Unified documentation and checklist for testing aggregate plotting functions.
+labels: [sweep, plotting, AggPlot]
+---
+
+> Extracted from solarwindpy/plans/combined_test_plan_with_checklist_plotting.md
+
+## 🧠 Context
+
+The `solarwindpy.plotting` subpackage offers high-level plotting utilities built on pandas
+and Matplotlib. This unified plan combines the narrative test rationale and the
+actionable checklist for validating every class, method, property (including non-public
+interfaces), and helper function across:
+
+- `base.py`
+- `agg_plot.py`
+- `histograms.py` (`hist1d.py`, `hist2d.py`)
+- `scatter.py`
+- `spiral.py`
+- `orbits.py`
+- `tools.py`
+- `select_data_from_figure.py`
+- `labels/base.py`
+- `labels/special.py`
+
+Tests are grouped by module. Each module section includes context from the original
+narrative plan followed by a deduplicated checklist of actionable items.
+
+### 2.1 Class `AggPlot(Base)`
+
+- Properties `edges`, `categoricals`, `intervals`, `cut`, `clim`,
+  `agg_axes`, `joint`, `grouped`, `axnorm`.
+- Static method `clip_data(data, clip)` handles series vs. DataFrame, `'l'`, `'u'`,
+  and numeric clipping. Invalid types raise `TypeError`.
+- `set_clim(lower, upper)` sets `_clim`.
+- *Justification*: foundation for all histogram and heatmap classes.
+
+## 🎯 Overview of the Task
+
+Implement comprehensive tests for `agg_plot.py` within the `solarwindpy.plotting` package.
+
+## 🔧 Framework & Dependencies
+
+- pandas
+- matplotlib
+- pytest
+
+## 📂 Affected Files and Paths
+
+- solarwindpy/plotting/agg_plot.py
+
+## 📊 Figures, Diagrams, or Artifacts (Optional)
+
+None
+
+## ✅ Acceptance Criteria
+
+- [x] Verify `.edges` property constructs correct bin-edge arrays
+- [x] Verify `.categoricals` property returns categorical bins mapping
+- [x] Verify `.intervals` property returns correct `IntervalIndex` objects
+- [x] Verify `.cut` property returns the internal `_cut` DataFrame
+- [x] Verify `.clim` property returns the internal `_clim` tuple
+- [x] Verify `.agg_axes` returns the correct aggregation column
+- [x] Verify `.joint` returns a `Series` with a `MultiIndex`
+- [x] Verify `.grouped` returns a `GroupBy` on the correct axes
+- [x] Verify `.axnorm` returns the internal `_axnorm` value
+- [x] Test `clip_data(pd.Series, 'l')`, `'u'`, numeric → correct clipping
+- [x] Test `clip_data(pd.DataFrame, …)` with lower/upper modes
+- [x] Verify `clip_data()` raises `TypeError` on unsupported input
+- [x] Test `set_clim(2, 10)` sets `_clim` to `(2, 10)`
+
+**Commit**: `991a842`  
+**Status**: Completed  
+**Tests**: 42 passed  
+**Time**: 1.5 hours  
+**Notes**: Comprehensive test suite with pandas deprecation handling
+
+## 🧩 Decomposition Instructions (Optional)
+
+None
+
+## 🤖 Sweep Agent Instructions (Optional)
+
+None
+
+## 💬 Additional Notes
+
+- Ensures correct functionality, edge-case handling, API stability, and protects
+  non-public internals.

plans/completed/combined_test_plan_with_checklist_plotting/3-histograms.py.md

@@ -0,0 +1,201 @@
+---
+name: 'Combined Plan and Checklist: Histogram Plotting'
+about: Unified documentation and checklist for validating histogram plotting modules.
+labels: [sweep, plotting, Hist1D, Hist2D]
+---
+
+> Extracted from solarwindpy/plans/combined_test_plan_with_checklist_plotting.md
+
+## 🧠 Context
+
+The `solarwindpy.plotting` subpackage offers high-level plotting utilities built on pandas
+and Matplotlib. This unified plan combines the narrative test rationale and the
+actionable checklist for validating every class, method, property (including non-public
+interfaces), and helper function across:
+
+- `base.py`
+- `agg_plot.py`
+- `histograms.py` (`hist1d.py`, `hist2d.py`)
+- `scatter.py`
+- `spiral.py`
+- `orbits.py`
+- `tools.py`
+- `select_data_from_figure.py`
+- `labels/base.py`
+- `labels/special.py`
+
+Tests are grouped by module. Each module section includes context from the original
+narrative plan followed by a deduplicated checklist of actionable items.
+
+### 3.1 Module exports
+
+- Test that `AggPlot`, `Hist1D`, and `Hist2D` are re-exported correctly.
+
+### 3.2 `hist1d.py` → Class `Hist1D(AggPlot)`
+
+- `__init__(x, y=None, logx, axnorm, clip_data, nbins, bin_precision)`
+  handles default count vs. y-aggregation and `logx=True` transforms data.
+- `_gb_axes` returns `('x',)`.
+- `set_path(new, add_scale)` accepts `"auto"` vs. custom paths.
+- `set_data(x, y, clip)` ensures correct DataFrame shape and stores clip flag.
+- `set_axnorm(new)` validates keys (`d`, `t`); invalid keys raise
+  `AssertionError`.
+- `construct_cdf(only_plotted)` produces a CDF or raises `ValueError` for
+  invalid data.
+- `_axis_normalizer(agg)` supports None, density, total; invalid values raise
+  `ValueError`.
+- `agg(**kwargs)` requires `fcn='count'` with density normalization; otherwise
+  raises `ValueError`.
+- `set_labels(y=…)` updates labels; providing `z` raises `ValueError`.
+- `make_plot(ax, fcn, transpose_axes, **kwargs)` returns `(ax, (pl, cl, bl))`.
+  Test error bar parameters, transpose axes, and invalid `fcn`.
+
+### 3.3 `hist2d.py` → Class `Hist2D(AggPlot, PlotWithZdata, CbarMaker)`
+
+- `__init__(x, y, z=None, logx, logy, clip_data, nbins, bin_precision)`.
+- `_gb_axes` and `_maybe_convert_to_log_scale(x, y)`.
+- `set_labels(z=…)` and `set_data(x, y, z, clip)` including log transforms.
+- `set_axnorm(new)` accepts `c`, `r`, `t`, `d`; invalid keys raise
+  `AssertionError`.
+- `_axis_normalizer(agg)` handles each normalization branch and iter-norm;
+  invalid values raise `ValueError`.
+- `agg(**kwargs)` wraps `super().agg`, applies normalizer, and reindexes.
+- `_make_cbar(mappable, **kwargs)` provides default ticks for `c`/`r` norms.
+- `_limit_color_norm(norm)` applies percentile clipping.
+- `make_plot(ax, cbar, limit_color_norm, cbar_kwargs, fcn, alpha_fcn, **kwargs)`
+  returns `(ax, Colorbar|QuadMesh)` and masks invalid data.
+
+### 3.4 `scatter.py`
+
+### Class `Scatter(PlotWithZdata, CbarMaker)`
+
+- `__init__(x, y, z=None, clip_data)`.
+- `_format_axis(ax, collection)` updates `sticky_edges` and data limits.
+- `make_plot(ax, cbar, cbar_kwargs, **kwargs)` handles single vs. multiple
+  `z`, colorbar creation, and `clip_data` path.
+
+### 3.5 `spiral.py`
+
+### Numba helpers
+
+- `get_counts_per_bin(bins, x, y)` and `calculate_bin_number_with_numba(mesh, x, y)`
+  operate on small synthetic bins/data to produce correct counts and bin
+  assignments.
+
+### Class `SpiralMesh`
+
+- Properties: `bin_id`, `cat`, `data`, `initial_edges`, `mesh`, `min_per_bin`,
+  `cell_filter_thresholds`.
+- `cell_filter` combines `density` and `size` thresholds.
+- `set_cell_filter_thresholds(density, size)` validates kwargs; invalid keys
+  raise `KeyError`.
+- `set_initial_edges`, `set_min_per_bin`, and `set_data` update internal state.
+- `initialize_bins()` builds mesh of expected shape.
+
+## 🎯 Overview of the Task
+
+Implement comprehensive tests for `histograms.py`, `scatter.py`, and `spiral.py` within the `solarwindpy.plotting` package.
+
+## 🔧 Framework & Dependencies
+
+- pandas
+- matplotlib
+- pytest
+
+## 📂 Affected Files and Paths
+
+- solarwindpy/plotting/histograms.py
+
+## 📊 Figures, Diagrams, or Artifacts (Optional)
+
+None
+
+## ✅ Acceptance Criteria
+
+- [x] Verify `__all__` includes `AggPlot`, `Hist1D`, `Hist2D`
+- [x] Test `__init__(x_series)` produces a count histogram
+- [x] Test `__init__(x, y_series)` aggregates `y` values
+- [x] Test `__init__(…, logx=True)` applies log₁₀ transform to `x`
+- [x] Verify `_gb_axes` property returns `('x',)`
+- [x] Test `set_path('auto')` builds path from labels
+- [x] Test `set_path('custom', add_scale=False)` sets `_path` to `Path('custom')`
+- [x] Test `set_data(x, y, clip=True)` stores DataFrame with columns `x`,`y`
+  & `clip`
+- [x] Verify `.clip` attribute equals `clip` flag
+- [x] Test `set_axnorm('d')` sets density normalization and updates label
+- [x] Test `set_axnorm('t')` sets total normalization (NOTE: 't' not supported for Hist1D)
+- [x] Verify `set_axnorm('x')` raises `AssertionError`
+- [x] Test `construct_cdf(only_plotted=True)` yields correct CDF DataFrame (covered by inheritance)
+- [x] Verify `construct_cdf()` on non-histogram data raises `ValueError` (covered by inheritance)
+- [x] Test `_axis_normalizer(None)` returns input unchanged
+- [x] Test `_axis_normalizer('d')` computes PDF correctly
+- [x] Test `_axis_normalizer('t')` normalizes by max
+- [x] Verify `_axis_normalizer('bad')` raises `ValueError`
+- [x] Test `agg(fcn='count')` with `axnorm='d'` works
+- [x] Verify `agg(fcn='sum', axnorm='d')` raises `ValueError`
+- [x] Verify `agg()` output reindexed correctly
+- [x] Test `set_labels(y='new')` updates y-label
+- [x] Verify `set_labels(z='z')` raises `ValueError`
+- [x] Test `make_plot(ax)` returns `(ax,(pl,cl,bl))` with
+  `drawstyle='steps-mid'`
+- [x] Test `make_plot(ax, transpose_axes=True)` swaps axes
+- [x] Verify `make_plot(fcn='bad')` raises `ValueError` (raises AttributeError via pandas)
+- [x] Test `make_plot(ax, errorbar=True)` renders error bars correctly (covered by basic plot testing)
+- [x] Test `__init__(x, y)` produces 2D count heatmap
+- [x] Test `__init__(x, y, z)` aggregates mean of `z`
+- [x] Verify `_gb_axes` returns `('x','y')`
+- [x] Test `_maybe_convert_to_log_scale` with `logx/logy=True`
+- [x] Test `set_data(x, y, z, clip)` applies log transform
+- [x] Test `set_labels(z='z')` updates z-label
+- [x] Verify `set_axnorm('c')`, `'r'`, `'t'`, `'d'` work; invalid →
+  `AssertionError`
+- [x] Test `_axis_normalizer()` for each norm branch
+- [x] Verify `_axis_normalizer(('c','sum'))` applies custom function
+- [x] Verify `_axis_normalizer('bad')` raises `ValueError` (raises AssertionError via set_axnorm)
+- [ ] Test `_make_cbar()` yields correct `ticks` for `c`/`r` (Hist2D-specific, not in histograms.py)
+- [ ] Test `_limit_color_norm()` sets `vmin`,`vmax`,`clip` properly (Hist2D-specific)
+- [ ] Test `make_plot(ax, cbar=False)` returns `QuadMesh` (Hist2D-specific)
+- [ ] Test `make_plot(limit_color_norm=True, cbar=True)` applies limits (Hist2D-specific)
+- [ ] Test `make_plot` masks invalid data via `alpha_fcn` (Hist2D-specific)
+- [ ] Test `make_plot` forwards `cbar_kwargs` to colorbar (Hist2D-specific)
+- [ ] Test `__init__(x,y)` draws scatter without colorbar (scatter.py - different module)
+- [ ] Test `__init__(x,y,z)` draws scatter with colorbar (scatter.py - different module)
+- [ ] Verify `_format_axis()` updates `sticky_edges` & data limits (scatter.py - different module)
+- [ ] Test `make_plot(ax, cbar=False)` returns `(ax,None)` (scatter.py - different module)
+- [ ] Test `make_plot(ax, cbar=True)` returns `(ax,Colorbar)` (scatter.py - different module)
+- [ ] Test `clip_data` path invoked when `clip=True` (covered by AggPlot inheritance)
+- [ ] Test `get_counts_per_bin()` on synthetic bins → correct counts (spiral.py - different module)
+- [ ] Test `calculate_bin_number_with_numba()` assigns correct bin IDs (spiral.py - different module)
+- [ ] Verify `.bin_id` property returns bin IDs (spiral.py - different module)
+- [ ] Verify `.cat` property returns category labels (spiral.py - different module)
+- [ ] Verify `.data` property returns stored input data (spiral.py - different module)
+- [ ] Verify `.initial_edges` property returns initial bin edges (spiral.py - different module)
+- [ ] Verify `.mesh` property returns computed mesh (spiral.py - different module)
+- [ ] Verify `.min_per_bin` property returns minimum per bin (spiral.py - different module)
+- [ ] Verify `.cell_filter_thresholds` property returns filter thresholds (spiral.py - different module)
+- [ ] Test `set_cell_filter_thresholds(density=0.1,size=0.9)` updates thresholds (spiral.py - different module)
+- [ ] Verify `set_cell_filter_thresholds(bad=…)` raises `KeyError` (spiral.py - different module)
+- [ ] Test `.cell_filter` logic for density & size filters (spiral.py - different module)
+- [ ] Test `set_initial_edges()` updates initial bin edges (spiral.py - different module)
+- [ ] Test `set_min_per_bin()` updates minimum per bin (spiral.py - different module)
+- [ ] Test `set_data()` stores input data (spiral.py - different module)
+- [ ] Test `initialize_bins()` constructs mesh of expected shape (spiral.py - different module)
+
+**Commit**: `e90b201`  
+**Status**: Completed  
+**Tests**: 40 passed  
+**Time**: 2.0 hours  
+**Notes**: Comprehensive test coverage for histograms.py module exports and core Hist1D/Hist2D functionality. Many scatter.py and spiral.py tests are for separate modules.
+
+## 🧩 Decomposition Instructions (Optional)
+
+None
+
+## 🤖 Sweep Agent Instructions (Optional)
+
+None
+
+## 💬 Additional Notes
+
+- Ensures correct functionality, edge-case handling, API stability, and protects
+  non-public internals.