Run pre-commit hooks and enable in CI (#39)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: VeckoTheGecko

.gitignore

@@ -13,4 +13,3 @@ build/
 parcels/
 .asv/
 html/
-

.prettierignore

@@ -0,0 +1,2 @@
+results
+pixi.lock

README.md

@@ -13,35 +13,39 @@ This repository houses performance benchmarks for [Parcels](https://github.com/O
 You can run the linting with `pixi run lint`
 
 > [!IMPORTANT]
-> The default path for the benchmark data is set by [pooch.os_cache](https://www.fatiando.org/pooch/latest/api/generated/pooch.os_cache.html), which typically is a subdirectory of your home directory. Currently, you will need at least 50GB of disk space available to store the benchmark data. 
-> To change the location of the benchmark data cache, you can set the environment variable `PARCELS_DATADIR` to a preferred location to store the benchmark data. 
-
+> The default path for the benchmark data is set by [pooch.os_cache](https://www.fatiando.org/pooch/latest/api/generated/pooch.os_cache.html), which typically is a subdirectory of your home directory. Currently, you will need at least 50GB of disk space available to store the benchmark data.
+> To change the location of the benchmark data cache, you can set the environment variable `PARCELS_DATADIR` to a preferred location to store the benchmark data.
 
 To view the benchmark data
 
 - `pixi run asv publish`
 - `pixi run asv preview`
 
 ## Contributing benchmark runs
+
 We value seeing how Parcels benchmarks perform on a variety of systems. When you run the benchmarks, this adds data to the `results/` subdirectory in this repository. After running the benchmarks, you can commit the changes made to the `results/` subdirectory and open a pull request to contribute your benchmark results.
 
 ### Parcels Community Members
+
 Members of the Parcels community can contribute benchmark data using the following steps
 
 1. [Create a fork of this repository](https://github.com/Parcels-code/parcels-benchmarks/fork)
 
 2. Clone your fork onto your system
+
 ```
 git clone git@github.com:<your-github-handle>/parcels-benchmarks.git ~/parcels-benchmarks
 ```
 
 3. Run the benchmarks
+
 ```
 cd ~/parcels-benchmarks
 pixi run asv run
 ```
 
 4. Commit your benchmark data and push the changes back to your fork, e.g.
+
 ```
 git add results
 git commit -m "Add benchmark data"
@@ -50,22 +54,23 @@ git push origin main
 
 5. [Open a pull request from your fork](https://github.com/Parcels-code/parcels-benchmarks/compare)
 
-
-
 ## Adding benchmarks
-Adding benchmarks for parcels typically involves adding a dataset and defining the benchmarks you want to run. 
 
+Adding benchmarks for parcels typically involves adding a dataset and defining the benchmarks you want to run.
 
 ### Adding new data
+
 Data is hosted remotely on a SurfDrive managed by the Parcels developers. You will need to open an issue on this repository to start the process of getting your data hosted in the shared SurfDrive.
 Once your data is hosted in the shared SurfDrive, you can easily add your dataset to the benchmark dataset manifest using
+
 ```
 pixi run benchmark-setup pixi add-dataset --name "Name for your dataset" --file "Path to ZIP archive in the SurfDrive"
 ```
 
 During this process, the dataset will be downloaded and a complete entry will be added to the [parcels_benchmarks/benchmarks.json](./parcels_benchmarks/benchmarks.json) manifest file. Once updated, this file can be committed to this repository and contributed via a pull request.
- 
+
 ### Writing the benchmarks
+
 This repository uses [ASV](https://asv.readthedocs.io/) for running benchmarks. You can add benchmarks by including a python script in the `benchmarks/` subdirectory. Within each `benchmarks/*.py` file, we ask that you define a class for the set of benchmarks you plan to run for your dataset. You can use the existing benchmarks as a good starting point for writing your benchmarks.
 
 To learn more about writing benchmarks compatible with ASV, see the [ASV "Writing Benchmarks" documentation](https://asv.readthedocs.io/en/latest/writing_benchmarks.html)

asv.conf.json

@@ -5,7 +5,11 @@
   "repo": "https://github.com/Parcels-Code/parcels.git",
   "branches": ["main"],
   "environment_type": "rattler",
-  "conda_channels": ["conda-forge", "defaults", "https://repo.prefix.dev/parcels"],
+  "conda_channels": [
+    "conda-forge",
+    "defaults",
+    "https://repo.prefix.dev/parcels"
+  ],
   "default_benchmark_timeout": 1800,
   "env_dir": ".asv/env",
   "results_dir": "results",

benchmarks/fesom2.py

@@ -1,19 +1,18 @@
 import numpy as np
 import uxarray as ux
 from parcels import (
-    convert,
-    Field,
     FieldSet,
     Particle,
     ParticleSet,
-    UxGrid,
-    VectorField,
+    convert,
 )
 from parcels.kernels import AdvectionRK2_3D
-from parcels_benchmarks.benchmark_setup import download_example_dataset, PARCELS_DATADIR
 
-runtime=np.timedelta64(1, "D")
-dt=np.timedelta64(2400, "s")
+from parcels_benchmarks.benchmark_setup import PARCELS_DATADIR, download_example_dataset
+
+runtime = np.timedelta64(1, "D")
+dt = np.timedelta64(2400, "s")
+
 
 def _load_ds(datapath):
     """Helper function to load uxarray dataset from datapath"""
@@ -24,38 +23,35 @@ def _load_ds(datapath):
 
 
 class FESOM2:
-    params = (
-            [10000],
-            [AdvectionRK2_3D]
-        )
-    param_names = [
-            "npart",
-            "integrator"
-        ]
-    def setup(self,npart,integrator):
+    params = ([10000], [AdvectionRK2_3D])
+    param_names = ["npart", "integrator"]
+
+    def setup(self, npart, integrator):
         # Ensure the dataset is downloaded in the desired data_home
         # and obtain the path to the dataset
-        self.datapath = download_example_dataset("FESOM-baroclinic-gyre", data_home=PARCELS_DATADIR)
+        self.datapath = download_example_dataset(
+            "FESOM-baroclinic-gyre", data_home=PARCELS_DATADIR
+        )
 
-    def time_load_data(self,npart,integrator):
+    def time_load_data(self, npart, integrator):
         ds = _load_ds(self.datapath)
         for i in range(min(ds.coords["time"].size, 2)):
-            u = ds["u"].isel(time=i).compute()
-            v = ds["v"].isel(time=i).compute()
+            _u = ds["u"].isel(time=i).compute()
+            _v = ds["v"].isel(time=i).compute()
 
-    def pset_execute(self,npart,integrator):
+    def pset_execute(self, npart, integrator):
         ds = _load_ds(self.datapath)
         ds = convert.fesom_to_ugrid(ds)
         fieldset = FieldSet.from_ugrid_conventions(ds)
 
-        lon = np.linspace(2.0,15.0,npart)
-        lat = np.linspace(32.0,19.0,npart)
+        lon = np.linspace(2.0, 15.0, npart)
+        lat = np.linspace(32.0, 19.0, npart)
 
         pset = ParticleSet(fieldset=fieldset, pclass=Particle, lon=lon, lat=lat)
         pset.execute(runtime=runtime, dt=dt, pyfunc=integrator)
 
-    def time_pset_execute(self,npart,integrator):
-        self.pset_execute(npart,integrator)
+    def time_pset_execute(self, npart, integrator):
+        self.pset_execute(npart, integrator)
 
-    def peakmem_pset_execute(self,npart,integrator):
-        self.pset_execute(npart,integrator)
+    def peakmem_pset_execute(self, npart, integrator):
+        self.pset_execute(npart, integrator)

benchmarks/moi_curvilinear.py

@@ -1,37 +1,57 @@
-import xarray as xr
-import time
 from glob import glob
+
 import numpy as np
 import parcels
+import xarray as xr
 import xgcm
 from parcels.interpolators import XLinear
-from parcels_benchmarks.benchmark_setup import download_example_dataset, PARCELS_DATADIR
+
+from parcels_benchmarks.benchmark_setup import PARCELS_DATADIR, download_example_dataset
 
 runtime = np.timedelta64(2, "D")
 dt = np.timedelta64(15, "m")
 
+
 def _load_ds(datapath, chunk):
     """Helper function to load xarray dataset from datapath with or without chunking"""
 
     fileU = f"{datapath}/psy4v3r1-daily_U_2025-01-0[1-3].nc"
-    filenames = {"U": glob(fileU), "V": glob(fileU.replace("_U_", "_V_")), "W": glob(fileU.replace("_U_", "_W_"))}
+    filenames = {
+        "U": glob(fileU),
+        "V": glob(fileU.replace("_U_", "_V_")),
+        "W": glob(fileU.replace("_U_", "_W_")),
+    }
     mesh_mask = f"{datapath}/PSY4V3R1_mesh_hgr.nc"
-    fileargs = {"concat_dim": "time_counter",
-       "combine": "nested",
-       "data_vars": 'minimal',
-       "coords": 'minimal',
-       "compat": 'override',
+    fileargs = {
+        "concat_dim": "time_counter",
+        "combine": "nested",
+        "data_vars": "minimal",
+        "coords": "minimal",
+        "compat": "override",
     }
     if chunk:
-        fileargs["chunks"] = {"time_counter": 1, "depth":2, "y": chunk, "x": chunk}
+        fileargs["chunks"] = {"time_counter": 1, "depth": 2, "y": chunk, "x": chunk}
 
-    ds_u = xr.open_mfdataset(filenames["U"], **fileargs)[["vozocrtx"]].drop_vars(["nav_lon", "nav_lat"])
-    ds_v = xr.open_mfdataset(filenames["V"], **fileargs)[["vomecrty"]].drop_vars(["nav_lon", "nav_lat"])
+    ds_u = xr.open_mfdataset(filenames["U"], **fileargs)[["vozocrtx"]].drop_vars(
+        ["nav_lon", "nav_lat"]
+    )
+    ds_v = xr.open_mfdataset(filenames["V"], **fileargs)[["vomecrty"]].drop_vars(
+        ["nav_lon", "nav_lat"]
+    )
     ds_depth = xr.open_mfdataset(filenames["W"], **fileargs)[["depthw"]]
     ds_mesh = xr.open_dataset(mesh_mask)[["glamf", "gphif"]].isel(t=0)
 
     ds = xr.merge([ds_u, ds_v, ds_depth, ds_mesh], compat="identical")
-    ds = ds.rename({"vozocrtx": "U", "vomecrty": "V", "glamf": "lon", "gphif": "lat", "time_counter": "time", "depthw": "depth"})
+    ds = ds.rename(
+        {
+            "vozocrtx": "U",
+            "vomecrty": "V",
+            "glamf": "lon",
+            "gphif": "lat",
+            "time_counter": "time",
+            "depthw": "depth",
+        }
+    )
     ds.deptht.attrs["c_grid_axis_shift"] = -0.5
 
     return ds
@@ -40,41 +60,46 @@ def _load_ds(datapath, chunk):
 class MOICurvilinear:
     """Mercator Ocean International model data based benchmark on a curvilinear grid."""
 
-    params = ( 
-            ["XLinear"],
-            [256],
-            [10000],
+    params = (
+        ["XLinear"],
+        [256],
+        [10000],
     )
     param_names = [
-            "interpolator",
-            "chunk",
-            "npart",
-        ]
-    def setup(self,interpolator,chunk,npart):
-        self.datapath = download_example_dataset("MOi-curvilinear", data_home=PARCELS_DATADIR)
-
-    def time_load_data_3d(self,interpolator,chunk,npart):
+        "interpolator",
+        "chunk",
+        "npart",
+    ]
+
+    def setup(self, interpolator, chunk, npart):
+        self.datapath = download_example_dataset(
+            "MOi-curvilinear", data_home=PARCELS_DATADIR
+        )
+
+    def time_load_data_3d(self, interpolator, chunk, npart):
         """Benchmark that times loading the 'U' and 'V' data arrays only for 3-D"""
 
         # To have a reasonable runtime, we only consider the time it takes to load two time levels
         # and two depth levels (at most)
-        ds = _load_ds(self.datapath,chunk)
-        for j in range(min(ds.coords["deptht"].size,2)):
+        ds = _load_ds(self.datapath, chunk)
+        for j in range(min(ds.coords["deptht"].size, 2)):
             for i in range(min(ds.coords["time"].size, 2)):
-                u = ds["U"].isel(deptht=j,time=i).compute()
-                v = ds["V"].isel(deptht=j,time=i).compute()
+                _u = ds["U"].isel(deptht=j, time=i).compute()
+                _v = ds["V"].isel(deptht=j, time=i).compute()
 
-
-    def pset_execute_3d(self,interpolator,chunk,npart):
-        ds = _load_ds(self.datapath,chunk)
-        coords={
+    def pset_execute_3d(self, interpolator, chunk, npart):
+        ds = _load_ds(self.datapath, chunk)
+        coords = {
             "X": {"left": "x"},
             "Y": {"left": "y"},
             "Z": {"center": "deptht", "left": "depth"},
             "T": {"center": "time"},
         }
 
-        grid = parcels._core.xgrid.XGrid(xgcm.Grid(ds, coords=coords, autoparse_metadata=False, periodic=False), mesh="spherical")
+        grid = parcels._core.xgrid.XGrid(
+            xgcm.Grid(ds, coords=coords, autoparse_metadata=False, periodic=False),
+            mesh="spherical",
+        )
 
         if interpolator == "XLinear":
             interp_method = XLinear
@@ -86,21 +111,22 @@ def pset_execute_3d(self,interpolator,chunk,npart):
         U.units = parcels.GeographicPolar()
         V.units = parcels.Geographic()
         UV = parcels.VectorField("UV", U, V)
-    
+
         fieldset = parcels.FieldSet([U, V, UV])
-    
+
         pclass = parcels.Particle
 
         lon = np.linspace(-10, 10, npart)
         lat = np.linspace(-30, -20, npart)
 
         pset = parcels.ParticleSet(fieldset=fieldset, pclass=pclass, lon=lon, lat=lat)
 
-        pset.execute(parcels.kernels.AdvectionEE, runtime=runtime, dt=dt, verbose_progress=False)
-
-    def time_pset_execute_3d(self,interpolator,chunk,npart):
-        self.pset_execute_3d(interpolator,chunk,npart)
+        pset.execute(
+            parcels.kernels.AdvectionEE, runtime=runtime, dt=dt, verbose_progress=False
+        )
 
-    def peakmem_pset_execute_3d(self,interpolator,chunk,npart):
-        self.pset_execute_3d(interpolator,chunk,npart)
+    def time_pset_execute_3d(self, interpolator, chunk, npart):
+        self.pset_execute_3d(interpolator, chunk, npart)
 
+    def peakmem_pset_execute_3d(self, interpolator, chunk, npart):
+        self.pset_execute_3d(interpolator, chunk, npart)