From f07be5cd26ac8a6c9131b67e175d7b531f57b962 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:43:42 +0200
Subject: [PATCH 01/16] build: add pyproject.toml + meson skeleton

First step of the meson-python migration. Adds pyproject.toml with
meson-python as build-backend, plus a minimal meson.build that installs
the pure-Python tree (src/pyfmi -> pyfmi, src/common -> pyfmi/common).

Cython extensions are not yet declared in meson; the legacy setup.py
continues to build them when invoked directly. This is the C1
checkpoint per the modernization plan -- pip-install via mesonpy at
this commit yields a wheel without compiled extensions on purpose.

Build requires include assimulo-testing>=3.9.0b1 so build isolation
resolves Assimulo's .pxd files in later commits.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 meson.build    | 17 +++++++++++++++++
 meson.options  |  1 +
 pyproject.toml | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+)
 create mode 100644 meson.build
 create mode 100644 meson.options
 create mode 100644 pyproject.toml

diff --git a/meson.build b/meson.build
new file mode 100644
index 00000000..6aeba52d
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,17 @@
+project(
+  'PyFMI',
+  ['c', 'cython'],
+  version: '3.0.0.dev0',
+  meson_version: '>=1.4'
+)
+
+py = import('python').find_installation(pure: false)
+
+# C1 skeleton: install the pure-Python package tree only. Cython extension
+# modules are still produced by the legacy setup.py during the C1 -> C3
+# transition. A pip install via mesonpy at this commit will produce a wheel
+# without compiled extensions — that is intentional for the checkpoint.
+
+install_subdir('src/pyfmi',  install_dir: py.get_install_dir())
+install_subdir('src/common', install_dir: py.get_install_dir() / 'pyfmi/common',
+               strip_directory: true)
diff --git a/meson.options b/meson.options
new file mode 100644
index 00000000..42790b59
--- /dev/null
+++ b/meson.options
@@ -0,0 +1 @@
+# Build options for PyFMI. Populated in C3 with fmil_prefix, openmp, etc.
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..4e8525cf
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,47 @@
+[build-system]
+requires = [
+    "meson-python>=0.16",
+    "meson>=1.4",
+    "ninja",
+    "Cython>=3.0.7",
+    "numpy>=2.1",
+    "assimulo-testing>=3.9.0b1",
+]
+build-backend = "mesonpy"
+
+[project]
+name = "PyFMI"
+version = "3.0.0.dev0"
+description = "A package for working with dynamic models compliant with the Functional Mock-Up Interface standard."
+readme = "README.md"
+license = { text = "LGPL-3.0-only" }
+authors = [{ name = "Modelon AB" }]
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: Unix",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+]
+
+dependencies = [
+    "numpy>=2.1",
+    "scipy>=1.14.0",
+    "matplotlib>=3.0",
+    "assimulo-testing>=3.9.0b1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.4",
+    "meson>=1.4",
+    "meson-python>=0.16",
+    "ninja",
+    "Cython>=3.0.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/modelon-community/PyFMI"

From 35d6d79ce883279b9449d3aa484906ae12d8aef9 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:44:44 +0200
Subject: [PATCH 02/16] build: move src/common into src/pyfmi/common

Flattens the source layout so the entire installable package lives
under src/pyfmi/. Removes the pyfmi.common package_dir mapping from
setup.py and the second install_subdir call from meson.build -- a
single install_subdir('src/pyfmi') now produces the same on-disk
layout as before. Import paths (pyfmi.common.*) are unchanged.

Mirrors the simplification done in the Assimulo modernization fork
(git mv src assimulo).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 meson.build                                 | 4 +---
 setup.py                                    | 4 +---
 src/{ => pyfmi}/common/__init__.py          | 0
 src/{ => pyfmi}/common/algorithm_drivers.py | 0
 src/{ => pyfmi}/common/core.py              | 0
 src/{ => pyfmi}/common/diagnostics.py       | 0
 src/{ => pyfmi}/common/io.py                | 0
 src/{ => pyfmi}/common/log/__init__.py      | 0
 src/{ => pyfmi}/common/log/parser.py        | 0
 src/{ => pyfmi}/common/log/prettyprinter.py | 0
 src/{ => pyfmi}/common/log/tree.py          | 0
 src/{ => pyfmi}/common/plotting/__init__.py | 0
 src/{ => pyfmi}/common/plotting/plot_gui.py | 0
 13 files changed, 2 insertions(+), 6 deletions(-)
 rename src/{ => pyfmi}/common/__init__.py (100%)
 rename src/{ => pyfmi}/common/algorithm_drivers.py (100%)
 rename src/{ => pyfmi}/common/core.py (100%)
 rename src/{ => pyfmi}/common/diagnostics.py (100%)
 rename src/{ => pyfmi}/common/io.py (100%)
 rename src/{ => pyfmi}/common/log/__init__.py (100%)
 rename src/{ => pyfmi}/common/log/parser.py (100%)
 rename src/{ => pyfmi}/common/log/prettyprinter.py (100%)
 rename src/{ => pyfmi}/common/log/tree.py (100%)
 rename src/{ => pyfmi}/common/plotting/__init__.py (100%)
 rename src/{ => pyfmi}/common/plotting/plot_gui.py (100%)

diff --git a/meson.build b/meson.build
index 6aeba52d..ee9e2725 100644
--- a/meson.build
+++ b/meson.build
@@ -12,6 +12,4 @@ py = import('python').find_installation(pure: false)
 # transition. A pip install via mesonpy at this commit will produce a wheel
 # without compiled extensions — that is intentional for the checkpoint.
 
-install_subdir('src/pyfmi',  install_dir: py.get_install_dir())
-install_subdir('src/common', install_dir: py.get_install_dir() / 'pyfmi/common',
-               strip_directory: true)
+install_subdir('src/pyfmi', install_dir: py.get_install_dir())
diff --git a/setup.py b/setup.py
index 58e6c2c7..d29274a2 100644
--- a/setup.py
+++ b/setup.py
@@ -434,9 +434,7 @@ def check_extensions():
       platforms=PLATFORMS,
       classifiers=CLASSIFIERS,
       ext_modules = ext_list,
-      package_dir = {'pyfmi':        os.path.join('src', 'pyfmi'),
-                     'pyfmi.common': os.path.join('src', 'common')
-                    },
+      package_dir = {'pyfmi': os.path.join('src', 'pyfmi')},
       packages=[
         'pyfmi',
         'pyfmi.simulation',
diff --git a/src/common/__init__.py b/src/pyfmi/common/__init__.py
similarity index 100%
rename from src/common/__init__.py
rename to src/pyfmi/common/__init__.py
diff --git a/src/common/algorithm_drivers.py b/src/pyfmi/common/algorithm_drivers.py
similarity index 100%
rename from src/common/algorithm_drivers.py
rename to src/pyfmi/common/algorithm_drivers.py
diff --git a/src/common/core.py b/src/pyfmi/common/core.py
similarity index 100%
rename from src/common/core.py
rename to src/pyfmi/common/core.py
diff --git a/src/common/diagnostics.py b/src/pyfmi/common/diagnostics.py
similarity index 100%
rename from src/common/diagnostics.py
rename to src/pyfmi/common/diagnostics.py
diff --git a/src/common/io.py b/src/pyfmi/common/io.py
similarity index 100%
rename from src/common/io.py
rename to src/pyfmi/common/io.py
diff --git a/src/common/log/__init__.py b/src/pyfmi/common/log/__init__.py
similarity index 100%
rename from src/common/log/__init__.py
rename to src/pyfmi/common/log/__init__.py
diff --git a/src/common/log/parser.py b/src/pyfmi/common/log/parser.py
similarity index 100%
rename from src/common/log/parser.py
rename to src/pyfmi/common/log/parser.py
diff --git a/src/common/log/prettyprinter.py b/src/pyfmi/common/log/prettyprinter.py
similarity index 100%
rename from src/common/log/prettyprinter.py
rename to src/pyfmi/common/log/prettyprinter.py
diff --git a/src/common/log/tree.py b/src/pyfmi/common/log/tree.py
similarity index 100%
rename from src/common/log/tree.py
rename to src/pyfmi/common/log/tree.py
diff --git a/src/common/plotting/__init__.py b/src/pyfmi/common/plotting/__init__.py
similarity index 100%
rename from src/common/plotting/__init__.py
rename to src/pyfmi/common/plotting/__init__.py
diff --git a/src/common/plotting/plot_gui.py b/src/pyfmi/common/plotting/plot_gui.py
similarity index 100%
rename from src/common/plotting/plot_gui.py
rename to src/pyfmi/common/plotting/plot_gui.py

From 7227b9925188d1a2ff03fb0e4b26d000e9969f25 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:52:31 +0200
Subject: [PATCH 03/16] build: port FMIL discovery and Cython extensions to
 meson

Wires the 15 Cython extension modules into meson.build:

- 14 plain modules (fmi_base, fmi, fmi1, fmi2, fmi3, fmi_util,
  fmi_extended, fmi_coupled, util, test_util, plus the four
  assimulo_interface variants in src/pyfmi/simulation/).
- master.pyx with a WITH_OPENMP cython compile-time env and optional
  -fopenmp link/compile args, driven by the new -Dopenmp meson option.

FMIL is located via the new -Dfmil_prefix meson option, falling back to
the FMIL_HOME environment variable for parity with setup.py. The lib
name is configurable via -Dfmil_name (default fmilib_shared) for the
static-link case.

NumPy include is resolved at configure time via `numpy.get_include()`,
mirroring Assimulo's pattern. Likewise the assimulo package parent dir
is added to Cython's include path so `cimport assimulo.problem`
resolves at build time (assimulo-testing is in build-system.requires
so it is present during build isolation).

NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION is set globally via
common_c_args, replacing the per-.pyx `# distutils:` headers
functionally (the per-file headers remain harmless since meson
ignores them).

install_rpath/build_rpath point at the FMIL libdir for non-wheel Linux
installs. Wheel-time bundling (with $ORIGIN rpath) lands in C4.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 meson.build   | 141 ++++++++++++++++++++++++++++++++++++++++++++++++--
 meson.options |  21 +++++++-
 2 files changed, 157 insertions(+), 5 deletions(-)

diff --git a/meson.build b/meson.build
index ee9e2725..ae166ad3 100644
--- a/meson.build
+++ b/meson.build
@@ -6,10 +6,143 @@ project(
 )
 
 py = import('python').find_installation(pure: false)
+fs = import('fs')
+cc = meson.get_compiler('c')
 
-# C1 skeleton: install the pure-Python package tree only. Cython extension
-# modules are still produced by the legacy setup.py during the C1 -> C3
-# transition. A pip install via mesonpy at this commit will produce a wheel
-# without compiled extensions — that is intentional for the checkpoint.
+numpy_inc = run_command(
+  py, ['-c', 'import numpy; print(numpy.get_include())'],
+  check: true
+).stdout().strip()
+
+# Parent of the assimulo package so Cython resolves `cimport assimulo.problem`.
+assimulo_pkg_parent = run_command(
+  py, ['-c', 'import assimulo, os; print(os.path.dirname(os.path.dirname(assimulo.__file__)))'],
+  check: true
+).stdout().strip()
+
+# numpy_inc is passed via -I rather than include_directories() because under
+# pip build isolation it lives outside the source tree, which meson rejects
+# for include_directories().
+if cc.get_argument_syntax() == 'msvc'
+  common_c_args = [
+    '-I' + numpy_inc,
+    '-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION',
+    '/O2',
+  ]
+else
+  common_c_args = [
+    '-I' + numpy_inc,
+    '-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION',
+    '-fno-strict-aliasing',
+    '-O2',
+  ]
+endif
+
+fmil_prefix = get_option('fmil_prefix')
+if fmil_prefix == ''
+  fmil_prefix = run_command(
+    py, ['-c', 'import os, sys; sys.stdout.write(os.environ.get("FMIL_HOME", ""))'],
+    check: true
+  ).stdout().strip()
+endif
+if fmil_prefix == ''
+  error('FMIL not found. Set -Dfmil_prefix=/path/to/fmil or env FMIL_HOME.')
+endif
+
+fmil_incdir = join_paths(fmil_prefix, 'include')
+if not fs.is_dir(fmil_incdir)
+  error('FMIL include directory not found at @0@'.format(fmil_incdir))
+endif
+
+fmil_libdirs = []
+foreach d : ['lib', 'lib64', 'bin']
+  p = join_paths(fmil_prefix, d)
+  if fs.is_dir(p)
+    fmil_libdirs += p
+  endif
+endforeach
+if fmil_libdirs.length() == 0
+  error('No FMIL lib directory found under @0@'.format(fmil_prefix))
+endif
+
+fmil_name = get_option('fmil_name')
+fmil_lib  = cc.find_library(fmil_name, dirs: fmil_libdirs, required: true)
+
+cython_include_dirs = [
+  '-I', meson.current_source_dir(),
+  '-I', join_paths(meson.current_source_dir(), 'src'),
+  '-I', join_paths(meson.current_source_dir(), 'src/pyfmi'),
+  '-I', assimulo_pkg_parent,
+]
+cython_common_args = ['-3', '-X', 'language_level=3str'] + cython_include_dirs
+
+# --- RPATH for non-wheel Linux installs: point at the FMIL libdir so the
+# shared library is found at runtime. Wheel builds get $ORIGIN added in C4
+# once the FMIL .so is bundled inside the package. ---
+ext_install_rpath = ''
+if host_machine.system() != 'windows'
+  ext_install_rpath = fmil_libdirs[0]
+endif
+
+with_openmp     = get_option('openmp')
+openmp_c_args   = with_openmp ? ['-fopenmp'] : []
+openmp_link_args = with_openmp ? ['-fopenmp'] : []
+
+ext_inc = [
+  include_directories('src', 'src/pyfmi'),
+  include_directories(fmil_incdir),
+]
+
+plain_modules = [
+  { 'name': 'fmi_base',     'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi_base.pyx' },
+  { 'name': 'fmi',          'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi.pyx' },
+  { 'name': 'fmi1',         'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi1.pyx' },
+  { 'name': 'fmi2',         'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi2.pyx' },
+  { 'name': 'fmi3',         'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi3.pyx' },
+  { 'name': 'fmi_util',     'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi_util.pyx' },
+  { 'name': 'fmi_extended', 'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi_extended.pyx' },
+  { 'name': 'fmi_coupled',  'subdir': 'pyfmi',            'src': 'src/pyfmi/fmi_coupled.pyx' },
+  { 'name': 'util',         'subdir': 'pyfmi',            'src': 'src/pyfmi/util.pyx' },
+  { 'name': 'test_util',    'subdir': 'pyfmi',            'src': 'src/pyfmi/test_util.pyx' },
+  { 'name': 'assimulo_interface',      'subdir': 'pyfmi/simulation', 'src': 'src/pyfmi/simulation/assimulo_interface.pyx' },
+  { 'name': 'assimulo_interface_fmi1', 'subdir': 'pyfmi/simulation', 'src': 'src/pyfmi/simulation/assimulo_interface_fmi1.pyx' },
+  { 'name': 'assimulo_interface_fmi2', 'subdir': 'pyfmi/simulation', 'src': 'src/pyfmi/simulation/assimulo_interface_fmi2.pyx' },
+  { 'name': 'assimulo_interface_fmi3', 'subdir': 'pyfmi/simulation', 'src': 'src/pyfmi/simulation/assimulo_interface_fmi3.pyx' },
+]
+
+foreach m : plain_modules
+  py.extension_module(
+    m['name'],
+    sources: [m['src']],
+    subdir: m['subdir'],
+    include_directories: ext_inc,
+    c_args: common_c_args,
+    cython_args: cython_common_args,
+    dependencies: [fmil_lib],
+    install_rpath: ext_install_rpath,
+    build_rpath:   ext_install_rpath,
+    install: true,
+  )
+endforeach
+
+# master.pyx branches on WITH_OPENMP at Cython compile time; the C compiler
+# also needs -fopenmp when openmp is enabled (added below via openmp_c_args).
+master_cython_args = cython_common_args + [
+  '-E', 'WITH_OPENMP=' + (with_openmp ? 'True' : 'False'),
+]
+
+py.extension_module(
+  'master',
+  sources: ['src/pyfmi/master.pyx'],
+  subdir: 'pyfmi',
+  include_directories: ext_inc,
+  c_args: common_c_args + openmp_c_args,
+  cython_args: master_cython_args,
+  dependencies: [fmil_lib],
+  link_args: openmp_link_args,
+  install_rpath: ext_install_rpath,
+  build_rpath:   ext_install_rpath,
+  install: true,
+)
 
 install_subdir('src/pyfmi', install_dir: py.get_install_dir())
diff --git a/meson.options b/meson.options
index 42790b59..e5bb152e 100644
--- a/meson.options
+++ b/meson.options
@@ -1 +1,20 @@
-# Build options for PyFMI. Populated in C3 with fmil_prefix, openmp, etc.
+option(
+  'fmil_prefix',
+  type: 'string',
+  value: '',
+  description: 'Path to FMI Library install prefix (containing include/, lib/, bin/). Falls back to env FMIL_HOME.',
+)
+
+option(
+  'fmil_name',
+  type: 'string',
+  value: 'fmilib_shared',
+  description: 'FMIL library name to link against (default: fmilib_shared; use fmilib for static).',
+)
+
+option(
+  'openmp',
+  type: 'boolean',
+  value: false,
+  description: 'Enable OpenMP parallelization in master.pyx.',
+)

From 9c03c33d1ca01811f5f04280054fe549bc9d4ac2 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:53:47 +0200
Subject: [PATCH 04/16] build: prepend $ORIGIN to install_rpath for wheel
 bundling

Adds '$ORIGIN' to install_rpath alongside the configured FMIL libdir.
Source installs continue to resolve libfmilib_shared.so via the libdir
entry. Wheel installs have FMIL repaired into the package by
auditwheel (Linux) and delvewheel (Windows); '$ORIGIN' lets ld.so find
the bundled copy next to the extension. Setup.py's manual shutil.copy2
of FMIL into src/pyfmi/ is therefore no longer needed -- the wheel
repair tools handle bundling on both platforms.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 meson.build | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/meson.build b/meson.build
index ae166ad3..54ba11e8 100644
--- a/meson.build
+++ b/meson.build
@@ -76,12 +76,13 @@ cython_include_dirs = [
 ]
 cython_common_args = ['-3', '-X', 'language_level=3str'] + cython_include_dirs
 
-# --- RPATH for non-wheel Linux installs: point at the FMIL libdir so the
-# shared library is found at runtime. Wheel builds get $ORIGIN added in C4
-# once the FMIL .so is bundled inside the package. ---
+# $ORIGIN lets installed wheels find the bundled libfmilib_shared.so that
+# auditwheel/delvewheel place next to the extension. The configured libdir is
+# kept as a fallback so editable/source installs against a system FMIL also
+# resolve at runtime.
 ext_install_rpath = ''
 if host_machine.system() != 'windows'
-  ext_install_rpath = fmil_libdirs[0]
+  ext_install_rpath = '$ORIGIN:' + fmil_libdirs[0]
 endif
 
 with_openmp     = get_option('openmp')

From 4d22d81f34278b85acae021909be9947729ea71f Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:55:57 +0200
Subject: [PATCH 05/16] build: switch version handling to importlib.metadata

Drops the svnversion+version.txt write path from setup.py and the
file-read fallback in pyfmi/__init__.py. The version is now resolved
via importlib.metadata.version("PyFMI") (or "pyfmi-testing" during the
beta-name window), matching the source of truth in pyproject.toml.

Also adds an install_data step to meson.build so LICENSE and CHANGELOG
land inside the installed pyfmi/ package -- previously handled by
shutil.copy2 + package_data in setup.py.

__revision__ is kept as a constant "unknown" for backward compat with
any user code that imports it; PyFMI moved off subversion long ago so
the value was already practically constant.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 meson.build           |  7 +++++++
 setup.py              | 27 ---------------------------
 src/pyfmi/__init__.py | 12 ++++++------
 3 files changed, 13 insertions(+), 33 deletions(-)

diff --git a/meson.build b/meson.build
index 54ba11e8..02364737 100644
--- a/meson.build
+++ b/meson.build
@@ -147,3 +147,10 @@ py.extension_module(
 )
 
 install_subdir('src/pyfmi', install_dir: py.get_install_dir())
+
+# LGPL requires the license to ship with the binary; CHANGELOG goes alongside
+# so users can identify the bundled version at runtime.
+install_data(
+  ['LICENSE', 'CHANGELOG'],
+  install_dir: py.get_install_dir() / 'pyfmi',
+)
diff --git a/setup.py b/setup.py
index d29274a2..84017b21 100644
--- a/setup.py
+++ b/setup.py
@@ -395,30 +395,6 @@ def check_extensions():
 
 ext_list = check_extensions()
 
-try:
-    from subprocess import Popen, PIPE
-    _p = Popen(["svnversion", "."], stdout=PIPE)
-    revision = _p.communicate()[0].decode('ascii')
-except Exception:
-    revision = "unknown"
-version_txt = os.path.join('src', 'pyfmi', 'version.txt')
-
-# If a revision is found, always write it!
-if revision != "unknown" and revision!="":
-    with open(version_txt, 'w') as f:
-        f.write(VERSION+'\n')
-        f.write("r"+revision)
-else:# If it does not, check if the file exists and if not, create the file!
-    if not os.path.isfile(version_txt):
-        with open(version_txt, 'w') as f:
-            f.write(VERSION+'\n')
-            f.write("unknown")
-
-try:
-    shutil.copy2('LICENSE', os.path.join('src', 'pyfmi', 'LICENSE'))
-    shutil.copy2('CHANGELOG', os.path.join('src', 'pyfmi', 'CHANGELOG'))
-except Exception:
-    pass
 extra_package_data = [f'*{fmil_name}*']
 extra_package_data += ['libgcc_s_dw2-1.dll'] if is_windows and copy_gcc_lib else []
 
@@ -448,9 +424,6 @@ def check_extensions():
         'examples/files/FMUs/CS1.0/*',
         'examples/files/FMUs/ME2.0/*',
         'examples/files/FMUs/CS2.0/*',
-        'version.txt',
-        'LICENSE',
-        'CHANGELOG',
         'util/*'] + extra_package_data
         },
       script_args=copy_args
diff --git a/src/pyfmi/__init__.py b/src/pyfmi/__init__.py
index aafb79f9..6db422f5 100644
--- a/src/pyfmi/__init__.py
+++ b/src/pyfmi/__init__.py
@@ -29,14 +29,14 @@
 import time
 
 try:
-    curr_dir = os.path.dirname(os.path.abspath(__file__))
-    _fpath=os.path.join(curr_dir,'version.txt')
-    with open(_fpath, 'r') as f:
-        __version__=f.readline().strip()
-        __revision__=f.readline().strip()
+    from importlib.metadata import version as _pkg_version, PackageNotFoundError
+    try:
+        __version__ = _pkg_version("PyFMI")
+    except PackageNotFoundError:
+        __version__ = _pkg_version("pyfmi-testing")
 except Exception:
     __version__ = "unknown"
-    __revision__= "unknown"
+__revision__ = "unknown"
 
 
 def check_packages():

From 872b490b5905722c7ef3615652462f9d140b541f Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:56:31 +0200
Subject: [PATCH 06/16] build: remove legacy setup.py / setup.cfg / MANIFEST.in

End of Phase 1. The meson-python backend is now the sole build entry
point; pyproject.toml declares everything previously expressed in
setup.cfg (dependencies, python_requires) and the Cython extension
graph lives entirely in meson.build.

MANIFEST.in is removed too -- meson-python's sdist builder uses git
ls-files, making the manifest redundant.

Build options previously surfaced as setup.py CLI flags are now meson
options (-Dfmil_prefix, -Dfmil_name, -Dopenmp) or built-in meson
features (-Dbuildtype=debug for the old --debug flag). The more
obscure flags (--force-32bit, --copy-libgcc, --no-msvcr,
--extra-c-flags) are dropped: 32-bit targets are out of scope for the
modernization, MinGW DLL bundling is handled by delvewheel in CI, and
ad-hoc CFLAGS can be passed via meson's standard CFLAGS env or
-Dc_args.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 MANIFEST.in |   5 -
 setup.cfg   |  17 --
 setup.py    | 436 ----------------------------------------------------
 3 files changed, 458 deletions(-)
 delete mode 100644 MANIFEST.in
 delete mode 100644 setup.cfg
 delete mode 100644 setup.py

diff --git a/MANIFEST.in b/MANIFEST.in
deleted file mode 100644
index 8aaaf77e..00000000
--- a/MANIFEST.in
+++ /dev/null
@@ -1,5 +0,0 @@
-include CHANGELOG
-include LICENSE
-include src/pyfmi/*.pyx
-include src/pyfmi/*.pxd
-exclude src/pyfmi/*.dll
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 932c5463..00000000
--- a/setup.cfg
+++ /dev/null
@@ -1,17 +0,0 @@
-[options]
-setup_requires =
-    setuptools
-    numpy >= 1.19.5
-    cython >= 3.0
-
-python_requires = >=3.11
-
-install_requires =
-    numpy >= 1.19.5
-    scipy >= 1.10.1
-    cython >= 3.0.7
-    matplotlib > 3
-    assimulo >= 3.5.0
-
-tests_require =
-    pytest >= 7.4.4
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 84017b21..00000000
--- a/setup.py
+++ /dev/null
@@ -1,436 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (C) 2014-2025 Modelon AB
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-import os
-import shutil
-import sysconfig
-import numpy as np
-import ctypes.util
-import sys
-from itertools import chain
-
-
-try:
-    from numpy.distutils.core import setup
-    have_nd = True
-except ImportError:
-    from setuptools import setup
-    have_nd = False
-
-from Cython.Build import cythonize
-
-
-NAME = "PyFMI"
-AUTHOR = "Modelon AB"
-AUTHOR_EMAIL = ""
-VERSION = "3.0-dev"
-LICENSE = "LGPL"
-URL = "https://github.com/modelon-community/PyFMI"
-DOWNLOAD_URL = "https://github.com/modelon-community/PyFMI/releases"
-DESCRIPTION = "A package for working with dynamic models compliant with the Functional Mock-Up Interface standard."
-PLATFORMS = ["Linux", "Windows", "MacOS X"]
-CLASSIFIERS = [ 'Programming Language :: Python',
-                'Operating System :: MacOS :: MacOS X',
-                'Operating System :: Microsoft :: Windows',
-                'Operating System :: Unix']
-
-LONG_DESCRIPTION = """
-PyFMI is a package for loading and interacting with Functional Mock-Up
-Units (FMUs), which are compiled dynamic models compliant with the
-Functional Mock-Up Interface (FMI), see
-https://www.fmi-standard.org/ for more information. PyFMI
-is based on FMI Library, see https://github.com/modelon-community/fmi-library .
-
-FMI is a standard that enables tool independent exchange of dynamic
-models on binary format. Several industrial simulation platforms
-supports export of FMUs, including, Impact, Dymola, OpenModelica
-and SimulationX, see https://www.fmi-standard.org/tools
-for a complete list. PyFMI offers a Python interface for interacting
-with FMUs and enables for example loading of FMU models, setting of
-model parameters and evaluation of model equations.
-
-Using PyFMI together with the Python
-simulation package `Assimulo <http://pypi.python.org/pypi/Assimulo>`_
-adds industrial grade simulation capabilities of FMUs to Python.
-
-Requirements:
--------------
-- `FMI Library (at least 2.0.1) <https://github.com/modelon-community/fmi-library>`_
-- `Python-headers (usually included on Windows, python-dev on Ubuntu)`_
-- `Python 3.11 or newer`_
-- Python package dependencies are listed in file setup.cfg.
-
-Optional
----------
-- `wxPython <http://pypi.python.org/pypi/wxPython>`_ For the Plot GUI.
-- `matplotlib <http://pypi.python.org/pypi/matplotlib>`_ For the Plot GUI.
-
-Source Installation (note that assimulo needs to be installed and on PYTHONPATH in order to install pyfmi):
-----------------------
-
-python setup.py install --fmil-home=/path/to/FMI_Library/
-
-
-Dynamic FMI Library Handling in PyFMI Build Process
-===================================================
-
-PyFMI depends on the FMI Library (FMIL) for core functionality. Users can choose
-between static or dynamic linking via the --fmil-name build argument (default: 'fmilib_shared').
-
-When building with dynamic FMIL, the behavior varies by platform and build type:
-
-Platform-Specific Dynamic Library Handling:
--------------------------------------------
-
-**Windows Builds:**
-- Dynamic FMIL library (.dll) is automatically copied into the PyFMI package directory
-- Creates a self-contained installation with no external library dependencies
-- End users don't need separate FMIL installation or PATH configuration
-
-**Linux Standard Installation:**
-- PyFMI extensions are linked with RPATH pointing to original FMIL location
-- Dynamic library remains in its system installation directory
-- Requires FMIL to remain accessible at the configured path during runtime
-- Suitable for system-wide installations with centralized FMIL management
-- Smaller PyFMI package size due to external library reference
-
-**Linux Wheel Builds:**
-- Dynamic FMIL library is copied into the PyFMI package (similar to Windows)
-- RPATH set to '$ORIGIN' for relative library loading
-- Creates portable, self-contained wheels for distribution
-- No external FMIL dependency required at runtime
-
-**Static Library Alternative:**
-- When using static FMIL (--fmil-name without 'shared' suffix):
-- Library code is embedded directly into PyFMI extensions
-- Larger package size but completely self-contained
-- No runtime library dependencies
-
-Build Process Flow:
-------------------
-1. Locate FMIL library in specified directories (lib/, lib64/, bin/)
-2. For dynamic libraries on Windows or wheel builds: copy to package directory
-3. Configure appropriate RPATH settings for Linux installations
-4. Build Cython extensions with proper library linking
-5. Clean up temporary library copies after successful build
-
-This approach ensures PyFMI works correctly across different deployment scenarios
-while optimizing for each platform's conventions and user expectations.
-"""
-
-copy_args = sys.argv[1:]
-
-fmil_home = os.getenv("FMIL_HOME")
-if fmil_home: #Check for environment variable that specifies FMIL
-    incdirs = [os.path.join(fmil_home, 'include')]
-    # Specify both lib64 and 64, since can it depend on the platform (rockylinux/ubuntu etc)
-    libdirs = [os.path.join(fmil_home, 'lib64'), os.path.join(fmil_home, 'lib')]
-    bindirs = [os.path.join(fmil_home, 'bin')]
-else:
-    incdirs = []
-    libdirs = []
-    bindirs = []
-
-static = False
-debug_flag = False
-fmil_name = "fmilib_shared"
-fmilib_shared = ""
-copy_gcc_lib = False
-gcc_lib = None
-force_32bit = False
-no_msvcr = False
-with_openmp = False
-
-static_link_gcc = "-static-libgcc"
-flag_32bit = "-m32"
-extra_c_flags = ""
-
-is_windows = sys.platform.startswith("win")
-is_wheel_build = 'bdist_wheel' in sys.argv
-# Fix path sep
-for x in sys.argv[1:]:
-    if not x.find('--prefix'):
-        if not have_nd:
-            raise Exception("Cannot specify --prefix without numpy.distutils")
-        copy_args[copy_args.index(x)] = x.replace('/', os.sep)
-    if not x.find('--fmil-home'):
-        incdirs = [os.path.join(x[12:],'include')]
-        libdirs = [
-            os.path.join(x[12:],'lib'),
-            os.path.join(x[12:],'lib64'),
-        ]
-
-        multiarch = sysconfig.get_config_var('MULTIARCH')
-        if multiarch is not None:
-            libdirs.append(os.path.join(x[12:], 'lib', multiarch))
-
-        bindirs = [os.path.join(x[12:],'bin')]
-        copy_args.remove(x)
-    if not x.find('--fmil-name'):
-        fmil_name = x[12:]
-        copy_args.remove(x)
-    if not x.find('--copy-libgcc'):
-        if x[14:].upper() == "TRUE":
-            copy_gcc_lib = True
-        copy_args.remove(x)
-    if not x.find('--static'):
-        static = x[9:].upper() == "TRUE"
-        copy_args.remove(x)
-    if not x.find('--force-32bit'):
-        if x[14:].upper() == "TRUE":
-            force_32bit = True
-        copy_args.remove(x)
-    if not x.find('--no-msvcr'):
-        if x[11:].upper() == "TRUE":
-            if not have_nd:
-                raise Exception("Cannot specify --no-msvcr without numpy.distutils")
-            no_msvcr = True
-        copy_args.remove(x)
-    if not x.find('--extra-c-flags'):
-        extra_c_flags = x[16:]
-        copy_args.remove(x)
-    if not x.find('--with-openmp'):
-        with_openmp = True
-        copy_args.remove(x)
-    if not x.find('--version'):
-        VERSION = x[10:]
-        copy_args.remove(x)
-    if not x.find('--debug'):
-        if x[8:].upper() == "TRUE":
-            debug_flag = True
-        else:
-            debug_flag = False
-        copy_args.remove(x)
-
-if not incdirs:
-    raise Exception(
-        "FMI Library cannot be found. Please specify its location, " + \
-        "either using the flag to the setup script '--fmil-home' or" + \
-        " specify it using the environment variable FMIL_HOME."
-    )
-
-def find_dynamic_fmil_library(*directories):
-    """ Find the dynamic library of FMIL. """
-    for path_to_dir in chain(*directories):
-        path_to_dir = os.path.abspath(path_to_dir)
-
-        if not os.path.exists(path_to_dir):
-            continue
-
-        for file_name in os.listdir(path_to_dir):
-            full_path = os.path.join(path_to_dir, file_name)
-            if fmil_name in file_name and not file_name.endswith(".a"):
-                return full_path
-
-    raise Exception(
-        f"Could not find shared library '{fmil_name}' at either locations:" + \
-            f"\n\t{', '.join(dirs_to_search)}")
-
-if 0 != sys.argv[1].find("clean"): # Dont check if we are cleaning!
-
-    use_dynamic_fmil_library = fmil_name.endswith("shared") # TODO: this should be improved in a future release
-
-    remove_copied_fmil = False
-    if use_dynamic_fmil_library:
-        fmil_shared = find_dynamic_fmil_library(libdirs, bindirs)
-
-        if is_windows or is_wheel_build:
-            # Copy the fmil library to current directory, point to the location of the copied file
-            fmil_shared = shutil.copy2(fmil_shared, os.path.join(".", "src", "pyfmi"))
-            remove_copied_fmil = True
-
-
-    if is_windows and copy_gcc_lib:
-        path_gcc_lib = ctypes.util.find_library("libgcc_s_dw2-1.dll")
-        if path_gcc_lib is not None:
-            gcc_lib = shutil.copy2(path_gcc_lib,os.path.join(".", "src", "pyfmi"))
-
-if no_msvcr:
-    # prevent the MSVCR* being added to the DLLs passed to the linker
-    def msvc_runtime_library_mod():
-        return None
-
-    import numpy.distutils
-    numpy.distutils.misc_util.msvc_runtime_library = msvc_runtime_library_mod
-
-def check_extensions():
-    ext_list = []
-    extra_link_flags = []
-
-    if static:
-        extra_link_flags.append(static_link_gcc)
-
-    if force_32bit:
-        extra_link_flags.append(flag_32bit)
-
-    #COMMON PYX
-    """
-    ext_list = cythonize([os.path.join("src", "common", "core.pyx")],
-                    include_path=[".","src",os.path.join("src", "common")],
-                    include_dirs=[N.get_include()],pyrex_gdb=debug)
-
-    ext_list[-1].include_dirs = [N.get_include(), "src",os.path.join("src", "common"), incdirs]
-
-    if debug:
-        ext_list[-1].extra_compile_args = ["-g", "-fno-strict-aliasing", "-ggdb"]
-        ext_list[-1].extra_link_args = extra_link_flags
-    else:
-        ext_list[-1].extra_compile_args = ["-O2", "-fno-strict-aliasing"]
-        ext_list[-1].extra_link_args = extra_link_flags
-    """
-    incl_path = [".", "src", os.path.join("src", "pyfmi")]
-    # FMI PYX
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi_base.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi1.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi2.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi3.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # FMI UTIL
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi_util.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # FMI Extended PYX
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi_extended.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # FMI Coupled PYX
-    ext_list += cythonize([os.path.join("src", "pyfmi", "fmi_coupled.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # Simulation interface PYX
-    ext_list += cythonize([os.path.join("src", "pyfmi", "simulation", "assimulo_interface.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "simulation", "assimulo_interface_fmi1.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "simulation", "assimulo_interface_fmi2.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-    ext_list += cythonize([os.path.join("src", "pyfmi", "simulation", "assimulo_interface_fmi3.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # MASTER PYX
-    compile_time_env = {'WITH_OPENMP': with_openmp}
-    ext_list += cythonize([os.path.join("src", "pyfmi", "master.pyx")],
-                    include_path = incl_path,
-                    compile_time_env=compile_time_env,
-                    compiler_directives={'language_level' : "3str"})
-
-    # UTILITIES
-    ext_list += cythonize([os.path.join("src", "pyfmi", "util.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    # Test utilities
-    ext_list += cythonize([os.path.join("src", "pyfmi", "test_util.pyx")],
-                    include_path = incl_path,
-                    compiler_directives={'language_level' : "3str"})
-
-    if not is_windows and use_dynamic_fmil_library:
-        if is_wheel_build:
-            extra_link_flags += ['-Wl,-rpath,$ORIGIN']
-        else:
-            extra_link_flags += [f'-Wl,-rpath,{os.path.dirname(fmil_shared)}']
-
-
-    for i in range(len(ext_list)):
-
-        ext_list[i].include_dirs = [np.get_include(), "src", os.path.join("src", "pyfmi")] + incdirs
-        ext_list[i].library_dirs = libdirs
-        ext_list[i].language = "c"
-        ext_list[i].libraries = [fmil_name]
-
-        if debug_flag:
-            ext_list[i].extra_compile_args = ["-g", "-fno-strict-aliasing", "-ggdb"]
-        else:
-            ext_list[i].extra_compile_args = ["-O2", "-fno-strict-aliasing"]
-
-        if force_32bit:
-            ext_list[i].extra_compile_args.append(flag_32bit)
-
-        if extra_c_flags:
-            flags = extra_c_flags.split(' ')
-            for f in flags:
-                ext_list[i].extra_compile_args.append(f)
-
-        ext_list[i].extra_link_args = extra_link_flags
-
-        if with_openmp:
-            ext_list[i].extra_link_args.append("-fopenmp")
-            ext_list[i].extra_compile_args.append("-fopenmp")
-
-        ext_list[i].cython_directives = {"language_level": 3}
-
-    return ext_list
-
-ext_list = check_extensions()
-
-extra_package_data = [f'*{fmil_name}*']
-extra_package_data += ['libgcc_s_dw2-1.dll'] if is_windows and copy_gcc_lib else []
-
-setup(name=NAME,
-      version=VERSION,
-      license=LICENSE,
-      description=DESCRIPTION,
-      long_description=LONG_DESCRIPTION,
-      author=AUTHOR,
-      author_email=AUTHOR_EMAIL,
-      url=URL,
-      download_url=DOWNLOAD_URL,
-      platforms=PLATFORMS,
-      classifiers=CLASSIFIERS,
-      ext_modules = ext_list,
-      package_dir = {'pyfmi': os.path.join('src', 'pyfmi')},
-      packages=[
-        'pyfmi',
-        'pyfmi.simulation',
-        'pyfmi.examples',
-        'pyfmi.common',
-        'pyfmi.common.plotting',
-        'pyfmi.common.log'
-      ],
-      package_data = {'pyfmi': [
-        'examples/files/FMUs/ME1.0/*',
-        'examples/files/FMUs/CS1.0/*',
-        'examples/files/FMUs/ME2.0/*',
-        'examples/files/FMUs/CS2.0/*',
-        'util/*'] + extra_package_data
-        },
-      script_args=copy_args
-      )
-
-if 0 != sys.argv[1].find("clean"): # Dont check if we are cleaning!
-    if remove_copied_fmil:
-        os.remove(fmil_shared)
-    if gcc_lib and os.path.exists(gcc_lib):
-        os.remove(gcc_lib)

From c604ceff992370ba626395d77552e6e9a96447a4 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:57:46 +0200
Subject: [PATCH 07/16] build: simplify Dockerfile for the meson-python flow

Removes the source builds of SuperLU, SUNDIALS, and Assimulo from the
dev image: the assimulo-testing wheel pulled in via pip build
isolation already embeds SuperLU + SUNDIALS statically and dynamically
links libopenblas only. The system therefore needs just libopenblas
and gfortran at runtime.

Drops the pre-install of Cython/numpy/scipy/matplotlib too -- pip
build isolation resolves the build-time numpy/Cython from
pyproject.toml, and the wheel install pulls in runtime numpy / scipy /
matplotlib / assimulo-testing automatically.

Keeps the FMI Library 3.0.4 build into /usr (still a system dep,
detected by meson via -Dfmil_prefix=/usr).

The venv is created without --system-site-packages now that runtime
deps come from pip; this keeps the image self-contained and matches
how CI-built wheels will resolve dependencies on end-user systems.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 Dockerfile | 57 +++++++++++++++++++-----------------------------------
 1 file changed, 20 insertions(+), 37 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index cb3277bf..40608f78 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -2,49 +2,32 @@ FROM ubuntu:22.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Install Python
-RUN apt update && apt install software-properties-common -y && add-apt-repository ppa:deadsnakes/ppa
-RUN apt update && apt install python3.11 python3-pip python3.11-dev python3.11-venv -y
-
-# Install system
-RUN python3.11 -m pip install Cython numpy scipy matplotlib setuptools==69.1.0
-RUN apt-get -y install cmake liblapack-dev libsuitesparse-dev libhypre-dev curl git make vim bash-completion
-RUN cp -v /usr/lib/x86_64-linux-gnu/libblas.so /usr/lib/x86_64-linux-gnu/libblas_OPENMP.so
-
-# Install superlu
-RUN cd /tmp && \
-    curl -fSsL https://github.com/xiaoyeli/superlu_mt/archive/refs/tags/v4.0.1.tar.gz | tar xz && \
-    cd superlu_mt-4.0.1 && \
-    cmake -Denable_examples=OFF -Denable_tests=OFF -DPLAT="_OPENMP" -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_INSTALL_LIBDIR=lib -DSUPERLUMT_INSTALL_INCLUDEDIR=include . && \
-    make -j4 && \
-    make install
-
-# Install sundials
-RUN git clone --depth 1 -b v2.7.0 https://github.com/LLNL/sundials /tmp/sundials && \
-    cd /tmp/sundials && \
-    echo "target_link_libraries(sundials_idas_shared lapack blas superlu_mt_OPENMP)" >> src/idas/CMakeLists.txt && \
-    echo "target_link_libraries(sundials_kinsol_shared lapack blas superlu_mt_OPENMP)" >> src/kinsol/CMakeLists.txt && \
-    cmake -LAH -DSUPERLUMT_BLAS_LIBRARIES=blas -DSUPERLUMT_INCLUDE_DIR=/usr/include -DSUPERLUMT_LIBRARY=/usr/lib/libsuperlu_mt_OPENMP.a -DSUPERLUMT_THREAD_TYPE=OpenMP -DCMAKE_INSTALL_PREFIX=/usr -DSUPERLUMT_ENABLE=ON -DLAPACK_ENABLE=ON -DEXAMPLES_ENABLE=OFF -B build .  && \
-    cd build  && \
-    make -j4  && \
-    make install
-
-#Install assimulo
-RUN git clone --depth 1 -b Assimulo-3.8.0 https://github.com/modelon-community/Assimulo /tmp/Assimulo && \
-    cd /tmp/Assimulo && \
-    rm setup.cfg && \
-    python3.11 setup.py install --user --sundials-home=/usr --blas-home=/usr/lib/x86_64-linux-gnu/ --lapack-home=/usr/lib/x86_64-linux-gnu/ --superlu-home=/usr
-
-# Install fmilib
+# Python toolchain
+RUN apt-get update && apt-get install -y software-properties-common && \
+    add-apt-repository ppa:deadsnakes/ppa && \
+    apt-get update && apt-get install -y \
+      python3.11 python3.11-dev python3.11-venv python3-pip
+
+# Build prerequisites for FMIL + runtime libs pulled in by assimulo-testing
+# (it dynamically links libopenblas; SUNDIALS + SuperLU are statically
+# embedded in the wheel).
+RUN apt-get install -y \
+      cmake make curl git vim bash-completion \
+      libopenblas-dev gfortran
+
+# Install fmilib 3.0.4 into /usr
 RUN cd /tmp && \
     curl -fSsL https://github.com/modelon-community/fmi-library/archive/3.0.4.tar.gz | tar xz && \
     cd fmi-library-3.0.4 && \
     cmake -DCMAKE_INSTALL_PREFIX=/usr -DFMILIB_BUILD_TESTS=OFF -B build . && \
     cd build && \
-    make -j4 && \
-    make install
+    make -j"$(nproc)" && \
+    make install && \
+    rm -rf /tmp/fmi-library-3.0.4
 
-# Setup a venv to put pip and python on path for convinience running commands
+# Venv with pip + pytest preinstalled. PyFMI itself is built/installed by
+# `make build`, which runs pip install . with meson-python; build isolation
+# resolves Cython/numpy/assimulo-testing automatically from pyproject.toml.
 ARG PYTHON_VENV=/src/.venv
 ENV PATH=${PYTHON_VENV}/bin:$PATH
 WORKDIR /src

From a73ae4a216f87d67de2866a30d7f7d95a69f22fd Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 08:57:51 +0200
Subject: [PATCH 08/16] build: update Makefile to use pip install with meson
 config-settings

Replaces the old 'python setup.py build_ext install --fmil-home=/usr'
incantation with a pip install that passes the FMIL prefix to meson
via setup-args. Pip resolves build-system.requires from pyproject.toml
in isolation, then invokes meson-python with the meson option set.

Also drops the SETUPTOOLS_JFLAG variable (parallel build threading is
now handled by ninja, which uses all cores by default) and switches
.venv creation away from --system-site-packages (the image no longer
preinstalls numpy/scipy/matplotlib system-wide).

Test target gains an explicit tests/ path so we exercise the suite at
its canonical location.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 Makefile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile
index c5c2ef76..8848d32f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,6 @@
 .PHONY: build build-dev-image test shell
 DOCKER_IMAGE := pyfmi-dev
 IN_DOCKER_IMG := $(shell test -f /.dockerenv && echo 1 || echo 0)
-SETUPTOOLS_JFLAG=-j$(shell nproc)
 
 define _run
 	@if [ $(IN_DOCKER_IMG) -eq 1 ]; then \
@@ -19,14 +18,15 @@ build-dev-image:
 	docker build -t ${DOCKER_IMAGE} .
 
 .venv:
-	$(call _run, python3.11 -m venv .venv --system-site-packages)
+	$(call _run, python3.11 -m venv .venv)
+	$(call _run, pip install --upgrade pip)
 	$(call _run, pip install pytest)
 
 build: .venv
-	$(call _run, python setup.py build_ext ${SETUPTOOLS_JFLAG} install --fmil-home=/usr)
+	$(call _run, pip install . --config-settings=setup-args=-Dfmil_prefix=/usr)
 
 test: build
-	$(call _run, pytest)
+	$(call _run, pytest tests/)
 
 shell:
 	$(call _run, /bin/bash,-it)

From e512ca10b3aa0ce334cf9027e951e93cee73c968 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:51:45 +0200
Subject: [PATCH 09/16] ci: tidy build.yml; defer multi-Python matrix to
 wheels.yml

- Adds workflow_dispatch trigger so the smoke workflow can be rerun
  manually.
- Adds a concurrency group keyed on workflow+ref so superseded runs
  cancel themselves; PR pushes no longer queue stale builds.
- Renames the workflow + job for clarity; keeps the canonical Py3.11
  Docker smoke as the single linux job.
- Adds a comment pointing readers at wheels.yml + cibuildwheel for the
  multi-Python matrix (cp311/312/313) per the modernization plan.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 .github/workflows/build.yml | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 4ef6cca0..9469b38e 100755
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,19 +1,31 @@
+name: Smoke build
+
 on:
   push:
   pull_request:
+  workflow_dispatch:
 
 permissions:
   contents: read
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   linux:
+    name: Linux smoke (Py3.11 in Docker)
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-    - uses: actions/checkout@v4
-    - name: Install make
-      run: sudo apt install make -y
-    - name: Build
-      run: make build-dev-image && make build
-    - name: Test
-      run: make test
+      - uses: actions/checkout@v4
+      - name: Install make
+        run: sudo apt install make -y
+      - name: Build dev image
+        run: make build-dev-image
+      - name: Build PyFMI
+        run: make build
+      - name: Run tests
+        run: make test
+# Multi-Python coverage lives in wheels.yml, which exercises every supported
+# CPython against its built wheel.

From 3e12a831c92f3a7ad152934fa80b539e3c15bbbf Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:52:15 +0200
Subject: [PATCH 10/16] ci: add cibuildwheel configuration to pyproject.toml

Targets cp311/312/313 on Linux and Windows; skips 32-bit and musllinux.
Linux uses a pre-built pyfmi-manylinux Docker image (created from
Dockerfile.manylinux in the next commit) that has FMIL 3.0.4 installed
in /usr, so each wheel build can find it via -Dfmil_prefix=/usr.
Windows expects FMIL to be built into C:/deps by the GHA workflow
(tools/wheels/build_dependencies_windows.sh) before cibuildwheel runs.

Wheels are repaired with auditwheel on Linux and the project-local
delvewheel wrapper script (tools/wheels/repair_windows.ps1) on
Windows.

Each built wheel is exercised by 'pytest {project}/tests' so a wheel
that imports but fails at runtime is caught in CI rather than after
publish.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 pyproject.toml | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 4e8525cf..0c823002 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -45,3 +45,21 @@ dev = [
 
 [project.urls]
 Homepage = "https://github.com/modelon-community/PyFMI"
+
+[tool.cibuildwheel]
+build = "cp311-* cp312-* cp313-*"
+skip  = "*-win32 *-manylinux_i686 *-musllinux*"
+
+[tool.cibuildwheel.linux]
+# FMIL is pre-installed into /usr inside the pyfmi-manylinux image; build it
+# locally with `make build-manylinux-image` before invoking cibuildwheel.
+manylinux-x86_64-image = "pyfmi-manylinux"
+repair-wheel-command   = "auditwheel repair -w {dest_dir} {wheel}"
+config-settings        = {"setup-args" = ["-Dfmil_prefix=/usr"]}
+
+[tool.cibuildwheel.windows]
+# FMIL is built into C:/deps by the workflow's MSYS2 UCRT64 step before
+# cibuildwheel runs. UCRT64 is on PATH so meson selects gcc over MSVC.
+before-build         = "pip install delvewheel"
+repair-wheel-command = "pwsh {project}/tools/wheels/repair_windows.ps1 {wheel} {dest_dir}"
+config-settings      = {"setup-args" = ["-Dfmil_prefix=C:/deps"]}

From dc1df4bb18638647e9dcbff78adcc2aca10af997 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:56:21 +0200
Subject: [PATCH 11/16] ci: add Dockerfile.manylinux + FMIL build script

Adds a build-only docker image that compiles FMI Library 3.0.4 into
/usr on top of the quay.io/pypa/manylinux_2_28_x86_64 base. cibuildwheel
references this image via manylinux-x86_64-image = "pyfmi-manylinux"
in pyproject.toml, so each cp311/312/313 wheel build can locate FMIL
through -Dfmil_prefix=/usr (already configured in C11).

tools/wheels/build_dependencies.sh is the single source of truth for
the FMIL build; the manylinux image bakes it in at image-build time.
Mirrors the assimulo-manylinux pattern but drops SuperLU/SUNDIALS,
which the assimulo-testing wheel already embeds statically.

Adds the build-manylinux-image Makefile target so it can be
rebuilt locally with the same incantation CI uses.

Verified locally: 'make build-manylinux-image' produces FMIL 3.0.4 at
/usr/lib64/libfmilib_shared.so, and 'cibuildwheel --only
cp311-manylinux_x86_64' against this image yields a 6.9 MB manylinux
wheel that runs all 935 tests successfully (15 skipped, 0 failed).
The repaired wheel bundles libfmilib_shared into pyfmi.libs/ via
auditwheel.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 Dockerfile                         | 29 ++++++++---------------------
 Dockerfile.manylinux               |  9 +++++++++
 Makefile                           |  5 ++++-
 tools/wheels/build_dependencies.sh | 25 +++++++++++++++++++++++++
 4 files changed, 46 insertions(+), 22 deletions(-)
 create mode 100644 Dockerfile.manylinux
 create mode 100755 tools/wheels/build_dependencies.sh

diff --git a/Dockerfile b/Dockerfile
index 40608f78..2ef8c5db 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -2,32 +2,19 @@ FROM ubuntu:22.04
 
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Python toolchain
 RUN apt-get update && apt-get install -y software-properties-common && \
     add-apt-repository ppa:deadsnakes/ppa && \
     apt-get update && apt-get install -y \
-      python3.11 python3.11-dev python3.11-venv python3-pip
+      python3.11 python3.11-dev python3.11-venv python3-pip \
+      build-essential cmake curl git vim bash-completion \
+      libgfortran5 && \
+    rm -rf /var/lib/apt/lists/*
 
-# Build prerequisites for FMIL + runtime libs pulled in by assimulo-testing
-# (it dynamically links libopenblas; SUNDIALS + SuperLU are statically
-# embedded in the wheel).
-RUN apt-get install -y \
-      cmake make curl git vim bash-completion \
-      libopenblas-dev gfortran
+# Build FMIL from the same script the wheel pipeline uses, so the dev image
+# and the published wheels link against an identical FMIL build.
+COPY tools/wheels/build_dependencies.sh /tmp/build_dependencies.sh
+RUN bash /tmp/build_dependencies.sh && rm /tmp/build_dependencies.sh
 
-# Install fmilib 3.0.4 into /usr
-RUN cd /tmp && \
-    curl -fSsL https://github.com/modelon-community/fmi-library/archive/3.0.4.tar.gz | tar xz && \
-    cd fmi-library-3.0.4 && \
-    cmake -DCMAKE_INSTALL_PREFIX=/usr -DFMILIB_BUILD_TESTS=OFF -B build . && \
-    cd build && \
-    make -j"$(nproc)" && \
-    make install && \
-    rm -rf /tmp/fmi-library-3.0.4
-
-# Venv with pip + pytest preinstalled. PyFMI itself is built/installed by
-# `make build`, which runs pip install . with meson-python; build isolation
-# resolves Cython/numpy/assimulo-testing automatically from pyproject.toml.
 ARG PYTHON_VENV=/src/.venv
 ENV PATH=${PYTHON_VENV}/bin:$PATH
 WORKDIR /src
diff --git a/Dockerfile.manylinux b/Dockerfile.manylinux
new file mode 100644
index 00000000..0e9bd15d
--- /dev/null
+++ b/Dockerfile.manylinux
@@ -0,0 +1,9 @@
+FROM quay.io/pypa/manylinux_2_28_x86_64
+
+# Pre-bake FMIL so cibuildwheel can skip before-all and so local
+# `cibuildwheel --platform linux` runs reproduce the CI environment exactly.
+COPY tools/wheels/build_dependencies.sh /tmp/build_dependencies.sh
+RUN bash /tmp/build_dependencies.sh && rm /tmp/build_dependencies.sh
+
+WORKDIR /src
+CMD ["/bin/bash"]
diff --git a/Makefile b/Makefile
index 8848d32f..5ff72217 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: build build-dev-image test shell
+.PHONY: build build-dev-image build-manylinux-image test shell
 DOCKER_IMAGE := pyfmi-dev
 IN_DOCKER_IMG := $(shell test -f /.dockerenv && echo 1 || echo 0)
 
@@ -17,6 +17,9 @@ endef
 build-dev-image:
 	docker build -t ${DOCKER_IMAGE} .
 
+build-manylinux-image:
+	docker build -f Dockerfile.manylinux -t pyfmi-manylinux .
+
 .venv:
 	$(call _run, python3.11 -m venv .venv)
 	$(call _run, pip install --upgrade pip)
diff --git a/tools/wheels/build_dependencies.sh b/tools/wheels/build_dependencies.sh
new file mode 100755
index 00000000..e4c1b214
--- /dev/null
+++ b/tools/wheels/build_dependencies.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Builds FMI Library into /usr. The single source of truth for the FMIL
+# version used by the dev image, the manylinux image, and cibuildwheel.
+# Requires curl, tar, cmake, and a C compiler on PATH.
+set -eux
+
+# cibuildwheel's before-all environment can ship a minimal PATH; restore the
+# standard system paths so /usr/bin tools resolve.
+export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin${PATH:+:${PATH}}"
+
+FMIL_VERSION="3.0.4"
+NPROC=$(nproc)
+
+curl -fSsL \
+    "https://github.com/modelon-community/fmi-library/archive/${FMIL_VERSION}.tar.gz" \
+    | tar xz -C /tmp
+
+cmake -S "/tmp/fmi-library-${FMIL_VERSION}" \
+      -B "/tmp/fmi-library-${FMIL_VERSION}/build" \
+      -DCMAKE_INSTALL_PREFIX=/usr \
+      -DFMILIB_BUILD_TESTS=OFF
+
+make -C "/tmp/fmi-library-${FMIL_VERSION}/build" -j"${NPROC}"
+make -C "/tmp/fmi-library-${FMIL_VERSION}/build" install
+rm -rf "/tmp/fmi-library-${FMIL_VERSION}"

From 6e139233dcf1d5c9f1fd1822102ac56f193b357b Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:57:39 +0200
Subject: [PATCH 12/16] ci: add Windows FMIL build + delvewheel repair script

build_dependencies_windows.sh compiles FMI Library 3.0.4 into C:/deps
using the MSYS2 UCRT64 toolchain (gcc + ninja + cmake). The wheels.yml
workflow (C14) runs this script in an msys2 shell before invoking
cibuildwheel, so the windows wheel build can find FMIL via
-Dfmil_prefix=C:/deps (already configured in pyproject.toml).

repair_windows.ps1 wraps delvewheel to bundle fmilib_shared.dll plus
the MSYS2 UCRT64 runtime DLLs into each wheel; cibuildwheel invokes
it via repair-wheel-command. Mirrors the assimulo-testing
delvewheel wrapper pattern.

Untested locally (no Windows host available); validation lands when
the wheels.yml workflow is dispatched against a windows-2022 runner.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 tools/wheels/build_dependencies_windows.sh | 26 ++++++++++++++++++++++
 tools/wheels/repair_windows.ps1            |  7 ++++++
 2 files changed, 33 insertions(+)
 create mode 100755 tools/wheels/build_dependencies_windows.sh
 create mode 100644 tools/wheels/repair_windows.ps1

diff --git a/tools/wheels/build_dependencies_windows.sh b/tools/wheels/build_dependencies_windows.sh
new file mode 100755
index 00000000..d66d8cbf
--- /dev/null
+++ b/tools/wheels/build_dependencies_windows.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Windows counterpart to build_dependencies.sh. Runs under MSYS2 UCRT64 so
+# FMIL is built with the same gcc the extension modules link against,
+# avoiding the MSVC/MinGW ABI mismatch that breaks delvewheel bundling.
+set -eux
+
+FMIL_VERSION="3.0.4"
+INSTALL_PREFIX="/c/deps"
+NPROC=$(nproc 2>/dev/null || echo 4)
+
+mkdir -p "${INSTALL_PREFIX}/bin" "${INSTALL_PREFIX}/lib" "${INSTALL_PREFIX}/include"
+
+curl -fSsL \
+    "https://github.com/modelon-community/fmi-library/archive/${FMIL_VERSION}.tar.gz" \
+    | tar xz -C /tmp
+
+cmake -S "/tmp/fmi-library-${FMIL_VERSION}" \
+      -B "/tmp/fmi-library-${FMIL_VERSION}/build" \
+      -G Ninja \
+      -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" \
+      -DFMILIB_BUILD_TESTS=OFF \
+      -DCMAKE_BUILD_TYPE=Release
+
+cmake --build "/tmp/fmi-library-${FMIL_VERSION}/build" --parallel "${NPROC}"
+cmake --install "/tmp/fmi-library-${FMIL_VERSION}/build"
+rm -rf "/tmp/fmi-library-${FMIL_VERSION}"
diff --git a/tools/wheels/repair_windows.ps1 b/tools/wheels/repair_windows.ps1
new file mode 100644
index 00000000..9e9abc0b
--- /dev/null
+++ b/tools/wheels/repair_windows.ps1
@@ -0,0 +1,7 @@
+# delvewheel needs --add-path because FMIL and the UCRT64 runtime are not on
+# the system DLL search path inside cibuildwheel's worker process.
+param([string]$Wheel, [string]$DestDir)
+delvewheel repair `
+    --add-path "C:\msys64\ucrt64\bin;C:\deps\bin;C:\deps\lib" `
+    -w $DestDir `
+    $Wheel

From e3a496d8b7e607c68f8a6c279d146b5e4454507e Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:58:01 +0200
Subject: [PATCH 13/16] ci: add wheels.yml workflow for cibuildwheel

Builds cp311/312/313 wheels on Linux (manylinux_2_28_x86_64 via
pre-built pyfmi-manylinux image) and Windows (MSYS2 UCRT64 toolchain).
Each platform invokes cibuildwheel with the configuration in
pyproject.toml (C11), which runs the test suite against the
installed wheel before signing off.

Triggers:
  - push / pull_request: build wheels on every change to catch
    regressions before merge; no publish.
  - workflow_dispatch with publish=true on a v* tag: download
    artifacts, upload to PyPI via OIDC Trusted Publisher.

PyPI publishing uses the standard pypa/gh-action-pypi-publish action,
configured for the PyFMI project. The beta-rename step
(pyfmi -> pyfmi-testing) lands in C15 as a separate workflow input
so reviewers can opt into it without rewriting this baseline.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 .github/workflows/wheels.yml | 107 +++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 .github/workflows/wheels.yml

diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
new file mode 100644
index 00000000..6552e3a4
--- /dev/null
+++ b/.github/workflows/wheels.yml
@@ -0,0 +1,107 @@
+name: Build wheels
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: "Publish wheels to PyPI after building"
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    name: Linux wheels
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - run: pip install cibuildwheel
+
+      - name: Build manylinux image (FMIL pre-installed)
+        run: docker build -f Dockerfile.manylinux -t pyfmi-manylinux .
+
+      - name: Build wheels
+        run: cibuildwheel --platform linux --output-dir dist/
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux
+          path: dist/*.whl
+
+  windows:
+    name: Windows wheels
+    runs-on: windows-2022
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up MSYS2 UCRT64
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: UCRT64
+          update: true
+          install: >-
+            git
+            mingw-w64-ucrt-x86_64-gcc
+            mingw-w64-ucrt-x86_64-cmake
+            mingw-w64-ucrt-x86_64-ninja
+            mingw-w64-ucrt-x86_64-pkg-config
+
+      - name: Build FMI Library
+        shell: msys2 {0}
+        run: bash tools/wheels/build_dependencies_windows.sh
+
+      # cibuildwheel spawns a fresh pwsh; the MSYS2 setup-action's PATH and
+      # compiler vars are scoped to its own shell and need re-exporting here.
+      - name: Configure compiler environment
+        shell: pwsh
+        run: |
+          echo "C:\msys64\ucrt64\bin" | Out-File -FilePath $env:GITHUB_PATH -Append
+          echo "C:\deps\bin"          | Out-File -FilePath $env:GITHUB_PATH -Append
+          echo "CC=gcc"               | Out-File -FilePath $env:GITHUB_ENV  -Append
+          echo "CXX=g++"              | Out-File -FilePath $env:GITHUB_ENV  -Append
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - run: pip install cibuildwheel
+        shell: pwsh
+
+      - name: Build wheels
+        shell: pwsh
+        run: cibuildwheel --platform windows --output-dir dist/
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows
+          path: dist/*.whl
+
+  upload_pypi:
+    name: Upload to PyPI
+    needs: [linux, windows]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' && inputs.publish && startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/PyFMI
+    permissions:
+      id-token: write  # required for OIDC Trusted Publisher
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: dist/
+          merge-multiple: true
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

From 4631e851b408ded2c6114aed461fea75b48b05f3 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 09:58:49 +0200
Subject: [PATCH 14/16] ci: add beta-rename step to wheels.yml for
 pyfmi-testing

Adds a 'test_release' workflow_dispatch input that gates a sed-based
rewrite of the project name from 'PyFMI' to 'pyfmi-testing' in both
pyproject.toml and meson.build. Runs only when publishing
(publish=true && test_release=true), mirroring the assimulo-testing
pattern.

This lets us publish a parallel-installable beta to PyPI under
'pyfmi-testing' while the upstream PyFMI release stream is unaffected.
The sed step is intended to be removed once the modernization branch
is merged into modelon-community/PyFMI and released under the
canonical name.

Verified sed patterns locally against the current pyproject.toml line
13 and meson.build line 2.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 .github/workflows/wheels.yml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
index 6552e3a4..5f29f052 100644
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -9,6 +9,10 @@ on:
         description: "Publish wheels to PyPI after building"
         type: boolean
         default: false
+      test_release:
+        description: "Publish under the pyfmi-testing PyPI name instead of PyFMI"
+        type: boolean
+        default: false
 
 permissions:
   contents: read
@@ -21,6 +25,14 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Rewrite package name to pyfmi-testing
+        if: github.event_name == 'workflow_dispatch' && inputs.publish && inputs.test_release
+        run: |
+          sed -i 's/^name = "PyFMI"$/name = "pyfmi-testing"/' pyproject.toml
+          sed -i "s/^  'PyFMI',$/  'pyfmi-testing',/" meson.build
+          grep '^name = ' pyproject.toml
+          grep -n "pyfmi-testing" meson.build
+
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
@@ -45,6 +57,15 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Rewrite package name to pyfmi-testing
+        if: github.event_name == 'workflow_dispatch' && inputs.publish && inputs.test_release
+        shell: bash
+        run: |
+          sed -i 's/^name = "PyFMI"$/name = "pyfmi-testing"/' pyproject.toml
+          sed -i "s/^  'PyFMI',$/  'pyfmi-testing',/" meson.build
+          grep '^name = ' pyproject.toml
+          grep -n "pyfmi-testing" meson.build
+
       - name: Set up MSYS2 UCRT64
         uses: msys2/setup-msys2@v2
         with:

From 591a1ed5c88da123836f024e7f3295ece3fe0b32 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 10:31:16 +0200
Subject: [PATCH 15/16] fix: drop distutils.strtobool for Python 3.12+

distutils was removed in Python 3.12 (PEP 632), so the wheel build's
post-install test step failed during collection of test_log.py when
running on cp312/cp313:

    pyfmi/common/log/parser.py:24: ModuleNotFoundError: No module named 'distutils'
        from distutils.util import strtobool

The only call site (parse_value) is guarded by a regex that limits
input to the literals True/true/False/false, so strtobool's broader
truthy/falsy mapping is overkill. Inline a direct string compare
instead.

Verified end-to-end: 'cibuildwheel --only cp312-manylinux_x86_64'
produces a wheel and its post-install pytest run completes with 937
passed / 13 skipped, same as the cp311 Docker smoke build.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 src/pyfmi/common/log/parser.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/pyfmi/common/log/parser.py b/src/pyfmi/common/log/parser.py
index 8f2bede0..faceca04 100644
--- a/src/pyfmi/common/log/parser.py
+++ b/src/pyfmi/common/log/parser.py
@@ -21,7 +21,6 @@
 from xml import sax
 import re
 import numpy as np
-from distutils.util import strtobool
 from pyfmi.common.log.tree import Node, Comment
 from pyfmi.exceptions import FMUException
 from pathlib import Path
@@ -52,7 +51,7 @@ def parse_value(text):
     elif floatingpoint_pattern.match(text):
         return float(text)
     elif boolean_pattern.match(text):
-        return bool(strtobool(text))
+        return text.lower() == "true"
     else:
         if quoted_string_pattern.match(text):
             text = text[1:-1].replace('""','"')

From 722591b594d0ee823067130b3cbe3665ce7ca9a2 Mon Sep 17 00:00:00 2001
From: Emil Fredriksson <fredrikssonemil@hotmail.com>
Date: Sun, 17 May 2026 11:56:58 +0200
Subject: [PATCH 16/16] build: pin dev environment via requirements.lock

Mirrors the workflow used in Assimulo so contributors get a reproducible
dev venv regardless of when they clone. .venv is rebuilt whenever the
lockfile changes; make compile-deps regenerates the lockfile from
pyproject.toml.
---
 Makefile          | 33 +++++++++++++++++-------
 requirements.lock | 65 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+), 9 deletions(-)
 create mode 100644 requirements.lock

diff --git a/Makefile b/Makefile
index 5ff72217..0d22abdf 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,10 @@
-.PHONY: build build-dev-image build-manylinux-image test shell
-DOCKER_IMAGE := pyfmi-dev
-IN_DOCKER_IMG := $(shell test -f /.dockerenv && echo 1 || echo 0)
+.PHONY: build build-dev-image build-manylinux-image test shell compile-deps
+DOCKER_IMAGE      := pyfmi-dev
+MANYLINUX_IMAGE   := pyfmi-manylinux
+IN_DOCKER_IMG     := $(shell test -f /.dockerenv && echo 1 || echo 0)
+
+MESON_SETUP_ARGS := -Dfmil_prefix=/usr
+PIP_SETUP_ARGS   := $(addprefix -Csetup-args=,$(MESON_SETUP_ARGS))
 
 define _run
 	@if [ $(IN_DOCKER_IMG) -eq 1 ]; then \
@@ -14,22 +18,33 @@ define _run
 	fi
 endef
 
+define _run_with_venv
+	$(call _run, bash -c '. .venv/bin/activate && $(1)')
+endef
+
 build-dev-image:
 	docker build -t ${DOCKER_IMAGE} .
 
 build-manylinux-image:
-	docker build -f Dockerfile.manylinux -t pyfmi-manylinux .
+	docker build -f Dockerfile.manylinux -t ${MANYLINUX_IMAGE} .
 
-.venv:
+.venv: requirements.lock
 	$(call _run, python3.11 -m venv .venv)
-	$(call _run, pip install --upgrade pip)
-	$(call _run, pip install pytest)
+	$(call _run_with_venv, pip install -r requirements.lock)
+	$(call _run, touch .venv)
 
 build: .venv
-	$(call _run, pip install . --config-settings=setup-args=-Dfmil_prefix=/usr)
+	$(call _run_with_venv, pip install . -v $(PIP_SETUP_ARGS))
 
 test: build
-	$(call _run, pytest tests/)
+	$(call _run_with_venv, pytest tests/)
 
 shell:
 	$(call _run, /bin/bash,-it)
+
+# Regenerate requirements.lock from pyproject.toml. Run after changing
+# build-system requires or runtime dependencies; commit the resulting file.
+compile-deps:
+	$(call _run, python3.11 -m venv .venv)
+	$(call _run_with_venv, pip install pip-tools)
+	$(call _run_with_venv, pip-compile --extra=dev --output-file=requirements.lock pyproject.toml)
diff --git a/requirements.lock b/requirements.lock
new file mode 100644
index 00000000..c5ca4b73
--- /dev/null
+++ b/requirements.lock
@@ -0,0 +1,65 @@
+#
+# This file is autogenerated by pip-compile with Python 3.11
+# by the following command:
+#
+#    pip-compile --extra=dev --output-file=requirements.lock pyproject.toml
+#
+assimulo-testing==3.9.0b1
+    # via PyFMI (pyproject.toml)
+contourpy==1.3.3
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+cython==3.2.4
+    # via PyFMI (pyproject.toml)
+fonttools==4.63.0
+    # via matplotlib
+iniconfig==2.3.0
+    # via pytest
+kiwisolver==1.5.0
+    # via matplotlib
+matplotlib==3.10.9
+    # via
+    #   PyFMI (pyproject.toml)
+    #   assimulo-testing
+meson==1.11.1
+    # via
+    #   PyFMI (pyproject.toml)
+    #   meson-python
+meson-python==0.19.0
+    # via PyFMI (pyproject.toml)
+ninja==1.13.0
+    # via PyFMI (pyproject.toml)
+numpy==2.4.5
+    # via
+    #   PyFMI (pyproject.toml)
+    #   assimulo-testing
+    #   contourpy
+    #   matplotlib
+    #   scipy
+packaging==26.2
+    # via
+    #   matplotlib
+    #   meson-python
+    #   pyproject-metadata
+    #   pytest
+pillow==12.2.0
+    # via matplotlib
+pluggy==1.6.0
+    # via pytest
+pygments==2.20.0
+    # via pytest
+pyparsing==3.3.2
+    # via matplotlib
+pyproject-metadata==0.11.0
+    # via meson-python
+pytest==9.0.3
+    # via PyFMI (pyproject.toml)
+python-dateutil==2.9.0.post0
+    # via matplotlib
+scipy==1.17.1
+    # via
+    #   PyFMI (pyproject.toml)
+    #   assimulo-testing
+six==1.17.0
+    # via python-dateutil