physiomodeler 0.5.1__py3-none-any.whl

physiomodeler/__init__.py

@@ -0,0 +1,6 @@
+from .physiomodel import PhysioModel
+from . import post_analysis
+
+__version__ = "0.5.1"
+
+__all__ = ["PhysioModel", "post_analysis"]

physiomodeler/converters.py

@@ -0,0 +1,104 @@
+import numpy as np
+from numpy.typing import ArrayLike
+
+
+def sanitize_inputs(
+    inputs,
+    allow_none=True,
+    allow_callable=False,
+    allow_string=False,
+    allow_sequence=False,
+):
+    if not isinstance(inputs, dict):
+        inputs = dict.fromkeys(inputs)
+
+    def check_value(key, value):
+        if not isinstance(key, str):
+            msg = f"Keys should be a non-string sequence, not '{key}' ({type(key)})"
+            raise TypeError(msg)
+
+        if (
+            (allow_none and value is None)
+            or isinstance(value, (int, float))
+            or (allow_callable and callable(value))
+            or (allow_string and isinstance(value, str))
+            or (allow_sequence and isinstance(value, (list, tuple)))
+        ):
+            return value
+
+        if isinstance(value, list):
+            value = np.array(value)
+
+        if isinstance(value, np.ndarray):
+            if np.sum(np.array(value.shape)) != 1:
+                raise ValueError("Input array should be 1D or reducable to 1D")
+
+            value = np.flatten(value)
+
+            return value
+
+        msg = f"Input with key '{key}' must be a {'function, ' if allow_callable else ''}number, list or 1D-array, not '{value}' ({type(value)})."
+        raise TypeError(msg)
+
+    return {key: check_value(key, value) for key, value in inputs.items()}
+
+
+def parse_time(
+    time: float | tuple[float, float] | tuple[float, float, float] | list | np.ndarray,
+    dt: float | None = None,
+) -> tuple[float, float, np.ndarray]:
+    step = start = end = None
+
+    if isinstance(time, (float, int)):
+        start = 0
+        end = time
+        step = dt
+    elif isinstance(time, tuple) and len(time) == 2:
+        start = time[0] or 0
+        end = time[1]
+        step = dt
+    elif isinstance(time, tuple) and len(time) == 3:
+        if dt:
+            msg = "Multiple values for `dt`: can't parse `time` as a tuple with length 3 when `dt` is set."
+            raise ValueError(msg)
+        start = time[0] or 0
+        end = time[1]
+        step = time[2]
+    elif isinstance(time, tuple):
+        msg = f"`time` should a tuple with length 2 or 3, not {time}"
+        raise ValueError(msg)
+    elif isinstance(time, list):
+        time = np.array(time)
+
+    if isinstance(time, np.ndarray):
+        start = time[0]
+        end = time[-1]
+    elif step:
+        time = np.arange(start, end, step)
+    else:
+        time = None
+
+    if start is None or end is None:
+        raise ValueError("`time` cannot be parsed. No start and end are provided.")
+
+    return start, end, time
+
+
+def convert_inputs(inputs: dict, time: int | ArrayLike, parameters):
+    """Converts function inputs to values at the given time point."""
+
+    parsed_inputs = dict()
+    for key, input_ in inputs.items():
+        if callable(input_):
+            parsed_inputs[key] = input_(time=time, parameters=parameters)
+        else:
+            parsed_inputs[key] = input_
+
+        if (
+            isinstance(parsed_inputs[key], np.ndarray)
+            and parsed_inputs[key].shape == tuple()
+        ):
+            # convert 0D array to number
+            parsed_inputs[key] = parsed_inputs[key].item()
+
+    return parsed_inputs

physiomodeler/events.py

@@ -0,0 +1,40 @@
+from typing import Literal
+
+
+def state_crosses_value(
+    label: str,
+    value: float,
+    *,
+    terminal: bool = False,
+    direction: Literal[-1, 0, 1] = 0,
+):
+    """
+    Create an event that detects when a state crossing the given value.
+
+
+    Example:
+        # This example will have an event and terminate when the volume (state)
+        # crosses the value 0.
+
+        model = PhysioModeler(
+            ...,
+            events=[
+                state_crosses_value("volume", 0, terminal=True),
+            ]
+        )
+
+    Attrs:
+        label: label of the state to track
+        value: the event will trigger when the state crosses this value
+        terminal: whether to terminate the simulation if the event occurs
+        direction: if 0, any crossing will be detected; if 1, only positive
+        crossings (value goes from negative to positive) will be detected; if
+        -1, only negative crossings will be detected.
+    """
+
+    def event(time, state, inputs, parameters):
+        return state[label] - value
+
+    event.terminal = terminal
+    event.direction = direction
+    return event

physiomodeler/physiomodel.py

@@ -0,0 +1,397 @@
+from functools import reduce
+from typing import Final, Literal, TypeAlias
+from collections.abc import Callable
+
+import numpy as np
+import scipy as sp
+import pandas as pd
+
+from attrs import define, field, validators
+
+from .converters import sanitize_inputs, parse_time, convert_inputs
+
+ModelFunc: TypeAlias = Callable[[float | np.ndarray, dict, dict, dict], dict]
+
+STATE_DERIVATIVE_LABEL_TEMPLATE: Final = "d{label}"
+
+
+@define()
+class PhysioModel:
+    """A state-space model described by an update function and parameters.
+
+    This class can be used to describe and numerically analyze a state space
+    model. A state-space model has at least one state variable that evolves
+    over time based on the state, as well as the inputs to and parameters of
+    the model.
+
+    The model is described by one or multiple update functions that returns how
+    the state changes. An update function should have the signature `fun(time,
+    state, inputs, parameters)`. Update functions are called in the order they
+    are provided. The output of each update function is added to the input of
+    later update functions. Each update function should return a dictionary
+    containing state derivatives and other value outputs. State derivates can
+    be returned by different functions, but a derivative should be returned for
+    all state variables.
+
+    By default, the key for a state derivative should be "d" + the state label,
+    e.g. "dvelocity" for the state "velocity". Alternatively, you can supply a
+    mapping dictionary `state_derivative_label_map` where the key is the state
+    variable label and the value is the state derivative label.
+
+    Inputs and parameters both contain values that can be used by the update
+    function. There is, however, a distinction between inputs and parameters.
+    Parameters are fixed values that are independent of time, e.g. the mass of
+    an object at the end of a pendulum. Inputs are disturbances added to the
+    system, and can be either fixed or variable with time, e.g. the force
+    applied to a moving mass. `inputs` and `parameters` are both dictionaries.
+    `inputs` values can be functions with the signature `fun(time, inputs,
+    parameters)`, which are converted to the appropriate before being passed to
+    the update function.
+
+    Events are functions with a signature `fun(time, state, inputs,
+    parameters)`. An event occurs when a function returns `0`. The solver will
+    find an accurate value of `time` where `fun(time, ...) == 0`. This ensures
+    proper simulation around that time point. Each event function can be marked
+    'terminal' by adding the `terminal` attribute with value `True` to the
+    event function (`fun.terminal = True`). This results in the simulation
+    being terminal as soon as the event return value crosses `0`. See
+    [`scipy.integrate.solve_ivp`](https://docs.scipy.org/doc/scipy-1.14.1/reference/reference/generated/scipy.integrate.solve_ivp.html#scipy.integrate.solve_ivp)
+    for more details.
+
+    Post analysis functions can be supplied, which receive the output of the
+    system as a pandas DataFrame (see `input_output_response`) and either
+    update the dataframe or return an array, list, Series or DataFrame object
+    with the same length that is added to the output of the model.
+
+    ### Example
+
+    The example below is the classic undampended pendulum. The system is
+    governed by the second derivative of the angle theta. The system state has
+    two components: the current angle "theta" and the angular velocity
+    "dtheta". The function `pendulum()` calculates the second derivative and
+    returns both the first and second derivative. When this system is solved,
+    the new state is calculated based on the derivatives of the previous step.
+
+    Example:
+    ```
+    >>> def pendulum(time, state, inputs, parameters):
+    ...     g = parameters["g"]
+    ...     l = parameters["l"]
+    ...     theta = state["theta"]
+    ...
+    ...     first_derivative_theta = state["dtheta"]
+    ...     second_derivative_theta = -(g / l) * np.sin(theta)
+    ...
+    ...     return {
+    ...         "dtheta": first_derivative_theta,
+    ...         "ddtheta": second_derivative_theta
+    ...     }
+    >>> model = PhysioModel(
+    ...     function=pendulum,
+    ...     state=("theta", "dtheta"),
+    ...     parameters={"g": 9.81, "l": 1},
+    ... )
+    >>> df = model.input_output_response(time=10, initial_state=(0.1, 0))
+    ```
+
+    Args:
+        function: a (list of) functions with accepting time, state, inputs and
+        parameters as arguments and returning a dictionary containing (at
+        least) the state derivatives state: a list containing the state labels,
+        or a dictionary containing the intial values of the state inputs: a
+        list/tuple containing the input labels, or a dictionary containing the
+        inputs parameters: a dictionary containing the parameters of the model
+        post_analysis: optional, a dictionary containing functions to calculate
+        values based on the output of the model state_derivative_label_map:
+        optional, a dictionary mapping the labels of the state derivatives to
+        the labels of the state variables.
+
+    """
+
+    function: ModelFunc | list[ModelFunc]
+    state: dict[str, float | None] = field(
+        kw_only=True,
+        converter=lambda x: sanitize_inputs(x, allow_callable=False),
+        validator=validators.min_len(1),
+    )
+    inputs: dict[str, float | Callable | None] = field(
+        kw_only=True,
+        factory=dict,
+        converter=lambda x: sanitize_inputs(x, allow_callable=True),
+    )
+    parameters: dict[str, float | str | bool] = field(kw_only=True, factory=dict)
+    events: Callable | list[Callable] = field(kw_only=True, factory=list)
+    post_analysis: dict[str, Callable] = field(kw_only=True, factory=dict)
+
+    state_derivative_label_map: dict[str, str] = field(kw_only=True, factory=dict)
+
+    @property
+    def input_labels(self) -> tuple:
+        """Labels of the inputs of the model."""
+        return tuple(self.inputs)
+
+    @property
+    def state_labels(self) -> tuple:
+        """Labels of the state variables of the model."""
+        return tuple(self.state)
+
+    @property
+    def state_derivative_labels(self) -> tuple:
+        """Labels of the state derivatives of the model."""
+        default_labels = {
+            label: STATE_DERIVATIVE_LABEL_TEMPLATE.format(label=label)
+            for label in self.state_labels
+        }
+        updated_labels = default_labels | self.state_derivative_label_map
+        return tuple(updated_labels.values())
+
+    def input_output_response(
+        self,
+        *,
+        initial_state: dict | list | tuple | None = None,
+        inputs: dict | list | tuple | None = None,
+        parameters: dict | list | tuple | None = None,
+        time: float | tuple | np.ndarray,
+        dt: float | None = None,
+        solve_ivp_method: Literal["Radau"] = "Radau",
+        rtol=1e-4,
+        atol=1e-6,
+    ):
+        """Generate an output based on the given initial state, inputs and
+        parameters.
+
+        This function generates the output of the model over a given time axis
+        based on an initial state, the inputs and parameters. If no or not all
+        the `initial_state`, `inputs` or `parameters` values are given, the
+        values provided to the system at initialisation are used instead.
+
+        The time can be passed in several ways. The simplest is passing a
+        duration. The model will be solved up to that duration. When `time` is
+        a tuple of length 2, it indicates the start and end time. (Note that
+        the initial state is the state at `t=start`, not at `t=0`.) The time
+        step will be `dt` if supplied, or determined by the solver otherwise.
+        If `time` is a tuple of length 3, the last value is used as the time
+        step. If a list or array is supplied, the output will contain these
+        time points.
+
+        Relative and abolute tolerance for the solver. The solver estimates a
+        local error as `atol + rol * abs(state)`. `rtol` controls a relative
+        accuracy ('number of correct digits') while `atol` controls abolute
+        accuracy ('number of correct decimal places'). See
+        [`scipy.integrate.solve_ivp`](https://docs.scipy.org/doc/scipy-1.14.1/reference/reference/generated/scipy.integrate.solve_ivp.html#scipy.integrate.solve_ivp)
+        for more details.
+
+        Args:
+            initial_state: optional, initial values for the state as a
+            dictionary, or list/tuple of values
+            inputs: optional, inputs of the system as a dictionary or
+            list/tuple of values
+            parameters:
+            optional, dictionary with the parameters of the system
+            time:
+            int/float, tuple or array indicating the time axis of the output
+            dt: optional, the time step of the time axis
+            solve_ivp_method: solver used; currently only "Radau" is supported
+            rtol: float, relative tolerance
+            atol: float: absolute tolerance
+        """
+
+        inputs = self._parse_inputs(inputs)
+        parameters = self._parse_parameters(parameters)
+        initial_state = self._parse_state(initial_state)
+        (t_start, t_end, time) = parse_time(time, dt)
+        events = self._parse_events(inputs, parameters)
+
+        update_function: Callable
+
+        if isinstance(self.function, list):
+            functions: list = self.function
+
+            def multiple_functions_wrapper(time, state, inputs, parameters) -> dict:
+                updating_inputs = inputs.copy()
+                outputs = []
+                for function in functions:
+                    out = function(time, state, updating_inputs, parameters)
+                    updating_inputs |= out
+                    outputs.append(out)
+
+                # combine all dictionaries
+                return reduce(lambda a, b: {**a, **b}, outputs)
+
+            update_function = multiple_functions_wrapper
+        elif callable(self.function):
+            update_function = self.function
+        else:
+            msg = "Provided argument `function` is not a function or list of functions."
+            raise TypeError(msg)
+
+        def function_wrapper(
+            time, state, inputs=inputs, parameters=parameters, function=update_function
+        ) -> dict:
+            """Wraps the user function to provide proper inputs and add inputs
+            and state to the results."""
+            converted_inputs = convert_inputs(inputs, time, parameters)
+
+            state = {k: v for k, v in zip(self.state_labels, state)}
+            result = function(time, state, converted_inputs, parameters)
+
+            result = converted_inputs | state | result
+
+            return result
+
+        def simplified_func(time, state, inputs=inputs, parameters=parameters) -> tuple:
+            output = function_wrapper(time, state, inputs, parameters)
+            return tuple(output[label] for label in self.state_derivative_labels)
+
+        solution = sp.integrate.solve_ivp(
+            simplified_func,
+            (t_start, t_end),
+            [initial_state[k] for k in self.state_labels],
+            method=solve_ivp_method,
+            t_eval=time,
+            events=events,
+            rtol=rtol,
+            atol=atol,
+        )
+
+        # generate an output for each timepoint/state combination
+        all_outputs = list(
+            function_wrapper(time, state)
+            for time, state in zip(solution.t, solution.y.T)
+        )
+        output_keys = all_outputs[0].keys()
+
+        # zip all outputs
+        zipped_outputs = {k: [o[k] for o in all_outputs] for k in output_keys}
+
+        if "time" not in zipped_outputs:
+            zipped_outputs["time"] = solution.t
+
+        data_frame = pd.DataFrame(zipped_outputs).set_index("time")
+
+        for k, update_function in self.post_analysis.items():
+            post_analysis_result = update_function(data_frame, parameters)
+            if post_analysis_result is None:
+                pass
+            elif isinstance(post_analysis_result, pd.DataFrame):
+                # TODO: join with copy of orignal, not original
+                data_frame = data_frame.join(post_analysis_result)
+            else:
+                try:
+                    data_frame[k] = post_analysis_result
+                except:  # noqa: E722
+                    msg = "The result of post analysis can't seem to be added to the output."
+                    raise RuntimeError(msg)
+
+        data_frame.attrs = dict(solution)
+
+        return data_frame
+
+    def _parse_events(self, inputs, parameters):
+        if self.events is None:
+            return []
+
+        def event_wrapper(event):
+            if not callable(event):
+                msg = f"'{event}' ({type(event)}) is not callable."
+                raise TypeError(msg)
+
+            def internal(time, state):
+                state = dict(zip(self.state_labels, state))
+                return event(
+                    time=time, state=state, inputs=inputs, parameters=parameters
+                )
+
+            if hasattr(event, "terminal"):
+                internal.terminal = event.terminal
+
+            if hasattr(event, "direction"):
+                internal.direction = event.direction
+
+            return internal
+
+        events = self.events if isinstance(self.events, list) else [self.events]
+        events = [event_wrapper(event) for event in events]
+        return events
+
+    def _parse_state(self, state) -> dict:
+        if state is None:
+            state = {}
+        elif isinstance(state, list | tuple):
+            state = {k: v for k, v in zip(self.state_labels, state, strict=True)}
+
+        if not isinstance(state, dict):
+            msg = f"Initial state should be dict or sequence, not {type(state)}"
+            raise TypeError(msg)
+
+        state = self.state | state
+        state = sanitize_inputs(state, allow_none=False)
+        return state
+
+    def _parse_parameters(self, parameters):
+        if parameters is None:
+            parameters = {}
+
+        parameters = self.parameters | parameters
+        parameters = sanitize_inputs(
+            parameters, allow_string=True, allow_none=False, allow_sequence=True
+        )
+        return parameters
+
+    def _parse_inputs(self, inputs):
+        if inputs is None:
+            inputs = {}
+
+        elif isinstance(inputs, (list, tuple, np.ndarray)):
+            if len(inputs) != len(self.input_labels):
+                msg = f"The number of inputs ({len(inputs)}) does not match the number of defined inputs ({len(self.input_labels)})."
+                raise ValueError(msg)
+            inputs = {k: v for k, v in zip(self.input_labels, inputs, strict=True)}
+
+        if not isinstance(inputs, dict):
+            raise TypeError(f"Inputs should be dict or sequence, not {type(inputs)}")
+
+        inputs = self.inputs | inputs
+        inputs = sanitize_inputs(inputs, allow_callable=True, allow_none=False)
+        return inputs
+
+    def find_equilibrium_state(
+        self,
+        *,
+        time: float,
+        dt: float | None = None,
+        estimated_equilibrium_state: dict | None = None,
+        inputs: dict | None = None,
+        parameters: dict | None = None,
+        max_n_runs: int = 100,
+        rtol: float = 1e-4,
+        atol: float = 1e-6,
+        rtol_eq: float = 1e-3,
+    ):
+        for _ in range(max_n_runs):
+            if estimated_equilibrium_state is None:
+                estimated_equilibrium_state = {k: 0 for k in self.state_labels}
+
+            data = self.input_output_response(
+                time=time,
+                dt=dt,
+                initial_state=estimated_equilibrium_state,
+                inputs=inputs,
+                parameters=parameters,
+                atol=atol,
+                rtol=rtol,
+            )
+            final_state = dict(data.loc[:, self.state_labels].iloc[-1])
+
+            if np.allclose(
+                list(estimated_equilibrium_state.values()),
+                list(final_state.values()),
+                rtol=rtol_eq,
+            ):
+                return final_state
+
+            estimated_equilibrium_state = final_state
+
+        else:
+            msg = f"Could not find an equilibrium in {max_n_runs} iterations."
+            raise RuntimeError(msg)

physiomodeler/post_analysis.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def mean_value(data, name, window=np.blackman(1200), trim=True):
+    diff = np.diff(data["time"])
+    mean_diff = np.mean(diff)
+    if not np.allclose(diff, mean_diff) or mean_diff <= 0:
+        msg = "Time should be linearly increasing."
+        raise ValueError(msg)
+    normalized_window = window / np.sum(window)
+    convolution = np.convolve(data[name], normalized_window, mode="same")
+    if trim:
+        len_window = len(normalized_window) // 2
+        convolution[:len_window] = np.nan
+        convolution[-len_window:] = np.nan
+    return convolution

physiomodeler-0.5.1.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.3
+Name: physiomodeler
+Version: 0.5.1
+Summary: Create physiological models for educational purposes.
+Author-email: Peter Somhorst <p.somhorst@tudelft.nl>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2023 Peter Somhorst
+        
+        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.
+License-File: LICENSE
+Keywords: education,modelling,physiology,respiration,simulation
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.11
+Requires-Dist: attrs
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: black; extra == 'docs'
+Requires-Dist: mike; extra == 'docs'
+Requires-Dist: mkdocs; extra == 'docs'
+Requires-Dist: mkdocs-exclude; extra == 'docs'
+Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: mkdocstrings; extra == 'docs'
+Requires-Dist: mkdocstrings-python; extra == 'docs'
+Requires-Dist: pymdown-extensions; extra == 'docs'

physiomodeler-0.5.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+physiomodeler/__init__.py,sha256=cSetgQEkVt1-u5uMZFdnqSayMCtokXGyp2i47XHQywg,132
+physiomodeler/converters.py,sha256=H8iszsw2wKZLHeeNNk9xTXXY77byiq0wNGwQUZT8EZ8,3185
+physiomodeler/events.py,sha256=Cxf2fpolGgZmwtafh1ZjNWT7UY0x3ER5SVIE1zHrc9c,1111
+physiomodeler/physiomodel.py,sha256=LmcUDJADhBHOL8-7IyrCcQZ404CYTVFYmNNvfnQltkY,16342
+physiomodeler/post_analysis.py,sha256=7GFgxQwHpeSAv12ODLRD49S8XTmxHeZm7g7BnwgKX0Y,582
+physiomodeler-0.5.1.dist-info/METADATA,sha256=zerxnxYcm1mIdzqeIqQgEGQhVPa-nN92UuQh6j10530,2171
+physiomodeler-0.5.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+physiomodeler-0.5.1.dist-info/licenses/LICENSE,sha256=bU80a4iDhEPFZUtLA0WQPguH14WlVDm8gA-CkhHH0LY,1081
+physiomodeler-0.5.1.dist-info/RECORD,,

physiomodeler-0.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

physiomodeler-0.5.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Peter Somhorst
+
+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.