sdf-xarray 0.4.0__cp314-cp314t-macosx_11_0_arm64.whl

sdf_xarray/sdf_interface.pyx

@@ -0,0 +1,342 @@
+cimport csdf
+
+import dataclasses
+import re
+import time
+
+from libc.string cimport memcpy
+
+import numpy as np
+
+cimport numpy as cnp
+
+cnp.import_array()
+
+# Some systems don't have F128
+_NUMPY_128 = getattr(np, "float128", None)
+
+cdef list[cnp.dtype | None] _sdf_type_mapping = [
+    None,
+    cnp.dtype(np.int32),
+    cnp.dtype(np.int64),
+    cnp.dtype(np.float32),
+    cnp.dtype(np.float64),
+    _NUMPY_128,
+    cnp.dtype("S"),
+    cnp.dtype(np.bool_),
+]
+
+
+@dataclasses.dataclass
+cdef class Block:
+    _id: str
+    name: str
+    dtype: np.dtype
+    shape: tuple[int]
+    is_point_data: bool
+    sdffile: SDFFile | None
+
+
+@dataclasses.dataclass
+cdef class Variable(Block):
+    units: str | None
+    mult: float | None
+    grid: str | None
+    grid_mid: str | None
+
+    @property
+    def data(self) -> np.ndarray :
+        """Read a variable from the file, returning numpy array
+        """
+
+        return self.sdffile.read(self)
+
+    @staticmethod
+    cdef Variable from_block(str name, csdf.sdf_block_t* block, SDFFile sdffile):
+        return Variable(
+            _id=block.id.decode("UTF-8"),
+            name=name,
+            dtype=_sdf_type_mapping[block.datatype_out],
+            shape=tuple(block.dims[i] for i in range(block.ndims)),
+            units=block.units.decode("UTF-8") if block.units else None,
+            mult=block.mult if block.mult else None,
+            grid=block.mesh_id.decode("UTF-8") if block.mesh_id else None,
+            grid_mid=f"{block.mesh_id.decode('UTF-8')}_mid" if block.mesh_id else None,
+            is_point_data=block.blocktype == csdf.SDF_BLOCKTYPE_POINT_VARIABLE,
+            sdffile=sdffile,
+        )
+
+
+@dataclasses.dataclass
+cdef class Mesh(Block):
+    units: tuple[str]
+    labels: tuple[str]
+    mults: tuple[float] | None
+    parent: Mesh | None = None
+
+    @property
+    def data(self) -> tuple[np.ndarray]:
+        """Read a variable from the file, returning numpy array
+        """
+
+        return self.sdffile.read(self)
+
+    @staticmethod
+    cdef Mesh from_block(str name, csdf.sdf_block_t* block, SDFFile sdffile):
+        return Mesh(
+            _id=block.id.decode("UTF-8"),
+            name=name,
+            dtype=_sdf_type_mapping[block.datatype_out],
+            shape=tuple(block.dims[i] for i in range(block.ndims)),
+            units=tuple(
+                block.dim_units[i].decode("UTF-8") for i in range(block.ndims)
+            ),
+            labels=tuple(
+                block.dim_labels[i].decode("UTF-8") for i in range(block.ndims)
+            ),
+            mults=(
+                tuple(block.dim_mults[i] for i in range(block.ndims))
+                if block.dim_mults
+                else None
+            ),
+            is_point_data=block.blocktype == csdf.SDF_BLOCKTYPE_POINT_MESH,
+            sdffile=sdffile,
+        )
+
+
+_CONSTANT_UNITS_RE = re.compile(r"(?P<name>.*) \((?P<units>.*)\)$")
+
+@dataclasses.dataclass
+cdef class Constant:
+    _id: str
+    name: str
+    data: int | str | float | bool
+    units: str | None
+
+    @staticmethod
+    cdef Constant from_block(str name, csdf.sdf_block_t* block):
+        data: int | str | float | double | bool
+
+        if block.datatype == csdf.SDF_DATATYPE_REAL4:
+            data = (<float*>block.const_value)[0]
+        elif block.datatype == csdf.SDF_DATATYPE_REAL8:
+            data = (<double*>block.const_value)[0]
+        if block.datatype == csdf.SDF_DATATYPE_INTEGER4:
+            data = (<csdf.int32_t*>block.const_value)[0]
+        if block.datatype == csdf.SDF_DATATYPE_INTEGER8:
+            data = (<csdf.int64_t*>block.const_value)[0]
+        if block.datatype == csdf.SDF_DATATYPE_LOGICAL:
+            data = (<bint*>block.const_value)[0]
+
+        # There's no metadata with e.g. units, but there's a
+        # convention to put one in brackets at the end of the name,
+        # if so, strip it off to give the name and units
+        units = None
+        if match := _CONSTANT_UNITS_RE.match(name):
+            name = match["name"]
+            units = match["units"]
+
+        return Constant(
+            _id=block.id.decode("UTF-8"), name=name, data=data, units=units
+        )
+
+    @property
+    def is_point_data(self) -> bool:
+        return False
+
+
+cdef class SDFFile:
+    """Read an SDF file
+
+    Attributes
+    ----------
+    header: dict
+        File metadata
+    run_info: dict
+        More metadata
+    variables: dict[str, Variable]
+        Mapping of variable name to metadata
+    grids: dict[str, Mesh]
+        Mapping of grid ID to metadata
+
+    """
+    cdef csdf.sdf_file_t* _c_sdf_file
+    cdef public str filename
+    cdef public dict header, run_info
+    cdef public dict[str, Variable] variables
+    cdef public dict[str, Mesh] grids
+
+    def __cinit__(self, filename: str):
+        self._c_sdf_file = csdf.sdf_open(
+            filename.encode("UTF-8"), 0, csdf.SDF_READ, False
+        )
+        if self._c_sdf_file == NULL:
+            raise IOError(f"Failed to open SDF file '{filename}'")
+
+        csdf.sdf_stack_init(self._c_sdf_file)
+        csdf.sdf_read_blocklist_all(self._c_sdf_file)
+
+        self.header = {
+            "filename": filename,
+            "file_version": self._c_sdf_file.file_version,
+            "file_revision": self._c_sdf_file.file_revision,
+            "code_name": self._c_sdf_file.code_name.decode("UTF-8"),
+            "step": self._c_sdf_file.step,
+            "time": self._c_sdf_file.time,
+            "jobid1": self._c_sdf_file.jobid1,
+            "jobid2": self._c_sdf_file.jobid2,
+            "code_io_version": self._c_sdf_file.code_io_version,
+            "restart_flag": bool(self._c_sdf_file.restart_flag),
+            "other_domains": bool(self._c_sdf_file.other_domains),
+            "station_file": bool(self._c_sdf_file.station_file),
+        }
+        self._read_variable_metadata()
+
+    cdef _read_variable_metadata(self):
+        cdef csdf.sdf_block_t* block = self._c_sdf_file.blocklist
+        cdef csdf.run_info* run = NULL
+
+        self.variables = {}
+        self.grids = {}
+
+        for i in range(self._c_sdf_file.nblocks):
+            name = block.name.decode("UTF-8")
+
+            if block.blocktype == csdf.SDF_BLOCKTYPE_RUN_INFO:
+                run = <csdf.run_info*>block.data
+                self.run_info = {
+                    "version": f"{run.version}.{run.revision}.{run.minor_rev}",
+                    "commit_id": run.commit_id.decode("UTF-8"),
+                    "sha1sum": run.sha1sum.decode("UTF-8"),
+                    "compile_machine": run.compile_machine.decode("UTF-8"),
+                    "compile_flags": run.compile_flags.decode("UTF-8"),
+                    "defines": f"{run.defines}",
+                    "compile_date": time.ctime(run.compile_date),
+                    "run_date": time.ctime(run.run_date),
+                    "io_date": time.ctime(run.io_date),
+                }
+
+            elif block.blocktype == csdf.SDF_BLOCKTYPE_CONSTANT:
+                # We modify the name to remove units, so convert it
+                # first so we can get the new name
+                constant = Constant.from_block(name, block)
+                self.variables[constant.name] = constant
+
+            elif block.blocktype in (
+                    csdf.SDF_BLOCKTYPE_PLAIN_MESH,
+                    csdf.SDF_BLOCKTYPE_POINT_MESH,
+                    csdf.SDF_BLOCKTYPE_LAGRANGIAN_MESH
+            ):
+                grid_id = block.id.decode("UTF-8")
+                self.grids[grid_id] = Mesh.from_block(name, block, self)
+
+                if block.blocktype != csdf.SDF_BLOCKTYPE_POINT_MESH:
+                    # Make the corresponding grid at mid-points, except for
+                    # particle grids
+                    mid_grid_block = Mesh.from_block(f"{name}_mid", block, self)
+                    mid_grid_block.shape = tuple(
+                        dim - 1 for dim in mid_grid_block.shape if dim > 1
+                    )
+                    mid_grid_block.parent = self.grids[grid_id]
+                    self.grids[f"{grid_id}_mid"] = mid_grid_block
+
+            elif block.blocktype in (
+                    csdf.SDF_BLOCKTYPE_PLAIN_VARIABLE,
+                    csdf.SDF_BLOCKTYPE_PLAIN_DERIVED,
+                    csdf.SDF_BLOCKTYPE_POINT_VARIABLE,
+                    csdf.SDF_BLOCKTYPE_POINT_DERIVED,
+                    csdf.SDF_BLOCKTYPE_ARRAY,
+            ):
+                # If the block doesn't have a datatype, that probably
+                # means its actually a grid dimension
+                if block.datatype_out != 0:
+                    self.variables[name] = Variable.from_block(name, block, self)
+
+            block = block.next
+
+    cpdef read(self, var: Block):
+        """Read a variable from the file, returning numpy array
+        """
+
+        if self._c_sdf_file is NULL:
+            raise RuntimeError(
+                f"Can't read '{var.name}', file '{self.filename}' is closed"
+            )
+
+        is_mesh: bool = isinstance(var, Mesh)
+
+        # Has a parent block, so we need to average node data to midpoint
+        if is_mesh and var.parent:
+            return self._read_mid_grid(var)
+
+        cdef csdf.sdf_block_t* block = csdf.sdf_find_block_by_name(
+            self._c_sdf_file, var.name.encode("utf-8")
+        )
+
+        if block is NULL:
+            raise RuntimeError(f"Could not read variable '{var.name}'")
+
+        self._c_sdf_file.current_block = block
+        csdf.sdf_helper_read_data(self._c_sdf_file, block)
+
+        if is_mesh:
+            # Meshes store the data for separate dimensions in block.grids
+            if not (block.grids is not NULL and block.grids[0] is not NULL):
+                raise RuntimeError(f"Could not read variable '{var.name}'")
+
+            data = []
+            for i, dim in enumerate(var.shape):
+                data.append(
+                    self._make_array((dim,), var.dtype, block.grids[i])
+                )
+            return tuple(data)
+
+        # Normal variables
+        return self._make_array(var.shape, var.dtype, block.data)
+
+    cdef _read_mid_grid(self, mesh: Mesh):
+        """Read a midpoint grid"""
+
+        data = []
+        for dim in mesh.parent.data:
+            if len(dim.shape) == 1:
+                mid_point = (dim[:-1] + dim[1:]) / 2
+            elif len(dim.shape) == 2:
+                mid_point = (
+                    dim[:-1, :-1] + dim[1:, :-1] + dim[:-1, 1:] + dim[1:, 1:]
+                ) / 4
+            else:
+                raise ValueError(
+                    f"Unexpected number of dimensions reading mesh '{mesh.name}' "
+                    f"(expected 1 or 2, got {len(dim.shape)})"
+                )
+            data.append(mid_point)
+        return tuple(data)
+
+    cdef cnp.ndarray _make_array(
+        self, tuple[int, ...] dims, cnp.dtype dtype, void* data
+    ):
+        """Helper function for making Numpy arrays from data allocated elsewhere"""
+        # This is not as efficient as it could be -- we should be able to steal
+        # the block's data, but I've not worked out to do that properly
+        # yet. This is correct at least, and means we don't need to worry about
+        # freeing the memory. Can't just use PyArray_NewFromDescr because this
+        # isn't available from Cython. Might be able to use one of the other
+        # low-level creation routines?
+        var_array = np.empty(dims, dtype=dtype, order="F")
+        memcpy(cnp.PyArray_DATA(var_array), data, var_array.nbytes)
+
+        return var_array
+
+    def close(self):
+        if self._c_sdf_file is NULL:
+            return
+        csdf.sdf_stack_destroy(self._c_sdf_file)
+        csdf.sdf_close(self._c_sdf_file)
+        self._c_sdf_file = NULL
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        self.close()

sdf_xarray-0.4.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: sdf-xarray
+Version: 0.4.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>, Chris Herdman <chris.herdman@york.ac.uk>, Liam Pattinson <liam.pattinson@york.ac.uk>
+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: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.10
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: dask>=2024.7.1
+Provides-Extra: jupyter
+Requires-Dist: dask[diagnostics]; extra == "jupyter"
+Requires-Dist: ipykernel>=6.29.5; extra == "jupyter"
+Provides-Extra: pint
+Requires-Dist: pint; extra == "pint"
+Requires-Dist: pint-xarray; extra == "pint"
+Description-Content-Type: text/markdown
+
+# sdf-xarray
+
+![Dynamic TOML Badge](https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2Fepochpic%2Fsdf-xarray%2Frefs%2Fheads%2Fmain%2Fpyproject.toml&query=%24.project.requires-python&label=python&logo=python)
+[![Available on PyPI](https://img.shields.io/pypi/v/sdf-xarray?color=blue&logo=pypi)](https://pypi.org/project/sdf-xarray/)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15351323.svg)](https://doi.org/10.5281/zenodo.15351323)
+![Build/Publish](https://github.com/epochpic/sdf-xarray/actions/workflows/build_publish.yml/badge.svg)
+![Tests](https://github.com/epochpic/sdf-xarray/actions/workflows/tests.yml/badge.svg)
+[![Read the Docs](https://img.shields.io/readthedocs/sdf-xarray?logo=readthedocs&link=https%3A%2F%2Fsdf-xarray.readthedocs.io%2F)](https://sdf-xarray.readthedocs.io)
+[![Formatted with black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
+
+
+sdf-xarray provides a backend for [xarray](https://xarray.dev) to read SDF files as created by
+[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).
+
+## Installation
+
+> [!IMPORTANT]
+> To install this package make sure you are using one of the Python versions listed above.
+
+Install from PyPI with:
+
+```bash
+pip install sdf-xarray
+```
+
+or download this code locally:
+
+```bash
+git clone --recursive https://github.com/epochpic/sdf-xarray.git
+cd sdf-xarray
+pip install .
+```
+
+We recommend switching to [uv](https://docs.astral.sh/uv/) to manage packages.
+
+## Usage
+
+Below are some simple examples to get you started. Please read the full
+documentation here <https://sdf-xarray.readthedocs.io>.
+
+### Single file loading
+
+```python
+import xarray as xr
+
+df = xr.open_dataset("0010.sdf")
+
+print(df["Electric_Field_Ex"])
+
+# <xarray.DataArray 'Electric_Field_Ex' (X_x_px_deltaf_electron_beam: 16)> Size: 128B
+# [16 values with dtype=float64]
+# Coordinates:
+#   * X_x_px_deltaf_electron_beam  (X_x_px_deltaf_electron_beam) float64 128B 1...
+# Attributes:
+#     units:    V/m
+#     full_name: "Electric Field/Ex"
+```
+
+### Multi-file loading
+
+You can open all the SDF files for a given simulation by calling the `open_mfdataset`
+function from `sdf_xarray`. This will additionally add a time dimension using the `"time"`
+value stored in each files attributes.
+
+> [!IMPORTANT]
+> If your simulation has multiple `output` blocks so that not all variables are
+> output at every time step, then at the timesteps where those variables are not
+> present they will have have a value of nan. To clean your dataset by removing
+> these nan values we suggest using the `xarray.DataArray.dropna` function or
+> loading sparse data along separate time dimensions using `separate_times=True`.
+
+```python
+from sdf_xarray import open_mfdataset
+
+ds = open_mfdataset("*.sdf")
+print(ds)
+
+# Dimensions:
+# time: 301, X_Grid_mid: 128, ...
+# Coordinates: (9) ...
+# Data variables: (18) ...
+# Indexes: (9) ...
+# Attributes: (22) ...
+```
+
+## Citing
+
+If sdf-xarray contributes to a project that leads to publication, please acknowledge this by citing sdf-xarray. This can be done by clicking the "cite this repository" button located near the top right of this page.
+
+## Contributing
+
+We welcome contributions to the BEAM ecosystem! Whether it's reporting issues, suggesting features, or submitting pull requests, your input helps improve these tools for the community.
+
+### How to Contribute
+
+There are many ways to get involved:
+- **Report bugs**: Found something not working as expected? Open an issue with as much detail as possible.
+- **Request a feature**: Got an idea for a new feature or enhancement? Open a feature request on [GitHub Issues](https://github.com/epochpic/sdf-xarray/issues)!
+- **Improve the documentation**: We aim to keep our docs clear and helpful—if something's missing or unclear, feel free to suggest edits.
+- **Submit code changes**: Bug fixes, refactoring, or new features are welcome.
+
+
+All code is automatically linted, formatted, and tested via GitHub Actions.
+
+To run checks locally before opening a pull request, see [CONTRIBUTING.md](CONTRIBUTING.md) or [readthedocs documentation](https://sdf-xarray.readthedocs.io/en/latest/contributing.html)
+
+## Broad EPOCH Analysis Modules (BEAM)
+
+![BEAM logo](./BEAM.png)
+
+**BEAM** is a collection of independent yet complementary open-source tools for analysing EPOCH simulations, designed to be modular so researchers can adopt only the components they require without being constrained by a rigid framework. In line with the **FAIR principles — Findable**, **Accessible**, **Interoperable**, and **Reusable** — each package is openly published with clear documentation and versioning (Findable), distributed via public repositories (Accessible), designed to follow common standards for data structures and interfaces (Interoperable), and includes licensing and metadata to support long-term use and adaptation (Reusable). The packages are as follows:
+
+- [sdf-xarray](https://github.com/epochpic/sdf-xarray): Reading and processing SDF files and converting them to [xarray](https://docs.xarray.dev/en/stable/).
+- [epydeck](https://github.com/epochpic/epydeck): Input deck reader and writer.
+- [epyscan](https://github.com/epochpic/epyscan): Create campaigns over a given parameter space using various sampling methods.
+
+## PlasmaFAIR
+
+![PlasmaFAIR logo](PlasmaFAIR.svg)
+
+Originally developed by [PlasmaFAIR](https://plasmafair.github.io), EPSRC Grant EP/V051822/1

sdf_xarray-0.4.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+include/SDFC_14.4.7/sdf_derived.h,sha256=VqRsCmjmSRIOGqZSiPMsvmNaFBoNzXhrlKeyWGYIzm8,636
+include/SDFC_14.4.7/sdf_helper.h,sha256=UD291Xf8ZUeh34iv-qLN-u8f5vPQz0joTFxIQWUIVYA,1020
+include/SDFC_14.4.7/sdf_vector_type.h,sha256=5tcQcF7zDm7kTkLCzm12G5Z3ARVXvw7-XpKQ6WWej6U,1527
+include/SDFC_14.4.7/stack_allocator.h,sha256=dwR5vISInhS-qtN2HF3_8CVlnHJgWKMZxEn9RiMGjuM,1286
+include/SDFC_14.4.7/sdf_extension.h,sha256=my_ze10hSGfWEQEaUWh8TxFuVsiAl-g6aDn6qB2QQUY,1136
+include/SDFC_14.4.7/uthash.h,sha256=BN_4JfPHloW0kI3VRhvCqP8D2VcvD0HpSLgo4MBz6Sk,62067
+include/SDFC_14.4.7/sdf.h,sha256=8RWP2yH8xn_sCcbqZPT443LBaPy_3SHjOxA6IL4xLzE,24996
+include/SDFC_14.4.7/sdf_list_type.h,sha256=WEq5Qmtv00-A7lmLadxC7RbFy46yLYRgg0LynCGk4PE,1350
+lib/SDFC_14.4.7/libsdfc.a,sha256=B_y_GclgdE0xdSv7uUxlENCg1xoKQ_7O20UMdNwyi94,601592
+lib/SDFC_14.4.7/SDFCTargets-release.cmake,sha256=Xq-QJnH563tMRWlM5o2wdMSm9EiSKXru4U4hlR-eXlo,811
+lib/SDFC_14.4.7/SDFCTargets.cmake,sha256=clkZz74QIZf_Fi28OhBWw6bM4D2ljPzytSapo0xz2r0,4046
+lib/SDFC_14.4.7/SDFCConfig.cmake,sha256=QQOXXHTYSEzXXckN8CCi9vuhMmirf2MrOA8b3tY4m2A,784
+lib/SDFC_14.4.7/SDFCConfigVersion.cmake,sha256=2dR0eWIHiMKSdOwWBD9kI6EA-1mvVZsn61d50hSazkE,2765
+sdf_xarray/_version.py,sha256=l7h0kVANk_zkMPjiVLsVjseleQV1Jro7H3JphPhrob0,712
+sdf_xarray/plotting.py,sha256=HHLZISdFaiafTlRrTRshwT4FdRn5Z6VWIyU8vAwm_J0,9257
+sdf_xarray/download.py,sha256=5rY5TPXxTZr4B_0OQHgur2Knerg4OwSD4E5dboFAycg,3036
+sdf_xarray/dataset_accessor.py,sha256=ziVMAunCxSvIsJuETt8dSYAVXQkBSX8mOmipxvNFW0s,2379
+sdf_xarray/sdf_interface.pyx,sha256=6wnODbj5Gi4IinwL-EXTPfcxJGtN6Nm9BQ7R88xwkrs,11754
+sdf_xarray/__init__.py,sha256=vHfy048FKTbrgyyQJ1QN6hzgxfH42oUuwnlvX5JHON0,23584
+sdf_xarray/sdf_interface.cpython-314t-darwin.so,sha256=yjURK6RR0bfktkuUlQE8c3EOOjdeTNhrClTdtFVaBlg,419384
+sdf_xarray/csdf.pxd,sha256=6VCmPTbvKOQt3O-r1R1Gj-GvQJ2pOUeSRnkxgMLBvy0,4078
+sdf_xarray-0.4.0.dist-info/RECORD,,
+sdf_xarray-0.4.0.dist-info/WHEEL,sha256=FQvoGV7U_hR0JELuWQHk3LhwiQiBfE7EgRQx8v3hXSQ,142
+sdf_xarray-0.4.0.dist-info/entry_points.txt,sha256=gP7BIQpXNg6vIf7S7p-Rw_EJZTC1X50BsVTkK7dA7g0,57
+sdf_xarray-0.4.0.dist-info/METADATA,sha256=9EoUJ22i_txDaZAX6ZIgnaQdogVv88M-L2VFIZDHofQ,6921
+sdf_xarray-0.4.0.dist-info/licenses/LICENCE,sha256=0FfLVWQRQERtj0vUKjJk7-UrDp-t70Et9izWejGe4Os,1487

sdf_xarray-0.4.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp314-cp314t-macosx_11_0_arm64
+Generator: delocate 0.13.0
+

sdf_xarray-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[xarray.backends]
+sdf_engine = sdf_xarray:SDFEntrypoint
+

sdf_xarray-0.4.0.dist-info/licenses/LICENCE

@@ -0,0 +1,28 @@
+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.