sdf-xarray 0.2.5__tar.gz → 0.3.0__tar.gz

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/.github/workflows/build_publish.yml

@@ -32,7 +32,7 @@ jobs:
         uv sync --python 3.12 --extra test --extra build --frozen
 
     - name: Build
-      uses: pypa/cibuildwheel@v2.21.3
+      uses: pypa/cibuildwheel@v3.1.3
       env:
         CIBW_ARCHS_LINUX: auto
         CIBW_ARCHS_MACOS: x86_64 arm64

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/CONTRIBUTING.md

@@ -33,7 +33,7 @@ To run these tools locally, install the optional dependencies and run:
 
 ```bash
 pip install "sdf-xarray[lint]"
-ruff check
+ruff check src tests
 ```
 
 ### Running and Adding Tests
@@ -68,6 +68,12 @@ pip install "sdf-xarray[docs]"
 cd docs
 make html
 ```
+
+The documentation can be updated by changing any of the `*.rst` files located
+in the main `docs` directory. The existing documentation hopefully includes most
+of the snippets you'd need to write or update it, however if you are stuck
+please don't hesitate to reach out.
+
 Every time you make changes to the documentation or add a new page, you must
 re-run the `make html` command to regenerate the HTML files.
 

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/PKG-INFO

@@ -1,47 +1,20 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sdf-xarray
-Version: 0.2.5
+Version: 0.3.0
 Summary: Provides a backend for xarray to read SDF files as created by the EPOCH plasma PIC code.
 Author-Email: Peter Hill <peter.hill@york.ac.uk>, Joel Adams <joel.adams@york.ac.uk>, Shaun Doherty <shaun.doherty@york.ac.uk>
-License: Copyright 2024, Peter Hill, Joel Adams, epochpic team
-         
-         Redistribution and use in source and binary forms, with or without
-         modification, are permitted provided that the following conditions are
-         met:
-         
-         1. Redistributions of source code must retain the above copyright
-         notice, this list of conditions and the following disclaimer.
-         
-         2. 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.
-         
-         3. 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.
-         
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: xarray>=2024.1.0
 Requires-Dist: dask>=2024.7.1
@@ -88,6 +61,9 @@ sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files
 [EPOCH](https://epochpic.github.io) using the [SDF-C](https://github.com/epochpic/SDF_C) library.
 Part of [BEAM](#broad-epoch-analysis-modules-beam) (Broad EPOCH Analysis Modules).
 
+> [!IMPORTANT]
+> To install this package make sure you are using one of the Python versions listed above.
+
 ## Installation
 
 Install from PyPI with:

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/README.md

@@ -13,6 +13,9 @@ sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files
 [EPOCH](https://epochpic.github.io) using the [SDF-C](https://github.com/epochpic/SDF_C) library.
 Part of [BEAM](#broad-epoch-analysis-modules-beam) (Broad EPOCH Analysis Modules).
 
+> [!IMPORTANT]
+> To install this package make sure you are using one of the Python versions listed above.
+
 ## Installation
 
 Install from PyPI with:

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/docs/conf.py

@@ -8,9 +8,9 @@ from importlib.metadata import version as get_version
 from pathlib import Path
 
 with suppress(ImportError):
-    import matplotlib
+    import matplotlib as mpl
 
-    matplotlib.use("Agg")
+    mpl.use("Agg")
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/docs/getting_started.rst

@@ -7,6 +7,15 @@
 Installation
 ------------
 
+.. |python_versions_pypi| image:: https://img.shields.io/pypi/pyversions/sdf-xarray.svg
+   :alt: Supported Python versions
+   :target: https://pypi.org/project/sdf-xarray/
+
+.. important::
+
+   To install this package, ensure that you are using one of the supported Python
+   versions: |python_versions_pypi|
+
 Install sdf-xarray from PyPI with:
 
 .. code-block:: bash
@@ -28,7 +37,7 @@ Usage
 `xarray`. There are several ways to load SDF files:
 
 - To load a single file, use :func:`xarray.open_dataset`.
-- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset`.
+- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset` (Recommended). 
 - To access the raw contents of a single SDF file, use :func:`sdf_xarray.sdf_interface.SDFFile`.
 
 .. note::
@@ -42,21 +51,32 @@ Basic usage:
 .. ipython:: python
 
     import xarray as xr
+    import sdf_xarray as sdfxr
     with xr.open_dataset("tutorial_dataset_1d/0010.sdf") as df:
         print(df["Electric_Field_Ex"])
 
 Multi file loading
 ~~~~~~~~~~~~~~~~~~
 
-To open a whole simulation at once, pass
-``preprocess=sdf_xarray.SDFPreprocess()`` to `xarray.open_mfdataset`:
+To open a whole simulation's files at once use the :func:`sdf_xarray.open_mfdataset` function:
+
+.. ipython:: python
+    
+    sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
+
+You can alternatively open the dataset using the xarray's :func:`xarray.open_mfdataset`
+along with the ``preprocess=sdfxr.SDFPreprocess()``:
 
 .. ipython:: python
 
-    from sdf_xarray import SDFPreprocess
-    xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+    xr.open_mfdataset(
+        "tutorial_dataset_1d/*.sdf",
+        join="outer",
+        compat="no_conflicts",
+        preprocess=sdfxr.SDFPreprocess()
+    )
 
-`SDFPreprocess` checks that all the files are from the same simulation, and
+:class:`sdf_xarray.SDFPreprocess` checks that all the files are from the same simulation, and
 ensures there's a ``time`` dimension so the files are correctly concatenated.
 
 If your simulation has multiple ``output`` blocks so that not all variables are
@@ -64,12 +84,11 @@ output at every time step, then those variables will have ``NaN`` values at the
 corresponding time points.
 
 Alternatively, we can create a separate time dimensions for each ``output``
-block using `sdf_xarray.open_mfdataset` with ``separate_times=True``:
+block using :func:`sdf_xarray.open_mfdataset` with ``separate_times=True``:
 
 .. ipython:: python
 
-    from sdf_xarray import open_mfdataset
-    open_mfdataset("tutorial_dataset_1d/*.sdf", separate_times=True)
+    sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf", separate_times=True)
 
 This is better for memory consumption, at the cost of perhaps slightly less
 friendly comparisons between variables on different time coordinates.

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/docs/index.rst

@@ -15,6 +15,7 @@ plasma PIC code.
    Getting Started <getting_started>
    Key Functionality <key_functionality>
    Unit Conversion <unit_conversion>
+   Known Issues <known_issues>
    Contributing <contributing>
 
 .. toctree::

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/docs/key_functionality.rst

@@ -6,17 +6,17 @@ Key Functionality
 
 .. ipython:: python
 
+   import xarray as xr
+   import sdf_xarray as sdfxr
    import matplotlib.pyplot as plt
    from IPython.display import display, HTML
-   import xarray as xr
-   from sdf_xarray import SDFFile, SDFPreprocess
 
 Loading SDF Files
 -----------------
 There are several ways to load SDF files:
 
 - To load a single file, use :func:`xarray.open_dataset`.
-- To load multiple files, use :func:`xarray.open_mfdataset` or :func:`sdf_xarray.open_mfdataset`.
+- To load multiple files, use :func:`sdf_xarray.open_mfdataset` or :func:`xarray.open_mfdataset`.
 - To access the raw contents of a single SDF file, use :func:`sdf_xarray.sdf_interface.SDFFile`.
 
 .. note::
@@ -34,23 +34,49 @@ Loading a Single Raw SDF File
 
 .. ipython:: python
 
-   with SDFFile("tutorial_dataset_1d/0010.sdf") as sdf_file:
+   with sdfxr.SDFFile("tutorial_dataset_1d/0010.sdf") as sdf_file:
       print(sdf_file.variables)
 
 Loading all SDF Files for a Simulation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-When loading in all the files we have do some processing of the data
+Multiple files can be loaded using one of two methods. The first of which
+is by using the :func:`sdf_xarray.open_mfdataset`
+
+.. ipython:: python
+
+   sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
+
+Alternatively files can be loaded using :func:`xarray.open_mfdataset`
+however when loading in all the files we have do some processing of the data
 so that we can correctly align it along the time dimension; This is
 done via the ``preprocess`` parameter.
 
 .. ipython:: python
 
-   xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+   xr.open_mfdataset(
+      "tutorial_dataset_1d/*.sdf",
+      join="outer",
+      compat="no_conflicts",
+      preprocess=sdfxr.SDFPreprocess())
 
 Reading particle data
 ~~~~~~~~~~~~~~~~~~~~~
 
+.. warning::
+   It is **not recommended** to use :func:`xarray.open_mfdataset` or
+   :func:`sdf_xarray.open_mfdataset` to load particle data from multiple
+   SDF outputs. The number of particles often varies between outputs,
+   which can lead to inconsistent array shapes that these functions
+   cannot handle. Instead, consider loading each file individually and
+   then concatenating them manually.
+
+.. note::
+   When loading multiple probes from a single SDF file, you **must** use the
+   ``probe_names`` parameter to assign a unique name to each. For example,
+   use ``probe_names=["Front_Electron_Probe", "Back_Electron_Probe"]``.
+   Failing to do so will result in dimension name conflicts.
+
 By default, particle data isn't kept as it takes up a lot of space.
 Pass ``keep_particles=True`` as a keyword argument to
 :func:`xarray.open_dataset` (for single files) or :func:`xarray.open_mfdataset` (for
@@ -79,7 +105,7 @@ looking at when you call ``.values``
 
 .. ipython:: python
 
-   ds = xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess())
+   ds = sdfxr.open_mfdataset("tutorial_dataset_1d/*.sdf")
 
    ds["Electric_Field_Ex"]
 

sdf_xarray-0.3.0/docs/known_issues.rst

@@ -0,0 +1,9 @@
+.. _sec-known-issues:
+
+============
+Known Issues
+============
+
+There are a couple of known 'quirks' in sdf-xarray:
+
+- `Issue #57 <https://github.com/epochpic/sdf-xarray/issues/57>`_ Loading multiple SDF files with `open_mfdataset` can lead to out-of-memory errors. The issue is believed to stem from how the underlying `xarray` library handles coordinates, causing it to infer an excessively large array shape that requests far more memory than is needed. Due to the significant architectural changes required for a fix, the maintainers do not plan to resolve this. The recommended solution is to load the files individually or in smaller batches.

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/docs/unit_conversion.rst

@@ -38,8 +38,7 @@ import, the ``xarray.Dataset.pint`` accessor will not be initialised.
 
 .. ipython:: python
 
-    import xarray as xr
-    from sdf_xarray import SDFPreprocess
+    from sdf_xarray import open_mfdataset
     import pint_xarray
 
 In the following example we will extract the time-resolved total particle
@@ -72,7 +71,7 @@ be removed.
 
 .. ipython:: python
 
-    with xr.open_mfdataset("tutorial_dataset_1d/*.sdf", preprocess=SDFPreprocess()) as ds:
+    with open_mfdataset("tutorial_dataset_1d/*.sdf") as ds:
         total_particle_energy = ds["Total_Particle_Energy_Electron"]
 
     total_particle_energy

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/pyproject.toml

@@ -10,30 +10,27 @@ build-backend = "scikit_build_core.build"
 [project]
 name = "sdf-xarray"
 dynamic = ["version"]
-license = { file = "LICENCE" }
+license = "BSD-3-Clause"
 readme = "README.md"
 authors = [
   { name = "Peter Hill", email = "peter.hill@york.ac.uk" },
   { name = "Joel Adams", email = "joel.adams@york.ac.uk" },
   { name = "Shaun Doherty", email = "shaun.doherty@york.ac.uk" },
 ]
-requires-python = ">=3.10"
-dependencies = [
-  "numpy>=2.0.0",
-  "xarray>=2024.1.0",
-  "dask>=2024.7.1",
-]
+requires-python = ">=3.10,<3.14"
+dependencies = ["numpy>=2.0.0", "xarray>=2024.1.0", "dask>=2024.7.1"]
 description = "Provides a backend for xarray to read SDF files as created by the EPOCH plasma PIC code."
 classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering",
+  "Operating System :: OS Independent",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
-  "Intended Audience :: Science/Research",
-  "Topic :: Scientific/Engineering",
-  "Operating System :: OS Independent",
 ]
 
 [project.optional-dependencies]

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/src/sdf_xarray/__init__.py

@@ -2,12 +2,15 @@ import os
 import re
 from collections import Counter, defaultdict
 from collections.abc import Callable, Iterable
+from importlib.metadata import version
 from itertools import product
+from os import PathLike as os_PathLike
 from pathlib import Path
 from typing import ClassVar
 
 import numpy as np
 import xarray as xr
+from packaging.version import Version
 from xarray.backends import AbstractDataStore, BackendArray, BackendEntrypoint
 from xarray.backends.file_manager import CachingFileManager
 from xarray.backends.locks import ensure_lock
@@ -21,6 +24,12 @@ import sdf_xarray.plotting  # noqa: F401
 
 from .sdf_interface import Constant, SDFFile  # type: ignore  # noqa: PGH003
 
+# TODO Remove this once the new kwarg options are fully implemented
+if Version(version("xarray")) >= Version("2025.8.0"):
+    xr.set_options(use_new_combine_kwarg_defaults=True)
+
+PathLike = str | os_PathLike
+
 
 def _rename_with_underscore(name: str) -> str:
     """A lot of the variable names have spaces, forward slashes and dashes in them, which
@@ -51,14 +60,32 @@ def _process_latex_name(variable_name: str) -> str:
     return variable_name
 
 
+def _resolve_glob(path_glob: PathLike | Iterable[PathLike]):
+    """
+    Normalise input path_glob into a sorted list of absolute, resolved Path objects.
+    """
+
+    try:
+        p = Path(path_glob)
+        paths = list(p.parent.glob(p.name)) if p.name == "*.sdf" else list(p)
+    except TypeError:
+        paths = list({Path(p) for p in path_glob})
+
+    paths = sorted(p.resolve() for p in paths)
+    if not paths:
+        raise FileNotFoundError(f"No files matched pattern or input: {path_glob!r}")
+    return paths
+
+
 def combine_datasets(path_glob: Iterable | str, **kwargs) -> xr.Dataset:
     """Combine all datasets using a single time dimension"""
 
     return xr.open_mfdataset(
         path_glob,
-        data_vars="minimal",
-        coords="minimal",
-        compat="override",
+        data_vars="all",
+        coords="different",
+        compat="no_conflicts",
+        join="outer",
         preprocess=SDFPreprocess(),
         **kwargs,
     )
@@ -69,6 +96,7 @@ def open_mfdataset(
     *,
     separate_times: bool = False,
     keep_particles: bool = False,
+    probe_names: list[str] | None = None,
 ) -> xr.Dataset:
     """Open a set of EPOCH SDF files as one `xarray.Dataset`
 
@@ -98,20 +126,21 @@ def open_mfdataset(
         different output frequencies
     keep_particles :
         If ``True``, also load particle data (this may use a lot of memory!)
+    probe_names :
+        List of EPOCH probe names
     """
 
-    # TODO: This is not very robust, look at how xarray.open_mfdataset does it
-    if isinstance(path_glob, str):
-        path_glob = Path().glob(path_glob)
-
-    # Coerce to list because we might need to use the sequence multiple times
-    path_glob = sorted(list(path_glob))  # noqa: C414
-
+    path_glob = _resolve_glob(path_glob)
     if not separate_times:
-        return combine_datasets(path_glob, keep_particles=keep_particles)
+        return combine_datasets(
+            path_glob, keep_particles=keep_particles, probe_names=probe_names
+        )
 
-    time_dims, var_times_map = make_time_dims(path_glob)
-    all_dfs = [xr.open_dataset(f, keep_particles=keep_particles) for f in path_glob]
+    _, var_times_map = make_time_dims(path_glob)
+    all_dfs = [
+        xr.open_dataset(f, keep_particles=keep_particles, probe_names=probe_names)
+        for f in path_glob
+    ]
 
     for df in all_dfs:
         for da in df:
@@ -128,7 +157,12 @@ def open_mfdataset(
                 )
 
     return xr.combine_by_coords(
-        all_dfs, data_vars="minimal", combine_attrs="drop_conflicts"
+        all_dfs,
+        data_vars="all",
+        coords="different",
+        combine_attrs="drop_conflicts",
+        join="outer",
+        compat="no_conflicts",
     )
 
 
@@ -211,14 +245,23 @@ class SDFDataStore(AbstractDataStore):
         "drop_variables",
         "keep_particles",
         "lock",
+        "probe_names",
     )
 
-    def __init__(self, manager, drop_variables=None, keep_particles=False, lock=None):
+    def __init__(
+        self,
+        manager,
+        drop_variables=None,
+        keep_particles=False,
+        lock=None,
+        probe_names=None,
+    ):
         self._manager = manager
         self._filename = self.ds.filename
         self.drop_variables = drop_variables
         self.keep_particles = keep_particles
         self.lock = ensure_lock(lock)
+        self.probe_names = probe_names
 
     @classmethod
     def open(
@@ -227,6 +270,7 @@ class SDFDataStore(AbstractDataStore):
         lock=None,
         drop_variables=None,
         keep_particles=False,
+        probe_names=None,
     ):
         if isinstance(filename, os.PathLike):
             filename = os.fspath(filename)
@@ -237,6 +281,7 @@ class SDFDataStore(AbstractDataStore):
             lock=lock,
             drop_variables=drop_variables,
             keep_particles=keep_particles,
+            probe_names=probe_names,
         )
 
     def _acquire(self, needs_lock=True):
@@ -347,7 +392,28 @@ class SDFDataStore(AbstractDataStore):
 
             if value.is_point_data:
                 # Point (particle) variables are 1D
-                var_coords = (f"ID_{_process_grid_name(key, _grid_species_name)}",)
+
+                # Particle data does not maintain a fixed dimension size
+                # throughout the simulation. An example of a particle name comes
+                # in the form of `Particles/Px/Ion_H` which is then modified
+                # using `_process_grid_name()` into `Ion_H`. This is fine as the
+                # other components of the momentum (`Py`, `Pz`) will have the same
+                # size as they represent the same bunch of particles.
+
+                # Probes however have names in the form of `Electron_Front_Probe/Px`
+                # which are changed to just `Px`; this is fine when there is only one
+                # probe in the system but when there are multiple they will have
+                # conflicting sizes so we can't keep the names as simply `Px` so we
+                # instead set their dimension as the full name `Electron_Front_Probe_Px`.
+                is_probe_name_match = self.probe_names is not None and any(
+                    name in key for name in self.probe_names
+                )
+                name_processor = (
+                    _rename_with_underscore
+                    if is_probe_name_match
+                    else _grid_species_name
+                )
+                var_coords = (f"ID_{_process_grid_name(key, name_processor)}",)
             else:
                 # These are DataArrays
 
@@ -414,6 +480,7 @@ class SDFEntrypoint(BackendEntrypoint):
         *,
         drop_variables=None,
         keep_particles=False,
+        probe_names=None,
     ):
         if isinstance(filename_or_obj, Path):
             # sdf library takes a filename only
@@ -424,6 +491,7 @@ class SDFEntrypoint(BackendEntrypoint):
             filename_or_obj,
             drop_variables=drop_variables,
             keep_particles=keep_particles,
+            probe_names=probe_names,
         )
         with close_on_error(store):
             return store.load()
@@ -432,6 +500,7 @@ class SDFEntrypoint(BackendEntrypoint):
         "filename_or_obj",
         "drop_variables",
         "keep_particles",
+        "probe_names",
     ]
 
     def guess_can_open(self, filename_or_obj):

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/src/sdf_xarray/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.5'
-__version_tuple__ = version_tuple = (0, 2, 5)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
+
+__commit_id__ = commit_id = 'gcca942b3f'

{sdf_xarray-0.2.5 → sdf_xarray-0.3.0}/src/sdf_xarray/plotting.py

@@ -114,8 +114,8 @@ def animate(
     --------
     >>> dataset["Derived_Number_Density_Electron"].epoch.animate()
     """
-    import matplotlib.pyplot as plt
-    from matplotlib.animation import FuncAnimation
+    import matplotlib.pyplot as plt  # noqa: PLC0415
+    from matplotlib.animation import FuncAnimation  # noqa: PLC0415
 
     kwargs_original = kwargs.copy()