Upload 765 files

.gitattributes

@@ -33,3 +33,118 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/FCM-R19-2003-WindchillReport.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/fundam.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/IAPWS95-2018.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/Miller1972.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/NSF-Unidata_lockup_horizontal_2024_darkmode_v3.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/NSF-Unidata_lockup_horizontal_2024.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/NWS_10-201.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/Res_IAU2012_B2.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/Smithsonian1951.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/docs/_static/USAF_SkewT_manual.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/AK-REGIONAL_8km_3.9_20160408_1445.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/CAM_test.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gem_conical.grd filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gem_cylindrical.grd filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gem_ship.sfc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gem_surface_with_text.sfc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gem_unmerged_with_text.snd filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/GFS_global.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/gfs_output.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/GFS_test.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/HI-REGIONAL_4km_3.9_20160616_1715.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/irma_gfs_example.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/KICX_20170712_1458 filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/Level2_FOP1_20191223_003655.ar2v filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/Level2_KDDC_20200823_204121.ar2v filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/Level2_KFTG_20150430_1419.ar2v filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/Level2_KLBB_single_chunk filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/Level3_Composite_dhr_1km_20180309_2225.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/NAM_test.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/narr_example.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/NHEM-MULTICOMP_1km_IR_20151208_2100.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/KLZK_H0C_20200814_0417 filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/KLZK_H0V_20200812_1309 filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/KLZK_H0W_20200812_1305 filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/KLZK_H0Z_20200812_1318 filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/KRAX_DTA_20200818_0454.nids filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/Level3_DEN_TZ0_20200804_2226.nids filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/Level3_DEN_TZ1_20200804_2226.nids filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/Level3_FTG_N0B_20220304_1820.nids filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/nids/Level3_MCI_TZL_20160526_2154.nids filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/PR-NATIONAL_1km_PCT_20200320_0446.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/sfc_obs.gem filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_20m.dbf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_20m.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_500k.dbf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_500k.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_5m.dbf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_counties_5m.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_states_20m.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_states_500k.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/us_states_5m.shp filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/WEST-CONUS_4km_WV_20151208_2200.gini filter=lfs diff=lfs merge=lfs -text
+MetPy/source/staticdata/wrf_example.nc filter=lfs diff=lfs merge=lfs -text
+MetPy/source/talks/MetPy[[:space:]]Infrastructure[[:space:]]-[[:space:]]SciPy[[:space:]]2016.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/talks/MetPy[[:space:]]Presentation[[:space:]]-[[:space:]]AMS[[:space:]]2016.pdf filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_colorfill_no_colorbar.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_colorfill_with_image_range.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_additional_layers_plot_options.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_arrow_changes.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_arrowkey.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_arrowplot.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_barb_earth_relative.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_barb_gfs_knots.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_barb_gfs.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_barb_options.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_barb_scale.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_colorbar_fontsize.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_contour_cam.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_contour_convert_units.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_contour_label_fontsize.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_contour_options.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_contour.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_events.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_figsize.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_global_gfs.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_gridded_scale.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_image.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_layers_plot_options.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_multiple_sfc_obs_change_units.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_overlay_projections.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_plot_geometry_points.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_plot_geometry_polygons.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_plot_surface_analysis_custom.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_plot_surface_analysis_default.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_raster_options.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_raster.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_region_modifier_zoom_out.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_obs_args.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_obs_change_units.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_obs_changes.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_obs_full.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_obs.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_sfc_text.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_smooth_contour_calculation.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_smooth_contour_order.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_smooth_contour.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_smooth_field.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_station_plot_fontsize.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_title_fontsize.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_titles.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_upa_obs_convert_barb_units.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_declarative_upa_obs.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_emagram_default_aspect_empty.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_emagram_mixing_line_args.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_hodograph_api.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_latlon.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_projection_object.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_scalloped_stroke_closed.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_scalloped_stroke_segment.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_skewt_api_units.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_skewt_api.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_skewt_default_aspect_empty.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_skewt_mixing_line_args.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_stuve_default_aspect_empty.png filter=lfs diff=lfs merge=lfs -text
+MetPy/source/tests/plots/baseline/test_stuve_mixing_line_args.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "MetPy/mcp_output/start_mcp.py"]

MetPy/mcp_output/README_MCP.md

@@ -0,0 +1,151 @@
+# MetPy MCP (Model Context Protocol) Service README
+
+## 1) Project Introduction
+
+This MCP (Model Context Protocol) service wraps core capabilities from [MetPy](https://github.com/Unidata/MetPy) to provide meteorological computation and data-processing tools for LLM-driven workflows.
+
+Primary service functions:
+- Thermodynamic diagnostics (e.g., LCL/LFC/EL, CAPE/CIN, mixing ratio, equivalent potential temperature)
+- Kinematic diagnostics (e.g., vorticity, divergence, advection, deformation, frontogenesis)
+- Basic wind/temperature transforms (wind speed/direction/components, potential temperature)
+- Forecast/stability indices (e.g., Showalter, K, Lifted, Total Totals, bulk shear, SRH)
+- Station/radar ingestion (METAR parsing, NEXRAD Level II/III readers)
+- Interpolation/gridding (station-to-grid workflows)
+- xarray + units integration via Pint for safer scientific calculations
+
+---
+
+## 2) Installation Method
+
+### Requirements
+Core dependencies:
+- numpy
+- scipy
+- pint
+- packaging
+
+Common optional dependencies (enable richer workflows):
+- xarray, pandas
+- matplotlib, cartopy
+- pyproj
+- netCDF4
+- pooch
+- siphon
+
+### Install
+- Install from PyPI:
+  pip install metpy
+
+- Recommended extras for full scientific workflows:
+  pip install metpy xarray pandas matplotlib cartopy pyproj netCDF4 pooch siphon
+
+- For MCP (Model Context Protocol) service development:
+  pip install -e .
+
+---
+
+## 3) Quick Start
+
+### Basic usage flow
+1. Load data (arrays, xarray objects, or text/radar files)
+2. Attach/use units (Pint via `metpy.units`)
+3. Run calculation endpoints
+4. Return structured numeric outputs (and optional metadata)
+
+### Example calls (service-level intent)
+- Thermo:
+  - `lcl`, `lfc`, `el`, `cape_cin`
+  - `mixing_ratio`, `dewpoint_from_relative_humidity`, `virtual_temperature`
+- Kinematics:
+  - `vorticity`, `divergence`, `advection`, `absolute_vorticity`, `frontogenesis`
+- Basic:
+  - `wind_speed`, `wind_direction`, `wind_components`, `potential_temperature`
+- IO:
+  - `parse_metar_file`
+  - `Level2File`, `Level3File` readers
+- Interpolation:
+  - `interpolate_to_grid`
+
+---
+
+## 4) Available Tools and Endpoints List
+
+Suggested MCP (Model Context Protocol) endpoint layout for this service:
+
+- `calc.thermo.parcel_profile`  
+  Parcel temperature profile computation.
+
+- `calc.thermo.lcl` / `calc.thermo.lfc` / `calc.thermo.el`  
+  Key parcel-level heights/pressures for convective diagnosis.
+
+- `calc.thermo.cape_cin`  
+  Convective available potential energy / inhibition.
+
+- `calc.thermo.mixing_ratio`  
+  Moisture ratio diagnostics.
+
+- `calc.thermo.dewpoint_from_relative_humidity`  
+  Dewpoint from RH and temperature.
+
+- `calc.thermo.equivalent_potential_temperature`  
+  Theta-e for thermodynamic state analysis.
+
+- `calc.kinematics.vorticity` / `divergence` / `advection`  
+  Core flow and derivative diagnostics.
+
+- `calc.kinematics.frontogenesis` / `absolute_vorticity` / `q_vector`  
+  Synoptic and mesoscale diagnostics.
+
+- `calc.kinematics.shearing_deformation` / `stretching_deformation` / `total_deformation`  
+  Deformation field analysis.
+
+- `calc.basic.wind_speed` / `wind_direction` / `wind_components`  
+  Wind vector conversions.
+
+- `calc.basic.potential_temperature`  
+  Thermodynamic transform.
+
+- `calc.indices.showalter_index` / `k_index` / `lifted_index` / `total_totals_index`  
+  Stability index suite.
+
+- `calc.indices.bulk_shear` / `storm_relative_helicity`  
+  Severe-weather kinematic predictors.
+
+- `interpolate.grid.interpolate_to_grid`  
+  Station/objective analysis to grid.
+
+- `io.metar.parse_metar_file`  
+  METAR text ingestion and parsing.
+
+- `io.nexrad.Level2File` / `io.nexrad.Level3File`  
+  NEXRAD binary product readers.
+
+- `xarray.preprocess_and_wrap` / `xarray.grid_deltas_from_dataarray`  
+  Coordinate-aware xarray workflows.
+
+---
+
+## 5) Common Issues and Notes
+
+- Units are mandatory for reliable science:
+  - Use Pint quantities consistently to avoid silent unit errors.
+- Optional stack matters:
+  - Plotting/raster/map workflows need matplotlib/cartopy/pyproj.
+- Radar and IO pipelines may be memory-heavy:
+  - For large NEXRAD files, stream/process in chunks where possible.
+- xarray interoperability:
+  - Prefer coordinate-aware arrays for derivative operations (dx/dy correctness).
+- No native CLI detected:
+  - This repository is primarily a Python library; expose MCP (Model Context Protocol) endpoints at the service layer.
+- Environment recommendations:
+  - Use a dedicated virtual environment/conda env to avoid binary dependency conflicts.
+
+---
+
+## 6) Reference Links / Documentation
+
+- Repository: https://github.com/Unidata/MetPy  
+- Official docs: https://unidata.github.io/MetPy/  
+- Project README: https://github.com/Unidata/MetPy/blob/main/README.md  
+- Contributing guide: https://github.com/Unidata/MetPy/blob/main/CONTRIBUTING.md  
+- Support: https://github.com/Unidata/MetPy/blob/main/SUPPORT.md

MetPy/mcp_output/analysis.json

@@ -0,0 +1,996 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/Unidata/MetPy",
+    "summary": "Imported via zip fallback, file count: 262",
+    "file_tree": {
+      ".codecov.yml": {
+        "size": 407
+      },
+      ".devcontainer/devcontainer.json": {
+        "size": 1589
+      },
+      ".github/ISSUE_TEMPLATE/bug_report.yml": {
+        "size": 2323
+      },
+      ".github/ISSUE_TEMPLATE/config.yml": {
+        "size": 237
+      },
+      ".github/ISSUE_TEMPLATE/documentation.yml": {
+        "size": 382
+      },
+      ".github/ISSUE_TEMPLATE/feature_request.yml": {
+        "size": 541
+      },
+      ".github/actions/build-docs/action.yml": {
+        "size": 2322
+      },
+      ".github/actions/install-conda/action.yml": {
+        "size": 1387
+      },
+      ".github/actions/install-pypi/action.yml": {
+        "size": 2622
+      },
+      ".github/actions/run-tests/action.yml": {
+        "size": 1836
+      },
+      ".github/codeql/codeql-config.yml": {
+        "size": 139
+      },
+      ".github/dependabot.yml": {
+        "size": 1759
+      },
+      ".github/pull_request_template.md": {
+        "size": 605
+      },
+      ".github/release.yml": {
+        "size": 443
+      },
+      ".github/workflows/assign-milestone.yml": {
+        "size": 1683
+      },
+      ".github/workflows/automerge-dependabot.yml": {
+        "size": 1127
+      },
+      ".github/workflows/backport-prs.yml": {
+        "size": 3850
+      },
+      ".github/workflows/benchmark-pr.yml": {
+        "size": 1561
+      },
+      ".github/workflows/cffcheck.yml": {
+        "size": 560
+      },
+      ".github/workflows/code-analysis.yml": {
+        "size": 846
+      },
+      ".github/workflows/docs-conda.yml": {
+        "size": 1177
+      },
+      ".github/workflows/docs.yml": {
+        "size": 4361
+      },
+      ".github/workflows/linting.yml": {
+        "size": 1943
+      },
+      ".github/workflows/nightly-builds.yml": {
+        "size": 3315
+      },
+      ".github/workflows/release.yml": {
+        "size": 1359
+      },
+      ".github/workflows/run-unstable-pr.yml": {
+        "size": 362
+      },
+      ".github/workflows/tests-conda.yml": {
+        "size": 1877
+      },
+      ".github/workflows/tests-pypi.yml": {
+        "size": 3192
+      },
+      ".github/workflows/unstable-builds.yml": {
+        "size": 2417
+      },
+      ".lgtm.yml": {
+        "size": 171
+      },
+      ".markdownlint.yaml": {
+        "size": 55
+      },
+      ".qlty/qlty.toml": {
+        "size": 282
+      },
+      ".stickler.yml": {
+        "size": 72
+      },
+      "AUTHORS.txt": {
+        "size": 742
+      },
+      "CLA.md": {
+        "size": 11868
+      },
+      "CODE_OF_CONDUCT.md": {
+        "size": 3230
+      },
+      "CONTRIBUTING.md": {
+        "size": 18912
+      },
+      "README.md": {
+        "size": 6298
+      },
+      "SUPPORT.md": {
+        "size": 1847
+      },
+      "benchmarks/asv.conf.json": {
+        "size": 8429
+      },
+      "benchmarks/benchmarks/__init__.py": {
+        "size": 189
+      },
+      "benchmarks/benchmarks/apparent_temp_benchmarks.py": {
+        "size": 2270
+      },
+      "benchmarks/benchmarks/bound_layer_turbulence_benchmarks.py": {
+        "size": 2473
+      },
+      "benchmarks/benchmarks/dry_thermo_benchmarks.py": {
+        "size": 5049
+      },
+      "benchmarks/benchmarks/dyn_kin_benchmarks.py": {
+        "size": 7030
+      },
+      "benchmarks/benchmarks/math_fctn_benchmarks.py": {
+        "size": 3217
+      },
+      "benchmarks/benchmarks/moist_thermo_benchmarks.py": {
+        "size": 11552
+      },
+      "benchmarks/benchmarks/other_benchmarks.py": {
+        "size": 3104
+      },
+      "benchmarks/benchmarks/smoothing_benchmarks.py": {
+        "size": 2701
+      },
+      "benchmarks/benchmarks/soundings_benchmarks.py": {
+        "size": 11218
+      },
+      "benchmarks/benchmarks/std_atm_benchmarks.py": {
+        "size": 2389
+      },
+      "benchmarks/data_array_generate.py": {
+        "size": 10497
+      },
+      "ci-dev/doc_requirements.txt": {
+        "size": 122
+      },
+      "ci-dev/linting_requirements.txt": {
+        "size": 254
+      },
+      "ci-dev/test_requirements.txt": {
+        "size": 79
+      },
+      "ci/download_cartopy_maps.py": {
+        "size": 1059
+      },
+      "ci/extra_requirements.txt": {
+        "size": 75
+      },
+      "ci/filter_links.py": {
+        "size": 1577
+      },
+      "ci/requirements.txt": {
+        "size": 136
+      },
+      "conftest.py": {
+        "size": 6621
+      },
+      "docs/_static/doc_shared.js": {
+        "size": 2554
+      },
+      "docs/conf.py": {
+        "size": 18700
+      },
+      "docs/devel/CONTRIBUTING.md": {
+        "size": 21
+      },
+      "docs/doc-server.py": {
+        "size": 1298
+      },
+      "docs/make_areas.py": {
+        "size": 4350
+      },
+      "docs/override_check.py": {
+        "size": 1137
+      },
+      "docs/test-server/pst-versions.json": {
+        "size": 720
+      },
+      "docs/userguide/SUPPORT.md": {
+        "size": 16
+      },
+      "examples/Advanced_Sounding.py": {
+        "size": 3280
+      },
+      "examples/Advanced_Sounding_With_Complex_Layout.py": {
+        "size": 15252
+      },
+      "examples/Four_Panel_Map.py": {
+        "size": 4745
+      },
+      "examples/README.txt": {
+        "size": 309
+      },
+      "examples/XArray_Projections.py": {
+        "size": 1171
+      },
+      "examples/calculations/Absolute_Vorticity.py": {
+        "size": 1036
+      },
+      "examples/calculations/Advection.py": {
+        "size": 1439
+      },
+      "examples/calculations/Angle_to_Direction.py": {
+        "size": 1305
+      },
+      "examples/calculations/Bulk_Shear.py": {
+        "size": 1807
+      },
+      "examples/calculations/Dewpoint_and_Mixing_Ratio.py": {
+        "size": 1705
+      },
+      "examples/calculations/Divergence.py": {
+        "size": 984
+      },
+      "examples/calculations/Equivalent_Potential_Temperature.py": {
+        "size": 2183
+      },
+      "examples/calculations/Gradient.py": {
+        "size": 2073
+      },
+      "examples/calculations/High_Low_Analysis.py": {
+        "size": 2632
+      },
+      "examples/calculations/Mean_Pressure_Weighted.py": {
+        "size": 1665
+      },
+      "examples/calculations/Mountain_Problem.py": {
+        "size": 2747
+      },
+      "examples/calculations/Parse_Angles.py": {
+        "size": 1063
+      },
+      "examples/calculations/QVector.py": {
+        "size": 2090
+      },
+      "examples/calculations/README.txt": {
+        "size": 104
+      },
+      "examples/calculations/Shearing_Deformation.py": {
+        "size": 1058
+      },
+      "examples/calculations/Smoothing.py": {
+        "size": 2435
+      },
+      "examples/calculations/Sounding_Calculations.py": {
+        "size": 8205
+      },
+      "examples/calculations/Static_Stability.py": {
+        "size": 1599
+      },
+      "examples/calculations/Stretching_Deformation.py": {
+        "size": 1076
+      },
+      "examples/calculations/Thickness_Hydrostatic.py": {
+        "size": 2069
+      },
+      "examples/calculations/Total_Deformation.py": {
+        "size": 1040
+      },
+      "examples/calculations/Vorticity.py": {
+        "size": 993
+      },
+      "examples/calculations/Wind_Speed.py": {
+        "size": 959
+      },
+      "examples/cross_section.py": {
+        "size": 5049
+      },
+      "examples/formats/GINI_Water_Vapor.py": {
+        "size": 1710
+      },
+      "examples/formats/NEXRAD_Level_2_File.py": {
+        "size": 3424
+      },
+      "examples/formats/NEXRAD_Level_3_File.py": {
+        "size": 2282
+      },
+      "examples/formats/README.txt": {
+        "size": 115
+      },
+      "examples/gridding/Find_Natural_Neighbors_Verification.py": {
+        "size": 2557
+      },
+      "examples/gridding/Inverse_Distance_Verification.py": {
+        "size": 7102
+      },
+      "examples/gridding/Natural_Neighbor_Verification.py": {
+        "size": 10380
+      },
+      "examples/gridding/Point_Interpolation.py": {
+        "size": 5119
+      },
+      "examples/gridding/README.txt": {
+        "size": 113
+      },
+      "examples/gridding/Wind_SLP_Interpolation.py": {
+        "size": 4475
+      },
+      "examples/isentropic_example.py": {
+        "size": 7367
+      },
+      "examples/meteogram_metpy.py": {
+        "size": 9027
+      },
+      "examples/plots/Combined_plotting.py": {
+        "size": 1336
+      },
+      "examples/plots/Hodograph_Inset.py": {
+        "size": 2383
+      },
+      "examples/plots/Mesonet_Stationplot.py": {
+        "size": 4217
+      },
+      "examples/plots/Plotting_Surface_Analysis.py": {
+        "size": 3423
+      },
+      "examples/plots/README.txt": {
+        "size": 103
+      },
+      "examples/plots/Simple_Fronts_Plot.py": {
+        "size": 1459
+      },
+      "examples/plots/Simple_Sounding.py": {
+        "size": 3184
+      },
+      "examples/plots/Simplified_Image_Plot.py": {
+        "size": 727
+      },
+      "examples/plots/Skew-T_Layout.py": {
+        "size": 2399
+      },
+      "examples/plots/Sounding_LCL_Dataset.py": {
+        "size": 3080
+      },
+      "examples/plots/Station_Plot.py": {
+        "size": 4577
+      },
+      "examples/plots/Station_Plot_with_Layout.py": {
+        "size": 8152
+      },
+      "examples/plots/US_Counties.py": {
+        "size": 850
+      },
+      "examples/plots/nhc_wind_probabilities.py": {
+        "size": 4274
+      },
+      "examples/plots/raster_declarative.py": {
+        "size": 1426
+      },
+      "examples/plots/spc_convective_outlook.py": {
+        "size": 1777
+      },
+      "examples/plots/surface_declarative.py": {
+        "size": 2181
+      },
+      "examples/plots/upperair_declarative.py": {
+        "size": 2177
+      },
+      "examples/remote/README.txt": {
+        "size": 159
+      },
+      "examples/remote/basic.py": {
+        "size": 1061
+      },
+      "examples/remote/ml_forecast.py": {
+        "size": 1199
+      },
+      "examples/sigma_to_pressure_interpolation.py": {
+        "size": 3493
+      },
+      "pyproject.toml": {
+        "size": 6144
+      },
+      "setup.cfg": {
+        "size": 1049
+      },
+      "src/metpy/__init__.py": {
+        "size": 525
+      },
+      "src/metpy/_vendor/__init__.py": {
+        "size": 189
+      },
+      "src/metpy/_vendor/xarray.py": {
+        "size": 2816
+      },
+      "src/metpy/_version.py": {
+        "size": 1332
+      },
+      "src/metpy/_warnings.py": {
+        "size": 823
+      },
+      "src/metpy/calc/__init__.py": {
+        "size": 1085
+      },
+      "src/metpy/calc/basic.py": {
+        "size": 46972
+      },
+      "src/metpy/calc/cross_sections.py": {
+        "size": 10773
+      },
+      "src/metpy/calc/exceptions.py": {
+        "size": 325
+      },
+      "src/metpy/calc/indices.py": {
+        "size": 26492
+      },
+      "src/metpy/calc/kinematics.py": {
+        "size": 73179
+      },
+      "src/metpy/calc/thermo.py": {
+        "size": 198357
+      },
+      "src/metpy/calc/tools.py": {
+        "size": 82702
+      },
+      "src/metpy/calc/turbulence.py": {
+        "size": 7608
+      },
+      "src/metpy/cbook.py": {
+        "size": 5854
+      },
+      "src/metpy/constants/__init__.py": {
+        "size": 6851
+      },
+      "src/metpy/constants/default.py": {
+        "size": 2978
+      },
+      "src/metpy/constants/nounit.py": {
+        "size": 872
+      },
+      "src/metpy/deprecation.py": {
+        "size": 11148
+      },
+      "src/metpy/future.py": {
+        "size": 285
+      },
+      "src/metpy/interpolate/__init__.py": {
+        "size": 778
+      },
+      "src/metpy/interpolate/geometry.py": {
+        "size": 10454
+      },
+      "src/metpy/interpolate/grid.py": {
+        "size": 12842
+      },
+      "src/metpy/interpolate/one_dimension.py": {
+        "size": 7900
+      },
+      "src/metpy/interpolate/points.py": {
+        "size": 13724
+      },
+      "src/metpy/interpolate/slices.py": {
+        "size": 6754
+      },
+      "src/metpy/interpolate/tools.py": {
+        "size": 4458
+      },
+      "src/metpy/io/__init__.py": {
+        "size": 1305
+      },
+      "src/metpy/io/_metar_parser.py": {
+        "size": 228959
+      },
+      "src/metpy/io/_nexrad_msgs/__init__.py": {
+        "size": 203
+      },
+      "src/metpy/io/_nexrad_msgs/msg18.py": {
+        "size": 43236
+      },
+      "src/metpy/io/_nexrad_msgs/msg3.py": {
+        "size": 18946
+      },
+      "src/metpy/io/_tools.py": {
+        "size": 12319
+      },
+      "src/metpy/io/gempak.py": {
+        "size": 114036
+      },
+      "src/metpy/io/gini.py": {
+        "size": 18521
+      },
+      "src/metpy/io/metar.py": {
+        "size": 20075
+      },
+      "src/metpy/io/nexrad.py": {
+        "size": 119894
+      },
+      "src/metpy/io/station_data.py": {
+        "size": 7650
+      },
+      "src/metpy/io/text.py": {
+        "size": 5899
+      },
+      "src/metpy/package_tools.py": {
+        "size": 2178
+      },
+      "src/metpy/pandas.py": {
+        "size": 826
+      },
+      "src/metpy/plots/__init__.py": {
+        "size": 1851
+      },
+      "src/metpy/plots/_util.py": {
+        "size": 9186
+      },
+      "src/metpy/plots/cartopy_utils.py": {
+        "size": 2810
+      },
+      "src/metpy/plots/ctables.py": {
+        "size": 8716
+      },
+      "src/metpy/plots/declarative.py": {
+        "size": 93828
+      },
+      "src/metpy/plots/fonts/wx_symbols_license.txt": {
+        "size": 328
+      },
+      "src/metpy/plots/mapping.py": {
+        "size": 8548
+      },
+      "src/metpy/plots/patheffects.py": {
+        "size": 43589
+      },
+      "src/metpy/plots/plot_areas.py": {
+        "size": 39092
+      },
+      "src/metpy/plots/skewt.py": {
+        "size": 41279
+      },
+      "src/metpy/plots/station_plot.py": {
+        "size": 27950
+      },
+      "src/metpy/plots/text.py": {
+        "size": 9211
+      },
+      "src/metpy/plots/wx_symbols.py": {
+        "size": 10744
+      },
+      "src/metpy/remote/__init__.py": {
+        "size": 454
+      },
+      "src/metpy/remote/aws.py": {
+        "size": 27436
+      },
+      "src/metpy/static-data-manifest.txt": {
+        "size": 24858
+      },
+      "src/metpy/testing.py": {
+        "size": 11806
+      },
+      "src/metpy/units.py": {
+        "size": 15097
+      },
+      "src/metpy/xarray.py": {
+        "size": 65473
+      },
+      "staticdata/20110522_OUN_12Z.txt": {
+        "size": 5900
+      },
+      "staticdata/WPC_sfc_fronts_20210628_1800.txt": {
+        "size": 3627
+      },
+      "staticdata/WPC_sfc_fronts_lowres_20210628_1800.txt": {
+        "size": 2863
+      },
+      "staticdata/dec9_sounding.txt": {
+        "size": 10765
+      },
+      "staticdata/jan20_sounding.txt": {
+        "size": 6084
+      },
+      "staticdata/master.txt": {
+        "size": 524313
+      },
+      "staticdata/may22_sounding.txt": {
+        "size": 6317
+      },
+      "staticdata/may4_sounding.txt": {
+        "size": 2730
+      },
+      "staticdata/mesonet_sample.txt": {
+        "size": 10075
+      },
+      "staticdata/metar_20190701_1200.txt": {
+        "size": 524313
+      },
+      "staticdata/nov11_sounding.txt": {
+        "size": 4460
+      },
+      "staticdata/station_data.txt": {
+        "size": 188266
+      },
+      "staticdata/stations.txt": {
+        "size": 524313
+      },
+      "tests/calc/test_basic.py": {
+        "size": 35703
+      },
+      "tests/calc/test_calc_tools.py": {
+        "size": 69144
+      },
+      "tests/calc/test_cross_sections.py": {
+        "size": 17512
+      },
+      "tests/calc/test_indices.py": {
+        "size": 16737
+      },
+      "tests/calc/test_kinematics.py": {
+        "size": 116459
+      },
+      "tests/calc/test_thermo.py": {
+        "size": 143254
+      },
+      "tests/calc/test_turbulence.py": {
+        "size": 19114
+      },
+      "tests/interpolate/test_geometry.py": {
+        "size": 6054
+      },
+      "tests/interpolate/test_grid.py": {
+        "size": 11977
+      },
+      "tests/interpolate/test_interpolate_tools.py": {
+        "size": 3800
+      },
+      "tests/interpolate/test_one_dimension.py": {
+        "size": 7950
+      },
+      "tests/interpolate/test_points.py": {
+        "size": 6042
+      },
+      "tests/interpolate/test_slices.py": {
+        "size": 9870
+      },
+      "tests/io/test_gempak.py": {
+        "size": 16437
+      },
+      "tests/io/test_gini.py": {
+        "size": 10122
+      },
+      "tests/io/test_metar.py": {
+        "size": 22999
+      },
+      "tests/io/test_nexrad.py": {
+        "size": 11659
+      },
+      "tests/io/test_station_data.py": {
+        "size": 2500
+      },
+      "tests/io/test_text.py": {
+        "size": 3314
+      },
+      "tests/io/test_tools.py": {
+        "size": 674
+      },
+      "tests/plots/test_cartopy_utils.py": {
+        "size": 3416
+      },
+      "tests/plots/test_ctables.py": {
+        "size": 4814
+      },
+      "tests/plots/test_declarative.py": {
+        "size": 68715
+      },
+      "tests/plots/test_mapping.py": {
+        "size": 10794
+      },
+      "tests/plots/test_patheffects.py": {
+        "size": 6190
+      },
+      "tests/plots/test_plot_areas.py": {
+        "size": 3747
+      },
+      "tests/plots/test_plot_text.py": {
+        "size": 1697
+      },
+      "tests/plots/test_skewt.py": {
+        "size": 32476
+      },
+      "tests/plots/test_station_plot.py": {
+        "size": 15430
+      },
+      "tests/plots/test_util.py": {
+        "size": 4838
+      },
+      "tests/plots/test_wx_symbols.py": {
+        "size": 2405
+      },
+      "tests/remote/fixtures/test_goes_range.yaml": {
+        "size": 19261
+      },
+      "tests/remote/fixtures/test_goes_single.yaml": {
+        "size": 29835
+      },
+      "tests/remote/fixtures/test_mlwp_range.yaml": {
+        "size": 8002
+      },
+      "tests/remote/fixtures/test_mlwp_single.yaml": {
+        "size": 3860
+      },
+      "tests/remote/fixtures/test_nexrad2_range.yaml": {
+        "size": 45493
+      },
+      "tests/remote/fixtures/test_nexrad2_single.yaml": {
+        "size": 124906
+      },
+      "tests/remote/fixtures/test_nexrad3_range.yaml": {
+        "size": 447356
+      },
+      "tests/remote/fixtures/test_nexrad3_single.yaml": {
+        "size": 52451
+      },
+      "tests/remote/test_aws.py": {
+        "size": 5945
+      },
+      "tests/test_cbook.py": {
+        "size": 857
+      },
+      "tests/test_deprecation.py": {
+        "size": 907
+      },
+      "tests/test_packaging.py": {
+        "size": 621
+      },
+      "tests/test_testing.py": {
+        "size": 2581
+      },
+      "tests/test_xarray.py": {
+        "size": 60599
+      },
+      "tests/units/test_units.py": {
+        "size": 9322
+      },
+      "tools/README.md": {
+        "size": 131
+      },
+      "tools/flake8-metpy/flake8_metpy.py": {
+        "size": 2532
+      },
+      "tools/flake8-metpy/test_flake8_metpy.py": {
+        "size": 1014
+      },
+      "tools/nexrad_msgs/parse_spec.py": {
+        "size": 6409
+      },
+      "tutorials/README.md": {
+        "size": 2426
+      },
+      "tutorials/area_tutorial.py": {
+        "size": 3835
+      },
+      "tutorials/declarative_tutorial.py": {
+        "size": 21683
+      },
+      "tutorials/unit_tutorial.py": {
+        "size": 10756
+      },
+      "tutorials/upperair_soundings.py": {
+        "size": 7360
+      },
+      "tutorials/xarray_tutorial.py": {
+        "size": 18510
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.benchmarks.benchmarks",
+      "source.src.metpy"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": true,
+    "setup_cfg": true,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.src.metpy",
+        "module": "calc.thermo",
+        "functions": [
+          "parcel_profile",
+          "lcl",
+          "lfc",
+          "el",
+          "cape_cin",
+          "mixing_ratio",
+          "dewpoint_from_relative_humidity",
+          "equivalent_potential_temperature",
+          "virtual_temperature"
+        ],
+        "classes": [],
+        "description": "Thermodynamic calculations for parcel diagnostics, moisture variables, and severe-weather indices; highest-value computational core."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "calc.kinematics",
+        "functions": [
+          "vorticity",
+          "divergence",
+          "advection",
+          "frontogenesis",
+          "absolute_vorticity",
+          "q_vector",
+          "shearing_deformation",
+          "stretching_deformation",
+          "total_deformation"
+        ],
+        "classes": [],
+        "description": "Grid/flow kinematics and derivative-based meteorological diagnostics."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "calc.basic",
+        "functions": [
+          "wind_speed",
+          "wind_direction",
+          "wind_components",
+          "potential_temperature",
+          "height_to_geopotential",
+          "geopotential_to_height"
+        ],
+        "classes": [],
+        "description": "Fundamental scalar/vector meteorological transformations used broadly by higher-level modules."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "calc.indices",
+        "functions": [
+          "showalter_index",
+          "k_index",
+          "total_totals_index",
+          "lifted_index",
+          "bulk_shear",
+          "storm_relative_helicity"
+        ],
+        "classes": [],
+        "description": "Forecast and severe-weather stability/kinematic indices frequently used in operational workflows."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "interpolate.grid",
+        "functions": [
+          "interpolate_to_grid"
+        ],
+        "classes": [],
+        "description": "Objective analysis/gridding entry point for station-to-grid interpolation workflows."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "io.metar",
+        "functions": [
+          "parse_metar_file"
+        ],
+        "classes": [],
+        "description": "METAR text decoding utilities for ingesting observational station reports."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "io.nexrad",
+        "functions": [],
+        "classes": [
+          "Level2File",
+          "Level3File"
+        ],
+        "description": "NEXRAD radar file readers for binary Level II/III products."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "plots.skewt",
+        "functions": [],
+        "classes": [
+          "SkewT",
+          "Hodograph"
+        ],
+        "description": "Sounding visualization primitives; useful but higher dependency footprint."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "xarray",
+        "functions": [
+          "preprocess_and_wrap",
+          "check_axis",
+          "grid_deltas_from_dataarray"
+        ],
+        "classes": [
+          "MetPyDataArrayAccessor",
+          "MetPyDatasetAccessor"
+        ],
+        "description": "xarray integration/accessor layer that enables coordinate-aware calculations and unit-aware parsing."
+      },
+      {
+        "package": "source.src.metpy",
+        "module": "units",
+        "functions": [
+          "units",
+          "pandas_dataframe_to_unit_arrays",
+          "concatenate",
+          "masked_array"
+        ],
+        "classes": [],
+        "description": "Unit handling bridge (Pint-centric) that underpins nearly all safe numeric usage in MetPy."
+      }
+    ],
+    "cli_commands": [
+      {
+        "name": "none_detected",
+        "module": "N/A",
+        "description": "No explicit CLI entry points detected in scanned package paths (no console_scripts or __main__-style command modules identified in source.src.metpy)."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.93
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy",
+        "pint",
+        "packaging"
+      ],
+      "optional": [
+        "xarray",
+        "pandas",
+        "matplotlib",
+        "cartopy",
+        "pyproj",
+        "netCDF4",
+        "pooch",
+        "siphon"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.91,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/Unidata/MetPy",
+    "repo_name": "MetPy",
+    "error": "DeepWiki analysis failed",
+    "model": "gpt-5.3-codex",
+    "source": "llm_direct_analysis",
+    "success": false
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-5.3-codex"
+  },
+  "risk": {
+    "import_feasibility": 0.91,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

MetPy/mcp_output/diff_report.md

@@ -0,0 +1,138 @@
+# MetPy Difference Report
+
+**Repository:** MetPy  
+**Project Type:** Python library  
+**Assessment Time:** 2026-03-12 09:35:35  
+**Intrusiveness:** None  
+**Workflow Status:** ✅ Success  
+**Test Status:** ❌ Failed  
+**File Changes:** 8 new files, 0 modified files
+
+---
+
+## 1. Project Overview
+
+This change set introduces **new artifacts only** (no edits to existing code paths), indicating an additive update intended to extend or support basic functionality in the MetPy project.  
+Given that the workflow completed successfully but tests failed, the repository is operational at a pipeline level, but code quality and/or integration validity is currently blocked by test regressions.
+
+---
+
+## 2. Change Summary
+
+| Metric | Value |
+|---|---|
+| New files | 8 |
+| Modified files | 0 |
+| Deleted files | 0 (not reported) |
+| Intrusiveness | None |
+| CI workflow | Success |
+| Test suite | Failed |
+
+### Interpretation
+- **Low-risk structural change** from a source-control perspective (no existing file edits).
+- **Functional risk remains** due to failed tests, which may indicate:
+  - missing integration wiring for new files,
+  - incomplete implementation,
+  - incorrect assumptions in new logic,
+  - test environment/configuration drift.
+
+---
+
+## 3. Difference Analysis
+
+Because only new files were added:
+1. **Backward compatibility risk is likely limited** at source level (no direct modifications).
+2. **Runtime risk still exists** if new files are imported or auto-discovered by package initialization.
+3. **Packaging/distribution risk** may increase if setup metadata includes new modules without required dependencies.
+4. **Quality gate failure** (tests) prevents safe promotion despite clean workflow execution.
+
+---
+
+## 4. Technical Analysis
+
+## 4.1 CI Signal Split
+- **Workflow Success** suggests:
+  - lint/build steps likely passed,
+  - pipeline orchestration and environment provisioning are healthy.
+- **Test Failure** suggests:
+  - logic-level or integration-level issues,
+  - potential mismatch between expected and actual behavior.
+
+## 4.2 Potential Failure Categories (for new-file-only changes)
+- **Uncovered edge cases** in newly introduced functionality.
+- **Import-time side effects** causing failures in unrelated tests.
+- **Dependency omissions** (requirements not updated but new files rely on external packages).
+- **Test expectation drift** if baseline outputs changed.
+- **Discovery/registration issues** (plugins, entry points, module exports).
+
+## 4.3 Risk Assessment
+
+| Area | Risk | Notes |
+|---|---|---|
+| Existing core behavior | Low–Medium | No modified files, but import/discovery could still affect runtime |
+| New functionality correctness | Medium–High | Tests failing indicate unresolved issues |
+| Release readiness | High risk (not ready) | Failing tests block reliable release |
+| Operational deployment | Medium | Depends on whether new code path is active by default |
+
+---
+
+## 5. Recommendations & Improvements
+
+## 5.1 Immediate Actions (Blockers)
+1. **Triage failing tests by category**
+   - Unit vs integration vs regression.
+   - New feature tests vs unrelated legacy tests.
+2. **Map failures to added files**
+   - Trace stack traces to determine whether failures originate from the new modules.
+3. **Fix and re-run full test matrix**
+   - Include supported Python versions and optional dependency sets.
+
+## 5.2 Code Quality Enhancements
+- Add/expand **unit tests per new file** (happy path + edge cases + invalid inputs).
+- Verify **typing and API contracts** for public-facing additions.
+- Ensure **docs and examples** align with actual behavior.
+- Validate **import safety** (avoid heavy work at module import time).
+
+## 5.3 Release Hygiene
+- Update changelog with clear “Added” entries.
+- Confirm packaging metadata includes/excludes new files intentionally.
+- If functionality is experimental, gate behind feature flags or internal namespace.
+
+---
+
+## 6. Deployment Information
+
+**Current deployment recommendation:** ⛔ **Do not deploy/promote** this revision to production or release tags while test status is failed.
+
+### Pre-deployment Checklist
+- [ ] All failing tests fixed and passing.
+- [ ] New files covered by tests at acceptable threshold.
+- [ ] Static checks (lint/type/security) pass.
+- [ ] Packaging and import validation pass.
+- [ ] Release notes/changelog updated.
+- [ ] CI rerun successful on full matrix.
+
+---
+
+## 7. Future Planning
+
+## 7.1 Short-Term (Next 1–2 iterations)
+- Stabilize failing tests and merge with green CI.
+- Add regression tests tied to current failure signatures.
+- Improve test diagnostics (clear assertions, deterministic fixtures).
+
+## 7.2 Mid-Term
+- Strengthen contribution guardrails:
+  - require test pass before merge,
+  - enforce coverage delta checks for newly added files.
+- Introduce targeted smoke tests for package import and basic functionality.
+
+## 7.3 Long-Term
+- Build reliability dashboards for CI trends (pass rate, flaky tests, duration).
+- Standardize module templates for new files (tests + docs + typing + examples).
+
+---
+
+## 8. Conclusion
+
+This update is structurally additive (**8 new files, no direct edits**), which is generally low-intrusive. However, **failed tests make the change set not release-ready**. Prioritize root-cause analysis of failures, close coverage gaps for the new files, and require a fully green CI matrix before deployment.

MetPy/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,293 @@
+import os
+import sys
+import traceback
+import importlib
+from typing import Any, Dict, List, Optional
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+sys.path.insert(0, source_path)
+
+
+class Adapter:
+    """
+    MCP Import-Mode Adapter for MetPy repository.
+
+    This adapter prefers direct import/use of repository modules and provides a
+    graceful fallback "blackbox" mode when imports fail.
+    """
+
+    def __init__(self) -> None:
+        self.mode = "import"
+        self.repo_url = "https://github.com/Unidata/MetPy"
+        self.package_root = "src.metpy"
+        self._modules: Dict[str, Any] = {}
+        self._import_errors: List[str] = []
+        self._load_modules()
+
+    # -------------------------------------------------------------------------
+    # Internal helpers
+    # -------------------------------------------------------------------------
+    def _ok(self, data: Any = None, message: str = "success", **extra: Any) -> Dict[str, Any]:
+        resp = {"status": "success", "mode": self.mode, "message": message, "data": data}
+        if extra:
+            resp.update(extra)
+        return resp
+
+    def _err(self, message: str, error: Optional[Exception] = None, **extra: Any) -> Dict[str, Any]:
+        resp = {"status": "error", "mode": self.mode, "message": message}
+        if error is not None:
+            resp["error"] = str(error)
+            resp["traceback"] = traceback.format_exc(limit=2)
+        if extra:
+            resp.update(extra)
+        return resp
+
+    def _fallback(self, action: str, guidance: str) -> Dict[str, Any]:
+        return {
+            "status": "fallback",
+            "mode": self.mode,
+            "action": action,
+            "message": "Import mode unavailable. Switched to fallback behavior.",
+            "guidance": guidance,
+        }
+
+    def _load_modules(self) -> None:
+        targets = [
+            "src.metpy",
+            "src.metpy.calc",
+            "src.metpy.interpolate",
+            "src.metpy.io",
+            "src.metpy.plots",
+            "src.metpy.remote",
+            "src.metpy.units",
+            "src.metpy.constants",
+            "src.metpy.xarray",
+        ]
+        for name in targets:
+            try:
+                self._modules[name] = importlib.import_module(name)
+            except Exception as e:
+                self._import_errors.append(f"{name}: {e}")
+
+        if self._import_errors:
+            self.mode = "blackbox"
+
+    def health(self) -> Dict[str, Any]:
+        """
+        Return adapter health and import diagnostics.
+        """
+        return self._ok(
+            data={
+                "repo_url": self.repo_url,
+                "package_root": self.package_root,
+                "loaded_modules": sorted(self._modules.keys()),
+                "import_errors": self._import_errors,
+            },
+            message="adapter initialized",
+        )
+
+    # -------------------------------------------------------------------------
+    # Module management
+    # -------------------------------------------------------------------------
+    def list_modules(self) -> Dict[str, Any]:
+        """
+        List managed MetPy modules loaded by this adapter.
+        """
+        return self._ok(data=sorted(self._modules.keys()))
+
+    def get_module(self, module_name: str) -> Dict[str, Any]:
+        """
+        Get a loaded module by full path (e.g., 'src.metpy.calc').
+
+        Parameters:
+            module_name: Full module import path.
+        """
+        try:
+            mod = self._modules.get(module_name)
+            if mod is None:
+                return self._err(
+                    f"Module '{module_name}' is not loaded.",
+                    None,
+                    guidance="Call reload_module or verify source path and dependencies.",
+                )
+            return self._ok(data={"module": module_name, "repr": repr(mod)})
+        except Exception as e:
+            return self._err("Failed to access module.", e)
+
+    def reload_module(self, module_name: str) -> Dict[str, Any]:
+        """
+        Reload a specific module by full path.
+        """
+        try:
+            mod = importlib.import_module(module_name)
+            mod = importlib.reload(mod)
+            self._modules[module_name] = mod
+            if self.mode == "blackbox":
+                self.mode = "import"
+            return self._ok(data={"module": module_name}, message="module reloaded")
+        except Exception as e:
+            self.mode = "blackbox"
+            return self._err(
+                f"Failed to reload module '{module_name}'.",
+                e,
+                guidance="Ensure optional dependencies are installed and module path is correct.",
+            )
+
+    # -------------------------------------------------------------------------
+    # Generic invocation utilities (comprehensive fallback for unknown symbols)
+    # -------------------------------------------------------------------------
+    def call_function(self, module_name: str, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call any function from a managed module.
+
+        Parameters:
+            module_name: Full module path, e.g., 'src.metpy.calc'
+            function_name: Function attribute name
+            *args/**kwargs: Forwarded to target function
+        """
+        if self.mode != "import":
+            return self._fallback(
+                action="call_function",
+                guidance="Restore import mode by installing required dependencies: numpy, scipy, pint, packaging.",
+            )
+        try:
+            mod = self._modules.get(module_name) or importlib.import_module(module_name)
+            fn = getattr(mod, function_name, None)
+            if fn is None or not callable(fn):
+                return self._err(
+                    f"Function '{function_name}' not found in module '{module_name}'.",
+                    None,
+                    guidance="Inspect available names via inspect_module.",
+                )
+            result = fn(*args, **kwargs)
+            return self._ok(data=result, message=f"{module_name}.{function_name} executed")
+        except Exception as e:
+            return self._err(
+                f"Failed to execute function '{function_name}' from '{module_name}'.",
+                e,
+                guidance="Verify parameter units/types expected by MetPy functions.",
+            )
+
+    def create_instance(self, module_name: str, class_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Instantiate any class from a managed module.
+
+        Parameters:
+            module_name: Full module path, e.g., 'src.metpy.plots'
+            class_name: Class attribute name
+            *args/**kwargs: Forwarded to class constructor
+        """
+        if self.mode != "import":
+            return self._fallback(
+                action="create_instance",
+                guidance="Install optional plotting/IO dependencies if constructing advanced classes.",
+            )
+        try:
+            mod = self._modules.get(module_name) or importlib.import_module(module_name)
+            cls = getattr(mod, class_name, None)
+            if cls is None:
+                return self._err(
+                    f"Class '{class_name}' not found in module '{module_name}'.",
+                    None,
+                    guidance="Inspect available names via inspect_module.",
+                )
+            instance = cls(*args, **kwargs)
+            return self._ok(data={"class": class_name, "instance_repr": repr(instance)})
+        except Exception as e:
+            return self._err(
+                f"Failed to instantiate class '{class_name}' from '{module_name}'.",
+                e,
+                guidance="Check constructor arguments and optional dependency availability.",
+            )
+
+    def inspect_module(self, module_name: str, include_private: bool = False) -> Dict[str, Any]:
+        """
+        Inspect attributes of a module and group into classes/functions/others.
+        """
+        try:
+            mod = self._modules.get(module_name) or importlib.import_module(module_name)
+            names = dir(mod)
+            if not include_private:
+                names = [n for n in names if not n.startswith("_")]
+            classes, functions, others = [], [], []
+            for n in names:
+                obj = getattr(mod, n, None)
+                if obj is None:
+                    continue
+                if isinstance(obj, type):
+                    classes.append(n)
+                elif callable(obj):
+                    functions.append(n)
+                else:
+                    others.append(n)
+            return self._ok(
+                data={
+                    "module": module_name,
+                    "classes": sorted(classes),
+                    "functions": sorted(functions),
+                    "others": sorted(others),
+                }
+            )
+        except Exception as e:
+            return self._err("Failed to inspect module.", e)
+
+    # -------------------------------------------------------------------------
+    # High-level convenience wrappers for detected core modules
+    # -------------------------------------------------------------------------
+    def calc_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.calc."""
+        return self.call_function("src.metpy.calc", function_name, *args, **kwargs)
+
+    def interpolate_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.interpolate."""
+        return self.call_function("src.metpy.interpolate", function_name, *args, **kwargs)
+
+    def io_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.io."""
+        return self.call_function("src.metpy.io", function_name, *args, **kwargs)
+
+    def plots_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.plots."""
+        return self.call_function("src.metpy.plots", function_name, *args, **kwargs)
+
+    def remote_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.remote."""
+        return self.call_function("src.metpy.remote", function_name, *args, **kwargs)
+
+    def units_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.units."""
+        return self.call_function("src.metpy.units", function_name, *args, **kwargs)
+
+    def xarray_call(self, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """Call a function from src.metpy.xarray."""
+        return self.call_function("src.metpy.xarray", function_name, *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Dependency and guidance utilities
+    # -------------------------------------------------------------------------
+    def dependency_status(self) -> Dict[str, Any]:
+        """
+        Check required and optional dependencies from analysis guidance.
+        """
+        required = ["numpy", "scipy", "pint", "packaging"]
+        optional = ["xarray", "pandas", "matplotlib", "cartopy", "pyproj", "netCDF4", "pooch", "siphon"]
+
+        def check(pkg: str) -> bool:
+            try:
+                importlib.import_module(pkg)
+                return True
+            except Exception:
+                return False
+
+        req_status = {p: check(p) for p in required}
+        opt_status = {p: check(p) for p in optional}
+        return self._ok(
+            data={
+                "required": req_status,
+                "optional": opt_status,
+                "all_required_available": all(req_status.values()),
+            }
+        )

MetPy/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

MetPy/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,314 @@
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from metpy.calc import (
+    advection,
+    cape_cin,
+    dewpoint_from_relative_humidity,
+    equivalent_potential_temperature,
+    lcl,
+    potential_temperature,
+    relative_humidity_from_dewpoint,
+    vorticity,
+    wind_speed,
+)
+from metpy.constants import g
+from metpy.io import parse_metar_file
+from metpy.units import units
+
+mcp = FastMCP("metpy_service")
+
+
+def _ok(result: Any) -> Dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
+
+
+def _err(message: str) -> Dict[str, Any]:
+    return {"success": False, "result": None, "error": message}
+
+
+@mcp.tool(name="calc_wind_speed", description="Compute wind speed from u and v wind components.")
+def calc_wind_speed(u_ms: float, v_ms: float) -> Dict[str, Any]:
+    """
+    Calculate scalar wind speed.
+
+    Parameters:
+        u_ms: Zonal wind component in meters per second.
+        v_ms: Meridional wind component in meters per second.
+
+    Returns:
+        Dictionary with success/result/error where result is wind speed in m/s.
+    """
+    try:
+        ws = wind_speed(u_ms * units("m/s"), v_ms * units("m/s"))
+        return _ok(float(ws.to("m/s").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_potential_temperature", description="Compute potential temperature from pressure and temperature.")
+def calc_potential_temperature(pressure_hpa: float, temperature_c: float) -> Dict[str, Any]:
+    """
+    Calculate potential temperature.
+
+    Parameters:
+        pressure_hpa: Air pressure in hPa.
+        temperature_c: Air temperature in degrees Celsius.
+
+    Returns:
+        Dictionary with success/result/error where result is theta in Kelvin.
+    """
+    try:
+        theta = potential_temperature(pressure_hpa * units.hPa, temperature_c * units.degC)
+        return _ok(float(theta.to("kelvin").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_lcl", description="Compute lifting condensation level pressure and temperature.")
+def calc_lcl(
+    pressure_hpa: float, temperature_c: float, dewpoint_c: float
+) -> Dict[str, Any]:
+    """
+    Calculate LCL pressure and temperature.
+
+    Parameters:
+        pressure_hpa: Parcel pressure in hPa.
+        temperature_c: Parcel temperature in degrees Celsius.
+        dewpoint_c: Parcel dewpoint in degrees Celsius.
+
+    Returns:
+        Dictionary with success/result/error where result contains lcl_pressure_hpa and lcl_temperature_c.
+    """
+    try:
+        lcl_p, lcl_t = lcl(
+            pressure_hpa * units.hPa,
+            temperature_c * units.degC,
+            dewpoint_c * units.degC,
+        )
+        return _ok(
+            {
+                "lcl_pressure_hpa": float(lcl_p.to("hPa").magnitude),
+                "lcl_temperature_c": float(lcl_t.to("degC").magnitude),
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_rh_from_dewpoint", description="Compute relative humidity from temperature and dewpoint.")
+def calc_rh_from_dewpoint(temperature_c: float, dewpoint_c: float) -> Dict[str, Any]:
+    """
+    Calculate relative humidity.
+
+    Parameters:
+        temperature_c: Air temperature in degrees Celsius.
+        dewpoint_c: Dewpoint temperature in degrees Celsius.
+
+    Returns:
+        Dictionary with success/result/error where result is relative humidity as a fraction [0, 1].
+    """
+    try:
+        rh = relative_humidity_from_dewpoint(
+            temperature_c * units.degC, dewpoint_c * units.degC
+        )
+        return _ok(float(rh.to("dimensionless").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_dewpoint_from_rh", description="Compute dewpoint from air temperature and relative humidity.")
+def calc_dewpoint_from_rh(temperature_c: float, relative_humidity: float) -> Dict[str, Any]:
+    """
+    Calculate dewpoint from temperature and RH.
+
+    Parameters:
+        temperature_c: Air temperature in degrees Celsius.
+        relative_humidity: Relative humidity as fraction [0, 1].
+
+    Returns:
+        Dictionary with success/result/error where result is dewpoint in degrees Celsius.
+    """
+    try:
+        td = dewpoint_from_relative_humidity(
+            temperature_c * units.degC, relative_humidity * units.dimensionless
+        )
+        return _ok(float(td.to("degC").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_equivalent_potential_temperature", description="Compute equivalent potential temperature.")
+def calc_equivalent_potential_temperature(
+    pressure_hpa: float, temperature_c: float, dewpoint_c: float
+) -> Dict[str, Any]:
+    """
+    Calculate equivalent potential temperature.
+
+    Parameters:
+        pressure_hpa: Air pressure in hPa.
+        temperature_c: Air temperature in degrees Celsius.
+        dewpoint_c: Dewpoint temperature in degrees Celsius.
+
+    Returns:
+        Dictionary with success/result/error where result is theta-e in Kelvin.
+    """
+    try:
+        theta_e = equivalent_potential_temperature(
+            pressure_hpa * units.hPa, temperature_c * units.degC, dewpoint_c * units.degC
+        )
+        return _ok(float(theta_e.to("kelvin").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_cape_cin", description="Compute CAPE and CIN from vertical profiles.")
+def calc_cape_cin(
+    pressure_hpa: List[float], temperature_c: List[float], dewpoint_c: List[float]
+) -> Dict[str, Any]:
+    """
+    Calculate CAPE and CIN for a sounding profile.
+
+    Parameters:
+        pressure_hpa: Pressure profile in hPa.
+        temperature_c: Temperature profile in degrees Celsius.
+        dewpoint_c: Dewpoint profile in degrees Celsius.
+
+    Returns:
+        Dictionary with success/result/error where result contains cape_j_per_kg and cin_j_per_kg.
+    """
+    try:
+        p = pressure_hpa * units.hPa
+        t = temperature_c * units.degC
+        td = dewpoint_c * units.degC
+        cape, cin = cape_cin(p, t, td)
+        return _ok(
+            {
+                "cape_j_per_kg": float(cape.to("J/kg").magnitude),
+                "cin_j_per_kg": float(cin.to("J/kg").magnitude),
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_vertical_vorticity", description="Compute vertical vorticity from wind and grid spacing.")
+def calc_vertical_vorticity(
+    u_ms: List[List[float]],
+    v_ms: List[List[float]],
+    dx_m: float,
+    dy_m: float,
+) -> Dict[str, Any]:
+    """
+    Calculate vertical vorticity on a regular grid.
+
+    Parameters:
+        u_ms: 2D zonal wind field in m/s.
+        v_ms: 2D meridional wind field in m/s.
+        dx_m: Grid spacing in x direction (meters).
+        dy_m: Grid spacing in y direction (meters).
+
+    Returns:
+        Dictionary with success/result/error where result is a 2D list of vorticity in 1/s.
+    """
+    try:
+        import numpy as np
+
+        u = np.array(u_ms) * units("m/s")
+        v = np.array(v_ms) * units("m/s")
+        zeta = vorticity(u, v, dx=dx_m * units.meter, dy=dy_m * units.meter)
+        return _ok(zeta.to("1/s").magnitude.tolist())
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="calc_advection_scalar", description="Compute scalar advection using wind and scalar field gradients.")
+def calc_advection_scalar(
+    scalar_field: List[List[float]],
+    u_ms: List[List[float]],
+    v_ms: List[List[float]],
+    dx_m: float,
+    dy_m: float,
+) -> Dict[str, Any]:
+    """
+    Calculate horizontal advection of a scalar field.
+
+    Parameters:
+        scalar_field: 2D scalar field (unitless values).
+        u_ms: 2D zonal wind field in m/s.
+        v_ms: 2D meridional wind field in m/s.
+        dx_m: Grid spacing in x direction in meters.
+        dy_m: Grid spacing in y direction in meters.
+
+    Returns:
+        Dictionary with success/result/error where result is 2D advection field in scalar units per second.
+    """
+    try:
+        import numpy as np
+
+        s = np.array(scalar_field) * units.dimensionless
+        u = np.array(u_ms) * units("m/s")
+        v = np.array(v_ms) * units("m/s")
+        adv = advection(s, u=u, v=v, dx=dx_m * units.meter, dy=dy_m * units.meter)
+        return _ok(adv.to("1/s").magnitude.tolist())
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="parse_metar_text", description="Parse METAR text and return selected station records.")
+def parse_metar_text(metar_text: str, year: Optional[int] = None, month: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Parse raw METAR text content.
+
+    Parameters:
+        metar_text: Raw METAR bulletin text with one report per line.
+        year: Optional year for parsing date context.
+        month: Optional month for parsing date context.
+
+    Returns:
+        Dictionary with success/result/error where result is a list of parsed records.
+    """
+    try:
+        import io
+
+        kwargs: Dict[str, Any] = {}
+        if year is not None:
+            kwargs["year"] = year
+        if month is not None:
+            kwargs["month"] = month
+
+        df = parse_metar_file(io.StringIO(metar_text), **kwargs)
+        records = df.head(100).to_dict(orient="records")
+        return _ok(records)
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="get_gravity_constant", description="Return standard gravity constant from MetPy constants.")
+def get_gravity_constant() -> Dict[str, Any]:
+    """
+    Fetch standard gravitational acceleration.
+
+    Parameters:
+        None.
+
+    Returns:
+        Dictionary with success/result/error where result is gravity in m/s^2.
+    """
+    try:
+        return _ok(float(g.to("m/s^2").magnitude))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+def create_app() -> FastMCP:
+    return mcp

MetPy/mcp_output/requirements.txt

@@ -0,0 +1,14 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+matplotlib>=3.7.0
+numpy>=1.25.0
+pandas>=2.1.0
+pint>=0.22
+pooch>=1.2.0
+pyproj>=3.4.0
+scipy>=1.10.0
+traitlets>=5.1.0
+xarray>=2022.6.0
+packaging

MetPy/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

MetPy/mcp_output/workflow_summary.json

@@ -0,0 +1,225 @@
+{
+  "repository": {
+    "name": "MetPy",
+    "url": "https://github.com/Unidata/MetPy",
+    "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/MetPy",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1773278863.8095639,
+    "end_time": 1773279187.500253,
+    "duration": 323.69068908691406,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 2,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.benchmarks.benchmarks",
+        "source.src.metpy"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": true,
+      "setup_cfg": true,
+      "setup_py": false
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.91,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/Unidata/MetPy",
+      "repo_name": "MetPy",
+      "error": "DeepWiki analysis failed",
+      "model": "gpt-5.3-codex",
+      "source": "llm_direct_analysis",
+      "success": false
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/MetPy/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Add a minimal MCP smoke test suite (server startup + 2–3 representative endpoints like `cape_cin`",
+    "`vorticity`",
+    "`parse_metar_file`) into CI",
+    "Define and enforce endpoint input/output schemas with Pydantic models (units",
+    "dimensionality",
+    "and array shape validation) to reduce runtime ambiguity",
+    "Introduce tiered endpoint sets (core-safe vs heavy-optional) so `plots`/`cartopy`/radar features are conditionally enabled based on installed extras",
+    "Add structured error mapping in the adapter layer (ValueError/UnitError/File I/O → stable MCP error codes/messages) for client reliability",
+    "Create regression tests for unit-handling edge cases (Pint quantities",
+    "masked arrays",
+    "xarray coordinates) across exposed endpoints",
+    "Pin and document compatibility matrix for Python + numpy/scipy/pint/xarray in `mcp_output/README_MCP.md`",
+    "Add benchmark gates for high-cost functions (`cape_cin`",
+    "`interpolate_to_grid`",
+    "`q_vector`) and track drift with existing ASV patterns",
+    "Improve import resilience by lazy-loading heavy modules (`plots`",
+    "`io.nexrad`) and emitting clear dependency-missing hints",
+    "Add contract tests to verify generated endpoint names map correctly to callable objects (especially class wrappers like `level2file`",
+    "`skewt`",
+    "accessors)",
+    "Provide example client payloads/responses for 5–10 common workflows in MCP README to reduce integration errors",
+    "Add observability hooks (request timing",
+    "endpoint success/failure counts",
+    "exception taxonomy) for MCP runtime diagnostics",
+    "Enforce static checks on plugin code (ruff/mypy/pyright) and align formatting/linting with repository standards",
+    "Add security hardening for file-based endpoints (`parse_metar_file`",
+    "radar readers): path allowlists",
+    "size limits",
+    "and timeout controls",
+    "Create golden-data tests using existing `staticdata/` and `tests/remote/fixtures/` to validate deterministic MCP outputs",
+    "Add release automation for the MCP artifact (versioning tied to MetPy tag/commit + changelog of exposed endpoints)",
+    "Document deprecation policy for endpoint names/arguments to prevent breaking downstream MCP clients"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Workflow completed end-to-end with status=success across all planned nodes (download, analysis, env, generate, run, review, finalize).",
+      "Import-based adapter strategy was feasible (import_feasibility ~0.91) and aligned with low intrusiveness risk.",
+      "Generated MCP plugin started healthy over stdio and passed plugin-level validation.",
+      "Repository structure and module discovery were strong enough to expose a broad endpoint set from high-value MetPy modules.",
+      "No runtime errors or warnings were reported by the orchestration pipeline."
+    ],
+    "failure_reasons": [
+      "Original project tests were not executed successfully (passed=false) despite reported 100% coverage metadata, indicating test execution/collection inconsistency.",
+      "DeepWiki analysis failed, reducing external architectural/context enrichment.",
+      "Telemetry quality is weak (0 LOC, 0 file size, 0 performance metrics) and prevents evidence-based quality/performance validation.",
+      "Generated tool_endpoints reported as 0 in one section, while service endpoints list is non-empty, indicating reporting/schema inconsistency."
+    ],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Completed successfully; repo imported via zip fallback (262 files). No per-node timing available, so exact duration cannot be isolated.",
+      "analysis_time": "Successful static/LLM-assisted analysis with medium complexity and maintainability index 75; DeepWiki substep failed.",
+      "generation_time": "Generation completed with 7 files and import adapter mode; endpoint exposure appears extensive, but generation telemetry is inconsistent.",
+      "test_time": "Plugin health checks passed; original project test status failed/not run meaningfully. Test evidence is partial."
+    },
+    "resource_usage": {
+      "memory_efficiency": "Unknown in practice; reported memory_usage_mb=0 indicates missing instrumentation rather than zero usage.",
+      "cpu_efficiency": "Unknown in practice; cpu_usage_percent=0 suggests metrics were not captured.",
+      "disk_usage": "Generated artifact footprint reported as 0, likely telemetry defect; actual disk usage is non-zero given created files."
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 74,
+    "architecture_score": 80,
+    "performance_score": 62,
+    "maintainability_score": 72,
+    "security_score": 85,
+    "scalability_score": 70
+  }
+}

MetPy/source/.codecov.yml

@@ -0,0 +1,24 @@
+coverage:
+  status:
+    patch:
+      default:
+        target: '80'
+    project:
+      library:
+        target: auto
+        threshold: 0.1%
+        paths:
+          - "src/metpy/.*"
+
+      tests:
+        target: 100%
+        paths:
+          - "tests/.*"
+          - "src/metpy/testing.py"
+
+  notify:
+    gitter:
+      default:
+        url: "https://webhooks.gitter.im/e/301b8fd7792e1a48b034"
+
+comment: off

MetPy/source/.codespellexclude

@@ -0,0 +1,19 @@
+            r'^(z|lv_|bottom_top|sigma|h(ei)?ght|altitude|depth|isobaric|pres|isotherm)'
+  | ``(thta, u, v, dx, dy, dim_order='yx')``                                                                         |
+       Changed signature from ``(thta, u, v, dx, dy, dim_order='yx')``
+    dpres = gempak.PRES.values
+    pres = 1
+    thta = 2
+                lambda grid: grid if grid.PARM in parameter else False,
+                            col_head.SELV,
+                'SELV': col_head.SELV,
+                                col_head.SELV,
+                                row_head.SELV,
+                'SELV': row_head.SELV,
+                'SELV': col_head.SELV,
+# GFS, NAM, RAP, or other gridded dataset (e.g., NARR).
+# This attribute can be set to False if the vector components are grid relative (e.g., for NAM
+    components that are earth-relative. The primary exception is NAM output with wind
+                                    col_head.SELV,
+                                    row_head.SELV,
+            by the archive (currently FOUR, PANG, GRAP, AURO), or the known names (

MetPy/source/.codespellignore

@@ -0,0 +1 @@
+trough

MetPy/source/.coveragerc

@@ -0,0 +1,10 @@
+[paths]
+source =
+    src/
+    /*/site-packages
+
+[run]
+source = tests
+source_pkgs = metpy
+omit =
+    src/metpy/io/_nexrad_msgs/parse_spec.py

MetPy/source/.devcontainer/Dockerfile

@@ -0,0 +1,7 @@
+FROM mcr.microsoft.com/vscode/devcontainers/miniconda:latest
+
+COPY ci/*.txt ci-dev/*.txt /tmp/conda-tmp/
+RUN sed -i -e "s/scipy==.*/scipy==1.5.3/" /tmp/conda-tmp/requirements.txt
+RUN /opt/conda/bin/conda config --add channels conda-forge
+RUN /opt/conda/bin/conda config --set channel_priority strict
+RUN /opt/conda/bin/conda install --quiet --yes --file /tmp/conda-tmp/test_requirements.txt --file /tmp/conda-tmp/extra_requirements.txt --file /tmp/conda-tmp/requirements.txt --file /tmp/conda-tmp/linting_requirements.txt --file /tmp/conda-tmp/doc_requirements.txt

MetPy/source/.devcontainer/devcontainer.json

@@ -0,0 +1,43 @@
+{
+	"name": "Miniconda (Python 3)",
+	"build": { 
+		"context": "..",
+		"dockerfile": "Dockerfile",
+		"args": {
+			"INSTALL_NODE": "false"
+		}
+	},
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": { 
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"python.pythonPath": "/opt/conda/bin/python",
+		"python.languageServer": "Pylance",
+		"python.linting.enabled": true,
+		"python.linting.pylintEnabled": true,
+		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
+	},
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-python.python",
+		"ms-python.vscode-pylance"
+	],
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "python -m pip install --no-deps .",
+
+	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode"
+}

MetPy/source/.lgtm.yml

@@ -0,0 +1,7 @@
+path_classifiers:
+    generated:
+        - src/metpy/io/_metar_parser.py
+    library:
+        - src/metpy/deprecation.py
+    test:
+        - exclude: src/metpy/testing.py

MetPy/source/.mailmap

@@ -0,0 +1,26 @@
+John Leeman <kd5wxb@gmail.com>
+John Leeman <kd5wxb@gmail.com> <john@leemangeophysical.com>
+<rmay@ucar.edu> <rmay31@gmail.com>
+<sarms@ucar.edu> <sarms@unidata.ucar.edu>
+Kevin Goebbert <kevin.goebbert@valpo.edu>
+<kevin.goebbert@valpo.edu> <kevin.goebbert@gmail.com>
+<kevin.goebbert@valpo.edu> <kgoebber@users.noreply.github.com>
+Tyler Wixtrom <tjwixtrom@gmail.com> <twixtrom@candy.unidata.ucar.edu> 
+Tyler Wixtrom <tjwixtrom@gmail.com>
+Brian Mapes <mapes@miami.edu>
+Kristen Pozsonyi <knpozson@millersville.edu>
+Daryl Herzmann <akrherz@iastate.edu>
+Kishan Mehta <kishan@mobifly.co.uk>
+Matt Wilson <matthew.wilson@valpo.edu>
+Andrew Huang <ahuang11@illinois.edu>
+<ahuang11@illinois.edu> <huang.andrew12@gmail.com>
+Andrew Huang <ahuang11@illinois.edu> Andrew <15331990+ahuang11@users.noreply.github.com>
+<tsupinie@gmail.com> <tsupinie@ou.edu>
+Tim Supinie <tsupinie@gmail.com>
+Zach Bruick <zachary.bruick@valpo.edu>
+Joy Monteiro <joy.merwin@gmail.com>
+Steven Decker <sgdecker@envsci.rutgers.edu>
+<sgdecker@envsci.rutgers.edu> <decker@envsci.rutgers.edu>
+Claude Dicaire <31997745+eliteuser26@users.noreply.github.com>
+David Ahijevych <ahijevyc@ucar.edu>
+William Minchin <w_minchin@hotmail.com> MinchinWeb

MetPy/source/.markdownlint.yaml

@@ -0,0 +1,6 @@
+default: true
+
+extends: null
+
+MD013:
+  line_length: 95

MetPy/source/.mdl_style.rb

@@ -0,0 +1,6 @@
+all
+rule 'MD013', :line_length => 95
+rule 'MD026', :punctuation => ".,;:!"
+exclude_rule 'MD002'
+exclude_rule 'MD034'
+exclude_rule 'MD041'

MetPy/source/.mdlrc

@@ -0,0 +1,2 @@
+style '.mdl_style.rb'
+ignore_front_matter true

MetPy/source/.qlty/qlty.toml

@@ -0,0 +1,17 @@
+config_version = "0"
+
+exclude_patterns = [
+    "src/metpy/io/_nexrad_msgs/msg*.py",
+    "src/metpy/io/_metar_parser*"
+]
+test_patterns = ["tests/**/*.py"]
+
+[[source]]
+name = "default"
+default = true
+
+[smells.function_parameters]
+threshold = 10
+
+[smells.similar_code]
+enabled = false

MetPy/source/.stickler.yml

@@ -0,0 +1,4 @@
+linters:
+    flake8:
+        ignore: 'F405'
+        max-line-length: 95

MetPy/source/AUTHORS.txt

@@ -0,0 +1,52 @@
+The following are the contributors of code within MetPy:
+Aaron Hill
+Abby Kenyon
+Alex Haberlie
+Andrew Huang
+Assela Pathirana
+Brian Mapes
+Bryan Guarente
+Claude Dicaire
+Dan Dawson
+Daniel Adriaansen
+Daryl Herzmann
+David Ahijevych
+David Lawrence
+Denis Sergeev
+Drew Camron
+Eric Bruning
+Joern Ungermann
+John Leeman
+Jon Thielen
+Jonathan Helmus
+Joy Monteiro
+Kevin Goebbert
+Kishan Mehta
+Kristen Pozsonyi
+kstilwell
+Leonardo Uieda
+LProx2020
+Lucas Sterzinger
+Matt Wilson
+Max Grover
+Michael James
+mmorello1
+Nathan Wendt
+Patrick Marsh
+Raul Mendez
+Rich Signell
+Russell Manser
+Ryan May
+Sean Arms
+Shawn Murdzek
+Stefan Hofer
+Steven Decker
+Tim Supinie
+TJ Turnage
+Tyler Wixtrom
+UCAR/Unidata
+Vardan Nadkarni
+Warren Pettee
+Will Holmgren
+William Minchin
+Zach Bruick

MetPy/source/CITATION.cff

@@ -0,0 +1,142 @@
+abstract: >
+    MetPy is an open-source and community-driven Python package for meteorology designed to fit well within the scientific Python stack (numpy, matplotlib, etc.).
+    Its goal is to bring the scripted weather analysis capabilities of GEMPAK (and tools like it) to the powerful scientific Python ecosystem.
+    The guiding principle is to make MetPy easy to use with any dataset that can be read into Python.
+    MetPy's general functionality breaks down into reading data, meteorological calculations, and meteorology-specific plotting.
+authors: 
+  - family-names: May
+    given-names: Ryan
+    affiliation: "UCAR/Unidata"
+    orcid: "https://orcid.org/0000-0003-2907-038X"
+  - family-names: Arms
+    given-names: Sean
+    affiliation: "UCAR/Unidata"
+    orcid: "https://orcid.org/0000-0001-9835-113X"
+  - family-names: Marsh
+    given-names: Patrick
+  - family-names: Bruning
+    given-names: Eric
+    affiliation: "Texas Tech University"
+    orcid: "https://orcid.org/0000-0003-1959-442X"
+  - family-names: Leeman
+    given-names: John
+    orcid: "https://orcid.org/0000-0002-3624-1821"
+  - family-names: Goebbert
+    given-names: Kevin
+    affiliation: "Valparaiso University"
+    orcid: "https://orcid.org/0000-0001-7559-2432"
+  - family-names: Thielen
+    given-names: Jonathan
+    orcid: "https://orcid.org/0000-0002-5479-0189"
+  - family-names: Bruick
+    given-names: Zachary
+    orcid: "https://orcid.org/0000-0002-0299-9845"
+  - family-names: Camron
+    given-names: "M. Drew"
+    affiliation: "UCAR/Unidata"
+    orcid: "https://orcid.org/0000-0001-7246-6502"
+cff-version: "1.2.0"
+contact:
+  - name: Unidata
+    city: Boulder
+    region: Colorado
+    country: US
+    email: "support@unidata.ucar.edu"
+    tel: "303-497-8643"
+    fax: "303-497-8690"
+    website: "https://www.unidata.ucar.edu"
+doi: "10.5065/D6WW7G29"
+keywords:
+  - meteorology
+  - weather
+license: "BSD-3-Clause"
+message: "If you use or contribute to MetPy, please use this information to reference it."
+repository-code: "https://github.com/Unidata/MetPy"
+title: "MetPy: A Python Package for Meteorological Data"
+type: software
+url: "https://www.unidata.ucar.edu/software/metpy/"
+references:
+  - type: grant
+    authors:
+      - family-names: Ramamurthy
+        given-names: Mohan
+        email: "mohan@ucar.edu"
+    date-released: 2014-04-01
+    institution:
+      name: "National Science Foundation"
+    identifiers:
+      - description: "NSF award number."
+        type: other
+        value: "AGS-1344155"
+    title: "Unidata 2018: Transforming Geoscience through Innovative Data Services"
+    url: "https://www.nsf.gov/awardsearch/showAward?AWD_ID=1344155"
+  - type: grant
+    authors:
+      - family-names: May
+        given-names: Ryan
+        email: "rmay@ucar.edu"
+      - family-names: Goebbert
+        given-names: Kevin
+      - family-names: Leeman
+        given-names: John
+    date-released: 2017-09-01
+    institution:
+      name: "National Science Foundation"
+    identifiers:
+      - description: "NSF award number."
+        type: other
+        value: "OAC-1740315"
+    title: "MetPy - A Python GEMPAK Replacement for Meteorological Data Analysis"
+    url: "https://www.nsf.gov/awardsearch/showAward?AWD_ID=1740315"
+  - type: grant
+    authors:
+      - family-names: Paul
+        given-names: Kevin
+        email: "kpaul@ucar.edu"
+      - family-names: May
+        given-names: Ryan
+      - family-names: Hamman
+        given-names: Joseph
+      - family-names: "Del Vento"
+        given-names: Davide
+    date-released: 2017-08-21
+    institution:
+      name: "National Science Foundation"
+    identifiers:
+      - description: "NSF award number."
+        type: other
+        value: "OCE-1740633"
+    title: "Pangeo: An Open Source Big Data Climate Science Platform"
+    url: "https://www.nsf.gov/awardsearch/showAward?AWD_ID=1740633"
+  - type: grant
+    authors:
+      - family-names: Ramamurthy
+        given-names: Mohan
+        email: "mohan@ucar.edu"
+    date-released: 2019-05-01
+    institution:
+      name: "National Science Foundation"
+    identifiers:
+      - description: "NSF award number."
+        type: other
+        value: "AGS-1901712"
+    title: "Unidata: Next-generation Data Services and Workflows to Advance Geoscience Research and Education"
+    url: "https://www.nsf.gov/awardsearch/showAward?AWD_ID=1901712"
+  - type: grant
+    authors:
+      - family-names: May
+        given-names: Ryan
+        email: "rmay@ucar.edu"
+      - family-names: Goebbert
+        given-names: Kevin
+      - family-names: Camron
+        given-names: Michael
+    date-released: 2021-05-01
+    institution:
+      name: "National Science Foundation"
+    identifiers:
+      - description: "NSF award number."
+        type: other
+        value: "OAC-2103682"
+    title: "Elements: Scaling MetPy to Big Data Workflows in Meteorology and Climate Science"
+    url: "https://www.nsf.gov/awardsearch/showAward?AWD_ID=2103682"

MetPy/source/CLA.md

@@ -0,0 +1,217 @@
+# About the Contributor License Agreement
+
+Everybody who contributes code to MetPy is going to be asked to sign a
+Contributor License Agreement (CLA). MetPy's CLA comes from
+[Project Harmony](http://www.harmonyagreements.org), which is a
+community-centered group focused on contributor agreements for free and open
+source software.
+
+The document you are reading now is not a legal analysis of the CLA. If you
+want one of those, please talk to your lawyer. This is a description of the
+purpose of the CLA.
+
+## Frequently Asked Questions (FAQ)
+
+### Why is a signed CLA required?
+
+The license agreement is a legal document in which you state you are entitled to
+contribute the code/documentation to MetPy and are willing to have it used in
+distributions and derivative works. This means that should there be any kind of
+legal issue in the future as to the origins and ownership of any particular
+piece of code, we have the necessary forms on file from the contributor(s)
+saying they were permitted to make this contribution.
+
+The CLA also ensures that once you have provided a contribution, you cannot try
+to withdraw permission for its use at a later date. People and companies can
+therefore use MetPy, confident that they will not be asked to stop using pieces
+of the code at a later date.
+
+Lastly, the CLA gives the MetPy project permission to change the license under
+which the project, including the various contributions from many developers, is
+distributed in the future. The CLA states that this license needs to be one
+that has been approved by the Open Source Initiative, including both copyleft
+and permissive licenses. This just gives the freedom to adjust licenses in the
+future if needed (e.g. some clause of the current license is found to be invalid).
+
+### Am I giving away the copyright to my contributions?
+
+No. This is a pure license agreement, not a copyright assignment. You still
+maintain the full copyright for your contributions. You are only providing a
+license to MetPy to distribute your code without further restrictions. This is
+not the case for all CLA's, but it is the case for the one we are using.
+
+### What about if I do MetPy development as part of my job?
+
+If any of your contributions to MetPy are created as part of your employment by
+somebody else, the work might not actually belong to you. It may be owned by
+your employer. In that case, your employer, or somebody able to represent the
+company as far as licensing goes, needs to sign the corporate version of the
+Contributor Licensing Agreement in order for that contribution to be accepted
+into MetPy. They will need to include the names of any developers (you and any
+others covered by that agreement) who are able to submit contributions on
+behalf of the employer. That list can be updated as new people are employed or
+others leave.
+
+You should also still sign an individual CLA in that case. Not all the work you
+do will necessarily belong to your employer and we still need permission to
+license your individual contributions.
+
+If you have signed an individual CLA, but not a corporate one, be very careful
+about submitting contributions you have made. We cannot accept anything that you
+do not have the rights to license in the first place and that includes code that
+belongs to your employer. Similarly, if you are a consultant who may be creating
+MetPy patches as part of a job, make sure you and your employer understand who
+owns the rights to the code. Only submit things that you are entitled to. The
+CLA is a legal declaration by you that you have the right to grant such a
+license for your contributions. It is up to you to make sure that is true.
+
+### Can I withdraw permission to use my contributions at a later date?
+
+No. This is one of the reasons we require a CLA. No individual contributor can hold
+such a threat over the entire community of users. Once you make a contribution, you
+are saying we can use that piece of code forever.
+
+### Can I submit patches without having signed the CLA?
+
+No. We will be asking all new contributors and patch submitters to sign before
+they submit anything.
+
+Based on material Copyright Django Software Foundation. [CC-BY](http://creativecommons.org/licenses/by/3.0/us/)
+Modified slightly to reflect MetPy.
+
+## UCAR/Unidata Individual Contributor License Agreement
+
+Thank you for your interest in contributing to UCAR/Unidata ("We" or "Us"). This contributor
+agreement ("Agreement") documents the rights granted by contributors to Us. To make this
+document effective, please sign it and send it to Us by electronic submission on
+https://cla-assistant.io. This is a legally binding document, so please read it carefully
+before agreeing to it. The Agreement may cover more than one software project managed by Us.
+
+(1) Definitions
+
+"You" means the individual who Submits a Contribution to Us.
+
+"Contribution" means any work of authorship that is Submitted by You to Us in which You own or
+assert ownership of the Copyright.
+
+"Copyright" means all rights protecting works of authorship owned or controlled by You,
+including copyright, moral and neighboring rights, as appropriate, for the full term of their
+existence including any extensions by You.
+
+"Material" means the work of authorship which is made available by Us to third parties. When
+this Agreement covers more than one software project, the Material means the work of authorship
+to which the Contribution was Submitted. After You Submit the Contribution, it may be included
+in the Material.
+
+"Submit" means any form of electronic, verbal, or written communication sent to Us or our
+representatives, including but not limited to electronic mailing lists, source code control
+systems, and issue tracking systems that are managed by, or on behalf of, Us for the purpose of
+discussing and improving the Material, but excluding communication that is conspicuously marked
+or otherwise designated in writing by You as "Not a Contribution."
+
+"Submission Date" means the date on which You Submit a Contribution to Us.
+
+"Effective Date" means the date You execute this Agreement or the date You first Submit a
+Contribution to Us, whichever is earlier.
+
+(2) Grant of Rights
+
+(2.1) Copyright License
+
+(a) You retain ownership of the Copyright in Your Contribution and have the same rights to use
+or license the Contribution which You would have had without entering into the Agreement.
+
+(b) To the maximum extent permitted by the relevant law, You grant to Us a perpetual,
+worldwide, non-exclusive, transferable, royalty-free, irrevocable license under the Copyright
+covering the Contribution, with the right to sublicense such rights through multiple tiers of
+sublicensees, to reproduce, modify, display, perform and distribute the Contribution as part of
+the Material; provided that this license is conditioned upon compliance with Section 2.3.
+
+(2.2) Patent License
+
+For patent claims including, without limitation, method, process, and apparatus claims which
+You own, control or have the right to grant, now or in the future, You grant to Us a perpetual,
+worldwide, non-exclusive, transferable, royalty-free, irrevocable patent license, with the
+right to sublicense these rights to multiple tiers of sublicensees, to make, have made, use,
+sell, offer for sale, import and otherwise transfer the Contribution and the Contribution in
+combination with the Material (and portions of such combination). This license is granted only
+to the extent that the exercise of the licensed rights infringes such patent claims; and
+provided that this license is conditioned upon compliance with Section 2.3.
+
+(2.3) Outbound License
+
+As a condition on the grant of rights in Sections 2.1 and 2.2, We agree to license the
+Contribution only under the terms of the license or licenses which We are using on the
+Submission Date for the Material or any licenses which are approved by the Open Source
+Initiative on or after the Effective Date, including both permissive and copyleft licenses,
+whether or not such licenses are subsequently disapproved (including any right to adopt any
+future version of a license if permitted).
+
+(2.4) Moral Rights. If moral rights apply to the Contribution, to the maximum extent permitted by
+law, You waive and agree not to assert such moral rights against Us or our successors in
+interest, or any of our licensees, either direct or indirect.
+
+(2.5) Our Rights. You acknowledge that We are not obligated to use Your Contribution as part of
+the Material and may decide to include any Contribution We consider appropriate.
+
+(2.6) Reservation of Rights. Any rights not expressly licensed under this section are expressly
+reserved by You.
+
+(3) Agreement
+
+You confirm that:
+
+(a) You have the legal authority to enter into this Agreement.
+
+(b) You own the Copyright and patent claims covering the Contribution which are required to
+grant the rights under Section 2.
+
+(c) The grant of rights under Section 2 does not violate any grant of rights which You have
+made to third parties, including Your employer. If You are an employee, You have had Your
+employer approve this Agreement or sign the Entity version of this document. If You are less
+than eighteen years old, please have Your parents or guardian sign the Agreement.
+
+(4) Disclaimer
+
+EXCEPT FOR THE EXPRESS WARRANTIES IN SECTION 3, THE CONTRIBUTION IS PROVIDED "AS IS". MORE
+PARTICULARLY, ALL EXPRESS OR IMPLIED WARRANTIES INCLUDING, WITHOUT LIMITATION, ANY IMPLIED
+WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+EXPRESSLY DISCLAIMED BY YOU TO US. TO THE EXTENT THAT ANY SUCH WARRANTIES CANNOT BE DISCLAIMED,
+SUCH WARRANTY IS LIMITED IN DURATION TO THE MINIMUM PERIOD PERMITTED BY LAW.
+
+(5) Consequential Damage Waiver
+
+TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL YOU BE LIABLE FOR ANY LOSS
+OF PROFITS, LOSS OF ANTICIPATED SAVINGS, LOSS OF DATA, INDIRECT, SPECIAL, INCIDENTAL,
+CONSEQUENTIAL AND EXEMPLARY DAMAGES ARISING OUT OF THIS AGREEMENT REGARDLESS OF THE LEGAL OR
+EQUITABLE THEORY (CONTRACT, TORT OR OTHERWISE) UPON WHICH THE CLAIM IS BASED.
+
+(6) Miscellaneous
+
+(6.1) This Agreement will be governed by and construed in accordance with the laws of the state
+of Colorado, excluding its conflicts of law provisions. Under certain circumstances, the
+governing law in this section might be superseded by the United Nations Convention on Contracts
+for the International Sale of Goods ("UN Convention") and the parties intend to avoid the
+application of the UN Convention to this Agreement and, thus, exclude the application of the UN
+Convention in its entirety to this Agreement.
+
+(6.2) This Agreement sets out the entire agreement between You and Us for Your Contributions to
+Us and overrides all other agreements or understandings.
+
+(6.3) If You or We assign the rights or obligations received through this Agreement to a third
+party, as a condition of the assignment, that third party must agree in writing to abide by all
+the rights and obligations in the Agreement.
+
+(6.4) The failure of either party to require performance by the other party of any provision of
+this Agreement in one situation shall not affect the right of a party to require such
+performance at any time in the future. A waiver of performance under a provision in one
+situation shall not be considered a waiver of the performance of the provision in the future or
+a waiver of the provision in its entirety.
+
+(6.5) If any provision of this Agreement is found void and unenforceable, such provision will
+be replaced to the extent possible with a provision that comes closest to the meaning of the
+original provision and which is enforceable. The terms and conditions set forth in this
+Agreement shall apply notwithstanding any failure of essential purpose of this Agreement or any
+limited remedy to the maximum extent possible under law.
+
+Harmony (HA-CLA-I-OSI) Version 1.0

MetPy/source/CODE_OF_CONDUCT.md

@@ -0,0 +1,68 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and
+maintainers pledge to making participation in our project and our community a harassment-free
+experience for everyone, regardless of age, body size, disability, ethnicity, gender identity
+and expression, level of experience, nationality, personal appearance, race, religion, or
+sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without
+  explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are
+expected to take appropriate and fair corrective action in response to any instances of
+unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments,
+commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of
+Conduct, or to ban temporarily or permanently any contributor for other behaviors that they
+deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual
+is representing the project or its community. Examples of representing a project or community
+include using an official project e-mail address, posting via an official social media account,
+or acting as an appointed representative at an online or offline event. Representation of a
+project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by
+contacting the project team at support-python@unidata.ucar.edu. The project team will review
+and investigate all complaints, and will respond in a way that it deems appropriate to the
+circumstances. The project team is obligated to maintain confidentiality with regard to the
+reporter of an incident. Further details of specific enforcement policies may be posted
+separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face
+temporary or permanent repercussions as determined by other members of the project's
+leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

MetPy/source/CONTRIBUTING.md

@@ -0,0 +1,412 @@
+# Contributors Guide
+
+Interested in helping build MetPy? Have code from your research that you believe others will
+find useful? Have a few minutes to tackle an issue? In this guide we will get you setup and
+integrated into contributing to MetPy!
+
+## Introduction
+
+First off, thank you for considering contributing to MetPy. MetPy is community-driven
+project. It's people like you that make MetPy useful and successful. There are many ways
+to contribute, from writing tutorials or examples, improvements to the documentation,
+submitting bug reports and feature requests, or even writing code which can be incorporated
+into MetPy for everyone to use.
+
+Following these guidelines helps to communicate that you respect the time of the
+developers managing and developing this open source project. In return, they
+should reciprocate that respect in addressing your issue, assessing changes, and
+helping you finalize your pull requests.
+
+So, please take a few minutes to read through this guide and get setup for success with your
+MetPy contributions. We're glad you're here!
+
+## What Can I Do?
+
+* Tackle any [issues](https://github.com/Unidata/MetPy/issues) you wish! We have a special
+  label for issues that beginners might want to try. Have a look at our
+  [current beginner issues.](https://github.com/Unidata/MetPy/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
+  Also have a look at if the issue is already assigned to someone - this helps us make sure
+  that work is not duplicated if the issue is already being worked on by Unidata Staff.
+* Contribute code you already have. It does not need to be perfect! We will help you clean
+  things up, test it, etc.
+* Make a tutorial or example of how to do something.
+* Improve documentation of a feature you found troublesome.
+* File a new issue if you run into problems!
+
+## Ground Rules
+
+The goal is to maintain a diverse community that's pleasant for everyone. Please
+be considerate and respectful of others by following our
+[code of conduct](https://github.com/Unidata/MetPy/blob/main/CODE_OF_CONDUCT.md).
+
+Other items:
+
+* Each pull request should consist of a logical collection of changes. You can
+  include multiple bug fixes in a single pull request, but they should be related.
+  For unrelated changes, please submit multiple pull requests.
+* Do not commit changes to files that are irrelevant to your feature or bug fix
+  (eg: .gitignore).
+* Be willing to accept criticism and work on improving your code; we don't want
+  to break other users' code, so care must be taken not to introduce bugs.
+* Be aware that the pull request review process is not immediate, and is
+  generally proportional to the size of the pull request.
+* Function arguments:
+  * Use full names for parameters rather than symbols (e.g. temperature instead of t)
+  * Order: pressure/height -> temperature/wind -> moisture (in general, but not a hard and
+    fast rule--like to allow for some default arguments).
+
+## Reporting a bug
+
+The easiest way to get involved is to report issues you encounter when using MetPy or by
+requesting something you think is missing.
+
+* Head over to the [issues](https://github.com/Unidata/MetPy/issues) page.
+* Search to see if your issue already exists or has even been solved previously.
+* If you indeed have a new issue or request, click the "New Issue" button.
+* Fill in as much of the issue template as is relevant. Please be as specific as possible.
+  Include the version of the code you were using, as well as what operating system you
+  are running. If possible, include complete, minimal example code that reproduces the problem.
+
+## Setting up your development environment
+
+We recommend using the [conda](https://conda.io/docs/) package manager for your Python environments.
+This requires some comfort with the command line and a little ``git`` knowledge.
+Our recommended setup for contributing:
+
+Install [miniconda](https://docs.conda.io/en/latest/miniconda.html) on your system.
+You may have to restart your prompt for the remaining steps to work.
+
+Install [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+(link with instructions) on your system if not already available
+(check with ``git --version`` at the command line.)
+This can also be installed from a variety of package managers, including ``conda`` if needed.
+
+Login to your [GitHub](https://github.com) account and make a fork of the
+[MetPy repository](https://github.com/unidata/metpy/) by clicking the "Fork" button.
+Clone your fork of the MetPy repository (in terminal on Mac/Linux or git shell/GUI on Windows)
+to the location you'd like to keep it.
+We are partial to creating a ``git_repos`` or ``projects`` directory in our home folder.
+
+```sh
+git clone https://github.com/<your-user-name>/metpy.git
+```
+
+Navigate to that folder in the terminal or in Anaconda Prompt if you're on Windows.
+The remainder of the instructions will take place within this directory.
+
+```sh
+cd metpy
+```
+
+Connect your repository to the upstream (main project).
+
+```sh
+git remote add unidata https://github.com/unidata/metpy.git
+```
+
+Create a new conda environment for us to configure, and give it a name.
+After ``-n`` you can specify any name you'd like; here we've chosen ``devel``.
+
+```sh
+conda create -n devel
+```
+
+**IMPORTANT**: Always activate this environment when developing and testing your changes!
+
+```sh
+conda activate devel
+```
+
+You will have to do this any time you re-open your prompt.
+Currently there are no packages in this environment, let's change that.
+Configure this environment so that we can reach
+[conda-forge](https://conda-forge.org/feedstock-outputs/) for the specific packages we depend on.
+
+```sh
+conda config --env --add channels conda-forge --add channels conda-forge/label/testing
+```
+
+Install the necessary dependency packages from conda-forge.
+Remember that these must be executed within the ``metpy`` directory.
+
+```sh
+conda install --file ci/requirements.txt --file ci/extra_requirements.txt --file ci-dev/test_requirements.txt
+```
+
+Finally, create an editable install of MetPy that will update with your development!
+
+```sh
+pip install -e .
+```
+
+Note sections on [documentation](#documentation) and [code style](#code-style) below,
+where you may need to install a few more packages into your new environment.
+
+Now you're all set!
+You have an environment called ``devel`` that you can work in.
+Remember, you will need to activate this environment the
+next time you want to use it after closing the terminal.
+If you want to get back to the root environment, run ``conda deactivate``.
+
+## Pull Requests
+
+The changes to the MetPy source (and documentation) should be made via GitHub pull requests
+against ``main``, even for those with administration rights. While it's tempting to
+make changes directly to ``main`` and push them up, it is better to make a pull request so
+that others can give feedback. If nothing else, this gives a chance for the automated tests to
+run on the PR. This can eliminate "brown paper bag" moments with buggy commits on the main
+branch.
+
+During the Pull Request process, before the final merge, it's a good idea to rebase the branch
+and squash together smaller commits. It's not necessary to flatten the entire branch, but it
+can be nice to eliminate small fixes and get the merge down to logically arranged commits. This
+can also be used to hide sins from history--this is the only chance, since once it hits
+``main``, it's there forever!
+
+**Working on your first Pull Request?** You can learn how from this *free* video series
+[How to Contribute to an Open Source Project on GitHub](https://egghead.io/courses/how-to-contribute-to-an-open-source-project-on-github),
+Aaron Meurer's [tutorial on the git workflow](https://www.asmeurer.com/git-workflow/), or the
+guide [“How to Contribute to Open Source"](https://opensource.guide/how-to-contribute/).
+
+Commit the changes you made. Chris Beams has written a [guide](https://cbea.ms/git-commit/)
+on how to write good commit messages.
+
+Push to your fork and [submit a pull request](https://github.com/Unidata/metpy/compare/).
+For the Pull Request to be accepted, you need to agree to the
+MetPy Contributor License Agreement (CLA). This will be handled automatically
+upon submission of a Pull Request.
+See [here](https://github.com/Unidata/MetPy/blob/main/CLA.md) for more
+explanation and rationale behind MetPy's CLA.
+
+## Source Code
+
+MetPy's source code is located in the `src/` directory in the root of the repository. Within
+`src/` is the `metpy/` directory, which is the base package. Inside here are the main
+top-level subpackages of MetPy:
+
+* `calc`: Calculations and tools
+* `interpolate`: Interpolating data points to other locations
+* `io`: Tools for reading and writing files
+* `plots`: Plotting tools using Matplotlib (and Cartopy)
+
+## Documentation
+
+Now that you've made your awesome contribution, it's time to tell the world how to use it.
+Writing documentation strings is really important to make sure others use your functionality
+properly. Didn't write new functions? That's fine, but be sure that the documentation for
+the code you touched is still in great shape. It is not uncommon to find some strange wording
+or clarification that you can take care of while you are here. If you added a new function
+make sure that it gets marked as included if appropriate in the GEMPAK conversion table.
+
+You can write examples in the documentation if they are simple concepts to demonstrate. If
+your feature is more complex, consider adding to the examples or tutorials for MetPy.
+
+You can build the documentation locally to see how your changes will look.
+After setting up your [development environment](#setting-up-your-development-environment) above,
+from within the ``metpy`` directory with your ``devel`` environment active,
+use ``conda install --file ci-dev/doc_requirements.txt``
+to install required packages to build our documentation.
+Then, still from within your ``devel`` environment,
+
+* Navigate to the docs folder ``cd docs``
+* Remove any old builds and build the current docs ``make clean html``
+  * (Try ``make cleanall html`` if ``make clean html`` fails)
+* Open ``docs/build/html/index.html`` and see your changes!
+
+### `doc-server.py`
+
+The MetPy documentation relies on the
+[Pydata Sphinx Theme](https://pydata-sphinx-theme.readthedocs.io/en/stable/index.html)
+for style and functionality.
+The theme includes some live javascript elements, including the version switcher.
+To test these elements, use our `doc-server.py` to deploy the built docs html files to a local
+server. If testing changes to `pst-versions.json` locally, change
+`html_theme_options['switcher']['json_url']` to reference `/MetPy/pst-versions.json` and the
+builds should pass and reflect any testing changes to `docs/test-server/pst-versions.json`.
+Documentation builds may fail if the links in the json fail to resolve.
+Change `html_theme_options['check_switcher']` to `False` in `conf.py` to bypass this behavior.
+Note: for production, `pst-versions.json` must live and is automatically updated on the online
+MetPy documentation via the `gh-pages` branch on GitHub.
+
+## Tests
+
+Unit tests are the lifeblood of the project, as it ensures that we can continue to add and
+change the code and stay confident that things have not broken. Running the tests requires
+``pytest``, which is easily available through ``conda``, ``pip``, or after installing the
+`test` extras with `uv`. It was also installed if you made our default ``devel`` 
+environment.
+
+### Running Tests
+
+Running the tests can be done by running ``pytest``
+
+Running the whole test suite isn't that slow, but can be a burden if you're working on just
+one module or a specific test. It is easy to run tests on a single directory:
+
+```sh
+pytest tests/calc
+```
+
+A specific test can be run as:
+
+```sh
+pytest -k test_my_test_func_name
+```
+
+### Writing Tests
+
+Tests should ideally hit all of the lines of code added or changed. We have automated
+services that can help track down lines of code that are missed by tests. Watching the
+coverage has even helped find sections of dead code that could be removed!
+
+Let's say we are adding a simple function to add two numbers and return the result as a float
+or as a string. (This would be a silly function, but go with us here for demonstration
+purposes.)
+
+```python
+def add_as_float_or_string(a, b, as_string=False):
+    res = a + b
+    if as_string:
+       return string(res)
+    return res
+```
+
+I can see two easy tests here: one for the results as a float and one for the results as a
+string. If I had added this to the ``calc`` module, I'd add those two tests in
+``tests/calc/test_calc.py``.
+
+```python
+def test_add_as_float_or_string_defaults():
+    res = add_as_float_or_string(3, 4)
+    assert(res, 7)
+
+
+def test_add_as_float_or_string_string_return():
+    res = add_as_float_or_string(3, 4, as_string=True)
+    assert(res, '7')
+```
+
+There are plenty of more advanced testing concepts, like dealing with floating point
+comparisons, parameterizing tests, testing that exceptions are raised, and more. Have a look
+at the existing tests to get an idea of some of the common patterns.
+
+### Image tests
+
+Some tests (for matplotlib plotting code) are done as an image comparison, using the
+pytest-mpl plugin.
+By following the [guide](#setting-up-your-development-environment) above,
+you should have a ``testing`` install of matplotlib, which will guarantee that your image tests
+behave exactly the same as ours.
+To run these tests, use:
+
+```sh
+pytest --mpl
+````
+
+When adding new image comparison tests, start by creating the baseline images for the tests:
+
+```sh
+pytest --mpl-generate-path=baseline
+```
+
+That command runs the tests and saves the images in the ``baseline`` directory.
+For MetPy this is generally ``tests/plots/baseline/``. We recommend using the ``-k`` flag
+to run only the test you just created for this step.
+
+For more information, see the [docs for pytest-mpl](https://github.com/astrofrog/pytest-mpl).
+
+## Cached Data Files
+
+MetPy keeps some test data, as well as things like shape files for US counties in a data cache
+supported by the pooch library. To add files to this, please ensure they are as small as
+possible. Put the files in the `staticdata` directory. Then run this command in the root of
+the MetPy repository to recreate the data registry:
+
+```sh
+python -c "import pooch; pooch.make_registry('staticdata', 'src/metpy/static-data-manifest.txt')"
+```
+
+Make sure that no system files (like `.DS_Store`) are in the manifest and add it to your
+contribution.
+
+## Code Style
+
+MetPy uses the Python code style outlined in [PEP8](https://pep8.org). For better or worse, this
+is what the majority of the Python world uses. The one deviation is that line length limit is
+95 characters. 80 is a good target, but some times longer lines are needed.
+
+While the authors are no fans of blind adherence to style and so-called project "clean-ups"
+that go through and correct code style, MetPy has adopted this style from the outset.
+Therefore, it makes sense to enforce this style as code is added to keep everything clean and
+uniform. To this end, part of the automated testing for MetPy checks style. To check style
+locally within the source directory you can use the [ruff](https://docs.astral.sh/ruff/) and
+[flake8](https://flake8.pycqa.org/en/latest/) tools.
+After setting up your [development environment](#setting-up-your-development-environment) above,
+from within the ``metpy`` directory with your ``devel`` environment active,
+install the code style tools we use with
+``conda install --file ci-dev/linting_requirements.txt``. Checking your code style is then as
+easy as running ``ruff check . ; flake8 .`` in the base of the repository.
+
+You can also just submit your PR and the kind robots will comment on all style violations as
+well. It can be a pain to make sure you have the right number of spaces around things, imports
+in order, and all of the other nits that the bots will find. It is very important though as
+this consistent style helps us keep MetPy readable, maintainable, and uniform.
+
+## What happens after the pull request
+
+You've make your changes, documented them, added some tests, and submitted a pull request.
+What now?
+
+### Automated Testing
+
+First, our army of never sleeping robots will begin a series of automated checks.
+The test suite, documentation, style, and more will be checked on various versions of Python
+with current and legacy packages. Travis CI and GitHub Actions will run testing on Linux, and
+Mac, and Windows. Other services will kick in and check if there is a drop in code coverage
+or any style variations that should be corrected. If you see a red mark by a service, something
+failed and clicking the "Details" link will give you more information. We're happy to help if
+you are stuck.
+
+The robots can be difficult to satisfy, but they are there to help everyone write better code.
+In some cases, there will be exceptions to their suggestions, but these are rare. If you make
+changes to your code and push again, the tests will automatically run again.
+
+### Code Review
+
+At this point you're waiting on us. You should expect to hear at least a comment within a
+couple of days. We may suggest some changes or improvements or alternatives.
+
+Some things that will increase the chance that your pull request is accepted quickly:
+
+* Write tests.
+* Follow [PEP8](https://pep8.org) for style. (The `flake8` utility can help with this.)
+* Write a [good commit message](https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+
+Pull requests will automatically have tests run by Travis. This includes
+running both the unit tests as well as the `flake8` code linter.
+
+### Merging
+
+Once we're all happy with the pull request, it's time for it to get merged in. Only the
+maintainers can merge pull requests and you should never merge a pull request you have commits
+on as it circumvents the code review. If this is your first or second pull request, we'll
+likely help by rebasing and cleaning up the commit history for you. As your development skills
+increase, we'll help you learn how to do this.
+
+## More Questions?
+
+If you're stuck somewhere or are interested in being a part of the community in
+other ways, feel free to contact us:
+
+* [MetPy's Gitter Channel](https://gitter.im/Unidata/MetPy)
+* ["metpy" tag on Stack Overflow](https://stackoverflow.com/questions/tagged/metpy)
+* [Unidata's Python support address](mailto:support-python@unidata.ucar.edu)
+* [python-users](https://mailinglists.unidata.ucar.edu/?software) mailing list
+
+## Further Reading
+
+There are a ton of great resources out there on contributing to open source and on the
+importance of writing tested and maintainable software.
+
+* [How to Contribute to Open Source Guide](https://opensource.guide/how-to-contribute/)
+* [Zen of Scientific Software Maintenance](https://jrleeman.github.io/ScientificSoftwareMaintenance/)

MetPy/source/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2008-2025, MetPy Developers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

MetPy/source/MANIFEST.in

@@ -0,0 +1,3 @@
+prune staticdata
+prune talks
+exclude docs/_static/*.pdf

MetPy/source/README.md

@@ -0,0 +1,118 @@
+MetPy
+=====
+
+[![MetPy Logo](https://github.com/Unidata/MetPy/raw/main/docs/_static/metpy_150x150.png)](https://unidata.github.io/MetPy/)
+[![NSF Unidata Logo](https://github.com/Unidata/MetPy/raw/main/docs/_static/NSF-Unidata_lockup_horizontal_2024.png)](https://www.unidata.ucar.edu)
+
+[![License](https://img.shields.io/pypi/l/metpy.svg)](https://pypi.python.org/pypi/MetPy/)
+[![Gitter](https://badges.gitter.im/Unidata/MetPy.svg)](https://gitter.im/Unidata/MetPy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=round-square)](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github)
+
+[![Latest Docs](https://github.com/Unidata/MetPy/workflows/Build%20Docs/badge.svg)](http://unidata.github.io/MetPy)
+[![PyPI Package](https://img.shields.io/pypi/v/metpy.svg)](https://pypi.python.org/pypi/MetPy/)
+[![Conda Package](https://anaconda.org/conda-forge/metpy/badges/version.svg)](https://anaconda.org/conda-forge/metpy)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/metpy.svg)](https://pypi.python.org/pypi/MetPy/)
+[![Conda Downloads](https://anaconda.org/conda-forge/metpy/badges/downloads.svg)](https://anaconda.org/conda-forge/metpy)
+
+[![PyPI Tests](https://github.com/Unidata/MetPy/workflows/PyPI%20Tests/badge.svg)](https://github.com/Unidata/MetPy/actions?query=workflow%3A%22PyPI+Tests%22)
+[![Conda Tests](https://github.com/Unidata/MetPy/workflows/Conda%20Tests/badge.svg)](https://github.com/Unidata/MetPy/actions?query=workflow%3A%22Conda+Tests%22)
+[![Code Coverage Status](https://codecov.io/github/Unidata/MetPy/coverage.svg?branch=main)](https://codecov.io/github/Unidata/MetPy?branch=main)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/2e64843f595c42e991457cb76fcfa769)](https://www.codacy.com/gh/Unidata/MetPy/dashboard)
+[![asv](https://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](https://unidata.github.io/MetPy-benchmark)
+[![Maintainability](https://qlty.sh/gh/Unidata/projects/MetPy/maintainability.svg)](https://qlty.sh/gh/Unidata/projects/MetPy)
+
+MetPy is a collection of tools in Python for reading, visualizing and
+performing calculations with weather data.
+
+MetPy follows [semantic versioning](https://semver.org) in its version number. This means
+that any MetPy ``1.x`` release will be backwards compatible with an earlier ``1.y`` release. By
+"backward compatible", we mean that **correct** code that works on a ``1.y`` version will work
+on a future ``1.x`` version.
+
+For additional MetPy examples not included in this repository, please see the
+[MetPy Cookbook on Project Pythia](https://projectpythia.org/metpy-cookbook/index.html).
+
+We support Python >= 3.11.
+
+Need Help?
+----------
+
+Need help using MetPy? Found an issue? Have a feature request? Checkout our
+[support page](https://github.com/Unidata/MetPy/blob/main/SUPPORT.md).
+
+Important Links
+---------------
+
+- [HTML Documentation](http://unidata.github.io/MetPy)
+- [MetPy Cookbook on Project Pythia](https://projectpythia.org/metpy-cookbook/index.html)
+- "metpy" tagged questions on [Stack Overflow](https://stackoverflow.com/questions/tagged/metpy)
+- [Gitter chat room](https://gitter.im/Unidata/MetPy)
+
+Dependencies
+------------
+
+Other required packages:
+
+- Numpy
+- Scipy
+- Matplotlib
+- Pandas
+- Pint
+- Xarray
+
+There is also an optional dependency on the pyproj library for geographic
+projections (used with cross sections, grid spacing calculation, and the GiniFile interface).
+
+See the [installation guide](https://unidata.github.io/MetPy/latest/userguide/installguide.html)
+for more information.
+
+Code of Conduct
+---------------
+
+We want everyone to feel welcome to contribute to MetPy and participate in discussions. In that
+spirit please have a look at our [Code of Conduct](https://github.com/Unidata/MetPy/blob/main/CODE_OF_CONDUCT.md).
+
+Contributing
+------------
+
+**Imposter syndrome disclaimer**: We want your help. No, really.
+
+There may be a little voice inside your head that is telling you that you're not ready to be
+an open source contributor; that your skills aren't nearly good enough to contribute. What
+could you possibly offer a project like this one?
+
+We assure you - the little voice in your head is wrong. If you can write code at all,
+you can contribute code to open source. Contributing to open source projects is a fantastic
+way to advance one's coding skills. Writing perfect code isn't the measure of a good developer
+(that would disqualify all of us!); it's trying to create something, making mistakes, and
+learning from those mistakes. That's how we all improve, and we are happy to help others learn.
+
+Being an open source contributor doesn't just mean writing code, either. You can help out by
+writing documentation, tests, or even giving feedback about the project (and yes - that
+includes giving feedback about the contribution process). Some of these contributions may be
+the most valuable to the project as a whole, because you're coming to the project with fresh
+eyes, so you can see the errors and assumptions that seasoned contributors have glossed over.
+
+For more information, please read the see the [contributing guide](https://github.com/Unidata/MetPy/blob/main/CONTRIBUTING.md).
+
+Philosophy
+----------
+
+The space MetPy aims for is GEMPAK (and maybe NCL)-like functionality, in a way that plugs
+easily into the existing scientific Python ecosystem (numpy, scipy, matplotlib). So, if you
+take the average GEMPAK script for a weather map, you need to:
+
+- read data
+- calculate a derived field
+- show on a map/skew-T
+
+One of the benefits hoped to achieve over GEMPAK is to make it easier to use these routines for
+any meteorological Python application; this means making it easy to pull out the LCL
+calculation and just use that, or reuse the Skew-T with your own data code. MetPy also prides
+itself on being well-documented and well-tested, so that on-going maintenance is easily
+manageable.
+
+The intended audience is that of GEMPAK: researchers, educators, and any one wanting to script
+up weather analysis. It doesn't even have to be scripting; all python meteorology tools are
+hoped to be able to benefit from MetPy. Conversely, it's hoped to be the meteorological
+equivalent of the audience of scipy/scikit-learn/skimage.

MetPy/source/SUPPORT.md

@@ -0,0 +1,38 @@
+# Support
+
+We want to help you use MetPy and solve any challenges you encounter. There
+are many ways to contact us:
+
+## Help using MetPy
+
+Need some help using MetPy to solve your problem? The MetPy development team is following all
+of these, so you only need to pick one to share your problem. 😉
+
+* [Stack Overflow](https://stackoverflow.com/questions/tagged/metpy): Ask a question using the
+  "metpy" tag. This is the highly preferred option as it allows the community to benefit from
+  answers to the questions, forming a readily-searched knowledge base. It's also likely to
+  result in the quickest response, as not only are the MetPy developers watching, but
+  community members can also chime in if they know the answer.
+* [GitHub Discussions](https://github.com/Unidata/MetPy/discussions): Ask your question and
+  have a discussion with members of MetPy's community. This is also a forum likely to result
+  in a quicker response.
+* [Unidata Python Support email](mailto:support-python@unidata.ucar.edu): Send an email to
+  Unidata's Python support email address.
+* [Gitter](https://gitter.im/Unidata/MetPy): text-based chat with the developers; sign in
+  using GitHub or Twitter.
+* [MetPy on Bluesky](https://bsky.app/profile/metpy.bsky.social)
+* [MetPy on Twitter](https://twitter.com/MetPy)
+* [Unidata Python User’s Mailing List](https://mailinglists.unidata.ucar.edu/?software)
+
+## Issues
+
+Find a problem with MetPy? Looking for a feature we don't have? File an issue!
+
+* [New Issue](https://github.com/Unidata/MetPy/issues/new/choose)
+* [Current List of Issues](https://github.com/Unidata/MetPy/issues)
+
+## Code of Conduct
+
+We want everyone to feel welcome to contribute to MetPy and participate in discussions. In that
+spirit please have a look at our
+[`code of conduct`](https://github.com/Unidata/MetPy/blob/main/CODE_OF_CONDUCT.md).

MetPy/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+MetPy Project Package Initialization File
+"""

MetPy/source/benchmarks/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.12
+
+RUN pip install --no-cache-dir netcdf4 asv pysu metpy
+
+COPY --chmod=700 entrypoint.sh /
+
+ENTRYPOINT ["/entrypoint.sh"]

MetPy/source/benchmarks/Jenkinsfile

@@ -0,0 +1,87 @@
+pipeline {
+	agent  { label 'main' }
+	environment {
+		CLONE_DIR = "temp_repo_results"
+	}
+	stages {
+        // checks out the results repo using secret stored in Jenkins
+		stage('Checkout results repo') {
+			steps {
+				sh 'git config --global credential.helper cache'
+				sh 'git config --global push.default simple'
+				checkout scmGit(branches: [[name: '*/main']], extensions: [[$class: 'RelativeTargetDirectory', relativeTargetDir: 'temp_repo_results'], cloneOption(depth: 1, noTags: false, reference: '', shallow: true)], userRemoteConfigs: [[credentialsId: 'GH_DEPLOY_KEY_METPY_BENCH_RESULTS', url: 'git@github.com:Unidata/MetPy-benchmark.git']])
+			}
+		}
+        // copies past results into the asv/results folder on the main repo
+		stage('Copy past results') {
+			steps {
+				sh '''
+    				if [ -d ${CLONE_DIR}/results ]; then 
+					echo "-------Copying results--------"
+    					cp -r ${CLONE_DIR}/results/* benchmarks/asv/results
+    				fi
+				'''
+			}
+		}
+        // generates the hashes to run and stores them in a text file
+        stage('Setup for ASV run') {
+            steps {
+                sh '''
+                    cd benchmarks
+                    bash generate_hashes.sh
+                    cd ..
+                '''
+            }
+        }
+        // Runs ASV in the docker container
+        // The catch error ensures that the build works even if some ASV fail
+		stage('Run ASV') {
+			steps {
+                catchError(buildResult: 'SUCCESS') {
+                    sh '''
+                    cd benchmarks
+                    docker build -t metpy-benchmarks:latest .
+                    cd ..
+                    docker run --rm -v .:/container-benchmarks --hostname Docker_Container -e DUID=$(id -u) -e DGID=$(id -g) metpy-benchmarks:latest benchmark
+                    '''
+                }
+   			}
+		}
+        // Copies results from the asv/results into the results repo
+		stage('Copy results') {
+			steps{
+				sh '''
+    				if [ -d "${CLONE_DIR}/results" ]; then 
+					echo "--------results repo exist-------"
+				else 
+    					mkdir ${CLONE_DIR}/results
+	 			fi
+    				cp -r benchmarks/asv/results/* ${CLONE_DIR}/results
+				'''
+			}
+		}
+        // Pushes to the git repo if there have been changes
+		stage('Update results repo') {
+			steps {
+				withCredentials([sshUserPrivateKey(credentialsId: 'GH_DEPLOY_KEY_METPY_BENCH_RESULTS', keyFileVariable: 'deploy_key')]) {
+                    sh '''
+				   	if [ -n "$(git status --porcelain)" ]; then 
+						cd ${CLONE_DIR} 
+						git add --all
+						git commit -m "Jenkins Updating Benchmark Results BUILD-NUMBER:${BUILD_NUMBER}" || echo "-----no changes to commit-----"
+						export GIT_SSH_COMMAND="ssh -i ${deploy_key}"
+                        			git push origin HEAD:main --force
+					fi
+					'''
+				}
+			}
+		}
+	}
+	post {
+        // always removes the temporary repo regardless of build status
+		always {
+			echo "---Cleaning up temporary repo---"
+			sh 'rm -rf "${CLONE_DIR}"'
+		}
+	}
+}

MetPy/source/benchmarks/asv.conf.json

@@ -0,0 +1,208 @@
+{
+    // The version of the config file format.  Do not change, unless
+    // you know what you are doing.
+    "version": 1,
+
+    // The name of the project being benchmarked
+    "project": "metpy",
+
+    // The project's homepage
+    "project_url": "https://unidata.github.io/MetPy/latest/",
+
+    // The URL or local path of the source code repository for the
+    // project being benchmarked
+    "repo": "..",
+
+    // The Python project's subdirectory in your repo.  If missing or
+    // the empty string, the project is assumed to be located at the root
+    // of the repository.
+    //"repo_subdir": "benchmarks",
+
+    // Customizable commands for building the project.
+    // See asv.conf.json documentation.
+    // To build the package using pyproject.toml (PEP518), uncomment the following lines
+     "build_command": [
+         "python -m pip install build",
+         "python -m build",
+         "python -mpip wheel -w {build_cache_dir} {build_dir}"
+    ],
+    // To build the package using setuptools and a setup.py file, uncomment the following lines
+    // "build_command": [
+    //     "python setup.py build",
+    //     "python -mpip wheel -w {build_cache_dir} {build_dir}"
+    // ],
+
+    // Customizable commands for installing and uninstalling the project.
+    // See asv.conf.json documentation.
+    "install_command": ["in-dir={env_dir} python -mpip install {build_dir}"],
+    "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
+
+    // List of branches to benchmark. If not provided, defaults to "main"
+    // (for git) or "default" (for mercurial).
+    "branches": ["HEAD"], // for git
+    // "branches": ["default"],    // for mercurial
+
+    // The DVCS being used.  If not set, it will be automatically
+    // determined from "repo" by looking at the protocol in the URL
+    // (if remote), or by looking for special directories, such as
+    // ".git" (if local).
+     // "dvcs": "git",
+
+    // The tool to use to create environments.  May be "conda",
+    // "virtualenv", "mamba" (above 3.8)
+    // or other value depending on the plugins in use.
+    // If missing or the empty string, the tool will be automatically
+    // determined by looking for tools on the PATH environment
+    // variable.
+    "environment_type": "virtualenv",
+
+    // timeout in seconds for installing any dependencies in environment
+    // defaults to 10 min
+    //"install_timeout": 600,
+
+    // the base URL to show a commit for the project.
+     "show_commit_url": "http://github.com/unidata/metpy/commit/",
+
+    // The Pythons you'd like to test against.  If not provided, defaults
+    // to the current version of Python used to run `asv`.
+    //"pythons": ["3.8", "3.12"],
+
+    // The list of conda channel names to be searched for benchmark
+    // dependency packages in the specified order
+    "conda_channels": ["conda-forge"],
+
+    // A conda environment file that is used for environment creation.
+    // "conda_environment_file": "environment.yml",
+
+    // The matrix of dependencies to test.  Each key of the "req"
+    // requirements dictionary is the name of a package (in PyPI) and
+    // the values are version numbers.  An empty list or empty string
+    // indicates to just test against the default (latest)
+    // version. null indicates that the package is to not be
+    // installed. If the package to be tested is only available from
+    // PyPi, and the 'environment_type' is conda, then you can preface
+    // the package name by 'pip+', and the package will be installed
+    // via pip (with all the conda available packages installed first,
+    // followed by the pip installed packages).
+    //
+    // The ``@env`` and ``@env_nobuild`` keys contain the matrix of
+    // environment variables to pass to build and benchmark commands.
+    // An environment will be created for every combination of the
+    // cartesian product of the "@env" variables in this matrix.
+    // Variables in "@env_nobuild" will be passed to every environment
+    // during the benchmark phase, but will not trigger creation of
+    // new environments.  A value of ``null`` means that the variable
+    // will not be set for the current combination.
+    //
+      "matrix": {
+        "req": {
+          "matplotlib": [
+          ],
+          "numpy": [
+          ],
+          "pandas": [
+          ],
+          "pint": [
+          ],
+          "pooch": [
+          ],
+          "pyproj": [
+          ],
+          "scipy": [
+          ],
+          "traitlets": [
+          ],
+          "xarray": [
+          ], 
+          "netcdf4": [
+          ], 
+        }
+      },
+  // Combinations of libraries/python versions can be excluded/included
+    // from the set to test. Each entry is a dictionary containing additional
+    // key-value pairs to include/exclude.
+    //
+    // An exclude entry excludes entries where all values match. The
+    // values are regexps that should match the whole string.
+    //
+    // An include entry adds an environment. Only the packages listed
+    // are installed. The 'python' key is required. The exclude rules
+    // do not apply to includes.
+    //
+    // In addition to package names, the following keys are available:
+    //
+    // - python
+    //     Python version, as in the *pythons* variable above.
+    // - environment_type
+    //     Environment type, as above.
+    // - sys_platform
+    //     Platform, as in sys.platform. Possible values for the common
+    //     cases: 'linux2', 'win32', 'cygwin', 'darwin'.
+    // - req
+    //     Required packages
+    // - env
+    //     Environment variables
+    // - env_nobuild
+    //     Non-build environment variables
+    //
+    // "exclude": [
+    //     {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
+    //     {"environment_type": "conda", "req": {"six": null}}, // don't run without six on conda
+    //     {"env": {"ENV_VAR_1": "val2"}}, // skip val2 for ENV_VAR_1
+    // ],
+    //
+    // "include": [
+    //     // additional env for python3.12
+    //     {"python": "3.12", "req": {"numpy": "1.26"}, "env_nobuild": {"FOO": "123"}},
+    //     // additional env if run on windows+conda
+    //     {"platform": "win32", "environment_type": "conda", "python": "3.12", "req": {"libpython": ""}},
+    // ],
+
+    // The directory (relative to the current directory) that benchmarks are
+    // stored in.  If not provided, defaults to "benchmarks"
+    // "benchmark_dir": "benchmarks",
+
+    // The directory (relative to the current directory) to cache the Python
+    // environments in.  If not provided, defaults to "env"
+    "env_dir": "asv/env",
+
+    // The directory (relative to the current directory) that raw benchmark
+    // results are stored in.  If not provided, defaults to "results".
+    "results_dir": "asv/results",
+
+    // The directory (relative to the current directory) that the html tree
+    // should be written to.  If not provided, defaults to "html".
+    "html_dir": "asv/html",
+
+    // The number of characters to retain in the commit hashes.
+    // "hash_length": 8,
+
+    // `asv` will cache results of the recent builds in each
+    // environment, making them faster to install next time.  This is
+    // the number of builds to keep, per environment.
+     "build_cache_size": 52
+
+    // The commits after which the regression search in `asv publish`
+    // should start looking for regressions. Dictionary whose keys are
+    // regexps matching to benchmark names, and values corresponding to
+    // the commit (exclusive) after which to start looking for
+    // regressions.  The default is to start from the first commit
+    // with results. If the commit is `null`, regression detection is
+    // skipped for the matching benchmark.
+    //
+    // "regressions_first_commits": {
+    //    "some_benchmark": "352cdf",  // Consider regressions only after this commit
+    //    "another_benchmark": null,   // Skip regression detection altogether
+    // },
+
+    // The thresholds for relative change in results, after which `asv
+    // publish` starts reporting regressions. Dictionary of the same
+    // form as in ``regressions_first_commits``, with values
+    // indicating the thresholds.  If multiple entries match, the
+    // maximum is taken. If no entry matches, the default is 5%.
+    //
+    // "regressions_thresholds": {
+    //    "some_benchmark": 0.01,     // Threshold of 1%
+    //    "another_benchmark": 0.5,   // Threshold of 50%
+    // },
+}

MetPy/source/benchmarks/asv_run_script.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+#Run asv
+
+# Generate artificial data file for benchmarks
+python3 data_array_generate.py
+
+#Set up asv machine
+asv machine --yes
+
+# Runs asv on the commits in the hash file but skips ones that already have results
+asv run --skip-existing-successful HASHFILE:no_bot_merge_commits.txt

MetPy/source/benchmarks/benchmarks/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""initialization file required for ASV to run."""

MetPy/source/benchmarks/benchmarks/apparent_temp_benchmarks.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.02'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+
+    def time_apparent_temperature(self, pressureslice):
+        """Benchmarking calculating apparent temperature on a 2d grid."""
+        mpcalc.apparent_temperature(self.pressureslice.temperature,
+                                    self.pressureslice.relative_humidity,
+                                    self.pressureslice.windspeed)
+
+    def time_heat_index(self, timeslice):
+        """Benchmarking calculating heat index on a 3d cube."""
+        mpcalc.heat_index(self.timeslice.temperature, self.timeslice.relative_humidity)
+
+    def time_windchill(self, timeslice):
+        """Benchmarking calculating windchill on a 3d cube."""
+        mpcalc.windchill(self.timeslice.temperature, self.timeslice.windspeed)

MetPy/source/benchmarks/benchmarks/bound_layer_turbulence_benchmarks.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+from metpy.units import units
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.02'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.timeslice = ds.isel(time=0)
+
+    def time_brunt_vaisala_frequency(self, timeslice):
+        """Benchmark Brunt Vaisala frequency calculation on a cube."""
+        mpcalc.brunt_vaisala_frequency(self.timeslice.height, self.timeslice.theta)
+
+    def time_gradient_richardson_number(self, timeslice):
+        """Benchmark Gradient Richardson Number on a cube."""
+        mpcalc.gradient_richardson_number(self.timeslice.height, self.timeslice.theta,
+                                          self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_tke(self, ds):
+        """Benchmarking turbulent kinetic energy calculation on a cube."""
+        mpcalc.tke(ds.uwind.values * units('m/s'), ds.vwind.values * units('m/s'),
+                   ds.wwind.values * units('m/s'))
+
+    def time_brunt_vaisala_period(self, timeslice):
+        """Benchmark Brunt Vaisala frequency calculation on a cube."""
+        mpcalc.brunt_vaisala_period(self.timeslice.height, self.timeslice.theta)

MetPy/source/benchmarks/benchmarks/dry_thermo_benchmarks.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+from metpy.units import units
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.07'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+        self.profileslice = ds.isel(time=0, lat=0, lon=0)
+
+    def time_density(self, pressureslice):
+        """Benchmarking density calculation on a 2d surface."""
+        mpcalc.density(self.pressureslice.pressure, self.pressureslice.temperature,
+                       self.pressureslice.mixing_ratio)
+
+    def time_height_to_geopotential(self, timeslice):
+        """Benchmarking the height to geopotenial calculation on a 3d cube."""
+        mpcalc.height_to_geopotential(self.timeslice.height)
+
+    def time_potential_temperature(self, timeslice):
+        """Benchmarking the potential temperature calculation on a 3d cube."""
+        mpcalc.potential_temperature(self.timeslice.pressure, self.timeslice.temperature)
+
+    def time_static_stability(self, timeslice):
+        """Benchmarking static stability calculation on a 3d cube."""
+        mpcalc.static_stability(self.timeslice.pressure, self.timeslice.temperature)
+
+    def time_thickness_hydrostatic(self, timeslice):
+        """Benchmarking hydrostatic thickness calculation on a 3d cube."""
+        mpcalc.thickness_hydrostatic(self.timeslice.pressure, self.timeslice.temperature,
+                                     self.timeslice.mixing_ratio)
+
+    def time_dry_lapse(self, timeslice):
+        """Benchmarking the dry lapse calculation on a 3d cube."""
+        mpcalc.dry_lapse(self.timeslice.pressure, self.timeslice.temperature)
+
+    def time_sigma_to_pressure(self, timeslice):
+        """Benchmarking the sigma to pressure calculation on a 3d cube."""
+        mpcalc.sigma_to_pressure(self.timeslice.sigma, self.timeslice.pressure[0],
+                                 self.timeslice.pressure[49])
+
+    def time_geopotential_to_height(self, timeslice):
+        """Benchmarking the geopotential to height calculation on a 3d cube."""
+        mpcalc.geopotential_to_height(self.timeslice.geopotential)
+
+    def time_add_pressure_to_height(self, timeslice):
+        """Benchmarking adding pressure to height on a 3d cube."""
+        mpcalc.add_pressure_to_height(self.timeslice.height, self.timeslice.pressure)
+
+    def time_add_height_to_pressure(self, timeslice):
+        """Benchmarking adding height to pressure on a 3d cube."""
+        mpcalc.add_height_to_pressure(self.timeslice.pressure.values * units('hPa'),
+                                      self.timeslice.height.values * units('km'))
+
+    def time_temperature_from_potential_temperature(self, timeslice):
+        """Benchmarking calculating temperature from potential temperature on a 3d cube."""
+        mpcalc.temperature_from_potential_temperature(self.timeslice.pressure,
+                                                      self.timeslice.theta)
+
+    def time_mean_pressure_weighted(self, profileslice):
+        """Benchmarking calculating weighted mean of pressure with temp on one profile."""
+        mpcalc.mean_pressure_weighted(self.profileslice.pressure,
+                                      self.profileslice.temperature)
+
+    def time_weighted_continuous_average(self, profileslice):
+        """Bencharmking calculating weighted continuous average on one profile."""
+        mpcalc.weighted_continuous_average(self.profileslice.pressure,
+                                           self.profileslice.temperature)
+
+    def time_dry_static_energy(self, timeslice):
+        """Benchmarking dry static energy calculation on a 3d cube."""
+        mpcalc.dry_static_energy(self.timeslice.height, self.timeslice.temperature)

MetPy/source/benchmarks/benchmarks/dyn_kin_benchmarks.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+import metpy.interpolate as mpinter
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.03'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        ds = ds.metpy.parse_cf()
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+        self.profileslice = ds.isel(time=0, lat=0, lon=0)
+        start = (30., 260.)
+        end = (40., 270.)
+        self.cross = mpinter.cross_section(self.timeslice, start, end).set_coords(('lat', 'lon'
+                                                                                   ))
+
+    def time_absolute_vorticity(self, pressureslice):
+        """Benchmarking absolute momentum calculation on a 2d surface."""
+        mpcalc.absolute_vorticity(self.pressureslice.uwind, self.pressureslice.vwind)
+
+    def time_advection(self, timeslice):
+        """Benchmarking the advection calculation of t on a 3d cube."""
+        mpcalc.advection(self.timeslice.temperature, self.timeslice.uwind,
+                         self.timeslice.vwind)
+
+    def time_ageostrophic_wind(self, pressureslice):
+        """Benchmarking ageostrophic wind calculation on a 2d surface."""
+        mpcalc.ageostrophic_wind(self.pressureslice.height, self.pressureslice.uwind,
+                                 self.pressureslice.vwind)
+
+    def time_frontogenesis(self, pressureslice):
+        """Benchmarking the calculation of frontogenesis of a 2d field."""
+        mpcalc.frontogenesis(self.pressureslice.theta, self.pressureslice.uwind,
+                             self.pressureslice.vwind)
+
+    def time_potential_vorticity_barotropic(self, timeslice):
+        """Benchmarking the barotropic potential vorticity calculation on a cube."""
+        mpcalc.potential_vorticity_barotropic(self.timeslice.height, self.timeslice.uwind,
+                                              self.timeslice.vwind)
+
+    def time_q_vector(self, pressureslice):
+        """Benchmarking q vector calculation on a 2d slice."""
+        mpcalc.q_vector(self.pressureslice.uwind, self.pressureslice.vwind,
+                        self.pressureslice.temperature, self.pressureslice.pressure)
+
+    def time_total_deformation(self, pressureslice):
+        """Benchmarking total deformation calculation on a 2d slice."""
+        mpcalc.total_deformation(self.pressureslice.uwind, self.pressureslice.vwind)
+
+    def time_vorticity(self, pressureslice):
+        """Benchmarking vorticity calculation on a 2d slice."""
+        mpcalc.vorticity(self.pressureslice.uwind, self.pressureslice.vwind)
+
+    def time_shear_vorticity(self, pressureslice):
+        """Benchmarking shear vorticity on a 2d slice."""
+        mpcalc.shear_vorticity(self.pressureslice.uwind, self.pressureslice.vwind)
+
+    def time_absolute_momentum(self, cross):
+        """Benchmarking absolute momentum calculation."""
+        mpcalc.absolute_momentum(self.cross.uwind, self.cross.vwind)
+
+    def time_potential_vorticity_baroclinic(self, timeslice):
+        """Benchmarking potential vorticity baroclinic on a 3d cube."""
+        mpcalc.potential_vorticity_baroclinic(self.timeslice.theta, self.timeslice.pressure,
+                                              self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_inertal_advective_wind(self, timeslice):
+        """Benchmarking inertal advective wind calculation on a 3d cube."""
+        mpcalc.inertial_advective_wind(self.timeslice.uwind, self.timeslice.vwind,
+                                       self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_curvature_vorticity(self, timeslice):
+        """Benchmarking the curvature vorticity calculation on a 3d cube."""
+        mpcalc.curvature_vorticity(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_montgomery_streamfunction(self, pressureslice):
+        """Benchmarking the montgomery streamfunction calculation on a 2d grid."""
+        mpcalc.montgomery_streamfunction(self.pressureslice.height,
+                                         self.pressureslice.temperature)
+
+    def time_wind_direction(self, timeslice):
+        """Benchmarking the wind direction calculation on a 3d cube."""
+        mpcalc.wind_direction(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_wind_components(self, timeslice):
+        """Benchmarking the wind components calculation on a 3d cube."""
+        mpcalc.wind_components(self.timeslice.windspeed, self.timeslice.winddir)
+
+    def time_divergence(self, timeslice):
+        """Benchmarking divergence on a 3d cube."""
+        mpcalc.divergence(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_stretching_deformation(self, timeslice):
+        """Benchmarking stretching deformation on a 3d cube."""
+        mpcalc.stretching_deformation(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_shearing_deformation(self, timeslice):
+        """Benchmarking shearing deformation on a 3d cube."""
+        mpcalc.shearing_deformation(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_geostrophic_wind(self, timeslice):
+        """Benchmarking the geostrophic wind calculation on a 3d cube."""
+        mpcalc.geostrophic_wind(self.timeslice.height, latitude=self.timeslice.lat)
+
+    def time_coriolis_parameter(self, timeslice):
+        """Benchmarking coriolis parameter calculation on a 3d cube."""
+        mpcalc.coriolis_parameter(self.timeslice.lat)
+
+    def time_wind_speed(self, timeslice):
+        """Benchmarking wind speed calculation on a 3d cube."""
+        mpcalc.wind_speed(self.timeslice.uwind, self.timeslice.vwind)
+
+    def time_exner_function(self, timeslice):
+        """Benchmark exner function calculation on a cube."""
+        mpcalc.exner_function(self.timeslice.pressure)

MetPy/source/benchmarks/benchmarks/math_fctn_benchmarks.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+import metpy.interpolate as mpinter
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.03'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        ds = ds.metpy.parse_cf()
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+        start = (30., 260.)
+        end = (40., 270.)
+        self.cross = mpinter.cross_section(self.timeslice,
+                                           start, end).set_coords(('lat', 'lon'))
+
+    def time_geospatial_gradient(self, pressureslice):
+        """Benchmarking calculating the geospatial gradient of temp on a 2d array."""
+        mpcalc.geospatial_gradient(self.pressureslice.temperature)
+
+    def time_geospatial_laplacian(self, pressureslice):
+        """Benchmarking calculating the geospatial laplacian of temp on a 2d array."""
+        mpcalc.geospatial_laplacian(self.pressureslice.temperature)
+
+    def time_gradient(self, timeslice):
+        """Benchmarking calculating the gradient of temp on a 3d cube."""
+        mpcalc.gradient(self.timeslice.temperature)
+
+    def time_vector_derivative(self, pressureslice):
+        """Benchmarking calculating the vector derivative of wind on a 2d slice."""
+        mpcalc.vector_derivative(self.pressureslice.uwind, self.pressureslice.vwind)
+
+    def time_tangential_component(self, cross):
+        """Benchmarking calculation of the tangential component of wind on a slice."""
+        mpcalc.tangential_component(self.cross.uwind, self.cross.vwind)
+
+    def time_cross_section_components(self, cross):
+        """Benchmarking the cross section components of a wind grid."""
+        mpcalc.cross_section_components(self.cross.uwind, self.cross.vwind)
+
+    def time_normal_component(self, cross):
+        """Benchmarking the calculating normal components times."""
+        mpcalc.normal_component(self.cross.uwind, self.cross.vwind)

MetPy/source/benchmarks/benchmarks/moist_thermo_benchmarks.py

@@ -0,0 +1,220 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+from metpy.units import units
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.02'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+        self.upperslice = ds.isel(pressure=49, time=0)
+        self.profileslice = ds.isel(time=0, lat=25, lon=25)
+
+    def time_virtual_temperature(self, timeslice):
+        """Benchmark virtual temperature on a 3d cube."""
+        mpcalc.virtual_temperature(self.timeslice.temperature, self.timeslice.mixing_ratio)
+
+    def time_dewpoint(self, timeslice):
+        """Benchmarking dewpoint from vapor pressure on a 3d cube."""
+        mpcalc.dewpoint(self.timeslice.vapor_pressure)
+
+    def time_rh_from_mixing_ratio(self, timeslice):
+        """Benchmarking relative humidity from mixing ratio on a 3d cube."""
+        mpcalc.relative_humidity_from_mixing_ratio(self.timeslice.pressure,
+                                                   self.timeslice.temperature,
+                                                   self.timeslice.mixing_ratio)
+
+    def time_dewpoint_from_rh(self, timeslice):
+        """Benchmarking dewpoint from calculated on a 3d cube."""
+        mpcalc.dewpoint_from_relative_humidity(self.timeslice.temperature,
+                                               self.timeslice.relative_humidity)
+
+    def time_precipitable_water(self, timeslice):
+        """Benchmarking precipitable water calculation for one column."""
+        mpcalc.precipitable_water(self.timeslice.pressure, self.timeslice.dewpoint[0][0])
+
+    def time_wet_bulb_temperature(self, pressureslice):
+        """Benchmarking wet bulb temperature calculation on on a slice."""
+        mpcalc.wet_bulb_temperature(self.pressureslice.pressure,
+                                    self.pressureslice.temperature,
+                                    self.pressureslice.dewpoint)
+
+    def time_scale_height(self, pressureslice):
+        """Benchmarking the calculation for the scale height of a layer for 2 surfaces."""
+        mpcalc.scale_height(self.upperslice.temperature, self.pressureslice.temperature)
+
+    def time_moist_lapse(self, profileslice):
+        """Benchmarking the calculation for the moist lapse rate for one profile."""
+        mpcalc.moist_lapse(self.profileslice.pressure.values * units('hPa'),
+                           self.profileslice.temperature[0].values * units('K'))
+
+    def time_saturation_vapor_pressure(self, timeslice):
+        """Benchmarking the saturation vapor pressure calculation for a 3d cube."""
+        mpcalc.saturation_vapor_pressure(self.timeslice.temperature)
+
+    def time_water_latent_heat_vaporization(self, timeslice):
+        """Benchmarking the vaporization latent heat calculation on a 3d cube."""
+        mpcalc.water_latent_heat_vaporization(self.timeslice.temperature)
+
+    def time_water_latent_heat_sublimation(self, timeslice):
+        """Benchmarking the sublimation latent heat calculation on a 3d cube."""
+        mpcalc.water_latent_heat_sublimation(self.timeslice.temperature)
+
+    def time_water_latent_heat_melting(self, timeslice):
+        """Benchmarking the melting latent heat calculation on a 3d cube."""
+        mpcalc.water_latent_heat_melting(self.timeslice.temperature)
+
+    def time_specific_humidity_from_dewpoint(self, timeslice):
+        """Benchmarking specific humidity from dewpoint calculation on a 3d cube."""
+        mpcalc.specific_humidity_from_dewpoint(self.timeslice.pressure,
+                                               self.timeslice.temperature)
+
+    def time_relative_humidity_from_dewpoint(self, timeslice):
+        """Benchmarking relative humidity from dewpoint calculation on a 3d cube."""
+        mpcalc.relative_humidity_from_dewpoint(self.timeslice.temperature,
+                                               self.timeslice.dewpoint)
+
+    def time_moist_static_energy(self, timeslice):
+        """Benchmarking moist static energy calculation on a 3d cube."""
+        mpcalc.moist_static_energy(self.timeslice.height, self.timeslice.temperature,
+                                   self.timeslice.specific_humidity)
+
+    def time_dewpoint_from_specific_humidity(self, timeslice):
+        """Benchmarking dewpoint from specific humidity calculation on a 3d cube."""
+        mpcalc.dewpoint_from_specific_humidity(self.timeslice.pressure,
+                                               self.timeslice.temperature,
+                                               self.timeslice.specific_humidity)
+
+    def time_moist_air_specific_heat_pressure(self, timeslice):
+        """Benchmarking moist air specific heat pressure calculation on a 3d cube."""
+        mpcalc.moist_air_specific_heat_pressure(self.timeslice.specific_humidity)
+
+    def time_moist_air_poisson_exponent(self, timeslice):
+        """Benchmarking moist air poisson exponent calculation on a cube."""
+        mpcalc.moist_air_poisson_exponent(self.timeslice.specific_humidity)
+
+    def time_relative_humidity_wet_psychrometric(self, timeslice):
+        """Benchmarking the relative humidity from psychometric calculation on a cube."""
+        mpcalc.relative_humidity_wet_psychrometric(self.timeslice.pressure,
+                                                   self.timeslice.temperature,
+                                                   self.timeslice.wet_bulb_temperature)
+
+    def time_thickness_hydrostatic_from_relative_humidity(self, profileslice):
+        """Benchmarking thickness  calculation from relative humidity on one profile."""
+        mpcalc.thickness_hydrostatic_from_relative_humidity(self.profileslice.pressure,
+                                                            self.profileslice.temperature,
+                                                            self.profileslice.relative_humidity
+                                                            )
+
+    def time_relative_humidity_from_specific_humidity(self, timeslice):
+        """Benchmarking relative humidity from specific humidity calculation on a 3d cube."""
+        mpcalc.relative_humidity_from_specific_humidity(self.timeslice.pressure,
+                                                        self.timeslice.temperature,
+                                                        self.timeslice.specific_humidity)
+
+    def time_wet_bulb_potential_temperature(self, timeslice):
+        """Benchmarking the wet bulb potential temperature calculation on a 3d cube."""
+        mpcalc.wet_bulb_potential_temperature(self.timeslice.pressure,
+                                              self.timeslice.temperature,
+                                              self.timeslice.dewpoint)
+
+    def time_vertical_velocity_pressure(self, timeslice):
+        """Benchmarking vertical velocity wrt pressure calculation on a 3d cube."""
+        mpcalc.vertical_velocity_pressure(self.timeslice.wwind, self.timeslice.pressure,
+                                          self.timeslice.temperature,
+                                          self.timeslice.mixing_ratio)
+
+    def time_vertical_velocity(self, timeslice):
+        """Benchmarking vertical velocity calculation on a 3d cube."""
+        mpcalc.vertical_velocity(self.timeslice.omega, self.timeslice.pressure,
+                                 self.timeslice.temperature,
+                                 self.timeslice.mixing_ratio)
+
+    def time_saturation_equivalent_potential_temperature(self, timeslice):
+        """Benchmarking saturation equivalent potential temperature on 3d cube."""
+        mpcalc.saturation_equivalent_potential_temperature(self.timeslice.pressure,
+                                                           self.timeslice.temperature)
+
+    def time_virtual_potential_temperature(self, timeslice):
+        """Benchmarking virtual potential temperature calculation on a 3d cube."""
+        mpcalc.virtual_potential_temperature(self.timeslice.pressure,
+                                             self.timeslice.temperature,
+                                             self.timeslice.mixing_ratio)
+
+    def time_psychrometric_vapor_pressure_wet(self, timeslice):
+        """Benchmarking psychrometric vapor pressure calculation on a 3d cube."""
+        mpcalc.psychrometric_vapor_pressure_wet(self.timeslice.pressure,
+                                                self.timeslice.temperature,
+                                                self.timeslice.wet_bulb_temperature)
+
+    def time_mixing_ratio_from_relative_humidity(self, timeslice):
+        """Benchmarking mixing ratio from relative humidity calculation on a 3d cube."""
+        mpcalc.mixing_ratio_from_relative_humidity(self.timeslice.pressure,
+                                                   self.timeslice.temperature,
+                                                   self.timeslice.relative_humidity)
+
+    def time_mixing_ratio_from_specific_humidity(self, timeslice):
+        """Benchmarking calculating mixing rato from specific humidity on a 3d cube."""
+        mpcalc.mixing_ratio_from_specific_humidity(self.timeslice.specific_humidity)
+
+    def time_relative_humidity_from_mixing_ratio(self, timeslice):
+        """Benchmarking relative humidity from mixing ratio calculation on a 3d cube."""
+        mpcalc.relative_humidity_from_mixing_ratio(self.timeslice.pressure,
+                                                   self.timeslice.temperature,
+                                                   self.timeslice.mixing_ratio)
+
+    def time_equivalent_potential_temperature(self, timeslice):
+        """Benchmarking equivalent potential temperature calculation on 3d cube."""
+        mpcalc.equivalent_potential_temperature(self.timeslice.pressure,
+                                                self.timeslice.temperature,
+                                                self.timeslice.dewpoint)
+
+    def time_virtual_temperature_from_dewpoint(self, timeslice):
+        """Benchmarking virtual temperature from dewpoint calculation on 3d cube."""
+        mpcalc.virtual_temperature_from_dewpoint(self.timeslice.pressure,
+                                                 self.timeslice.temperature,
+                                                 self.timeslice.dewpoint)

MetPy/source/benchmarks/benchmarks/other_benchmarks.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+from metpy.units import units
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.02'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.ds = ds
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+        self.lineslice = ds.isel(pressure=0, time=0, lat=0)
+        self.profileslice = ds.isel(time=0, lat=0, lon=0)
+
+    def time_find_intersections(self, lineslice):
+        """Benchmarking finding intersections calculation."""
+        mpcalc.find_intersections(self.lineslice.lon, self.lineslice.temperature,
+                                  self.lineslice.dewpoint)
+
+    def time_find_peaks(self, pressureslice):
+        """Benchmarking finding peaks of 2d dewpoint slice."""
+        mpcalc.find_peaks(self.pressureslice.dewpoint)
+
+    def time_get_perturbation(self, ds):
+        """Benchmarking getting the perturbation of a time series."""
+        mpcalc.get_perturbation(self.ds.temperature)
+
+    def time_peak_persistence(self, pressureslice):
+        """Benchmarking calculating persistence of of maxima point in 3d."""
+        mpcalc.peak_persistence(self.pressureslice.dewpoint)
+
+    def time_isentropic_interpolation_as_dataset(self, timeslice):
+        """Benchmarking the isentropic interpolation as dataset calculation on a 3d cube."""
+        mpcalc.isentropic_interpolation_as_dataset([265.] * units.kelvin,
+                                                   self.timeslice.temperature)
+
+    def time_isentropic_interpolation(self, timeslice):
+        """Bencharking the isentropic interpolation calculation on a 3d cube."""
+        mpcalc.isentropic_interpolation([265.] * units.kelvin, self.timeslice.pressure,
+                                        self.timeslice.temperature)

MetPy/source/benchmarks/benchmarks/smoothing_benchmarks.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import numpy as np
+import xarray as xr
+
+import metpy.calc as mpcalc
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.02'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.pressureslice = ds.isel(pressure=0, time=0)
+        self.timeslice = ds.isel(time=0)
+
+    def time_smooth_gaussian(self, pressureslice):
+        """Benchmarking the gaussian smoothing of a 2d grid."""
+        mpcalc.smooth_gaussian(self.pressureslice.relative_humidity, 5)
+
+    def time_smooth_window(self, pressureslice):
+        """Benchmarking the window smoothing of a 2d grid."""
+        mpcalc.smooth_window(self.pressureslice.relative_humidity, np.diag(np.ones(5)))
+
+    def time_smooth_rectangular(self, pressureslice):
+        """Benchmarking the rectangular smoothing of a 2d grid."""
+        mpcalc.smooth_rectangular(self.pressureslice.relative_humidity, (3, 7))
+
+    def time_smooth_circular(self, pressureslice):
+        """Benchmarking the circular smoothing of a 2d grid."""
+        mpcalc.smooth_circular(self.pressureslice.relative_humidity, 2)
+
+    def time_smooth_n_point(self, pressureslice):
+        """Benchmarking the 5 point smoothing of a 2d grid."""
+        mpcalc.smooth_n_point(self.pressureslice.relative_humidity)
+
+    def time_zoom_xarray(self, pressureslice):
+        """Benchmarking the zoom xarray function."""
+        mpcalc.zoom_xarray(self.pressureslice.temperature, zoom=3.0)

MetPy/source/benchmarks/benchmarks/soundings_benchmarks.py

@@ -0,0 +1,225 @@
+# Copyright (c) 2025 MetPy Developers.
+# Distributed under the terms of the BSD 3-Clause License.
+# SPDX-License-Identifier: BSD-3-Clause
+"""Benchmark the functions in the moist thermo section of metpy's calc module.
+
+Uses Airspeed Velocity for benchmarking and uses artificial dataset to ensure consistent and
+reliable data for results.
+
+"""
+
+import os
+
+import xarray as xr
+
+import metpy.calc as mpcalc
+from metpy.units import units
+
+
+class TimeSuite:
+    """Benchmark moist thermo functions in time using Airspeed Velocity and xarray datasets.
+
+    Uses ASV's benchmarking format to load in data and run benchmarks to measure time
+     performance
+
+    """
+
+    # NOTE: I'm using CalVer https://calver.org/ YYYY.MM.DD
+    version = '2025.07.21'
+
+    def setup_cache(self):
+        """Collect the sample dataset from the filepath and opens it as an xarray.
+
+        Returns
+        -------
+        ds
+            Dataset with artificial meteorology data for testing
+        """
+        base_path = os.path.dirname(__file__)  # path to current file
+        file_path = os.path.join(base_path, '..', 'data_array_compressed.nc')
+        file_path = os.path.abspath(file_path)
+        ds = xr.open_dataset(file_path)
+        return ds
+
+    def setup(self, ds):
+        """Set up the appropriate slices from the sample dataset for testing.
+
+        Parameters
+        ----------
+        ds : dataset
+            The dataset made in setup_cache which contains the testing data
+        """
+        self.timeslice = ds.isel(time=0)
+        self.pressureslice = ds.isel(time=0, pressure=0)
+        self.profileslice = ds.isel(lat=25, lon=25, time=0)
+        self.parcelprofile = mpcalc.parcel_profile(self.profileslice.pressure,
+                                                   self.profileslice.temperature[0],
+                                                   self.profileslice.dewpoint[0])
+        self.sbcape, _ = mpcalc.surface_based_cape_cin(self.profileslice.pressure,
+                                                       self.profileslice.temperature,
+                                                       self.profileslice.dewpoint)
+        self.sblcl, _ = mpcalc.lcl(self.profileslice.pressure,
+                                   self.profileslice.temperature,
+                                   self.profileslice.dewpoint)
+        self.sblclheight = mpcalc.pressure_to_height_std(self.sblcl)
+        _, _, self.relhel = mpcalc.storm_relative_helicity(self.profileslice.height,
+                                                           self.profileslice.uwind,
+                                                           self.profileslice.vwind,
+                                                           1 * units('km'))
+        self.shearu, self.shearv = mpcalc.bulk_shear(self.profileslice.pressure,
+                                                     self.profileslice.uwind,
+                                                     self.profileslice.vwind)
+        self.shear = mpcalc.wind_speed(self.shearu, self.shearv)
+
+    def time_bulk_shear(self, profileslice):
+        """Benchmarking calculating the bulk shear of a profile."""
+        mpcalc.bulk_shear(self.profileslice.pressure, self.profileslice.uwind,
+                          self.profileslice.vwind)
+
+    def time_ccl(self, profileslice):
+        """Benchmarking calculating the convective condensation level of a profile."""
+        mpcalc.ccl(self.profileslice.pressure, self.profileslice.temperature,
+                   self.profileslice.dewpoint)
+
+    def time_parcel_profile(self, profileslice):
+        """Benchmarking the atmospheric parcel profile for one profile."""
+        mpcalc.parcel_profile(self.profileslice.pressure, self.profileslice.temperature[0],
+                              self.profileslice.dewpoint[0])
+
+    def time_most_unstable_parcel(self, profileslice):
+        """Benchmarking the calculation to find the most unstable parcel for one profile."""
+        mpcalc.most_unstable_parcel(self.profileslice.pressure, self.profileslice.temperature,
+                                    self.profileslice.dewpoint)
+
+    def time_cape_cin(self, profileslice):
+        """Benchmarking cape_cin calculation for one profile."""
+        mpcalc.cape_cin(self.profileslice.pressure, self.profileslice.temperature,
+                        self.profileslice.dewpoint, self.parcelprofile)
+
+    def time_lcl(self, timeslice):
+        """Benchmarks lcl on a 3d cube - many profiles."""
+        mpcalc.lcl(self.timeslice.pressure, self.timeslice.temperature,
+                   self.timeslice.dewpoint)
+
+    def time_el(self, profileslice):
+        """Benchmarks el calculation on one profile."""
+        mpcalc.el(self.profileslice.pressure, self.profileslice.temperature,
+                  self.profileslice.dewpoint)
+
+    def time_storm_relative_helicity(self, profileslice):
+        """Benchmarks storm relative helicity over one profile."""
+        mpcalc.storm_relative_helicity(self.profileslice.height, self.profileslice.uwind,
+                                       self.profileslice.vwind, 1 * units('km'))
+
+    def time_vertical_totals(self, timeslice):
+        """Benchmarking vertical totals for many profiles."""
+        mpcalc.vertical_totals(self.timeslice.pressure, self.timeslice.temperature)
+
+    def time_supercell_composite(self, profileslice):
+        """Benchmarks supercell composite calculation for one calculation."""
+        mpcalc.supercell_composite(2500 * units('J/kg'), 125 * units('m^2/s^2'),
+                                   50 * units.knot)
+
+    def time_critical_angle(self, profileslice):
+        """Benchmarking critical angle on one profile."""
+        mpcalc.critical_angle(self.profileslice.pressure, self.profileslice.uwind,
+                              self.profileslice.vwind, self.profileslice.height,
+                              0 * units('m/s'), 0 * units('m/s'))
+
+    def time_bunkers_storm_motion(self, profileslice):
+        """Benchmarking bunkers storm motion on one profile."""
+        mpcalc.bunkers_storm_motion(self.profileslice.pressure, self.profileslice.uwind,
+                                    self.profileslice.vwind, self.profileslice.height)
+
+    def time_corfidi_storm_motion(self, profileslice):
+        """Benchmarking corfidi storm motion on one profile."""
+        mpcalc.corfidi_storm_motion(self.profileslice.pressure, self.profileslice.uwind,
+                                    self.profileslice.vwind)
+
+    def time_sweat_index(self, timeslice):
+        """Benchmarking SWEAT index on many profiles."""
+        mpcalc.sweat_index(self.timeslice.pressure, self.timeslice.temperature,
+                           self.timeslice.dewpoint, self.timeslice.windspeed,
+                           self.timeslice.winddir)
+
+    def time_most_unstable_cape_cin(self, profileslice):
+        """Benchmarking most unstable cape cin calculation on one profile."""
+        mpcalc.most_unstable_cape_cin(self.profileslice.pressure,
+                                      self.profileslice.temperature,
+                                      self.profileslice.dewpoint)
+
+    def time_surface_based_cape_cin(self, profileslice):
+        """Benchmarking surface based cape cin calculation on one profile."""
+        mpcalc.surface_based_cape_cin(self.profileslice.pressure,
+                                      self.profileslice.temperature,
+                                      self.profileslice.dewpoint)
+
+    def time_lifted_index(self, profileslice):
+        """Benchmarking lifted index calculation on one profile."""
+        mpcalc.lifted_index(self.profileslice.pressure, self.profileslice.temperature,
+                            self.parcelprofile)
+
+    def time_k_index(self, timeslice):
+        """Benchmarking k index calculation on many profiles."""
+        mpcalc.k_index(self.timeslice.pressure, self.timeslice.temperature,
+                       self.timeslice.dewpoint)
+
+    def time_mixed_layer_cape_cin(self, profileslice):
+        """Benchmarking mixed layer cape cin calculation for one profile."""
+        mpcalc.mixed_layer_cape_cin(self.profileslice.pressure, self.profileslice.temperature,
+                                    self.profileslice.dewpoint)
+
+    def time_cross_totals(self, timeslice):
+        """Benchmarking cross totals calculation on many profiles."""
+        mpcalc.cross_totals(self.timeslice.pressure, self.timeslice.temperature,
+                            self.timeslice.dewpoint)
+
+    def time_downdraft_cape(self, profileslice):
+        """Benchmarking downdraft cape calculation on one profile."""
+        mpcalc.downdraft_cape(self.profileslice.pressure, self.profileslice.temperature,
+                              self.profileslice.dewpoint)
+
+    def time_parcel_profile_with_lcl_as_dataset(self, profileslice):
+        """Benchmarking parcel profile with lcl as dataset one on profile."""
+        mpcalc.parcel_profile_with_lcl_as_dataset(self.profileslice.pressure,
+                                                  self.profileslice.temperature,
+                                                  self.profileslice.dewpoint)
+
+    def time_showalter_index(self, profileslice):
+        """Benchmarking calculating the showalter index on one profiles."""
+        mpcalc.showalter_index(self.profileslice.pressure, self.profileslice.temperature,
+                               self.profileslice.dewpoint)
+
+    def time_galvez_davison_index(self, timeslice):
+        """Benchmarking calculating the galvez davison index on many profiles."""
+        mpcalc.galvez_davison_index(self.timeslice.pressure, self.timeslice.temperature,
+                                    self.timeslice.mixing_ratio, self.timeslice.pressure[0])
+
+    def time_significant_tornado(self, profileslice):
+        """Benchmarking significant tornado param for one profile."""
+        mpcalc.significant_tornado(self.sbcape, self.sblclheight, self.relhel, self.shear)
+
+    def time_total_totals_index(self, timeslice):
+        """Benchmarking total totals index for many profiles."""
+        mpcalc.total_totals_index(self.timeslice.pressure, self.timeslice.temperature,
+                                  self.timeslice.dewpoint)
+
+    def time_lfc(self, profileslice):
+        """Benchmarking level of free convection calculation for one profile."""
+        mpcalc.lfc(self.profileslice.pressure, self.profileslice.temperature,
+                   self.profileslice.dewpoint)
+
+    def time_mixed_parcel(self, profileslice):
+        """Benchmarking mixed parcel for one profile."""
+        mpcalc.mixed_parcel(self.profileslice.pressure, self.profileslice.temperature,
+                            self.profileslice.dewpoint)
+
+    def time_mixed_layer(self, profileslice):
+        """Benchmarking mixed layer of temperature for one profile."""
+        mpcalc.mixed_layer(self.profileslice.pressure, self.profileslice.temperature)
+
+    def time_parcel_profile_with_lcl(self, profileslice):
+        """Benchmarking parcel profile with lcl calculation."""
+        mpcalc.parcel_profile_with_lcl(self.profileslice.pressure,
+                                       self.profileslice.temperature,
+                                       self.profileslice.dewpoint)