ported changes in halos/profiles

pyccl/base.py

@@ -2,9 +2,11 @@
 import functools
 from collections import OrderedDict
 import numpy as np
-from inspect import signature
+from inspect import signature, Parameter
 from _thread import RLock
 from abc import ABC
+import warnings
+from .errors import CCLDeprecationWarning
 
 
 def _to_hashable(obj):
@@ -619,3 +621,131 @@ def __repr__(self):
             from ._repr import _build_string_from_attrs
             return _build_string_from_attrs(self)
         return object.__repr__(self)
+
+
+def warn_api(func=None, *, pairs=[], reorder=[]):
+    """ This decorator translates old API to new API for:
+      - functions/methods whose arguments have been ranamed,
+      - functions/methods with changed argument order,
+      - constructors in the ``halos`` sub-package where ``cosmo`` is removed,
+      - functions/methods where ``normprof`` is now a required argument.
+
+    Parameters:
+        pairs : list of pairs, optional
+            List of renaming pairs ``('old', 'new')``.
+        reorder : list, optional
+            List of the **previous** order of the arguments whose order
+            has been changed, under their **new** name.
+
+    Example:
+        We have the legacy constructor:
+
+        >>> def __init__(self, cosmo, a, b, c=0, d=1, normprof=False):
+                # do something
+                return a, b, c, d, normprof
+
+        and we want to change the API to
+
+        >>> def __init__(self, a, *, see=0, bee, d=1, normprof=None):
+                # do the same thing
+                return a, bee, see, d, normprof
+
+        Then, adding this decorator to our new function would preserve API
+
+        >>> @warn_api(pairs=[('b', 'bee'), ('c', 'see')],
+                      reorder=['bee', 'see'])
+
+        - ``cosmo`` is automatically detected for all constructors in ``halos``
+        - ``normprof`` is automatically detected for all decorated functions.
+    """
+    if func is None:
+        # called with parentheses
+        return functools.partial(warn_api, pairs=pairs, reorder=reorder)
+
+    name = func.__qualname__
+    plural = lambda expr: "" if not len(expr)-1 else "s"  # noqa: final 's'
+    params = signature(func).parameters
+    POK = Parameter.POSITIONAL_OR_KEYWORD
+    KWO = Parameter.KEYWORD_ONLY
+    pos_names = [k for k, v in params.items() if v.kind == POK]
+    kwo_names = [k for k, v in params.items() if v.kind == KWO]
+    npos = len(pos_names)
+    rename = dict(pairs)
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Custom definition of `isinstance` to avoic cyclic imports.
+        is_instance = lambda obj, cl: cl in obj.__class__.__name__  # noqa
+
+        # API compatibility with `cosmo` as a first argument in `halos`.
+        catch_cosmo = args[1] if len(args) > 1 else kwargs.get("cosmo")
+        if ("pyccl.halos" in func.__module__
+                and func.__name__ == "__init__"
+                and is_instance(catch_cosmo, "Cosmology")):
+            warnings.warn(
+                f"Use of argument `cosmo` has been deprecated in {name}. "
+                "This will trigger an exception in the future.",
+                CCLDeprecationWarning)
+            # `cosmo` may be in `args` or in `kwargs`, so we check both.
+            args = tuple(
+                item for item in args if not is_instance(item, "Cosmology"))
+            kwargs.pop("cosmo", None)
+
+        # API compatibility for reordered positionals in `fourier_2pt`.
+        first_arg = args[1] if len(args) > 1 else None
+        if (func.__name__ == "fourier_2pt"
+                and is_instance(first_arg, "HaloProfile")):
+            api = dict(zip(["prof", "cosmo", "k", "M", "a"], args[1: 6]))
+            args = (args[0],) + args[6:]  # discard args [1-5]
+            kwargs.update(api)            # they are now kwargs
+            warnings.warn(
+                "API for Profile2pt.fourier_2pt has changed. "
+                "Argument order (prof, cosmo, k, M, a) has been replaced by "
+                "(cosmo, k, M, a, prof).", CCLDeprecationWarning)
+
+        # API compatibility for renamed arguments.
+        warn_names = set(kwargs) - set(params)
+        if warn_names:
+            s = plural(warn_names)
+            warnings.warn(
+                f"Use of argument{s} {list(warn_names)} is deprecated "
+                f"in {name}. Pass the new name{s} of the argument{s} "
+                f"{[rename[k] for k in warn_names]}, respectively.",
+                CCLDeprecationWarning)
+            for param in warn_names:
+                kwargs[rename[param]] = kwargs.pop(param)
+
+        # API compatibility for star operator.
+        if len(args) > npos:
+            # API compatibility for shuffled order.
+            if reorder:
+                # Pick up the positions of the common elements.
+                mask = [param in reorder for param in kwo_names]
+                start = mask.index(True)
+                stop = start + len(reorder)
+                # Sort the reordered part of `kwo_names` by `reorder` indexing.
+                kwo_names[start: stop] = sorted(kwo_names[start: stop],
+                                                key=reorder.index)
+            extras = dict(zip(kwo_names, args[npos:]))
+            kwargs.update(extras)
+            s = plural(extras)
+            warnings.warn(
+                f"Use of argument{s} {list(extras)} as positional is "
+                f"deprecated in {func.__qualname__}.", CCLDeprecationWarning)
+
+        # API compatibility for `normprof` as a required argument.
+        if "normprof" in set(params) - set(kwargs):
+            kwargs["normprof"] = False
+            warnings.warn(
+                "Halo profile normalization `normprof` has become a required "
+                f"argument in {name}. Not specifying it will trigger an "
+                "exception in the future", CCLDeprecationWarning)
+
+        # Collect what's remaining and sort to preserve signature order.
+        pos = dict(zip(pos_names, args))
+        kwargs.update(pos)
+        kwargs = {param: kwargs[param]
+                  for param in sorted(kwargs, key=list(params).index)}
+
+        return func(**kwargs)
+    return wrapper

pyccl/halos/profiles/einasto.py

@@ -1,3 +1,4 @@
+from ...base import warn_api
 from ...power import sigmaM
 from ..concentration import Concentration
 from ..massdef import MassDef
@@ -31,22 +32,24 @@ class HaloProfileEinasto(HaloProfile):
     By default, this profile is truncated at :math:`r = R_\\Delta(M)`.
 
     Args:
-        c_M_relation (:obj:`Concentration`): concentration-mass
+        c_m_relation (:obj:`Concentration`): concentration-mass
             relation to use with this profile.
         truncated (bool): set to `True` if the profile should be
             truncated at :math:`r = R_\\Delta` (i.e. zero at larger
             radii.
         alpha (float, 'cosmo'): Set the Einasto alpha parameter or set to
             'cosmo' to calculate the value from cosmology. Default: 'cosmo'
     """
-    __repr_attrs__ = ("cM", "truncated", "alpha", "precision_fftlog",)
+    __repr_attrs__ = ("c_m_relation", "truncated", "alpha",
+                      "precision_fftlog",)
     name = 'Einasto'
 
-    def __init__(self, c_M_relation, truncated=True, alpha='cosmo'):
-        if not isinstance(c_M_relation, Concentration):
-            raise TypeError("c_M_relation must be of type `Concentration`")
+    @warn_api(pairs=[("c_M_relation", "c_m_relation")])
+    def __init__(self, *, c_m_relation, truncated=True, alpha='cosmo'):
+        if not isinstance(c_m_relation, Concentration):
+            raise TypeError("c_m_relation must be of type `Concentration`")
 
-        self.cM = c_M_relation
+        self.c_m_relation = c_m_relation
         self.truncated = truncated
         self.alpha = alpha
         super(HaloProfileEinasto, self).__init__()
@@ -68,19 +71,18 @@ def update_parameters(self, alpha=None):
         if alpha is not None and alpha != self.alpha:
             self.alpha = alpha
 
-    def _get_cM(self, cosmo, M, a, mdef=None):
-        return self.cM.get_concentration(cosmo, M, a, mdef_other=mdef)
-
-    def _get_alpha(self, cosmo, M, a, mdef):
+    def _get_alpha(self, cosmo, M, a, mass_def):
         if self.alpha == 'cosmo':
-            mdef_vir = MassDef('vir', 'matter')
-            Mvir = mdef.translate_mass(cosmo, M, a, mdef_vir)
+            Mvir = mass_def.translate_mass(
+                cosmo, M, a, mass_def_other=MassDef('vir', 'matter'))
             sM = sigmaM(cosmo, Mvir, a)
             nu = 1.686 / sM
-            alpha = 0.155 + 0.0095 * nu * nu
-        else:
-            alpha = np.full_like(M, self.alpha)
-        return alpha
+            return 0.155 + 0.0095 * nu * nu
+        return np.full_like(M, self.alpha)
+
+    def _get_c_m_relation(self, cosmo, M, a, mass_def=None):
+        return self.c_m_relation.get_concentration(cosmo, M, a,
+                                                   mass_def_other=mass_def)
 
     def _norm(self, M, Rs, c, alpha):
         # Einasto normalization from mass, radius, concentration and alpha
@@ -94,7 +96,7 @@ def _real(self, cosmo, r, M, a, mass_def):
 
         # Comoving virial radius
         R_M = mass_def.get_radius(cosmo, M_use, a) / a
-        c_M = self._get_cM(cosmo, M_use, a, mdef=mass_def)
+        c_M = self._get_c_m_relation(cosmo, M_use, a, mass_def=mass_def)
         R_s = R_M / c_M
 
         alpha = self._get_alpha(cosmo, M_use, a, mass_def)

pyccl/halos/profiles/gaussian.py

@@ -1,3 +1,4 @@
+from ...base import warn_api
 from .profile_base import HaloProfile
 import numpy as np
 
@@ -14,19 +15,20 @@ class HaloProfileGaussian(HaloProfile):
     Args:
         r_scale (:obj:`function`): the width of the profile.
             The signature of this function should be
-            `f(cosmo, M, a, mdef)`, where `cosmo` is a
+            `f(cosmo, M, a, mass_def)`, where `cosmo` is a
             :class:`~pyccl.core.Cosmology` object, `M` is a halo mass in
-            units of M_sun, `a` is the scale factor and `mdef`
+            units of M_sun, `a` is the scale factor and `mass_def`
             is a :class:`~pyccl.halos.massdef.MassDef` object.
         rho0 (:obj:`function`): the amplitude of the profile.
             It should have the same signature as `r_scale`.
     """
-    __repr_attrs__ = ("r_s", "rho_0", "precision_fftlog",)
+    __repr_attrs__ = ("r_scale", "rho_0", "precision_fftlog",)
     name = 'Gaussian'
 
-    def __init__(self, r_scale, rho0):
+    @warn_api
+    def __init__(self, *, r_scale, rho0):
         self.rho_0 = rho0
-        self.r_s = r_scale
+        self.r_scale = r_scale
         super(HaloProfileGaussian, self).__init__()
         self.update_precision_fftlog(padding_lo_fftlog=0.01,
                                      padding_hi_fftlog=100.,
@@ -37,7 +39,7 @@ def _real(self, cosmo, r, M, a, mass_def):
         M_use = np.atleast_1d(M)
 
         # Compute scale
-        rs = self.r_s(cosmo, M_use, a, mass_def)
+        rs = self.r_scale(cosmo, M_use, a, mass_def)
         # Compute normalization
         rho0 = self.rho_0(cosmo, M_use, a, mass_def)
         # Form factor

pyccl/halos/profiles/hernquist.py

@@ -1,3 +1,4 @@
+from ...base import warn_api
 from ..concentration import Concentration
 from .profile_base import HaloProfile
 import numpy as np
@@ -27,7 +28,7 @@ class HaloProfileHernquist(HaloProfile):
     By default, this profile is truncated at :math:`r = R_\\Delta(M)`.
 
     Args:
-        c_M_relation (:obj:`Concentration`): concentration-mass
+        c_m_relation (:obj:`Concentration`): concentration-mass
             relation to use with this profile.
         fourier_analytic (bool): set to `True` if you want to compute
             the Fourier profile analytically (and not through FFTLog).
@@ -42,19 +43,20 @@ class HaloProfileHernquist(HaloProfile):
             truncated at :math:`r = R_\\Delta` (i.e. zero at larger
             radii.
     """
-    __repr_attrs__ = ("cM", "fourier_analytic", "projected_analytic",
+    __repr_attrs__ = ("c_m_relation", "fourier_analytic", "projected_analytic",
                       "cumul2d_analytic", "truncated", "precision_fftlog",)
     name = 'Hernquist'
 
-    def __init__(self, c_M_relation,
+    @warn_api(pairs=[("c_M_relation", "c_m_relation")])
+    def __init__(self, *, c_m_relation,
                  truncated=True,
                  fourier_analytic=False,
                  projected_analytic=False,
                  cumul2d_analytic=False):
-        if not isinstance(c_M_relation, Concentration):
-            raise TypeError("c_M_relation must be of type `Concentration`")
+        if not isinstance(c_m_relation, Concentration):
+            raise TypeError("c_m_relation must be of type `Concentration`")
 
-        self.cM = c_M_relation
+        self.c_m_relation = c_m_relation
         self.truncated = truncated
         self.fourier_analytic = fourier_analytic
         self.projected_analytic = projected_analytic
@@ -79,8 +81,9 @@ def __init__(self, c_M_relation,
                                      n_per_decade=1000,
                                      plaw_fourier=-2.)
 
-    def _get_cM(self, cosmo, M, a, mdef=None):
-        return self.cM.get_concentration(cosmo, M, a, mdef_other=mdef)
+    def _get_c_m_relation(self, cosmo, M, a, mass_def=None):
+        return self.c_m_relation.get_concentration(cosmo, M, a,
+                                                   mass_def_other=mass_def)
 
     def _norm(self, M, Rs, c):
         # Hernquist normalization from mass, radius and concentration
@@ -92,7 +95,7 @@ def _real(self, cosmo, r, M, a, mass_def):
 
         # Comoving virial radius
         R_M = mass_def.get_radius(cosmo, M_use, a) / a
-        c_M = self._get_cM(cosmo, M_use, a, mdef=mass_def)
+        c_M = self._get_c_m_relation(cosmo, M_use, a, mass_def=mass_def)
         R_s = R_M / c_M
 
         norm = self._norm(M_use, R_s, c_M)
@@ -131,7 +134,7 @@ def _projected_analytic(self, cosmo, r, M, a, mass_def):
 
         # Comoving virial radius
         R_M = mass_def.get_radius(cosmo, M_use, a) / a
-        c_M = self._get_cM(cosmo, M_use, a, mdef=mass_def)
+        c_M = self._get_c_m_relation(cosmo, M_use, a, mass_def=mass_def)
         R_s = R_M / c_M
 
         x = r_use[None, :] / R_s[:, None]
@@ -170,7 +173,7 @@ def _cumul2d_analytic(self, cosmo, r, M, a, mass_def):
 
         # Comoving virial radius
         R_M = mass_def.get_radius(cosmo, M_use, a) / a
-        c_M = self._get_cM(cosmo, M_use, a, mdef=mass_def)
+        c_M = self._get_c_m_relation(cosmo, M_use, a, mass_def=mass_def)
         R_s = R_M / c_M
 
         x = r_use[None, :] / R_s[:, None]
@@ -190,7 +193,7 @@ def _fourier_analytic(self, cosmo, k, M, a, mass_def):
 
         # Comoving virial radius
         R_M = mass_def.get_radius(cosmo, M_use, a) / a
-        c_M = self._get_cM(cosmo, M_use, a, mdef=mass_def)
+        c_M = self._get_c_m_relation(cosmo, M_use, a, mass_def=mass_def)
         R_s = R_M / c_M
 
         x = k_use[None, :] * R_s[:, None]