pythonfmu3 0.3.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

pythonfmu3/__main__.py

@@ -43,6 +43,14 @@ def cli_main():
     )
     deploy.create_command_parser(deploy_parser)
 
+    studio_parser = subparsers.add_parser(
+        "studio",
+        description="Open PythonFMU3 Studio, a local web app to edit, check, simulate, build and inspect FMUs.",
+        help="Open the PythonFMU3 Studio web app."
+    )
+    from .studio.server import create_command_parser as create_studio_parser
+    create_studio_parser(studio_parser)
+
     options = vars(parser.parse_args())
     execute = options.pop("execute")
     execute(**options)

pythonfmu3/_version.py

@@ -1 +1 @@
-__version__ = "0.3.4"
+__version__ = "1.1.0"

pythonfmu3/builder.py

@@ -1,15 +1,16 @@
 """Python FMU builder"""
 import argparse
-import importlib
+import importlib.util
 import itertools
 import logging
 import re
 import shutil
 import sys
+import sysconfig
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import Iterable, Optional, Tuple, Union
+from typing import Iterable, List, Optional, Tuple, Union
 from xml.dom.minidom import parseString
 from xml.etree.ElementTree import Element, SubElement, tostring
 from .osutil import get_lib_extension, get_platform
@@ -21,13 +22,49 @@ HERE = Path(__file__).parent
 logger = logging.getLogger(__name__)
 
 
+_SLAVE_CLASS_RE = re.compile(r'^class (\w+)\(([^)]*\bFmi3Slave(?:Base)?\b[^)]*)\)\s*:', re.MULTILINE)
+
+
 def get_class_name(file_name: Path) -> str:
-    with open(str(file_name), 'r') as file:
-        data = file.read()
-        return re.search(r'class (\w+)\(([^)]*\bFmi3Slave(?:Base)?\b[^)]*)\)\s*:', data).group(1)
+    """Find the name of the first class in *file_name* that textually extends Fmi3Slave/Fmi3SlaveBase."""
+    data = Path(file_name).read_text(encoding="utf-8")
+    match = _SLAVE_CLASS_RE.search(data)
+    if match is None:
+        raise ValueError(f"Unable to find a class extending Fmi3Slave or Fmi3SlaveBase in {file_name!s}")
+    return match.group(1)
+
 
+def _find_slave_class(module, filepath: Path) -> type:
+    """Locate the FMU class in an imported module.
 
-def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Element]:
+    Classes defined in the module that inherit from Fmi3SlaveBase are candidates. If the
+    regex-based lookup (also used by the native wrapper as a fallback) matches one of them
+    it wins, so behaviour stays identical for existing scripts; otherwise a single
+    candidate is accepted (this handles multi-line base lists and indirect inheritance).
+    """
+    candidates = {
+        name: obj for name, obj in vars(module).items()
+        if isinstance(obj, type)
+        and obj.__module__ == module.__name__
+        and any(base.__name__ == Fmi3SlaveBase.__name__ for base in obj.__mro__)
+    }
+    try:
+        preferred = get_class_name(filepath)
+    except ValueError:
+        preferred = None
+    if preferred in candidates:
+        return candidates[preferred]
+    if len(candidates) == 1:
+        return next(iter(candidates.values()))
+    if not candidates:
+        raise ValueError(f"No class inheriting from {Fmi3SlaveBase.__qualname__} found in {filepath!s}")
+    raise ValueError(
+        f"Several FMU classes found in {filepath!s} ({', '.join(sorted(candidates))}); "
+        "keep a single Fmi3Slave subclass per script."
+    )
+
+
+def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Element, str]:
     """Extract the FMU model description as XML.
 
     Args:
@@ -35,7 +72,7 @@ def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Elemen
         module_name (str) : python module to load
 
     Returns:
-        Tuple[str, xml.etree.TreeElement.Element] : FMU model name, model description
+        Tuple[str, xml.etree.TreeElement.Element, str] : FMU model name, model description, class name
     """
     # Add current folder to handle local dependencies
     sys.path.insert(0, str(filepath.parent))
@@ -45,8 +82,9 @@ def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Elemen
         fmu_interface = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(fmu_interface)
         # Instantiate the interface
-        class_name = get_class_name(filepath)
-        instance = getattr(fmu_interface, class_name)(instance_name="dummyInstance", resources=str(filepath.parent))
+        slave_class = _find_slave_class(fmu_interface, filepath)
+        class_name = slave_class.__name__
+        instance = slave_class(instance_name="dummyInstance", resources=str(filepath.parent))
     finally:
         sys.path.remove(str(filepath.parent))  # remove inserted temporary path
 
@@ -55,7 +93,30 @@ def get_model_description(filepath: Path, module_name: str) -> Tuple[str, Elemen
             f"The provided class '{class_name}' does not inherit from {Fmi3SlaveBase.__qualname__}"
         )
     # Produce the xml
-    return instance.modelName, instance.to_xml()
+    return instance.modelName, instance.to_xml(), class_name
+
+
+def _is_fmu_entry_library(path: Path) -> bool:
+    """True for the library exporting the FMI functions (renamed to the model identifier)."""
+    return path.stem in ("pythonfmu-export", "libpythonfmu-export")
+
+
+def _libpython_candidates() -> List[str]:
+    """Paths of the shared libpython of the running interpreter, if it has one."""
+    if sys.platform == "win32":
+        return []  # the Windows library links python3.dll directly
+    libdir = sysconfig.get_config_var("LIBDIR") or ""
+    framework_prefix = sysconfig.get_config_var("PYTHONFRAMEWORKPREFIX") or ""
+    candidates = []
+    for name in (sysconfig.get_config_var("INSTSONAME"), sysconfig.get_config_var("LDLIBRARY")):
+        if not name or name.endswith(".a"):
+            continue  # statically linked interpreter: nothing to point at
+        for base in (libdir, framework_prefix):
+            if base:
+                candidate = Path(base) / name
+                if candidate.is_file() and str(candidate) not in candidates:
+                    candidates.append(str(candidate))
+    return candidates
 
 
 class FmuBuilder:
@@ -64,7 +125,7 @@ class FmuBuilder:
     def build_FMU(
         script_file: FilePath,
         dest: FilePath = ".",
-        project_files: Iterable[FilePath] = set(),
+        project_files: Iterable[FilePath] = (),
         documentation_folder: Optional[FilePath] = None,
         terminals : Optional[FilePath] = None,
         **options,
@@ -130,7 +191,7 @@ class FmuBuilder:
                     else:
                         shutil.copy2(file_, temp_dir)
 
-            model_identifier, xml = get_model_description(
+            model_identifier, xml, class_name = get_model_description(
                 temp_dir.absolute() / script_file.name, module_name
             )
 
@@ -163,8 +224,20 @@ class FmuBuilder:
                         relative_f = f.relative_to(temp_dir)
                         zip_fmu.write(f, arcname=(resource / relative_f))
 
-                # Add information for the Python loader
-                zip_fmu.writestr(str(resource.joinpath("slavemodule.txt")), module_name)
+                # Hint for the Linux/macOS shim: where the Python that built this FMU
+                # keeps its shared library (used when the importer is not Python itself).
+                libpython_hints = _libpython_candidates()
+                if libpython_hints:
+                    zip_fmu.writestr(
+                        str(resource.joinpath("pythonfmu_libpython.txt")),
+                        "\n".join(libpython_hints) + "\n",
+                    )
+
+                # Add information for the Python loader: line 1 is the module, line 2 the class.
+                # Older wrappers only read the first line, so this stays backward compatible.
+                zip_fmu.writestr(
+                    str(resource.joinpath("slavemodule.txt")), f"{module_name}\n{class_name}\n"
+                )
 
                 # Add FMI API wrapping Python class source
                 sources = Path("sources")
@@ -174,7 +247,7 @@ class FmuBuilder:
                 ):
                     relative_f = f.relative_to(src)
                     if "build" in relative_f.parts:
-                        continue;
+                        continue
                     zip_fmu.write(f, arcname=(sources / relative_f))
 
                 # Add FMI API wrapping Python class library
@@ -186,12 +259,13 @@ class FmuBuilder:
                     src_binaries.rglob("*.dylib"),
                 ):
                     relative_f = f.relative_to(src_binaries)
-                    arcname = (
-                        binaries
-                        / relative_f.parent
-                        / f"{model_identifier}{relative_f.suffix}"
-                    )
-                    zip_fmu.write(f, arcname=arcname)
+                    # Only the FMI entry-point library takes the model identifier's name;
+                    # helper libraries (the Linux/macOS backend) keep their own name.
+                    if _is_fmu_entry_library(f):
+                        name = f"{model_identifier}{relative_f.suffix}"
+                    else:
+                        name = relative_f.name
+                    zip_fmu.write(f, arcname=(binaries / relative_f.parent / name))
 
                 # Add the documentation folder
                 if documentation_folder is not None:
@@ -203,9 +277,7 @@ class FmuBuilder:
 
                 if terminals is not None:
                     terminalsFolder = Path("terminalsAndIcons")
-                    relative_f = terminals.relative_to(terminals.parent)
-                    zip_fmu.write(f, arcname=(terminalsFolder / relative_f))
-                    
+                    zip_fmu.write(terminals, arcname=(terminalsFolder / terminals.name))
 
                 # Add the model description
                 xml_str = parseString(tostring(xml, "UTF-8"))

pythonfmu3/fmi3slave.py

@@ -76,7 +76,7 @@ class Fmi3SlaveBase(object):
         self.type_definitions: Dict[str, VariableType] = {}
         self.units: Dict[str, Unit] = {}
 
-    def to_xml(self, model_options: Dict[str, str] = dict()) -> Element:
+    def to_xml(self, model_options: Optional[Dict[str, Any]] = None) -> Element:
         """Build the XML representation of the model.
         
         Args:
@@ -110,20 +110,24 @@ class Fmi3SlaveBase(object):
 
         root = Element("fmiModelDescription", attrib)
 
+        model_options = model_options or {}
+
+        def _resolve(option: ModelOptions) -> str:
+            return str(model_options.get(option.name, option.value)).lower()
+
         options = dict()
         for option in FMI3_MODEL_OPTIONS_COMMON:
-            value = model_options.get(option.name, option.value)
-            options[option.name] = str(value).lower()
+            options[option.name] = _resolve(option)
         
         options["modelIdentifier"] = self.modelName
 
         options_cs = options.copy()
         for option in FMI3_MODEL_OPTIONS_COSIM:
-            options_cs[option.name] = str(value).lower()
+            options_cs[option.name] = _resolve(option)
         
         options_me = options.copy()
         for option in FMI3_MODEL_OPTIONS_MX:
-            options_me[option.name] = str(value).lower()
+            options_me[option.name] = _resolve(option)
 
         # check if we have cosim mixin or model exchange mixin
         if isinstance(self, ModelExchange):
@@ -175,9 +179,7 @@ class Fmi3SlaveBase(object):
             filter(lambda v: v.causality == Fmi3Causality.output, self.vars.values())
         )
 
-        continuous_state_derivatives = list(
-            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
-        )
+        continuous_state_derivatives = self._continuous_state_derivatives()
 
         allowed_variability = [None, Fmi3Initial.approx, Fmi3Initial.calculated]
         initial_unknown = list(
@@ -200,6 +202,15 @@ class Fmi3SlaveBase(object):
 
         return root
 
+    def _continuous_state_derivatives(self) -> List[Float64]:
+        """Return the registered derivative variables (one per continuous state), in registration order."""
+        return [
+            v for v in self.vars.values()
+            if isinstance(v, Float64)
+            and v.variability == Fmi3Variability.continuous
+            and v.derivative is not None
+        ]
+
     def __apply_start_value(self, var: ModelVariable):
         vrs = [var.value_reference]
         if isinstance(var, Int32):
@@ -243,7 +254,7 @@ class Fmi3SlaveBase(object):
         if var.setter is None and hasattr(owner, var.local_name) and var.variability != Fmi3Variability.constant:
             if hasattr(var, "dimensions") and len(var.dimensions) > 0:
                 import numpy as np
-                var.setter = lambda v: setattr(owner, var.local_name, np.reshape(v, newshape=getattr(owner, var.local_name).shape))
+                var.setter = lambda v: setattr(owner, var.local_name, np.reshape(v, getattr(owner, var.local_name).shape))
             else:
                 var.setter = lambda v: setattr(owner, var.local_name, v)
         
@@ -476,9 +487,7 @@ class Fmi3SlaveBase(object):
 
     def set_continuous_states(self, values: List[float]):
         offset = 0
-        continuous_state_derivatives = list(
-            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
-        )
+        continuous_state_derivatives = self._continuous_state_derivatives()
 
         vrs = [v.derivative for v in continuous_state_derivatives]
         
@@ -492,10 +501,7 @@ class Fmi3SlaveBase(object):
             offset += size
         
     def get_continuous_states(self) -> List[float]:
-        offset = 0
-        continuous_state_derivatives = list(
-            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
-        )
+        continuous_state_derivatives = self._continuous_state_derivatives()
 
         vrs = [v.derivative for v in continuous_state_derivatives]
         
@@ -510,9 +516,7 @@ class Fmi3SlaveBase(object):
         return refs
     
     def get_number_of_continuous_states(self) -> int:
-        continuous_state_derivatives = list(
-            filter(lambda v: v.variability == Fmi3Variability.continuous and (isinstance(v, Float64) and v.derivative is not None), self.vars.values())
-        )
+        continuous_state_derivatives = self._continuous_state_derivatives()
         return len(continuous_state_derivatives)
     
     def set_time(self, time: float):

pythonfmu3/modelexchange.py

@@ -3,13 +3,28 @@ from dataclasses import dataclass
 
 @dataclass
 class Fmi3UpdateDiscreteStatesResult:
-    discreteStateNeedsUpdate: bool = False
+    """Return value of `update_discrete_states`, mirroring the outputs of fmi3UpdateDiscreteStates."""
+    discreteStatesNeedUpdate: bool = False
     terminateSimulation: bool = False
-    nominalsOfContinuousStatesChanged: bool = False
+    nominalContinuousStatesChanged: bool = False
     valuesOfContinuousStatesChanged: bool = False
     nextEventTimeDefined: bool = False
     nextEventTime: float = 0.0
 
+
+def _alias(field_name: str) -> property:
+    return property(
+        lambda self: getattr(self, field_name),
+        lambda self, value: setattr(self, field_name, value),
+        doc=f"Deprecated alias of `{field_name}`.",
+    )
+
+
+# Earlier releases used these names, which the FMU wrapper never read (so the flags were
+# silently ignored). Kept as aliases so existing models keep working - and now take effect.
+Fmi3UpdateDiscreteStatesResult.discreteStateNeedsUpdate = _alias("discreteStatesNeedUpdate")
+Fmi3UpdateDiscreteStatesResult.nominalsOfContinuousStatesChanged = _alias("nominalContinuousStatesChanged")
+
 class RequireTimeMeta(ABCMeta):
     def __init__(cls, name, bases, namespace):
         super().__init__(name, bases, namespace)

pythonfmu3/osutil.py

@@ -1,14 +1,40 @@
+import platform
 import sys
 
-import platform
+# FMI 3.0 platform tuples are "<arch>-<sys>" (FMI 3.0 standard, section 2.5.1.4),
+# e.g. x86_64-linux, aarch64-darwin, x86-windows.
+_SYSTEMS = {"Windows": "windows", "Linux": "linux", "Darwin": "darwin"}
+
+_ARCHITECTURES_64 = {
+    "x86_64": "x86_64", "amd64": "x86_64", "x64": "x86_64",
+    "i386": "x86_64", "i686": "x86_64", "x86": "x86_64",  # 64-bit Python on x86 hardware
+    "aarch64": "aarch64", "arm64": "aarch64", "armv8l": "aarch64",
+    "ppc64": "ppc64", "ppc64le": "ppc64",
+    "riscv64": "riscv64",
+}
+
+_ARCHITECTURES_32 = {
+    "x86_64": "x86", "amd64": "x86", "x64": "x86", "i386": "x86", "i686": "x86", "x86": "x86",
+    "aarch64": "aarch32", "arm64": "aarch32", "armv7l": "aarch32", "armv8l": "aarch32", "arm": "aarch32",
+    "ppc": "ppc32",
+    "riscv32": "riscv32",
+}
+
+
+def _is_64bit() -> bool:
+    # Bitness of the running interpreter, which is what the FMU binary must match
+    # (e.g. a 32-bit Python on 64-bit Windows needs x86-windows).
+    return sys.maxsize > 2 ** 32
+
+
+def get_fmu_arch() -> str:
+    """FMI 3.0 platform tuple of the running interpreter, e.g. 'aarch64-darwin'."""
+    machine = platform.machine().lower()
+    table = _ARCHITECTURES_64 if _is_64bit() else _ARCHITECTURES_32
+    arch = table.get(machine, machine or "unknown")
+    system = _SYSTEMS.get(platform.system(), platform.system().lower() or "unknown")
+    return f"{arch}-{system}"
 
-def get_fmu_arch():
-    #is_64bits = sys.maxsize > 2 ** 32
-    system = platform.system()
-    is_x86 = platform.machine() in ["i386", "AMD64", "x86_64"]
-    platforms = {"Windows": "windows", "Linux": "linux", "Darwin": "darwin"}
-    arch = "x86_64" if is_x86 else "x86"
-    return arch + "-" + platforms.get(system, "unknown")
 
 def get_platform() -> str:
     """Get FMU binary platform folder name."""
@@ -19,4 +45,3 @@ def get_lib_extension() -> str:
     """Get FMU library platform extension."""
     platforms = {"Darwin": "dylib", "Linux": "so", "Windows": "dll"}
     return platforms.get(platform.system(), "")
-

pythonfmu3/pythonfmu-export/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(pythonfmu-export VERSION 0.2.0)
+project(pythonfmu-export VERSION 1.0.0)
 
 # ==============================================================================
 # Build settings
@@ -48,12 +48,44 @@ else ()
   set(TARGET_PLATFORM linux)
 endif ()
 
-if ("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
-  set(TARGET_PLATFORM x86_64-${TARGET_PLATFORM})
+# FMI 3.0 platform tuple <arch>-<sys>; must match pythonfmu3/osutil.py:get_fmu_arch().
+# The architecture is the one being *built for*: the Visual Studio -A option, or a single
+# CMAKE_OSX_ARCHITECTURES entry on macOS, take precedence over the host processor.
+if (CMAKE_GENERATOR_PLATFORM)
+  set(_arch "${CMAKE_GENERATOR_PLATFORM}")
+elseif (APPLE AND CMAKE_OSX_ARCHITECTURES)
+  list(LENGTH CMAKE_OSX_ARCHITECTURES _n_arch)
+  if (NOT _n_arch EQUAL 1)
+    message(FATAL_ERROR "Universal builds are not supported: set CMAKE_OSX_ARCHITECTURES to a single architecture")
+  endif ()
+  set(_arch "${CMAKE_OSX_ARCHITECTURES}")
+else ()
+  set(_arch "${CMAKE_SYSTEM_PROCESSOR}")
+endif ()
+string(TOLOWER "${_arch}" _arch)
+
+if (_arch MATCHES "^(aarch64|arm64|armv8)")
+  set(_fmi_arch aarch64)
+elseif (_arch MATCHES "^arm")
+  set(_fmi_arch aarch32)
+elseif (_arch MATCHES "^(x86_64|amd64|x64|i[3-6]86|x86|win32)$")
+  set(_fmi_arch x86)
 else ()
-  set(TARGET_PLATFORM x86-${TARGET_PLATFORM})
+  set(_fmi_arch "${_arch}")
 endif ()
 
+if ("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+  if (_fmi_arch STREQUAL "x86")
+    set(_fmi_arch x86_64)
+  elseif (_fmi_arch STREQUAL "aarch32")
+    set(_fmi_arch aarch64)
+  endif ()
+elseif (_fmi_arch STREQUAL "aarch64")
+  set(_fmi_arch aarch32)
+endif ()
+
+set(TARGET_PLATFORM ${_fmi_arch}-${TARGET_PLATFORM})
+
 message("Building pythonfmu-export for platform ${TARGET_PLATFORM}")
 
 add_subdirectory(src)

pythonfmu3/pythonfmu-export/generate_shim.py

@@ -0,0 +1,88 @@
+"""Generate src/shim/fmi3_forwarders.cpp from src/fmi/fmi3FunctionTypes.h.
+
+The shim is the library the importer loads on Linux/macOS. It has no link-time
+dependency on libpython: on instantiation it loads libpython (unless the host process
+already provides it, e.g. when the importer is itself written in Python) and then the
+real implementation (the "backend" library), and forwards every FMI call to it.
+
+Re-run this script after updating the FMI headers:
+    python generate_shim.py
+"""
+import re
+from pathlib import Path
+
+HERE = Path(__file__).parent
+TYPES_HEADER = HERE / "src" / "fmi" / "fmi3FunctionTypes.h"
+OUTPUT = HERE / "src" / "shim" / "fmi3_forwarders.cpp"
+
+TYPEDEF_RE = re.compile(r"typedef\s+([\w\s\*]+?)\s*\b(fmi3\w+)TYPE\s*\((.*?)\)\s*;", re.S)
+INSTANTIATE = {
+    "fmi3InstantiateModelExchange",
+    "fmi3InstantiateCoSimulation",
+    "fmi3InstantiateScheduledExecution",
+}
+
+
+def param_names(params: str):
+    params = " ".join(params.split())
+    if params in ("", "void"):
+        return []
+    return [re.findall(r"\w+", p.replace("[]", ""))[-1] for p in params.split(",")]
+
+
+def main():
+    functions = [
+        (" ".join(ret.split()), name, " ".join(params.split()))
+        for ret, name, params in TYPEDEF_RE.findall(TYPES_HEADER.read_text())
+    ]
+    forwarded = [f for f in functions if f[1] != "fmi3GetVersion"]
+
+    out = [
+        "// GENERATED by generate_shim.py from fmi/fmi3FunctionTypes.h - do not edit by hand.",
+        '#include "shim/shim_loader.hpp"',
+        "",
+        "namespace pythonfmu_shim",
+        "{",
+        "const char* const kFunctionNames[] = {",
+        *[f'    "{name}",' for _, name, _ in forwarded],
+        "};",
+        f"const std::size_t kFunctionCount = {len(forwarded)};",
+        "} // namespace pythonfmu_shim",
+        "",
+        'extern "C" {',
+        "",
+        "FMI3_Export const char* fmi3GetVersion(void)",
+        "{",
+        "    return fmi3Version;",
+        "}",
+        "",
+    ]
+    for index, (ret, name, params) in enumerate(forwarded):
+        names = param_names(params)
+        args = ", ".join(names)
+        out.append(f"FMI3_Export {ret} {name}({params})")
+        out.append("{")
+        if name in INSTANTIATE:
+            out.append(
+                "    if (!pythonfmu_shim::ensureBackendLoaded(resourcePath, instanceEnvironment, logMessage)) return nullptr;"
+            )
+        out.append(f"    const auto fn = reinterpret_cast<{name}TYPE*>(pythonfmu_shim::function({index}));")
+        if ret == "void":
+            out.append(f"    if (fn) fn({args});")
+        elif ret == "fmi3Status":
+            out.append("    if (!fn) return fmi3Error;")
+            out.append(f"    return fn({args});")
+        else:
+            out.append("    if (!fn) return nullptr;")
+            out.append(f"    return fn({args});")
+        out.append("}")
+        out.append("")
+    out.append('} // extern "C"')
+    out.append("")
+    OUTPUT.parent.mkdir(exist_ok=True)
+    OUTPUT.write_text("\n".join(out))
+    print(f"wrote {OUTPUT.relative_to(HERE)} ({len(functions)} functions)")
+
+
+if __name__ == "__main__":
+    main()

pythonfmu3/pythonfmu-export/src/CMakeLists.txt

@@ -1,4 +1,3 @@
-
 set(headers
         cppfmu/cppfmu_cs.hpp
         cppfmu/cppfmu_common.hpp
@@ -17,29 +16,58 @@ set(sources
         pythonfmu/PySlaveInstance.cpp
         )
 
-add_library(pythonfmu-export ${sources} ${headers})
-target_compile_features(pythonfmu-export PUBLIC "cxx_std_17")
+set(BINARY_OUTPUT_DIR "${CMAKE_SOURCE_DIR}/../resources/binaries/${TARGET_PLATFORM}")
 
-target_include_directories(pythonfmu-export
+if (WIN32)
+  # Windows: a single library, linked against the version-independent python3.dll.
+  set(PYTHONFMU_IMPL_TARGET pythonfmu-export)
+else ()
+  # Linux/macOS: the Python-dependent implementation lives in a "backend" library
+  # (FMI functions renamed with a prefix). The FMU library itself (pythonfmu-export,
+  # renamed to <modelIdentifier> by the builder) is a small shim with no link-time
+  # dependency on libpython, so non-Python importers can load it. See shim/shim_loader.cpp.
+  set(PYTHONFMU_IMPL_TARGET pythonfmu-backend)
+endif ()
+
+add_library(${PYTHONFMU_IMPL_TARGET} ${sources} ${headers})
+target_compile_features(${PYTHONFMU_IMPL_TARGET} PUBLIC "cxx_std_17")
+target_include_directories(${PYTHONFMU_IMPL_TARGET}
         PRIVATE
         "${Python3_INCLUDE_DIRS}"
         "${CMAKE_CURRENT_SOURCE_DIR}"
         )
 
 if (WIN32)
-  target_link_libraries(pythonfmu-export PRIVATE ${Python3_LIBRARIES})
-elseif (APPLE)
-  set_target_properties(pythonfmu-export PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
-endif ()
-
-if (WIN32)
-  set_target_properties(pythonfmu-export
+  target_link_libraries(${PYTHONFMU_IMPL_TARGET} PRIVATE ${Python3_LIBRARIES})
+  set_target_properties(${PYTHONFMU_IMPL_TARGET}
           PROPERTIES
-          RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_SOURCE_DIR}/../resources/binaries/${TARGET_PLATFORM}"
+          RUNTIME_OUTPUT_DIRECTORY_RELEASE "${BINARY_OUTPUT_DIR}"
           )
 else ()
+  # Python symbols are resolved at load time against the process (the host Python, or
+  # the libpython the shim opened with RTLD_GLOBAL).
+  target_compile_definitions(${PYTHONFMU_IMPL_TARGET} PRIVATE FMI3_FUNCTION_PREFIX=pythonfmu_backend_)
+  if (APPLE)
+    set_target_properties(${PYTHONFMU_IMPL_TARGET} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
+  endif ()
+  set_target_properties(${PYTHONFMU_IMPL_TARGET}
+          PROPERTIES
+          LIBRARY_OUTPUT_DIRECTORY "${BINARY_OUTPUT_DIR}"
+          )
+
+  add_library(pythonfmu-export
+          shim/shim_loader.cpp
+          shim/shim_loader.hpp
+          shim/fmi3_forwarders.cpp
+          )
+  target_compile_features(pythonfmu-export PUBLIC "cxx_std_17")
+  target_include_directories(pythonfmu-export PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
+  target_link_libraries(pythonfmu-export PRIVATE ${CMAKE_DL_LIBS})
   set_target_properties(pythonfmu-export
           PROPERTIES
-          LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../resources/binaries/${TARGET_PLATFORM}"
+          LIBRARY_OUTPUT_DIRECTORY "${BINARY_OUTPUT_DIR}"
+          # Only the FMI functions (marked FMI3_Export) are exported
+          CXX_VISIBILITY_PRESET hidden
+          VISIBILITY_INLINES_HIDDEN ON
           )
 endif ()

pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_common.hpp

@@ -121,6 +121,9 @@ public:
         FMIString message,
         Args&&... args) CPPFMU_NOEXCEPT
     {
+        if (m_fmiLogger == nullptr) {
+            return; // FMI 3.0 allows instantiating without a logger callback
+        }
         if (m_settings->loggedCategories.empty() ||
             detail::CanFind(m_settings->loggedCategories, category)) {
             m_fmiLogger(