screamlab 0.1.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

screamlab/dataset.py

@@ -12,8 +12,10 @@ Classes:
 
 """
 
+import sys
 from datetime import datetime
 import numpy as np
+from lmfit import Parameters
 from screamlab import io, utils, settings, functions
 
 
@@ -66,12 +68,17 @@ class Dataset:
         print(
             f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start buildup fit."
         )
+
         self._start_buildup_fit()
         print(
             f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: "
             f"Start generating result files. ({self.props.output_folder})"
         )
         self._print_all()
+        print(
+            f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: "
+            f"Finished with {self.props.path_to_experiment}"
+        )
 
     def _start_buildup_fit_from_spectra(self):
         """Starts buildup fitting using data imported from spectra CSV files."""
@@ -86,6 +93,7 @@ class Dataset:
         fitting_type="voigt",
         peak_sign="-",
         line_broadening=None,
+        integration_range=None,
     ):
         """
         Adds a peak to the ds.
@@ -94,7 +102,7 @@ class Dataset:
         ----------
             center_of_peak (float): Peak position in ppm (chemical shift).
             peak_label (str, optional): Custom label. Defaults to "Peak_at_<ppm>_ppm".
-            fitting_type (str, optional): Peak shape: "gauss", "lorentz", or "voigt" (default).
+            fitting_type (str, optional): Peak shape:  "gauss", "lorentz", or "voigt" (default).
             peak_sign (str, optional): "+" for upward, "-" for downward peaks. Defaults to "+".
             line_broadening (dict, optional): Dict with "sigma" and "gamma" keys for line width.
                 Defaults to {"sigma": {"min": 0, "max": 3}, "gamma": {"min": 0, "max": 3}}.
@@ -109,6 +117,7 @@ class Dataset:
         peak.fitting_type = fitting_type
         peak.peak_sign = peak_sign
         peak.line_broadening = line_broadening
+        peak.integration_range = integration_range
 
     def _read_in_data_from_topspin(self):
         """Reads and imports data from TopSpin."""
@@ -132,7 +141,7 @@ class Dataset:
 
     def _calculate_peak_intensities(self):
         """Calculates peak intensities based on fitting methods."""
-        if self.props.prefit:
+        if self.props.prefit and self.props.spectrum_fit_type != "numint":
             print(
                 f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start prefit."
             )
@@ -148,7 +157,7 @@ class Dataset:
             result = self.fitter.fit()
             self.lmfit_result_handler.global_fit = result
             self._get_intensities(result)
-        if "global" == self.props.spectrum_fit_type:
+        elif "global" == self.props.spectrum_fit_type:
             print(
                 f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start global fit."
             )
@@ -156,6 +165,15 @@ class Dataset:
             result = self.fitter.fit()
             self.lmfit_result_handler.global_fit = result
             self._get_intensities(result)
+        elif "numint" == self.props.spectrum_fit_type:
+            print(
+                f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: Start integration."
+            )
+            self._set_integration_calc()
+            result = self.fitter.fit()
+            self._get_intensities(result)
+        else:
+            sys.exit()
 
     def _start_buildup_fit(self):
         """Performs buildup fitting using the appropriate fitter classes."""
@@ -164,7 +182,9 @@ class Dataset:
             "biexponential_with_offset": utils.BiexpFitterWithOffset,
             "exponential": utils.ExpFitter,
             "exponential_with_offset": utils.ExpFitterWithOffset,
-            "streched_exponential": utils.StrechedExponentialFitter,
+            "stretched_exponential": utils.StrechedExponentialFitter,
+            "exponential_decay": utils.ExpDecayFitter,
+            "exponential_decay_with_offset": utils.ExpDecayFitterWithOffset,
         }
 
         for b_type in self.props.buildup_types:
@@ -187,10 +207,18 @@ class Dataset:
         """Sets up a global fitter for all spectra."""
         self.fitter = utils.GlobalFitter(self)
 
+    def _set_integration_calc(self):
+        self.fitter = utils.NumericalIntegration(self)
+
     def _get_intensities(self, result):
         """Extracts intensity values from the fitting results."""
         if isinstance(
-            self.fitter, (utils.IndependentFitter, utils.GlobalFitter)
+            self.fitter,
+            (
+                utils.IndependentFitter,
+                utils.GlobalFitter,
+                utils.NumericalIntegration,
+            ),
         ):
             for peak in self.peak_list:
                 peak.buildup_vals = (result, self.spectra)
@@ -213,6 +241,21 @@ class Dataset:
                 if f"{peak.peak_label}_{lw}_0" in result.params
             }
 
+    def _transform_result_format(self, results):
+        print(results)
+        params_new = Parameters()
+        for result in results:
+            for name, par in result.params.items():
+                params_new.add(
+                    name,
+                    value=par.value,
+                    vary=par.vary,
+                    min=par.min,
+                    max=par.max,
+                    expr=par.expr,
+                )
+        return params_new
+
 
 class Spectra:
     """
@@ -257,6 +300,7 @@ class Peak:
         self._line_broadening = None
         self._line_broadening_init = None
         self._buildup_vals = None
+        self._integration_range = None
 
     def __str__(self):
         """
@@ -277,6 +321,34 @@ class Peak:
             f" {self._format_fitting_range('')}"
         )
 
+    def to_string(self, spectrum_fit_type):
+        """
+        Returns a string representation of the peak.
+
+        If `spectrum_fit_type` is "numint", detailed peak information
+        is returned, including center, label, sign, and integration range.
+        Otherwise, the default string representation of the object is returned.
+
+        Args:
+            spectrum_fit_type (str): The type of spectrum fitting.
+                Supports "numint" for numerical integration.
+
+        Returns
+        -------
+            str: A formatted string with peak information, or the default
+                string representation of the object.
+
+
+        """
+        if spectrum_fit_type == "numint":
+            return (
+                f"Peak center: {self.peak_center} ppm\n"
+                f"Peak label: {self.peak_label}\n"
+                f"Peak sign: {self.peak_sign}\n"
+                f"Numerical integration range: {self.integration_range} ppm\n"
+            )
+        return str(self)
+
     def _format_fitting_range(self, fit_type):
         a_max = "0 and inf" if self.peak_sign == "+" else "-inf and 0"
         lb = ""
@@ -297,6 +369,34 @@ class Peak:
             f"{lb}"
         )
 
+    @property
+    def integration_range(self) -> list:
+        """
+        Gets the integration range.
+
+        :return:
+        """
+        return self._integration_range
+
+    @integration_range.setter
+    def integration_range(self, args):
+        """
+        Sets the integration range.
+
+        :param args: List containing the integration range for numerical integragtion.
+        """
+        if args is not None:
+            if (
+                not isinstance(args, list)
+                or len(args) != 2
+                or not all(isinstance(e, (int, float)) for e in args)
+            ):
+                raise TypeError(
+                    "Integration range must be a list of two numbers or None."
+                )
+
+        self._integration_range = args
+
     @property
     def buildup_vals(self) -> list:
         """
@@ -315,7 +415,10 @@ class Peak:
         """
         result, spectra = args
         self._buildup_vals = BuildupList()
-        self._buildup_vals.set_vals(result, spectra, self.peak_label)
+        if isinstance(result, dict):
+            self._buildup_vals.set_num_int_vals(result[self], spectra)
+        else:
+            self._buildup_vals.set_vals(result, spectra, self.peak_label)
 
     @property
     def line_broadening(self) -> str:
@@ -600,6 +703,21 @@ class BuildupList:
         self._set_intensity(result, label, spectra)
         self._sort_lists()
 
+    def set_num_int_vals(self, result, spectra):
+        """
+        Sets buildup values from numerical integration.
+
+        Attributes
+        ----------
+            result (list): Intensity values
+            spectra (list): Spectrum objects used with result to compute buildup.
+            label (str): Peak label used to filter relevant parameters in result.
+
+        """
+        self._set_tpol(spectra)
+        self.intensity = result
+        self._sort_lists()
+
     def _set_tpol(self, spectra):
         self.tpol = [s.tpol for s in spectra]
 
@@ -607,20 +725,26 @@ class BuildupList:
         last_digid = None
         self.intensity = []
         val_list = []
-        for param in result.params:
-            if label in param:
-                if last_digid != param.split("_")[-1]:
-                    if val_list:
-                        self.intensity.append(
-                            self._calc_integral(
-                                val_list, spectra[int(last_digid)]
+        res_list = []
+        if not isinstance(result, list):
+            res_list.append(result)
+        else:
+            res_list = result
+        for single_result in res_list:
+            for param in single_result.params:
+                if label in param:
+                    if last_digid != param.split("_")[-1]:
+                        if val_list:
+                            self.intensity.append(
+                                self._calc_integral(
+                                    val_list, spectra[int(last_digid)]
+                                )
                             )
-                        )
-                    last_digid = param.split("_")[-1]
-                    val_list = []
-                val_list.append(float(result.params[param].value))
-                if param.split("_")[-2] == "gamma":
-                    val_list.append("gamma")
+                        last_digid = param.split("_")[-1]
+                        val_list = []
+                    val_list.append(float(single_result.params[param].value))
+                    if param.split("_")[-2] == "gamma":
+                        val_list.append("gamma")
         self.intensity.append(
             self._calc_integral(val_list, spectra[int(last_digid)])
         )
@@ -641,6 +765,8 @@ class BuildupList:
         """
         simspec = [0 for _ in range(len(spectrum.x_axis))]
         simspec = functions.calc_peak(spectrum.x_axis, simspec, val_list)
+        if hasattr(np, "trapezoid"):
+            return np.trapezoid(simspec)
         return np.trapz(simspec)
 
     def _sort_lists(self):

screamlab/functions.py

@@ -169,6 +169,48 @@ def calc_stretched_exponential(time_vals, param):
     )
 
 
+def calc_expdecay(time_vals, param):
+    """
+    Compute values of an exponential growth function over time.
+
+    The function models the equation:
+        I(t) = A * exp(-t / t)
+
+    where:
+        - I(t)  : The output value at time t
+        - A     : Amplitude (maximum value the function approaches)
+        - t    : Time constant (controls the rate of decay)
+
+    Returns
+    -------
+        list: Exponential profile evaluated at t.
+
+    """
+    return list(param[0] * np.exp(-np.asarray(time_vals) / param[1]))
+
+
+def calc_expdecaywithoffset(time_vals, param):
+    """
+    Compute values of an exponential growth function over time.
+
+    The function models the equation:
+        I(t) = A * exp(-t / t) + I0
+
+    where:
+        - I(t)  : The output value at time t
+        - A     : Amplitude (maximum value the function approaches)
+        - t    : Time constant (controls the rate of decay)
+
+    Returns
+    -------
+        list: Exponential profile evaluated at t.
+
+    """
+    return list(
+        param[0] * np.exp(-np.asarray(time_vals) / param[1]) + param[2]
+    )
+
+
 def calc_biexponential(time_vals, param):
     """
     Compute values of a biexponential growth function over time.
@@ -245,7 +287,7 @@ def calc_biexponential_with_offset(time_vals, param):
     )
 
 
-def generate_spectra_param_dict(params):
+def generate_spectra_param_dict_global(params):
     """
     Generate a dictionary of spectral parameters from a list of parameter names.
 
@@ -278,6 +320,40 @@ def generate_spectra_param_dict(params):
     return param_dict
 
 
+def generate_spectra_param_dict_individual(params):
+    """
+    Generate a dictionary of spectral parameters from a list of parameter names.
+
+    :param params: Dictionary of parameter names and values.
+    :return: Dictionary of structured parameter values.
+    """
+    param_dict = {}
+    dict_index = -1
+    for list_element in params:
+        prefix, lastfix = None, None
+        param_value_list = []
+        for param in list_element.params:
+            parts = re.split(r"_(cen|amp|sigma|gamma)_", param)
+            if prefix != parts[0]:
+                if param_value_list:
+                    param_dict[dict_index].append(param_value_list)
+                prefix = parts[0]
+                param_value_list = []
+            if lastfix != parts[2]:
+                if param_value_list:
+                    param_dict[dict_index].append(param_value_list)
+                    param_value_list = []
+                lastfix = parts[2]
+                dict_index += 1
+            if dict_index not in param_dict:
+                param_dict[dict_index] = []
+            param_value_list.append(float(list_element.params[param].value))
+            if parts[1] == "gamma":
+                param_value_list.append("gam")
+        param_dict[dict_index].append(param_value_list)
+    return param_dict
+
+
 def calc_peak(x_axis, simspec, val):
     """Simulates spectra based on given parameters."""
     if len(val) == 5:
@@ -303,8 +379,9 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
-        "streched_exponential": [
+        "stretched_exponential": [
             "Af",
             "tf",
             "---",
@@ -315,6 +392,7 @@ def format_mapping():
             "Sf",
             "---",
             "beta",
+            "---",
         ],
         "exponential_with_offset": [
             "Af",
@@ -327,6 +405,7 @@ def format_mapping():
             "Sf",
             "---",
             "---",
+            "---",
         ],
         "biexponential": [
             "Af",
@@ -339,6 +418,7 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
         ],
         "biexponential_with_offset": [
             "Af",
@@ -351,6 +431,33 @@ def format_mapping():
             "Sf",
             "Ss",
             "---",
+            "---",
+        ],
+        "exponential_decay": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "---",
+        ],
+        "exponential_decay_with_offset": [
+            "Af",
+            "tf",
+            "---",
+            "---",
+            "---",
+            "Rf",
+            "---",
+            "Sf",
+            "---",
+            "---",
+            "I0",
         ],
     }
 
@@ -368,7 +475,8 @@ def buildup_header():
         "Rs / 1/s",
         "Sensitivity1 (Af/sqrt(tf))",
         "Sensitivity2 (As/sqrt(ts))",
-        "beta",
+        "beta / a.u.",
+        "I0 / a.u.",
     ]
 
 
@@ -395,7 +503,9 @@ def return_func_map():
         "biexponential": calc_biexponential,
         "exponential_with_offset": calc_exponential_with_offset,
         "biexponential_with_offset": calc_biexponential_with_offset,
-        "streched_exponential": calc_stretched_exponential,
+        "stretched_exponential": calc_stretched_exponential,
+        "exponential_decay": calc_expdecay,
+        "exponential_decay_with_offset": calc_expdecaywithoffset,
     }
 
 

screamlab/io.py

@@ -113,6 +113,13 @@ class TopspinImporter:
         ]
         return path_list
 
+    def _gen_subspectrum(self):
+        self._dataset.spectra[-1].x_axis, self._dataset.spectra[-1].y_axis = (
+            screamlab.functions.generate_subspec(
+                self._dataset.spectra[-1], self._dataset.props.subspec
+            )
+        )
+
 
 class ScreamImporter(TopspinImporter):
     """
@@ -124,15 +131,6 @@ class ScreamImporter(TopspinImporter):
 
     """
 
-    def _set_number_of_scans(self):
-        """Set the number of scans for the last spectrum in the ds."""
-        with open(rf"{self.file}/acqu", "r", encoding="utf-8") as acqu_file:
-            for acqu_line in acqu_file:
-                if "##$NS=" in acqu_line:
-                    self._dataset.spectra[-1].number_of_scans = int(
-                        acqu_line.strip().split(" ")[-1]
-                    )
-
     def import_topspin_data(self):
         """Import NMR data from TopSpin and process it."""
         files = self._generate_path_to_experiment()
@@ -142,6 +140,15 @@ class ScreamImporter(TopspinImporter):
             self._set_values()
         self._sort_xy_lists()
 
+    def _set_number_of_scans(self):
+        """Set the number of scans for the last spectrum in the ds."""
+        with open(rf"{self.file}/acqus", "r", encoding="utf-8") as acqu_file:
+            for acqu_line in acqu_file:
+                if "##$NS=" in acqu_line:
+                    self._dataset.spectra[-1].number_of_scans = int(
+                        acqu_line.strip().split(" ")[-1]
+                    )
+
     def _set_buildup_time(self):
         """Set the buildup time for the last spectrum in the ds."""
         delay = self._extract_params_from_acqus("##$D= (0..63)", 64)
@@ -204,16 +211,49 @@ class ScreamImporter(TopspinImporter):
             self._dataset.spectra[-1].number_of_scans,
         )
 
-    def _gen_subspectrum(self):
-        self._dataset.spectra[-1].x_axis, self._dataset.spectra[-1].y_axis = (
-            screamlab.functions.generate_subspec(
-                self._dataset.spectra[-1], self._dataset.props.subspec
-            )
-        )
-
 
 class Pseudo2DImporter(TopspinImporter):
-    """Not implemented yet."""
+    """
+    Class for importing and processing Pseudo2D data based on VD list.
+
+    Automatically reads information about x- and y-axis (chemical shift and intensitys),
+    polarization times (t_pol) and the number of scans used for the respective experiment.
+    Automatically normalizes the  intensitys to the number of scans.
+
+    """
+
+    def import_topspin_data(self):
+        """Import pseudo 2D NMR data from TopSpin and process it."""
+        files = self._generate_path_to_experiment()
+        self.file = files[0]
+        self._set_values()
+
+    def _set_values(self):
+        """Set internal values including scans, buildup time, x and y data."""
+        dic, data = ng.bruker.read_pdata(
+            f"{self.file}/pdata/{self._dataset.props.procno}"
+        )
+        uc = ng.bruker.guess_udic(dic, data)
+        vdlist = self._get_vdvals()
+        for spectrum_nr in range(data.shape[0]):
+            self._add_spectrum()
+            self._dataset.spectra[-1].number_of_scans = int(
+                dic.get("acqus", {}).get("NS", None)
+            )
+            self._dataset.spectra[-1].tpol = vdlist[spectrum_nr]
+            self._dataset.spectra[-1].x_axis = ng.fileiobase.uc_from_udic(
+                uc, dim=1
+            ).ppm_scale()
+            self._dataset.spectra[-1].y_axis = data[spectrum_nr, :]
+            if len(self._dataset.props.subspec) == 2:
+                self._gen_subspectrum()
+
+    def _get_vdvals(self):
+        vdvals = []
+        with open(rf"{self.file}/vdlist", "r", encoding="utf-8") as vdlist:
+            for vdline in vdlist:
+                vdvals.append(float(vdline.strip()))
+        return vdvals
 
 
 class Exporter:
@@ -258,18 +298,29 @@ class Exporter:
         """
         self._print_report()
         self._plot_topspin_data()
-        self._plot_global_all_together()
-        if self.dataset.props.prefit:
+        if self.dataset.props.spectrum_fit_type != "numint":
+            self._plot_global_all_together()
+        if (
+            self.dataset.props.prefit
+            and self.dataset.props.spectrum_fit_type != "numint"
+        ):
             self._plot_prefit()
             self._print_lmfit_prefit_report()
-        if "global" in self.dataset.props.spectrum_fit_type:
+        if (
+            "global" in self.dataset.props.spectrum_fit_type
+            and self.dataset.props.spectrum_fit_type != "numint"
+        ):
             self._plot_global_each_individual()
-        if "individual" in self.dataset.props.spectrum_fit_type:
+        if (
+            "individual" in self.dataset.props.spectrum_fit_type
+            and self.dataset.props.spectrum_fit_type != "numint"
+        ):
             self._plot_global_each_individual()
         for buildup_type in self.dataset.props.buildup_types:
             self._plot_buildup(buildup_type)
-        self._write_global_fit_results_to_semicolon_separated_file()
-        self._write_buildup_fit_to_semicolon_separated_file()
+        if self.dataset.props.spectrum_fit_type != "numint":
+            self._write_global_fit_results_to_semicolon_separated_file()
+            self._write_buildup_fit_to_semicolon_separated_file()
         self._csv_output()
 
     def _plot_topspin_data(self):
@@ -321,7 +372,7 @@ class Exporter:
             self.dataset.props.spectrum_for_prefit
         ]
         x_axis, y_axis = spectrum.x_axis, spectrum.y_axis
-        valdict = screamlab.functions.generate_spectra_param_dict(
+        valdict = screamlab.functions.generate_spectra_param_dict_global(
             self.dataset.lmfit_result_handler.prefit.params
         )
         simspec = [0] * len(y_axis)
@@ -430,9 +481,19 @@ class Exporter:
 
     def _plot_global_each_individual(self):
         output_dir = self._generate_output_dir("spectral_deconvolution_plots")
-        param_dict = screamlab.functions.generate_spectra_param_dict(
-            self.dataset.lmfit_result_handler.global_fit.params
-        )
+        param_dict = None
+        if self.dataset.props.spectrum_fit_type == "global":
+            param_dict = (
+                screamlab.functions.generate_spectra_param_dict_global(
+                    self.dataset.lmfit_result_handler.global_fit.params
+                )
+            )
+        elif self.dataset.props.spectrum_fit_type == "individual":
+            param_dict = (
+                screamlab.functions.generate_spectra_param_dict_individual(
+                    self.dataset.lmfit_result_handler.global_fit
+                )
+            )
 
         for key, param_list in param_dict.items():
             spectrum = self.dataset.spectra[key]
@@ -484,10 +545,19 @@ class Exporter:
 
     def _plot_global_all_together(self):
         output_dir = self._generate_output_dir("spectral_deconvolution_plots")
-
-        param_dict = screamlab.functions.generate_spectra_param_dict(
-            self.dataset.lmfit_result_handler.global_fit.params
-        )
+        param_dict = None
+        if self.dataset.props.spectrum_fit_type == "global":
+            param_dict = (
+                screamlab.functions.generate_spectra_param_dict_global(
+                    self.dataset.lmfit_result_handler.global_fit.params
+                )
+            )
+        elif self.dataset.props.spectrum_fit_type == "individual":
+            param_dict = (
+                screamlab.functions.generate_spectra_param_dict_individual(
+                    self.dataset.lmfit_result_handler.global_fit
+                )
+            )
 
         num_spectra = len(param_dict)
         cols = 3
@@ -572,15 +642,23 @@ class Exporter:
             f.write("[[Peaks]]\n")
             for peak_nr, peak in enumerate(self.dataset.peak_list):
                 f.write(f"[Peak {peak_nr + 1}]\n")
-                f.write(str(peak))
+                f.write(peak.to_string(self.dataset.props.spectrum_fit_type))
             f.write("[[Prefit]]\n")
-            if self.dataset.props.prefit:
+            if (
+                self.dataset.props.prefit
+                and self.dataset.props.spectrum_fit_type != "numint"
+            ):
                 self._get_prefit_string(f)
             else:
                 f.write("No prefit performed.\n")
 
-            f.write("[[Global fit results]]\n")
-            self._print_global_fit_results(f)
+            if self.dataset.props.spectrum_fit_type != "numint":
+                f.write("[[Spectral deconvolution results]]\n")
+                self._print_global_fit_results(f)
+
+            else:
+                f.write("[[Numerical integration results]]\n")
+                self._print_global_fit_results_numint(f)
             f.write("[[Buildup fit results]]\n")
             self._print_buildup(f)
 
@@ -588,7 +666,7 @@ class Exporter:
         for buildup_type in self.dataset.props.buildup_types:
             f.write(f"[{buildup_type}]\n")
             header = screamlab.functions.buildup_header()
-            column_widths = [20, 15, 10, 15, 10, 15, 15, 15, 35, 35, 10]
+            column_widths = [20, 15, 10, 15, 10, 15, 15, 15, 35, 35, 20, 15]
             f.write(
                 "".join(h.ljust(w) for h, w in zip(header, column_widths))
                 + "\n"
@@ -614,12 +692,42 @@ class Exporter:
                     + "\n"
                 )
 
-    def _print_global_fit_results(self, f):
-        valdict = screamlab.functions.generate_spectra_param_dict(
-            self.dataset.lmfit_result_handler.global_fit.params
+    def _print_global_fit_results_numint(self, f):
+        header = ["Label", "Time", "Integral"]
+        column_widths = [25, 12, 10]
+        f.write(
+            "".join(f"{h:<{w}}" for h, w in zip(header, column_widths)) + "\n"
         )
+        for peak in self.dataset.peak_list:
+            for integral_nr, integral in enumerate(
+                peak.buildup_vals.intensity
+            ):
+                line = []
+                if integral_nr == 0:
+                    line.append(peak.peak_label)
+                else:
+                    line.append(" ")
+                line.append(peak.buildup_vals.tpol[integral_nr])
+                line.append(round(integral, 4))
+                f.write(
+                    "".join(f"{h:<{w}}" for h, w in zip(line, column_widths))
+                    + "\n"
+                )
+
+    def _print_global_fit_results(self, f):
+        valdict = None
+        if self.dataset.props.spectrum_fit_type == "global":
+            valdict = screamlab.functions.generate_spectra_param_dict_global(
+                self.dataset.lmfit_result_handler.global_fit.params
+            )
+        elif self.dataset.props.spectrum_fit_type == "individual":
+            valdict = (
+                screamlab.functions.generate_spectra_param_dict_individual(
+                    self.dataset.lmfit_result_handler.global_fit
+                )
+            )
         header = screamlab.functions.spectrum_fit_header()
-        column_widths = [25, 12, 15, 20, 15, 15, 22, 20, 20, 10]
+        column_widths = [25, 12, 15, 20, 15, 15, 22, 20, 20, 20, 15]
         f.write(
             "".join(f"{h:<{w}}" for h, w in zip(header, column_widths)) + "\n"
         )
@@ -633,7 +741,7 @@ class Exporter:
                 )
 
     def _get_prefit_string(self, f):
-        valdict = screamlab.functions.generate_spectra_param_dict(
+        valdict = screamlab.functions.generate_spectra_param_dict_global(
             self.dataset.lmfit_result_handler.prefit.params
         )
         widths = [25, 18, 20, 15, 15]
@@ -764,9 +872,18 @@ class Exporter:
         )
 
         with open(output_file_path, "w", encoding="utf-8") as f:
-            valdict = screamlab.functions.generate_spectra_param_dict(
-                self.dataset.lmfit_result_handler.global_fit.params
-            )
+            valdict = None
+            if self.dataset.props.spectrum_fit_type == "global":
+                valdict = (
+                    screamlab.functions.generate_spectra_param_dict_global(
+                        self.dataset.lmfit_result_handler.global_fit.params
+                    )
+                )
+            elif self.dataset.props.spectrum_fit_type == "individual":
+                valdict = screamlab.functions.generate_spectra_param_dict_individual(
+                    self.dataset.lmfit_result_handler.global_fit
+                )
+
             header = screamlab.functions.spectrum_fit_header()
             f.write(";".join(str(item) for item in header) + "\n")
             for delay_time in range(0, len(valdict[0])):
@@ -859,6 +976,7 @@ class Exporter:
         return row
 
     def _gen_voigt_output(self, values, delay_time, val_nr):
+
         return [
             (
                 self.dataset.peak_list[delay_time].peak_label

screamlab/settings.py

@@ -80,12 +80,20 @@ class Properties:
         return self._subspec
 
     @subspec.setter
-    def subspec(self, value: Any):
-        """Sets list for subspectrum"""
-        if value is not None:
-            self._subspec = value
-        else:
+    def subspec(self, value):
+        if value is None:
             self._subspec = []
+            return
+
+        try:
+            self._subspec = [float(v) for v in value]
+        except (TypeError, ValueError) as exc:
+            raise ValueError(
+                "subspec must be a sequence of two floats"
+            ) from exc
+
+        if len(self._subspec) != 2:
+            raise ValueError("subspec must contain exactly two values")
 
     @property
     def output_folder(self) -> str:
@@ -181,7 +189,7 @@ class Properties:
         """
         str, optional: A list specifying the spectrum fit type
 
-        Options supporded: "global","independent".
+        Options supporded: "global", "independent, "numint".
 
         """
         return self._spectrum_fit_type
@@ -189,10 +197,7 @@ class Properties:
     @spectrum_fit_type.setter
     def spectrum_fit_type(self, value: Any):
         """Sets the spectrum fit type"""
-        allowed_values = {
-            "global",
-            "individual",
-        }
+        allowed_values = {"global", "individual", "numint"}
         if not isinstance(value, str):
             raise TypeError(
                 f"Expected 'spectrum_fit_type' to be of type 'str', got"
@@ -227,7 +232,9 @@ class Properties:
             "biexponential",
             "biexponential_with_offset",
             "exponential_with_offset",
-            "streched_exponential",
+            "stretched_exponential",
+            "exponential_decay",
+            "exponential_decay_with_offset",
         }
         if not isinstance(value, list):
             raise TypeError(

screamlab/utils.py

@@ -23,6 +23,7 @@ Classes:
 """
 
 import copy
+from datetime import datetime
 import numpy as np
 import lmfit
 from pyDOE3 import lhs
@@ -33,7 +34,7 @@ class Fitter:
     """
     Base class for spectral fitting using `lmfit`.
 
-    This class handles parameter initialization and spectral fitting for a ds.
+    This class handles parameter initialization and spectral fitting for a dataset.
 
     Attributes
     ----------
@@ -44,7 +45,7 @@ class Fitter:
 
     def __init__(self, dataset):
         """
-        Initializes the Fitter with a ds.
+        Initializes the Fitter with a dataset.
 
         Args
         ----
@@ -66,7 +67,6 @@ class Fitter:
         x_axis, y_axis = self._generate_axis_list()
         params = self._generate_params_list()
         params = self._set_param_expr(params)
-
         return self._start_minimize(x_axis, y_axis, params)
 
     def _start_minimize(self, x_axis, y_axis, params):
@@ -194,8 +194,8 @@ class Fitter:
         return {
             "name": f"{peak.peak_label}_cen_{nr}",
             "value": peak.peak_center,
-            "min": peak.peak_center - 20,
-            "max": peak.peak_center + 20,
+            "min": peak.peak_center - 1,
+            "max": peak.peak_center + 1,
         }
 
     def _get_lw_dict(self, peak, nr, lw):
@@ -240,7 +240,9 @@ class Fitter:
 
         """
         residual = copy.deepcopy(y_axis)
-        params_dict_list = functions.generate_spectra_param_dict(params)
+        params_dict_list = functions.generate_spectra_param_dict_global(
+            params
+        )
         for key, val_list in params_dict_list.items():
             for val in val_list:
                 simspec = [0 for _ in range(len(x_axis[key]))]
@@ -281,6 +283,71 @@ class Prefitter(Fitter):
         return result
 
 
+class NumericalIntegration(Fitter):
+    """
+    Subclass of Fitter that calculates spectral signal intensities via numerical integration.
+
+    This class is designed for applications where the area under a curve
+    in a given spectral window is of interest, such as quantifying peak
+    intensities in spectroscopy or other analytical measurements.
+    By integrating over a defined region, it provides a robust measure
+    of signal strength that accounts for variations in peak shape
+    and baseline fluctuations.
+    """
+
+    def fit(self):
+        """
+        Performs spectral numerical integration using numpy trapz or trapezoid function.
+
+        Returns
+        -------
+        dict
+            The result of the integration process.
+
+        """
+        integrals = {}
+        for spectrum in self.dataset.spectra:
+            for peak in self.dataset.peak_list:
+                if peak not in integrals:
+                    integrals[peak] = []
+                self._check_integration_range_in_spectra(spectrum, peak)
+                subspec_x_axis, subspec_y_axis = functions.generate_subspec(
+                    spectrum, peak.integration_range
+                )
+                if hasattr(np, "trapezoid"):
+                    integrals[peak].append(
+                        np.trapezoid(
+                            subspec_y_axis[::-1], subspec_x_axis[::-1]
+                        )
+                    )
+                else:
+                    integrals[peak].append(
+                        np.trapz(subspec_y_axis[::-1], subspec_x_axis[::-1])
+                    )
+        return integrals
+
+    def _check_integration_range_in_spectra(self, spectrum, peak):
+        self._check_if_integration_range_are_set(peak)
+        for integration_boundary in peak.integration_range:
+            if not (
+                min(spectrum.x_axis)
+                <= integration_boundary
+                <= max(spectrum.x_axis)
+            ):
+                raise ValueError(
+                    f"Integration boundary {integration_boundary} is outside the spectrum "
+                    f"range ({min(spectrum.x_axis)} – {max(spectrum.x_axis)})."
+                )
+
+    def _check_if_integration_range_are_set(self, peak):
+        if peak.integration_range is None:
+            raise ValueError(
+                f"Peak '{peak.peak_label}' ({peak.peak_center:.3f} ppm): "
+                f"integration_range is not set. "
+                f"Call dataset.add_peak({peak.peak_center}, integration_range=(from_ppm, to_ppm))."
+            )
+
+
 class GlobalFitter(Fitter):
     """
     Global fit over all spectra at different polarization times.
@@ -329,6 +396,77 @@ class IndependentFitter(Fitter):
     must be ensured that all spectra can be fitted by conditions given in point two.
     """
 
+    def _generate_params_list(self):
+        """
+        Generates initial fitting parameters based on peak information in the ds.
+
+        Returns
+        -------
+        lmfit.Parameters
+            The initialized parameters for fitting.
+
+        """
+        params_list = []
+        spectra = self._get_spectra_list()
+        lw_types = {
+            "voigt": ["sigma", "gamma"],
+            "gauss": ["sigma"],
+            "lorentz": ["gamma"],
+        }
+        for spectrum_nr, _ in enumerate(spectra):
+            params = lmfit.Parameters()
+            for peak in self.dataset.peak_list:
+                params.add(**self._get_amplitude_dict(peak, spectrum_nr))
+                params.add(**self._get_center_dict(peak, spectrum_nr))
+
+                for lw_type in lw_types.get(peak.fitting_type, []):
+                    params.add(
+                        **self._get_lw_dict(peak, spectrum_nr, lw_type)
+                    )
+            params_list.append(params)
+        return params_list
+
+    def _start_minimize(self, x_axis, y_axis, params):
+        all_results = []
+        for spectrum_nr, spectrum in enumerate(x_axis):
+            print(
+                f"\t{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}: "
+                f"Start fitting spectrum number {spectrum_nr+1}/{len(x_axis)}"
+            )
+            result = lmfit.minimize(
+                self._spectral_fitting,
+                params[spectrum_nr],
+                args=(spectrum, y_axis[spectrum_nr]),
+            )
+            all_results.append(result)
+        return all_results
+
+    def _spectral_fitting(self, params, x_axis, y_axis):
+        """
+        Computes the residual between the fitted and experimental spectra.
+
+        Args
+        ----
+            params (lmfit.Parameters): The fitting parameters.
+            x_axis (list): List of x-axis values.
+            y_axis (list): List of y-axis values.
+
+        Returns
+        -------
+            np.ndarray: The residual between the fitted and experimental spectra.
+
+        """
+        residual = y_axis.copy()
+        params_dict_list = functions.generate_spectra_param_dict_global(
+            params
+        )
+        for _, val_list in params_dict_list.items():
+            for val in val_list:
+                simspec = [0 for _ in range(len(x_axis))]
+                simspec = functions.calc_peak(x_axis, simspec, val)
+                residual -= simspec
+        return residual
+
 
 class BuildupFitter:
     """
@@ -483,6 +621,27 @@ class BuildupFitter:
         """
         return [params[key].value for key in params]
 
+    def _get_intensity_offset_dict(self, peak):
+        """
+        Generate intensity offset parameter dictionary.
+
+        :param peak: Peak object containing buildup values.
+        :return: Dictionary with default intensity parameter values.
+        """
+        return (
+            {
+                "value": 10,
+                "min": max(peak.buildup_vals.intensity) * -3,
+                "max": max(peak.buildup_vals.intensity) * 3,
+            }
+            if peak.peak_sign == "+"
+            else {
+                "value": 10,
+                "max": min(peak.buildup_vals.intensity) * -3,
+                "min": min(peak.buildup_vals.intensity) * 3,
+            }
+        )
+
     def _get_intensity_dict(self, peak):
         """
         Generate intensity parameter dictionary.
@@ -559,6 +718,88 @@ class BiexpFitter(BuildupFitter):
         return functions.calc_biexponential(tdel, param)
 
 
+class ExpDecayFitter(BuildupFitter):
+    """
+    Class for fitting exponential decay models to experimental data.
+
+    The exponential decay model fits decay curves using one exponential term
+    characterized by an amplitude (A) and a time constants (t).
+
+    The model function is defined as:
+        I(t_pol) = A *  exp(-t_pol / t))
+
+    where:
+        - A        : amplitudes of the exponential components
+        - t        : time constants of the exponential components (t > 0)
+        - t_pol    : polarization time (independent variable)
+        - I(t_pol) : peak intensity at polarization time t_pol
+    """
+
+    def _get_default_param_dict(self, peak):
+        """
+        Define default parameters for exponential decay fitting.
+
+        :param peak: Peak object containing peak_sign and buildup values.
+        :return: Dictionary of default parameters with keys: A, t.
+        """
+        return {
+            "Af": self._get_intensity_dict(peak),
+            "tf": self._get_time_dict(peak),
+        }
+
+    def _calc_intensity(self, tdel, param):
+        """
+        Calculate exponential decay intensity.
+
+        :param tdel: Time delays.
+        :param param: List of parameters.
+        :return: Calculated intensity values.
+        """
+        return functions.calc_expdecay(tdel, param)
+
+
+class ExpDecayFitterWithOffset(BuildupFitter):
+    """
+    Class for fitting exponential decay models to experimental data.
+
+    The exponential decay model fits decay curves using one exponential term
+    characterized by an amplitude (A), an intensity offset (I0) and a time constants (t).
+
+    The model function is defined as:
+        I(t_pol) = I0 + A *  exp(-t_pol / t))
+
+    where:
+        - A        : amplitudes of the exponential components
+        - t        : time constants of the exponential components (t > 0)
+        - t_pol    : polarization time (independent variable)
+        - I0       : Intensity offset
+        - I(t_pol) : peak intensity at polarization time t_pol
+    """
+
+    def _get_default_param_dict(self, peak):
+        """
+        Define default parameters for exponential decay fitting with offset.
+
+        :param peak: Peak object containing peak_sign and buildup values.
+        :return: Dictionary of default parameters with keys: A, t, I0.
+        """
+        return {
+            "Af": self._get_intensity_dict(peak),
+            "tf": self._get_time_dict(peak),
+            "I0": self._get_intensity_offset_dict(peak),
+        }
+
+    def _calc_intensity(self, tdel, param):
+        """
+        Calculate exponential decay intensity.
+
+        :param tdel: Time delays.
+        :param param: List of parameters.
+        :return: Calculated intensity values.
+        """
+        return functions.calc_expdecaywithoffset(tdel, param)
+
+
 class BiexpFitterWithOffset(BuildupFitter):
     """
     Class for fitting biexponential models with offset to buildup data.

{screamlab-0.1.0.dist-info → screamlab-0.3.1.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: screamlab
-Version: 0.1.0
+Version: 0.3.1
 Summary: Package for reproducible evaluation of SCREAM-DNP data.
 Home-page: https://github.com/FlorianTaube/screamlab
 Author: Florian Taube
 Author-email: florian.taube@uni-rostock.de
 License: BSD
-Project-URL: Documentation, https://github.com/FlorianTaube/screamlab/docs
+Project-URL: Documentation, https://screamlab.readthedocs.io
 Project-URL: Source, https://github.com/FlorianTaube/screamlab/screamlab
 Keywords: Buildup Time Calculator,NMR,DNP,SCREAM_DNP,TopspinExport
 Classifier: Programming Language :: Python :: 3

screamlab-0.3.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+screamlab/__init__.py,sha256=M2vfzk7vI3qvlxE2uIHyGYmPSrFYNUacFjkjiLX00wc,63
+screamlab/dataset.py,sha256=d4Ztrr-gAYiNA8nGi5zhkQeRvdBdI6FblYBst3XLnzQ,26837
+screamlab/functions.py,sha256=zujGG87iwcBfl8clg1JUG1SYYTIO4XutNmCVhlZME4M,14638
+screamlab/io.py,sha256=deZEbf9gFn3OIr3lCS_ZbklGni-YG3_DBuNMEt710EQ,42968
+screamlab/settings.py,sha256=4lUsrTj6Ne9RQPmjSy1EAM5M2I8EwaM4ZpVE8-GP-JM,9459
+screamlab/utils.py,sha256=Ca82YmSmKsZf-EX9dra0WEcZrJWYcWdsnzs3xQDtHoQ,34268
+screamlab/__pycache__/__init__.cpython-310.pyc,sha256=nGadfOt1WUjQxMQAWhkaJ8HQIBoFYgJOXOcou6xtrJ4,245
+screamlab/__pycache__/__init__.cpython-312.pyc,sha256=Vo2caaR8VoJ8_NleXq-XOrPKFsFfwxsYJtyJjRxMaAQ,253
+screamlab/__pycache__/__init__.cpython-313.pyc,sha256=yQf9pPv0AH2e55exkKjAhkP7dXZn17lnMgudh9XDnxo,249
+screamlab/__pycache__/__init__.cpython-38.pyc,sha256=M5eZ95kmsA8r__ZH_prnNqi--MGl8WclL9g0yUXGTAo,176
+screamlab/__pycache__/dataset.cpython-310.pyc,sha256=wIfwBQFdYvUbanp8okbVfyF4Txdx0DwPrID_AG054QM,24961
+screamlab/__pycache__/dataset.cpython-312.pyc,sha256=6I6pajXpcAGzgMMWz8Uz8RBFvHhamr8ldh4LYvgmVHY,29658
+screamlab/__pycache__/dataset.cpython-313.pyc,sha256=SZHG1m9zZ8iKTrETEkd1IyrZ0ts41wyONaug2zFYPNc,33499
+screamlab/__pycache__/functions.cpython-310.pyc,sha256=QFIT-SC3IypiT3FjxR4rdFaX3mBCuNmI7gwHj3IPIWI,12089
+screamlab/__pycache__/functions.cpython-312.pyc,sha256=3XGaxzxxkM11879B0tD2igT9kx-_s3lk1fhABYwIPec,13136
+screamlab/__pycache__/functions.cpython-313.pyc,sha256=ozCyYcTb6HU6BBgz0Byag3-EYVdqTTNHmU1VqAFnVNU,12631
+screamlab/__pycache__/io.cpython-310.pyc,sha256=qbi2IVwZfOTr8nZ1u4vxsgQtsqlxMAJxDUYUIZn3ZaM,33595
+screamlab/__pycache__/io.cpython-312.pyc,sha256=MMoeXwNuzsekbKxuU151oMMqJ_Hn-gQ-GmwSHULdVOA,53564
+screamlab/__pycache__/io.cpython-313.pyc,sha256=FqolkwTPOY7ViOsfEGFzf5pYfif4ikfFPDlXoG-tdlA,51707
+screamlab/__pycache__/settings.cpython-310.pyc,sha256=JDbCK7P7CAU_xoh3uwcKJhyge-7TXD59RKRG6RcV6Hs,8642
+screamlab/__pycache__/settings.cpython-312.pyc,sha256=C_E_orj-EgVwor9s8eqF0hBs-vejOFEglWI7DN1U6Yo,11907
+screamlab/__pycache__/settings.cpython-313.pyc,sha256=m1P8CXfLTds2c40e-pmtBuWTfKI6X3YaroXsZL-mV7Q,12019
+screamlab/__pycache__/utils.cpython-310.pyc,sha256=vG1o5HO3D_tTicOQJv1gYdkAg-9PhB2jnXxA5QVoSSU,32103
+screamlab/__pycache__/utils.cpython-312.pyc,sha256=NkdFr8Yr-ywDfFqTJK3QUro_YMGyezhQ04YF5Va4yGo,30799
+screamlab/__pycache__/utils.cpython-313.pyc,sha256=6nj3DrKpIb11HUDjo1ubnP4ymMBE8S2vuacY3zGjhNk,29120
+screamlab-0.3.1.dist-info/licenses/LICENSE,sha256=Ic_N1IFIdReR7m-W6XtN_4k6B8IgJ33dQFLc6Xi5C2E,1291
+screamlab-0.3.1.dist-info/METADATA,sha256=cPkvLs3GDzSemCu4hNU0Xnq4-C6RxaYBw2Et0VrLQYU,2942
+screamlab-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+screamlab-0.3.1.dist-info/top_level.txt,sha256=XjErA4-PG_phESo1eWs-bMzdnBWu4gNxB-RX78zZqqw,10
+screamlab-0.3.1.dist-info/RECORD,,

screamlab-0.1.0.dist-info/RECORD

@@ -1,27 +0,0 @@
-screamlab/__init__.py,sha256=M2vfzk7vI3qvlxE2uIHyGYmPSrFYNUacFjkjiLX00wc,63
-screamlab/dataset.py,sha256=QZSGwm3au08ZEBLdH-pmkyXaeatwBVMZQKs-37j3IQ4,22537
-screamlab/functions.py,sha256=vq6YseAt6L0YlduI6LV3_WBcLhFaOqDRGDIIDaZ3kfc,11398
-screamlab/io.py,sha256=B5I9oxQ4uH2dExnoDlO7Glbk3KcrXSVJcWTEl05eLOk,38017
-screamlab/settings.py,sha256=XBlzWjsdcAO3Fq_d9UyxYViirT9qmpw5_UVrYd-lt0o,9130
-screamlab/utils.py,sha256=VbHaH_QWfcj2WM-TrraPCdjMr7qJ5ybkc2Vgguqhvxg,25503
-screamlab/__pycache__/__init__.cpython-310.pyc,sha256=nGadfOt1WUjQxMQAWhkaJ8HQIBoFYgJOXOcou6xtrJ4,245
-screamlab/__pycache__/__init__.cpython-312.pyc,sha256=Vo2caaR8VoJ8_NleXq-XOrPKFsFfwxsYJtyJjRxMaAQ,253
-screamlab/__pycache__/__init__.cpython-313.pyc,sha256=yQf9pPv0AH2e55exkKjAhkP7dXZn17lnMgudh9XDnxo,249
-screamlab/__pycache__/__init__.cpython-38.pyc,sha256=M5eZ95kmsA8r__ZH_prnNqi--MGl8WclL9g0yUXGTAo,176
-screamlab/__pycache__/dataset.cpython-310.pyc,sha256=_faFHwzFWVQ12RQn_JEmVacRbG3kfRjiq2oZMFC0lKU,21615
-screamlab/__pycache__/dataset.cpython-312.pyc,sha256=6I6pajXpcAGzgMMWz8Uz8RBFvHhamr8ldh4LYvgmVHY,29658
-screamlab/__pycache__/dataset.cpython-313.pyc,sha256=hUv5iLuEbc1ZvsghDsBs5fMJX8P2c9LVODugU9AUq6Q,28966
-screamlab/__pycache__/functions.cpython-310.pyc,sha256=NCAC7EjK1gJCi5sdEcferiMHbFVOhTL6jme0-0-5xKg,10221
-screamlab/__pycache__/functions.cpython-312.pyc,sha256=3XGaxzxxkM11879B0tD2igT9kx-_s3lk1fhABYwIPec,13136
-screamlab/__pycache__/io.cpython-310.pyc,sha256=5l2qLRHXu0_xQIeBtpRf4on_aX8z9M8Y-pvPWRNNxMM,30699
-screamlab/__pycache__/io.cpython-312.pyc,sha256=MMoeXwNuzsekbKxuU151oMMqJ_Hn-gQ-GmwSHULdVOA,53564
-screamlab/__pycache__/settings.cpython-310.pyc,sha256=NEb0GFRJNxnFdCyQSv5WPBp6yPT15dwC8_IHQVpB0Us,8263
-screamlab/__pycache__/settings.cpython-312.pyc,sha256=C_E_orj-EgVwor9s8eqF0hBs-vejOFEglWI7DN1U6Yo,11907
-screamlab/__pycache__/settings.cpython-313.pyc,sha256=bkB5KCTnxR8rKtrYezCt753f-cnjwhTfXZL2LsVTiaE,11800
-screamlab/__pycache__/utils.cpython-310.pyc,sha256=1ADymFGnozfp-gqDCH8PMxPKGDAutepRqsPheXKcuQ0,25452
-screamlab/__pycache__/utils.cpython-312.pyc,sha256=NkdFr8Yr-ywDfFqTJK3QUro_YMGyezhQ04YF5Va4yGo,30799
-screamlab-0.1.0.dist-info/licenses/LICENSE,sha256=Ic_N1IFIdReR7m-W6XtN_4k6B8IgJ33dQFLc6Xi5C2E,1291
-screamlab-0.1.0.dist-info/METADATA,sha256=rJ7ubHx5d35-l0izBb6ax6N4Sosrjb6kqlVZwaCLnEU,2956
-screamlab-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-screamlab-0.1.0.dist-info/top_level.txt,sha256=XjErA4-PG_phESo1eWs-bMzdnBWu4gNxB-RX78zZqqw,10
-screamlab-0.1.0.dist-info/RECORD,,