xarray-binfile 0.1.0b0__py3-none-any.whl

xarray_binfile/__init__.py

@@ -0,0 +1,3 @@
+"""Blueprint for a quick start of a new Python project."""
+
+from xarray_binfile._version import __version__, __version_tuple__

xarray_binfile/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0b0'
+__version_tuple__ = version_tuple = (0, 1, 0, 'b0')

xarray_binfile/read/__init__.py

@@ -0,0 +1,2 @@
+from xarray_binfile.read.entrypoint import RawBinaryEntrypoint
+from xarray_binfile.read.file_metadata import ReadSpecs, ReadSpecsGetterProtocol

xarray_binfile/read/array.py

@@ -0,0 +1,165 @@
+"""
+Defines a backend array for reading binary files in Xarray.
+"""
+
+import numpy as np
+import xarray as xr
+from xarray.backends import BackendArray
+from xarray.core import indexing
+
+from xarray_binfile.read.file_metadata import ReadSpecs
+
+
+def _is_coord_sliced(size: int, slice_spec: slice) -> bool:
+    """
+    Check if a coordinate is sliced.
+    Args:
+        size: Size of the coordinate.
+        slice_spec: Slice specification.
+    Returns:
+        True if the coordinate is sliced, False otherwise.
+    """
+    return any(
+        (
+            (slice_spec.start or 0) != 0,
+            (slice_spec.stop or size) != size,
+            (slice_spec.step or 1) != 1,
+        ),
+    )
+
+
+class BinaryEngineBackendArray(BackendArray):
+    """
+    Backend array for reading binary files in Xarray.
+
+    Attributes:
+        metadata: Metadata describing the binary file.
+        dtype: Data type of the array.
+        shape: Shape of the array.
+    """
+
+    def __init__(self, metadata: ReadSpecs):
+        """
+        Initializes the backend array.
+
+        Args:
+            metadata: Metadata describing the binary file.
+        """
+        self.metadata = metadata
+
+        # Attributes required by BackendArray
+        self.dtype = self.metadata.dtype
+        self.shape = self.metadata.shape
+
+    def __getitem__(self, key: indexing.ExplicitIndexer) -> np.typing.ArrayLike:
+        """
+        Retrieves data from the array using explicit indexing.
+
+        Args:
+            key: Indexing key specifying the data to retrieve.
+
+        Returns:
+            The retrieved data.
+        """
+        return indexing.explicit_indexing_adapter(
+            key=key,
+            shape=self.metadata.shape,
+            indexing_support=indexing.IndexingSupport.VECTORIZED,
+            raw_indexing_method=self._raw_indexing_method,
+        )
+
+    def _raw_indexing_method(self, key: tuple[slice, ...]) -> np.typing.ArrayLike:
+        """
+        Performs raw indexing on the binary file.
+
+        Args:
+            key: Tuple of slices specifying the indices to read.
+
+        Returns:
+            The data read from the binary file.
+        """
+        with open(self.metadata.filepath, "rb") as file:
+            return self._read_binary_at_slices(file, key)
+
+    def _is_sliced(self, key: tuple[slice, ...]) -> bool:
+        """
+        Checks if the key is a slice of the original array.
+
+        Args:
+            key: Tuple of slices specifying the indices to check.
+
+        Returns:
+            True if the key is a slice, False otherwise.
+        """
+
+        return any(
+            _is_coord_sliced(s, k)
+            for k, s in zip(key, self.metadata.shape, strict=True)
+        )
+
+    def _wrap_numpy_fromfile(self, file) -> np.typing.NDArray:
+        """
+        Reads the entire binary file into a NumPy array.
+
+        Args:
+            file: The binary file to read.
+
+        Returns:
+            The data read from the file.
+        """
+        return np.fromfile(
+            file, dtype=self.metadata.dtype, count=np.prod(self.metadata.shape)
+        ).reshape(self.metadata.shape)
+
+    def _wrap_numpy_memmap(self, file, key: tuple[slice, ...]) -> np.typing.NDArray:
+        """
+        Reads a portion of the binary file using memory mapping.
+
+        Args:
+            file: The binary file to read.
+            key: Tuple of slices specifying the indices to read.
+
+        Returns:
+            The data read from the file.
+        """
+        memory_map = np.memmap(
+            file,
+            dtype=self.metadata.dtype,
+            mode="r",
+            shape=self.metadata.shape,
+            order="C",
+        )
+        return np.asarray(memory_map[key])  # ensure we actually read the data
+
+    def _read_binary_at_slices(self, file, key: tuple[slice, ...]) -> np.typing.NDArray:
+        """
+        Reads a binary file at specific locations based on the key tuple of slices.
+
+        Args:
+            file: The binary file to read.
+            key: Tuple of slices specifying the indices to read.
+
+        Returns:
+            The array data read from the file at the specified slices.
+        """
+        if self._is_sliced(key):
+            return self._wrap_numpy_memmap(file, key)
+        return self._wrap_numpy_fromfile(file)
+
+    def get_xarray_dataset(self) -> xr.Dataset:
+        """
+        Converts the backend array to an Xarray Dataset.
+
+        Returns:
+            The Xarray Dataset representation of the backend array.
+        """
+        return xr.Dataset(
+            data_vars={
+                self.metadata.name: (
+                    self.metadata.dims,
+                    indexing.LazilyIndexedArray(self),
+                )
+            },
+            coords=self.metadata.coords,
+            attrs=self.metadata.attrs,
+        )

xarray_binfile/read/entrypoint.py

@@ -0,0 +1,74 @@
+"""
+Backend for reading binary files in Xarray.
+
+References:
+    * https://docs.xarray.dev/en/latest/internals/how-to-add-new-backend.html
+    * https://github.com/pydata/xarray/discussions/6406
+"""
+
+import os
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from xarray import Dataset
+from xarray.backends import BackendEntrypoint
+
+from xarray_binfile.read.array import BinaryEngineBackendArray
+from xarray_binfile.read.file_metadata import ReadSpecsGetterProtocol
+
+
+class RawBinaryEntrypoint(BackendEntrypoint):
+    """
+    Backend entry point for reading binary files in Xarray.
+
+    Attributes:
+        open_dataset_parameters: Parameters accepted by the `open_dataset` method.
+        description: Description of the backend.
+        url: URL to the backend documentation.
+    """
+
+    open_dataset_parameters = ("filename_or_obj", "drop_variables, read_specs_getter")
+    description = "Read and write raw binary files using the familiar interface from the Xarray library."
+    url = "https://docs.fschuch.com/xarray-binfile/"
+
+    def open_dataset(  # type: ignore[override]
+        self,
+        filename_or_obj: str | os.PathLike[Any],
+        *,
+        read_specs_getter: ReadSpecsGetterProtocol,
+        drop_variables: str | Iterable[str] | None = None,
+    ) -> Dataset:
+        """
+        Open a dataset from a binary file.
+
+        Args:
+            filename_or_obj: Path to the binary file or a file-like object.
+            read_specs_getter: A callable that generates read specifications for the binary file.
+            drop_variables: Variables to drop from the dataset. Defaults to None.
+
+        Returns:
+            The opened Xarray dataset.
+
+        Raises:
+            ValueError: If `filename_or_obj` is not a valid file path.
+            ValueError: If there is an error reading the metadata from the file path.
+        """
+        try:
+            file_path = Path(filename_or_obj)
+        except TypeError as err:
+            error_message = f"Expected a file path or file-like object, but got: {filename_or_obj!r}"
+            raise ValueError(error_message) from err
+        try:
+            file_metadata = read_specs_getter(path=file_path)
+        except Exception as err:
+            error_message = f"Error reading metadata from {file_path}: {err}"
+            raise ValueError(error_message) from err
+        if (
+            isinstance(drop_variables, str) and file_metadata.name == drop_variables
+        ) or (
+            isinstance(drop_variables, Iterable)
+            and file_metadata.name in drop_variables
+        ):
+            return Dataset()
+        return BinaryEngineBackendArray(metadata=file_metadata).get_xarray_dataset()

xarray_binfile/read/file_metadata.py

@@ -0,0 +1,68 @@
+"""
+Defines metadata structures and protocols for reading binary files.
+"""
+
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Protocol
+
+from xarray_binfile.typing import AttributesLike, CoordsLike, DTypeLike
+
+
+@dataclass(frozen=True)
+class ReadSpecs:
+    """
+    Metadata for reading a binary file.
+
+    Attributes:
+        filepath: Path to the binary file.
+        dtype: Data type of the binary file.
+        coords: Coordinates of the data in the binary file.
+        name: Name of the dataset or variable.
+        attrs: Additional attributes for the dataset or variable.
+    """
+
+    filepath: Path
+    dtype: DTypeLike
+    coords: CoordsLike
+    name: str
+    attrs: AttributesLike | None = None
+
+    @cached_property
+    def shape(self) -> tuple[int, ...]:
+        """
+        Gets the shape of the data based on the coordinates.
+
+        Returns:
+            Shape of the data.
+        """
+        return tuple(len(i) for i in self.coords.values())
+
+    @cached_property
+    def dims(self) -> tuple[str, ...]:
+        """
+        Gets the dimension names of the data.
+
+        Returns:
+            Dimension names.
+        """
+        return tuple(self.coords.keys())
+
+
+class ReadSpecsGetterProtocol(Protocol):
+    """
+    Protocol for generating read specifications for a binary file.
+    """
+
+    def __call__(self, path: Path) -> ReadSpecs:
+        """
+        Generates read specifications for a binary file.
+
+        Args:
+            path: Path to the binary file.
+
+        Returns:
+            Metadata for reading the binary file.
+        """
+        ...

xarray_binfile/tutorial/__init__.py

@@ -0,0 +1,2 @@
+from xarray_binfile.tutorial.dataset_generator import DatasetGenerator
+from xarray_binfile.tutorial.file_metadata import FileSpecsGetter

xarray_binfile/tutorial/dataset_generator.py

@@ -0,0 +1,80 @@
+"""
+Provides a utility for generating xarray Datasets with random data.
+"""
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import xarray as xr
+
+from xarray_binfile.read.file_metadata import ReadSpecs, ReadSpecsGetterProtocol
+
+
+@dataclass(frozen=True)
+class DatasetGenerator:
+    """
+    Generates xarray Datasets with random data based on metadata.
+
+    Attributes:
+        read_specs_getter: A callable that generates read specifications for binary files.
+        random_generator: A random number generator for creating random data.
+    """
+
+    read_specs_getter: ReadSpecsGetterProtocol
+    random_generator = np.random.Generator(np.random.PCG64(1234))
+
+    def _get_numpy_array(self, metadata: ReadSpecs) -> np.ndarray:
+        """
+        Generates a random NumPy array based on metadata.
+
+        Args:
+            metadata: Metadata describing the array.
+
+        Returns:
+            A random NumPy array.
+        """
+        return self.random_generator.random(size=metadata.shape, dtype=metadata.dtype)
+
+    def _get_xarray_array(self, metadata: ReadSpecs) -> xr.DataArray:
+        """
+        Generates a random xarray DataArray based on metadata.
+
+        Args:
+            metadata: Metadata describing the array.
+
+        Returns:
+            A random xarray DataArray.
+        """
+        return xr.DataArray(
+            data=self._get_numpy_array(metadata),
+            coords=metadata.coords,
+            attrs=metadata.attrs,
+        )
+
+    def _get_dataset(self, metadata: ReadSpecs) -> xr.Dataset:
+        """
+        Generates a random xarray Dataset based on metadata.
+
+        Args:
+            metadata: Metadata describing the dataset.
+
+        Returns:
+            A random xarray Dataset.
+        """
+        return self._get_xarray_array(metadata).to_dataset(name=metadata.name)
+
+    def __call__(self, iter_filepath: Iterator[Path]) -> xr.Dataset:
+        """
+        Generates a merged xarray Dataset from multiple file paths.
+
+        Args:
+            iter_filepath: An iterator over file paths.
+
+        Returns:
+            A merged xarray Dataset.
+        """
+        metadata = map(self.read_specs_getter, iter_filepath)
+        datasets = map(self._get_dataset, metadata)
+        return xr.merge(datasets)

xarray_binfile/tutorial/file_metadata.py

@@ -0,0 +1,92 @@
+"""
+Defines utilities for generating file metadata for reading and writing binary files.
+"""
+
+import re
+from collections.abc import Iterator
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+
+import numpy as np
+from xarray import DataArray
+
+from xarray_binfile.read.file_metadata import ReadSpecs
+from xarray_binfile.typing import ArrayLike, DTypeLike
+from xarray_binfile.write.file_metadata import WriteSpecs
+
+
+@dataclass(frozen=True)
+class FileSpecsGetter:
+    """
+    Generates file metadata for reading and writing binary files.
+
+    Attributes:
+        base_coords: Base coordinates for the data.
+        dtype: Data type of the binary file. Defaults to np.float64.
+        filename_template: Template for generating filenames.
+        filename_regex: Regular expression for parsing filenames.
+    """
+
+    base_coords: dict[str, ArrayLike]
+    dtype: DTypeLike = np.float64
+    filename_template: str = "{name}-{digits:04}.bin"
+    filename_regex: re.Pattern = re.compile(r"(?P<name>\w+)-(?P<digits>\d{4})\.bin")
+
+    def reader(self, path: Path) -> ReadSpecs:
+        """
+        Generate read specifications for a binary file.
+
+        Args:
+            path: Path to the binary file.
+
+        Returns:
+            ReadSpecs: Metadata for reading the binary file.
+
+        Raises:
+            ValueError: If the filename does not match the expected pattern.
+        """
+        match = self.filename_regex.match(path.name)
+        if not match:
+            error_message = f"Invalid filename: {path.name}"
+            raise ValueError(error_message)
+
+        name, digits = match.groups()
+        time = np.array([int(digits)], dtype=np.int64)
+
+        return ReadSpecs(
+            filepath=path.resolve(),
+            dtype=self.dtype,
+            coords=self.base_coords | {"time": time},
+            name=name,
+        )
+
+    def writer(self, data_array: DataArray) -> Iterator[WriteSpecs]:
+        """
+        Generate write specifications for a DataArray.
+
+        Args:
+            data_array: The data array to generate write specifications for.
+
+        Returns:
+            An iterator over write specifications.
+        """
+        for time in data_array.coords["time"]:
+            yield WriteSpecs(
+                filename=self.filename_template.format(
+                    name=data_array.name, digits=int(time)
+                ),
+                sub_array=data_array.sel(time=time).transpose(
+                    *self._base_dims, missing_dims="raise"
+                ),
+            )
+
+    @cached_property
+    def _base_dims(self) -> tuple[str, ...]:
+        """
+        Get the base dimensions from the coordinates.
+
+        Returns:
+            A tuple of base dimension names.
+        """
+        return tuple(self.base_coords.keys())

xarray_binfile/typing.py

@@ -0,0 +1,12 @@
+"""Module for type hints used in the binary_engine_xarray package."""
+
+import typing
+
+import numpy.typing
+
+# TODO: Type aliases could look better on the docs https://github.com/sphinx-doc/sphinx/issues/10785#issuecomment-1897551241
+
+ArrayLike = numpy.typing.ArrayLike
+DTypeLike = numpy.typing.DTypeLike
+AttributesLike: typing.TypeAlias = typing.Mapping[typing.Any, typing.Any]
+CoordsLike: typing.TypeAlias = typing.Mapping[str, numpy.typing.ArrayLike]

xarray_binfile/write/__init__.py

@@ -0,0 +1,2 @@
+from xarray_binfile.write.accessor import BinaryEngineDataArray, BinaryEngineDataset
+from xarray_binfile.write.file_metadata import WriteSpecs, WriteSpecsGetterProtocol

xarray_binfile/write/accessor.py

@@ -0,0 +1,72 @@
+"""
+Provides accessors for writing xarray Dataset and DataArray objects to binary files.
+"""
+
+from pathlib import Path
+
+import xarray as xr
+
+from xarray_binfile.write.file_metadata import WriteSpecsGetterProtocol
+
+
+@xr.register_dataset_accessor("binary_engine")
+class BinaryEngineDataset:
+    """
+    An accessor with extra utilities for xarray.Dataset.
+    """
+
+    def __init__(self, data_set: xr.Dataset):
+        """
+        Initializes the BinaryEngineDataset accessor.
+
+        Args:
+            data_set: The dataset to attach the accessor to.
+        """
+        self._data_set = data_set
+
+    def to_file(
+        self,
+        write_specs_getter: WriteSpecsGetterProtocol,
+        directory: Path | None = None,
+    ) -> None:
+        """
+        Writes the dataset to binary files.
+
+        Args:
+            write_specs_getter: A callable that generates write specifications for the data arrays.
+            directory: The directory where the binary files will be written. Defaults to the current working directory.
+        """
+        for data_array in self._data_set.data_vars.values():
+            data_array.binary_engine.to_file(write_specs_getter, directory)
+
+
+@xr.register_dataarray_accessor("binary_engine")
+class BinaryEngineDataArray:
+    """
+    An accessor with extra utilities for xarray.DataArray.
+    """
+
+    def __init__(self, data_array: xr.DataArray):
+        """
+        Initializes the BinaryEngineDataArray accessor.
+
+        Args:
+            data_array: The data array to attach the accessor to.
+        """
+        self._data_array = data_array
+
+    def to_file(
+        self,
+        write_specs_getter: WriteSpecsGetterProtocol,
+        directory: Path | None = None,
+    ) -> None:
+        """
+        Writes the data array to binary files.
+
+        Args:
+            write_specs_getter: A callable that generates write specifications for the data array.
+            directory: The directory where the binary files will be written. Defaults to the current working directory.
+        """
+        _directory = directory or Path.cwd()
+        for details in write_specs_getter(self._data_array):
+            details.sub_array.to_numpy().tofile(_directory / details.filename)

xarray_binfile/write/file_metadata.py

@@ -0,0 +1,46 @@
+"""
+Defines metadata structures and protocols for writing binary files.
+"""
+
+from collections.abc import Iterator
+from typing import NamedTuple, Protocol
+
+import xarray as xr
+
+
+class WriteSpecs(NamedTuple):
+    """
+    Metadata for writing a portion of a DataArray to a binary file.
+
+    Attributes
+    ----------
+    filename : str
+        The name of the binary file.
+    sub_array : xr.DataArray
+        The portion of the DataArray to be written.
+    """
+
+    filename: str
+    sub_array: xr.DataArray
+
+
+class WriteSpecsGetterProtocol(Protocol):
+    """
+    Protocol for generating write specifications for a DataArray.
+    """
+
+    def __call__(self, data_array: xr.DataArray) -> Iterator[WriteSpecs]:
+        """
+        Generate write specifications for a DataArray.
+
+        Parameters
+        ----------
+        data_array : xr.DataArray
+            The data array for which to generate write specifications.
+
+        Returns
+        -------
+        Iterator[WriteSpecs]
+            An iterator over the write specifications.
+        """
+        ...

xarray_binfile-0.1.0b0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: xarray-binfile
+Version: 0.1.0b0
+Summary: Read and write raw binary files using the familiar interface from the Xarray library
+Project-URL: Source, https://github.com/fschuch/xarray-binfile
+Project-URL: Tracker, https://github.com/fschuch/xarray-binfile/issues
+Project-URL: Changelog, https://fschuch.github.io/xarray-binfile/references/what-is-new.html
+Project-URL: Documentation, https://fschuch.github.io/xarray-binfile/
+Author-email: fschuch <me@fschuch.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.10
+Requires-Dist: dask>=2024.0.0
+Requires-Dist: xarray>=2024.1.0
+Provides-Extra: docs
+Requires-Dist: docutils==0.21.2; extra == 'docs'
+Requires-Dist: jupyter-book==1.0.4.post1; extra == 'docs'
+Requires-Dist: sphinx-autobuild==2024.10.3; extra == 'docs'
+Requires-Dist: sphinx-github-changelog==1.7.1; extra == 'docs'
+Requires-Dist: sphinx==7.4.7; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: coverage[toml]>=7.5.3; extra == 'tests'
+Requires-Dist: hypothesis>=6.130.4; extra == 'tests'
+Requires-Dist: pre-commit>=3.5.0; extra == 'tests'
+Requires-Dist: pytest-benchmark>=5.1.0; extra == 'tests'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'tests'
+Requires-Dist: pytest-memray>=1.7.0; (sys_platform != 'win32') and extra == 'tests'
+Requires-Dist: pytest>=8.2.2; extra == 'tests'
+Provides-Extra: tests-extra
+Requires-Dist: pytest-randomly==3.16.0; extra == 'tests-extra'
+Requires-Dist: pytest-rerunfailures==15.1; extra == 'tests-extra'
+Requires-Dist: pytest-xdist==3.8.0; extra == 'tests-extra'
+Description-Content-Type: text/markdown
+
+# Xarray-binfile
+
+<p align="center">
+<a href="https://github.com/fschuch/xarray-binfile"><img src="https://raw.githubusercontent.com/fschuch/xarray-binfile/refs/heads/main/docs/logo.png" alt="Wizard template logo" width="320"></a>
+</p>
+<p align="center">
+    <em>Custom Xarray file engine to handle raw binary files</em>
+</p>
+
+______________________________________________________________________
+
+- QA:
+  [![CI](https://github.com/fschuch/xarray-binfile/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/fschuch/xarray-binfile/actions/workflows/ci.yaml)
+  [![CodeQL](https://github.com/fschuch/xarray-binfile/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/fschuch/xarray-binfile/actions/workflows/github-code-scanning/codeql)
+  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/fschuch/xarray-binfile/main.svg)](https://results.pre-commit.ci/latest/github/fschuch/xarray-binfile/main)
+  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=fschuch_xarray-binfile&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=fschuch_xarray-binfile)
+  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=fschuch_xarray-binfile&metric=coverage)](https://sonarcloud.io/summary/new_code?id=fschuch_xarray-binfile)
+  [![CodeFactor](https://www.codefactor.io/repository/github/fschuch/xarray-binfile/badge)](https://www.codefactor.io/repository/github/fschuch/xarray-binfile)
+
+<!-- - Docs:
+  [![Docs](https://github.com/fschuch/xarray-binfile/actions/workflows/docs.yaml/badge.svg?branch=main)](https://docs.fschuch.com/xarray-binfile) -->
+
+- Package:
+  [![PyPI - Version](https://img.shields.io/pypi/v/xarray-binfile.svg?logo=pypi&label=PyPI)](https://pypi.org/project/xarray-binfile/)
+  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/xarray-binfile.svg?logo=python&label=Python)](https://pypi.org/project/xarray-binfile/)
+
+- Meta:
+  [![Wizard Template](https://img.shields.io/badge/Wizard-Template-%23447CAA)](https://github.com/fschuch/wizard-template)
+  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+  [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
+  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+  ![GitHub License](https://img.shields.io/github/license/fschuch/xarray-binfile?color=blue)
+  [![EffVer Versioning](https://img.shields.io/badge/version_scheme-EffVer-0097a7)](https://jacobtomlinson.dev/effver)
+
+______________________________________________________________________
+
+## Overview
+
+Xarray-binfile is a Python package designed to extend the capabilities of Xarray, a powerful library for working with labeled multi-dimensional arrays. This package provides a custom file engine specifically for reading and writing raw binary files, enabling users to leverage Xarray's data structures while working with binary data formats.
+
+## Copyright and License
+
+© 2025 [Felipe N. Schuch](https://github.com/fschuch).
+All content is under [MIT License](https://github.com/fschuch/xarray-binfile/blob/main/LICENSE).

xarray_binfile-0.1.0b0.dist-info/RECORD

@@ -0,0 +1,19 @@
+xarray_binfile/__init__.py,sha256=8e2AniDmmZDP4ACal8BLZUQAZH3bdYigoyuwoMwU3-A,127
+xarray_binfile/_version.py,sha256=3IdK5-9L8GfdJbn5XMY6rBIueY27XuOo8ogyssGipNE,519
+xarray_binfile/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xarray_binfile/typing.py,sha256=OULN2kY8eJtkJRyT_D3HG_MH8sZ9JYTYpAdCJJ7s0ww,452
+xarray_binfile/read/__init__.py,sha256=Rmvab90D3K9OcJSp6jJUulSEcg_0QbKQaUUVWM20wqE,144
+xarray_binfile/read/array.py,sha256=kzEnu8Vq_YZ2Fv1GoHmTnt_vSqt-oehN7mzvqTKUYWo,4786
+xarray_binfile/read/entrypoint.py,sha256=KQ8fBr47hu4K-knTpLwd0iwurWvRM_YttoT2hzxbvKo,2717
+xarray_binfile/read/file_metadata.py,sha256=hs3pZT3f8sAs0rxxTh-bCHKPdZQS1aLTEYBDlaquXPc,1639
+xarray_binfile/tutorial/__init__.py,sha256=1XMAc-gELAxmiHBDaSX9cwnhRm3OEISvF-_vSviiBzM,137
+xarray_binfile/tutorial/dataset_generator.py,sha256=rTCi6_Kx80NgCYjyILgXe1pNJoTH7QbGhNVjMt7MLOM,2315
+xarray_binfile/tutorial/file_metadata.py,sha256=t6RpDsIdUdWg6-zk9EsnjYuinLyro3xR4oW2IFId0s8,2810
+xarray_binfile/write/__init__.py,sha256=zckfWb6NXP8OE7r38Iz2r3crr1_rL0OOM5kpQ-RmD-Q,169
+xarray_binfile/write/accessor.py,sha256=FTeXtpVB1698ga1uIm3ifeA3DwVbN3yQezxDipI5f5k,2212
+xarray_binfile/write/file_metadata.py,sha256=800GtnSDyUo_qEIuYPh5GHPaTtzVFhtnCJG3tck6YIg,1059
+xarray_binfile-0.1.0b0.dist-info/METADATA,sha256=MzDa1apSAJn_e_jQDfJWUNvzmXnpSBghPuNJMnIRqBU,5350
+xarray_binfile-0.1.0b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xarray_binfile-0.1.0b0.dist-info/entry_points.txt,sha256=SPu6_MRtBw578qcwsBcjsaQeW-P-sutg3HfHeKFzA0k,79
+xarray_binfile-0.1.0b0.dist-info/licenses/LICENSE,sha256=hsXQT5P2j7Kz8HdmUWgf7uiJ1FCY_EI-3Gxht-DVITU,1073
+xarray_binfile-0.1.0b0.dist-info/RECORD,,

xarray_binfile-0.1.0b0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

xarray_binfile-0.1.0b0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xarray.backends]
+binfile = xarray_binfile.read.entrypoint:RawBinaryEntrypoint

xarray_binfile-0.1.0b0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Felipe N. Schuch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.