cached_property replaces CachedReadOnlyProperty

This is a Python 3.8 feature.

Author: amorison

stagpy/_helpers.py

@@ -1,15 +1,16 @@
 """Various helper functions and classes."""
 
 from __future__ import annotations
+
+import typing
 from inspect import getdoc
-from typing import TYPE_CHECKING, Generic, TypeVar
 
 import matplotlib.pyplot as plt
 
 from . import conf
 
-if TYPE_CHECKING:
-    from typing import Optional, Any, Callable, NoReturn
+if typing.TYPE_CHECKING:
+    from typing import Optional, Any
     from matplotlib.figure import Figure
     from numpy import ndarray
 
@@ -103,42 +104,3 @@ def find_in_sorted_arr(value: Any, array: ndarray, after: bool = False) -> int:
     if not after and array[ielt] != value and ielt > 0:
         ielt -= 1
     return ielt
-
-
-T = TypeVar('T')
-V = TypeVar('V')
-
-
-class CachedReadOnlyProperty(Generic[T, V]):
-    """Descriptor implementation of read-only cached properties.
-
-    Properties are cached as ``_cropped_{name}`` instance attribute.
-
-    This is preferable to using a combination of ``@property`` and
-    ``@functools.lru_cache`` since the cache is bound to instances and
-    therefore get GCd with the instance when the latter is no longer in use
-    instead of staying in the cache which would use the instance itself as its
-    key.
-
-    This also has an advantage over ``@cached_property`` (Python>3.8): the
-    property is read-only instead of being writeable.
-    """
-
-    def __init__(self, thunk: Callable[[T], V]):
-        self._thunk = thunk
-        self._name = thunk.__name__
-        self._cache_name = f'_cropped_{self._name}'
-        self.__doc__ = thunk.__doc__
-
-    def __get__(self, instance: T, _: Any) -> V:
-        try:
-            return getattr(instance, self._cache_name)
-        except AttributeError:
-            pass
-        cached_value = self._thunk(instance)
-        setattr(instance, self._cache_name, cached_value)
-        return cached_value
-
-    def __set__(self, instance: T, _: Any) -> NoReturn:
-        raise AttributeError(
-            f'Cannot set {self._name} property of {instance!r}')

stagpy/_step.py

@@ -8,13 +8,13 @@
 
 from __future__ import annotations
 from collections import abc
+from functools import cached_property
 from itertools import chain
 import typing
 
 import numpy as np
 
 from . import error, phyvars, stagyyparsers
-from ._helpers import CachedReadOnlyProperty as crop
 from .datatypes import Field, Rprof, Varr
 
 if typing.TYPE_CHECKING:
@@ -48,31 +48,42 @@ def _scale_radius_mo(self, radius: ndarray) -> ndarray:
                 radius + self._header['mo_lambda'])
         return radius
 
-    @crop
+    @cached_property
     def nttot(self) -> int:
         """Number of grid point along the x/theta direction."""
         return self._shape['ntot'][0]
 
-    @crop
+    @cached_property
     def nptot(self) -> int:
         """Number of grid point along the y/phi direction."""
         return self._shape['ntot'][1]
 
-    @crop
+    @cached_property
     def nrtot(self) -> int:
         """Number of grid point along the z/r direction."""
         return self._shape['ntot'][2]
 
-    @crop
+    @cached_property
     def nbtot(self) -> int:
         """Number of blocks."""
         return self._shape['ntot'][3]
 
-    nxtot = nttot
-    nytot = nptot
-    nztot = nrtot
+    @property
+    def nxtot(self) -> int:
+        """Same as nttot."""
+        return self.nttot
+
+    @property
+    def nytot(self) -> int:
+        """Same as nptot."""
+        return self.nptot
+
+    @property
+    def nztot(self) -> int:
+        """Same as nrtot."""
+        return self.nrtot
 
-    @crop
+    @cached_property
     def r_walls(self) -> ndarray:
         """Position of FV walls along the z/r direction."""
         rgeom = self._header.get("rgeom")
@@ -83,7 +94,7 @@ def r_walls(self) -> ndarray:
             walls = np.append(walls, self._step.rprofs.bounds[1])
         return self._scale_radius_mo(walls)
 
-    @crop
+    @cached_property
     def r_centers(self) -> ndarray:
         """Position of FV centers along the z/r direction."""
         rgeom = self._header.get("rgeom")
@@ -93,7 +104,7 @@ def r_centers(self) -> ndarray:
             walls = self._step.rprofs.centers
         return self._scale_radius_mo(walls)
 
-    @crop
+    @cached_property
     def t_walls(self) -> ndarray:
         """Position of FV walls along x/theta."""
         if self.threed or self.twod_xz:
@@ -113,12 +124,12 @@ def t_walls(self) -> ndarray:
         d_t = (self.p_walls[1] - self.p_walls[0]) / 2
         return np.array([center - d_t, center + d_t])
 
-    @crop
+    @cached_property
     def t_centers(self) -> ndarray:
         """Position of FV centers along x/theta."""
         return (self.t_walls[:-1] + self.t_walls[1:]) / 2
 
-    @crop
+    @cached_property
     def p_walls(self) -> ndarray:
         """Position of FV walls along y/phi."""
         if self.threed or self.twod_yz:
@@ -136,17 +147,40 @@ def p_walls(self) -> ndarray:
         d_p = (self.t_walls[1] - self.t_walls[0]) / 2
         return np.array([-d_p, d_p])
 
-    @crop
+    @cached_property
     def p_centers(self) -> ndarray:
         """Position of FV centers along y/phi."""
         return (self.p_walls[:-1] + self.p_walls[1:]) / 2
 
-    z_walls = r_walls
-    z_centers = r_centers
-    x_walls = t_walls
-    x_centers = t_centers
-    y_walls = p_walls
-    y_centers = p_centers
+    @property
+    def z_walls(self) -> ndarray:
+        """Same as r_walls."""
+        return self.r_walls
+
+    @property
+    def z_centers(self) -> ndarray:
+        """Same as r_centers."""
+        return self.r_centers
+
+    @property
+    def x_walls(self) -> ndarray:
+        """Same as t_walls."""
+        return self.t_walls
+
+    @property
+    def x_centers(self) -> ndarray:
+        """Same as t_centers."""
+        return self.t_centers
+
+    @property
+    def y_walls(self) -> ndarray:
+        """Same as p_walls."""
+        return self.p_walls
+
+    @property
+    def y_centers(self) -> ndarray:
+        """Same as p_centers."""
+        return self.p_centers
 
     def _init_shape(self) -> None:
         """Determine shape of geometry."""
@@ -160,7 +194,7 @@ def _init_shape(self) -> None:
         self._shape['axi'] = self.cartesian and self.twod_xz and \
             shape == 'axisymmetric'
 
-    @crop
+    @cached_property
     def rcmb(self) -> float:
         """Radius of CMB, 0 in cartesian geometry."""
         return max(self._header["rcmb"], 0)
@@ -272,7 +306,7 @@ def __getitem__(self, name: str) -> Field:
             self._set(fld_name, fld)
         return self._data[name]
 
-    @crop
+    @cached_property
     def _present_fields(self) -> List[str]:
         return [fld for fld in chain(self._vars, self._extra)
                 if fld in self]
@@ -341,7 +375,7 @@ def __delitem__(self, name: str) -> None:
         if name in self._data:
             del self._data[name]
 
-    @crop
+    @cached_property
     def _header(self) -> Optional[Dict[str, Any]]:
         if self.step.isnap is None:
             return None
@@ -354,7 +388,7 @@ def _header(self) -> Optional[Dict[str, Any]]:
             header = stagyyparsers.read_geom_h5(xmf, self.step.isnap)[0]
         return header if header else None
 
-    @crop
+    @cached_property
     def geom(self) -> _Geometry:
         """Geometry information.
 
@@ -425,7 +459,7 @@ def __init__(self, step: Step):
         self.step = step
         self._cached_extra: Dict[str, Rprof] = {}
 
-    @crop
+    @cached_property
     def _data(self) -> Optional[DataFrame]:
         step = self.step
         return step.sdat._rprof_and_times[0].get(step.istep)
@@ -464,12 +498,12 @@ def stepstr(self) -> str:
         """String representation of the parent :class:`Step`."""
         return str(self.step.istep)
 
-    @crop
+    @cached_property
     def centers(self) -> ndarray:
         """Radial position of cell centers."""
         return self._rprofs['r'].values + self.bounds[0]
 
-    @crop
+    @cached_property
     def walls(self) -> ndarray:
         """Radial position of cell walls."""
         rbot, rtop = self.bounds
@@ -484,7 +518,7 @@ def walls(self) -> ndarray:
             walls = np.append(walls, rtop)
         return walls
 
-    @crop
+    @cached_property
     def bounds(self) -> Tuple[float, float]:
         """Radial or vertical position of boundaries.
 

stagpy/stagyydata.py

@@ -8,8 +8,10 @@
 """
 
 from __future__ import annotations
+
 from collections import abc
 from dataclasses import dataclass, field
+from functools import cached_property
 from itertools import zip_longest
 from pathlib import Path
 import re
@@ -18,7 +20,6 @@
 import numpy as np
 
 from . import conf, error, parfile, phyvars, stagyyparsers, _helpers, _step
-from ._helpers import CachedReadOnlyProperty as crop
 from ._step import Step
 from .datatypes import Rprof, Tseries, Vart
 
@@ -71,7 +72,7 @@ class _Scales:
     def __init__(self, sdat: StagyyData):
         self._sdat = sdat
 
-    @crop
+    @cached_property
     def length(self) -> float:
         """Length in m."""
         thick = self._sdat.par['geometry']['d_dimensional']
@@ -159,7 +160,7 @@ class _Refstate:
     def __init__(self, sdat: StagyyData):
         self._sdat = sdat
 
-    @crop
+    @cached_property
     def _data(self) -> Tuple[List[List[DataFrame]], List[DataFrame]]:
         """Read reference state profile."""
         reffile = self._sdat.filename('refstat.dat')
@@ -225,7 +226,7 @@ def __init__(self, sdat: StagyyData):
         self.sdat = sdat
         self._cached_extra: Dict[str, Tseries] = {}
 
-    @crop
+    @cached_property
     def _data(self) -> Optional[DataFrame]:
         timefile = self.sdat.filename('TimeSeries.h5')
         data = stagyyparsers.time_series_h5(
@@ -639,7 +640,7 @@ def rprofs_averaged(self) -> _RprofsAveraged:
             self._rprofs_averaged = _RprofsAveraged(self)
         return self._rprofs_averaged
 
-    @crop
+    @cached_property
     def stepstr(self) -> str:
         """String representation of the requested set of steps."""
         items = []
@@ -772,7 +773,7 @@ def parpath(self) -> Path:
         """Path of par file."""
         return self._parpath
 
-    @crop
+    @cached_property
     def hdf5(self) -> Optional[Path]:
         """Path of output hdf5 folder if relevant, None otherwise."""
         h5_folder = self.path / self.par['ioin']['hdf5_output_folder']
@@ -787,7 +788,7 @@ def par(self) -> Namelist:
         """
         return self._par
 
-    @crop
+    @cached_property
     def _rprof_and_times(
         self
     ) -> Tuple[Dict[int, DataFrame], Optional[DataFrame]]:
@@ -806,7 +807,7 @@ def rtimes(self) -> DataFrame:
         """Radial profiles times."""
         return self._rprof_and_times[1]
 
-    @crop
+    @cached_property
     def _files(self) -> Set[Path]:
         """Set of found binary files output by StagYY."""
         out_stem = Path(self.par['ioin']['output_file_stem'] + '_')