Anselmoo · Anselmoo · Jan 23, 2023 · Jan 23, 2023 · Jan 23, 2023 · Jan 23, 2023
@@ -15,6 +15,7 @@ ignore=CVS
 # regex matches against paths and can be in Posix or Windows format.
 ignore-paths=^spectrafit/test/.*?,
             ^spectrafit/plugins/test/.*?,
+            ^spectrafit/utilities/test/.*?,
             ^tools/.*?,
 
 # Files or directories matching the regex patterns are skipped. The regex

@@ -665,7 +665,7 @@ def make_solver_contribution(self) -> SolverAPI:
             linear_correlation=self.get_linear_correlation,
             component_correlation=self.get_component_correlation,
             confidence_interval=self.get_confidence_interval,
-            covariance_matrix=self.get_component_correlation,
+            covariance_matrix=self.get_covariance_matrix,
             variables=self.get_variables,
             errorbars=self.get_errorbars,
         )

@@ -7,12 +7,14 @@
 from typing import List
 from typing import Optional
 from typing import Tuple
+from typing import Union
 
 import numpy as np
 import pandas as pd
 
 from art import tprint
 from lmfit import Minimizer
+from lmfit import Parameter
 from lmfit import Parameters
 from lmfit import conf_interval
 from lmfit import report_ci
@@ -199,28 +201,24 @@ def fit_report_as_dict(
     )
     for name in parnames:
         par = params[name]
-        buffer["variables"][name] = {}
-
-        if par.init_value is not None:
-            buffer["variables"][name]["init_value"] = par.init_value
-        elif par.expr is not None:
-            buffer["variables"][name]["init_value"] = f"As expressed value: {par.expr}"
-        else:
-            buffer["variables"][name]["init_value"] = f"As fixed value: {par.value}"
+        buffer["variables"][name] = {"init_value": get_init_value(param=par)}
+
         if modelpars is not None and name in modelpars:
             buffer["variables"][name]["model_value"] = modelpars[name].value
         try:
             buffer["variables"][name]["best_value"] = par.value
-        except (TypeError, ValueError):
-            buffer["variables"][name]["init_value"] = "NonNumericValue"
+        except (TypeError, ValueError):  # pragma: no cover
+            buffer["variables"][name][
+                "init_value"
+            ] = "NonNumericValue"  # pragma: no cover
         if par.stderr is not None:
             buffer["variables"][name]["error_relative"] = par.stderr
             try:
                 buffer["variables"][name]["error_absolute"] = (
                     abs(par.stderr / par.value) * 100
                 )
-            except ZeroDivisionError:
-                buffer["variables"][name]["error_absolute"] = np.inf
+            except ZeroDivisionError:  # pragma: no cover
+                buffer["variables"][name]["error_absolute"] = np.inf  # pragma: no cover
 
     for i, name_1 in enumerate(parnames):
         par = params[name_1]
@@ -244,6 +242,27 @@ def fit_report_as_dict(
     return buffer
 
 
+def get_init_value(
+    param: Parameter, modelpars: Optional[Parameter] = None
+) -> Union[float, str]:
+    """Get the initial value of a parameter.
+
+    Args:
+        param (Parameter): The Parameter to extract the initial value from.
+        modelpars (Parameter], optional): Known Model Parameters. Defaults to None.
+
+    Returns:
+        Union[float, str]: The initial value.
+    """
+    if param.init_value is not None:
+        return param.init_value
+    if param.expr is not None:
+        return f"As expressed value: {param.expr}"
+    if modelpars is not None and param.name in modelpars:
+        return modelpars[param.name].value
+    return f"As fixed value: {param.value}"
+
+
 def _extracted_gof_from_results(
     result: minimize, buffer: Dict[str, Any], params: Parameters
 ) -> Tuple[minimize, Dict[str, Any], Parameters]:

@@ -213,10 +213,10 @@ def command_line_runner(args: Optional[Dict[str, Any]] = None) -> None:
             __status__.thanks
             __status__.credits
             return
-        elif again == "y":
-            continue
-        else:
-            __status__.yes_no
+        elif again == "y":  # pragma: no cover
+            continue  # pragma: no cover
+        else:  # pragma: no cover
+            __status__.yes_no  # pragma: no cover
 
 
 def extracted_from_command_line_runner() -> Dict[str, Any]:

@@ -1,15 +1,19 @@
 """Pytest of report model."""
 from typing import Any
 from typing import Dict
+from typing import Union
 
 import numpy as np
 import pandas as pd
 import pytest
 
+from lmfit import Parameter
+from lmfit import Parameters
 from pytest_mock.plugin import MockerFixture
 from spectrafit.report import PrintingResults
 from spectrafit.report import RegressionMetrics
 from spectrafit.report import _extracted_gof_from_results
+from spectrafit.report import get_init_value
 
 
 class TestRegressionMetrics:
@@ -85,3 +89,55 @@ def test_printing_results() -> None:
     )
     pr.print_confidence_interval()
     assert pr.args["confidence_interval"] == {}
+
+
+@pytest.fixture(
+    scope="module",
+    name="par_init",
+)
+def par_init() -> Parameter:
+    """Parameter with init value."""
+    return Parameter(name="par_init", value=1.0)
+
+
+@pytest.fixture(
+    scope="module",
+    name="par_expr",
+)
+def par_expr() -> Parameter:
+    """Parameter with expression."""
+    return Parameter(name="par_expr", expr="par_init")
+
+
+@pytest.fixture(
+    scope="module",
+    name="par_model",
+)
+def par_model() -> Dict[str, Union[Parameter, Parameters]]:
+    """Parameter with expression."""
+    modelpars = Parameters()
+    modelpars.add("param", value=2.0)
+
+    return {"param": Parameter(name="param"), "modelpars": modelpars}
+
+
+@pytest.fixture(
+    scope="module",
+    name="par_fixed",
+)
+def par_fixed() -> Parameter:
+    """Parameter with expression."""
+    return Parameter(name="par_fixed", value=None, vary=False, min=3.0)
+
+
+def test_get_init_value(
+    par_init: Parameter,
+    par_expr: Parameter,
+    par_model: Dict[str, Union[Parameter, Parameters]],
+    par_fixed: Parameter,
+) -> None:
+    """Test of the get init value."""
+    assert get_init_value(par_init) == 1.0
+    assert get_init_value(par_expr) == f"As expressed value: {par_expr.expr}"
+    assert get_init_value(**par_model) == 2.0
+    assert get_init_value(par_fixed) == f"As fixed value: {par_fixed.min}"
@@ -80,5 +80,5 @@ def test_converter(
 
 def test_remove_none_type() -> None:
     """Test remove_none_type function."""
-    d = {"a": None, "b": {"c": None, "d": {"e": None, "f": 1}}}
-    assert remove_none_type(d) == {"b": {"d": {"f": 1}}}
+    d = {"a": None, "b": {"c": None, "d": {"e": None, "f": [1, None]}}}
+    assert remove_none_type(d) == {"b": {"d": {"f": [1]}}}