diffpy.srreal 1.5.0__tar.gz → 1.5.1rc0__tar.gz

diffpy_srreal-1.5.1rc0/CHANGELOG.rst

@@ -0,0 +1,184 @@
+=============
+Release notes
+=============
+
+.. current developments
+
+1.5.0
+=====
+
+**Added:**
+
+* Publish self-contained wheels to PyPI for Linux (x86_64),
+macOS (x86_64, arm64) and Windows (AMD64). The wheels link
+Boost.Serialization and GSL statically and install without conda.
+``vcpkg.json`` pins the library versions on all platforms.
+* Add the ``SRREAL_STATIC_DEPS`` CMake option to link Boost.Serialization
+and GSL statically. It is off by default, so conda and system builds
+keep linking the shared libraries.
+* Update citation reference in README and docs.
+
+**Changed:**
+
+* Build the embedded libdiffpy core from a pinned Git submodule. Source
+distributions include the core sources and runtime data for offline builds.
+* Use typed nanobind arrays for numeric input, copied results, and writable
+Atom views. Keep NumPy output types, shapes, native dtypes, and the existing
+scalar-versus-array return conventions.
+* Remove the NumPy C API and build-time NumPy dependency. NumPy remains a
+runtime dependency; wheel Python ABI requirements are unchanged.
+* Retain NumPy-owned writable storage for copied results and explicit storage
+owners for Atom views, including slices retained after structural edits.
+* Preserve endpoint-specific conversion rules, NumPy scalar casting warnings,
+and coordinate/matrix broadcasting. Invalid coordinate/matrix assignments
+no longer partially modify an Atom.
+* updated cpp minimum version to c++23.
+* replaced boost smart pointer usages with stl implementations.
+* Added Python 3.14 support, removed Python 3.11 support.
+* Align the nanobind migration with pyobjcryst issue 101: use scikit-build-core,
+CMake, and pinned upstream libdiffpy sources compiled into the extension.
+Retain C++23 to match libdiffpy's own build requirements.
+* Use pyobjcryst's Python API for Crystal and Molecule conversion, removing
+the build-time libobjcryst dependency and cross-extension C++ ABI coupling.
+* Retain the centralized scikit-package testing, release, and documentation
+workflows and their platform matrix. Download the pinned libdiffpy source
+archive with CMake and verify its SHA-256 checksum, without a Git submodule
+or unsupported shared-workflow inputs. Test the current pyobjcryst migration
+on Linux through the shared post-install hook. Preserve tag-based package
+versions.
+* Structure conversion now returns ordinary atomic or periodic adapters,
+without reading ``pdffit`` metadata. Configure PDF parameters explicitly
+through the existing calculator interfaces.
+* ``nometa()`` returns or converts the source adapter without a proxy.
+``None`` returns the empty adapter.
+* Require nanobind 3.1 or newer within the 3.x series.
+* Use consistent Atom references for indexing and iteration. Surviving atoms
+follow index shifts; removed or replaced atoms detach safely. NumPy views
+retained across structural edits become snapshots; reacquire a view to
+modify the updated structure.
+* Expose calculator component properties directly without preserving the
+``PeakWidthModelOwner`` and ``ScatteringFactorTableOwner`` inheritance
+relationships. Use the calculator's own properties and methods.
+* Use Python ``str`` for text parameters; decode byte strings explicitly.
+Binary serialization payloads remain ``bytes``.
+* Follow nanobind's numerical conversions. Explicitly call ``float(value)``
+when an overridden ``__float__`` must be honored. ``None`` is not accepted
+as numerical input to baselines, envelopes, or scattering-factor lookup.
+* Use value equality and nanobind's representation for ``QuantityType``.
+These mutable containers are unhashable, and slice assignment requires
+an iterable, including for a single replacement value.
+* Interpret ``__getstate_manages_dict__`` by its truth value. Custom pickle
+hooks on guarded classes must preserve Python metadata and set this flag
+to ``True``.
+
+**Deprecated:**
+
+* ``NoMetaStructureAdapter``, retained for saved objects and subclasses.
+Its Python constructor now emits ``DeprecationWarning``. Historical
+metadata adapter classes remain importable for pickle compatibility.
+* Deprecated setScatteringFactorTableByType.
+
+**Fixed:**
+
+* Include libdiffpy's ``LICENSE.rst`` and ``LICENSE_DANSE.rst`` in the
+sdist under their actual file names.
+* Fixed example to pass correct Molecule structure for PDF comparison
+* Use libdiffpy's Windows-compatible runtime data lookup and declarations,
+enable MSVC mathematical constants, and disambiguate tuple restoration
+in calculator pickles.
+* Use ``Lattice.cell_parms`` in place of the deprecated ``Lattice.abcABG`` when converting ``diffpy.structure`` objects to silence deprecation warnings.
+* Use ``load_structure``, ``get_parser``, ``parse_file``, ``read_structure``, ``set_latt_parms``, and ``add_new_atom`` in place of the deprecated ``diffpy.structure`` functions in tests, examples, and docstrings.
+* Fixed `parallelPDF.py` example multiprocessing safe importing of main module issue.
+* Install libdiffpy's ``LICENSE.rst`` and ``LICENSE_DANSE.rst`` instead of the renamed ``LICENSE.txt`` and ``LICENSE_DANSE.txt``.
+* Read strided and reversed integer index arrays in logical order instead of
+treating their storage as contiguous.
+* Interpret byte-swapped FFT inputs and integer index arrays in their actual
+byte order, and safely handle unaligned buffers.
+* Reject integer-array indices outside the C++ ``int`` range with
+``OverflowError`` instead of silently wrapping. These three corrections
+intentionally change erroneous behavior inherited from Boost.Python.
+* Allow structureadapter to be imported before other srreal modules.
+* Support the custom virtual-method dispatch used by both nanobind 2 and 3.
+* Fail pyobjcryst integration tests on conversion errors instead of skipping
+them as if ObjCryst support were unavailable.
+* Reject mismatched libdiffpy revisions when a local Git checkout is supplied
+for an offline build, while preserving Git-free archive builds.
+* Prevent repeated Python calculation callbacks when calling base methods.
+* Restore structure sequence edits and resizing contribution-array slices.
+* Keep retained Atom references and NumPy views safe during structure edits
+and deserialization.
+* Keep public calculator exports callable and configurable, including objects
+loaded from supported Boost.Python pickles.
+* Restore saved structures and Python-defined components, honor subclass
+construction hooks, and guard against accidental metadata loss in custom
+pickle hooks.
+* Accept Python and NumPy truth values in adapter anisotropy callbacks.
+
+**Removed:**
+
+* Remove utils scripts ``devutils`` from the package.
+* Remove the deprecated ``setScatteringFactorTableByType`` method from
+``ScatteringFactorTableOwner``, ``PDFCalculator``, and ``DebyePDFCalculator``.
+* The ``_customPQConfig`` bindings and Python callback dispatch, including
+automatic application of structure metadata to PDF calculators.
+
+
+1.4.0
+=====
+
+**Added:**
+
+* Update linelength to sk-package standard of 79 characters.
+
+**Changed:**
+
+* Renamed CODE_OF_CONDUCTS.rst to CODE-OF-CONDUCTS.rst, doc folder to docs, and requirements/test.txt to requirements/tests.txt
+
+**Fixed:**
+
+* Configure ``black`` to have a linelength requirement of 79 characters.
+* Update requirements to use full release `libdiffpy` and remove wrong build dependencies.
+* Support ``scikit-package`` Level 5 standard (https://scikit-package.github.io/scikit-package/).
+
+
+
+Version 1.3.0  2019-03-13
+=========================
+
+Main differences from version 1.2.
+
+**Added:**
+
+* Support for Python 3.7, 3.6, 3.5 in addition to 2.7.
+* Validation of compiler options from `python-config`.
+* Make scons scripts compatible with Python 3 and Python 2.
+* `ConstantPeakWidth` attributes `uisowidth`, `bisowidth` to ease
+  PDF simulation with uniform isotropic atom displacements.
+
+**Changed:**
+
+* Require libdiffpy 1.4 or later.
+* Build Anaconda package with Anaconda C++ compiler.
+* Allow language standard c++11.
+* Pickle format for `PDFCalculator`, `DebyePDFCalculator`,
+  `OverlapCalculator`, `PeakWidthModel`, `PeakProfile`, `PDFEnvelope`,
+  `PDFBaseline`, and `ScatteringFactorTable` objects.
+
+**Deprecated:**
+
+* Variable `__gitsha__` in the `version` module renamed to `__git_commit__`.
+* `libdiffpy_version_info` attribute `git_sha` renamed to `git_commit`.
+
+**Removed**
+
+* Unused method `BVParam.__hash__`.
+* Disable pickling of `BasePairQuantity` as it is in effect abstract.
+* Pickling of Python-added attributes to exported C++ classes.
+* Function `get_libdiffpy_version_info` from the `version` module.
+
+**Fixed**
+
+* Return value conversion of `CrystalStructureAdapter` methods
+  `expandLatticeAtom` and `getEquivalentAtoms` methods.
+  Make them return a `list` of `Atom` objects.
+* Name suffix resolution of `boost_python` shared library.

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/CMakeLists.txt

@@ -1,13 +1,13 @@
-cmake_minimum_required(VERSION 3.20)
+cmake_minimum_required(VERSION 3.22)
 project(diffpy_srreal LANGUAGES NONE)
 
-# Keep this aligned with the pinned libdiffpy's src/SConscript.
+# Keep this aligned with the pinned libdiffpy's CMakeLists.txt.
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 set(LIBDIFFPY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/extern/libdiffpy")
-if(NOT EXISTS "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/version.tpl")
+if(NOT EXISTS "${LIBDIFFPY_SOURCE_DIR}/CMakeLists.txt")
     message(FATAL_ERROR
         "Missing libdiffpy sources. Initialize the submodule with "
         "'git submodule update --init --recursive', or use a source distribution "
@@ -15,42 +15,28 @@ if(NOT EXISTS "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/version.tpl")
     )
 endif()
 
-# Read version information from the submodule; sdists carry the generated header.
-set(LIBDIFFPY_VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/include/diffpy/version.hpp")
-set(LIBDIFFPY_SDIST_VERSION_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/_build/libdiffpy-version.hpp")
-if(EXISTS "${LIBDIFFPY_SOURCE_DIR}/.git")
-    file(STRINGS "${LIBDIFFPY_SOURCE_DIR}/site_scons/fallback_version.py"
-         LIBDIFFPY_FALLBACK_VERSION REGEX "^FALLBACK_VERSION =")
-    if(NOT LIBDIFFPY_FALLBACK_VERSION MATCHES "([0-9]+)\\.([0-9]+)\\.([0-9]+)")
-        message(FATAL_ERROR "Cannot read the libdiffpy base version.")
-    endif()
-    set(DIFFPY_VERSION_MAJOR "${CMAKE_MATCH_1}")
-    set(DIFFPY_VERSION_MINOR "${CMAKE_MATCH_2}")
-    set(DIFFPY_VERSION_MICRO "${CMAKE_MATCH_3}")
-    set(DIFFPY_VERSION_PATCH 0)
-    set(DIFFPY_VERSION_STR "${DIFFPY_VERSION_MAJOR}.${DIFFPY_VERSION_MINOR}.${DIFFPY_VERSION_MICRO}")
-    math(EXPR DIFFPY_VERSION "${DIFFPY_VERSION_MAJOR} * 1000000000 + ${DIFFPY_VERSION_MINOR} * 1000000 + ${DIFFPY_VERSION_MICRO} * 1000")
-    set(DIFFPY_VERSION "${DIFFPY_VERSION}LL")
-    find_package(Git REQUIRED)
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" -C "${LIBDIFFPY_SOURCE_DIR}" log -1 "--format=%H;%ci"
-        OUTPUT_VARIABLE LIBDIFFPY_COMMIT_INFO
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        COMMAND_ERROR_IS_FATAL ANY
-    )
-    list(GET LIBDIFFPY_COMMIT_INFO 0 DIFFPY_GIT_SHA)
-    list(GET LIBDIFFPY_COMMIT_INFO 1 DIFFPY_VERSION_DATE)
-    configure_file("${LIBDIFFPY_SOURCE_DIR}/src/diffpy/version.tpl"
-                   "${LIBDIFFPY_VERSION_HEADER}")
-else()
-    configure_file("${LIBDIFFPY_SDIST_VERSION_HEADER}"
-                   "${LIBDIFFPY_VERSION_HEADER}" COPYONLY)
-endif()
+# libdiffpy resolves its version from git unless src/diffpy/version.hpp exists,
+# as in its own source distribution. The srreal sdist has no git, so write that
+# header here and ship it.
+set(LIBDIFFPY_SDIST_VERSION_HEADER "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/version.hpp")
 if(SKBUILD_STATE STREQUAL "sdist")
-    configure_file("${LIBDIFFPY_VERSION_HEADER}"
-                   "${LIBDIFFPY_SDIST_VERSION_HEADER}" COPYONLY)
+    # Refresh git checkouts; preserve the header when repacking an sdist.
+    if(EXISTS "${LIBDIFFPY_SOURCE_DIR}/.git" OR
+       NOT EXISTS "${LIBDIFFPY_SDIST_VERSION_HEADER}")
+        include("${LIBDIFFPY_SOURCE_DIR}/cmake/LibdiffpyVersion.cmake")
+        libdiffpy_resolve_version()
+        libdiffpy_write_version_header(
+            "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/version.tpl"
+            "${LIBDIFFPY_SDIST_VERSION_HEADER}")
+    endif()
     return()
 endif()
+# A header left over from a local sdist build would freeze the git checkout's
+# version, so remove it.
+if(EXISTS "${LIBDIFFPY_SOURCE_DIR}/.git" AND EXISTS "${LIBDIFFPY_SDIST_VERSION_HEADER}")
+    message(STATUS "Removing stale ${LIBDIFFPY_SDIST_VERSION_HEADER}")
+    file(REMOVE "${LIBDIFFPY_SDIST_VERSION_HEADER}")
+endif()
 enable_language(CXX)
 
 # Conda is optional; system packages and CMAKE_PREFIX_PATH work as well.
@@ -95,40 +81,30 @@ if(DEFINED _srreal_saved_suffixes)
     endforeach()
 endif()
 
-set(DIFFPY_HAS_OBJCRYST 0)
-configure_file("${LIBDIFFPY_SOURCE_DIR}/src/diffpy/features.tpl"
-               "include/diffpy/features.hpp")
-
-file(GLOB LIBDIFFPY_SOURCES CONFIGURE_DEPENDS
-    "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/*.cpp"
-    "${LIBDIFFPY_SOURCE_DIR}/src/diffpy/srreal/*.cpp"
-)
+# Embed libdiffpy as an OBJECT library: every object is linked, so its static
+# factory/serialization registrars are kept.
+set(LIBDIFFPY_BUILD_OBJECT_LIB ON)
+set(LIBDIFFPY_INSTALL OFF)
 # ObjCryst conversion uses the public Python API, so it does not depend on
 # pyobjcryst's private static library, compiler, REAL precision, or nanobind ABI.
-list(FILTER LIBDIFFPY_SOURCES EXCLUDE REGEX "ObjCryst")
-# Include every object: libdiffpy has static factory/serialization registrars
-# that an ordinary static archive link can otherwise discard.
-add_library(diffpy_core OBJECT ${LIBDIFFPY_SOURCES})
-set_target_properties(diffpy_core PROPERTIES
+set(LIBDIFFPY_ENABLE_OBJCRYST OFF)
+set(LIBDIFFPY_BUILD_TESTS OFF)
+# Runtime data installs next to the extension, in diffpy/srreal/data.
+set(LIBDIFFPY_RUNTIME_RELPATH data)
+add_subdirectory("${LIBDIFFPY_SOURCE_DIR}" libdiffpy EXCLUDE_FROM_ALL)
+set_target_properties(diffpy PROPERTIES
     POSITION_INDEPENDENT_CODE ON
     CXX_VISIBILITY_PRESET hidden
     VISIBILITY_INLINES_HIDDEN ON
 )
-target_include_directories(diffpy_core PUBLIC
-    "${CMAKE_CURRENT_BINARY_DIR}/include"
-    "${LIBDIFFPY_SOURCE_DIR}/src"
-)
-target_compile_definitions(diffpy_core PRIVATE DIFFPYRUNTIMERELPATH=data)
-if(WIN32)
-    # libdiffpy and its Python wrappers are compiled into the same extension.
-    target_compile_definitions(diffpy_core PUBLIC BUILD_DLL _USE_MATH_DEFINES NOMINMAX)
-endif()
-target_link_libraries(diffpy_core PUBLIC Boost::serialization GSL::gsl GSL::gslcblas ${CMAKE_DL_LIBS})
 
 file(GLOB SRREAL_SOURCES CONFIGURE_DEPENDS "src/extensions/*.cpp")
 # Retain CPython-specific wheels; stable-ABI packaging is a separate change.
 nanobind_add_module(srreal_ext NB_STATIC ${SRREAL_SOURCES})
-target_link_libraries(srreal_ext PRIVATE diffpy_core)
+target_link_libraries(srreal_ext PRIVATE libdiffpy::diffpy)
+if(WIN32)
+    target_compile_definitions(srreal_ext PRIVATE NOMINMAX)
+endif()
 set_target_properties(srreal_ext PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
 install(TARGETS srreal_ext LIBRARY DESTINATION diffpy/srreal)
 install(DIRECTORY "${LIBDIFFPY_SOURCE_DIR}/src/runtime/"

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diffpy.srreal
-Version: 1.5.0
+Version: 1.5.1rc0
 Summary: Calculators for PDF, bond valence sum, and other quantities based on atom pair interaction.
 Keywords: PDF,BVS,atom,overlap,calculator,real-space
 Author-Email: Simon Billinge <sbillinge@ucsb.edu>

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.codecov.yml

@@ -12,7 +12,3 @@ comment:
   require_base: false # [true :: must have a base report to post]
   require_head: false # [true :: must have a head report to post]
   hide_project_coverage: false # [true :: only show coverage on the git diff aka patch coverage]
-
-# SCons compiles copies of the sources in build/coverage-<arch>/, map them back to src/
-fixes:
-  - "build/coverage-x86_64/::src/"

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.github/ISSUE_TEMPLATE/release_checklist.md

@@ -14,8 +14,8 @@ assignees: ""
 - [ ] Locally rendered documentation contains all appropriate pages and other human-written text is up-to-date with any changes in the code.
 - [ ] Installation instructions in the README, documentation, and the website are updated.
 - [ ] Grammar and writing quality are checked (no typos).
-- [ ] Review `FALLBACK_VERSION` in `site_scons/fallback_version.py` for builds without a resolvable release tag.
-- [ ] `scons test` passes locally with the latest conda-forge compilers and dependencies.
+- [ ] Review `LIBDIFFPY_FALLBACK_VERSION` in `cmake/FallbackVersion.cmake` for builds without a resolvable release tag.
+- [ ] The unit tests pass locally (`cmake --preset debug`, `cmake --build --preset debug`, `ctest --preset debug`) with the latest conda-forge compilers and dependencies.
 - [ ] Dispatch matrix testing to test the release on all systems. If you do not have permission to run this workflow, tag the maintainer and say `@maintainer, please dispatch matrix testing workflow`. Matrix testing also runs automatically after a GitHub release is published, but it does not block the release, so check that it passes.
 
 Please tag the maintainer (e.g., @username) in the comment here when you are ready for the GitHub release. Include any additional comments necessary, such as version information and details about the pre-release here:

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.github/actions/setup-tests/action.yml

@@ -7,13 +7,6 @@ runs:
       shell: bash
       run: git fetch --tags https://github.com/diffpy/libdiffpy.git
 
-    - name: Check out CxxTest 4.4
-      uses: actions/checkout@v6
-      with:
-        repository: CxxTest/cxxtest
-        ref: 191adddb3876ab389c0c856e1c03874bf70f8ee4
-        path: build/cxxtest
-
     - name: Prepare C++ test configuration
       shell: python {0}
       run: |

diffpy_srreal-1.5.1rc0/extern/libdiffpy/.github/scripts/configure-tests.py

@@ -0,0 +1,24 @@
+"""Write the conda environment file for the CI tests."""
+
+import json
+from pathlib import Path
+
+requirements = ["python"]
+for filename in ("build.txt", "conda.txt", "tests.txt"):
+    for line in (Path("requirements") / filename).read_text().splitlines():
+        spec = line.split("#", 1)[0].strip()
+        if spec:
+            requirements.append(spec)
+
+Path("build").mkdir(exist_ok=True)
+Path("build/test-environment.yml").write_text(
+    json.dumps(
+        {
+            "name": "test",
+            "channels": ["conda-forge"],
+            "dependencies": requirements,
+        },
+        indent=2,
+    )
+    + "\n"
+)

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.github/workflows/matrix-and-codecov.yml

@@ -27,19 +27,21 @@ jobs:
         include:
           - os: ubuntu-latest
             shell: bash -l {0}
-            build: coverage
+            build-type: Debug
+            coverage: "ON"
             jobs: 4
           - os: windows-latest
             shell: cmd /C CALL {0}
-            build: fast
             jobs: 4
           - os: macos-latest
             shell: bash -l {0}
-            build: fast
+            build-type: Release
+            coverage: "OFF"
             jobs: 2
           - os: macos-15-intel
             shell: bash -l {0}
-            build: fast
+            build-type: Release
+            coverage: "OFF"
             jobs: 4
     defaults:
       run:
@@ -55,13 +57,29 @@ jobs:
         uses: ./.github/actions/setup-tests
 
       - name: Build and run C++ tests
-        run: scons -j${{ matrix.jobs }} build=${{ matrix.build }} test
+        if: runner.os != 'Windows'
+        run: |
+          cmake -S . -B build/ci -G Ninja $CMAKE_ARGS \
+            -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \
+            -DLIBDIFFPY_COVERAGE=${{ matrix.coverage }} \
+            -DLIBDIFFPY_BUILD_TESTS=ON
+          cmake --build build/ci --parallel ${{ matrix.jobs }}
+          ctest --test-dir build/ci --output-on-failure
+
+      # The conda cxx-compiler activation configures MSVC for Ninja in cmd.
+      - name: Build and run C++ tests (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          where cl.exe || exit /b 1
+          cmake --preset release -DLIBDIFFPY_BUILD_TESTS=ON || exit /b 1
+          cmake --build --preset release --parallel ${{ matrix.jobs }} || exit /b 1
+          ctest --test-dir build\release --output-on-failure --no-tests=error
 
       - name: Generate coverage report
         if: runner.os == 'Linux'
         run: >-
           gcovr --gcov-executable "$CONDA_PREFIX/bin/gcov"
-          --root . --filter 'build/coverage-.*/diffpy/'
+          --root . --filter 'src/diffpy/'
           --xml coverage.xml
 
       - name: Save coverage report

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.github/workflows/tests-on-pr.yml

@@ -27,12 +27,15 @@ jobs:
       - name: Build and run C++ tests with coverage
         run: |
           "$CONDA_PREFIX/bin/c++" --version
-          scons -j4 build=coverage test
+          cmake --preset coverage $CMAKE_ARGS \
+            -DCMAKE_INSTALL_LIBDIR=lib/x86_64-linux-gnu
+          cmake --build --preset coverage --parallel 4
+          ctest --preset coverage
 
       - name: Generate coverage report
         run: >-
           gcovr --gcov-executable "$CONDA_PREFIX/bin/gcov"
-          --root . --filter 'build/coverage-.*/diffpy/'
+          --root . --filter 'src/diffpy/'
           --xml coverage.xml
 
       - name: Upload coverage to Codecov

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.gitignore

@@ -19,11 +19,8 @@ __pycache__/
 *.la
 *.a
 
-# SCons build files
-.sconf_temp/
-.sconsign.dblite
-/sconscript.local
-/sconsvars.py
+# CMake user settings
+/CMakeUserPresets.json
 .gdb_history
 tags
 

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.pre-commit-config.yaml

@@ -9,10 +9,9 @@ ci:
   autoupdate_schedule: monthly
   skip: [no-commit-to-branch]
   submodules: false
-# Leave the vendored CxxTest SCons tool and the data tables untouched.
+# Leave the data tables untouched.
 exclude: |
   (?x)^(
-    site_scons/site_tools/cxxtest\.py|
     .*\.(cif|dat)
   )$
 repos:

{diffpy_srreal-1.5.0 → diffpy_srreal-1.5.1rc0}/extern/libdiffpy/.readthedocs.yaml

@@ -4,6 +4,9 @@ build:
   os: "ubuntu-22.04"
   tools:
     python: "latest"
+  # cmake resolves the documentation version from git tags.
+  apt_packages:
+    - cmake
 
 python:
   install: