lime-stable 2.0.2__tar.gz → 2.2.dev1__tar.gz

{lime_stable-2.0.2/src/lime_stable.egg-info → lime_stable-2.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.2
+Version: 2.2.dev1
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@stsci.edu>
 License: GPL-3.0-or-later
@@ -18,7 +18,7 @@ Requires-Dist: scipy~=1.16
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: aspect-stable~=0.4.1; extra == "full"
+Requires-Dist: aspect-stable~=0.7.dev1; extra == "full"
 Requires-Dist: bokeh~=3.8; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"

{lime_stable-2.0.2 → lime_stable-2.2.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.2"
+version = "2.2.dev1"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 license = {text = "GPL-3.0-or-later"}
@@ -24,7 +24,7 @@ dependencies = ["astropy~=7.1",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "aspect-stable~=0.4.1",
+        "aspect-stable~=0.7.dev1",
         "bokeh~=3.8",
         "mplcursors~=0.6",
         "openpyxl~=3.1",
@@ -46,4 +46,5 @@ pythonpath = ["src"]
 mpl-baseline-path = 'tests/baseline'
 mpl-results-path = 'tests/outputs'
 mpl-results-always = false
+markers = ["mpl: matplotlib image comparison tests"]
 addopts = "-p no:asdf_schema_tester"

{lime_stable-2.0.2 → lime_stable-2.2.dev1}/src/lime/archives/read_fits.py

@@ -265,6 +265,7 @@ def check_fits_instructions(fits_source, online_provider=False):
             fits_reader = getattr(fits_manager, fits_source)
         else:
             source_type = 'instrument' if online_provider is False else 'survey'
+            # TODO show instruments supported
             raise LiMe_Error(f'Input {source_type} "{fits_source}" is not recognized. LiMe observation cannot be created.')
 
     else:
@@ -375,6 +376,40 @@ def load_fits(fits_address, data_ext_list=None, hdr_ext_list=None, url_check=Fal
     return data_list, header_list
 
 
+def join_spectra_matrix(wave, flux, err=None):
+
+    # Make sure the wavelength array is increasing
+    # for i in range(wave.shape[0]):
+    #     if wave[i, 0] > wave[i, -1]:
+    #         wave[i] = wave[i, ::-1]
+    #         flux[i] = flux[i, ::-1]
+    #         err[i] = err[i, ::-1] if err is not None else None
+
+    # Make sure the passes are sorted:
+    key = np.nanmean(wave, axis=1)
+    order = np.argsort(key)
+    wave, flux, err = wave[order], flux[order], err[order] if err is not None else None
+
+    # Get dimensions
+    n_passes, n_pix = wave.shape
+
+    join_wl = 0.5 * (wave[:-1, -1] + wave[1:, 0])
+    cut_idx = np.sum(wave[:-1] <= join_wl[:, None], axis=1)
+    cut_idx = np.append(cut_idx, n_pix)
+
+    pix = np.arange(n_pix)
+    mask = pix < cut_idx[:, None]
+
+    wave_1d = wave[mask]
+    flux_1d = flux[mask]
+    err_1d = err[mask] if err is not None else None
+
+    lengths = np.sum(mask, axis=1)
+    starts = np.concatenate(([0], np.cumsum(lengths[:-1])))
+
+    return wave_1d, flux_1d, err_1d
+
+
 class OpenFits:
 
     def __init__(self, file_address, file_source=None, load_function=None, lime_object=None):
@@ -785,30 +820,42 @@ class OpenFits:
 
         """
 
-        # Check dimensions of array
+        # Read the array
         data_list, header_list = load_fits(fits_address, data_ext_list, hdr_ext_list, url_check=False)
+
+        # Warning in the case of empty observartion
+        if len(data_list[0]['WAVELENGTH'].squeeze()) == 0:
+            _logger.critical(f'Input COS observation does not have scientific data ({fits_address}).')
+
+        # One single array with the data
         if data_list[0]['WAVELENGTH'].squeeze().ndim == 1:
             wave_arr = data_list[0]['WAVELENGTH'].squeeze()
             flux_arr = data_list[0]['FLUX'].squeeze()
             err_arr = data_list[0]['ERROR'].squeeze()
 
+        # Multiple passes
         else:
-            # Get common middle index for joining the spectra
-            # wave_matrix = data_list[0]['WAVELENGTH'][::-1]
-            idcs_common = np.nonzero(data_list[0]['WAVELENGTH'][1, :] > data_list[0]['WAVELENGTH'][0, 0])[0]
-            center_idx = idcs_common.shape[0] // 2
-
-            # Create empty containers
-            wave_arr = np.empty(data_list[0]['WAVELENGTH'].size - center_idx, data_list[0]['WAVELENGTH'].dtype)  # TODO check for additional extension to join the spectra
-            flux_arr = np.empty(data_list[0]['FLUX'].size - center_idx, data_list[0]['FLUX'].dtype)  # dtype=data_list[0]['FLUX'].dtype)
-            err_arr = np.empty(data_list[0]['ERROR'].size - center_idx, data_list[0]['ERROR'].dtype)  # dtype=data_list[0]['ERROR'].dtype)
-
-            # Fill with the array data
-            arr_size = data_list[0]['WAVELENGTH'].shape[1]
-            for key_arr, cont_arr in zip(['WAVELENGTH', 'FLUX', 'ERROR'], [wave_arr, flux_arr, err_arr]):
-                cont_arr[0:arr_size - center_idx] = data_list[0][key_arr][1][0:arr_size - center_idx]
-                cont_arr[arr_size - center_idx:] = data_list[0][key_arr][0]
-                # print(key_arr, np.any(np.isnan(cont_arr)))
+
+            wave_arr, flux_arr, err_arr = join_spectra_matrix(data_list[0]['WAVELENGTH'],
+                                                              data_list[0]['FLUX'],
+                                                              data_list[0]['ERROR'])
+
+            # # Get common middle index for joining the spectra
+            # # wave_matrix = data_list[0]['WAVELENGTH'][::-1]
+            # idcs_common = np.nonzero(data_list[0]['WAVELENGTH'][1, :] > data_list[0]['WAVELENGTH'][0, 0])[0]
+            # center_idx = idcs_common.shape[0] // 2
+            #
+            # # Create empty containers
+            # wave_arr = np.empty(data_list[0]['WAVELENGTH'].size - center_idx, data_list[0]['WAVELENGTH'].dtype)  # TODO check for additional extension to join the spectra
+            # flux_arr = np.empty(data_list[0]['FLUX'].size - center_idx, data_list[0]['FLUX'].dtype)  # dtype=data_list[0]['FLUX'].dtype)
+            # err_arr = np.empty(data_list[0]['ERROR'].size - center_idx, data_list[0]['ERROR'].dtype)  # dtype=data_list[0]['ERROR'].dtype)
+            #
+            # # Fill with the array data
+            # arr_size = data_list[0]['WAVELENGTH'].shape[1]
+            # for key_arr, cont_arr in zip(['WAVELENGTH', 'FLUX', 'ERROR'], [wave_arr, flux_arr, err_arr]):
+            #     cont_arr[0:arr_size - center_idx] = data_list[0][key_arr][1][0:arr_size - center_idx]
+            #     cont_arr[arr_size - center_idx:] = data_list[0][key_arr][0]
+            #     # print(key_arr, np.any(np.isnan(cont_arr)))
 
         # Spectrum properties
         params_dict = SPECTRUM_FITS_PARAMS['cos']
@@ -960,7 +1007,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def kcwi(fits_address, data_ext_list=(1, 2), hdr_ext_list=(1,2), **kwargs):
+    def kcwi(fits_address, data_ext_list=(0, 1, 2), hdr_ext_list=(1,2), **kwargs):
 
         """
 
@@ -993,13 +1040,14 @@ class OpenFits:
         wave_array = np.linspace(w_min, w_max, pixels, endpoint=False)
 
         flux_cube = data_list[0]
-        err_cube = data_list[1]
-        pixel_mask_cube = np.isnan(flux_cube)
+        err_cube = np.sqrt(data_list[1])
+        mask_cube = (data_list[2] == 1) | np.isnan(flux_cube)
+        # mask_cube = np.isnan(flux_cube)
 
         wcs = WCS(header_list[0])
 
         # Fits properties
-        fits_params = {**CUBE_FITS_PARAMS['kcwi'], 'pixel_mask': pixel_mask_cube, 'wcs': wcs}
+        fits_params = {**CUBE_FITS_PARAMS['kcwi'], 'pixel_mask': mask_cube, 'wcs': wcs}
 
         return wave_array, flux_cube, err_cube, header_list, fits_params
 

{lime_stable-2.0.2 → lime_stable-2.2.dev1}/src/lime/changelog.txt

@@ -69,7 +69,7 @@ LiMe minor update - 1.2.1 - 10/29/2024
     - Corrected bug on the latex label generation in the lime.line_bands command not reproducing the expected format
     - The unit_conversion function for Cube observations now uses the format from the previous update.
 
-LiMe medium update - 1.3.0 - 10/29/2024
+LiMe medium update - 1.3.0 - 12/10/2024
     - This update includes ASPECT as an optional dependency and has adapted several functions to include the possibility to use its predictions
     - Added the Spectrum.retrieve attribute to group tasks which return data for the user related to the spectrum
     - Added the Spectrum.retrieve.line_bands to return the line bands which match the observation redshift, wave interval and components detection.
@@ -86,7 +86,7 @@ LiMe medium update - 1.3.0 - 10/29/2024
     - The air_to_vacuum_function now only applies the theoretical relation, its inputs and outputs are wavelength arrays.
     - The new lime.Line.update_label function can be used to update the line label by reviewing the line properties.
 
-LiMe Mayor update - 2.0.1 - XX/XX/XXXX
+LiMe Mayor update - 2.0.1 - 10/20/2025
     - Change installer convention from "setup.py + requirements.txt" to pyproject.toml
     - Updated dependencies to current version of packages and for python 3.12
     - Renamed cfg.toml to lime.toml
@@ -114,5 +114,12 @@ LiMe Mayor update - 2.0.1 - XX/XX/XXXX
     - Change "output_address" argument name to "fname" across functions
     - Now the ``cont_source`` argument in the ``.fit`` functions gives the option to fit the line continuum using the ``central`` and ``adjacent`` bands in addition to the ``fit`` continuum.
 
-LiMe Mayor update - 2.0.2 - XX/XX/XXXX
-    - Updated the documentation to show the line continua fitting options.
+LiMe minor update - 2.0.4 - 12/05/2025
+    - Added function to rebinned spectrum given a wavelength range, a number of pixels, or a pixel width (no documenation entry yet): lime.Spectrum.retrieve.rebinned
+    - The lime.save_cfg function first two arguments have changed order (first file location and the file name)
+    - The default colors for the continuum fitting plots and peak dectection plots have changed
+    - Added suport for KCWI cubes
+    - Further development for the functions involving redshift a line fitting using aspect
+    - The spatial masking functions should not require the 'PARAM', 'PARAMIDX', 'PARAMVAL' and 'NUMSPAXE' in the .fits headers to plot the mask overlays
+
+

lime_stable-2.2.dev1/src/lime/fitting/redshift.py

@@ -0,0 +1,338 @@
+import logging
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.optimize import minimize, linear_sum_assignment
+
+from lime.io import LiMe_Error
+from lime.fitting.lines import compute_inst_sigma_array, gaussian_model
+from lime.plotting.plots import redshift_key_evaluation, redshift_permu_evaluation
+
+try:
+    import aspect
+    aspect_check = True
+except ImportError:
+    aspect_check = False
+
+_logger = logging.getLogger('LiMe')
+
+c_KMpS = 299792.458
+k_gFWHM = 2 * np.sqrt(2 * np.log(2))
+
+
+def comp_counter(arr_mask: np.ndarray) -> int:
+    return np.sum(~arr_mask[:-1] & arr_mask[1:]) + arr_mask[0]
+
+
+def compute_gaussian_ridges(redshift, lines_lambda, wave_matrix, amp_arr, band_vsigma, resol_arr, n_sigma=3):
+
+    # Compute the observed line wavelengths
+    obs_lambda = lines_lambda * (1 + redshift)
+    obs_lambda = obs_lambda[(obs_lambda > wave_matrix[0, 0]) & (obs_lambda < wave_matrix[0, -1])]
+
+    if obs_lambda.size > 1:
+
+        # Compute Gaussian centroids
+        idcs_obs = np.searchsorted(wave_matrix[0, :], obs_lambda)
+        mu_lines = wave_matrix[0, :][idcs_obs]
+
+        # Compute Gaussian sigmas
+        sigma_lines = mu_lines * (band_vsigma / c_KMpS) + mu_lines / (resol_arr[idcs_obs] * k_gFWHM)
+
+        # Compute the Gaussian bands
+        x_matrix = wave_matrix[:idcs_obs.size, :]
+        gauss_matrix = gaussian_model(x_matrix, amp_arr, mu_lines[:, None], sigma_lines[:, None])
+        gauss_arr = gauss_matrix.sum(axis=0)
+
+        # Set maximum to 1:
+        idcs_one = gauss_arr > 1
+        gauss_arr[idcs_one] = 1
+
+    else:
+        gauss_arr = None
+
+    return gauss_arr
+
+
+# def redshift_xor_method(spec, bands, z_min, z_max, z_nsteps, pred_arr, components_number, res_power, sigma_factor,
+#                         sig_digits=2, plot_results=False):
+#
+#     # Use the detection bands if provided
+#     if (pred_arr is not None) and (components_number is not None):
+#         idcs_lines = np.isin(pred_arr, components_number)
+#     else:
+#         idcs_lines = None
+#
+#     # Continue with measurement
+#     if idcs_lines is not None:
+#
+#         # Extract the data
+#         pixel_mask = spec.flux.mask
+#         wave_arr = spec.wave.data
+#         flux_arr = spec.flux.data
+#
+#         # Loop throught the redshift steps
+#         if not np.all(pixel_mask):
+#
+#             # Compute the resolution params
+#             sigma_arr = compute_inst_sigma_array(wave_arr, res_power)
+#             sigma_arr = sigma_arr if sigma_factor is None else sigma_arr * sigma_factor
+#
+#             # Lines selection
+#             theo_lambda = bands.wavelength.to_numpy()
+#
+#             # Parameters for the brute analysis
+#             z_arr = np.linspace(z_min, z_max, z_nsteps)
+#             wave_matrix = np.tile(wave_arr, (theo_lambda.size, 1))
+#             xor_sum = np.zeros(z_arr.size)
+#
+#             # Invert the mask
+#             data_mask = ~pixel_mask
+#
+#             # Revert the data
+#             for i, z_i in enumerate(z_arr):
+#                 gauss_arr = compute_gaussian_ridges(z_i, theo_lambda, wave_matrix, 1, sigma_arr)
+#                 xor_sum[i] = 0 if gauss_arr is None else np.sum(idcs_lines[data_mask] * gauss_arr[data_mask])
+#
+#             z_infer = np.round(z_arr[np.argmax(xor_sum)], decimals=sig_digits)
+#
+#         # No lines or all masked
+#         else:
+#             z_infer = None
+#
+#         if plot_results and (z_infer is not None):
+#             gauss_arr_max = compute_gaussian_ridges(z_infer, theo_lambda, wave_matrix, 1, sigma_arr)
+#             redshift_key_evaluation(spec, z_infer, data_mask, gauss_arr_max, z_arr, xor_sum)
+#
+#     # Do not attempt measurement
+#     else:
+#         z_infer = None
+#
+#     return z_infer
+
+
+def redshift_key_method(spec, bands, z_min, z_max, delta_z, pred_arr, components_number, band_vsigma,
+                        method, sig_digits=2, detection_only=True, plot_results=False):
+
+    # Use the detection bands if provided
+    if (pred_arr is not None) and (components_number is not None):
+        idcs_lines = np.isin(pred_arr, components_number)
+    else:
+        idcs_lines = None
+
+    # For flux method give the option for fitting redshift without detection
+    method_flux = True if method == 'key' else False
+    if method_flux and not detection_only:
+        idcs_lines = np.ones(idcs_lines.shape).astype(bool)
+    else:
+        if np.all(idcs_lines):
+            _logger.warning('All the spectrum pixels match the input redshift components criteria')
+
+    # Continue with measurement
+    z_infer = None
+    if idcs_lines is not None:
+
+        # If there is only one line return nan
+        if not (method_flux and not detection_only):
+            # match np.count_nonzero(np.diff(np.r_[False, idcs_lines])):
+            match comp_counter(idcs_lines):
+                case 0:
+                    return None # No components
+                case 1:
+                    return np.nan # No components
+
+        # Extract the data
+        wave_arr = spec.wave.data
+        flux_arr = spec.flux.data
+
+        # Compute the resolving power if necessary
+        if spec.res_power is not None:
+            res_power = spec.res_power
+        else:
+            delta_lambda = np.ediff1d(wave_arr, to_end=0)
+            delta_lambda[-1] = delta_lambda[-2]
+            res_power = wave_arr / delta_lambda
+
+        # Lines selection
+        theo_lambda = bands.wavelength.to_numpy()
+
+        # Compute the redshift range
+        if delta_z is None:
+            delta_arr = np.diff(wave_arr)
+            delta_z = np.median(delta_arr)/np.median(wave_arr)
+        z_arr = np.arange(z_min, z_max + 0.5 * delta_z, delta_z)
+
+        # Parameters for the brute analysis
+        wave_matrix = np.tile(wave_arr, (theo_lambda.size, 1))
+        flux_sum = np.zeros(z_arr.size)
+
+        # Combine line and pixel_mask
+        mask = ~spec.flux.mask & idcs_lines
+
+        # Loop through the redshift steps
+        for i, z_i in enumerate(z_arr):
+
+            # Generate the redshift key
+            gauss_arr = compute_gaussian_ridges(z_i, theo_lambda, wave_matrix, 1, band_vsigma, res_power)
+
+            # Null gauss case
+            if gauss_arr is None:
+                flux_sum[i] = 0
+
+            # Compute cumulative flux or pixel-number sum
+            else:
+                # Check more than one line
+                if comp_counter((gauss_arr * mask) > 0.001) >= 2:
+                    if method_flux:
+                        flux_sum[i] = np.sum(flux_arr[mask] * gauss_arr[mask])
+                    else:
+                        flux_sum[i] = np.sum(idcs_lines[mask] * gauss_arr[mask])
+
+        z_infer = np.round(z_arr[np.argmax(flux_sum)], decimals=sig_digits)
+
+    if plot_results and (z_infer is not None):
+        gauss_arr_max = compute_gaussian_ridges(z_infer, theo_lambda, wave_matrix, 1, band_vsigma, res_power)
+        redshift_key_evaluation(spec, method, z_infer, mask, gauss_arr_max, z_arr, flux_sum, theo_lambda)
+
+    return z_infer
+
+
+def permutation_objective_function(redshift, obs_arr, theo_arr):
+
+    adjusted_observed = obs_arr / (1 + redshift)
+    cost_matrix = np.abs(adjusted_observed[:, None] - theo_arr[None, :])
+
+    # Find the best matching subset using linear sum assignment
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+    residual = np.sum(cost_matrix[row_ind, col_ind])
+
+    return
+
+
+def permutation_residual(redshift, obs_arr, theo_arr):
+
+    return permutation_objective_function(redshift, obs_arr, theo_arr)
+
+
+def compute_residual(Z, observed, theoretical):
+    """
+    Computes the residual for a given redshift Z.
+
+    Parameters:
+    - Z: Redshift value.
+    - observed: Observed transitions (array-like).
+    - theoretical: Theoretical transitions (array-like).
+
+    Returns:
+    - Residual value (float).
+    """
+    adjusted_observed = observed / (1 + Z)
+    cost_matrix = np.abs(adjusted_observed[:, None] - theoretical[None, :])
+
+    # Find the best matching subset using linear sum assignment
+    row_ind, col_ind = linear_sum_assignment(cost_matrix)
+    residual = np.sum(cost_matrix[row_ind, col_ind])
+
+    return residual
+
+
+def redshift_permutation_method(spec, bands, z_min, z_max, pred_arr, components_number, plot_results):
+
+    # Use the detection array
+    if (pred_arr is not None) and (components_number is not None):
+        idcs_lines = np.isin(pred_arr, components_number)
+    else:
+        idcs_lines = None
+
+    # Decide if proceed
+    measure_check = True if np.any(idcs_lines) else False
+    if measure_check:
+
+        # Identify where changes occur (edges of ones and zeros)
+        edges = np.diff(np.concatenate(([0], idcs_lines, [0])))
+        start_indices = np.where(edges == 1)[0]
+        end_indices = np.where(edges == -1)[0] - 1
+
+        # Calculate observed wavelengths
+        central_indices = [(start + end) // 2 for start, end in zip(start_indices, end_indices)]
+        pixel_mask = spec.flux.mask
+        data_mask = ~pixel_mask
+        wave_arr = spec.wave.data if pixel_mask is not None else spec.wave
+        wave_obs = wave_arr[central_indices]
+
+        # Calculate theo wavelengths
+        wave_theo = bands.wavelength.to_numpy()
+
+        # Run the permutation
+        # result = minimize(permutation_residual, x0=5, bounds=[(z_min, z_max)])
+        result = minimize(lambda Z: compute_residual(Z, wave_obs, wave_theo), x0=0.01, bounds=[(z_min, z_max)],
+                          method='L-BFGS-B')
+        z_infer = result.x[0]
+
+        # Recompute cost matrix and find the best matching subset
+        adjusted_observed = wave_obs / (1 + z_infer)
+        cost_matrix = np.abs(adjusted_observed[:, None] - wave_theo[None, :])
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+        # Extract the best matching subset of theoretical transitions
+        best_matching_subset = wave_theo[col_ind]
+
+        if plot_results:
+            idcs_theo = (wave_theo * (1 + z_infer) >= wave_arr[0]) & (wave_theo * (1 + z_infer) <= wave_arr[-1])
+            redshift_permu_evaluation(spec, z_infer, wave_obs, wave_theo[idcs_theo] * (1 + z_infer))
+
+
+    else:
+        z_infer = None
+
+    return z_infer
+
+
+class RedshiftFitting:
+
+    def __init__(self):
+
+        return
+
+    def redshift(self, bands, z_min=0, z_max=12, delta_z=None,  mode='key', comps_list=['emission', 'doublet-em'],
+                 res_power=None, detection_only=True, band_vsigma=70, sig_digits=2, plot_results=False):
+
+        '''
+        bands, z_min, z_max, z_nsteps, idcs_lines, res_power, sigma_factor, sig_digits=2,
+                                detection_only=True, plot_results=False
+        '''
+
+        # Check that ASPECT is available
+        if not aspect_check:
+            _logger.info("ASPECT has not been installed the redshift measurements won't be constrained to lines")
+
+        # Get the features array
+        pred_arr, conf_arr = None, None
+        if aspect_check:
+            if self._spec.infer.pred_arr is None:
+                _logger.warning("The observation does not have a components detection array please run ASPECT")
+            else:
+                pred_arr, conf_arr = self._spec.infer.pred_arr, self._spec.infer.conf_arr
+
+        # Resolving power # TODO this should be read at another point...
+        res_power = self._spec.res_power if res_power is None else res_power
+
+        # Get the reference for the components
+        components_number = np.empty(len(comps_list)).astype(int)
+        for i, comp in enumerate(comps_list):
+            components_number[i] = aspect.cfg['shape_number'][comp]
+
+        # Set the type of fitting and the components to use
+        match mode:
+            case 'key' | 'xor':
+                z_infer = redshift_key_method(self._spec, bands, z_min, z_max, delta_z, pred_arr, components_number,
+                                              band_vsigma, mode, sig_digits=sig_digits,
+                                              detection_only=detection_only, plot_results=plot_results)
+            case 'permute':
+                z_infer = redshift_permutation_method(self._spec, bands, z_min, z_max, pred_arr, components_number,
+                                                      plot_results=plot_results)
+            case _:
+                raise KeyError(f'Input redshift fitting technique "{mode}" is not recognized, please use: '
+                                 f'"key" or "xor"')
+
+        return z_infer

{lime_stable-2.0.2 → lime_stable-2.2.dev1}/src/lime/io.py

@@ -122,19 +122,6 @@ def hdu_to_log_df(file_path, page_name):
         hdu_log = hdul[page_name].data
 
     df_log = pd.DataFrame.from_records(data=hdu_log, index='index')
-    #
-    # # Change 'nan' to np.nan
-    # if 'group_label' in df_log:
-    #     idcs_nan_str = df_log['group_label'] == 'nan'
-    #     df_log.loc[idcs_nan_str, 'group_label'] = np.nan
-
-    # log_df = Table.read(file_path, page_name, character_as_bytes=False).to_pandas()
-    # log_df.set_index('index', inplace=True)
-    #
-    # # Change 'nan' to np.nan
-    # if 'group_label' in log_df:
-    #     idcs_nan_str = log_df['group_label'] == 'nan'
-    #     log_df.loc[idcs_nan_str, 'group_label'] = np.nan
 
     return df_log
 
@@ -154,7 +141,6 @@ def parse_lime_cfg(toml_cfg, fit_cfg_suffix='_line_fitting'):
     return toml_cfg
 
 
-# Function to load configuration file
 def load_cfg(file_address, fit_cfg_suffix='_line_fitting'):
 
     """
@@ -219,8 +205,7 @@ def load_cfg(file_address, fit_cfg_suffix='_line_fitting'):
     return cfg_lime
 
 
-# Function to save SpecSyzer configuration file
-def save_cfg(param_dict, output_file, section_name=None, clear_section=False):
+def save_cfg(output_file, param_dict, section_name=None, clear_section=False):
 
     """
     This function safes the input dictionary into a configuration file. If no section is provided the input dictionary
@@ -231,11 +216,36 @@ def save_cfg(param_dict, output_file, section_name=None, clear_section=False):
     output_path = Path(output_file)
 
     if output_path.suffix == '.toml':
+
         # TODO review convert numpy arrays and floats64
         if toml_check:
-            toml_str = toml.dumps(param_dict)
-            with open(output_path, "w") as f:
-                f.write(toml_str)
+
+            # Section dict or the default dictionary
+            output_data = param_dict if section_name is None else {section_name: param_dict}
+
+            # If the file does not exist create a new file
+            if not output_path.is_file():
+                with open(output_file, "w") as f:
+                    toml.dump(output_data, f)
+
+            # Load the file and add the new section
+            else:
+                with open(output_path, 'r') as f:
+                    full_config = toml.load(f)
+
+                # Update the section data
+                full_config.update(output_data)
+                # if section_name is not None:
+                #     full_config.update(output_data)
+                #
+                # # Add the new data
+                # else:
+                #     full_config.update(output_data)
+
+                # Save the new data
+                with open(output_file, "w") as f:
+                    toml.dump(full_config, f)
+
         else:
             raise LiMe_Error(f'toml library is not installed. Toml files cannot be saved')
 
@@ -549,7 +559,7 @@ def save_frame(fname, dataframe, page='FRAME', parameters='all', header=None, co
 
                 lineLogHDU = log_to_HDU(lines_log, ext_name=page, column_dtypes=column_dtypes, header_dict=header)
 
-                if log_path.is_file(): # TODO this strategy is slow for many 2_guides
+                if log_path.is_file(): # TODO this strategy is slow for many configuration
                     try:
                         fits.update(log_path, data=lineLogHDU.data, header=lineLogHDU.header, extname=lineLogHDU.name, verify=True)
                     except KeyError:

{lime_stable-2.0.2 → lime_stable-2.2.dev1}/src/lime/lime.toml

@@ -1,6 +1,6 @@
 [metadata]
 name = 'lime-stable'
-version = "2.0.2"
+version = "2.2.dev1"
 
 # =====================
 # Spectrum / Long-slit