pywiggle 0.1.3__tar.gz

pywiggle-0.1.3/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,16 @@
+* pywiggle version:
+* Python version:
+* Operating System:
+
+### Description
+
+Describe what you were trying to get done.
+Tell us what happened, what went wrong, and what you expected to happen.
+
+### What I Did
+
+```
+Paste the command(s) you ran and the output.
+If there was a crash, please include the traceback here.
+For long outputs, use https://pastebin.com/
+```

pywiggle-0.1.3/.github/workflows/build.yml

@@ -0,0 +1,187 @@
+name: Build
+
+on: [push, pull_request]
+
+jobs:
+         
+  test-linux:
+    name: "Run tests on Linux"
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python: ["3.13", "3.12", "3.11", "3.10"]
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      
+      - name: Run Tests (Linux)
+        run: |
+          python -m pip install --upgrade pip setuptools wheel meson ninja meson-python numpy scipy pybind11
+          python -m pip install --no-build-isolation --editable '.[test]'
+          pytest --cov --cov-report html --cov-report xml --cov-report annotate -sx
+          
+      - uses: codecov/codecov-action@v2
+        with:
+          verbose: true # optional (default = false)
+          
+  build_wheels_ubuntu:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        # macos-13 is an intel runner, macos-14 is apple silicon
+        os: [ubuntu-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+        
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.23.3
+        env:
+          CIBW_SKIP: "pp* *-musllinux*" # TODO: Temporary
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_wheels_macos:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-13   # Intel → x86_64 wheel
+            cibw_arch: x86_64
+          - os: macos-14   # Apple-Silicon → arm64 wheel
+            cibw_arch: arm64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # ---------- 1 · compiler + single OpenMP runtime ---------- #
+      - name: Install LLVM + libomp
+        run: |
+          brew install llvm libomp          # unversioned, current LLVM 18.x
+          LLVM_PREFIX="$(brew --prefix llvm)"
+
+          # put clang/clang++ first in PATH
+          echo "PATH=${LLVM_PREFIX}/bin:$PATH" >> "$GITHUB_ENV"
+          echo "CC=${LLVM_PREFIX}/bin/clang"   >> "$GITHUB_ENV"
+          echo "CXX=${LLVM_PREFIX}/bin/clang++" >> "$GITHUB_ENV"
+
+          # headers & linker path for the system libomp
+          echo "CPPFLAGS=-I${LLVM_PREFIX}/include" >> "$GITHUB_ENV"
+          echo "LDFLAGS=-L${LLVM_PREFIX}/lib -lomp \
+                       -Wl,-rpath,@loader_path \
+                       -Wl,-rpath,${LLVM_PREFIX}/lib" >> "$GITHUB_ENV"
+
+      # ---------- 2 · build wheel & leave libomp OUT ---------- #
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.23.3
+        env:
+          CIBW_ARCHS_MACOS: ${{ matrix.cibw_arch }}
+          CIBW_SKIP: "pp*" # TODO: Temporary
+
+          # compile with OpenMP flags
+          CIBW_ENVIRONMENT_MACOS: |
+            CFLAGS="-O3 -fopenmp"
+            CXXFLAGS="-O3 -fopenmp"
+            FFLAGS="-O3 -fopenmp=libomp"
+            LDFLAGS="${LDFLAGS}"
+
+          CIBW_REPAIR_WHEEL_COMMAND_MACOS: >
+            delocate-wheel -w {dest_dir}
+            -e libomp.dylib
+            --require-archs x86_64,arm64
+            {wheel}
+
+
+          MACOSX_DEPLOYMENT_TARGET: "13.0"
+
+        with:
+          output-dir: wheelhouse
+
+      # ---------- 3 · upload artefact ---------- #
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.cibw_arch }}
+          path: wheelhouse/*.whl
+
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        name: Install Python
+        with:
+          python-version: '3.10'
+
+      - name: Build sdist
+        run: |
+          python -m pip install -U pip
+          python -m pip install -U setuptools
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install numpy pybind11 scipy
+          python -m pip install build
+          python -m build . --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  upload_pypi:
+    needs: [build_wheels_ubuntu, build_sdist, build_wheels_macos]
+    runs-on: ubuntu-latest
+    # upload to PyPI on every tag starting with 'v'
+    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')
+    # alternatively, to publish when a GitHub Release is created, use the following rule:
+    # if: github.event_name == 'release' && github.event.action == 'published'
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_TOKEN }}
+          # To test: repository_url: https://test.pypi.org/legacy/
+
+
+  test-wheel:
+    needs: [upload_pypi]
+    name: "Run tests on ${{ matrix.os }} with uploaded wheels"
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-13, macos-14]
+        python: ["3.13", "3.12", "3.11", "3.10"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Install test dependencies and wheel from PyPI
+        run: |
+          python -m pip install --upgrade pip setuptools wheel pytest
+          python -m pip install pywiggle
+          
+      - name: Run Tests
+        run: |
+          pytest --pyargs pywiggle.tests

pywiggle-0.1.3/LICENSE

@@ -0,0 +1,32 @@
+
+
+BSD License
+
+Copyright (c) 2025-2035, Mathew Syriac Madhavacheril.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* 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.
+
+* 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.
+

pywiggle-0.1.3/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.1
+Name: pywiggle
+Version: 0.1.3
+Summary: Fast angular power spectrum estimator
+Author-Email: Mathew Madhavacheril <mathewsyriac@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/msyriac/wiggle
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pybind11>=2.11
+Requires-Dist: healpy
+Requires-Dist: fastgl>=0.1.10
+Requires-Dist: scipy>=1.0
+Provides-Extra: test
+Requires-Dist: pytest-cov>=2.6; extra == "test"
+Requires-Dist: coveralls>=1.5; extra == "test"
+Requires-Dist: pytest>=4.6; extra == "test"
+Requires-Dist: threadpoolctl; extra == "test"
+Description-Content-Type: text/x-rst
+
+``wiggle``
+==========
+
+.. image:: https://github.com/msyriac/wiggle/workflows/Build/badge.svg
+           :target: https://github.com/msyriac/wiggle/actions?query=workflow%3ABuild
+
+.. image:: https://readthedocs.org/projects/pywiggle/badge/?version=latest
+           :target: https://pywiggle.readthedocs.io/en/latest/?badge=latest
+		   :alt: Documentation Status
+
+
+``wiggle`` stands for the WIGner Gauss-Legendre Estimator. This Python package provides a fast implementation of unbiased angular power spectrum estimation of spin-0 and spin-2 fields on the sphere, most commonly encountered in the context of cosmological data analysis.
+
+Typically, estimates of the power spectrum of masked fields involve products of Wigner-3j symbols, which can be factorized into products of Wigner-d matrices and integrated exactly using Gauss-Legendre quadrature. This code provides efficient implementations of this approach to mode decoupling for exact power spectrum estimation, which in the case of binned spectra can be orders of magnitude faster than other approaches (often around a second of compute-time at most).
+
+* Free software: BSD license
+* Documentation: https://pywiggle.readthedocs.io.
+
+
+  
+Installing
+----------
+
+Make sure your ``pip`` tool is up-to-date. To install ``wiggle``, run:
+
+.. code-block:: console
+		
+   $ pip install pywiggle --user
+
+This will install a pre-compiled binary suitable for your system (only Linux and Mac OS X with Python>=3.9 are supported). After installation, make sure to run a test with:
+
+.. code-block:: console
+		
+   $ pytest --pyargs pywiggle.tests
+
+If you require more control over your installation, e.g. using Intel compilers, please see the section below on compiling from source.
+
+Compiling from source (advanced / development workflow)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The easiest way to install from source is to use the ``pip`` tool,
+with the ``--no-binary`` flag. This will download the source distribution
+and compile it for you. Don't forget to make sure you have CXX set
+if you have any problems.
+
+For all other cases, below are general instructions.
+
+First, download the source distribution or ``git clone`` this repository. You
+can work from ``master`` or checkout one of the released version tags (see the
+Releases section on Github). Then change into the cloned/source directory.
+
+Once downloaded, you can install using ``pip install .`` inside the project
+directory. We use the ``meson`` build system, which should be understood by
+``pip`` (it will build in an isolated environment).
+
+We suggest you then test the installation by running the unit tests. You
+can do this by running ``pytest``.
+
+To run an editable install, you will need to do so in a way that does not
+have build isolation (as the backend build system, `meson` and `ninja`, actually
+perform micro-builds on usage in this case):
+
+.. code-block:: console
+   
+   $ pip install --upgrade pip meson ninja meson-python cython numpy pybind11
+   $ pip install  --no-build-isolation --editable .
+
+After installation, make sure to run a test with:
+   
+.. code-block:: console
+   
+   $ pytest
+
+Quick Usage
+-----------
+
+Accurate power spectrum estimation requires you to first convert a pixelated and masked map to its spherical harmonic coefficients. ``wiggle`` does not provide tools for SHTs and expects you to have the ``alm`` coefficients both for the masked fields and the mask itself already in hand.  These can be obtained using a code like ``healpy`` in the case of HEALPix maps or a code like ``pixell`` in the case of rectangular pixelization maps.
+
+If you are interested in accurate power spectra out to some maximum multipole ``lmax``, we recommend you evaluate SHTs out to ``lmax`` for the masked fields, but out to  ``2 lmax`` for the mask itself. With these in hand, you can obtain unbiased power spectra as follows, in the case of a spin-0 field for example:
+
+.. code-block:: python
+		
+		> import pywiggle
+		> import numpy as np
+
+		> lmax = 4000
+		> bin_edges = np.arange(40,lmax,40)
+		
+		> dcls, th_filt = pywiggle.alm2auto_power_spin0(lmax,alm,mask_alm,bin_edges = bin_edges)
+
+
+Here ``dcls`` is the mode-decoupled unbiased power spectrum and ``th_filt`` is a matrix that can be dotted with a theory spectrum to obtain the binned theory to compare the power spectrum to (e.g. for inference):
+    
+		
+.. code-block:: python
+		
+		> chisquare = get_chisquare(dcls,th_filt @ theory_cls,cinv)
+
+While the above function ``alm2auto_power_spin0`` is intended for the auto-spectra of a spin-0 field, many additional convenience functions are provided:
+
+* ``alm2cross_power_spin0``: Cross-power of spin-0 fields (:math:`T_1` x :math:`T_2`)
+* ``alm2auto_power_spin2``: Auto-power of E/B decomposition of spin-2 fields (EE and BB)
+* ``alm2auto_power_spin02``: Auto-power of scalar,E,B fields along with the scalar-E power (TT, EE, BB, TE)
+* ``alm2cross_power_spin2``: Cross-power of E/B decomposition of spin-2 fields (:math:`E_1` x :math:`E_2` and :math:`B_1` x :math:`B_2`)
+* ``alm2cross_power_spin02``: Cross-power of scalar,E/B fields along with the scalar-E power (:math:`T_1` x :math:`T_2`, :math:`E_1` x :math:`E_2` and :math:`B_1` x :math:`B_2`, :math:`T_1` x :math:`E_2`, :math:`T_2` x :math:`E_1`)
+
+Cached workflow
+~~~~~~~~~~~~~~~
+
+The above functions are convenience wrappers around the core class ``Wiggle``, which can be used directly if speed and efficient re-use of cached mode-coupling matrices is important. For example,
+
+.. code-block:: python
+		
+		> w = Wiggle(lmax, bin_edges=bin_edges)
+		# Register the SHT of a mask and identify it with a key
+		> w.add_mask('mt1', mask_alm_t1)
+		# Register another mask
+		> w.add_mask('mt2', mask_alm_p2)
+		# Register a beam to deconvolve from both fields
+		> g.add_beam('b1', beam_fl)
+		# Get the decoupled cross-Cls from the masked field SHTs
+		> ret_TT = g.decoupled_cl(alm_t1, alm_t2, 'mt1', 'mt2', spectype='TT',
+		                          return_theory_filter=False,
+		     			  beam_id1='b1', beam_id2='b1')
+
+This object can then be reused if the same masks are being re-used, which avoids re-calculation of mode-coupling matrices. The interface to ``decoupled_cl`` is flexible enough to allow all auto- and cross- spectra of spin-0 and spin-2 fields.
+
+
+Coming soon
+~~~~~~~~~~~
+
+TB and EB spectra as well as mode-decoupling for purified E/B fiels have not been implemented yet, but are planned to in a future release.
+
+
+Contributions
+-------------
+
+If you have write access to this repository, please:
+
+1. create a new branch
+2. push your changes to that branch
+3. merge or rebase to get in sync with master
+4. submit a pull request on github
+
+If you do not have write access, create a fork of this repository and proceed as described above. 

pywiggle-0.1.3/README.rst

@@ -0,0 +1,145 @@
+``wiggle``
+==========
+
+.. image:: https://github.com/msyriac/wiggle/workflows/Build/badge.svg
+           :target: https://github.com/msyriac/wiggle/actions?query=workflow%3ABuild
+
+.. image:: https://readthedocs.org/projects/pywiggle/badge/?version=latest
+           :target: https://pywiggle.readthedocs.io/en/latest/?badge=latest
+		   :alt: Documentation Status
+
+
+``wiggle`` stands for the WIGner Gauss-Legendre Estimator. This Python package provides a fast implementation of unbiased angular power spectrum estimation of spin-0 and spin-2 fields on the sphere, most commonly encountered in the context of cosmological data analysis.
+
+Typically, estimates of the power spectrum of masked fields involve products of Wigner-3j symbols, which can be factorized into products of Wigner-d matrices and integrated exactly using Gauss-Legendre quadrature. This code provides efficient implementations of this approach to mode decoupling for exact power spectrum estimation, which in the case of binned spectra can be orders of magnitude faster than other approaches (often around a second of compute-time at most).
+
+* Free software: BSD license
+* Documentation: https://pywiggle.readthedocs.io.
+
+
+  
+Installing
+----------
+
+Make sure your ``pip`` tool is up-to-date. To install ``wiggle``, run:
+
+.. code-block:: console
+		
+   $ pip install pywiggle --user
+
+This will install a pre-compiled binary suitable for your system (only Linux and Mac OS X with Python>=3.9 are supported). After installation, make sure to run a test with:
+
+.. code-block:: console
+		
+   $ pytest --pyargs pywiggle.tests
+
+If you require more control over your installation, e.g. using Intel compilers, please see the section below on compiling from source.
+
+Compiling from source (advanced / development workflow)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The easiest way to install from source is to use the ``pip`` tool,
+with the ``--no-binary`` flag. This will download the source distribution
+and compile it for you. Don't forget to make sure you have CXX set
+if you have any problems.
+
+For all other cases, below are general instructions.
+
+First, download the source distribution or ``git clone`` this repository. You
+can work from ``master`` or checkout one of the released version tags (see the
+Releases section on Github). Then change into the cloned/source directory.
+
+Once downloaded, you can install using ``pip install .`` inside the project
+directory. We use the ``meson`` build system, which should be understood by
+``pip`` (it will build in an isolated environment).
+
+We suggest you then test the installation by running the unit tests. You
+can do this by running ``pytest``.
+
+To run an editable install, you will need to do so in a way that does not
+have build isolation (as the backend build system, `meson` and `ninja`, actually
+perform micro-builds on usage in this case):
+
+.. code-block:: console
+   
+   $ pip install --upgrade pip meson ninja meson-python cython numpy pybind11
+   $ pip install  --no-build-isolation --editable .
+
+After installation, make sure to run a test with:
+   
+.. code-block:: console
+   
+   $ pytest
+
+Quick Usage
+-----------
+
+Accurate power spectrum estimation requires you to first convert a pixelated and masked map to its spherical harmonic coefficients. ``wiggle`` does not provide tools for SHTs and expects you to have the ``alm`` coefficients both for the masked fields and the mask itself already in hand.  These can be obtained using a code like ``healpy`` in the case of HEALPix maps or a code like ``pixell`` in the case of rectangular pixelization maps.
+
+If you are interested in accurate power spectra out to some maximum multipole ``lmax``, we recommend you evaluate SHTs out to ``lmax`` for the masked fields, but out to  ``2 lmax`` for the mask itself. With these in hand, you can obtain unbiased power spectra as follows, in the case of a spin-0 field for example:
+
+.. code-block:: python
+		
+		> import pywiggle
+		> import numpy as np
+
+		> lmax = 4000
+		> bin_edges = np.arange(40,lmax,40)
+		
+		> dcls, th_filt = pywiggle.alm2auto_power_spin0(lmax,alm,mask_alm,bin_edges = bin_edges)
+
+
+Here ``dcls`` is the mode-decoupled unbiased power spectrum and ``th_filt`` is a matrix that can be dotted with a theory spectrum to obtain the binned theory to compare the power spectrum to (e.g. for inference):
+    
+		
+.. code-block:: python
+		
+		> chisquare = get_chisquare(dcls,th_filt @ theory_cls,cinv)
+
+While the above function ``alm2auto_power_spin0`` is intended for the auto-spectra of a spin-0 field, many additional convenience functions are provided:
+
+* ``alm2cross_power_spin0``: Cross-power of spin-0 fields (:math:`T_1` x :math:`T_2`)
+* ``alm2auto_power_spin2``: Auto-power of E/B decomposition of spin-2 fields (EE and BB)
+* ``alm2auto_power_spin02``: Auto-power of scalar,E,B fields along with the scalar-E power (TT, EE, BB, TE)
+* ``alm2cross_power_spin2``: Cross-power of E/B decomposition of spin-2 fields (:math:`E_1` x :math:`E_2` and :math:`B_1` x :math:`B_2`)
+* ``alm2cross_power_spin02``: Cross-power of scalar,E/B fields along with the scalar-E power (:math:`T_1` x :math:`T_2`, :math:`E_1` x :math:`E_2` and :math:`B_1` x :math:`B_2`, :math:`T_1` x :math:`E_2`, :math:`T_2` x :math:`E_1`)
+
+Cached workflow
+~~~~~~~~~~~~~~~
+
+The above functions are convenience wrappers around the core class ``Wiggle``, which can be used directly if speed and efficient re-use of cached mode-coupling matrices is important. For example,
+
+.. code-block:: python
+		
+		> w = Wiggle(lmax, bin_edges=bin_edges)
+		# Register the SHT of a mask and identify it with a key
+		> w.add_mask('mt1', mask_alm_t1)
+		# Register another mask
+		> w.add_mask('mt2', mask_alm_p2)
+		# Register a beam to deconvolve from both fields
+		> g.add_beam('b1', beam_fl)
+		# Get the decoupled cross-Cls from the masked field SHTs
+		> ret_TT = g.decoupled_cl(alm_t1, alm_t2, 'mt1', 'mt2', spectype='TT',
+		                          return_theory_filter=False,
+		     			  beam_id1='b1', beam_id2='b1')
+
+This object can then be reused if the same masks are being re-used, which avoids re-calculation of mode-coupling matrices. The interface to ``decoupled_cl`` is flexible enough to allow all auto- and cross- spectra of spin-0 and spin-2 fields.
+
+
+Coming soon
+~~~~~~~~~~~
+
+TB and EB spectra as well as mode-decoupling for purified E/B fiels have not been implemented yet, but are planned to in a future release.
+
+
+Contributions
+-------------
+
+If you have write access to this repository, please:
+
+1. create a new branch
+2. push your changes to that branch
+3. merge or rebase to get in sync with master
+4. submit a pull request on github
+
+If you do not have write access, create a fork of this repository and proceed as described above. 

pywiggle-0.1.3/meson.build

@@ -0,0 +1,38 @@
+project('pywiggle',
+        ['cpp'],
+        default_options : ['cpp_std=c++17'])
+
+py = import('python').find_installation(pure: false)
+
+
+# Get pybind11 include paths dynamically
+pybind_includes = run_command(py, '-m', 'pybind11', '--includes').stdout().strip().split()
+
+
+inc    = include_directories('src')
+
+sources = files(
+  'src/wiggle.cpp',          
+  'src/wiggle_bindings.cpp', # pybind11 glue
+)
+
+# --- find OpenMP ----------------
+omp_dep = dependency('openmp')
+
+# Enable OpenMP for C++ manually
+add_project_arguments('-fopenmp', language: 'cpp')
+add_project_link_arguments('-fopenmp', language: 'cpp')
+
+
+extension = py.extension_module(
+  '_wiggle',
+  sources             : sources,
+  dependencies        : [omp_dep],
+  cpp_args            : pybind_includes + ['-O3', '-fopenmp'],
+  include_directories : inc,
+  subdir              : 'pywiggle',      
+  install             : true,
+)
+
+# Install the pure-Python package tree itself
+install_subdir('pywiggle', install_dir : py.get_install_dir())

pywiggle-0.1.3/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["meson-python>=0.15", "pybind11>=2.11", "build", "pytest"]
+build-backend = "mesonpy"
+
+[project]
+name = "pywiggle"
+version = "0.1.3"
+description = "Fast angular power spectrum estimator"
+authors = [{name = "Mathew Madhavacheril", email = "mathewsyriac@gmail.com"}]
+readme = "README.rst"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+
+dependencies = [
+    'numpy',
+     "pybind11>=2.11",
+     "healpy",
+    'fastgl>=0.1.10',
+    'scipy>=1.0'
+     ]
+
+[project.optional-dependencies]
+test = [
+    'pytest-cov>=2.6',
+    'coveralls>=1.5',
+    'pytest>=4.6',
+    'threadpoolctl'
+]
+
+
+[project.urls]
+Homepage = "https://github.com/msyriac/wiggle"

pywiggle-0.1.3/pywiggle/__init__.py

@@ -0,0 +1,15 @@
+
+from importlib import import_module as _import_module
+import sys as _sys
+
+
+from . import _wiggle
+from .core import *
+
+
+
+try:
+    from importlib.metadata import version as _get_version
+    __version__ = _get_version(__name__)
+except Exception:          # pragma: no cover
+    __version__ = "0.0.0"