pycontrails 0.54.4__cp310-cp310-win_amd64.whl → 0.54.5__cp310-cp310-win_amd64.whl

pycontrails/core/vector.py

@@ -37,6 +37,8 @@ logger = logging.getLogger(__name__)
 class AttrDict(dict[str, Any]):
     """Thin wrapper around dict to warn when setting a key that already exists."""
 
+    __slots__ = ()
+
     def __setitem__(self, k: str, v: Any) -> None:
         """Warn when setting values that already contain values.
 
@@ -85,7 +87,7 @@ class VectorDataDict(dict[str, np.ndarray]):
     Parameters
     ----------
     data : dict[str, np.ndarray], optional
-        Dictionary input
+        Dictionary input. A shallow copy is always made.
     """
 
     __slots__ = ("_size",)
@@ -130,8 +132,8 @@ class VectorDataDict(dict[str, np.ndarray]):
     def __delitem__(self, k: str) -> None:
         super().__delitem__(k)
 
-        # if not data keys left, set size to 0
-        if not len(self):
+        # if no keys remain, delete _size attribute
+        if not self:
             del self._size
 
     def setdefault(self, k: str, default: npt.ArrayLike | None = None) -> np.ndarray:
@@ -191,9 +193,9 @@ class VectorDataDict(dict[str, np.ndarray]):
         super().update(kwargs_arr)
 
     def _validate_array(self, arr: np.ndarray) -> None:
-        """Ensure that `arr` is compatible with instance.
+        """Ensure that ``arr`` is compatible (1 dimensional of equal size) with instance.
 
-        Set attribute `_size` if it has not yet been defined.
+        Set attribute ``_size`` if it has not yet been defined.
 
         Parameters
         ----------
@@ -203,34 +205,34 @@ class VectorDataDict(dict[str, np.ndarray]):
         Raises
         ------
         ValueError
-            If `arr` is not compatible with instance.
+            If ``arr`` is not compatible with instance.
         """
         if arr.ndim != 1:
             raise ValueError("All np.arrays must have dimension 1.")
 
         size = getattr(self, "_size", 0)
-        if size != 0:
-            if arr.size != size:
-                raise ValueError(f"Incompatible array sizes: {arr.size} and {size}.")
-        else:
+        if not size:
             self._size = arr.size
+            return
+
+        if arr.size != size:
+            raise ValueError(f"Incompatible array sizes: {arr.size} and {size}.")
 
 
-def _empty_vector_dict(keys: Iterable[str]) -> VectorDataDict:
-    """Create instance of VectorDataDict with variables defined by `keys` and size 0.
+def _empty_vector_dict(keys: Iterable[str]) -> dict[str, np.ndarray]:
+    """Create a dictionary with keys defined by ``keys`` and empty arrays.
 
     Parameters
     ----------
     keys : Iterable[str]
-        Keys to include in empty VectorDataset instance.
+        Keys to include in dictionary.
 
     Returns
     -------
-    VectorDataDict
-        Empty :class:`VectorDataDict` instance.
+    dict[str, np.ndarray]
+        Dictionary with empty arrays.
     """
-    keys = keys or ()
-    data = VectorDataDict({key: np.array([]) for key in keys})
+    data = {key: np.array([]) for key in keys}
 
     # The default dtype is float64
     # Time is special and should have a non-default dtype of datetime64[ns]
@@ -245,14 +247,15 @@ class VectorDataset:
 
     Parameters
     ----------
-    data : dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataDict | VectorDataset | None, optional
-        Initial data, by default None
-    attrs : dict[str, Any] | AttrDict, optional
-        Dictionary of attributes, by default None
+    data : dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataset | None, optional
+        Initial data, by default None. A shallow copy is always made. Use the ``copy``
+        parameter to copy the underlying array data.
+    attrs : dict[str, Any] | None, optional
+        Dictionary of attributes, by default None. A shallow copy is always made.
     copy : bool, optional
-        Copy data on class creation, by default True
+        Copy individual arrays on instantiation, by default True.
     **attrs_kwargs : Any
-        Additional attributes passed as keyword arguments
+        Additional attributes passed as keyword arguments.
 
     Raises
     ------
@@ -262,24 +265,22 @@ class VectorDataset:
 
     __slots__ = ("attrs", "data")
 
-    #: Vector data with labels as keys and :class:`numpy.ndarray` as values
-    data: VectorDataDict
-
     #: Generic dataset attributes
     attrs: AttrDict
 
+    #: Vector data with labels as keys and :class:`numpy.ndarray` as values
+    data: VectorDataDict
+
     def __init__(
         self,
-        data: (
-            dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataDict | VectorDataset | None
-        ) = None,
+        data: dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataset | None = None,
         *,
-        attrs: dict[str, Any] | AttrDict | None = None,
+        attrs: dict[str, Any] | None = None,
         copy: bool = True,
         **attrs_kwargs: Any,
     ) -> None:
-        # Set data
-        # --------
+        # Set data: always shallow copy
+        # -----------------------------
 
         # Casting from one VectorDataset type to another
         # e.g., flight = Flight(...); vector = VectorDataset(flight)
@@ -288,7 +289,7 @@ class VectorDataset:
             if copy:
                 self.data = VectorDataDict({k: v.copy() for k, v in data.data.items()})
             else:
-                self.data = data.data
+                self.data = VectorDataDict(data.data)
 
         elif data is None:
             self.data = VectorDataDict()
@@ -307,31 +308,45 @@ class VectorDataset:
                 data["time"] = time.to_numpy(copy=copy)
                 self.data = VectorDataDict(data)
 
-        elif isinstance(data, VectorDataDict):
-            if copy:
-                self.data = VectorDataDict({k: v.copy() for k, v in data.items()})
-            else:
-                self.data = data
-
         # For anything else, we assume it is a dictionary of array-like and attach it
         else:
             self.data = VectorDataDict({k: np.array(v, copy=copy) for k, v in data.items()})
 
-        # Set attributes
-        # --------------
+        # Set attributes: always shallow copy
+        # -----------------------------------
+
+        self.attrs = AttrDict(attrs or {})  # type: ignore[arg-type]
+        self.attrs.update(attrs_kwargs)
+
+    @classmethod
+    def _from_fastpath(
+        cls,
+        data: dict[str, np.ndarray],
+        attrs: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Self:
+        """Create new instance from consistent data.
 
-        if attrs is None:
-            self.attrs = AttrDict()
+        This is a low-level method that bypasses the standard constructor in certain
+        special cases. It is intended for internal use only.
 
-        elif isinstance(attrs, AttrDict) and not copy:
-            self.attrs = attrs
+        In essence, this method skips any validation from __init__ and directly sets
+        ``data`` and ``attrs``. This is useful when creating a new instance from an existing
+        instance the data has already been validated.
+        """
+        obj = cls.__new__(cls)
 
-        #  shallow copy if dict
-        else:
-            self.attrs = AttrDict(attrs.copy())
+        obj.data = VectorDataDict(data)
+        obj.attrs = AttrDict(attrs or {})
 
-        # update with kwargs
-        self.attrs.update(attrs_kwargs)
+        for key, value in kwargs.items():
+            try:
+                setattr(obj, key, value)
+            # If key not present in __slots__ of class (or parents), it's intended for attrs
+            except AttributeError:
+                obj.attrs[key] = value
+
+        return obj
 
     # ------------
     # dict-like methods
@@ -663,6 +678,13 @@ class VectorDataset:
         8  15  18
 
         """
+        if cls not in (VectorDataset, GeoVectorDataset):
+            msg = (
+                "Method 'sum' is only available on 'VectorDataset' and 'GeoVectorDataset'. "
+                "To sum 'Flight' instances, use 'Fleet.from_seq'."
+            )
+            raise TypeError(msg)
+
         vectors = [v for v in vectors if v is not None]  # remove None values
 
         if not vectors:
@@ -693,10 +715,9 @@ class VectorDataset:
             return np.concatenate(values)
 
         data = {key: concat(key) for key in keys}
+        attrs = vectors[0].attrs if infer_attrs else None
 
-        if infer_attrs:
-            return cls(data, attrs=vectors[0].attrs, copy=False)
-        return cls(data, copy=False)
+        return cls._from_fastpath(data, attrs)
 
     def __eq__(self, other: object) -> bool:
         """Determine if two instances are equal.
@@ -803,7 +824,8 @@ class VectorDataset:
         Self
             Copy of class
         """
-        return type(self)(data=self.data, attrs=self.attrs, copy=True, **kwargs)
+        data = {key: value.copy() for key, value in self.data.items()}
+        return type(self)._from_fastpath(data, self.attrs, **kwargs)
 
     def select(self: VectorDataset, keys: Iterable[str], copy: bool = True) -> VectorDataset:
         """Return new class instance only containing specified keys.
@@ -823,8 +845,8 @@ class VectorDataset:
             Note that this method always returns a :class:`VectorDataset`, even if
             the calling class is a proper subclass of :class:`VectorDataset`.
         """
-        data = {key: self[key] for key in keys}
-        return VectorDataset(data=data, attrs=self.attrs, copy=copy)
+        data = {key: np.array(self[key], copy=copy) for key in keys}
+        return VectorDataset._from_fastpath(data, self.attrs)
 
     def filter(self, mask: npt.NDArray[np.bool_], copy: bool = True, **kwargs: Any) -> Self:
         """Filter :attr:`data` according to a boolean array ``mask``.
@@ -856,8 +878,8 @@ class VectorDataset:
         if mask.dtype != bool:
             raise TypeError("Parameter `mask` must be a boolean array.")
 
-        data = {key: value[mask] for key, value in self.data.items()}
-        return type(self)(data=data, attrs=self.attrs, copy=copy, **kwargs)
+        data = {key: np.array(value[mask], copy=copy) for key, value in self.data.items()}
+        return type(self)._from_fastpath(data, self.attrs, **kwargs)
 
     def sort(self, by: str | list[str]) -> Self:
         """Sort data by key(s).
@@ -1116,7 +1138,7 @@ class VectorDataset:
         cls,
         keys: Iterable[str],
         attrs: dict[str, Any] | None = None,
-        **attrs_kwargs: Any,
+        **kwargs: Any,
     ) -> Self:
         """Create instance with variables defined by ``keys`` and size 0.
 
@@ -1129,15 +1151,16 @@ class VectorDataset:
             Keys to include in empty VectorDataset instance.
         attrs : dict[str, Any] | None, optional
             Attributes to attach instance.
-        **attrs_kwargs : Any
-            Define attributes as keyword arguments.
+        **kwargs : Any
+            Additional keyword arguments passed into the constructor of the returned class.
 
         Returns
         -------
         Self
             Empty VectorDataset instance.
         """
-        return cls(data=_empty_vector_dict(keys or set()), attrs=attrs, copy=False, **attrs_kwargs)
+        data = _empty_vector_dict(keys)
+        return cls._from_fastpath(data, attrs, **kwargs)
 
     @classmethod
     def from_dict(cls, obj: dict[str, Any], copy: bool = True, **obj_kwargs: Any) -> Self:
@@ -1216,7 +1239,7 @@ class GeoVectorDataset(VectorDataset):
 
     Parameters
     ----------
-    data : dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataDict | VectorDataset | None, optional
+    data : dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataset | None, optional
         Data dictionary or :class:`pandas.DataFrame` .
         Must include keys/columns ``time``, ``latitude``, ``longitude``, ``altitude`` or ``level``.
         Keyword arguments for ``time``, ``latitude``, ``longitude``, ``altitude`` or ``level``
@@ -1269,9 +1292,7 @@ class GeoVectorDataset(VectorDataset):
 
     def __init__(
         self,
-        data: (
-            dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataDict | VectorDataset | None
-        ) = None,
+        data: dict[str, npt.ArrayLike] | pd.DataFrame | VectorDataset | None = None,
         *,
         longitude: npt.ArrayLike | None = None,
         latitude: npt.ArrayLike | None = None,
@@ -1279,7 +1300,7 @@ class GeoVectorDataset(VectorDataset):
         altitude_ft: npt.ArrayLike | None = None,
         level: npt.ArrayLike | None = None,
         time: npt.ArrayLike | None = None,
-        attrs: dict[str, Any] | AttrDict | None = None,
+        attrs: dict[str, Any] | None = None,
         copy: bool = True,
         **attrs_kwargs: Any,
     ) -> None:
@@ -1293,7 +1314,10 @@ class GeoVectorDataset(VectorDataset):
             and time is None
         ):
             keys = *self.required_keys, "altitude"
-            data = _empty_vector_dict(keys)
+            self.data = VectorDataDict(_empty_vector_dict(keys))
+            self.attrs = AttrDict(attrs or {})  # type: ignore[arg-type]
+            self.attrs.update(attrs_kwargs)
+            return
 
         super().__init__(data=data, attrs=attrs, copy=copy, **attrs_kwargs)
 
@@ -1819,7 +1843,6 @@ class GeoVectorDataset(VectorDataset):
         latitude_buffer: tuple[float, float] = ...,
         level_buffer: tuple[float, float] = ...,
         time_buffer: tuple[np.timedelta64, np.timedelta64] = ...,
-        copy: bool = ...,
     ) -> met_module.MetDataset: ...
 
     @overload
@@ -1831,7 +1854,6 @@ class GeoVectorDataset(VectorDataset):
         latitude_buffer: tuple[float, float] = ...,
         level_buffer: tuple[float, float] = ...,
         time_buffer: tuple[np.timedelta64, np.timedelta64] = ...,
-        copy: bool = ...,
     ) -> met_module.MetDataArray: ...
 
     def downselect_met(
@@ -1845,10 +1867,13 @@ class GeoVectorDataset(VectorDataset):
             np.timedelta64(0, "h"),
             np.timedelta64(0, "h"),
         ),
-        copy: bool = True,
     ) -> met_module.MetDataType:
         """Downselect ``met`` to encompass a spatiotemporal region of the data.
 
+        .. versionchanged:: 0.54.5
+
+            Returned object is no longer copied.
+
         Parameters
         ----------
         met : MetDataset | MetDataArray
@@ -1873,8 +1898,6 @@ class GeoVectorDataset(VectorDataset):
             and ``time_buffer[1]`` on the high side.
             Units must be the same as class coordinates.
             Defaults to ``(np.timedelta64(0, "h"), np.timedelta64(0, "h"))``.
-        copy : bool
-            If returned object is a copy or view of the original. True by default.
 
         Returns
         -------
@@ -1915,7 +1938,7 @@ class GeoVectorDataset(VectorDataset):
             level=level_slice,
             time=time_slice,
         )
-        return type(met)(data, copy=copy)
+        return type(met)._from_fastpath(data)
 
     # ------------
     # I / O

pycontrails/models/apcemm/apcemm.py

@@ -474,7 +474,7 @@ class APCEMM(models.Model):
             for coord in ("longitude", "latitude", "level")
         }
         buffers["time_buffer"] = (0, self.params["max_age"] + self.params["dt_lagrangian"])
-        met = self.source.downselect_met(self.met, **buffers, copy=False)
+        met = self.source.downselect_met(self.met, **buffers)
         model = DryAdvection(
             met=met,
             dt_integration=self.params["dt_lagrangian"],
@@ -816,7 +816,7 @@ class APCEMM(models.Model):
         # Ensure required met data is present.
         # No buffers needed for interpolation!
         vars = ap_model.met_variables + ap_model.optional_met_variables + emissions.met_variables
-        met = self.source.downselect_met(self.met, copy=False)
+        met = self.source.downselect_met(self.met)
         met.ensure_vars(vars)
         met.standardize_variables(vars)
         for var in vars:

pycontrails/models/apcemm/utils.py

@@ -214,7 +214,7 @@ def generate_apcemm_input_met(
     )
 
     # Downselect met before interpolation
-    met = vector.downselect_met(met, copy=False)
+    met = vector.downselect_met(met)
 
     # Interpolate meteorology data onto vector
     scale_humidity = humidity_scaling is not None and "specific_humidity" not in vector

pycontrails/models/cocip/cocip.py

@@ -391,7 +391,7 @@ class Cocip(Model):
         # which is the positive direction for level
         logger.debug("Downselect met for Cocip initialization")
         level_buffer = 0, self.params["met_level_buffer"][1]
-        met = self.source.downselect_met(self.met, level_buffer=level_buffer, copy=False)
+        met = self.source.downselect_met(self.met, level_buffer=level_buffer)
         met = add_tau_cirrus(met)
 
         # Prepare flight for model
@@ -976,9 +976,9 @@ class Cocip(Model):
             for coord in ("longitude", "latitude", "level")
         }
         logger.debug("Downselect met for start of Cocip evolution")
-        met = self._downwash_contrail.downselect_met(self.met, **buffers, copy=False)
+        met = self._downwash_contrail.downselect_met(self.met, **buffers)
         met = add_tau_cirrus(met)
-        rad = self._downwash_contrail.downselect_met(self.rad, **buffers, copy=False)
+        rad = self._downwash_contrail.downselect_met(self.rad, **buffers)
 
         calc_continuous(self._downwash_contrail)
         calc_timestep_geometry(self._downwash_contrail)
@@ -1135,11 +1135,11 @@ class Cocip(Model):
             & (self._downwash_flight["time"] <= lookahead),
             copy=False,
         )
-        vector = GeoVectorDataset(
+        vector = GeoVectorDataset._from_fastpath(
             {
                 key: np.concatenate((latest_contrail[key], future_contrails[key]))
                 for key in ("longitude", "latitude", "level", "time")
-            }
+            },
         )
 
         # compute time buffer to ensure downselection extends to time_end
@@ -1152,7 +1152,7 @@ class Cocip(Model):
             max(np.timedelta64(0, "ns"), time_end - vector["time"].max()),
         )
 
-        return vector.downselect_met(met, **buffers, copy=False)
+        return vector.downselect_met(met, **buffers)
 
     def _create_downwash_contrail(self) -> GeoVectorDataset:
         """Get Contrail representation of downwash flight."""
@@ -1180,7 +1180,7 @@ class Cocip(Model):
             "persistent": self._downwash_flight["persistent_1"],
         }
 
-        contrail = GeoVectorDataset(downwash_contrail_data, copy=True)
+        contrail = GeoVectorDataset._from_fastpath(downwash_contrail_data).copy()
         contrail["formation_time"] = contrail["time"].copy()
         contrail["age"] = contrail["formation_time"] - contrail["time"]
 
@@ -2300,7 +2300,7 @@ def calc_timestep_contrail_evolution(
     level_2 = geo.advect_level(level_1, vertical_velocity_1, rho_air_1, terminal_fall_speed_1, dt)
     altitude_2 = units.pl_to_m(level_2)
 
-    contrail_2 = GeoVectorDataset(
+    contrail_2 = GeoVectorDataset._from_fastpath(
         {
             "waypoint": waypoint_2,
             "flight_id": contrail_1["flight_id"],
@@ -2312,7 +2312,6 @@ def calc_timestep_contrail_evolution(
             "altitude": altitude_2,
             "level": level_2,
         },
-        copy=False,
     )
     intersection = contrail_2.coords_intersect_met(met)
     if not np.any(intersection):

pycontrails/models/cocipgrid/cocip_grid.py

@@ -11,11 +11,10 @@ from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, overload
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
-import xarray as xr
 
 import pycontrails
 from pycontrails.core import models
-from pycontrails.core.met import MetDataset
+from pycontrails.core.met import MetDataset, maybe_downselect_mds
 from pycontrails.core.vector import GeoVectorDataset, VectorDataset
 from pycontrails.models import humidity_scaling, sac
 from pycontrails.models.cocip import cocip, contrail_properties, wake_vortex, wind_shear
@@ -323,8 +322,8 @@ class CocipGrid(models.Model):
         If ``self.params["downselect_met"]`` is True, the :func:`_downselect_met` has
         already performed a spatial downselection of the met data.
         """
-        met = _maybe_downselect_mds(self.met, met, t0, t1)
-        rad = _maybe_downselect_mds(self.rad, rad, t0, t1)
+        met = maybe_downselect_mds(self.met, met, t0, t1)
+        rad = maybe_downselect_mds(self.rad, rad, t0, t1)
 
         return met, rad
 
@@ -615,7 +614,7 @@ class CocipGrid(models.Model):
             for idx, time in enumerate(times_in_filt):
                 # For now, sticking with the convention that every vector should
                 # have a constant time value.
-                source_slice = MetDataset(self.source.data.sel(time=[time]))
+                source_slice = MetDataset._from_fastpath(self.source.data.sel(time=[time]))
 
                 # Convert the 4D grid to a vector
                 vector = source_slice.to_vector()
@@ -1402,7 +1401,7 @@ def simulate_wake_vortex_downwash(
 
     # Experimental segment-free model
     if _is_segment_free_mode(vector):
-        return GeoVectorDataset(data, attrs=vector.attrs, copy=True)
+        return GeoVectorDataset._from_fastpath(data, attrs=vector.attrs).copy()
 
     # Stored in `_generate_new_grid_vectors`
     data["longitude_head"] = vector["longitude_head"]
@@ -1421,7 +1420,7 @@ def simulate_wake_vortex_downwash(
         # segment_length variable.
         data["segment_length"] = np.full_like(data["longitude"], segment_length)
 
-    return GeoVectorDataset(data, attrs=vector.attrs, copy=True)
+    return GeoVectorDataset._from_fastpath(data, attrs=vector.attrs).copy()
 
 
 def find_initial_persistent_contrails(
@@ -2022,7 +2021,7 @@ def advect(
         assert _is_segment_free_mode(contrail)
         assert dt_tail is None
         assert dt_head is None
-        return GeoVectorDataset(data, attrs=contrail.attrs, copy=True)
+        return GeoVectorDataset._from_fastpath(data, attrs=contrail.attrs).copy()
 
     longitude_head = contrail["longitude_head"]
     latitude_head = contrail["latitude_head"]
@@ -2064,7 +2063,7 @@ def advect(
     data["segment_length"] = segment_length_t2
     data["head_tail_dt"] = head_tail_dt_t2
 
-    return GeoVectorDataset(data, attrs=contrail.attrs, copy=True)
+    return GeoVectorDataset._from_fastpath(data, attrs=contrail.attrs).copy()
 
 
 def _aggregate_ef_summary(vector_list: list[VectorDataset]) -> VectorDataset | None:
@@ -2438,7 +2437,6 @@ def _downselect_met(
         longitude_buffer=longitude_buffer,
         level_buffer=level_buffer,
         time_buffer=(t0, t1),
-        copy=False,
     )
 
     rad = source.downselect_met(
@@ -2446,7 +2444,6 @@ def _downselect_met(
         latitude_buffer=latitude_buffer,
         longitude_buffer=longitude_buffer,
         time_buffer=(t0, t1),
-        copy=False,
     )
 
     return met, rad
@@ -2522,65 +2519,3 @@ def _check_end_time(
             f"Include additional time at the end of '{name}' or reduce 'max_age' parameter."
             f"{note}"
         )
-
-
-def _maybe_downselect_mds(
-    big_mds: MetDataset,
-    little_mds: MetDataset | None,
-    t0: np.datetime64,
-    t1: np.datetime64,
-) -> MetDataset:
-    """Possibly downselect ``big_mds`` to cover ``[t0, t1]``.
-
-    This implementation assumes ``t0 <= t1``, but this is not enforced.
-
-    If possible, ``little_mds`` is recycled to avoid re-loading data.
-
-    This function only downselects in the time domain.
-
-    If ``big_mds`` doesn't cover the time range, no error is raised.
-    """
-    if little_mds is not None:
-        little_time = little_mds.indexes["time"].to_numpy()
-        ignore_little = t0 > little_time[-1] or t1 < little_time[0]
-
-    big_time = big_mds.indexes["time"].to_numpy()
-    if little_mds is None or ignore_little:
-        i0 = np.searchsorted(big_time, t0, side="right").item()
-        i0 = max(0, i0 - 1)
-        i1 = np.searchsorted(big_time, t1, side="left").item()
-        i1 = min(i1 + 1, big_time.size)
-        return MetDataset(big_mds.data.isel(time=slice(i0, i1)), copy=False)
-
-    j0 = np.searchsorted(little_time, t0, side="right").item()
-    j0 = max(0, j0 - 1)
-    j1 = np.searchsorted(little_time, t1, side="left").item()
-    j1 = min(j1 + 1, little_time.size)
-
-    little_ds = little_mds.data.isel(time=slice(j0, j1))
-    little_time0 = little_time[j0]
-    little_time1 = little_time[j1 - 1]
-
-    if t0 >= little_time0 and t1 <= little_time1:
-        return MetDataset(little_ds, copy=False)
-
-    ds_concat = []
-    if t0 < little_time0:  # unlikely to encounter this case
-        i0 = np.searchsorted(big_time, t0, side="right").item()
-        i0 = max(0, i0 - 1)
-        i1 = np.searchsorted(big_time, little_time0, side="right").item()
-        i1 = max(i1, i0 + 1)
-        ds_concat.append(big_mds.data.isel(time=slice(i0, i1)))
-
-    ds_concat.append(little_ds)
-
-    if t1 > little_time1:
-        i0 = np.searchsorted(big_time, little_time1, side="left").item()
-        i0 = min(i0 + 1, big_time.size)
-        i1 = np.searchsorted(big_time, t1, side="left").item()
-        i1 = min(i1 + 1, big_time.size)
-        ds_concat.append(big_mds.data.isel(time=slice(i0, i1)))
-
-    # If little_mds is loaded into memory but big_mds is not,
-    # the concat operation below will load the slice of big_mds into memory.
-    return MetDataset(xr.concat(ds_concat, dim="time"), copy=False)