pythonfmu3 0.3.1__tar.gz → 0.3.3__tar.gz

{pythonfmu3-0.3.1/pythonfmu3.egg-info → pythonfmu3-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.3.1
+Version: 0.3.3
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith
@@ -44,15 +44,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:
@@ -182,6 +173,7 @@ To create a model exchange FMU you must inherit from `Fmi3SlaveBase` and one of
 ```python
 
 from pythonfmu3 import Fmi3Causality, Fmi3SlaveBase, Float64, ModelExchange
+from typing import List
 
 
 class PythonSlaveMX(Fmi3SlaveBase, ModelExchange):

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/README.md

@@ -17,15 +17,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:
@@ -155,6 +146,7 @@ To create a model exchange FMU you must inherit from `Fmi3SlaveBase` and one of
 ```python
 
 from pythonfmu3 import Fmi3Causality, Fmi3SlaveBase, Float64, ModelExchange
+from typing import List
 
 
 class PythonSlaveMX(Fmi3SlaveBase, ModelExchange):

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/__init__.py

@@ -1,7 +1,7 @@
 from ._version import __version__
 from .builder import FmuBuilder
 from .cosimulation import CoSimulation
-from .modelexchange import ModelExchange
+from .modelexchange import ModelExchange, Fmi3UpdateDiscreteStatesResult
 from .enums import Fmi3Causality, Fmi3Initial, Fmi3Status, Fmi3Variability
 from .fmi3slave import Fmi3Slave, Fmi3SlaveBase, Fmi3StepResult
 from .variables import Boolean, Enumeration, Int32, Int64, UInt64, Float64, String, Dimension

pythonfmu3-0.3.3/pythonfmu3/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.3"

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/builder.py

@@ -13,7 +13,7 @@ from typing import Iterable, 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
-from .fmi3slave import FMI3_MODEL_OPTIONS, Fmi3Slave, Fmi3SlaveBase
+from .fmi3slave import FMI3_MODEL_OPTIONS_COMMON, FMI3_MODEL_OPTIONS_COSIM, FMI3_MODEL_OPTIONS_MX, Fmi3Slave, Fmi3SlaveBase
 
 FilePath = Union[str, Path]
 HERE = Path(__file__).parent
@@ -137,16 +137,20 @@ class FmuBuilder:
             dest_file = dest / f"{model_identifier}.fmu"
 
             type_node = xml.find("CoSimulation")
-            option_names = [opt.name for opt in FMI3_MODEL_OPTIONS]
-            if type_node:
+            option_names = [opt.name for opt in FMI3_MODEL_OPTIONS_COMMON]
+            cosim_option_names = option_names.copy()
+            cosim_option_names.extend(opt.name for opt in FMI3_MODEL_OPTIONS_COSIM)
+            if type_node is not None:
                 for option, value in options.items():
-                    if option in option_names:
+                    if option in cosim_option_names:
                         type_node.set(option, str(value).lower())
 
             type_node = xml.find("ModelExchange")
-            if type_node:
+            mx_option_names = option_names.copy()
+            mx_option_names.extend(opt.name for opt in FMI3_MODEL_OPTIONS_MX)
+            if type_node is not None:
                 for option, value in options.items():
-                    if option in option_names:
+                    if option in mx_option_names:
                         type_node.set(option, str(value).lower())
 
             with zipfile.ZipFile(dest_file, "w") as zip_fmu:
@@ -247,7 +251,25 @@ def create_command_parser(parser: argparse.ArgumentParser):
         default=None
     )
 
-    for option in FMI3_MODEL_OPTIONS:
+    for option in FMI3_MODEL_OPTIONS_COMMON:
+        action = "store_false" if option.value else "store_true"
+        parser.add_argument(
+            f"--{option.cli}",
+            dest=option.name,
+            help=f"If given, {option.name}={action[6:]}",
+            action=action
+        )
+
+    for option in FMI3_MODEL_OPTIONS_COSIM:
+        action = "store_false" if option.value else "store_true"
+        parser.add_argument(
+            f"--{option.cli}",
+            dest=option.name,
+            help=f"If given, {option.name}={action[6:]}",
+            action=action
+        )
+    
+    for option in FMI3_MODEL_OPTIONS_MX:
         action = "store_false" if option.value else "store_true"
         parser.add_argument(
             f"--{option.cli}",

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/fmi3slave.py

@@ -21,14 +21,22 @@ from .unit import Unit
 
 ModelOptions = namedtuple("ModelOptions", ["name", "value", "cli"])
 
-FMI3_MODEL_OPTIONS: List[ModelOptions] = [
+FMI3_MODEL_OPTIONS_COMMON: List[ModelOptions] = [
     ModelOptions("needsExecutionTool", True, "no-external-tool"),
-    ModelOptions("canHandleVariableCommunicationStepSize", True, "no-variable-step"),
     ModelOptions("canBeInstantiatedOnlyOncePerProcess", False, "only-one-per-process"),
     ModelOptions("canGetAndSetFMUState", False, "handle-state"),
     ModelOptions("canSerializeFMUState", False, "serialize-state")
 ]
 
+FMI3_MODEL_OPTIONS_COSIM: List[ModelOptions] = [
+    ModelOptions("canHandleVariableCommunicationStepSize", True, "no-variable-step"),
+]
+
+FMI3_MODEL_OPTIONS_MX: List[ModelOptions] = [
+    ModelOptions("needsCompletedIntegratorStep", False, "needs-completed-step"),
+]
+
+
 class Fmi3StepResult(NamedTuple):
     status: Fmi3Status = Fmi3Status.ok
     eventHandlingNeeded: bool = False
@@ -50,6 +58,7 @@ class Fmi3SlaveBase(object):
 
     def __init__(self, **kwargs):
         self.vars = OrderedDict()
+        self.event_indicators: List[int] = []
         self.instance_name = kwargs["instance_name"]
         self.resources = kwargs.get("resources", None)
         self.visible = kwargs.get("visible", False)
@@ -102,23 +111,26 @@ class Fmi3SlaveBase(object):
         root = Element("fmiModelDescription", attrib)
 
         options = dict()
-        for option in FMI3_MODEL_OPTIONS:
+        for option in FMI3_MODEL_OPTIONS_COMMON:
             value = model_options.get(option.name, option.value)
             options[option.name] = str(value).lower()
+        
         options["modelIdentifier"] = self.modelName
-        options["canNotUseMemoryManagementFunctions"] = "true"
+
+        options_cs = options.copy()
+        for option in FMI3_MODEL_OPTIONS_COSIM:
+            options_cs[option.name] = str(value).lower()
         
-        options_me = dict()
-        options_me["canGetAndSetFMUState"] = "true"
-        options_me["modelIdentifier"] = self.modelName
-        options_me["needsCompletedIntegratorStep"] = "false"
+        options_me = options.copy()
+        for option in FMI3_MODEL_OPTIONS_MX:
+            options_me[option.name] = str(value).lower()
 
         # check if we have cosim mixin or model exchange mixin
         if isinstance(self, ModelExchange):
             SubElement(root, "ModelExchange", attrib=options_me)
         
         if isinstance(self, CoSimulation):
-            SubElement(root, "CoSimulation", attrib=options)
+            SubElement(root, "CoSimulation", attrib=options_cs)
 
         if self.units:
             unit_defs = SubElement(root, "UnitDefinitions")
@@ -184,7 +196,8 @@ class Fmi3SlaveBase(object):
         for v in initial_unknown:
             SubElement(structure, "InitialUnknown", attrib=dict(valueReference=str(v.value_reference)))
         
-
+        for v in self.event_indicators:
+            SubElement(structure, "EventIndicator", attrib=dict(valueReference=str(v)))
 
         return root
 
@@ -206,7 +219,7 @@ class Fmi3SlaveBase(object):
             raise Exception(f"Unsupported type {type(var)}!")
         var.start = refs if len(getattr(var, "dimensions", [])) > 0 else refs[0]
 
-    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None):
+    def register_variable(self, var: ModelVariable, nested: bool = True, var_type: Any = None, has_event_indicator: bool = False):
         """Register a variable as FMU interface.
         
         Args:
@@ -238,6 +251,12 @@ class Fmi3SlaveBase(object):
         if var_type:
             self.type_definitions[var_type.name] = var_type
             var.declared_type = var_type.name
+            
+        if has_event_indicator:
+            self.register_event_indicator(var.value_reference)
+
+    def register_event_indicator(self, vr):
+        self.event_indicators.append(vr)
 
     def setup_experiment(self, start_time: float):
         pass
@@ -416,6 +435,9 @@ class Fmi3SlaveBase(object):
                 if v.setter is not None:
                     v.setter(value)
 
+    def get_number_of_event_indicators(self) -> int:
+        return len(self.event_indicators)
+
     def set_continuous_states(self, values: List[float]):
         offset = 0
         continuous_state_derivatives = list(

pythonfmu3-0.3.3/pythonfmu3/modelexchange.py

@@ -0,0 +1,52 @@
+from abc import ABC, ABCMeta, abstractmethod
+from dataclasses import dataclass
+
+@dataclass
+class Fmi3UpdateDiscreteStatesResult:
+    discreteStateNeedsUpdate: bool = False
+    terminateSimulation: bool = False
+    nominalsOfContinuousStatesChanged: bool = False
+    valuesOfContinuousStatesChanged: bool = False
+    nextEventTimeDefined: bool = False
+    nextEventTime: float = 0.0
+
+class RequireTimeMeta(ABCMeta):
+    def __init__(cls, name, bases, namespace):
+        super().__init__(name, bases, namespace)
+        orig_init = cls.__init__
+        def new_init(self, *args, **kwargs):
+            orig_init(self, *args, **kwargs)
+            if not hasattr(self, 'time'):
+                raise AttributeError(f"{cls.__name__} must define 'self.time' in __init__")
+        cls.__init__ = new_init
+
+
+# model exchange mixin
+class ModelExchange(ABC, metaclass=RequireTimeMeta):
+    """
+    Classes derived from ModelExchange must define a 'self.time' member variable.
+    
+    Required methods to override:
+    - `get_continuous_state_derivatives`: Must return a list of continuous state derivatives.
+
+    Optional methods:
+    - `get_event_indicators`: Should return a list of event indicators.
+    - `update_discrete_states`: Signify converged solution at current super-dense time instant.
+    """
+    
+    @abstractmethod
+    def get_continuous_state_derivatives(self):
+        """Return the continuous state derivatives of the model."""
+        pass
+    
+    def get_event_indicators(self):
+        """Return the event indicators of the model."""
+        return []
+    
+    def update_discrete_states(self):
+        """Update the discrete states of the model."""
+        return Fmi3UpdateDiscreteStatesResult()
+
+    def get_nominals_of_continuous_states(self, size: int) -> list[float]:
+        """Return the nominal values of the continuous states."""
+        return [1.0] * size

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/pythonfmu-export/src/cppfmu/cppfmu_cs.hpp

@@ -141,6 +141,7 @@ public:
     virtual void SetTime(cppfmu::FMIFloat64 time) = 0;
     virtual void GetNumberOfContinuousStates(std::size_t& nStates) const = 0;
     virtual void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const = 0;
+    virtual void GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nEventIndicators) const = 0;
     virtual void UpdateDiscreteStates(
         cppfmu::FMIBoolean* discreteStatesNeedUpdate,
         cppfmu::FMIBoolean* terminateSimulation,

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/pythonfmu-export/src/cppfmu/fmi_functions.cpp

@@ -622,7 +622,17 @@ fmi3Status fmi3GetEventIndicators(
     fmi3Float64 eventIndicators[],
     size_t nEventIndicators)
 {
-    return fmi3OK;
+    const auto component = reinterpret_cast<Component*>(c);
+    try {
+        component->slave->GetEventIndicators(eventIndicators, nEventIndicators);
+        return fmi3OK;
+    } catch (const cppfmu::FatalError& e) {
+        component->logger.Log(fmi3Fatal, "", e.what());
+        return fmi3Fatal;
+    } catch (const std::exception& e) {
+        component->logger.Log(fmi3Error, "", e.what());
+        return fmi3Error;
+    }
 }
 
 fmi3Status fmi3GetNominalsOfContinuousStates(

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -542,6 +542,7 @@ void PySlaveInstance::GetContinuousStates(cppfmu::FMIFloat64* continuousStates,
             PyObject* item = PyList_GetItem(f, i);
             continuousStates[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
         }
+        Py_DECREF(f);
         clearLogBuffer();
     });
 }
@@ -551,6 +552,7 @@ void PySlaveInstance::GetContinuousStateDerivatives(cppfmu::FMIFloat64* continuo
     py_safe_run([this, &continuousStateDerivatives, nStates](PyGILState_STATE gilState) {
         auto f = PyObject_CallMethod(pInstance_, "get_continuous_state_derivatives", nullptr);
         if (f == nullptr) {
+            PyErr_Print();
             handle_py_exception("[get_continuous_state_derivatives] PyObject_CallMethod", gilState);
         }
         // Assuming f is a list of floats
@@ -558,15 +560,27 @@ void PySlaveInstance::GetContinuousStateDerivatives(cppfmu::FMIFloat64* continuo
             PyObject* item = PyList_GetItem(f, i);
             continuousStateDerivatives[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
         }
+        Py_DECREF(f);
         clearLogBuffer();
     });
 }
 
 void PySlaveInstance::GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalsOfContinuousStates, std::size_t nStates) const
 {
-    for (size_t i = 0u; i < nStates; i++) {
-        nominalsOfContinuousStates[i] = 1.0;
-    }
+    py_safe_run([this, &nominalsOfContinuousStates, nStates](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_nominals_of_continuous_states", "(i)", static_cast<int>(nStates));
+         // Check if f is a valid object
+         if (f == nullptr) {
+            handle_py_exception("[getNominalContinuousStates] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nStates; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            nominalsOfContinuousStates[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
 }
 
 void PySlaveInstance::SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates)
@@ -602,9 +616,36 @@ void PySlaveInstance::GetNumberOfContinuousStates(std::size_t& nStates) const
 
 void PySlaveInstance::GetNumberOfEventIndicators(std::size_t& nIndicators) const
 {
-   nIndicators= 0u;
+    py_safe_run([this, &nIndicators](PyGILState_STATE gilState) {
+         auto f = PyObject_CallMethod(pInstance_, "get_number_of_event_indicators", nullptr);
+         if (f == nullptr) {
+             handle_py_exception("[getNumberOfEventIndicators] PyObject_CallMethod", gilState);
+         }
+         nIndicators = static_cast<std::size_t>(PyLong_AsLong(f));
+         Py_DECREF(f);
+         clearLogBuffer();
+    });
 }
 
+void PySlaveInstance::GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nIndicators) const
+{
+    py_safe_run([this, &eventIndicators, nIndicators](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "get_event_indicators", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[getEventIndicators] PyObject_CallMethod", gilState);
+        }
+        // Assuming f is a list of floats
+        for (std::size_t i = 0; i < nIndicators; i++) {
+            PyObject* item = PyList_GetItem(f, i);
+            eventIndicators[i] = static_cast<cppfmu::FMIFloat64>(PyFloat_AsDouble(item));
+        }
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
+
+}
+
+
 void PySlaveInstance::SetTime(cppfmu::FMIFloat64 time)
 {
     py_safe_run([this, time](PyGILState_STATE gilState) {
@@ -625,12 +666,46 @@ void PySlaveInstance::UpdateDiscreteStates(
     cppfmu::FMIBoolean* nextEventTimeDefined,
     cppfmu::FMIFloat64* nextEventTime)
 {
-    *discreteStatesNeedUpdate = false;
-    *terminateSimulation = false;
-    *nominalContinuousStatesChanged = false;
-    *valuesOfContinuousStatesChanged = false;
-    *nextEventTimeDefined = false;
-    *nextEventTime = 0.0;
+    py_safe_run([this, discreteStatesNeedUpdate, terminateSimulation, nominalContinuousStatesChanged, valuesOfContinuousStatesChanged, nextEventTimeDefined, nextEventTime](PyGILState_STATE gilState) {
+        auto f = PyObject_CallMethod(pInstance_, "update_discrete_states", nullptr);
+        if (f == nullptr) {
+            handle_py_exception("[updateDiscreteStates] PyObject_CallMethod", gilState);
+        }
+
+        if (PyObject_HasAttrString(f, "discreteStatesNeedUpdate")) {
+            PyObject * pyDiscreteStatesNeedUpdate = PyObject_GetAttrString(f, "discreteStatesNeedUpdate");
+            *discreteStatesNeedUpdate = static_cast<bool>(PyObject_IsTrue(pyDiscreteStatesNeedUpdate));
+            Py_DECREF(pyDiscreteStatesNeedUpdate);
+        }
+        if (PyObject_HasAttrString(f, "terminateSimulation")) {
+            PyObject* pyTerminateSimulation = PyObject_GetAttrString(f, "terminateSimulation");
+            *terminateSimulation = static_cast<bool>(PyObject_IsTrue(pyTerminateSimulation));
+            Py_DECREF(pyTerminateSimulation);
+        }
+        if (PyObject_HasAttrString(f, "nominalContinuousStatesChanged")) {
+            PyObject* pyNominalContinuousStatesChanged = PyObject_GetAttrString(f, "nominalContinuousStatesChanged");
+            *nominalContinuousStatesChanged = static_cast<bool>(PyObject_IsTrue(pyNominalContinuousStatesChanged));
+            Py_DECREF(pyNominalContinuousStatesChanged);
+        }
+        if (PyObject_HasAttrString(f, "valuesOfContinuousStatesChanged")) {
+            PyObject* pyValuesOfContinuousStatesChanged = PyObject_GetAttrString(f, "valuesOfContinuousStatesChanged");
+            *valuesOfContinuousStatesChanged = static_cast<bool>(PyObject_IsTrue(pyValuesOfContinuousStatesChanged));
+            Py_DECREF(pyValuesOfContinuousStatesChanged);
+        }
+        if (PyObject_HasAttrString(f, "nextEventTimeDefined")) {
+            PyObject* pyNextEventTimeDefined = PyObject_GetAttrString(f, "nextEventTimeDefined");
+            *nextEventTimeDefined = static_cast<bool>(PyObject_IsTrue(pyNextEventTimeDefined));
+            Py_DECREF(pyNextEventTimeDefined);
+        }
+        if (nextEventTimeDefined && *nextEventTimeDefined) {
+            PyObject* pyNextEventTime = PyObject_GetAttrString(f, "nextEventTime");
+            *nextEventTime = PyFloat_AsDouble(pyNextEventTime);
+            Py_DECREF(pyNextEventTime);
+        }
+
+        Py_DECREF(f);
+        clearLogBuffer();
+    });
 }
 
 void PySlaveInstance::GetFMUstate(fmi3FMUState& state)

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -57,6 +57,7 @@ public:
     void GetNumberOfEventIndicators(std::size_t& nEventIndicators) const override;
     void GetContinuousStateDerivatives(cppfmu::FMIFloat64* derivatives, std::size_t nStates) const override;
     void GetNominalsOfContinuousStates(cppfmu::FMIFloat64* nominalContinuousStates, std::size_t nStates) const override;
+    void GetEventIndicators(cppfmu::FMIFloat64* eventIndicators, std::size_t nEventIndicators) const override;
     void SetContinuousStates(const cppfmu::FMIFloat64* continuousStates, std::size_t nStates) override;
     void SetTime(cppfmu::FMIFloat64 time) override;
     void UpdateDiscreteStates(

pythonfmu3-0.3.3/pythonfmu3/tests/test_docs.py

@@ -0,0 +1,98 @@
+import pytest
+import pathlib
+import re
+import tempfile
+
+def extract_python_code_from_md(md_file):
+    """Extract Python code blocks from markdown, excluding skip blocks"""
+    content = pathlib.Path(md_file).read_text()
+    
+    # Find all python code blocks that aren't marked as skip
+    python_blocks = []
+    
+    # Pattern to match python blocks but not python skip
+    pattern = r'```python(?!\s+skip)(?:[^\n]*)\n(.*?)\n```'
+    matches = re.findall(pattern, content, re.DOTALL)
+    
+    for match in matches:
+        # Skip blocks that are wrapped in skip-test comments
+        if '<!-- skip-test -->' not in content.split(match)[0][-100:]:
+            python_blocks.append(match)
+    
+    return python_blocks
+
+@pytest.mark.doc
+def test_readme():
+    test_dir = pathlib.Path(__file__).parent
+    fpath = test_dir.parent.parent / "README.md"
+    
+    # extract Python code
+    code_blocks = extract_python_code_from_md(fpath)
+
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+            print(f"✅ Code block {i+1} executed successfully")
+        except Exception as e:
+            pytest.fail(f"Code block {i+1} failed: {e}\nCode:\n{code}")
+    
+
+
+
+@pytest.mark.doc
+def test_cosimulation_examples():
+    """Test that all Python examples in usage.md actually work"""
+    test_dir = pathlib.Path(__file__).parent
+    usage_file = test_dir.parent.parent / "docs" / "usage.md"
+    
+    # Extract Python code
+    code_blocks = extract_python_code_from_md(usage_file)
+    
+    # Create a test namespace
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+    
+    # Execute each code block
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+            print(f"✅ Code block {i+1} executed successfully")
+        except Exception as e:
+            pytest.fail(f"Code block {i+1} failed: {e}\nCode:\n{code}")
+            
+    assert 'LinearTransform' in namespace, "LinearTransform class not found"
+    assert 'PIDController' in namespace, "PIDController class not found"
+
+    # Test instantiation
+    lt = namespace['LinearTransform'](instance_name="test")
+    pc = namespace['PIDController'](instance_name="test")
+
+
+@pytest.mark.doc
+def test_model_exchange_examples():
+    """Test Model Exchange examples"""
+    test_dir = pathlib.Path(__file__).parent
+    mx_file = test_dir.parent.parent / "docs" / "usageMX.md"
+    
+    code_blocks = extract_python_code_from_md(mx_file)
+    
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+    
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+        except Exception as e:
+            pytest.fail(f"MX Code block {i+1} failed: {e}")
+    
+    # Test that classes were actually created
+    assert 'VanDerPol' in namespace, "VanDerPol class not found"
+    assert 'BouncingBall' in namespace, "BouncingBall class not found"
+    
+    # Test instantiation
+    vdp = namespace['VanDerPol'](instance_name="test")
+    
+    bb = namespace['BouncingBall'](instance_name="test")

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3/pythonfmu3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonfmu3
-Version: 0.3.1
+Version: 0.3.3
 Summary: A lightweight framework that enables the packaging of Python3.x code as co-simulation FMUs.
 Home-page: https://github.com/stephensmith25/PythonFMU3
 Author: Stephen Smith
@@ -44,15 +44,6 @@ This project is a fork of the original PythonFMU repository available at https:/
 Please take a look at the examples to see the supported features.
 We currently support both the Model exchange and Cosimulation Interfaces.
 
-For both interfaces event mode is not supported.
-
-We currently do not support the following methods (beyond a default, trivial implementation)
-
-- fmi3UpdateDiscreteStates
-- fmi3GetNumberOfEventindicators
-- fmi3GetNominalsOfContinuousStates
-- fmi3EvaluateDiscreteStates
-
 ### How do I build an FMU from python code?
 
 1. Install `pythonfmu3` package:
@@ -182,6 +173,7 @@ To create a model exchange FMU you must inherit from `Fmi3SlaveBase` and one of
 ```python
 
 from pythonfmu3 import Fmi3Causality, Fmi3SlaveBase, Float64, ModelExchange
+from typing import List
 
 
 class PythonSlaveMX(Fmi3SlaveBase, ModelExchange):

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/pythonfmu3.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ pythonfmu3/tests/__init__.py
 pythonfmu3/tests/conftest.py
 pythonfmu3/tests/test_builder.py
 pythonfmu3/tests/test_deploy.py
+pythonfmu3/tests/test_docs.py
 pythonfmu3/tests/test_fmi3slave.py
 pythonfmu3/tests/test_integration.py
 pythonfmu3/tests/test_logger.py

{pythonfmu3-0.3.1 → pythonfmu3-0.3.3}/setup.cfg

@@ -49,6 +49,7 @@ tests =
 [tool:pytest]
 markers = 
 	integration: marks integration tests
+	doc: marks documentation tests
 
 [egg_info]
 tag_build = 

pythonfmu3-0.3.1/pythonfmu3/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.1"

pythonfmu3-0.3.1/pythonfmu3/modelexchange.py

@@ -1,23 +0,0 @@
-from abc import ABC, ABCMeta, abstractmethod
-
-class RequireTimeMeta(ABCMeta):
-    def __init__(cls, name, bases, namespace):
-        super().__init__(name, bases, namespace)
-        orig_init = cls.__init__
-        def new_init(self, *args, **kwargs):
-            orig_init(self, *args, **kwargs)
-            if not hasattr(self, 'time'):
-                raise AttributeError(f"{cls.__name__} must define 'self.time' in __init__")
-        cls.__init__ = new_init
-
-
-# model exchange mixin
-class ModelExchange(ABC, metaclass=RequireTimeMeta):
-    """
-    Classes derived from ModelExchange must define a 'self.time' member variable.
-    """
-    
-    @abstractmethod
-    def get_continuous_state_derivatives(self):
-        """Return the continuous state derivatives of the model."""
-        pass