xarray Internals

xarray builds upon two of the foundational libraries of the scientific Python stack, NumPy and pandas. It is written in pure Python (no C or Cython extensions), which makes it easy to develop and extend. Instead, we push compiled code to optional dependencies.

Variable objects

The core internal data structure in xarray is the Variable, which is used as the basic building block behind xarray’s Dataset and DataArray types. A Variable consists of:

  • dims: A tuple of dimension names.
  • data: The N-dimensional array (typically, a NumPy or Dask array) storing the Variable’s data. It must have the same number of dimensions as the length of dims.
  • attrs: An ordered dictionary of metadata associated with this array. By convention, xarray’s built-in operations never use this metadata.
  • encoding: Another ordered dictionary used to store information about how these variable’s data is represented on disk. See Reading encoded data for more details.

Variable has an interface similar to NumPy arrays, but extended to make use of named dimensions. For example, it uses dim in preference to an axis argument for methods like mean, and supports Broadcasting by dimension name.

However, unlike Dataset and DataArray, the basic Variable does not include coordinate labels along each axis.

Variable is public API, but because of its incomplete support for labeled data, it is mostly intended for advanced uses, such as in xarray itself or for writing new backends. You can access the variable objects that correspond to xarray objects via the (readonly) Dataset.variables and DataArray.variable attributes.

Extending xarray

xarray is designed as a general purpose library, and hence tries to avoid including overly domain specific functionality. But inevitably, the need for more domain specific logic arises.

One standard solution to this problem is to subclass Dataset and/or DataArray to add domain specific functionality. However, inheritance is not very robust. It’s easy to inadvertently use internal APIs when subclassing, which means that your code may break when xarray upgrades. Furthermore, many builtin methods will only return native xarray objects.

The standard advice is to use composition over inheritance, but reimplementing an API as large as xarray’s on your own objects can be an onerous task, even if most methods are only forwarding to xarray implementations.

If you simply want the ability to call a function with the syntax of a method call, then the builtin pipe() method (copied from pandas) may suffice.

To resolve this issue for more complex cases, xarray has the register_dataset_accessor() and register_dataarray_accessor() decorators for adding custom “accessors” on xarray objects. Here’s how you might use these decorators to write a custom “geo” accessor implementing a geography specific extension to xarray:

import xarray as xr

class GeoAccessor(object):
    def __init__(self, xarray_obj):
        self._obj = xarray_obj
        self._center = None

    def center(self):
        """Return the geographic center point of this dataset."""
        if self._center is None:
            # we can use a cache on our accessor objects, because accessors
            # themselves are cached on instances that access them.
            lon = self._obj.latitude
            lat = self._obj.longitude
            self._center = (float(lon.mean()), float(lat.mean()))
        return self._center

    def plot(self):
        """Plot data on a map."""
        return 'plotting!'

This achieves the same result as if the Dataset class had a cached property defined that returns an instance of your class:

class Dataset:
    def geo(self)
        return GeoAccessor(self)

However, using the register accessor decorators is preferable to simply adding your own ad-hoc property (i.e., Dataset.geo = property(...)), for several reasons:

  1. It ensures that the name of your property does not accidentally conflict with any other attributes or methods (including other accessors).
  2. Instances of accessor object will be cached on the xarray object that creates them. This means you can save state on them (e.g., to cache computed properties).
  3. Using an accessor provides an implicit namespace for your custom functionality that clearly identifies it as separate from built-in xarray methods.

Back in an interactive IPython session, we can use these properties:

In [1]: ds = xr.Dataset({'longitude': np.linspace(0, 10),
   ...:                  'latitude': np.linspace(0, 20)})

In [2]: ds.geo.center
Out[2]: (10.0, 5.0)

In [3]: ds.geo.plot()
Out[3]: 'plotting!'

The intent here is that libraries that extend xarray could add such an accessor to implement subclass specific functionality rather than using actual subclasses or patching in a large number of domain specific methods. For further reading on ways to write new accessors and the philosophy behind the approach, see GH1080.

To help users keep things straight, please let us know if you plan to write a new accessor for an open source library. In the future, we will maintain a list of accessors and the libraries that implement them on this page.

Here are several existing libraries that build functionality upon xarray. They may be useful points of reference for your work:

  • xgcm: General Circulation Model Postprocessing. Uses subclassing and custom xarray backends.
  • PyGDX: Python 3 package for accessing data stored in GAMS Data eXchange (GDX) files. Also uses a custom subclass.
  • windspharm: Spherical harmonic wind analysis in Python.
  • eofs: EOF analysis in Python.
  • salem: Adds geolocalised subsetting, masking, and plotting operations to xarray’s data structures via accessors.