def __init_subclass__(cls): """Initialize a subclass with a bound DataArray class.""" if not cls._name: return if cls._name not in cls._dataarrayclasses: register_dataarray_accessor(cls._name)(cls) cls._dataarrayclasses[cls._name].insert(0, cls._dataarrayclass)
def patch(name='hvplot', extension='bokeh', logo=False): from . import hvPlot, post_patch try: import xarray as xr except: raise ImportError('Could not patch plotting API onto xarray. ' 'xarray could not be imported.') xr.register_dataset_accessor(name)(hvPlot) xr.register_dataarray_accessor(name)(hvPlot) post_patch(extension, logo)
def _register_xarray_accessors_(dataarrays=None, datasets=None): """Silently register xarray accessors""" import xarray as xr with warnings.catch_warnings(): warnings.simplefilter( "ignore", xr.core.extensions.AccessorRegistrationWarning) if dataarrays: for name, cls in dataarrays.items(): xr.register_dataarray_accessor(name)(cls) if datasets: for name, cls in datasets.items(): xr.register_dataset_accessor(name)(cls)
def dataarray_method(func: Callable) -> Callable: """Decorator to make a DataArray function available as a method.""" class Accessor: def __init__(self, dataarray): self.dataarray = dataarray @wraps(func) def __call__(self, *args, **kwargs): return func(self.dataarray, *args, **kwargs) register_dataarray_accessor(func.__name__)(Accessor) return func
def patch(library, name='hvplot', extension=None, logo=False): """ Patch library to support HoloViews based plotting API. """ if not isinstance(library, list): library = [library] _patch_plot.__doc__ = hvPlot.__call__.__doc__ patch_property = property(_patch_plot) if 'streamz' in library: try: import streamz.dataframe as sdf except ImportError: raise ImportError('Could not patch plotting API onto streamz. ' 'Streamz could not be imported.') setattr(sdf.DataFrame, name, patch_property) setattr(sdf.DataFrames, name, patch_property) setattr(sdf.Series, name, patch_property) setattr(sdf.Seriess, name, patch_property) if 'pandas' in library: try: import pandas as pd except: raise ImportError('Could not patch plotting API onto pandas. ' 'Pandas could not be imported.') setattr(pd.DataFrame, name, patch_property) setattr(pd.Series, name, patch_property) if 'dask' in library: try: import dask.dataframe as dd except: raise ImportError('Could not patch plotting API onto dask. ' 'Dask could not be imported.') setattr(dd.DataFrame, name, patch_property) setattr(dd.Series, name, patch_property) if 'xarray' in library: try: import xarray as xr except: raise ImportError('Could not patch plotting API onto xarray. ' 'xarray could not be imported.') xr.register_dataset_accessor(name)(hvPlot) xr.register_dataarray_accessor(name)(hvPlot) if 'intake' in library: try: import intake except: raise ImportError('Could not patch plotting API onto intake. ' 'intake could not be imported.') setattr(intake.source.base.DataSource, name, patch_property) if extension and not getattr(_hv.extension, '_loaded', False): _hv.extension(extension, logo=logo)
def test_cf_dataarraycfaccessor(): with warnings.catch_warnings(): warnings.simplefilter("ignore", xr.core.extensions.AccessorRegistrationWarning) xr.register_dataarray_accessor('cf')(cf.DataArrayCFAccessor) lon = xr.DataArray(range(5), dims='xxx', name='xxx', attrs={'standard_name': 'longitude'}) temp = xr.DataArray(range(20, 25), dims='xxx', coords={'xxx': lon}, name='temp') assert temp.cf.lon.name == 'xxx' assert temp.cf.lat is None assert temp.cf.lon.cf.name == "lon"
class XMetadata: def __init__(self, xarray_obj): # self._obj = xarray_obj self._metadata = Annotation(None) class XDataset(XMetadata): def __init__(self, xarray_obj): super().__init__(xarray_obj) class XDataArray(XMetadata): def __init__(self, xarray_obj): super().__init__(xarray_obj) try: import xarray as xr xr.register_dataset_accessor("climetlab")(XDataset) xr.register_dataarray_accessor("climetlab")(XDataArray) except Exception: pass def init_metadata(): # Dummy function so climetlab.__init__ loads that file # and the xarray accessors are registered pass
da = self.dataArray for d in self.dataArray.dims: if d in coords: try: da = da.sel({d: coords[d]}) except (KeyError, IndexError): interp_coords[d] = coords[d] kwargs['bounds_error'] = bounds_error return da.interp(**interp_coords, method=method, kwargs=kwargs) class plot_xy_map(): def __init__(self, dataArray): self.dataArray = dataArray def __call__(self, **kwargs): if ('x' in self.dataArray.coords and 'y' in self.dataArray.coords and 'x' not in kwargs and self.dataArray.squeeze().shape == (len(np.atleast_1d(self.dataArray.x)), len(np.atleast_1d(self.dataArray.y)))): kwargs['x'] = 'x' _PlotMethods(self.dataArray)(**kwargs) if not hasattr(xr.DataArray(None), 'ilk'): xr.register_dataarray_accessor("ilk")(ilk) xr.register_dataarray_accessor("interp_all")(interp_all) xr.register_dataarray_accessor("sel_interp_all")(sel_interp_all) with warnings.catch_warnings(): warnings.simplefilter("ignore") xr.register_dataarray_accessor('plot')(plot_xy_map)
def register_xarray_dataarray_method(method: callable): accessor_wrapper = make_accessor_wrapper(method) register_dataarray_accessor(method.__name__)(accessor_wrapper) return method
def interp_pchip(self, dim, ix=100): return xr_interp_pchip(self._obj, dim=dim, ix=ix) @functools.wraps(xr_filter_wiener) def filter_wiener(self, dim, mysize=5, noise=1e-2): return xr_filter_wiener(self._obj, dim=dim, mysize=mysize, noise=noise) @functools.wraps(xr_filtfilt_butter) def filtfilt_butter(self, dim, N=2, Wn=0.4): return xr_filtfilt_butter(self._obj, dim=dim, N=N, Wn=Wn) @functools.wraps(xr_filtfilt_bessel) def filtfilt_bessel(self, dim, N=2, Wn=0.4): return xr_filtfilt_bessel(self._obj, dim=dim, N=N, Wn=Wn) @functools.wraps(xr_unispline) def unispline(self, dim, err=None, num_knots=11, ix=None): return xr_unispline(self._obj, dim=dim, err=err, num_knots=num_knots, ix=ix) @functools.wraps(xr_polyfit) def polyfit(self, dim, ix=None, deg=0.5, poly='chebyshev'): return xr_polyfit(self._obj, dim=dim, ix=ix, deg=deg, poly=poly) xr.register_dataarray_accessor('xyz')(XYZPY) xr.register_dataset_accessor('xyz')(XYZPY)
def __call__(self, dataArray2, **kwargs): interp_coords = { d: dataArray2[d] for d in self.dataArray.dims if d in dataArray2 } return self.dataArray.interp(**interp_coords, **kwargs) class sel_interp_all(): def __init__(self, dataArray): self.dataArray = dataArray def __call__(self, coords, method="linear", bounds_error=True, **kwargs): interp_coords = {} da = self.dataArray for d in self.dataArray.dims: if d in coords: try: da = da.sel({d: coords[d]}) except (KeyError, IndexError): interp_coords[d] = coords[d] kwargs['bounds_error'] = bounds_error return da.interp(**interp_coords, method=method, kwargs=kwargs) if not hasattr(xr.DataArray(), 'ilk'): xr.register_dataarray_accessor("ilk")(ilk) xr.register_dataarray_accessor("interp_all")(interp_all) xr.register_dataarray_accessor("sel_interp_all")(sel_interp_all)
def _register_xarray_helper(): # pylint: disable=import-outside-toplevel import xarray as xr from .xarray_helper import XArrayHelper xr.register_dataarray_accessor('rm')(XArrayHelper)
return xr_interp(self._obj, dim=dim, ix=ix, order=order) @functools.wraps(xr_interp_pchip) def interp_pchip(self, dim, ix=100): return xr_interp_pchip(self._obj, dim=dim, ix=ix) @functools.wraps(xr_filter_wiener) def filter_wiener(self, dim, mysize=5, noise=1e-2): return xr_filter_wiener(self._obj, dim=dim, mysize=mysize, noise=noise) @functools.wraps(xr_filtfilt_butter) def filtfilt_butter(self, dim, N=2, Wn=0.4): return xr_filtfilt_butter(self._obj, dim=dim, N=N, Wn=Wn) @functools.wraps(xr_filtfilt_bessel) def filtfilt_bessel(self, dim, N=2, Wn=0.4): return xr_filtfilt_bessel(self._obj, dim=dim, N=N, Wn=Wn) @functools.wraps(xr_unispline) def unispline(self, dim, err=None, num_knots=11, ix=None): return xr_unispline(self._obj, dim=dim, err=err, num_knots=num_knots, ix=ix) @functools.wraps(xr_polyfit) def polyfit(self, dim, ix=None, deg=0.5, poly='chebyshev'): return xr_polyfit(self._obj, dim=dim, ix=ix, deg=deg, poly=poly) xr.register_dataarray_accessor('xyz')(XYZPY) xr.register_dataset_accessor('xyz')(XYZPY)
def __init_subclass__(cls) -> None: """Initialize a subclass with a bound DataArray class.""" cls._dataarrayclass._accessor = cls cls._name = "_accessor_" + uuid4().hex[:16] register_dataarray_accessor(cls._name)(cls)