pythonfmu3 0.3.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

pythonfmu3/_version.py

@@ -1 +1 @@
-__version__ = "0.3.3"
+__version__ = "1.0.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,16 +179,13 @@ 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(
             filter(lambda v: (v.causality == Fmi3Causality.output and (v.initial in allowed_variability))
                               or v.causality == Fmi3Causality.calculatedParameter
-                              or v in continuous_state_derivatives and v.initial in allowed_variability
-                              or v.variability == Fmi3Variability.continuous and v.initial in allowed_variability and v.causality != Fmi3Causality.independent, self.vars.values())
+                              or v in continuous_state_derivatives and v.initial in allowed_variability, self.vars.values())
         )
 
         for v in outputs:
@@ -201,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):
@@ -244,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)
         
@@ -282,10 +292,13 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Int32):
-                refs.append(int(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(int(var.getter()))
+                else:
+                    refs.extend(map(int, var.getter()))
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int32!"
                 )
         return refs
     
@@ -294,7 +307,10 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, (Enumeration, Int64)):
-                refs.append(int(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(int(var.getter()))
+                else:
+                    refs.extend(map(int, var.getter()))
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Int64!"
@@ -306,11 +322,14 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, UInt64):
-                val = var.getter()
-                refs.append(val if isinstance(val, ctypes.c_uint64) else ctypes.c_uint64(val))
+                if len(var.dimensions) == 0:
+                    val = var.getter()
+                    refs.append(ctypes.c_uint64(val) if not isinstance(val, ctypes.c_uint64) else val)
+                else:
+                    refs.extend(map(ctypes.c_uint64, var.getter()))
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type UInt64!"
+                    f"Variable with valueReference={vr} is not of type Uint64!"
                 )
         return refs
 
@@ -325,7 +344,7 @@ class Fmi3SlaveBase(object):
                     refs.extend(var.getter())
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Real!"
+                    f"Variable with valueReference={vr} is not of type Float64!"
                 )
         return refs
 
@@ -334,7 +353,11 @@ class Fmi3SlaveBase(object):
         for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Boolean):
-                refs.append(bool(var.getter()))
+                if len(var.dimensions) == 0:
+                    refs.append(bool(var.getter()))
+                else:
+                    refs.extend(var.getter())
+            
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Boolean!"
@@ -354,30 +377,48 @@ class Fmi3SlaveBase(object):
         return refs
 
     def set_int32(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Int32):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int32!"
                 )
                 
     def set_int64(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, (Enumeration, Int64)):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Integer!"
+                    f"Variable with valueReference={vr} is not of type Int64!"
                 )
 
     def set_uint64(self, vrs: List[int], values: List[int]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, UInt64):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type UInt64!"
@@ -396,14 +437,20 @@ class Fmi3SlaveBase(object):
                 offset += size
             else:
                 raise TypeError(
-                    f"Variable with valueReference={vr} is not of type Real!"
+                    f"Variable with valueReference={vr} is not of type Float64!"
                 )
 
     def set_boolean(self, vrs: List[int], values: List[bool]):
-        for vr, value in zip(vrs, values):
+        offset = 0
+        for vr in vrs:
             var = self.vars[vr]
             if isinstance(var, Boolean):
-                var.setter(value)
+                size = var.size(self.vars)
+                if size > 1:
+                    var.setter(values[offset:offset+size])
+                else:
+                    var.setter(values[offset])
+                offset += size
             else:
                 raise TypeError(
                     f"Variable with valueReference={vr} is not of type Boolean!"
@@ -440,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]
         
@@ -456,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]
         
@@ -474,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)