sacc 1.0__py3-none-any.whl

sacc/utils.py

@@ -0,0 +1,168 @@
+import re
+
+from astropy.table import Column
+import numpy as np
+import scipy.linalg
+
+# These null values are used in place
+# of missing values.
+null_values = {
+    'i': -1437530437530211245,
+    'f': -1.4375304375e30,
+    'U': '',
+}
+
+
+def hide_null_values(table):
+    """Replace None values in an astropy table
+    with a null value, and change the column type
+    to whatever suits the remaining data points
+
+    Parameters
+    ----------
+    table: astropy table
+        Table to modify in-place
+    """
+
+    for name, col in list(table.columns.items()):
+        if col.dtype.kind == 'O':
+            good_values = [x for x in col if x is not None]
+            good_kind = np.array(good_values).dtype.kind
+            null = null_values[good_kind]
+            good_col = np.array([null if x is None else x for x in col])
+            table[name] = Column(good_col)
+
+
+def remove_dict_null_values(dictionary):
+    """Remove values in a dictionary that
+    correspond to the null values above.
+
+    Parameters
+    ----------
+    dictionary: dict
+        Dict (or subclass instance or other mapping) to modify in-place
+    """
+    # will figure out the list of keys to remove
+    deletes = []
+    for k, v in dictionary.items():
+        try:
+            dt = np.dtype(type(v)).kind
+            if v == null_values[dt]:
+                deletes.append(k)
+        except (TypeError, KeyError):
+            continue
+    for d in deletes:
+        del dictionary[d]
+
+
+def unique_list(seq):
+    """
+    Find the unique elements in a list or other sequence
+    while maintaining the order. (i.e., remove any duplicated
+    elements but otherwise leave it the same)
+
+    Method from:
+    https://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-whilst-preserving-order
+
+    Parameters
+    ----------
+    seq: list or sequence
+        Any input object that can be iterated
+
+    Returns
+    -------
+    L: list
+        a new list of the unique objects
+    """
+    seen = set()
+    seen_add = seen.add
+    return [x for x in seq if not (x in seen or seen_add(x))]
+
+
+class Namespace:
+    """
+    This helper class implements a very simple namespace object
+    designed to store strings with the same name as their contents
+    as a kind of simple string enum.
+
+    N = Namespace('a', 'b', 'c')
+
+    assert N.a=='a'
+
+    assert N['a']=='a'
+
+    assert N.index('b')==1
+    """
+    def __init__(self, *strings):
+        """
+        Create the object from a list of strings, which will become attributes
+        """
+        self._index = {}
+        n = 0
+        for s in strings:
+            self.__dict__[s] = s
+            self._index[s] = n
+            n += 1
+
+    def __contains__(self, s):
+        return hasattr(self, s)
+
+    def __getitem__(self, s):
+        return getattr(self, s)
+
+    def __str__(self):
+        return "\n".join(f"- {s}" for s in self._index)
+
+    def index(self, s):
+        return self._index[s]
+
+
+def invert_spd_matrix(M, strict=True):
+    """
+    Invert a symmetric positive definite matrix.
+
+    SPD matrices (for example, covariance matrices) have only
+    positive eigenvalues.
+
+    Based on:
+    https://stackoverflow.com/questions/40703042/more-efficient-way-to-invert-a-matrix-knowing-it-is-symmetric-and-positive-semi
+
+    Parameters
+    ----------
+    M: 2d array
+        Matrix to invert
+
+    strict: bool, default=True
+        If True, require that the matrix is SPD.
+        If False, use a slower algorithm that will work on other matrices
+
+    Returns
+    -------
+    invM: 2d array
+        Inverse matrix
+
+    """
+    M = np.atleast_2d(M)
+
+    # In strict mode we use a method which will only work for SPD matrices,
+    # and raise an exception otherwise.
+    if strict:
+        L, _ = scipy.linalg.lapack.dpotrf(M, False, False)
+        invM, info = scipy.linalg.lapack.dpotri(L)
+        if info:
+            raise ValueError("Matrix is not symmetric-positive-definite")
+        else:
+            invM = np.triu(invM) + np.triu(invM, k=1).T
+    # Otherwise we use the generic (and also slower) method that will
+    # work if, due to numerical issues, the matrix is not quite SPD
+    else:
+        invM = np.linalg.inv(M)
+
+    return invM
+
+
+def camel_case_split_and_lowercase(identifier):
+    matches = re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])'
+                          '|(?<=[A-Z])(?=[A-Z][a-z])|$)',
+                          identifier)
+    return [m.group(0).lower() for m in matches]

sacc/windows.py

@@ -0,0 +1,334 @@
+import numpy as np
+from astropy.table import Table
+
+
+class BaseWindow:
+    """Base class for window functions.
+
+    Window functions here are for 1D variables and describe
+    binnings from functions onto discrete values.
+
+    They are treated as a special kind of tag value in Sacc.
+
+    Subclasses describe common types of window function, including
+    a top hat between two values and a general tabulated
+    functional form.
+
+    This base class has class methods that can be used to turn
+    mixed lists of windows to/from astropy tables, for I/O.
+    """
+    _window_classes = {}
+
+    def __init_subclass__(cls, window_type):
+        # This gets called whenever a subclass is defined.
+        # The window_type argument is specified next to the
+        # base class in the subclass definition, e.g.
+        # window_typ='TopHat', as shown below
+        cls._window_classes[window_type] = cls
+        cls.window_type = window_type
+
+    @classmethod
+    def to_tables(cls, instance_list):
+        """Convert a list of BaseWindos to a list of tables.
+
+        This is called when saving data to file.
+
+        The input instances can be different subclasses, and no
+        ordering is maintained.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of BaseWindow subclass instances
+
+        Returns
+        -------
+        table: list
+            List of astropy.table.Table instances
+        """
+        tables = []
+        for name, subcls in cls._window_classes.items():
+            # Pull out the relevant objects for this subclass.
+            # Note that we can't use isinstance here.
+            windows = [w for w in instance_list if type(w) == subcls]
+            if len(windows) > 0:
+                tables += subcls.to_tables(windows)
+        return tables
+
+    @classmethod
+    def from_tables(cls, table_list):
+        """Turn a list of astropy tables into window objects
+
+        This is called when loading data from file.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of BaseWindow instances
+
+        Returns
+        -------
+        windows: dict
+            Dictionary of id -> Window instances
+        """
+        windows = {}
+        for table in table_list:
+            subclass_name = table.meta['SACCCLSS']
+            subclass = cls._window_classes[subclass_name]
+            # Different subclasses can handle this differently.
+            windows.update(subclass.from_table(table))
+        return windows
+
+
+class TopHatWindow(BaseWindow, window_type='TopHat'):
+    """A window function that is constant between two values.
+
+    The top-hat is zero elsewhere.
+
+    In the case of discrete functions like ell window where it matters, these
+    window functions should follow the python convention and
+    the upper limit should be exclusive, so that you can use
+    range(win.min, win.max) to select the right ell values.
+
+    Parameters
+    ----------
+    min: int/float
+        The minimum value where the top-hat function equals 1
+
+    max: int/float
+        The maximum value where the top-hat function equals 1
+    """
+    def __init__(self, range_min, range_max):
+        """Create a top-hat window
+
+        Parameters
+        ----------
+        range_min: int/float
+            The minimum value where the top-hat function equals 1
+
+        range_max: int/float
+            The maximum value where the top-hat function equals 1
+
+        """
+        self.min = range_min
+        self.max = range_max
+
+    @classmethod
+    def to_tables(cls, window_list):
+        """Convert a list of Top-Hat windows to a list of astropy tables.
+
+        A single table is created for all the windows.
+
+        The tables contain an ID column which uniquely identifies the
+        window instance, but only whilst running a given python process -
+        it is not portable.  It should not be used for anythng other than I/O.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of TopHatWindow instances
+
+        Returns
+        -------
+        table: list
+            List of astropy.table.Table instances
+        """
+        mins = [w.min for w in window_list]
+        maxs = [w.max for w in window_list]
+        ids = [id(w) for w in window_list]
+        t = Table(data=[ids, mins, maxs], names=['id', 'min', 'max'])
+        t.meta['SACCTYPE'] = 'window'
+        t.meta['SACCCLSS'] = cls.window_type
+        t.meta['EXTNAME'] = 'window:' + cls.window_type
+        return [t]
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table to a dictionary of Top-Hat windows
+
+        Multiple windows are extracted from the single table.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+
+        Returns
+        -------
+        windows: dict
+            Dictionary of id -> TopHatWindow instances
+        """
+        return {row['id']: cls(row['min'], row['max']) for row in table}
+
+
+class LogTopHatWindow(TopHatWindow, window_type='LogTopHat'):
+    """A window function that is log-constant between two values.
+
+    This object is the same as the TopHat form, except that in between
+    the min and max values it is assumed to be constant in the log of the
+    argument.  The difference arises when this object is used elsewhere.
+    """
+    pass
+
+
+class Window(BaseWindow, window_type='Standard'):
+    """The Window class defines a tabulated window function.
+
+    The class contains tabulated values of the abscissa (e.g. ell or theta) and
+    corresponding weights values for each one.
+
+    The function could be integrated or summed depending on the
+    context.
+
+    Parameters
+    ----------
+    values: array
+        The points at which the weights are defines
+    weight:
+        The weights corresponding to each value
+
+    """
+    def __init__(self, values, weight):
+        self.values = np.array(values)
+        self.weight = np.array(weight)
+
+    @classmethod
+    def to_tables(cls, window_list):
+        """Convert a list of windows to a list of astropy tables.
+
+        One table is created per window.
+
+        The tables contain an ID column which uniquely identifies the
+        window instance, but only whilst running a given python process -
+        it is not portable.  It should not be used for anythng other than I/O.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of Window instances
+
+        Returns
+        -------
+        table: list
+            List of astropy.table.Table instances
+        """
+        tables = []
+        for w in window_list:
+            cols = [w.values, w.weight]
+            names = ['values', 'weight']
+            t = Table(data=cols, names=names)
+            t.meta['SACCTYPE'] = 'window'
+            t.meta['SACCCLSS'] = cls.window_type
+            t.meta['SACCNAME'] = id(w)
+            t.meta['EXTNAME'] = 'window:' + cls.window_type
+            tables.append(t)
+        return tables
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table to a dictionary of Windows
+
+        One window is extracted from the table.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+
+        Returns
+        -------
+        windows: dict
+            Dictionary of id -> Window instances
+        """
+        return {table.meta['SACCNAME']: cls(table['values'], table['weight'])}
+
+
+class BandpowerWindow(BaseWindow, window_type='Bandpower'):
+    """The BandpowerWindow class defines a tabulated for power
+    spectrum bandpowers.
+
+    The class contains tabulated values of ell and corresponding weights
+    values for each one. More than one set of weights can be used.
+
+    Parameters
+    ----------
+    values: array
+        An array of dimension (N_ell) containing the ell values at which the
+        weights are defined.
+    weight:
+        An array of dimensions (N_ell, N_weight) containing N_weight sets of
+        weights corresponding to each value.
+
+    """
+    def __init__(self, values, weight):
+        nl, nv = weight.shape
+        nell = len(values)
+        if nl != len(values):
+            raise ValueError(f"Wrong input shapes ${nl}!=${nell}")
+        self.nell = nell
+        self.nv = nv
+        self.values = np.array(values)
+        self.weight = np.array(weight)
+
+    @classmethod
+    def to_tables(cls, window_list):
+        """Convert a list of windows to a list of astropy tables.
+
+        One table is created per window.
+
+        The tables contain an ID column which uniquely identifies the
+        window instance, but only whilst running a given python process -
+        it is not portable.  It should not be used for anythng other than I/O.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of Window instances
+
+        Returns
+        -------
+        table: list
+            List of astropy.table.Table instances
+        """
+        tables = []
+        for w in window_list:
+            cols = [w.values, w.weight]
+            names = ['values', 'weight']
+            t = Table(data=cols, names=names)
+            t.meta['SACCTYPE'] = 'window'
+            t.meta['SACCCLSS'] = cls.window_type
+            t.meta['SACCNAME'] = id(w)
+            t.meta['EXTNAME'] = 'window:' + cls.window_type
+            tables.append(t)
+        return tables
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table to a dictionary of Windows
+
+        One window is extracted from the table.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+
+        Returns
+        -------
+        windows: dict
+            Dictionary of id -> Window instances
+        """
+        return {table.meta['SACCNAME']: cls(table['values'], table['weight'])}
+
+    def get_section(self, indices):
+        """Get part of this window function corresponding to the input
+        indices.
+
+        Parameters
+        ----------
+        indices: int or array_like
+            Indices to return.
+
+        Returns
+        -------
+        window: `Window`
+            A `Window object.
+        """
+        return self.__class__(self.values, self.weight[:, indices])

sacc-1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: sacc
+Version: 1.0
+Summary: SACC - the LSST/DESC summary statistic data format library
+Author-email: LSST DESC <joezuntz@googlemail.com>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/LSSTDESC/sacc
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy
+Requires-Dist: numpy>=1.20
+Requires-Dist: astropy
+Provides-Extra: all
+Requires-Dist: qp-prob[all]; extra == "all"
+Requires-Dist: numpydoc; extra == "all"
+Provides-Extra: doc
+Requires-Dist: numpydoc; extra == "doc"
+Provides-Extra: qp
+Requires-Dist: qp-prob[all]; extra == "qp"
+Dynamic: license-file
+
+Sacc
+====
+
+SACC (Save All Correlations and Covariances) is a format and reference library for general storage
+of summary statistic measurements for the Dark Energy Science Collaboration (DESC) within the Large Synoptic
+Survey Telescope (LSST) project.
+
+
+Installation
+------------
+
+You can install sacc with the command:
+
+``pip install sacc``
+
+(For local installation you might need to add `--user`)
+
+Or for development versions you can download the repository with git and install from there using ``python setup.py install``
+
+
+Documentation & Examples
+------------------------
+
+Documentation can be found [on ReadTheDocs](https://sacc.readthedocs.io/en/latest/).
+
+The [examples directory](https://github.com/LSSTDESC/sacc/tree/master/examples) on github contains ipython notebooks showing various ways of constructing and using sacc data files.
+
+If you have a problem you've not been able to debug, or a feature request/suggestion the you can [open an issue](https://github.com/LSSTDESC/sacc/issues) to discuss it.
+
+Versions
+--------
+
+The current release is [version 0.12](https://github.com/LSSTDESC/sacc/releases/tag/0.12).
+
+You can find a list of [previous releases here](https://github.com/LSSTDESC/sacc/releases).  The releases above 0.2 are all backwards compatible; 0.1 is a previous version of the format.
+
+The master branch includes more recent (non-released) development changes.
+
+
+Citation
+--------
+
+Sacc has been submitted to the [Astrophysics Source Code Library](https://ascl.net/code/v/2277); follow the link that will appear there to NASA ADS to export a bibtex citation.
+
+The core developers of Sacc are Joe Zuntz (maintainer), David Alonso, and Matt Becker.

sacc-1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+sacc/__init__.py,sha256=gBQL_7lot-eVvroFsQAeM8_Gxaj5saR-hShiDLDwjV8,353
+sacc/covariance.py,sha256=ZxeEI1zWNlMhh-ttUiX7r6j8qx5zKySw_zYRu6npq_o,16402
+sacc/data_types.py,sha256=nsa6iM8ApRmMwb0GNQ-kO3LkgTMaJca-soC0G44TjAs,16285
+sacc/sacc.py,sha256=cgc0p3wwTKF2WT089jDC9qh4TvOFks5MXR16kMKVHOY,51492
+sacc/tracers.py,sha256=as4QLvStrposeneKLRPJxtCt-MOGFGvXOIm14yHVcFc,42893
+sacc/utils.py,sha256=nmauWm_bXNFMWxGomM6GlgLM2bPxG_awYvcE67XF07s,4440
+sacc/windows.py,sha256=Ww6z23ys17pv_QbDHGwHEqQWauD1jk6aWOiQ4Riis2U,10137
+sacc-1.0.dist-info/licenses/LICENSE,sha256=WMLhPVmrUk6KoMHcLwY1ynIJcA7id_bfU-QSSiCAxtI,1469
+sacc-1.0.dist-info/METADATA,sha256=Vo12b76DVXcvMBQdWYK38nOCEKRPikSb-0OMv1RDa78,2396
+sacc-1.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+sacc-1.0.dist-info/top_level.txt,sha256=nyd_Bzl4Ly4EGXdgYFa0MHs8CYGAOIGPG1PhQTZsSdM,5
+sacc-1.0.dist-info/RECORD,,

sacc-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sacc-1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2019-2023 The SACC Developers
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

sacc-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sacc