syncmoss 0.3.0__tar.gz → 0.4.1__tar.gz

syncmoss-0.4.1/.github/workflows/_MacOS.yml

@@ -0,0 +1,451 @@
+name: _macOS (PyInstaller universal2 app)
+
+# Modelled on crispy's release workflow (github.com/mretegan/crispy):
+#   1. build the app natively on an Apple Silicon AND an Intel runner,
+#   2. fuse the two bundles into one universal2 SYNCmoss.app,
+#   3. sign it (Developer ID + hardened runtime), pack the DMG, notarize, staple.
+#
+# Signing and notarization run only when the Apple secrets are set (repository
+# Settings -> Secrets and variables -> Actions; release.yml forwards them).
+# Without them the job still ships a universal2 DMG, ad-hoc signed and not
+# notarized, named SYNCmoss-macOS-universal2.dmg. A notarized one is named
+# SYNCmoss-macOS-universal2-signed.dmg; _TagRelease.yml / _UploadRelease.yml
+# tell the two apart by that name.
+#
+#   APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64
+#       the "Developer ID Application" certificate WITH its private key,
+#       exported from Keychain Access as .p12, then: base64 -i cert.p12 | pbcopy
+#   APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD   password of that .p12
+#   APPLE_ID                             Apple Account e-mail of the developer
+#   APPLE_TEAM_ID                        10-character Team ID (developer.apple.com -> Membership)
+#   APPLE_APPLICATION_SPECIFIC_PASSWORD  app-specific password (account.apple.com -> Sign-In and Security)
+#   APPLE_KEYCHAIN_PASSWORD              optional: password of the throwaway CI keychain
+#                                        (a random one is used when unset)
+
+on:
+  workflow_call:
+    secrets:
+      APPLE_ID:
+        required: false
+      APPLE_TEAM_ID:
+        required: false
+      APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD:
+        required: false
+      APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64:
+        required: false
+      APPLE_KEYCHAIN_PASSWORD:
+        required: false
+      APPLE_APPLICATION_SPECIFIC_PASSWORD:
+        required: false
+
+jobs:
+  build:
+    name: Build macOS app (${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: macos-15
+            arch: arm64
+          - runner: macos-15-intel
+            arch: x86_64
+    env:
+      MACOSX_DEPLOYMENT_TARGET: "11"
+      CFLAGS: "-mmacosx-version-min=11"
+      LDFLAGS: "-mmacosx-version-min=11"
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+          cache: "pip"
+
+      - name: Check the runner architecture
+        run: |
+          MACHINE="$(python -c 'import platform; print(platform.machine())')"
+          echo "Python runs as ${MACHINE}"
+          if [ "${MACHINE}" != "${{ matrix.arch }}" ]; then
+            echo "::error::expected a ${{ matrix.arch }} runner, got ${MACHINE}"
+            exit 1
+          fi
+
+      - name: Download wheel artifact
+        uses: actions/download-artifact@v6
+        with:
+          name: wheels
+          path: wheels
+
+      # numba 0.62.x (llvmlite 0.45.x) is the last release with macOS x86_64
+      # wheels. The pin applies to BOTH architectures: the universal2 app holds
+      # one copy of the pure-Python code, so the two builds must resolve the
+      # same versions (checked again before the merge). --only-binary stops pip
+      # from quietly building an sdist on one architecture only.
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install --only-binary=:all: "numba==0.62.1" -r requirements.txt pyinstaller wheels/*.whl
+          python -m pip list --format=freeze
+
+      - name: Build the app
+        run: python bundle/macos_bundle.py --dist-dir bundle/MacOS/${{ matrix.arch }} --work-dir bundle/build/MacOS/${{ matrix.arch }}
+
+      # tar keeps the symlinks (Qt frameworks) and executable bits that
+      # upload-artifact would drop.
+      - name: Archive the app bundle
+        run: |
+          set -euo pipefail
+          DIST="bundle/MacOS/${{ matrix.arch }}"
+          APP_PATH=""
+          for candidate in "${DIST}/SYNCmoss.app" "${DIST}/SYNCmoss/SYNCmoss.app"; do
+            if [ -d "${candidate}" ]; then
+              APP_PATH="${candidate}"
+              break
+            fi
+          done
+          if [ -z "${APP_PATH}" ]; then
+            echo "::error::SYNCmoss.app not found in the ${{ matrix.arch }} build output"
+            find "${DIST}" -maxdepth 3 -print
+            exit 1
+          fi
+          echo "Executable architectures: $(lipo -archs "${APP_PATH}/Contents/MacOS/SYNCmoss")"
+          mkdir -p macos-artifact
+          tar -cpzf macos-artifact/SYNCmoss.app.tar.gz -C "$(dirname "${APP_PATH}")" SYNCmoss.app
+          python -m pip list --format=freeze > macos-artifact/pip-freeze.txt
+          echo "APP_PATH=${APP_PATH}" >> "${GITHUB_ENV}"
+
+      - name: Upload the app bundle
+        uses: actions/upload-artifact@v5
+        with:
+          name: macos-app-${{ matrix.arch }}
+          path: macos-artifact/
+          if-no-files-found: error
+          retention-days: 1
+
+      # Runs each architecture natively (the x86_64 slice is never exercised
+      # later). After archiving, so nothing the test writes reaches the artifact.
+      - name: Smoke-test the frozen app
+        run: |
+          "${APP_PATH}/Contents/MacOS/SYNCmoss" --test
+
+  universal2:
+    name: Merge, sign and notarize the universal2 app
+    needs: build
+    runs-on: macos-15
+    timeout-minutes: 90
+    steps:
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - name: Download the arm64 app
+        uses: actions/download-artifact@v6
+        with:
+          name: macos-app-arm64
+          path: bundles/arm64
+
+      - name: Download the x86_64 app
+        uses: actions/download-artifact@v6
+        with:
+          name: macos-app-x86_64
+          path: bundles/x86_64
+
+      - name: Check both builds used the same packages
+        run: |
+          if ! diff -u bundles/arm64/pip-freeze.txt bundles/x86_64/pip-freeze.txt; then
+            echo "::error::arm64 and x86_64 resolved different package versions, so the universal2 app would mix them; pin the differing packages in the build job's install step"
+            exit 1
+          fi
+
+      - name: Extract the app bundles
+        run: |
+          set -euo pipefail
+          mkdir -p arm64 x86_64
+          tar -xpf bundles/arm64/SYNCmoss.app.tar.gz -C arm64
+          tar -xpf bundles/x86_64/SYNCmoss.app.tar.gz -C x86_64
+
+      # Adapted from crispy's package/merge-universal.py: walk both bundles,
+      # fuse every pair of thin Mach-O files with lipo, copy everything else
+      # (identical files, already-universal binaries, data files, symlinks),
+      # then require every Mach-O file of the result to carry both slices.
+      - name: Merge into a universal2 app
+        shell: python
+        run: |
+          import filecmp
+          import os
+          import shutil
+          import subprocess
+          import sys
+
+          ARM_APP = "arm64/SYNCmoss.app"
+          X86_APP = "x86_64/SYNCmoss.app"
+          OUT_APP = "dist/universal2/SYNCmoss.app"
+
+          THIN_MAGICS = {b"\xfe\xed\xfa\xce", b"\xfe\xed\xfa\xcf", b"\xce\xfa\xed\xfe", b"\xcf\xfa\xed\xfe"}
+          FAT_MAGICS = {b"\xca\xfe\xba\xbe", b"\xbe\xba\xfe\xca"}
+
+
+          def macho_kind(path):
+              """'thin', 'fat' or None, from the magic bytes: PyInstaller ships
+              extension-less Mach-O files. Java .class files share the fat magic,
+              but a real universal binary has only a few architectures."""
+              with open(path, "rb") as f:
+                  header = f.read(8)
+              if len(header) < 8:
+                  return None
+              if header[:4] in THIN_MAGICS:
+                  return "thin"
+              if header[:4] in FAT_MAGICS:
+                  byteorder = "big" if header[:4] == b"\xca\xfe\xba\xbe" else "little"
+                  return "fat" if int.from_bytes(header[4:8], byteorder) < 30 else None
+              return None
+
+
+          def collect(root):
+              """Relative path -> 'dir', 'symlink' or 'file' (symlinked dirs are not descended)."""
+              entries = {}
+              for current, dirnames, filenames in os.walk(root):
+                  for name in dirnames + filenames:
+                      path = os.path.join(current, name)
+                      if os.path.islink(path):
+                          kind = "symlink"
+                      elif os.path.isdir(path):
+                          kind = "dir"
+                      else:
+                          kind = "file"
+                      entries[os.path.relpath(path, root)] = kind
+              return entries
+
+
+          arm = collect(ARM_APP)
+          x86 = collect(X86_APP)
+          os.makedirs(OUT_APP)
+          single_arch = []
+          fused = 0
+
+          for rel in sorted(set(arm) | set(x86)):
+              arm_kind, x86_kind = arm.get(rel), x86.get(rel)
+              arm_path = os.path.join(ARM_APP, rel)
+              x86_path = os.path.join(X86_APP, rel)
+              out_path = os.path.join(OUT_APP, rel)
+
+              if "dir" in (arm_kind, x86_kind):
+                  os.makedirs(out_path, exist_ok=True)
+                  continue
+              os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+              if "symlink" in (arm_kind, x86_kind):
+                  if arm_kind == x86_kind and os.readlink(arm_path) != os.readlink(x86_path):
+                      print(f"WARNING: symlink target differs, using arm64: {rel}")
+                  os.symlink(os.readlink(arm_path if arm_kind == "symlink" else x86_path), out_path)
+                  continue
+
+              if arm_kind is None or x86_kind is None:
+                  present = arm_path if arm_kind else x86_path
+                  if macho_kind(present):
+                      single_arch.append(rel)
+                  else:
+                      print(f"WARNING: data file present in one build only: {rel}")
+                      shutil.copy2(present, out_path)
+                  continue
+
+              if filecmp.cmp(arm_path, x86_path, shallow=False):
+                  shutil.copy2(arm_path, out_path)
+                  continue
+
+              arm_macho, x86_macho = macho_kind(arm_path), macho_kind(x86_path)
+              if arm_macho == x86_macho == "thin":
+                  subprocess.run(["lipo", "-create", arm_path, x86_path, "-output", out_path], check=True)
+                  shutil.copymode(arm_path, out_path)
+                  fused += 1
+              elif "fat" in (arm_macho, x86_macho):
+                  # Already universal; the two copies differ only in their signature.
+                  shutil.copy2(arm_path if arm_macho == "fat" else x86_path, out_path)
+              elif arm_macho or x86_macho:
+                  single_arch.append(rel)
+              else:
+                  print(f"WARNING: data file differs, using arm64: {rel}")
+                  shutil.copy2(arm_path, out_path)
+
+          if single_arch:
+              sys.exit(
+                  "ERROR: these Mach-O binaries exist for one architecture only, so the "
+                  "app would crash on the other:\n" + "\n".join(f"  - {p}" for p in single_arch)
+              )
+
+          not_universal = []
+          checked = 0
+          for rel, kind in sorted(collect(OUT_APP).items()):
+              path = os.path.join(OUT_APP, rel)
+              if kind != "file" or not macho_kind(path):
+                  continue
+              checked += 1
+              archs = subprocess.run(["lipo", "-archs", path], capture_output=True, text=True).stdout.split()
+              if not {"arm64", "x86_64"} <= set(archs):
+                  not_universal.append(f"  - {rel}: {' '.join(archs) or 'unreadable'}")
+
+          print(f"Fused {fused} binaries, checked {checked} Mach-O files")
+          if not_universal:
+              sys.exit("ERROR: these binaries are not universal2:\n" + "\n".join(not_universal))
+          print(f"Universal2 app written to {OUT_APP}")
+
+      # The merge leaves the bundle's seal stale, so the app is always re-signed:
+      # with the Developer ID when the certificate secrets are set, otherwise
+      # ad-hoc (so macOS reports "unverified developer", not "damaged").
+      - name: Sign the app
+        id: sign
+        env:
+          CERTIFICATE_BASE64: ${{ secrets.APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_BASE64 }}
+          CERTIFICATE_PASSWORD: ${{ secrets.APPLE_DEVELOPER_ID_APPLICATION_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.APPLE_KEYCHAIN_PASSWORD }}
+        run: |
+          set -euo pipefail
+          APP="dist/universal2/SYNCmoss.app"
+
+          # The hardened runtime needs these for the numba/llvmlite JIT (writable
+          # + executable memory) and for loading the bundled Python extensions.
+          ENTITLEMENTS="${RUNNER_TEMP}/entitlements.plist"
+          cat > "${ENTITLEMENTS}" <<'EOF'
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>com.apple.security.cs.allow-jit</key>
+              <true/>
+              <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+              <true/>
+              <key>com.apple.security.cs.disable-library-validation</key>
+              <true/>
+          </dict>
+          </plist>
+          EOF
+
+          # Extended attributes would invalidate the signature.
+          xattr -cr "${APP}"
+
+          if [ -n "${CERTIFICATE_BASE64}" ] && [ -n "${CERTIFICATE_PASSWORD}" ]; then
+            KEYCHAIN_PATH="${RUNNER_TEMP}/signing.keychain-db"
+            CERTIFICATE_PATH="${RUNNER_TEMP}/certificate.p12"
+            if [ -z "${KEYCHAIN_PASSWORD}" ]; then
+              KEYCHAIN_PASSWORD="$(openssl rand -base64 24)"
+              echo "::add-mask::${KEYCHAIN_PASSWORD}"
+            fi
+
+            echo "Creating a temporary keychain and importing the certificate"
+            echo "${CERTIFICATE_BASE64}" | base64 --decode -o "${CERTIFICATE_PATH}"
+            security create-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}"
+            security set-keychain-settings -lut 21600 "${KEYCHAIN_PATH}"
+            security unlock-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}"
+            security import "${CERTIFICATE_PATH}" -P "${CERTIFICATE_PASSWORD}" -A -t cert -f pkcs12 -k "${KEYCHAIN_PATH}"
+            rm -f "${CERTIFICATE_PATH}"
+            security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_PATH}" > /dev/null
+            security list-keychains -d user -s "${KEYCHAIN_PATH}"
+
+            IDENTITY="$(security find-identity -v -p codesigning "${KEYCHAIN_PATH}" | awk '/"Developer ID Application/ && !found { print $2; found = 1 }')"
+            if [ -z "${IDENTITY}" ]; then
+              echo "::error::the certificate holds no 'Developer ID Application' identity"
+              security find-identity -v -p codesigning "${KEYCHAIN_PATH}"
+              exit 1
+            fi
+
+            echo "Signing with the Developer ID (hardened runtime)"
+            codesign --force --deep --timestamp --options runtime \
+              --entitlements "${ENTITLEMENTS}" \
+              --keychain "${KEYCHAIN_PATH}" \
+              --sign "${IDENTITY}" \
+              "${APP}"
+            security delete-keychain "${KEYCHAIN_PATH}"
+            echo "developer_id=true" >> "${GITHUB_OUTPUT}"
+          else
+            echo "::warning::Apple certificate secrets are not set: the macOS DMG is ad-hoc signed and not notarized"
+            codesign --force --deep --sign - "${APP}"
+            echo "developer_id=false" >> "${GITHUB_OUTPUT}"
+          fi
+
+          codesign --verify --deep --strict --verbose=2 "${APP}"
+          echo "Universal executable architectures: $(lipo -archs "${APP}/Contents/MacOS/SYNCmoss")"
+
+      # On a copy, so files the test writes never reach the DMG. For a Developer
+      # ID build this runs under the hardened runtime, i.e. it also checks that
+      # the entitlements above are enough for numba.
+      - name: Smoke-test the signed universal2 app
+        run: |
+          set -euo pipefail
+          mkdir -p "${RUNNER_TEMP}/smoke"
+          ditto dist/universal2/SYNCmoss.app "${RUNNER_TEMP}/smoke/SYNCmoss.app"
+          "${RUNNER_TEMP}/smoke/SYNCmoss.app/Contents/MacOS/SYNCmoss" --test
+
+      - name: Create the DMG
+        run: |
+          set -euo pipefail
+          STAGING="${RUNNER_TEMP}/dmg"
+          mkdir -p "${STAGING}"
+          ditto dist/universal2/SYNCmoss.app "${STAGING}/SYNCmoss.app"
+          ln -s /Applications "${STAGING}/Applications"
+          # hdiutil is occasionally "Resource busy" on hosted runners: retry.
+          for attempt in 1 2 3; do
+            if hdiutil create -volname SYNCmoss -srcfolder "${STAGING}" -ov -format UDZO -imagekey zlib-level=9 dist/SYNCmoss.dmg; then
+              break
+            fi
+            if [ "${attempt}" -eq 3 ]; then
+              exit 1
+            fi
+            echo "hdiutil failed, retrying in 10 s"
+            sleep 10
+          done
+
+      - name: Notarize and staple the DMG
+        id: notarize
+        if: steps.sign.outputs.developer_id == 'true'
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          APPLICATION_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APPLICATION_SPECIFIC_PASSWORD }}
+        run: |
+          set -euo pipefail
+          if [ -z "${APPLE_ID}" ] || [ -z "${APPLE_TEAM_ID}" ] || [ -z "${APPLICATION_SPECIFIC_PASSWORD}" ]; then
+            echo "::warning::APPLE_ID / APPLE_TEAM_ID / APPLE_APPLICATION_SPECIFIC_PASSWORD are not set: the DMG is signed but not notarized, so Gatekeeper will still block it"
+            exit 0
+          fi
+          DMG="dist/SYNCmoss.dmg"
+
+          echo "Submitting ${DMG} for notarization"
+          RESULT="$(xcrun notarytool submit "${DMG}" \
+            --apple-id "${APPLE_ID}" --team-id "${APPLE_TEAM_ID}" --password "${APPLICATION_SPECIFIC_PASSWORD}" \
+            --wait --timeout 1h --output-format json)" || true
+          echo "${RESULT}"
+          SUBMISSION_ID="$(python -c 'import json, sys; print(json.loads(sys.argv[1]).get("id", ""))' "${RESULT}" 2> /dev/null || true)"
+          STATUS="$(python -c 'import json, sys; print(json.loads(sys.argv[1]).get("status", ""))' "${RESULT}" 2> /dev/null || true)"
+          if [ "${STATUS}" != "Accepted" ]; then
+            echo "::error::notarization did not succeed (status: '${STATUS:-none}')"
+            if [ -n "${SUBMISSION_ID}" ]; then
+              xcrun notarytool log "${SUBMISSION_ID}" \
+                --apple-id "${APPLE_ID}" --team-id "${APPLE_TEAM_ID}" --password "${APPLICATION_SPECIFIC_PASSWORD}" || true
+            fi
+            exit 1
+          fi
+
+          xcrun stapler staple "${DMG}"
+          xcrun stapler validate "${DMG}"
+          echo "notarized=true" >> "${GITHUB_OUTPUT}"
+
+      - name: Name the DMG
+        env:
+          NOTARIZED: ${{ steps.notarize.outputs.notarized }}
+        run: |
+          if [ "${NOTARIZED}" = "true" ]; then
+            mv dist/SYNCmoss.dmg dist/SYNCmoss-macOS-universal2-signed.dmg
+          else
+            mv dist/SYNCmoss.dmg dist/SYNCmoss-macOS-universal2.dmg
+          fi
+          ls -lh dist/*.dmg
+
+      - name: Upload the universal2 DMG
+        uses: actions/upload-artifact@v5
+        with:
+          name: macos-universal2
+          path: dist/SYNCmoss-macOS-universal2*.dmg
+          if-no-files-found: error
+          retention-days: 5

{syncmoss-0.3.0 → syncmoss-0.4.1}/.github/workflows/_Tests.yml

@@ -74,7 +74,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install wheels/*.whl
-          pip install pytest
+          pip install pytest pytest-xdist
 
       - name: Install runtime dependencies + pytest (source checkout)
         if: inputs.install == 'source'
@@ -82,7 +82,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install -r requirements.txt
-          pip install pytest
+          pip install pytest pytest-xdist
 
       - name: Run the test-suite
         shell: bash
@@ -103,4 +103,7 @@ jobs:
           if [ "$INSTALL" = "wheel" ]; then cd "$(mktemp -d)"; fi
 
           python -c "import syncmoss.syncmoss_main as m; print('syncmoss from:', m.__file__)"
-          python -m pytest "$GITHUB_WORKSPACE/tests" "${args[@]}"
+          # -n 0 forces a SERIAL run: pyproject sets -n auto for local use,
+          # which oversubscribes a small CI runner. xdist is installed above
+          # only so that this flag parses.
+          python -m pytest "$GITHUB_WORKSPACE/tests" -n 0 "${args[@]}"

{syncmoss-0.3.0 → syncmoss-0.4.1}/.gitignore

@@ -162,3 +162,11 @@ minimi_optimization_notes.txt
 # suite still covers the model end-to-end via the SCDW golden case, plus its
 # param-count and locked-angle checks (test_model_io / test_thick_gui).
 tests/test_sdw_grid.py
+
+# SMS instrumental-function study against the ESRF (temperature, angle) dataset
+# on N:\SL_studies: analysis scripts, cached intermediate fits and the figures
+# they produce. Local-only -- it needs a network share that is not part of the
+# repo, and its outputs are large. The conclusions that matter are tracked in
+# docs/sms_instrumental_function.md; the calibration it produced is in
+# sms_theory.FEBO3_BS_CALIBRATION and instrumental_io.ESRF_STANDARD_LINE_WIDTH.
+sms_study/

{syncmoss-0.3.0 → syncmoss-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncmoss
-Version: 0.3.0
+Version: 0.4.1
 Summary: SYNCmoss — Mössbauer spectroscopy analysis application
 Author: Sergey Yaroslavtsev
 License: MIT

{syncmoss-0.3.0 → syncmoss-0.4.1}/pyproject.toml

@@ -73,7 +73,21 @@ local_scheme = "no-local-version"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-q --basetemp=./.pytest_tmp"
+# -n 6: almost every test here spends its time in ONE process doing physics
+# (a fit, a calibration, an instrumental-function search), so a serial run
+# leaves most of the machine idle -- measured 351 s serial against 116 s on 8
+# workers for the calibration + instrumental set.
+#
+# A FIXED 6, not "auto". Each worker builds its own QApplication, PhysicsApp
+# and numba-compiled model, so the suite is limited by MEMORY, not by cores:
+# "auto" resolves to one worker per core (22 here) and dies during start-up
+# with an execnet EOFError once the machine runs out. The same ceiling bit the
+# 83-spectrum study, where 10 parallel fits OOM'd and 6 did not.
+#
+# CI overrides this with -n 0 (see .github/workflows/_Tests.yml): the runners
+# are small, where even 6 oversubscribes. Use -n 0 locally too when debugging,
+# since xdist swallows live output.
+addopts = "-q --basetemp=./.pytest_tmp -n 6"
 markers = [
     "gui: builds the PySide6 GUI; runs head-less via QT_QPA_PLATFORM=offscreen (set in tests/conftest.py)",
     "slow: slow tests (numba compilation / fitting)",

{syncmoss-0.3.0 → syncmoss-0.4.1}/syncmoss/Calibration.py

@@ -102,6 +102,7 @@ import numpy as np
 
 import syncmoss.minimi_lib as mi
 import syncmoss.models as m5
+import syncmoss.sms_theory as smst
 from syncmoss.constants import (number_of_baseline_parameters, ALPHA_FE_FIELD,
                                 TESLA_PER_MMS, LINE_RATIO_25, LINE_RATIO_34,
                                 NAT_WIDTH)
@@ -532,11 +533,16 @@ def Calibration(dir_path, Cal_file, pool, VVV, INS, JN, x0, MulCo, Vel_start=1,
             return m5.TI(x, p, model, JN, pool, x0, MulCo, INS, [], [], Norm=Norm)
 
         # The multi-line instrumental function displaces the apparent line
-        # positions by the intensity-weighted sum of the squared line shifts;
-        # the folded velocity axis is corrected by this at the very end.
+        # positions by its first moment (for the legacy sum of unit-area
+        # Gaussians: the intensity-weighted sum of the line shifts); the folded
+        # velocity axis is corrected by this at the very end. The theoretical
+        # SMS shapes compute the same moment in sms_theory.ins_centroid.
         INS_shift = 0
-        for i in range(0, int(len(INS) / 3)):
-            INS_shift += INS[i * 3 + 1] * INS[i * 3 + 2] ** 2
+        if smst.ins_kind(INS) == smst.KIND_GAUSS:
+            for i in range(0, int(len(INS) / 3)):
+                INS_shift += INS[i * 3 + 1] * INS[i * 3 + 2] ** 2
+        else:
+            INS_shift = smst.ins_centroid(INS)
     else:
         raise ValueError(f"unknown experimental method VVV={VVV!r} (expected 1 or 3)")
 

{syncmoss-0.3.0 → syncmoss-0.4.1}/syncmoss/Library_window.py

@@ -119,7 +119,7 @@ def save_to_library_via_dialog(main_window):
 
 def open_library_model_dialog(main_window, parent_widget, insert_row, model_options=None):
     """Open internal Library browser with filters and detailed preview."""
-    library_dir = os.path.join(main_window.dir_path, 'Library')
+    library_dir = main_window.library_dir
     if not os.path.isdir(library_dir):
         main_window.set_status(f"Library folder not found: {library_dir}", "red")
         return

{syncmoss-0.3.0 → syncmoss-0.4.1}/syncmoss/constants.py

@@ -56,6 +56,26 @@ TESLA_PER_MMS = 1 / (2 * LINE_SHIFT_16)                 # 3.1097641 T per mm/s o
 LINE_RATIO_25 = LINE_SHIFT_25 / LINE_SHIFT_16           # 0.5789752
 LINE_RATIO_34 = LINE_SHIFT_34 / LINE_SHIFT_16           # 0.1579504
 
+# --- scattering-side 57Fe quantities (sms_theory.py) -----------------------
+# Everything below is DERIVED from the primitives above plus two new inputs,
+# ALPHA_IC and the universal hc; no 57Fe literal is repeated.
+#   ALPHA_IC -- internal conversion coefficient of the 14.4 keV level.
+#   HC_EV_A  -- h*c = 1239.8419843320026 eV nm (exact in SI since 2019).
+ALPHA_IC = 8.56
+HC_EV_A = 12398.419843320026                            # eV * Angstrom
+
+MMPS_TO_NEV = E0 / c * 10**9            # 48.0733 neV per (mm/s): E = E0 v/c
+GAMMA0_NEV = NAT_WIDTH * MMPS_TO_NEV    # 4.7112 neV, the natural width in neV
+MU_N_NEV_PER_T = mun / (E0_J / E0) * 10**9              # 31.4331 neV/T
+LAMBDA_A = HC_EV_A / E0                                 # 0.8603 A
+K_VEC_A = 2 * 3.141592653589793 / LAMBDA_A              # 7.3035 1/A
+R_E_A = 2.8179403262 * 10**-5                           # classical electron radius, A
+# Maximum resonant cross-section from the level scheme:
+#   sigma_0 = 2 pi lambdabar^2 (2 I_e + 1)/(2 I_g + 1) / (1 + alpha_ic)
+# equals `sigma` above (2.464e-22 m^2) to 0.02 %; sms_theory.selftest() checks it.
+SIGMA0_A2 = (2 * 3.141592653589793 * (LAMBDA_A / (2 * 3.141592653589793))**2
+             * (2 * 1.5 + 1) / (2 * 0.5 + 1) / (1 + ALPHA_IC))   # 0.024644 A^2
+
 # Linear polarization degree of the SMS (synchrotron) beam, 0..1. Only a default:
 # it is GUI-editable via Supp -> "Set polarization" and travels to the models as
 # the `pol` / `sms_pol` argument. 0.98 is a realistic synchrotron beam.

{syncmoss-0.3.0 → syncmoss-0.4.1}/syncmoss/fitting_io.py

@@ -343,7 +343,8 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
             # Load and concatenate all spectra
             A_list, B_list = [], []
             for i, spec_file in enumerate(spectrum_files):
-                A_temp, B_temp = load_spectrum(app, spec_file)
+                A_temp, B_temp = load_spectrum(
+                    app, spec_file, calibration_path=app.calibration_path)
                 A_temp, B_temp = A_temp[0], B_temp[0]
                 A_list.append(A_temp)
                 B_list.append(B_temp)
@@ -357,7 +358,8 @@ def fit_single_spectrum(app, spectrum_file, pool, background=None, sequence_para
             
         else:
             # Single spectrum fitting mode
-            A, B = load_spectrum(app, spectrum_file)
+            A, B = load_spectrum(app, spectrum_file,
+                                 calibration_path=app.calibration_path)
             A, B = A[0], B[0]  # Unpack from list
             A_list, B_list = [A], [B]