From dc466fbfec6a740c716e29abb4902b0f9ff183c6 Mon Sep 17 00:00:00 2001
From: RoxGamba <rgamba@berkeley.edu>
Date: Thu, 19 Mar 2026 17:06:13 -0700
Subject: [PATCH 1/6] Fixes: change requirements to include sxs, romspline and
 pycbc; choose versions compatible with numpy<2 (for pycbc match)

---
 PyART/__init__.py                 |  3 ---
 PyART/analysis/__init__.py        |  2 --
 PyART/analytic/__init__.py        |  2 --
 PyART/catalogs/__init__.py        |  2 --
 PyART/models/__init__.py          |  2 --
 PyART/numerical/__init__.py       |  2 --
 PyART/utils/__init__.py           |  2 --
 PyART/utils/convert_sxs_to_lvc.py |  2 +-
 examples/match_sxs.py             | 11 ++++++++++-
 requirements.txt                  | 11 +++++++++--
 setup.cfg                         |  3 ++-
 tests/test_gra.py                 |  1 +
 12 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/PyART/__init__.py b/PyART/__init__.py
index 462c39e..f296254 100644
--- a/PyART/__init__.py
+++ b/PyART/__init__.py
@@ -1,7 +1,4 @@
 #!/usr/bin/env python
-from __future__ import absolute_import
-
-__import__("pkg_resources").declare_namespace(__name__)
 
 from . import analysis
 from . import analytic
diff --git a/PyART/analysis/__init__.py b/PyART/analysis/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/analysis/__init__.py
+++ b/PyART/analysis/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/analytic/__init__.py b/PyART/analytic/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/analytic/__init__.py
+++ b/PyART/analytic/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/catalogs/__init__.py b/PyART/catalogs/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/catalogs/__init__.py
+++ b/PyART/catalogs/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/models/__init__.py b/PyART/models/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/models/__init__.py
+++ b/PyART/models/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/numerical/__init__.py b/PyART/numerical/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/numerical/__init__.py
+++ b/PyART/numerical/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/utils/__init__.py b/PyART/utils/__init__.py
index f5ba105..8b13789 100644
--- a/PyART/utils/__init__.py
+++ b/PyART/utils/__init__.py
@@ -1,3 +1 @@
-from __future__ import absolute_import
 
-__import__("pkg_resources").declare_namespace(__name__)
diff --git a/PyART/utils/convert_sxs_to_lvc.py b/PyART/utils/convert_sxs_to_lvc.py
index f5abad7..d696f28 100644
--- a/PyART/utils/convert_sxs_to_lvc.py
+++ b/PyART/utils/convert_sxs_to_lvc.py
@@ -731,7 +731,7 @@ def convert_simulation(
     The option resolution is an integer labeling the resolution of the
     converted waveform. Modes is an array of the format
     [[l1, m1], [l2, m2], ...] listing the l,m modes to convert. This function
-    outputs a file in LVC format named SXS_BBH_\#\#\#\#_Res\#.h5
+    outputs a file in LVC format named SXS_BBH_####_Res#.h5
     in out_path."""
     horizons = h5py.File(sxs_data_path + "/Horizons.h5", "r")
     rhOverM = h5py.File(sxs_data_path + "/rhOverM_Asymptotic_GeometricUnits_CoM.h5")
diff --git a/examples/match_sxs.py b/examples/match_sxs.py
index 826628d..da5afc1 100644
--- a/examples/match_sxs.py
+++ b/examples/match_sxs.py
@@ -5,6 +5,9 @@
 from PyART.models import teob
 from PyART.analysis.match import Matcher
 from PyART.utils import utils as ut
+from PyART.logging_config import setup_logging
+
+setup_logging(level="INFO")
 
 matplotlib.rc("text", usetex=True)
 
@@ -39,7 +42,13 @@
 # load (or download) SXS data
 sxs_id = f"{args.sxs_id:04}"  # e.g.0180
 nr = sxs.Waveform_SXS(
-    path=sxs_path, download=True, ID=sxs_id, order="Extrapolated_N3.dir", ellmax=7
+    path=sxs_path,
+    download=True,
+    ID=sxs_id,
+    ellmax=7,
+    ignore_deprecation=True,
+    downloads=["hlm", "metadata", "horizons"],
+    load=["hlm", "metadata", "horizons"],
 )
 nr.cut(300)
 # nr.compute_hphc()
diff --git a/requirements.txt b/requirements.txt
index 827a637..e67385e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,6 @@
 # Requirements for most basic library
+# Note: numpy<2.0 required — pycbc>=2.4.0 uses np.array(..., copy=False) which
+# changed semantics in numpy 2.x and raises ValueError at runtime.
 numpy>=1.16.0,<2.0,!=1.19.0
 scipy>=1.13.0
 rich>=13.7.0
@@ -8,11 +10,16 @@ astropy>=5.0.0
 setuptools
 
 # GW package dependencies
-# pycbc>=2.4.0
+pycbc>=2.4.0
 # teobresums>=4.4.0
 # gw-eccentricity>=1.0.4
 # mayawaves>=2024.4.25
-# lalsuite>=7.22
+lalsuite>=7.22
+
+# SXS catalog support (optional; needed for downloading SXS simulations)
+# sxs>=2025.0 requires numpy>=2.0 which is incompatible with pycbc; pin <2025
+sxs>=2024.0.0,<2025.0
+romspline
 
 # Documentation
 sphinx>=4.2.0
diff --git a/setup.cfg b/setup.cfg
index 82d4c24..1e05e46 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -16,6 +16,7 @@ classifiers =
     Programming Language :: Python :: 3.9
     Programming Language :: Python :: 3.10
     Programming Language :: Python :: 3.11
+    Programming Language :: Python :: 3.12
     Topic :: Scientific/Engineering :: Astronomy
     Topic :: Scientific/Engineering :: Physics
     Natural Language :: English
@@ -24,4 +25,4 @@ classifiers =
 [options]
 packages = find:
 install_requires = file: requirements.txt
-python_requires = >=3.9
+python_requires = >=3.9,<3.13
diff --git a/tests/test_gra.py b/tests/test_gra.py
index 60363aa..fd3d649 100644
--- a/tests/test_gra.py
+++ b/tests/test_gra.py
@@ -19,6 +19,7 @@ def test_gra():
         res="128",
         downloads=["hlm", "metadata"],
         ext="CCE",
+        r_ext="50.00",
     )
     # check attributes
     assert wf.ID == "0001"

From cba6f1171600a9e2317a49c824d71a678ae3cf7f Mon Sep 17 00:00:00 2001
From: RoxGamba <rgamba@berkeley.edu>
Date: Thu, 19 Mar 2026 18:39:33 -0700
Subject: [PATCH 2/6] Fix: apply patch to pycbc after installation for
 compatibility with np > 2

---
 .github/workflows/tests.yml   |  8 ++-
 README.md                     |  8 +++
 requirements.txt              | 10 ++--
 scripts/patch_pycbc_numpy2.py | 96 +++++++++++++++++++++++++++++++++++
 setup.py                      | 32 +++++++++++-
 5 files changed, 146 insertions(+), 8 deletions(-)
 create mode 100644 scripts/patch_pycbc_numpy2.py

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 8efdd57..acaf7b5 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -26,8 +26,12 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-        pip install flake8 pytest 'sxs==2025.0.9' romspline pycbc requests bs4
+        pip install -r requirements.txt
+        pip install flake8 pytest
+        pip install -e .
+    - name: Apply pycbc numpy 2.x compatibility patch
+      run: |
+        python scripts/patch_pycbc_numpy2.py
     #- name: Lint with flake8
     #  run: |
         # stop the build if there are Python syntax errors or undefined names
diff --git a/README.md b/README.md
index 9c01ea8..0843591 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,14 @@ Install with
 pip install .
 ```
 
+> **Note:** PyART depends on `pycbc`, which currently has two incompatibilities with numpy 2.x.
+> After installing, apply the one-time patch:
+> ```
+> python scripts/patch_pycbc_numpy2.py
+> ```
+> This patches `pycbc`'s `events/threshold_cpu.py` and `filter/matchedfilter.py`
+> in-place. It is idempotent and safe to re-run after pycbc upgrades.
+
 ## For developers
 
 If you are a developer:
diff --git a/requirements.txt b/requirements.txt
index e67385e..c372a1a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,8 @@
 # Requirements for most basic library
-# Note: numpy<2.0 required — pycbc>=2.4.0 uses np.array(..., copy=False) which
-# changed semantics in numpy 2.x and raises ValueError at runtime.
-numpy>=1.16.0,<2.0,!=1.19.0
+# Note: pycbc>=2.4.0 uses np.array(..., copy=False) which changed semantics in
+# numpy 2.x. After installing, apply the one-time patch:
+#     python scripts/patch_pycbc_numpy2.py
+numpy>=2.0
 scipy>=1.13.0
 rich>=13.7.0
 matplotlib>=3.7.3
@@ -17,8 +18,7 @@ pycbc>=2.4.0
 lalsuite>=7.22
 
 # SXS catalog support (optional; needed for downloading SXS simulations)
-# sxs>=2025.0 requires numpy>=2.0 which is incompatible with pycbc; pin <2025
-sxs>=2024.0.0,<2025.0
+sxs>=2025.0
 romspline
 
 # Documentation
diff --git a/scripts/patch_pycbc_numpy2.py b/scripts/patch_pycbc_numpy2.py
new file mode 100644
index 0000000..a200d75
--- /dev/null
+++ b/scripts/patch_pycbc_numpy2.py
@@ -0,0 +1,96 @@
+"""
+Patch pycbc for numpy 2.x compatibility.
+
+pycbc <= 2.10.0 has two numpy 2.x incompatibilities:
+
+  1. events/threshold_cpu.py: np.array(..., copy=False) raises ValueError in
+     numpy 2.x when a copy is required; numpy.asarray() preserves the original
+     numpy 1.x semantics (copy only if necessary, silently).
+
+  2. filter/matchedfilter.py: numpy.real(x) / numpy.imag(x) dispatch via
+     x.real / x.imag. On pycbc Array objects these are plain methods, not
+     properties, so numpy.real() returns the bound method instead of the data.
+     Replacing with numpy.asarray(x).real / .imag forces conversion via
+     Array.__array__ first, which is safe and localized to the affected calls.
+
+Run once after installing pycbc:
+    python scripts/patch_pycbc_numpy2.py
+"""
+
+import inspect
+import re
+import shutil
+import sys
+from pathlib import Path
+
+
+def _clear_cache(path):
+    cache_dir = path.parent / "__pycache__"
+    if cache_dir.exists():
+        shutil.rmtree(cache_dir)
+        print(f"  Cleared __pycache__ in {cache_dir.parent.name}/")
+
+
+def patch_threshold_cpu():
+    try:
+        import pycbc.events.threshold_cpu as mod
+    except ImportError:
+        print("pycbc not found – nothing to patch.", file=sys.stderr)
+        sys.exit(1)
+
+    path = Path(inspect.getfile(mod))
+    src = path.read_text()
+    original = src
+
+    src = src.replace(
+        "numpy.array(series.data, copy=False, dtype=numpy.complex64)",
+        "numpy.asarray(series.data, dtype=numpy.complex64)",
+    )
+    src = re.sub(
+        r"numpy\.array\(series\.data,\s*copy=False,\s*\n(\s*)dtype=numpy\.complex64\)",
+        r"numpy.asarray(series.data,\n\1dtype=numpy.complex64)",
+        src,
+    )
+
+    if src == original:
+        print("threshold_cpu.py: already patched or pattern not found, skipping.")
+    else:
+        path.write_text(src)
+        _clear_cache(path)
+        print("threshold_cpu.py: patched (copy=False → asarray).")
+
+
+def patch_matchedfilter():
+    try:
+        import pycbc.filter.matchedfilter as mod
+    except ImportError:
+        print("pycbc not found – nothing to patch.", file=sys.stderr)
+        sys.exit(1)
+
+    path = Path(inspect.getfile(mod))
+    src = path.read_text()
+    original = src
+
+    replacements = [
+        ("numpy.real(hplus)", "numpy.asarray(hplus).real"),
+        ("numpy.real(hcross)", "numpy.asarray(hcross).real"),
+        ("numpy.imag(hplus)", "numpy.asarray(hplus).imag"),
+        ("numpy.imag(hcross)", "numpy.asarray(hcross).imag"),
+        ("numpy.real(hphccorr)", "numpy.asarray(hphccorr).real"),
+        ("numpy.real(hplus_cross_corr)", "numpy.asarray(hplus_cross_corr).real"),
+    ]
+    for old, new in replacements:
+        src = src.replace(old, new)
+
+    if src == original:
+        print("matchedfilter.py: already patched or pattern not found, skipping.")
+    else:
+        path.write_text(src)
+        _clear_cache(path)
+        n = sum(1 for a, b in zip(original.splitlines(), src.splitlines()) if a != b)
+        print(f"matchedfilter.py: patched ({n} lines changed).")
+
+
+if __name__ == "__main__":
+    patch_threshold_cpu()
+    patch_matchedfilter()
diff --git a/setup.py b/setup.py
index 7fada01..467517c 100644
--- a/setup.py
+++ b/setup.py
@@ -3,10 +3,36 @@
 setup.py file for GWforge package
 """
 
-from setuptools import setup, find_packages
+from setuptools import setup, find_packages, Command
+from setuptools.command.install import install
+from setuptools.command.develop import develop
 import os
 
 
+PATCH_MESSAGE = """
+============================================================
+  PyART post-install step required
+------------------------------------------------------------
+  pycbc <= 2.10.0 is incompatible with numpy 2.x.
+  Run the following command once to patch pycbc in-place:
+
+      python scripts/patch_pycbc_numpy2.py
+
+  The patch is idempotent and safe to re-run after pycbc
+  upgrades.
+============================================================
+"""
+
+
+def print_patch_notice(command_cls):
+    class Patched(command_cls):
+        def run(self):
+            super().run()
+            print(PATCH_MESSAGE)
+
+    return Patched
+
+
 def find_files(
     dirname,
     relpath=None,
@@ -52,6 +78,10 @@ def find_paths(directory):
 ignore_files = [".DS_Store", "*.pyc", "Thumbs.db", "*.sqlite", "*.swp", "*.env", ".env"]
 
 setup(
+    cmdclass={
+        "install": print_patch_notice(install),
+        "develop": print_patch_notice(develop),
+    },
     scripts=find_files(
         "bin/", relpath="./", ignore_dirs=ignore_dirs, ignore_files=ignore_files
     ),

From 1ff01827f44fcc2e22e81acccfefc4207ee51e3d Mon Sep 17 00:00:00 2001
From: RoxGamba <rgamba@berkeley.edu>
Date: Sun, 29 Mar 2026 21:31:59 -0700
Subject: [PATCH 3/6] Feat: interface to load and use PNPedia

---
 PyART/analytic/pnpedia.py           | 387 ++++++++++++++++++++++++++++
 docs/source/tutorials/pnpedia.ipynb | 161 ++++++++++++
 tests/test_pnpedia.py               | 150 +++++++++++
 3 files changed, 698 insertions(+)
 create mode 100644 PyART/analytic/pnpedia.py
 create mode 100644 docs/source/tutorials/pnpedia.ipynb
 create mode 100644 tests/test_pnpedia.py

diff --git a/PyART/analytic/pnpedia.py b/PyART/analytic/pnpedia.py
new file mode 100644
index 0000000..0ad2997
--- /dev/null
+++ b/PyART/analytic/pnpedia.py
@@ -0,0 +1,387 @@
+import numpy as np
+import sympy as sp
+import os
+import logging
+from sympy.parsing.mathematica import parse_mathematica
+
+x = sp.symbols("x")
+
+
+class PNPedia(object):
+    """
+    Class to interact with the PNPedia repository, which contains a collection of PN quantities relevant for
+    GW modeling etc.
+        https://github.com/davidtrestini/PNpedia
+
+    The class provides methods to retrieve and evaluate PN quantities based on their names and the desired PN order.
+    """
+
+    def __init__(self, path, dowload=False):
+        """
+        Initializes the PNPedia class.
+
+        Parameters
+        ----------
+        path : str
+            The path to the local copy of the PNPedia repository.
+        dowload : bool, optional
+            If True, downloads the PNPedia repository from GitHub. Default is False.
+        """
+        self.path = path
+        if dowload:
+            self.download_pnpedia()
+        self.__parse_pnpedia()
+
+    def download_pnpedia(self):
+        """
+        Clone the PNPedia repository from GitHub using git
+        to a specified path. This method requires git to be installed on the system and accessible via the command line.
+        """
+        import subprocess
+
+        # check if the path already exists
+        if os.path.exists(self.path):
+            logging.info(
+                f"PNPedia repository already exists at {self.path}. Skipping download."
+            )
+            return
+        else:
+            logging.info("Cloning PNPedia repository from GitHub...")
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "https://github.com/davidtrestini/PNpedia.git",
+                    self.path,
+                ]
+            )
+            logging.info(f"PNPedia repository cloned to {self.path}")
+
+    def __parse_pnpedia(self):
+        """
+        Internal method to setup the structure of the PNPedia repository and create a dictionary
+        mapping the paths and names of the PN quantities to a dictionary for easy retrieval/evaluation.
+        """
+
+        pnpedia_structure = {}
+        # Walk through the directory structure and populate the dictionary
+        for root, dirs, files in os.walk(self.path):
+            for file in files:
+                if file.endswith(".txt"):
+                    quantity_name = file[:-4]  # Remove the .txt extension
+                    # save the full path to the quantity in the dictionary
+                    # use as key the quantity name and directory structure to allow for easy retrieval
+                    structure = (
+                        root.replace(self.path, "")[1:]
+                        .replace("/", "_")
+                        .replace(" ", "-")
+                        .strip()
+                        .lower()
+                    )
+                    quantity_name = quantity_name.lower()
+                    key = quantity_name
+                    if structure:
+                        key = f"{structure}_{quantity_name}"
+                    pnpedia_structure[key] = os.path.join(root, file)
+
+        self.pnpedia_structure = pnpedia_structure
+        logging.info("PNPedia structure parsed successfully.")
+
+    def get_pn_quantity(self, name, order, path=None, variable="x"):
+        """
+        Retrieve a PN quantity from PNPedia based on its name and the desired PN order.
+
+        The PNPedia structure (inside Core post-Newtonian quantities) is:
+        - orbit type (Circular, Elliptic, Hyperbolic)
+        - Spin (NonSpinning, Spinning)
+        - Precession (Precessing, Nonprecessing)
+        - Tides (With tidal effects, Without tidal effects)
+        - Quantity (Waveform, Fluxes, Constants of motion, Waveform frequencies):
+            - Constants of motion (Energy, Angular momentum)
+            - Fluxes (Angular momentum flux, Energy flux)
+            - Waveform (h_l_m.txt)
+
+        We load the quantities (that are stored as Mathematica-readable text files) using sympy,
+        which can parse the Mathematica syntax and convert it to Python expressions.
+
+        Parameters
+        ----------
+        name : str
+            The name of the PN quantity to retrieve,
+        order : str
+            The desired PN order (e.g., "1", "2", "3", etc.)
+        path : str, optional
+            The path to the PNPedia file to be loaded. If None, it will be constructed based on the name and order.
+
+        Returns
+        -------
+        sympy expression
+            The requested PN quantity as a sympy expression.
+        """
+
+        if path is None:
+            # Construct the path based on the name and order
+            # Select the right key from the pnpedia_structure dictionary based on the name
+            # if there are multiple matches, raise an error and ask the user to specify more details (e.g., orbit type, spin, precession, tides)
+            # split the various components of the name and order to construct the key
+            name = name.lower()
+            name_pieces = name.split("_")
+
+            matches = []
+            for key in self.pnpedia_structure.keys():
+                key_lower = key.lower()
+                key_terms = key_lower.replace("-", "_").split("_")
+                for piece in name_pieces:
+                    if piece not in key_terms:
+                        break
+                else:
+                    matches.append(key)
+
+            if len(matches) == 0:
+                raise ValueError(
+                    f"No matches found for quantity name '{name}' in PNPedia structure."
+                )
+            elif len(matches) > 1:
+                raise ValueError(
+                    f"Multiple matches found for quantity name '{name}' in PNPedia structure: {matches}. Please specify more details (e.g., orbit type, spin, precession, tides)."
+                )
+            else:
+                path = self.pnpedia_structure[matches[0]]
+        else:
+            logging.info(f"Loading PN quantity from {path}...")
+
+        with open(path, "r") as file:
+            content = file.read()
+
+        # Parse the Mathematica expression using sympy
+        content = self.mathematica_to_python_vars(content)
+        try:
+            pn_quantity = parse_mathematica(content)
+        except Exception as e:
+            logging.warning(
+                "parse_mathematica failed for %s; falling back to sympy.sympify: %s",
+                path,
+                e,
+            )
+            content_py = content.replace("[", "(").replace("]", ")").replace("^", "**")
+            pn_quantity = sp.sympify(content_py)
+
+        # determine the symbol used for PN counting
+        if isinstance(variable, str):
+            x_symbol = sp.symbols(variable)
+        elif isinstance(variable, sp.Symbol):
+            x_symbol = variable
+        else:
+            raise TypeError("variable must be a string or a sympy.Symbol")
+
+        # handle log terms by replacing them with a dummy function that can
+        # be expanded in series
+        pn_quantity = pn_quantity.replace(sp.log(x_symbol), sp.symbols("logx0"))
+
+        # Expand to expose separate x powers in each term for correct truncation
+        pn_quantity = sp.expand(pn_quantity)
+
+        min_order, max_order = self._get_x_power_range(pn_quantity, x_symbol)
+        max_pn_order = max_order - min_order
+
+        requested_pn_order = sp.Rational(order)
+        if requested_pn_order > max_pn_order:
+            logging.warning(
+                f"Requested PN order {order} is higher than the maximum available order {max_pn_order} for this quantity. Returning up to available order {max_pn_order}."
+            )
+
+        target_order_power = min_order + requested_pn_order
+
+        truncated_terms = []
+        for term in pn_quantity.as_ordered_terms():
+            term_power = self._get_x_exponent(term, x_symbol)
+            if term_power <= target_order_power:
+                truncated_terms.append(term)
+
+        pn_quantity = sum(truncated_terms) if truncated_terms else sp.Integer(0)
+
+        # sub the dummy log function back to log
+        result = pn_quantity.replace(sp.symbols("logx0"), sp.log(x_symbol))
+        return self.pn_to_function(result)
+
+    def _get_x_power_range(self, expr, x_symbol=x):
+        """
+        Determine the minimum and maximum powers of the selected PN symbol in an expression.
+
+        This handles expressions that include factors like log(x) and non-polynomial terms,
+        by capturing only pure x-power factors for the order truncation logic.
+
+        Parameters
+        ----------
+        expr : sympy.Expr
+            Expression to analyze.
+        x_symbol : sympy.Symbol, optional
+            Symbol used for PN counting (default is x).
+
+        Returns
+        -------
+        tuple
+            (min_exponent, max_exponent) where exponent may be int or Rational.
+        """
+        expr = sp.expand(expr)
+
+        if expr == 0:
+            return sp.Integer(0), sp.Integer(0)
+
+        min_exp = None
+        max_exp = None
+
+        for term in expr.as_ordered_terms():
+            exponent = self._get_x_exponent(term, x_symbol)
+
+            if min_exp is None or exponent < min_exp:
+                min_exp = exponent
+            if max_exp is None or exponent > max_exp:
+                max_exp = exponent
+
+        return min_exp, max_exp
+
+    def _get_x_exponent(self, term, x_symbol=x):
+        """Return the total power of the selected PN symbol appearing in a term."""
+        if term == 0:
+            return sp.Integer(0)
+
+        def walk(expr):
+            if expr == x_symbol:
+                return sp.Integer(1)
+            if expr.is_Pow and expr.base == x_symbol:
+                return sp.simplify(expr.exp)
+            if expr.is_Mul:
+                total = sp.Rational(0)
+                for arg in expr.args:
+                    total += walk(arg)
+                return total
+            if expr.is_Add:
+                # For sums, the power of x in the (sub)expression is the maximum
+                # power among the terms (not their sum). This is crucial to avoid
+                # over-counting when an expression is factored, e.g., x*(1 + x + x**2).
+                powers = [walk(arg) for arg in expr.args]
+                return max(powers)
+            return sp.Integer(0)
+
+        return walk(term)
+
+    def pn_to_function(self, expr):
+        """
+        Convert a SymPy PN expression into a Python function.
+
+        Automatically detects all free symbols in the expression.
+
+        Returns:
+            f(*args) -> numeric evaluation
+            symbols -> tuple of symbols in order
+        """
+        # Detect all free symbols in a consistent order
+        symbols = tuple(sorted(expr.free_symbols, key=lambda s: s.name))
+
+        # Create the callable function
+        f = sp.lambdify(symbols, expr, modules="numpy")
+
+        return f, symbols
+
+    def mathematica_to_python_vars(self, expr):
+        """
+        Convert Mathematica variables in a sympy expression to Python variables.
+
+        Parameters
+        ----------
+        expr : sympy expression or str
+            The sympy expression or raw Mathematica string containing Mathematica variables.
+
+        Returns
+        -------
+        str
+            The expression string with Mathematica identifiers converted to Python-friendly names.
+        """
+
+        expr_str = str(expr)
+
+        # Specific, known replacements used in PNPedia files
+        var_mapping = {
+            # Must come before shorter \[Lambda] etc to avoid partial match
+            r"\[Lambda]0'[e]": "lambda0eprime",
+            r"\[Lambda]0[e]": "lambda0e",
+            r"\[Lambda]0'[et]": "lambda0eprimeEt",
+            r"\[Lambda]0[et]": "lambda0eEt",
+            r"\[Lambda]0'[Sqrt[1-\[Iota]]]": "lambda0primeSqrt1miota",
+            r"\[Lambda]0[Sqrt[1-\[Iota]]]": "lambda0Sqrt1miota",
+            r"Derivative[1][\[Lambda]0][Sqrt[1-\[Iota]]]": "Derivative1Lambda0Sqrt1miota",
+            r"\[Lambda]0'[Sqrt[1-j]]": "lambda0primeSqrt1mj",
+            r"\[Lambda]0[Sqrt[1-j]]": "lambda0Sqrt1mj",
+            r"\[CurlyPhi][Sqrt[1-\[Iota]]]": "curlyphiSqrt1miota",
+            r"\[CurlyPhi]'[Sqrt[1-\[Iota]]]": "curlyphiPrimeSqrt1miota",
+            r"Derivative[1][\[CurlyPhi]][Sqrt[1-\[Iota]]]": "Derivative1CurlyphiSqrt1miota",
+            r"\[CurlyPhi][Sqrt[1-j]]": "curlyphiSqrt1mj",
+            r"\[CurlyPhi]'[Sqrt[1-j]]": "curlyphiPrimeSqrt1mj",
+            r"\[CurlyPhi]$tilde[e]": "curlyphiTildeE",
+            r"\[CurlyPhi]$tilde[et]": "curlyphiTildeEt",
+            r"\[CurlyPhi]$tilde'[Sqrt[1-\[Iota]]]": "curlyphiTildePrimeSqrt1miota",
+            r"\[CurlyPhi]$tilde[Sqrt[1-j]]": "curlyphiTildeSqrt1mj",
+            r"\[CurlyPhi]$tilde'[Sqrt[1-j]]": "curlyphiTildePrimeSqrt1mj",
+            r"\[CurlyPhi]$tilde[Sqrt[1-\[Iota]]]": "curlyphiTildeSqrt1miota",
+            r"\[CurlyPhi]$tilde'[e]": "curlyphiTildePrimeE",
+            r"\[Zeta]$tilde[e]": "zetaTildeEt",
+            r"\[Zeta]$tilde[et]": "zetaTildeEt",
+            r"\[Zeta]$tilde[Sqrt[1-j]]": "zetaTildeSqrt1mj",
+            r"\[Zeta]$tilde'[e]": "zetaTildePrimeE",
+            r"\[Zeta]$tilde'[et]": "zetaTildePrimeEt",
+            r"\[Zeta]$tilde'[Sqrt[1-j]]": "zetaTildePrimeSqrt1mj",
+            r"\[Zeta]$tilde[Sqrt[1-\[Iota]]]": "zetaTildeSqrt1miota",
+            r"\[Zeta]$tilde'[Sqrt[1-\[Iota]]]": "zetaTildePrimeSqrt1miota",
+            r"\[Psi]$tilde[e]": "psiTildeE",
+            r"\[Psi]$tilde[e]": "psiTildeEt",
+            r"\[Psi]$tilde[Sqrt[1-j]]": "psiTildeSqrt1mj",
+            r"\[Kappa]$tilde[e]": "kappaTildeE",
+            r"\[Kappa]$tilde'[et]": "kappaTildePrimeEt",
+            r"\[Kappa]$tilde[Sqrt[1-j]]": "kappaTildeSqrt1mj",
+            r"\[Kappa][Sqrt[1-j]]": "kappaSqrt1mj",
+            # Greek letters — plain
+            r"\[Nu]": "nu",
+            r"\[Delta]": "delta",
+            r"\[Epsilon]": "epsilon",
+            r"\[Gamma]": "gamma",
+            r"\[Iota]": "iota",
+            r"\[Theta]": "theta",
+            r"\[Phi]": "phi",
+            r"\[Zeta]": "zeta",
+            r"\[Omega]": "omega",
+            r"\[Pi]": "pi",
+            r"\[Sigma]": "sigma",
+            r"\[Xi]": "xi",
+            r"\[Mu]": "mu",
+            r"\[Rho]": "rho",
+            r"\[Upsilon]": "upsilon",
+            r"\[Kappa]": "kappa",
+            r"\[Tau]": "tau",
+            r"\[Psi]": "psi",
+            r"\[Lambda]": "lambda_",
+            # Curly variants
+            r"\[CurlyEpsilon]": "curlyepsilon",
+            r"\[CurlyPhi]": "curlyphi",
+            r"\[CurlyTheta]": "curlytheta",
+            r"\[CurlyRho]": "curlyrho",
+            r"\[CurlyKappa]": "curlykappa",
+            # Capital variants
+            r"\[CapitalPsi]": "CapitalPsi",
+            r"\[CapitalPhi]": "CapitalPhi",
+            r"\[CapitalDelta]": "CapitalDelta",
+            r"\[CapitalGamma]": "CapitalGamma",
+            r"\[CapitalLambda]": "CapitalLambda",
+            r"\[CapitalOmega]": "CapitalOmega",
+            r"\[CapitalSigma]": "CapitalSigma",
+            r"\[CapitalTheta]": "CapitalTheta",
+            r"\[CapitalXi]": "CapitalXi",
+        }
+
+        # Pre-apply specific mapping in explicit order to avoid partial collisions
+        for math_var, py_var in sorted(
+            var_mapping.items(), key=lambda item: -len(item[0])
+        ):
+            expr_str = expr_str.replace(math_var, py_var)
+
+        return expr_str
diff --git a/docs/source/tutorials/pnpedia.ipynb b/docs/source/tutorials/pnpedia.ipynb
new file mode 100644
index 0000000..369b011
--- /dev/null
+++ b/docs/source/tutorials/pnpedia.ipynb
@@ -0,0 +1,161 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7f0aebb9",
+   "metadata": {},
+   "source": [
+    "# PNPedia example: nonspinning circular binding energy\n",
+    "\n",
+    "This notebook demonstrates how to use `PyART.analytic.pnpedia.PNPedia` to load a PN quantity from the local PNPedia repository and plot it as a function of PN parameter `x`.\n",
+    "\n",
+    "Quantity: `energy_circular_nonspinning_binding` (nonspinning, circular, non-tidal, binding energy).\n",
+    "\n",
+    "The `get_pn_quantity()` call returns a callable and the symbolic argument order."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59e8a8e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PyART.analytic.pnpedia import PNPedia\n",
+    "\n",
+    "# Path to the local PNPedia repository clone (in this repo tree)\n",
+    "pnpedia_path = './PNPedia'\n",
+    "npd = PNPedia(path=pnpedia_path, dowload=True)\n",
+    "\n",
+    "# PN variable x range for circular inspiral (small x region)\n",
+    "x = np.linspace(0.001, 0.3, 400)\n",
+    "\n",
+    "# Evaluate with geometric-like normalized constants, and symmetric mass ratio nu=0.25\n",
+    "# (set G,c,m,b0=1 for demonstration, then tune for physics units as required).\n",
+    "G = np.ones_like(x)\n",
+    "b0 = np.ones_like(x)\n",
+    "c = np.ones_like(x)\n",
+    "m = np.ones_like(x)\n",
+    "nu = 0.25 * np.ones_like(x)\n",
+    "\n",
+    "energy_orders = ['0', '1', '2', '3', '4']\n",
+    "JM_orders = ['0', '1', '2', '3', '4']\n",
+    "\n",
+    "# 1) Plot E(x) for multiple PN truncations\n",
+    "plt.figure(figsize=(9,6))\n",
+    "for order in energy_orders:\n",
+    "    func, symbols = npd.get_pn_quantity('energy_circular_nonspinning_binding', order)\n",
+    "\n",
+    "    value_map = {'G': 1.0, 'b0': 1.0, 'c': 1.0, 'm': 1.0, 'nu': 0.25, 'x': x}\n",
+    "    args = [value_map[str(s)] for s in symbols]\n",
+    "    energy = func(*args)\n",
+    "\n",
+    "    plt.plot(x, energy, lw=1.5, label=f'{order}PN')\n",
+    "\n",
+    "plt.xlabel('x (post-Newtonian parameter)')\n",
+    "plt.ylabel('binding energy (dimensionless, G=c=m=1)')\n",
+    "plt.title('PNPedia: E_binding(x) for nonspinning circular binaries')\n",
+    "plt.grid(True)\n",
+    "plt.legend(ncol=2, fontsize='small')\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# 2) Plot J(x) for multiple PN truncations\n",
+    "plt.figure(figsize=(9,6))\n",
+    "for order in JM_orders:\n",
+    "    func, symbols = npd.get_pn_quantity('angular_momentum_circular_nonspinning_conservative', order)\n",
+    "\n",
+    "    value_map = {'G': 1.0, 'b0': 1.0, 'c': 1.0, 'm': 1.0, 'nu': 0.25, 'x': x}\n",
+    "    args = [value_map[str(s)] for s in symbols]\n",
+    "    angmom = func(*args)\n",
+    "\n",
+    "    plt.plot(x, angmom, lw=1.5, label=f'{order}PN')\n",
+    "\n",
+    "plt.xlabel('x (post-Newtonian parameter)')\n",
+    "plt.ylabel('angular momentum (dimensionless, G=c=m=1)')\n",
+    "plt.title('PNPedia: J_binding(x) for nonspinning circular binaries')\n",
+    "plt.grid(True)\n",
+    "plt.legend(ncol=2, fontsize='small')\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# 3) Joint E(J) plot, choose the 4PN curve as representative\n",
+    "funcE, symE = npd.get_pn_quantity('energy_circular_nonspinning_binding', '4')\n",
+    "funcJ, symJ = npd.get_pn_quantity('angular_momentum_circular_nonspinning_conservative', '4')\n",
+    "E = funcE(*[value_map[str(s)] for s in symE])\n",
+    "J = funcJ(*[value_map[str(s)] for s in symJ])\n",
+    "\n",
+    "plt.figure(figsize=(8,5))\n",
+    "plt.plot(J, E, 'k-', lw=2)\n",
+    "plt.xlabel('J (dimensionless, G=c=m=1)')\n",
+    "plt.ylabel('E_binding (dimensionless, G=c=m=1)')\n",
+    "plt.title('PNPedia: E_binding(J_binding) at 4PN for nonspinning circular binaries')\n",
+    "plt.grid(True)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f838c17",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pyart-dev-3.11",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/test_pnpedia.py b/tests/test_pnpedia.py
new file mode 100644
index 0000000..c9472c2
--- /dev/null
+++ b/tests/test_pnpedia.py
@@ -0,0 +1,150 @@
+from PyART.analytic import pnpedia
+
+
+def test_pnpedia_order_truncation():
+    """Test that PNPedia returns a callable expression truncated to requested PN order."""
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+
+    # Capture the resulting symbolic expression used to build the numeric function
+    captured = {}
+    original_pn_to_function = pnpedia_instance.pn_to_function
+
+    def capture(expr):
+        captured["expr"] = expr
+        return original_pn_to_function(expr)
+
+    pnpedia_instance.pn_to_function = capture
+
+    func, sym = pnpedia_instance.get_pn_quantity(
+        name="energy_circular_nonspinning_binding", order="3"
+    )
+
+    assert callable(func)
+    assert isinstance(sym, tuple)
+
+    assert "expr" in captured
+    expr = captured["expr"]
+
+    # The raw expression should be truncated at most to x^4 for 3PN relative.
+    powers = [
+        t.as_coeff_exponent(pnpedia.sp.symbols("x"))[1] for t in expr.as_ordered_terms()
+    ]
+    assert float(min(powers)) >= 0
+    assert float(max(powers)) <= 4
+
+
+def test_pnpedia_fractional_power_handling():
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+
+    expr = (
+        pnpedia.sp.symbols("x") ** pnpedia.sp.Rational(3, 2)
+        + pnpedia.sp.symbols("x") ** 2
+        + pnpedia.sp.symbols("x") ** pnpedia.sp.Rational(5, 2)
+    )
+
+    min_order, max_order = pnpedia_instance._get_x_power_range(expr)
+    assert min_order == pnpedia.sp.Rational(3, 2)
+    assert max_order == pnpedia.sp.Rational(5, 2)
+
+    term_powers = [
+        pnpedia_instance._get_x_exponent(term) for term in expr.as_ordered_terms()
+    ]
+    assert sorted(term_powers) == [
+        pnpedia.sp.Rational(3, 2),
+        pnpedia.sp.Rational(2),
+        pnpedia.sp.Rational(5, 2),
+    ]
+
+    target_power = pnpedia.sp.Rational(9, 2)
+    selected = sum(
+        term
+        for term in expr.as_ordered_terms()
+        if pnpedia_instance._get_x_exponent(term) <= target_power
+    )
+    assert selected == expr
+
+
+def test_pnpedia_custom_variable_counting():
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+
+    v = pnpedia.sp.symbols("v")
+    expr = v**2 + v ** pnpedia.sp.Rational(5, 2)
+
+    min_order, max_order = pnpedia_instance._get_x_power_range(expr, v)
+    assert min_order == pnpedia.sp.Rational(2)
+    assert max_order == pnpedia.sp.Rational(5, 2)
+
+    term_powers = [
+        pnpedia_instance._get_x_exponent(term, v) for term in expr.as_ordered_terms()
+    ]
+    assert sorted(term_powers) == [pnpedia.sp.Rational(2), pnpedia.sp.Rational(5, 2)]
+
+
+def test_mathematica_to_python_vars_expanded():
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+
+    expr = "x * \\[Nu] + \\[Delta]^2 + \\[Theta] + \\[Lambda]0[e] + \\[Lambda]0'[e] + Sqrt[x] + Log[x]"
+    converted = pnpedia_instance.mathematica_to_python_vars(expr)
+
+    assert "\\[" not in converted
+    assert "nu" in converted
+    assert "delta" in converted
+    assert "theta" in converted
+    assert "lambda0e" in converted
+    assert "lambda0eprime" in converted
+
+    parsed = pnpedia.parse_mathematica(converted)
+    assert parsed.has(pnpedia.sp.symbols("x"))
+
+
+def test_pnpedia_parse_many_files():
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+
+    # Test a reasonable subset to avoid linear full-repo run-time in CI while still covering many expressions.
+    candidates = list(pnpedia_instance.pnpedia_structure.items())[:150]
+
+    failures = []
+    for key, path in candidates:
+        try:
+            func, symbols = pnpedia_instance.get_pn_quantity(
+                name=key, order="1", path=path
+            )
+            assert callable(func)
+            assert isinstance(symbols, tuple)
+        except Exception as exc:
+            failures.append((key, path, str(exc)))
+
+    assert (
+        not failures
+    ), f"PNPedia parse failures in subset: {len(failures)} failures. First: {failures[:3]}"
+
+
+def test_pnpedia_noninteger_order_truncation():
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    captured = {}
+    original_pn_to_function = pnpedia_instance.pn_to_function
+
+    def capture(expr):
+        captured["expr"] = expr
+        return original_pn_to_function(expr)
+
+    pnpedia_instance.pn_to_function = capture
+
+    func, sym = pnpedia_instance.get_pn_quantity(
+        name="energy_circular_nonspinning_binding", order="2.5"
+    )
+
+    assert callable(func)
+    assert isinstance(sym, tuple)
+
+    expr = captured["expr"]
+    powers = [
+        t.as_coeff_exponent(pnpedia.sp.symbols("x"))[1] for t in expr.as_ordered_terms()
+    ]
+
+    assert float(max(powers)) <= 1 + 2.5
+
+
+if __name__ == "__main__":
+    test_pnpedia_order_truncation()
+    test_pnpedia_fractional_power_handling()

From 0060f7894d890496b63746570ba43dd9836a63c6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 30 Mar 2026 04:44:06 +0000
Subject: [PATCH 4/6] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 setup.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/setup.py b/setup.py
index 467517c..ee37bc4 100644
--- a/setup.py
+++ b/setup.py
@@ -8,7 +8,6 @@
 from setuptools.command.develop import develop
 import os
 
-
 PATCH_MESSAGE = """
 ============================================================
   PyART post-install step required

From 9f30e6bdd74cd720a71a5b469e0ca0795d5a7fa3 Mon Sep 17 00:00:00 2001
From: RoxGamba <rgamba@berkeley.edu>
Date: Sun, 29 Mar 2026 21:48:20 -0700
Subject: [PATCH 5/6] Update requirements

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index c372a1a..3550d62 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,6 +9,7 @@ matplotlib>=3.7.3
 pandas>=2.1.4
 astropy>=5.0.0
 setuptools
+sympy
 
 # GW package dependencies
 pycbc>=2.4.0

From d2221ce8875abce8f8f85ea286dd8af840363483 Mon Sep 17 00:00:00 2001
From: RoxGamba <rgamba@berkeley.edu>
Date: Sun, 29 Mar 2026 21:56:25 -0700
Subject: [PATCH 6/6] Fix PNPedia test

---
 tests/test_pnpedia.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/test_pnpedia.py b/tests/test_pnpedia.py
index c9472c2..a9a83b4 100644
--- a/tests/test_pnpedia.py
+++ b/tests/test_pnpedia.py
@@ -3,7 +3,7 @@
 
 def test_pnpedia_order_truncation():
     """Test that PNPedia returns a callable expression truncated to requested PN order."""
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
 
     # Capture the resulting symbolic expression used to build the numeric function
     captured = {}
@@ -34,7 +34,7 @@ def capture(expr):
 
 
 def test_pnpedia_fractional_power_handling():
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
 
     expr = (
         pnpedia.sp.symbols("x") ** pnpedia.sp.Rational(3, 2)
@@ -65,7 +65,7 @@ def test_pnpedia_fractional_power_handling():
 
 
 def test_pnpedia_custom_variable_counting():
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
 
     v = pnpedia.sp.symbols("v")
     expr = v**2 + v ** pnpedia.sp.Rational(5, 2)
@@ -81,7 +81,7 @@ def test_pnpedia_custom_variable_counting():
 
 
 def test_mathematica_to_python_vars_expanded():
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
 
     expr = "x * \\[Nu] + \\[Delta]^2 + \\[Theta] + \\[Lambda]0[e] + \\[Lambda]0'[e] + Sqrt[x] + Log[x]"
     converted = pnpedia_instance.mathematica_to_python_vars(expr)
@@ -98,7 +98,7 @@ def test_mathematica_to_python_vars_expanded():
 
 
 def test_pnpedia_parse_many_files():
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
 
     # Test a reasonable subset to avoid linear full-repo run-time in CI while still covering many expressions.
     candidates = list(pnpedia_instance.pnpedia_structure.items())[:150]
@@ -120,7 +120,7 @@ def test_pnpedia_parse_many_files():
 
 
 def test_pnpedia_noninteger_order_truncation():
-    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=False)
+    pnpedia_instance = pnpedia.PNPedia(path="./PNPedia", dowload=True)
     captured = {}
     original_pn_to_function = pnpedia_instance.pn_to_function