Apart for the doc typo I mentioned, this looks very good, thanks!

This looks good to me. Anyone else have any final comments?

Finally got around to updating this.

I added caching of these properties per @fmaussion's suggestion. Caching is a little error prone (I wrote a custom descriptor), but I think test cases should cover it pretty well.

:+1: nice one

@fmaussion that's still helpful, thanks.

For cases where you want to do custom initialization, the suggestion (which I should add) is to simply write your own function to use in place of xarray.open_dataset.

Now that I think of it, it should also be possible to use some other in logic in __init__()—or even as a kludge store something like xarray_obj.attrs['_geoaccessor_state']—to determine whether the object is already, or needs to be, "initialized" (whatever that happens to mean for each accessor).

For instance, if the accessor creates and uses certain variables in a Dataset, it could check for their presence, and skip any initialization code if they already exist.

Thanks for the clarification. Would it make sense to make a @lazy_property out of it in oder to avoid multiple builds?

Just to be clear—xarray_obj is passed to the init() method of an accessor. Will this happen before, or after Dataset.init()/DataArray.init() is invoked?

This will happen after Dataset.init/DataArray.init. For cases where you want to do custom initialization, the suggestion (which I should add) is to simply write your own function to use in place of xarray.open_dataset.

It's probably worth noting in the documentation that this is equivalent to just adding a property, e.g.,

python class Dataset: ... @property def geo(self) return GeoAccessor(self)

Oh, I realize that this doesn't answer your question though :flushed:

Yes, this looks very good, thanks!

@khaeru : I had the same question and just tested it:

``` python import xarray as xr import numpy as np

@xr.register_dataset_accessor('geo') class GeoAccessor(object): def init(self, xarray_obj): print('In constructor') self._obj = xarray_obj

@property
def center(self):
    # return the geographic center point of this dataset
    lon = self._obj.latitude
    lat = self._obj.longitude
    return (float(lon.mean()), float(lat.mean()))

def plot(self):
    print('plot data on a map')  # e.g., using Cartopy

Nothing is printed

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

out: In constructor

out = ds.geo.center

out: In constructor

plot data on a map

ds.geo.plot() ```

So the constructor is called only if the property is accessed, which is good. the drawback is that a new object is instantiated at each access.

Of the two different projects I'm working (sporadically) on that both subclass Dataset, it seems like one (pyGDX) should more properly be a backend, while the other could work as an accessor. This code looks good!

Just to be clear—xarray_obj is passed to the __init__() method of an accessor. Will this happen before, or after Dataset.__init__()/DataArray.__init__() is invoked?

:+1: Very nice.

:+1: very cool