cppmodel 0.9.0__py3-none-manylinux_2_28_aarch64.whl

cppmodel/__init__.py

@@ -0,0 +1,23 @@
+"""CppModel for Python: write CppModel simulations in Python and submit them to your workspace."""
+from ._native import API_VERSION, lib as _lib, library_path
+from ._simulation import CppModelError, Inputs, Outputs, Parameters, Simulation, Status
+
+__version__ = "0.9.0"
+
+
+def library_version():
+    """The release version of the loaded CppModel library, e.g. "0.8.0"."""
+    return _lib.cm_version().decode("utf-8")
+
+
+__all__ = [
+    "API_VERSION",
+    "CppModelError",
+    "Inputs",
+    "Outputs",
+    "Parameters",
+    "Simulation",
+    "Status",
+    "library_path",
+    "library_version",
+]

cppmodel/_native.py

@@ -0,0 +1,99 @@
+"""ctypes declarations of the CppModel C API (include/cppmodel.h) and loading of the shared library."""
+import ctypes
+import os
+import sys
+from ctypes import POINTER, c_char_p, c_double, c_int, c_size_t, c_uint64, c_void_p
+
+# The major C API version these bindings are written against; the library must report the same.
+API_VERSION = 1
+
+# cm_callback: cm_status (*)(cm_simulation simulation, uint64_t time_ms, void *user_data)
+CALLBACK = ctypes.CFUNCTYPE(c_int, c_void_p, c_uint64, c_void_p)
+
+_LIBRARY_NAMES = {"win32": "cppmodel.dll", "darwin": "libcppmodel.dylib"}
+
+
+def library_path():
+    """The shared library to load: $CPPMODEL_LIBRARY, else the one bundled in the package."""
+    override = os.environ.get("CPPMODEL_LIBRARY")
+    if override:
+        return override
+    name = _LIBRARY_NAMES.get(sys.platform, "libcppmodel.so.1")
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib", name)
+
+
+_handle = c_void_p
+_out_handle = POINTER(c_void_p)
+_out_text = POINTER(c_char_p)
+_out_int = POINTER(c_int)
+_out_size = POINTER(c_size_t)
+_out_double = POINTER(c_double)
+_out_uint64 = POINTER(c_uint64)
+
+# Only the functions the bindings use. Persistent simulations are C/C++ only, and
+# cm_require_non_interactive is left out because it exits the process.
+_SIGNATURES = {
+    "cm_api_version": (c_int, []),
+    "cm_version": (c_char_p, []),
+    "cm_last_error_message": (c_char_p, []),
+    "cm_simulation_create": (c_int, [c_char_p, c_uint64, c_uint64, _out_handle]),
+    "cm_simulation_destroy": (c_int, [_handle]),
+    "cm_simulation_set_name": (c_int, [_handle, c_char_p]),
+    "cm_simulation_get_name": (c_int, [_handle, _out_text]),
+    "cm_simulation_set_timing": (c_int, [_handle, c_uint64, c_uint64]),
+    "cm_simulation_get_timing": (c_int, [_handle, _out_uint64, _out_uint64]),
+    "cm_simulation_set_run_offline": (c_int, [_handle, c_int]),
+    "cm_simulation_set_fingerprint_file": (c_int, [_handle, c_char_p]),
+    "cm_simulation_set_init_callback": (c_int, [_handle, CALLBACK, c_void_p]),
+    "cm_simulation_set_step_callback": (c_int, [_handle, CALLBACK, c_void_p]),
+    "cm_simulation_set_finalize_callback": (c_int, [_handle, CALLBACK, c_void_p]),
+    "cm_simulation_run": (c_int, [_handle]),
+    "cm_simulation_reset_data": (c_int, [_handle]),
+    "cm_simulation_get_result": (c_int, [_handle, _out_int]),
+    "cm_simulation_set_result": (c_int, [_handle, c_int]),
+    "cm_simulation_results_json": (c_int, [_handle, _out_text]),
+    "cm_simulation_apply_inputs_json": (c_int, [_handle, c_char_p]),
+    "cm_simulation_inputs": (c_int, [_handle, _out_handle]),
+    "cm_simulation_outputs": (c_int, [_handle, _out_handle]),
+    "cm_input_get": (c_int, [_handle, c_char_p, c_double, _out_double]),
+    "cm_inputs_load_json": (c_int, [_handle, c_char_p]),
+    "cm_inputs_contains": (c_int, [_handle, c_char_p, _out_int]),
+    "cm_inputs_count": (c_int, [_handle, _out_size]),
+    "cm_inputs_key_at": (c_int, [_handle, c_size_t, _out_text]),
+    "cm_output_set": (c_int, [_handle, c_char_p, c_double]),
+    "cm_output_get": (c_int, [_handle, c_char_p, _out_double]),
+    "cm_outputs_contains": (c_int, [_handle, c_char_p, _out_int]),
+    "cm_outputs_count": (c_int, [_handle, _out_size]),
+    "cm_outputs_key_at": (c_int, [_handle, c_size_t, _out_text]),
+    "cm_param_set_double": (c_int, [_handle, c_char_p, c_double]),
+    "cm_param_set_json": (c_int, [_handle, c_char_p, c_char_p]),
+    "cm_param_get_json": (c_int, [_handle, c_char_p, _out_text]),
+    "cm_param_get_or_json": (c_int, [_handle, c_char_p, c_char_p, _out_text]),
+    "cm_param_contains": (c_int, [_handle, c_char_p, _out_int]),
+    "cm_param_count": (c_int, [_handle, _out_size]),
+    "cm_param_key_at": (c_int, [_handle, c_size_t, _out_text]),
+}
+
+
+def _load():
+    path = library_path()
+    try:
+        library = ctypes.CDLL(path)
+    except OSError as error:
+        raise ImportError(
+            f"cppmodel: cannot load the CppModel library {path}: {error}. "
+            "Reinstall the cppmodel package for this platform, or set CPPMODEL_LIBRARY."
+        ) from error
+    for name, (restype, argtypes) in _SIGNATURES.items():
+        function = getattr(library, name)
+        function.restype = restype
+        function.argtypes = argtypes
+    if library.cm_api_version() != API_VERSION:
+        raise ImportError(
+            f"cppmodel: {path} implements C API version {library.cm_api_version()}, "
+            f"these bindings need version {API_VERSION}"
+        )
+    return library
+
+
+lib = _load()

cppmodel/_simulation.py

@@ -0,0 +1,391 @@
+"""A Pythonic wrapper over the C API: Simulation with its inputs, outputs and parameters."""
+import enum
+import inspect
+import json
+import os
+import sys
+from ctypes import byref, c_char_p, c_double, c_int, c_size_t, c_uint64, c_void_p
+
+from ._native import CALLBACK, lib
+
+
+class Status(enum.IntEnum):
+    """cm_status codes of the C API."""
+
+    OK = 0
+    INVALID_ARGUMENT = 1
+    NOT_FOUND = 2
+    TYPE_MISMATCH = 3
+    INVALID_JSON = 4
+    CALLBACK = 5
+    INTERNAL = 6
+
+
+class CppModelError(Exception):
+    """A CppModel library call failed. `status` is the Status it returned."""
+
+    def __init__(self, status, message):
+        super().__init__(message)
+        try:
+            self.status = Status(status)
+        except ValueError:
+            self.status = status
+
+
+def _check(status):
+    if status != Status.OK:
+        raise CppModelError(status, lib.cm_last_error_message().decode("utf-8", "replace"))
+
+
+def _encode(text):
+    return text.encode("utf-8")
+
+
+def _decode(raw):
+    return raw.decode("utf-8") if raw is not None else ""
+
+
+def _keys(count_function, key_function, handle):
+    count = c_size_t()
+    _check(count_function(handle, byref(count)))
+    keys = []
+    for index in range(count.value):
+        key = c_char_p()
+        _check(key_function(handle, index, byref(key)))
+        keys.append(_decode(key.value))
+    return keys
+
+
+class Inputs:
+    """The simulation's inputs: time series whose value is read at the current step."""
+
+    def __init__(self, simulation):
+        self._simulation = simulation
+        handle = c_void_p()
+        _check(lib.cm_simulation_inputs(simulation._live(), byref(handle)))
+        self._handle = handle
+
+    def _live(self):
+        self._simulation._live()
+        return self._handle
+
+    def get(self, name, fallback=0.0):
+        """The input's value at the current step, or `fallback` (then recorded as its value) when
+        nothing was loaded for it."""
+        value = c_double()
+        _check(lib.cm_input_get(self._live(), _encode(name), float(fallback), byref(value)))
+        return value.value
+
+    def __getitem__(self, name):
+        return self.get(name)
+
+    def load(self, series):
+        """Loads series [{"label": name, "x": [ms, ...], "y": [value, ...]}, ...]."""
+        _check(lib.cm_inputs_load_json(self._live(), _encode(json.dumps(series))))
+
+    def __contains__(self, name):
+        found = c_int()
+        _check(lib.cm_inputs_contains(self._live(), _encode(name), byref(found)))
+        return bool(found.value)
+
+    def keys(self):
+        """The inputs read or loaded so far, in name order."""
+        return _keys(lib.cm_inputs_count, lib.cm_inputs_key_at, self._live())
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        count = c_size_t()
+        _check(lib.cm_inputs_count(self._live(), byref(count)))
+        return count.value
+
+
+class Outputs:
+    """The simulation's outputs. An output holds its value until set again and is recorded at the
+    end of every step. Values are numbers; bools are stored as 1 and 0."""
+
+    def __init__(self, simulation):
+        self._simulation = simulation
+        handle = c_void_p()
+        _check(lib.cm_simulation_outputs(simulation._live(), byref(handle)))
+        self._handle = handle
+
+    def _live(self):
+        self._simulation._live()
+        return self._handle
+
+    def __setitem__(self, name, value):
+        _check(lib.cm_output_set(self._live(), _encode(name), float(value)))
+
+    def __getitem__(self, name):
+        """The output's current value; reading an output that was never set creates it with 0."""
+        value = c_double()
+        _check(lib.cm_output_get(self._live(), _encode(name), byref(value)))
+        return value.value
+
+    def __contains__(self, name):
+        found = c_int()
+        _check(lib.cm_outputs_contains(self._live(), _encode(name), byref(found)))
+        return bool(found.value)
+
+    def keys(self):
+        return _keys(lib.cm_outputs_count, lib.cm_outputs_key_at, self._live())
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        count = c_size_t()
+        _check(lib.cm_outputs_count(self._live(), byref(count)))
+        return count.value
+
+
+class Parameters:
+    """The simulation's parameters. They keep their JSON type: numbers, bools, strings, lists,
+    dicts or None."""
+
+    def __init__(self, simulation):
+        self._simulation = simulation
+
+    def get(self, name, fallback):
+        """The parameter's value, storing `fallback` first when it isn't set. A fetched value
+        replaces a stored fallback; a value set with parameters[name] = ... is never replaced."""
+        out = c_char_p()
+        fallback_json = _encode(json.dumps(fallback, allow_nan=False))
+        _check(lib.cm_param_get_or_json(self._simulation._live(), _encode(name), fallback_json, byref(out)))
+        return json.loads(_decode(out.value))
+
+    def __getitem__(self, name):
+        out = c_char_p()
+        status = lib.cm_param_get_json(self._simulation._live(), _encode(name), byref(out))
+        if status == Status.NOT_FOUND:
+            raise KeyError(name)
+        _check(status)
+        return json.loads(_decode(out.value))
+
+    def __setitem__(self, name, value):
+        handle = self._simulation._live()
+        if isinstance(value, float):
+            _check(lib.cm_param_set_double(handle, _encode(name), value))
+        else:
+            _check(lib.cm_param_set_json(handle, _encode(name), _encode(json.dumps(value, allow_nan=False))))
+
+    def __contains__(self, name):
+        found = c_int()
+        _check(lib.cm_param_contains(self._simulation._live(), _encode(name), byref(found)))
+        return bool(found.value)
+
+    def keys(self):
+        return _keys(lib.cm_param_count, lib.cm_param_key_at, self._simulation._live())
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        count = c_size_t()
+        _check(lib.cm_param_count(self._simulation._live(), byref(count)))
+        return count.value
+
+    def to_dict(self):
+        return {name: self[name] for name in self.keys()}
+
+
+class Simulation:
+    """A CppModel simulation.
+
+    Either subclass it and override init(), step(time_ms) and finalize(), or pass those as
+    functions taking the simulation as their first argument:
+
+        sim = Simulation("Heater", total_time_ms=60000, step_ms=100, step=lambda sim, t: ...)
+
+    run() fetches the pending inputs and parameters from the workspace, calls init(), then step()
+    for every step from 0 to total_time_ms, then finalize(), and submits the execution. An
+    exception raised in init(), step() or finalize() aborts the run (nothing is submitted) and is
+    re-raised by run().
+    """
+
+    def __init__(self, name, total_time_ms, step_ms, *, offline=False, init=None, step=None, finalize=None):
+        handle = c_void_p()
+        _check(lib.cm_simulation_create(_encode(name), total_time_ms, step_ms, byref(handle)))
+        self._handle = handle
+        self._error = None
+        self._functions = {"init": init, "step": step, "finalize": finalize}
+        # ctypes frees a callback when its CFUNCTYPE object is collected, so keep them with the handle.
+        self._callbacks = (
+            CALLBACK(lambda _sim, _time, _user: self._invoke(self.init)),
+            CALLBACK(lambda _sim, time_ms, _user: self._invoke(self.step, time_ms)),
+            CALLBACK(lambda _sim, _time, _user: self._invoke(self.finalize)),
+        )
+        _check(lib.cm_simulation_set_init_callback(handle, self._callbacks[0], None))
+        _check(lib.cm_simulation_set_step_callback(handle, self._callbacks[1], None))
+        _check(lib.cm_simulation_set_finalize_callback(handle, self._callbacks[2], None))
+        self._offline = False
+        self.offline = offline
+        self._fingerprint_file = None
+        default = self._default_fingerprint_file()
+        if default is not None and lib.cm_simulation_set_fingerprint_file(handle, _encode(default)) == Status.OK:
+            self._fingerprint_file = default
+        self.inputs = Inputs(self)
+        self.outputs = Outputs(self)
+        self.parameters = Parameters(self)
+
+    # ── Overridables ─────────────────────────────────────────────────────
+
+    def init(self):
+        """Called once before the first step."""
+        if self._functions["init"] is not None:
+            self._functions["init"](self)
+
+    def step(self, time_ms):
+        """Called every step with the simulation time in milliseconds."""
+        if self._functions["step"] is not None:
+            self._functions["step"](self, time_ms)
+
+    def finalize(self):
+        """Called once after the last step."""
+        if self._functions["finalize"] is not None:
+            self._functions["finalize"](self)
+
+    # ── Running ──────────────────────────────────────────────────────────
+
+    def _invoke(self, method, *args):
+        try:
+            method(*args)
+            return Status.OK
+        except BaseException as error:  # also KeyboardInterrupt: Ctrl-C aborts the run between steps
+            self._error = error
+            return Status.CALLBACK
+
+    def run(self):
+        """Runs the simulation and returns its result: 0 when every step passed, otherwise the
+        CppModel.Step of the first failing step (or -1)."""
+        self._error = None
+        status = lib.cm_simulation_run(self._live())
+        if self._error is not None:
+            error, self._error = self._error, None
+            raise error
+        _check(status)
+        return self.result
+
+    def reset_data(self):
+        """Deletes the simulation on the server (same as deleting it in the UI). Call before run()."""
+        _check(lib.cm_simulation_reset_data(self._live()))
+
+    def results(self):
+        """The execution as it is (or would be) submitted: {"inputs", "results", "parameters", ...}."""
+        out = c_char_p()
+        _check(lib.cm_simulation_results_json(self._live(), byref(out)))
+        return json.loads(_decode(out.value))
+
+    def apply_inputs(self, response):
+        """Applies a GET /simulations/{id}/inputs response ({"inputs": [...], "parameters": {...}}).
+        Inputs and parameters already set are kept."""
+        _check(lib.cm_simulation_apply_inputs_json(self._live(), _encode(json.dumps(response))))
+
+    # ── Properties ───────────────────────────────────────────────────────
+
+    @property
+    def name(self):
+        out = c_char_p()
+        _check(lib.cm_simulation_get_name(self._live(), byref(out)))
+        return _decode(out.value)
+
+    @name.setter
+    def name(self, value):
+        _check(lib.cm_simulation_set_name(self._live(), _encode(value)))
+
+    def _timing(self):
+        total, step = c_uint64(), c_uint64()
+        _check(lib.cm_simulation_get_timing(self._live(), byref(total), byref(step)))
+        return total.value, step.value
+
+    @property
+    def total_time_ms(self):
+        return self._timing()[0]
+
+    @total_time_ms.setter
+    def total_time_ms(self, value):
+        _check(lib.cm_simulation_set_timing(self._live(), value, self.step_ms))
+
+    @property
+    def step_ms(self):
+        return self._timing()[1]
+
+    @step_ms.setter
+    def step_ms(self, value):
+        _check(lib.cm_simulation_set_timing(self._live(), self.total_time_ms, value))
+
+    @property
+    def offline(self):
+        """When true, run() doesn't reach the workspace: nothing is fetched or submitted."""
+        return self._offline
+
+    @offline.setter
+    def offline(self, value):
+        _check(lib.cm_simulation_set_run_offline(self._live(), 1 if value else 0))
+        self._offline = bool(value)
+
+    def _default_fingerprint_file(self):
+        # The simulation's code: the subclass's file, else the callbacks' file, else the main script.
+        candidates = [type(self)] if type(self) is not Simulation else []
+        candidates += [function for function in self._functions.values() if function is not None]
+        for candidate in candidates:
+            try:
+                path = inspect.getsourcefile(candidate)
+            except TypeError:
+                continue
+            if path and os.path.isfile(path):
+                return os.path.abspath(path)
+        main = getattr(sys.modules.get("__main__"), "__file__", None)
+        return os.path.abspath(main) if main and os.path.isfile(main) else None
+
+    @property
+    def fingerprint_file(self):
+        """The file whose fingerprint is recorded as CppModel.BinaryFingerprint, so that runs of the
+        same code can be told apart from runs of changed code. Defaults to the file the simulation is
+        defined in; None means the Python interpreter's fingerprint."""
+        return self._fingerprint_file
+
+    @fingerprint_file.setter
+    def fingerprint_file(self, path):
+        encoded = _encode(os.path.abspath(path)) if path is not None else None
+        _check(lib.cm_simulation_set_fingerprint_file(self._live(), encoded))
+        self._fingerprint_file = os.path.abspath(path) if path is not None else None
+
+    @property
+    def result(self):
+        """0 when every step passed; otherwise the CppModel.Step of the first failing step (or -1)."""
+        out = c_int()
+        _check(lib.cm_simulation_get_result(self._live(), byref(out)))
+        return out.value
+
+    @result.setter
+    def result(self, value):
+        _check(lib.cm_simulation_set_result(self._live(), value))
+
+    @property
+    def passed(self):
+        return self.result == 0
+
+    # ── Lifetime ─────────────────────────────────────────────────────────
+
+    def _live(self):
+        if self._handle is None:
+            raise ValueError("the simulation is closed")
+        return self._handle
+
+    def close(self):
+        """Frees the simulation. It is also freed when garbage-collected."""
+        handle, self._handle = getattr(self, "_handle", None), None
+        if handle is not None:
+            lib.cm_simulation_destroy(handle)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.close()
+
+    def __del__(self):
+        self.close()

cppmodel-0.9.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: cppmodel
+Version: 0.9.0
+Summary: Write CppModel simulations in Python
+Project-URL: Homepage, https://cppmodel.com
+Author-email: Control Edge AB <support@cedge.se>
+License-Expression: LicenseRef-CppModel
+License-File: LICENSE
+License-File: licenses/IXWebSocket-LICENSE.txt
+License-File: licenses/cpp-httplib-LICENSE.txt
+License-File: licenses/jwt-cpp-LICENSE.txt
+License-File: licenses/nlohmann-json-LICENSE.txt
+License-File: licenses/openssl-LICENSE.txt
+License-File: licenses/picojson-LICENSE.txt
+Keywords: cppmodel,embedded,plant model,simulation,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# CppModel for Python
+
+Write [CppModel](https://cppmodel.com) simulations in Python. Every run fetches the inputs and
+parameters posted for it in your CppModel workspace and submits its execution there, just like a
+C or C++ simulation built with the CppModel SDK.
+
+```sh
+pip install cppmodel
+```
+
+Wheels are available for Linux (x86_64 and aarch64, glibc 2.28+), Windows (x64 and ARM64) and
+macOS 11+ (Apple silicon and Intel), for Python 3.9 and later. Each wheel contains the CppModel
+library, so nothing else needs installing.
+
+## A simulation
+
+```python
+import sys
+import cppmodel
+
+
+class Heater(cppmodel.Simulation):
+    def init(self):
+        self.temperature = 20.0
+
+    def step(self, time_ms):
+        setpoint = self.inputs.get("Setpoint", 22.0)        # input, with its fallback
+        gain = self.parameters.get("HeaterGain", 0.05)      # parameter, with its fallback
+
+        heater_on = self.temperature < setpoint             # the controller under test
+        self.temperature += gain if heater_on else -0.01
+
+        self.outputs["Temperature"] = self.temperature
+        self.outputs["HeaterOn"] = heater_on
+        self.outputs["CppModel.Step"] = time_ms
+        self.outputs["CppModel.StepResult"] = self.temperature < setpoint + 1.0
+
+
+with Heater("Example - Heater (Python)", total_time_ms=60_000, step_ms=100) as simulation:
+    sys.exit(simulation.run())
+```
+
+`run()` fetches the pending inputs and parameters, calls `init()`, then `step(time_ms)` for every
+step from 0 to `total_time_ms`, then `finalize()`, and submits the execution. It returns 0 when every
+step passed, otherwise the `CppModel.Step` of the first step whose `CppModel.StepResult` was 0.
+
+An exception raised in `init()`, `step()` or `finalize()` (Ctrl-C included) aborts the run, submits
+nothing and is re-raised by `run()`.
+
+Instead of subclassing, you can pass functions that take the simulation as their first argument:
+
+```python
+def ramp(sim, time_ms):
+    sim.outputs["Ramp"] = time_ms
+
+sim = cppmodel.Simulation("Ramp", total_time_ms=1000, step_ms=100, step=ramp)
+sim.run()
+```
+
+## Inputs, outputs and parameters
+
+| | |
+|---|---|
+| `sim.inputs.get(name, fallback)` | The input's value at the current step, or `fallback` (recorded as its value) |
+| `sim.inputs[name]` | Same, with fallback 0 |
+| `sim.inputs.load([{"label", "x", "y"}, ...])` | Loads input series locally (x in ms) |
+| `sim.outputs[name] = value` | Sets an output; it holds until set again and is recorded every step. Values are numbers; bools become 1/0 |
+| `sim.parameters.get(name, fallback)` | The parameter, storing `fallback` when it isn't set; a fetched value replaces the fallback |
+| `sim.parameters[name] = value` | Sets a parameter that fetched values never replace |
+| `sim.parameters[name]` | The parameter, or `KeyError` |
+| `sim.results()` | The execution as submitted: `{"inputs", "results", "parameters", ...}` |
+
+Inputs and outputs are numbers. Parameters keep their JSON type: numbers, bools, strings, lists,
+dicts and `None`. All three support `in`, `len()`, iteration and `keys()`.
+
+## Workspace access
+
+A run needs to sign in to your workspace:
+
+- **Scripts, CI:** set `CPPMODEL_USERNAME` and `CPPMODEL_PASSWORD`.
+- **Without the workspace:** create the simulation with `offline=True`. Nothing is fetched or
+  submitted.
+
+Without credentials, the first run prints a sign-in link and waits until you've signed in. The link
+goes to the process's standard output, which Jupyter doesn't show, so use credentials in notebooks.
+
+## Fingerprint
+
+Each execution records a `CppModel.BinaryFingerprint` of the simulation's code, so the workspace can
+tell runs of the same code from runs of changed code. It is the fingerprint of the file your
+`Simulation` subclass (or step function) is defined in. Set `sim.fingerprint_file` to use another
+file.
+
+## Errors
+
+A failing library call raises `cppmodel.CppModelError`; its `status` is a `cppmodel.Status`.
+
+## License
+
+The CppModel library is proprietary software of Control Edge AB, used under the [CppModel Terms of Service](https://www.cppmodel.com/Tos.html); see `LICENSE`. The package also
+contains third-party components under their own licenses, in `licenses/`.

cppmodel-0.9.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cppmodel/__init__.py,sha256=ROu85RGFEeHsH8hSfT4qVk0Aud3EQoqF7hSI0tgZozw,594
+cppmodel/_native.py,sha256=qUAZuxYVprNMVT0YEekZ7poJlMZkNgP2gyF42Lu09sg,4512
+cppmodel/_simulation.py,sha256=2iogZUPmZO367SNlF7Wvxf253GYVTnHVPNe13UXhaPI,14502
+cppmodel/lib/libcppmodel.so.1,sha256=hF165qMliq9SsePZDXzHhw3u-bJ3a50EQoRHZIvjs_Y,8680696
+cppmodel-0.9.0.dist-info/METADATA,sha256=KF5E1BCwBiiWXhBdrI-gdiU02mhUDYgqiHBs83W4TWQ,5213
+cppmodel-0.9.0.dist-info/WHEEL,sha256=oXgmTSTIbSDIyOVMzS8RHEg6vKUanNsrgMkxt107nkM,107
+cppmodel-0.9.0.dist-info/licenses/LICENSE,sha256=m9J9CSAmn7L5LSEbmwtNhVbRCJin6u75y91XhYRNlgc,382
+cppmodel-0.9.0.dist-info/licenses/licenses/IXWebSocket-LICENSE.txt,sha256=nMRtQmXxirlZt1xEECKF3AS7BOortpaxhY9cOPfrrKA,1506
+cppmodel-0.9.0.dist-info/licenses/licenses/cpp-httplib-LICENSE.txt,sha256=S0XL4W17cbia5hJ-JuDZCgKRmMpelYrY49C4u-02TYs,1075
+cppmodel-0.9.0.dist-info/licenses/licenses/jwt-cpp-LICENSE.txt,sha256=NcLX1oJKHh7SsmbsM0t4YnJq5ZOFXDz6aLlSu3XwgsQ,1075
+cppmodel-0.9.0.dist-info/licenses/licenses/nlohmann-json-LICENSE.txt,sha256=RqZc_9HqlVEy2VqN2SFkBxSo1rU30uTkgtMRRa6VtgM,1076
+cppmodel-0.9.0.dist-info/licenses/licenses/openssl-LICENSE.txt,sha256=QyBwV9TPsX2Di2V-9G25NfX992mLGmN8Hm8ENGqhsu0,611
+cppmodel-0.9.0.dist-info/licenses/licenses/picojson-LICENSE.txt,sha256=VYX-FBzHuwjJU_OFnbYIhSlo0LvGJbm22VwL1jSbrLY,1336
+cppmodel-0.9.0.dist-info/RECORD,,

cppmodel-0.9.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: false
+Tag: py3-none-manylinux_2_28_aarch64

cppmodel-0.9.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+CppModel
+Copyright (c) Control Edge AB. All rights reserved.
+
+This package and the CppModel library it contains are proprietary software of Control Edge AB.
+They are licensed, not sold, and may only be used under the CppModel Terms of Service:
+https://www.cppmodel.com/Tos.html
+
+The package also contains third-party components, each under its own license; see the licenses
+folder.

cppmodel-0.9.0.dist-info/licenses/licenses/IXWebSocket-LICENSE.txt

@@ -0,0 +1,29 @@
+Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the
+   distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cppmodel-0.9.0.dist-info/licenses/licenses/cpp-httplib-LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 yhirose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

cppmodel-0.9.0.dist-info/licenses/licenses/jwt-cpp-LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Dominik Thalhammer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cppmodel-0.9.0.dist-info/licenses/licenses/nlohmann-json-LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License 
+
+Copyright (c) 2013-2025 Niels Lohmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cppmodel-0.9.0.dist-info/licenses/licenses/openssl-LICENSE.txt

@@ -0,0 +1,16 @@
+Apache License
+Version 2.0, January 2004
+
+Copyright (c) OpenSSL Project Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

cppmodel-0.9.0.dist-info/licenses/licenses/picojson-LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright 2009-2010 Cybozu Labs, Inc.
+Copyright 2011-2014 Kazuho Oku
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.