sacc 1.0.2__tar.gz → 2.0__tar.gz

{sacc-1.0.2 → sacc-2.0}/.github/workflows/desc-ci.yml

@@ -12,11 +12,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8, 3.9, "3.10", "3.11"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: Setup python
       uses: actions/setup-python@v4
@@ -26,15 +26,25 @@ jobs:
     - name: Dependencies
       run: |
         python -m pip install --upgrade numpy pytest pytest-cov coverage pip
+        # Temporary until fixes applied in another PR
         python -m pip install '.[all]'
 
     - name: Run tests and measure coverage
       run: |
-        pytest  --cov sacc --cov-report xml:coverage.xml   ./test
+        pytest  --cov sacc --cov-report xml:coverage.xml --cov-branch  ./test
 
-    - name: Report coverage
+    - name: Report coverage in GitHub PR
       uses: orgoro/coverage@v3.2
       if: matrix.python-version == '3.11'
       with:
         coverageFile: ./coverage.xml
         token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Upload coverage reports to Codecov
+      if: matrix.python-version == '3.11'
+      uses: codecov/codecov-action@v5
+      with:
+        fail_ci_if_error: true
+        verbose: true
+        use_oidc: false
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{sacc-1.0.2/sacc.egg-info → sacc-2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sacc
-Version: 1.0.2
+Version: 2.0
 Summary: SACC - the LSST/DESC summary statistic data format library
 Author-email: LSST DESC <joezuntz@googlemail.com>
 License: BSD-3-Clause
@@ -10,17 +10,19 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy
-Requires-Dist: numpy>=1.20
+Requires-Dist: numpy>=2
 Requires-Dist: astropy
 Provides-Extra: all
-Requires-Dist: qp-prob[all]; extra == "all"
+Requires-Dist: qp-prob[all]>=1; 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"
+Requires-Dist: qp-prob[all]>=1; extra == "qp"
 Dynamic: license-file
 
+[![codecov](https://codecov.io/github/LSSTDESC/sacc/graph/badge.svg?token=YZf4IXbzA0)](https://codecov.io/github/LSSTDESC/sacc)
+
 Sacc
 ====
 

{sacc-1.0.2 → sacc-2.0}/README.md

@@ -1,3 +1,5 @@
+[![codecov](https://codecov.io/github/LSSTDESC/sacc/graph/badge.svg?token=YZf4IXbzA0)](https://codecov.io/github/LSSTDESC/sacc)
+
 Sacc
 ====
 

sacc-2.0/codecov.yml

@@ -0,0 +1,36 @@
+# See https://docs.codecov.com/docs/codecovyml-reference for config reference
+# To validate: `curl -X POST --data-binary @codecov.yml https://codecov.io/validate`
+
+comment:
+  layout: "diff, flags, files"
+  behavior: default
+  require_changes: false  
+  require_base: false        
+  require_head: true       
+  hide_project_coverage: false 
+
+coverage:
+  precision: 1
+  round: down
+  # red below 70, yellow between 70 and 95, green above 95.
+  range: 70..95 
+
+  status:
+    patch:
+      default:
+        target: 100%
+        threshold: 0%
+        if_ci_failed: error
+        only_pulls: false
+
+    project:
+      default: 
+        target: auto
+        threshold: 0%
+        if_ci_failed: error
+        only_pulls: false
+        removed_code_behavior: fully_covered_patch
+      
+github_checks:
+  annotations: true
+

sacc-2.0/examples/demo.py

@@ -0,0 +1,50 @@
+
+import numpy as np
+from sacc import Sacc, BandpowerWindow
+
+# Create Sacc object
+s = Sacc()
+
+# Add metadata
+s.metadata['creator'] = 'Demo'
+s.metadata['purpose'] = 'Full feature test'
+
+ # Add tracers
+z = np.linspace(0, 1, 101)
+nz = np.exp(-((z-0.5)/0.1)**2)
+s.add_tracer('NZ', 'source_0', z, nz)
+s.add_tracer('NZ', 'source_1', z, nz)
+
+nu = np.linspace(30, 60, 5)
+bandpass = np.ones(5)
+
+ell = np.linspace(10, 1000, 100)
+beam = np.exp(-0.01 * ell)
+s.add_tracer('NuMap', 'cmb', 2, nu, bandpass, ell, beam)
+
+
+
+
+
+
+
+
+
+# Add window (correct shape)
+ells_large = np.arange(100)
+window_matrix = np.eye(100)  # shape (100, 100)
+win1 = BandpowerWindow(ells_large, window_matrix)
+
+# Add data points, referencing the window object directly
+for i in range(100):
+    s.add_data_point('cl_ee', ('source_0', 'source_1'), 0.1*i, ell=ell[i], window=win1)
+    s.add_data_point('cl_00', ('source_0', 'cmb'), 0.2*i, ell=ell[i], window=win1)
+
+# Add covariance
+n = len(s.data)
+cov = np.eye(n)
+s.add_covariance(cov)
+
+# Write to files
+s.save_fits('demo.fits', overwrite=True)
+s.save_hdf5('demo.hdf5', overwrite=True)

{sacc-1.0.2 → sacc-2.0}/pyproject.toml

@@ -17,7 +17,7 @@ classifiers = [
 
 dependencies = [
     "scipy",
-    "numpy>=1.20",
+    "numpy>=2",
     "astropy"
 ]
 
@@ -37,9 +37,9 @@ Homepage = "https://github.com/LSSTDESC/sacc"
 
 
 [project.optional-dependencies]
-all = ["qp-prob[all]", "numpydoc"]
+all = ["qp-prob[all]>=1", "numpydoc"]
 doc = ["numpydoc"]
-qp = ["qp-prob[all]"]
+qp = ["qp-prob[all]>=1"]
 
 [tool.setuptools.packages.find]
 where = ["."]
@@ -48,5 +48,3 @@ include = ["sacc"]
 [tool.setuptools.dynamic]
 version = {attr = "sacc.__version__"}
 
-[tool.coverage.run]
-relative_paths = true

{sacc-1.0.2 → sacc-2.0}/sacc/__init__.py

@@ -3,4 +3,7 @@ from .windows import Window, BandpowerWindow, TopHatWindow, LogTopHatWindow  # n
 from .data_types import standard_types, parse_data_type_name, build_data_type_name  # noqa
 from .tracers import BaseTracer  # noqa
 from .covariance import BaseCovariance  # noqa
-__version__ = '1.0.2' #noqa
+from .tracer_uncertainty import NZLinearUncertainty, NZShiftUncertainty, NZShiftStretchUncertainty  # noqa
+from .io import BaseIO  # noqa
+from . import io  # noqa
+__version__ = '2.0' #noqa

{sacc-1.0.2 → sacc-2.0}/sacc/covariance.py

@@ -1,12 +1,12 @@
-from astropy.io import fits
 from astropy.table import Table
 import scipy.linalg
 import numpy as np
+import warnings
 
 from .utils import invert_spd_matrix
+from .io import BaseIO, ONE_OBJECT_PER_TABLE, ONE_OBJECT_MULTIPLE_TABLES
 
-
-class BaseCovariance:
+class BaseCovariance(BaseIO):
     """
     The abstract base class for covariances in different forms.
     These are not currently designed to be modified after creation.
@@ -26,7 +26,7 @@ class BaseCovariance:
     cov_type: string
         The type of the covariance (class variable)
     """
-    _covariance_classes = {}
+    _sub_classes = {}
 
     def __init__(self):
         """Abstract superclass constructor.
@@ -37,13 +37,34 @@ class BaseCovariance:
         self._dense = None
         self._dense_inverse = None
 
-    # This method gets called whenever a subclass is
-    # defined.  The keyword argument in the class definition
-    # (e.g. cov_type='full' below is passed to this class method)
-    @classmethod
-    def __init_subclass__(cls, cov_type):
-        cls._covariance_classes[cov_type] = cls
-        cls.cov_type = cov_type
+        # At the moment we only allow one covariance object per table,
+        # so this is only used for consistency when saving objects.
+        self.name = "cov"
+
+    def __eq__(self, other):
+        """
+        Test for equality
+
+        Parameters
+        ----------
+        other: object
+            The other object to test for equality
+
+        Returns
+        -------
+        equal: bool
+            True if the objects are equal
+        """
+        if not isinstance(other, self.__class__):
+            return False
+        # We do not test the inverse; we rely on the fact that
+        # if the dense matrices are equal, then the inverses will be equal.
+        # We are also relying on each subclass to have an instance variable
+        # 'size'.
+        return self.name == other.name and \
+            self.size == other.size and \
+            ((self._dense is None and other._dense is None) or \
+            np.allclose(self._dense, other._dense))
 
     @classmethod
     def from_hdu(cls, hdu):
@@ -64,8 +85,11 @@ class BaseCovariance:
         instance: BaseCovariance
             A covariance instance
         """
+        warnings.warn("You are using an older SACC legacy SACC file format with old covariance data."
+                      " Consider updating it by loading it and saving it again with the latest SACC version.",
+                      DeprecationWarning)
         subclass_name = hdu.header['saccclss']
-        subclass = cls._covariance_classes[subclass_name]
+        subclass = cls._sub_classes[subclass_name]
         return subclass.from_hdu(hdu)
 
     @classmethod
@@ -80,32 +104,29 @@ class BaseCovariance:
         Parameters
         ----------
         cov: list[array] or array
-            If a list, the total length of all the arrays in it
-            should equal n.  If an array, it should be either 1D of
-            length n or 2D of shape (n x n).
+            If a list, it should be a list of array-like objects each of which
+            can be coerced into a 2d array. A BlockDiagonalCovariance will be
+            returned.
 
-        n: int
-            length of the data vector to which this covariance applies
+            If an array, it should be either 1D or 2d and square. Either a
+            DiagonalCovariance or a FullCovariance will be returned.
         """
         if isinstance(cov, list):
-            s = 0
             for block in cov:
                 block = np.atleast_2d(block)
                 if (block.ndim != 2) or (block.shape[0] != block.shape[1]):
                     raise ValueError("Covariance block has wrong size "
                                      f"or shape {block.shape}")
-                s += block.shape[0]
             return BlockDiagonalCovariance(cov)
-        else:
-            cov = np.array(cov).squeeze()
-            if cov.ndim == 0:
-                return DiagonalCovariance(np.atleast_1d(cov))
-            if cov.ndim == 1:
-                return DiagonalCovariance(cov)
-            if (cov.ndim != 2) or (cov.shape[0] != cov.shape[1]):
-                raise ValueError("Covariance is not a 2D square matrix "
-                                 f"- shape: {cov.shape}")
-            return FullCovariance(cov)
+        cov = np.array(cov).squeeze()
+        if cov.ndim == 0:
+            return DiagonalCovariance(np.atleast_1d(cov))
+        if cov.ndim == 1:
+            return DiagonalCovariance(cov)
+        if (cov.ndim != 2) or (cov.shape[0] != cov.shape[1]):
+            raise ValueError("Covariance is not a 2D square matrix "
+                             f"- shape: {cov.shape}")
+        return FullCovariance(cov)
 
     @property
     def dense(self):
@@ -140,7 +161,7 @@ class BaseCovariance:
         return self._dense_inverse
 
 
-class FullCovariance(BaseCovariance, cov_type='full'):
+class FullCovariance(BaseCovariance, type_name='full'):
     """
     A covariance subclass representing a full matrix with correlations
     anywhere.  Represented as an n x n matrix.
@@ -153,15 +174,40 @@ class FullCovariance(BaseCovariance, cov_type='full'):
     covmat: 2D array
         The matrix itself, of shape (size x size)
     """
+
+    storage_type = ONE_OBJECT_PER_TABLE
+
     def __init__(self, covmat):
         self.covmat = np.atleast_2d(covmat)
         self.size = self.covmat.shape[0]
         super().__init__()
 
-    def to_hdu(self):
+    def __eq__(self, other):
+        return super().__eq__(other) and \
+            np.allclose(self.covmat, other.covmat)
+
+    @classmethod
+    def from_hdu(cls, hdu):
+        """
+
+        Load a covariance object from the data in the HDU
+        LEGACY METHOD: new sacc files will use from_table
+
+        Parameters
+        ----------
+        hdu: astropy.fits.ImageHDU instance
+
+        Returns
+        -------
+        cov: FullCovariance
+            Loaded covariance object
+        """
+        C = hdu.data
+        return cls(C)
+
+    def to_table(self):
         """
-        Make an astropy FITS HDU object with this covariance in it.
-        This is represented as an image.
+        Make an astropy table object with this covariance in it.
 
         Parameters
         ----------
@@ -169,32 +215,33 @@ class FullCovariance(BaseCovariance, cov_type='full'):
 
         Returns
         -------
-        hdu: astropy.fits.ImageHDU instance
-            HDU that can be used to reconstruct the object.
+        table: astropy.table.Table instance
+            Table that can be used to reconstruct the object.
         """
-        hdu = fits.ImageHDU(self.covmat)
-        hdu.header['EXTNAME'] = 'covariance'
-        hdu.header['SACCTYPE'] = 'cov'
-        hdu.header['SACCCLSS'] = self.cov_type
-        hdu.header['SIZE'] = self.size
-        return hdu
+        col_names = [f'col_{i}' for i in range(self.size)]
+        cols = [self.covmat[i] for i in range(self.size)]
+        table = Table(data=cols, names=col_names)
+        table.meta['SIZE'] = self.size
+        return table
 
     @classmethod
-    def from_hdu(cls, hdu):
+    def from_table(cls, table):
         """
-        Load a covariance object from the data in the HDU
+        Load a covariance object from the data in the table
 
         Parameters
         ----------
-        hdu: astropy.fits.ImageHDU instance
+        table: astropy.table.Table instance
 
         Returns
         -------
         cov: FullCovariance
             Loaded covariance object
         """
-        C = hdu.data
-        return cls(C)
+        size = table.meta['SIZE']
+        covmat = np.array([table[f'col_{i}'] for i in range(size)])
+        return cls(covmat)
+
 
     def keeping_indices(self, indices):
         """
@@ -240,7 +287,7 @@ class FullCovariance(BaseCovariance, cov_type='full'):
         return self.covmat.copy()
 
 
-class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
+class BlockDiagonalCovariance(BaseCovariance, type_name='block'):
     """A covariance subclass representing block diagonal covariances
 
     Block diagonal covariances have sub-blocks that are full dense matrices,
@@ -258,6 +305,9 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
     size: int
         overall total size of the matrix
     """
+
+    storage_type = ONE_OBJECT_MULTIPLE_TABLES
+
     def __init__(self, blocks):
         """Create a BlockDiagonalCovariance object from a list of blocks
 
@@ -271,34 +321,17 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
         self.size = sum(self.block_sizes)
         super().__init__()
 
-    def to_hdu(self):
-        """Write a FITS HDU from the data, ready to be saved.
-
-        The data in the HDU is stored as a single 1 x size image,
-        and the header contains the information needed to reconstruct it.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        hdu: astropy.fits.ImageHDU object
-            HDU containing data and metadata
-        """
-        hdu = fits.ImageHDU(np.concatenate([b.flatten() for b in self.blocks]))
-        hdu.name = 'covariance'
-        hdu.header['sacctype'] = 'cov'
-        hdu.header['saccclss'] = self.cov_type
-        hdu.header['size'] = self.size
-        hdu.header['blocks'] = len(self.blocks)
-        for i, s in enumerate(self.block_sizes):
-            hdu.header[f'size_{i}'] = s
-        return hdu
+    def __eq__(self, other):
+        return super().__eq__(other) and \
+            self.block_sizes == other.block_sizes and \
+            all(np.allclose(b1, b2)
+                for b1, b2
+                in zip(self.blocks, other.blocks))
 
     @classmethod
     def from_hdu(cls, hdu):
         """Read a covariance object from a loaded FITS HDU.
+        LEGACY METHOD: new sacc files will use from_tables
 
         Parameters
         ----------
@@ -320,6 +353,59 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
             blocks.append(B)
         return cls(blocks)
 
+    @classmethod
+    def from_tables(cls, tables):
+        """
+        Load a covariance object from the data in the tables
+
+        Parameters
+        ----------
+        tables: list
+            list of astropy.table.Table instances in block order
+
+        Returns
+        -------
+        cov: BlockDiagonalCovariance
+            Loaded covariance object
+        """
+
+        blocks = []
+        # Get the block count from the first table
+        nblock = list(tables.values())[0].meta['SACCBCNT']
+        for i in range(nblock):
+            table = tables[f'block_{i}']
+            block_size = table.meta['SACCBSZE']
+            cols = [table[f'block_col_{i}'] for i in range(block_size)]
+            blocks.append(np.array(cols))
+        return cls(blocks)
+
+    def to_tables(self):
+        """
+        Make an astropy table object with this covariance in it.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        table: astropy.table.Table instance
+            Table that can be used to reconstruct the object.
+        """
+        tables = {}
+        nblock = len(self.blocks)
+        for j, block in enumerate(self.blocks):
+            b = len(block)
+            col_names = [f'block_col_{i}' for i in range(b)]
+            cols = [block[i] for i in range(b)]
+            table = Table(data=cols, names=col_names)
+            table.meta['SIZE'] = self.size
+            table.meta['SACCBIDX'] = j
+            table.meta['SACCBCNT'] = nblock
+            table.meta['SACCBSZE'] = b
+            tables[f'block_{j}'] = table
+        return tables
+
     def get_block(self, indices):
         """Read a (not necessarily contiguous) sublock of the matrix
 
@@ -378,7 +464,7 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
             blocks = [self.blocks[i][m][:, m] for i, m in
                       enumerate(block_masks)]
             return self.__class__(blocks)
-        elif (np.diff(indices) > 0).all():
+        if (np.diff(indices) > 0).all():
             s = 0
             sub_blocks = []
             for block, sz in zip(self.blocks, self.block_sizes):
@@ -387,10 +473,9 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
                 sub_blocks.append(block[m][:, m])
                 s += sz
             return self.__class__(sub_blocks)
-        else:
-            C = scipy.linalg.block_diag(*self.blocks)
-            C = C[indices][:, indices]
-            return FullCovariance(C)
+        C = scipy.linalg.block_diag(*self.blocks)
+        C = C[indices][:, indices]
+        return FullCovariance(C)
 
     def _get_dense_inverse(self):
         # Invert all the blocks individually and then
@@ -405,7 +490,7 @@ class BlockDiagonalCovariance(BaseCovariance, cov_type='block'):
         return scipy.linalg.block_diag(*self.blocks)
 
 
-class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
+class DiagonalCovariance(BaseCovariance, type_name='diagonal'):
     """A covariance subclass representing covariances that are
     purely diagonal.
 
@@ -417,6 +502,9 @@ class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
     diag: array
         The diagonal terms in the covariance (i.e. the variances)
     """
+
+    storage_type = ONE_OBJECT_PER_TABLE
+
     def __init__(self, variances):
         """
         Create a DiagonalCovariance object from the variances
@@ -431,26 +519,10 @@ class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
         self.size = len(self.diag)
         super().__init__()
 
-    def to_hdu(self):
-        """
-        Make an astropy FITS HDU object with this covariance in it.
-        In this can a binary table HDU is created.
+    def __eq__(self, other):
+        return super().__eq__(other) and \
+            np.allclose(self.diag, other.diag)
 
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        hdu: astropy.fits.BinTableHDU instance
-            HDU that can be used to reconstruct the object.
-        """
-        table = Table(names=['variance'], data=[self.diag])
-        hdu = fits.table_to_hdu(table)
-        hdu.name = 'covariance'
-        hdu.header['sacctype'] = 'cov'
-        hdu.header['saccclss'] = self.cov_type
-        return hdu
 
     def keeping_indices(self, indices):
         """
@@ -472,6 +544,40 @@ class DiagonalCovariance(BaseCovariance, cov_type='diagonal'):
         D = self.diag[indices]
         return self.__class__(D)
 
+    @classmethod
+    def from_table(cls, table):
+        """
+        Load a covariance object from the data in the table
+
+        Parameters
+        ----------
+        table: astropy.table.Table instance
+
+        Returns
+        -------
+        cov: DiagonalCovariance
+            Loaded covariance object
+        """
+        D = table['variance']
+        return cls(D)
+
+    def to_table(self):
+        """
+        Make an astropy table object with this covariance in it.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        table: astropy.table.Table instance
+            Table that can be used to reconstruct the object.
+        """
+        table = Table(data=[self.diag], names=['variance'])
+        table.meta['SIZE'] = self.size
+        return table
+
     @classmethod
     def from_hdu(cls, hdu):
         """