lime-stable 2.0.dev4__py3-none-any.whl → 2.0.dev7__py3-none-any.whl

lime/__init__.py

@@ -42,7 +42,7 @@ _logger.debug(f'Launching LiMe {__version__} in Python {__python_version__}')
 from lime.observations import Spectrum, Sample, Cube
 from lime.io import *
 from lime.tools import *
-from lime.transitions import Line, label_decomposition, bands_from_frame
+from lime.transitions import Line, label_decomposition, bands_from_measurements
 from lime.archives.read_fits import OpenFits, show_instrument_cfg
 from lime.plotting.plots import theme
 from lime.workflow import line_bands

lime/archives/read_fits.py

@@ -154,7 +154,7 @@ def check_fits_source(fits_source, lime_object=None, load_function=None):
     else:
 
         if load_function is None:
-            raise LiMe_Error(f'Please introduce fits file instrument or a load function to import the fits file as a '
+            _logger.warning(f'Please introduce fits file instrument or a load function to import the fits file as a '
                              f'LiMe observation')
 
     return fits_source, spectrum_type

lime/changelog.txt

@@ -109,4 +109,5 @@ LiMe Mayor update - 2.0.0 - XX/XX/XXXX
     - Rename term "_conf" to "_cfg" across function names and arguments for uniformity
     - Fitting functions now have the update_default=True argument. In the default behaviour the default configuration updates the default one. If set to update_default=False only the obj_cfg is used if available else the default one.
     - Creating a spectrum object where all the entries are masked now produces a critical warning instead of raising an error.
-    - By default line_bands
+    - By default line_bands.
+    - Added bands_from_log function

lime/fitting/lines.py

@@ -180,7 +180,6 @@ def pp_FWHM(line, idx):
 
 
 def gaussian_area(line, idx, n_steps):
-
     amp = np.random.normal(line.amp[idx], line.amp_err[idx], n_steps)
     sigma = np.random.normal(line.sigma[idx], line.sigma_err[idx], n_steps)
 
@@ -470,8 +469,6 @@ class ProfileModelCompiler:
         self.model.prefix = f'line0_'
 
         # Fix or not the continuum
-        # m_cont_conf = _SLOPE_FIX_PAR if line._cont_from_adjacent else _SLOPE_FREE_PAR
-        # n_cont_conf = _INTER_FIX_PAR if line._cont_from_adjacent else _INTER_FREE_PAR
         self.define_param(0, line, 'm_cont', line.m_cont, _SLOPE_FIX_PAR, user_conf)
         self.define_param(0, line, 'n_cont', line.n_cont, _INTER_FIX_PAR, user_conf)
 
@@ -616,8 +613,11 @@ class ProfileModelCompiler:
             # Check for negative -0.0 # TODO this needs a better place # FIXME -0.0 error
             if np.signbit(line.sigma_err[i]):
                 line.sigma_err[i] = np.nan
-                if self.output.errorbars:
-                    _logger.warning(f'Negative value for profile sigma at {line.label}')
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
+
+            if np.signbit(line.amp_err[i]):
+                line.amp_err[i] = np.nan
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
 
             # Compute the profile areas
             profile_flux_dist = AREA_FUNCTIONS[line._p_shape[i]](line, i, 1000)

lime/inference/intensity_threshold.py

@@ -52,8 +52,8 @@ class LineFinder:
 
         return
 
-    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5, band_modification=None,
-                       continuum_array=None, continuum_std=None, plot_steps=False, log_scale=False):
+    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5,
+                       continuum_array=None, continuum_std=None, plot_steps=False, **kwargs):
 
         """
 
@@ -82,9 +82,6 @@ class LineFinder:
         :param width_tol: Minimum number of pixels between peaks/troughs. The default value is 5.
         :type width_tol: float, optional
 
-        :param band_modification: Method to adjust the line band with. The default value is None.
-        :type band_modification: str, optional
-
         :param ml_detection: Machine learning algorithm to detect lines. The default value is None.
         :type ml_detection: str, optional
 
@@ -105,101 +102,36 @@ class LineFinder:
 
         # Match peaks with theoretical lines
         bands = check_file_dataframe(bands)
-        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, band_modification=band_modification,
-                                      line_type=emission_type)
+        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, line_type=emission_type)
 
         # Plot the results
         if plot_steps:
-            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, log_scale)
+            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, **kwargs)
 
         return matched_DF
 
 
-    def label_peaks(self, peak_table, mask_df, line_type='emission', width_tol=5, band_modification=None, detect_check=False):
-
-        # TODO auto param should be changed to boolean
-        # Establish the type of input values for the peak indexes, first numpy array
-        if isinstance(peak_table, np.ndarray):
-            idcsLinePeak = peak_table
-
-        # Specutils table
-        else:
-            # Query the lines from the astropy finder archives #
-            if len(peak_table) != 0:
-                idcsLineType = peak_table['emission_type'] == line_type
-                idcsLinePeak = np.array(peak_table[idcsLineType]['line_center_index'])
-            else:
-                idcsLinePeak = np.array([])
+    def label_peaks(self, idcs_peaks, matched_DF, line_type='emission', width_tol=5):
 
         # Security check in case no lines detected
-        if len(idcsLinePeak) == 0:
-            return pd.DataFrame(columns=mask_df.columns)
-
-        # Exclude bands not withing the regime:
-        w0, wf = self._spec.wave_rest.data[~self._spec.wave_rest.mask][0],  self._spec.wave_rest.data[~self._spec.wave_rest.mask][-1]
-        idcs_selection = (mask_df.w3 > w0) & (mask_df.w4 < wf)
-
-        # Prepare dataframe to stored the matched lines
-        matched_DF = mask_df.loc[idcs_selection].copy()
-        matched_DF['signal_peak'] = np.nan
-
-        # Theoretical wave values
-        waveTheory = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
-        matched_DF['wavelength'] = waveTheory
-
-        # Match the lines with the theoretical emission
-        tolerance = np.diff(self._spec.wave_rest).mean() * width_tol
-        matched_DF['observation'] = 'not_detected'
-        unidentifiedLine = dict.fromkeys(matched_DF.columns.values, np.nan)
-
-        # Get the wavelength peaks
-        wave_peaks = self._spec.wave_rest[idcsLinePeak]
-
-        for i in np.arange(wave_peaks.size):
-
-            idx_array = np.where(np.isclose(a=waveTheory.astype(np.float64), b=wave_peaks[i], atol=tolerance))
-
-            if len(idx_array[0]) == 0:
-                unknownLineLabel = 'xy_{:.0f}A'.format(np.round(wave_peaks[i]))
-
-                # Scheme to avoid repeated lines
-                if (unknownLineLabel not in matched_DF.index) and detect_check:
-                    newRow = unidentifiedLine.copy()
-                    newRow.update({'wavelength': wave_peaks[i], 'w3': wave_peaks[i] - 5, 'w4': wave_peaks[i] + 5,
-                                   'observation': 'not_identified'})
-                    matched_DF.loc[unknownLineLabel] = newRow
-
-            else:
-
-                row_index = matched_DF.index[matched_DF.wavelength == waveTheory[idx_array[0][0]]]
-                matched_DF.loc[row_index, 'observation'] = 'detected'
-                matched_DF.loc[row_index, 'signal_peak'] = idcsLinePeak[i]
-                theoLineLabel = row_index[0]
-
-                blended_check = True if '_b' in theoLineLabel else False
-                minSeparation = 4 if blended_check else 2
+        if len(idcs_peaks) == 0:
+            return pd.DataFrame(columns=matched_DF.columns)
 
-                # Width is only computed for blended lines
-                if band_modification is not None:
-                    if band_modification == 'auto':
-                        if blended_check is False:
-                            emission_check = True if line_type == 'emission' else False
-                            idx_min = compute_line_width(idcsLinePeak[i], self._spec.flux, delta_i=-1, min_delta=minSeparation, emission_check=emission_check)
-                            idx_max = compute_line_width(idcsLinePeak[i], self._spec.flux, delta_i=1, min_delta=minSeparation, emission_check=emission_check)
-                            matched_DF.loc[row_index, 'w3'] = self._spec.wave_rest[idx_min]
-                            matched_DF.loc[row_index, 'w4'] = self._spec.wave_rest[idx_max]
+        # Add theoretical wavelength values if necessary
+        if 'wavelength' not in matched_DF.columns:
+            matched_DF['wavelength'] = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
 
-        # Include_only_detected
-        idcs_unknown = matched_DF['observation'] == 'not_detected'
-        matched_DF.drop(index=matched_DF.loc[idcs_unknown].index.values, inplace=True)
+        # Get bands limits indexes
+        idcs_w3 = np.searchsorted(self._spec.wave_rest, matched_DF.w3)
+        idcs_w4 = np.searchsorted(self._spec.wave_rest, matched_DF.w4)
 
-        # Sort by wavelength
-        matched_DF.sort_values('wavelength', inplace=True)
-        matched_DF.drop(columns=['wavelength', 'observation'], inplace=True)
+        # Get the bands matching
+        band_contains_peak = (idcs_peaks[None, :] > idcs_w3[:, None]) & (idcs_peaks[None, :] < idcs_w4[:, None])
+        idcs_matched_bands = band_contains_peak.any(axis=1)
+        idcs_matched_peaks = idcs_peaks[band_contains_peak.argmax(axis=1)[idcs_matched_bands]]
 
-        # Security check all bands are within selection
-        wave_peak_matched = self._spec.wave_rest[matched_DF.signal_peak.to_numpy().astype(int)]
-        idcs_valid = (matched_DF.w3 < wave_peak_matched) & (matched_DF.w4 > wave_peak_matched)
-        matched_DF = matched_DF.loc[idcs_valid]
+        # Crop the bands to the detection
+        matched_DF.loc[idcs_matched_bands, 'observation'] = 'detected'
+        matched_DF.loc[idcs_matched_bands, 'signal_peak'] = idcs_matched_peaks
 
-        return matched_DF
+        return matched_DF.loc[idcs_matched_bands]

lime/lime.toml

@@ -1,3 +1,3 @@
 [metadata]
 name = 'lime-stable'
-version = "2.0.dev4"
+version = "2.0.dev7"

lime/plotting/bokeh_plots.py

@@ -102,14 +102,7 @@ def bokeh_bands(fig, bands, x, y, z_corr, redshift):
 
     # Loop through the detections and plot the names
     for i in np.arange(latex.size):
-        if idcs_band_limits[0, i] != idcs_band_limits[0, i]:  # Y limit for the label check if same pixel
-            max_region = np.max(y[idcs_band_limits[0, i]:idcs_band_limits[0, i]])
-        else:
-            max_region = y[idcs_band_limits[0, i]]
-
-        label = 'Matched line' if i == 0 else '_'
         fig.add_layout(BoxAnnotation(left=w3_obs[i]/z_corr, right=w4_obs[i]/z_corr, fill_alpha=0.3, fill_color=theme.colors['match_line']))
-        # axis.text(wave_array[i] * (1 + redshift) / z_corr, max_region * 0.9 * z_corr, latex[i], rotation=270)
 
     return
 
@@ -124,16 +117,25 @@ def bands_filling_bokeh(fig, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
         low_lim = 0 if np.isnan(low_lim) else low_lim
 
         # Central bands
+        print('1',x[idcs_mask[2]:idcs_mask[3]]/z_corr)
+        print('1',y[idcs_mask[2]:idcs_mask[3]]*z_corr)
+        print('1',low_lim*z_corr)
         fig.varea_step(x=x[idcs_mask[2]:idcs_mask[3]]/z_corr, y1=low_lim*z_corr, y2=y[idcs_mask[2]:idcs_mask[3]]*z_corr,
                         step_mode="center", fill_alpha=0.25, color=color_dict['line_band'])
 
         # Continua bands exclusion
         if exclude_continua is False:
+            print('2', x[idcs_mask[0]:idcs_mask[1]]/z_corr)
+            print('2', low_lim*z_corr)
+            print('2', y[idcs_mask[0]:idcs_mask[1]]*z_corr)
             fig.varea_step(x=x[idcs_mask[0]:idcs_mask[1]]/z_corr,
                            y1=low_lim*z_corr,
                            y2=y[idcs_mask[0]:idcs_mask[1]]*z_corr,
                            step_mode="center", fill_alpha=0.25, color=color_dict['cont_band'])
 
+            print('3', x[idcs_mask[4]:idcs_mask[5]]/z_corr)
+            print('3', low_lim*z_corr)
+            print('3', y[idcs_mask[4]:idcs_mask[5]]*z_corr)
             fig.varea_step(x=x[idcs_mask[4]:idcs_mask[5]]/z_corr,
                            y1=low_lim*z_corr,
                            y2=y[idcs_mask[4]:idcs_mask[5]]*z_corr,
@@ -193,8 +195,8 @@ class BokehFigures:
 
         return
 
-    def bands(self, label, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, log_scale=True, fig_cfg=None,
-              ax_cfg=None, return_fig=False):
+    def bands(self, label, output_address=None, bands=None, include_fits=True, rest_frame=False, log_scale=True,
+              exclude_continua=True, fig_cfg=None, ax_cfg=None, return_fig=False):
 
 
         # Unpack variables
@@ -205,7 +207,7 @@ class BokehFigures:
         legend_check = True if label is not None else False
 
         # Check which line should be plotted
-        line = parse_bands_arguments(label, log, ref_bands, norm_flux)
+        line = parse_bands_arguments(label, log, bands, norm_flux)
 
         # Proceed to plot
         if line is not None:
@@ -232,16 +234,13 @@ class BokehFigures:
             # Create figure with default utils if not provided
             fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"), y_axis_type=scale_str)
 
-            # # Create figure with default utils if not provided
-            # fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"))
-
             # Spectrum data source
             source = ColumnDataSource(data={"x": wave_plot[idcs_bands[0]:idcs_bands[5]] / z_corr,
                                             "y": flux_plot[idcs_bands[0]:idcs_bands[5]] * z_corr})
             fig.step("x", "y", source=source, color=theme.colors['fg'], line_width=1, mode='center')
 
             # Fille the bands
-            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line)
+            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line, exclude_continua=exclude_continua)
 
             # Plot labels
             fig.xaxis.axis_label = AXES_CONF['xlabel']
@@ -250,6 +249,9 @@ class BokehFigures:
             # Adjust the format of the plot
             update_bokeh_figure(fig, PLT_CONF)
 
+            # Hide the legend if there are line profiles
+            fig.legend.visible = legend_check
+
             # Save or display the plot
             if return_fig:
                 return fig
@@ -258,11 +260,14 @@ class BokehFigures:
                 save(fig, filename=output_address)
 
             else:
-                # output_notebook()
                 show(fig)
 
+        else:
+            _logger.info(f'The input line {label} could not be found')
+
         return
 
+
     def grid(self, output_address=None, rest_frame=True, log_scale=False, n_cols=6, n_rows=None, col_row_scale=(2, 1.5),
              include_fits=True, in_fig=None, fig_cfg=None, ax_cfg=None, maximize=False):
 
@@ -410,6 +415,9 @@ class BokehFigures:
         # Adjust the format of the plot
         update_bokeh_figure(fig, PLT_CONF)
 
+        # Hide the legend if there are line profiles
+        fig.legend.visible = legend_check
+
         # Save or display the plot
         if return_fig:
             return fig

lime/plotting/format.py

@@ -54,6 +54,7 @@ class Themer:
         self.conf = None        # All the formating data
         self.style = None       # Label of the active style
         self.active_conf = None   # Dictionary with the active figure configuration and library
+        self.default_lib = 'matplotlib'
 
         # LiMe plots personalization
         self.colors = None      # Features individual colors
@@ -67,6 +68,8 @@ class Themer:
         self.conf = conf.copy()
         self.set_style(style)
 
+
+
         return
 
 
@@ -163,7 +166,7 @@ class Themer:
         return ax_cfg
 
 
-    def set_style(self, style=None, scale=None, colors_conf=None, library=None):
+    def set_style(self, style=None, scale=None, colors_conf=None, library='matplotlib'):
 
         # Set the default style
         # self.style = ['default']
@@ -173,6 +176,7 @@ class Themer:
         #     self.style += [style] if isinstance(style, str) else style
         self.style = 'default' if style is None else style
         self.scale = ['default'] if style is None else [scale]
+        self.default_lib = library
 
         # Set the library defaults
         self.active_conf = {'matplotlib': self.conf['matplotlib']['default'].copy(),

lime/plotting/plots.py

@@ -159,7 +159,10 @@ def _auto_flux_scale(axis, y, y_scale, scale_dict=theme.plt):
             ratio = np.abs(y_max/y_min)
             if (ratio > 25) or (ratio < 0.06):
                 if neg_check:
-                    y_scale = {'value': 'symlog', 'linthresh': min(np.ceil(np.abs(y_min)), np.min(y[y>0]))}
+                    if np.sum(y>0) > 1:
+                        y_scale = {'value': 'symlog', 'linthresh': min(np.ceil(np.abs(y_min)), np.min(y[y>0]))}
+                    else:
+                        y_scale = {'value': 'symlog', 'linthresh': np.ceil(np.abs(y_min))}
                 else:
                     y_scale = {'value': 'log'}
             else:
@@ -657,7 +660,7 @@ def redshift_permu_evaluation(spectrum, z_infered, obs_wave_arr, theo_wave_arr,
 def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=False, color_dict=theme.colors, show_central=True):
 
     # Security check for low selection
-    if len(x[idcs_mask[2]:idcs_mask[3]]) > 1:
+    if y[idcs_mask[2]:idcs_mask[3]].size > 1:
 
         # Lower limit for the filled region
         if exclude_continua is False:
@@ -666,10 +669,10 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
             x_interval = x[idcs_mask[2]:idcs_mask[3]]
             y_interval = y[idcs_mask[2]:idcs_mask[3]]
         else:
-            m = (y[idcs_mask[3]] - y[idcs_mask[2]])/(x[idcs_mask[3]] - x[idcs_mask[2]])
-            n = y[idcs_mask[2]] - m * x[idcs_mask[2]]
             x_interval = x[idcs_mask[2]:idcs_mask[3]]
             y_interval = y[idcs_mask[2]:idcs_mask[3]]
+            m = (y_interval[-1] - y_interval[0])/(x_interval[-1] - x_interval[0])
+            n = y_interval[0] - m * x_interval[0]
             low_lim = m * x_interval + n
 
         # Central bands
@@ -690,7 +693,7 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
     return
 
 
-def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, log_scale=False):
+def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, **kwargs):
 
     norm_flux = spec.norm_flux
     wave = spec.wave
@@ -724,9 +727,6 @@ def plot_peaks_troughs(spec, peak_idcs, detect_limit, continuum, match_bands, lo
         ax.scatter(wave_plot[idcs_mask], flux_plot[idcs_mask], label='Masked pixels', marker='x',
                    color=theme.colors['mask_marker'])
 
-        if log_scale:
-            ax.set_yscale('log')
-
         ax.legend()
         ax.update(AXES_CONF)
         plt.tight_layout()
@@ -783,7 +783,6 @@ class Plotter:
 
         # Loop through the detections and plot the names
         for i, line_label in enumerate(match_log.index):
-            print(line_label)
             line = Line(line_label, match_log)
 
             # Get the max flux on the region making the exception for 1 pixel bands
@@ -792,7 +791,7 @@ class Plotter:
 
             x_text = line.wavelength * (1 + redshift)/z_corr if not line.blended_check else line.wavelength[0] * (1 + redshift)/z_corr
             y_text = max_region * 0.9 * z_corr
-            text = line.latex_label[0]
+            text = line.label
 
             axis.text(x_text, y_text, text, rotation=270)
             axis.axvspan(x[idx_w3]/z_corr, x[idx_w4]/z_corr, label='Matched line' if i == 0 else '_', alpha=0.30,
@@ -1009,84 +1008,79 @@ class SpectrumFigures(Plotter):
                 in_ax.fill_between(wave_plot/z_corr, low_limit*z_corr, high_limit*z_corr, alpha=0.2,
                                    color=theme.colors['fade_fg'])
 
-            # Include the detection bands
-            if detection_band is not None:
-
-                detec_obj = getattr(self._spec.infer, detection_band)
-
-                if detec_obj.confidence is not None:
-
-                    # Boundaries array for confidence intervals
-                    bounds = np.array([0.0, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-
-                    # Adjust color map to match lower detection limit to fg color
-                    cmap = plt.get_cmap(theme.colors['mask_map'])
-                    cmaplist = [cmap(i) for i in range(cmap.N)]
-                    cmaplist[0] = theme.colors['fg']
-                    cmap = colors.LinearSegmentedColormap.from_list('mcm', cmaplist, bounds.size-1)
-                    norm = colors.BoundaryNorm(bounds * 100, cmap.N)
-
-                    # Iterate through the confidence intervals and plot the step spectrum
-                    for i in range(1, len(bounds)):
-                        if i > 1:
-                            idcs = detec_obj(bounds[i-1]*100, confidence_max=bounds[i]*100)
-                            wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
-                            wave_nan[idcs], flux_nan[idcs] = wave_plot[idcs] / z_corr, flux_plot[idcs] * z_corr
-
-                            in_ax.step(wave_nan, flux_nan, label=label, where='mid', color=cmap(i-1))
-
-                    # Color bar
-                    sm = cm.ScalarMappable(cmap=cmap, norm=norm)
-                    sm.set_array([])
-                    cbar = plt.colorbar(sm, ax=in_ax)
-                    cbar.set_label('Detection confidence %', rotation=270, labelpad=35)
-
-
-                else:
-                    _logger.warning(f'The line detection bands confidence has not been calculated. They are not included'
-                                    f' on plot.')
-
-            if show_categories:
-                # Define the bins you want
-                bins = [40, 60, 80, 100]
+            # # Include the detection bands
+            # if detection_band is not None:
+            #
+            #     detec_obj = getattr(self._spec.infer, detection_band)
+            #
+            #     if detec_obj.confidence is not None:
+            #
+            #         # Boundaries array for confidence intervals
+            #         bounds = np.array([0.0, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+            #
+            #         # Adjust color map to match lower detection limit to fg color
+            #         cmap = plt.get_cmap(theme.colors['mask_map'])
+            #         cmaplist = [cmap(i) for i in range(cmap.N)]
+            #         cmaplist[0] = theme.colors['fg']
+            #         cmap = colors.LinearSegmentedColormap.from_list('mcm', cmaplist, bounds.size-1)
+            #         norm = colors.BoundaryNorm(bounds * 100, cmap.N)
+            #
+            #         # Iterate through the confidence intervals and plot the step spectrum
+            #         for i in range(1, len(bounds)):
+            #             if i > 1:
+            #                 idcs = detec_obj(bounds[i-1]*100, confidence_max=bounds[i]*100)
+            #                 wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
+            #                 wave_nan[idcs], flux_nan[idcs] = wave_plot[idcs] / z_corr, flux_plot[idcs] * z_corr
+            #
+            #                 in_ax.step(wave_nan, flux_nan, label=label, where='mid', color=cmap(i-1))
+            #
+            #         # Color bar
+            #         sm = cm.ScalarMappable(cmap=cmap, norm=norm)
+            #         sm.set_array([])
+            #         cbar = plt.colorbar(sm, ax=in_ax)
+            #         cbar.set_label('Detection confidence %', rotation=270, labelpad=35)
+            #
+            #
+            #     else:
+            #         _logger.warning(f'The line detection bands confidence has not been calculated. They are not included'
+            #                         f' on plot.')
+
+            # Show components
+            if show_categories and self._spec.infer.pred_arr is not None:
 
                 # Use np.histogram to get the counts in each bin
-                if self._spec.infer.pred_arr is not None:
-                    if aspect_check:
-                        categories = np.sort(np.unique(self._spec.infer.pred_arr))
-                        legend_scatter = []
-
-                        for category in categories:
-                            if category != 0:
-
-                                # Get category properties
-                                feature_name = self._spec.infer.model_mgr.medium.number_feature_dict[category]
-                                feature_color = aspect.cfg['colors'][feature_name]
-                                idcs_feature = self._spec.infer.pred_arr == category
-                                legend_scatter.append(mlines.Line2D([], [], marker='o', color='w',
-                                                                    markerfacecolor=feature_color, markersize=8, label=feature_name))
-
-                                # Count the pixels for each category
-                                counts, _ = np.histogram(self._spec.infer.conf_arr[idcs_feature], bins=bins)
-                                for idx_conf, count_conf in enumerate(counts):
-                                    if count_conf > 0:
-
-                                        # Get indeces matching the detections
-                                        idcs_count = np.where((bins[idx_conf] < self._spec.infer.conf_arr[idcs_feature]) &
-                                                              (self._spec.infer.conf_arr[idcs_feature] <= bins[idx_conf + 1]))[0]
-                                        idcs_nonnan = np.where(idcs_feature)[0][idcs_count]  # Returns indices where mask is True
-
-                                        # Generate nan arrays with the data to avoid filling non detections
-                                        wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
-                                        wave_nan[idcs_nonnan] = wave_plot[idcs_nonnan] / z_corr
-                                        flux_nan[idcs_nonnan] = flux_plot[idcs_nonnan] * z_corr
-
-                                        # Plot with the corresponding colors and linestyle
-                                        in_ax.step(wave_nan, flux_nan, label=feature_name, where='mid', color=feature_color,
-                                                   linestyle=category_conf_styles[idx_conf])
-
-                    else:
-                        _logger.warning('Aspect needs to be installed to display the spectrum components')
+                categories = np.sort(np.unique(self._spec.infer.pred_arr))
+                legend_scatter = []
+
+                for category in categories:
+                    if category != 0:
+
+                        # Get category properties
+                        feature_name = self._spec.infer.model_mgr.medium.number_feature_dict[category]
+                        feature_color = aspect.cfg['colors'][feature_name]
+                        idcs_feature = self._spec.infer.pred_arr == category
+                        legend_scatter.append(mlines.Line2D([], [], marker='o', color='w',
+                                                            markerfacecolor=feature_color, markersize=8, label=feature_name))
+
+                        # Count the pixels for each category
+                        bins = [40, 60, 80, 100]
+                        counts, _ = np.histogram(self._spec.infer.conf_arr[idcs_feature], bins=bins)
+                        for idx_conf, count_conf in enumerate(counts):
+                            if count_conf > 0:
+
+                                # Get indeces matching the detections
+                                idcs_count = np.where((bins[idx_conf] < self._spec.infer.conf_arr[idcs_feature]) &
+                                                      (self._spec.infer.conf_arr[idcs_feature] <= bins[idx_conf + 1]))[0]
+                                idcs_nonnan = np.where(idcs_feature)[0][idcs_count]  # Returns indices where mask is True
+
+                                # Generate nan arrays with the data to avoid filling non detections
+                                wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
+                                wave_nan[idcs_nonnan] = wave_plot[idcs_nonnan] / z_corr
+                                flux_nan[idcs_nonnan] = flux_plot[idcs_nonnan] * z_corr
+
+                                # Plot with the corresponding colors and linestyle
+                                in_ax.step(wave_nan, flux_nan, label=feature_name, where='mid', color=feature_color,
+                                           linestyle=category_conf_styles[idx_conf])
 
                     # Legend category
                     legend_category = in_ax.legend(handles=legend_scatter, edgecolor=theme.colors['fg'])
@@ -1275,8 +1269,8 @@ class SpectrumFigures(Plotter):
 
         return in_fig
 
-    def bands(self, label=None, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, y_scale='auto', fig_cfg=None,
-              ax_cfg=None, in_fig=None, maximize=False, show_err=True):
+    def bands(self, label=None, bands=None, output_address=None, include_fits=True, rest_frame=False, y_scale='auto', fig_cfg=None,
+              ax_cfg=None, in_fig=None, maximize=False, show_err=False, exclude_continua=False):
 
         """
 
@@ -1333,7 +1327,7 @@ class SpectrumFigures(Plotter):
         display_check = True if in_fig is None else False
 
         # Check which line should be plotted
-        line = parse_bands_arguments(label, log, ref_bands, norm_flux)
+        line = parse_bands_arguments(label, bands, log, norm_flux)
 
         # Check the observation has uncertainty to display
         if show_err and (self._spec.err_flux is None):
@@ -1378,13 +1372,13 @@ class SpectrumFigures(Plotter):
                 idcs_bands = line.index_bands(self._spec.wave, self._spec.redshift, just_band_edges=True)
 
                 # Plot the spectrum
-                label_leg = line.latex_label if (line.latex_label is not None and include_fits is False) else None
+                label_leg = line.latex_label[0] if (line.latex_label[0] is not None and include_fits is False) else None
                 in_ax[0].step(wave_plot[idcs_bands[0]:idcs_bands[5]] / z_corr, flux_plot[idcs_bands[0]:idcs_bands[5]] * z_corr,
                               where='mid', color=theme.colors['fg'], label=label_leg, linewidth=theme.plt['spectrum_width'])
 
                 # Continuum bands
                 bands_filling_plot(in_ax[0], wave_plot, flux_plot, z_corr, idcs_bands, line, color_dict=theme.colors,
-                                   show_central=not show_err)
+                                   show_central=not show_err, exclude_continua=exclude_continua)
 
                 if show_err:
                     err_plot = self._spec.err_flux.data

lime/plotting/utils.py

@@ -7,21 +7,21 @@ from lime.io import _PARENT_BANDS
 _logger = logging.getLogger('LiMe')
 
 
-def parse_bands_arguments(label, log, ref_bands, norm_flux):
+def parse_bands_arguments(label, bands, log, norm_flux):
 
     line = None
     if label is None and (log.index.size > 0):
         label = log.index[-1]
         line = Line.from_log(label, log, norm_flux)
 
+    # The user provided a reference band to check the region use it
+    elif label is not None and bands is not None:
+        line = Line(label, bands)
+
     # Line has been measured before
     elif label is not None and (log.index.size > 0):
         line = Line.from_log(label, log, norm_flux)
 
-    # The user provided a reference band to check the region use it
-    elif label is not None and ref_bands is not None:
-        line = Line(label, ref_bands)
-
     elif label is not None and label in _PARENT_BANDS.index:
         line = Line(label, band=_PARENT_BANDS.loc[label, 'w1':'w6'].to_numpy())
 

lime/tools.py

@@ -54,7 +54,7 @@ def int_to_roman(num):
     return roman_num
 
 
-def pd_get(df, row, column, default=None, transform=None):
+def pd_get(df, row, column, default=None, transform=None, nan_to_none=False):
 
     # Fast get from dataframe
     try:
@@ -66,6 +66,12 @@ def pd_get(df, row, column, default=None, transform=None):
     if transform is not None:
         cell = default if cell == transform else cell
 
+    # Transform nan to None
+    if nan_to_none and (cell is not None):
+        if isinstance(cell, float):
+            # print('JODER', cell)
+            cell = None if np.isnan(cell) else cell
+
     return cell
 
 

lime/transitions.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from numpy.core.fromnumeric import argmin
 
-from .io import _PARENT_BANDS, _LOG_EXPORT, _LOG_COLUMNS, check_file_dataframe, LiMe_Error
+from .io import _PARENT_BANDS, _LOG_EXPORT, _LOG_COLUMNS, check_file_dataframe, LiMe_Error, load_frame
 from pandas import DataFrame
 from .tools import pd_get, au
 
@@ -185,46 +185,53 @@ def air_to_vacuum_function(wave_array, units_wave='AA'):
     return wave_array / (1 + 1e-6 * (287.6155 + 1.62887 * sigma2 + 0.01360 * np.square(sigma2)))
 
 
-def check_units_from_wave(line, str_ion, str_wave, lines_df):
+def check_units_from_wave(line, str_ion, str_wave, bands, ref_bands=None):
 
-    # Try to recover from dataframe
-    if lines_df is not None:
+    # First the input database
+    if bands is not None:
 
         # Check literal unit
-        wave = pd_get(lines_df, line, 'wavelength')
-        units = pd_get(lines_df, line, 'units_wave')
+        wave = pd_get(bands, line, 'wavelength', nan_to_none=True)
+        units = pd_get(bands, line, 'units_wave', nan_to_none=True)
 
         # Check core element
         if wave is None:
             core_element = f'{str_ion}_{str_wave}'
-            wave = pd_get(lines_df, core_element, 'wavelength')
-            units = pd_get(lines_df, core_element, 'units_wave')
+            wave = pd_get(bands, core_element, 'wavelength', nan_to_none=True)
+            units = pd_get(bands, core_element, 'units_wave', nan_to_none=True)
 
         # Convert to units
         units = au.Unit(units) if units is not None else units
+        # units = None if (units is None or np.isnan(units)) else au.Unit(units)
 
     else:
         wave, units = None, None
 
-    # Otherwise decipher from label
+    # Second the reference database
+    if (units is None) or (wave is None):
+        ref_bands = ref_bands if ref_bands is not None else _PARENT_BANDS
+        wave = pd_get(ref_bands, line, 'wavelength', nan_to_none=True)
+        units = pd_get(ref_bands, line, 'units_wave', nan_to_none=True)
+
+        # Convert to units
+        units = au.Unit(units) if units is not None else units
+
+    # Third decipher from label
     if (units is None) or (wave is None):
 
         # First check for Angstroms
         if str_wave[-1] == 'A':
-            units_label = au.Unit('AA')
-            wave_label = float(str_wave[:-1])
+            units = au.Unit('AA')
+            wave = float(str_wave[:-1])
 
         else:
             au_unit = au.Unit(str_wave)
-            units_label = au_unit.bases[0]
-            wave_label = au_unit.scale
-
-    else:
-        units_label, wave_label = None, None
+            units = au_unit.bases[0]
+            wave = au_unit.scale
 
-    # Give preferences to the tabel values
-    wave = wave_label if wave is None else wave
-    units = units_label if units is None else units
+    # # Give preferences to the tabel values
+    # wave = wave_label if wave is None else wave
+    # units = units_label if units is None else units
 
     return wave, units
 
@@ -400,7 +407,7 @@ def latex_from_label(label, particle=None, wave=None, units_wave=None, kinem=Non
     #
 
 
-def label_composition(line_list, ref_df=None, default_profile=None):
+def label_composition(line_list, bands=None, default_profile=None, ref_bands=None):
 
     # Empty containers for the label componentes
     n_comps = len(line_list)
@@ -429,7 +436,7 @@ def label_composition(line_list, ref_df=None, default_profile=None):
         particle[i] = Particle.from_label(line_items[0])
 
         # Wavelength properties
-        wavelength[i], units_wave[i] = check_units_from_wave(line, line_items[0], line_items[1], ref_df)
+        wavelength[i], units_wave[i] = check_units_from_wave(line, line_items[0], line_items[1], bands, ref_bands)
 
         # Split the optional components: "H1_1216A_t-rec_k-0_p-g" -> {'t': 'rec', 'k': '0', 'p': 'g'} # TODO better do that with optional_comps
         comp_conf = {optC[0]: optC[2:] for optC in line_items[2:]}
@@ -452,8 +459,8 @@ def label_composition(line_list, ref_df=None, default_profile=None):
         trans = comp_conf.get('t', None)
 
         # If none is provided check from the table
-        if (trans is None) and (ref_df is not None):
-            trans = pd_get(ref_df, line, 'transition')
+        if (trans is None) and (bands is not None):
+            trans = pd_get(bands, line, 'transition')
 
         # Else assume default
         if trans is None:
@@ -607,27 +614,48 @@ def format_line_mask_option(entry_value, wave_array):
     return formatted_value
 
 
-def bands_from_frame(frame, lines_level='line', sort=True):
+def bands_from_measurements(frame, sample_levels=['id', 'line'], sort=True, remove_empty_columns=False, index_dict=None,
+                            bands_hdrs=('wavelength', 'w1', 'w2', 'w3', 'w4', 'w5', 'w6', 'group_label', 'units_wave', 'particle',
+                                 'transition')):
 
-    # Empty container to store the data
-    headers = ['wavelength', 'w1', 'w2', 'w3', 'w4', 'w5', 'w6', 'group_label', 'latex_label', 'units_wave', 'particle', 'transition']
-    bands = pd.DataFrame(columns=headers)
+    # Load the frame if necessary
+    frame = check_file_dataframe(frame, sample_levels=sample_levels)
 
     # Single frame
     if not isinstance(frame.index, pd.MultiIndex):
-        print('bicho')
+
+        # Make dataframe with single lines
+        idcs_single = frame.group_label == 'none'
+        bands = frame.reindex(index=frame.loc[idcs_single].index, columns=bands_hdrs)
+
+        # Get the indexes of grouped lines
+        group_labels_arr = frame.loc[~idcs_single].group_label
+        unique_values, unique_indices = np.unique(group_labels_arr, return_index=True)
+        group_labels_arr = group_labels_arr.iloc[np.sort(unique_indices)]
+
+        # Make dataframe with grouped lines and add blended suffix
+        bands_group = frame.reindex(index=group_labels_arr.index, columns=bands_hdrs)
+        blended_arr = bands_group.loc[~bands_group.index.to_series().str.endswith('_m')].index.to_numpy()
+        bands_group.rename(index={key: f"{key}_b" for key in blended_arr}, inplace=True)
+
+        # Combine the dataframes
+        bands = pd.concat([bands, bands_group], axis=0)
 
     # Multi-index
     else:
 
-        line_list = frame.index.get_level_values(lines_level).unique()
+        line_list = frame.index.get_level_values(sample_levels).unique()
+
+        idcs_single = frame.group_label == 'none'
+        bands = frame.reindex(index=frame.loc[idcs_single].index, columns=bands_hdrs)
+
 
         # Loop through the lines
         for i, line_label in enumerate(line_list):
 
             # Exclude kinematic components:
             if '_k-' not in line_label:
-                df_line = frame.xs(line_label, level=lines_level, drop_level=False)
+                df_line = frame.xs(line_label, level=sample_levels, drop_level=False)
                 group_list = df_line.group_label.unique()
 
                 for j, group in enumerate(group_list):
@@ -673,12 +701,16 @@ def bands_from_frame(frame, lines_level='line', sort=True):
                     bands.loc[line.label, 'latex_label'] = line.latex_label
                     bands.loc[line.label, 'units_wave'] = line.units_wave[line._ref_idx]
                     bands.loc[line.label, 'particle'] = line.particle[line._ref_idx]
-                # bands.loc[line.label, 'transition'] = line.transition
-
 
     if sort:
         bands.sort_values(by=['wavelength', 'group_label'], inplace=True)
 
+    if remove_empty_columns:
+        bands = bands.dropna(axis=1, how='all')
+
+    if index_dict is not None:
+        bands.rename(index=index_dict, inplace=True)
+
     return bands
 
 
@@ -734,7 +766,7 @@ class Particle:
 class Line:
 
     def __init__(self, label, band=None, fit_conf=None, profile=None, cont_from_bands=True, z_line=None,
-                 update_latex=False, interpret=True):
+                 update_latex=False, ref_bands=None, interpret=True):
 
         # Label attributes
         self.label = label
@@ -796,7 +828,7 @@ class Line:
 
         # Interpret the line from the user reference
         if interpret:
-            self._from_label(label, band, fit_conf, update_latex)
+            self._from_label(label, band, fit_conf, update_latex, ref_bands)
 
         return
 
@@ -808,7 +840,7 @@ class Line:
 
         return self.label
 
-    def _from_label(self, label, band=None, fit_conf=None, update_latex=False):
+    def _from_label(self, label, band=None, fit_conf=None, update_latex=False, ref_bands=None):
 
         # If band is not provided use default database
         if band is None:
@@ -830,8 +862,8 @@ class Line:
         self._modularity_component(modularity_comp, fit_conf, band)
 
         # Review the components of the line
-        ref_bands_df = band if isinstance(band, DataFrame) else None
-        items = label_composition(self.list_comps, ref_df=ref_bands_df, default_profile=self.profile_comp)
+        items = label_composition(self.list_comps, bands=band if isinstance(band, DataFrame) else None,
+                                  default_profile=self.profile_comp)
         self.particle, self.wavelength, self.units_wave, self.kinem, self.profile_comp, self.transition_comp = items
 
         # Quick elements for the line profile

lime/workflow.py

@@ -13,7 +13,9 @@ from lime.transitions import Line, air_to_vacuum_function, label_decomposition
 from lime.io import check_file_dataframe, check_file_array_mask, log_to_HDU, results_to_log, load_frame, LiMe_Error, check_fit_conf, _PARENT_BANDS
 from lime.fitting.redshift import RedshiftFitting
 from lime import __version__
-from itertools import combinations
+from scipy.sparse import csr_matrix, csgraph
+
+
 
 try:
     import aspect
@@ -526,7 +528,7 @@ def get_merged_blended_lines(spec, bands, in_cfg, composite_lines):
     #
     # return output_dict
 
-def pars_bands_conf(spec, bands, ref_bands, fit_conf, composite_lines):
+def pars_bands_conf(spec, bands, ref_bands, fit_conf, composite_lines, automatic_grouping=False):
 
     # Get the the grouped lines
     comps_dict = {} if fit_conf is False else {comp: group_label
@@ -537,6 +539,31 @@ def pars_bands_conf(spec, bands, ref_bands, fit_conf, composite_lines):
     if composite_lines is not None:
         comps_dict = {line: comps for line, comps in comps_dict.items() if line in composite_lines}
 
+    if automatic_grouping:
+
+        # Get candidate lines for grouping
+        line_arr = [item for v in comps_dict.values() for item in v.split('+')]
+        line_arr = bands.loc[bands.index.isin(line_arr)].index
+        lambda_arr = bands.loc[line_arr, 'wavelength'].to_numpy()
+
+        # Generate the line - wavelength matrix with the line pixels width
+        wave_matrix = np.zeros((lambda_arr.size, spec.wave_rest.data.size))
+        w3_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w3'].to_numpy())
+        w4_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w4'].to_numpy())
+        cols = np.arange(wave_matrix.shape[1])
+        wave_matrix[(cols >= w3_arr[:, None]) & (cols <= w4_arr[:, None])] = 1
+        pixels_width = wave_matrix.sum(axis=1)
+
+        # Get the decision matrix with the matching intervals
+        decision_matrix = wave_matrix @ wave_matrix.T
+        blended_matrix = decision_matrix < np.ceil(pixels_width/3)[:, None]
+        math_dict = dict(zip(line_arr, np.arange(line_arr.size)))
+
+        # Get groups of common entries
+        _, auto_labels = csgraph.connected_components(csgraph=csr_matrix(decision_matrix > 1), directed=False)
+        for labels, group in zip(line_arr, auto_labels):
+            print(f"{labels}   {group}")
+
     # Loop through the lines on the list and review which changes are necessary
     rename_dict, exclude_list= {}, []
     group_dict, w3_dict, w4_dict = {}, {}, {}
@@ -811,7 +838,8 @@ class SpecTreatment(LineFitting, RedshiftFitting):
         self._n_lines = 0
 
     def bands(self, label, bands=None, fit_cfg=None, min_method='least_squares', profile='g-emi', cont_from_bands=True,
-              err_from_bands=None, temp=10000.0, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True):
+              err_from_bands=None, temp=10000.0, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True,
+              ref_bands=None):
 
         """
 
@@ -883,7 +911,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
         cont_from_bands = True if cont_from_bands is None else cont_from_bands
 
         # Interpret the input line
-        self.line = Line(label, bands, input_conf, profile, cont_from_bands)
+        self.line = Line(label, bands, input_conf, profile, cont_from_bands, ref_bands=ref_bands)
 
         # Check the line selection is valid
         idcs_selection = review_bands(self._spec, self.line, user_cont_from_bands=cont_from_bands, user_err_from_bands=err_from_bands)
@@ -925,7 +953,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
 
     def frame(self, bands, fit_cfg=None, min_method='least_squares', profile='g-emi', cont_from_bands=None, err_from_bands=None,
               temp=10000.0, line_list=None, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True, line_detection=False,
-              plot_fit=False, progress_output='bar'):
+              plot_fit=False, progress_output='bar', ref_bands=None):
 
         """
 
@@ -1053,8 +1081,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
                         # Fit the lines
                         self.bands(line, bands, input_conf, min_method, profile,
                                    cont_from_bands=cont_from_bands, err_from_bands=err_from_bands,
-                                   temp=temp,
-                                   obj_cfg_prefix=None, default_cfg_prefix=None)
+                                   temp=temp, obj_cfg_prefix=None, default_cfg_prefix=None, ref_bands=ref_bands)
 
                         if plot_fit:
                             self._spec.plot.bands()
@@ -1069,7 +1096,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
         return
 
     def continuum(self, degree_list, emis_threshold, abs_threshold=None, smooth_length=None, plot_steps=False,
-                  log_scale=False):
+                  **kwargs):
 
         """
 
@@ -1134,7 +1161,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
             if plot_steps:
                 ax_cfg = {'title':f'Continuum fitting, iteration ({i+1}/{len(degree_list)})'}
                 self._spec.plot._continuum_iteration(input_wave, input_flux, cont_fit, input_flux_s, mask_cont, low_lim,
-                                                     high_lim, emis_threshold[i], ax_cfg, log_scale=log_scale)
+                                                     high_lim, emis_threshold[i], ax_cfg, **kwargs)
 
         # Include the standard deviation of the spectrum for the unmasked pixels
         self._spec.cont = np.ma.masked_array(cont_fit, self._spec.flux.mask)

{lime_stable-2.0.dev4.dist-info → lime_stable-2.0.dev7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev4
+Version: 2.0.dev7
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later
@@ -19,7 +19,7 @@ Requires-Dist: aspect-stable~=0.3.1
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: bokeh~=3.6; extra == "full"
+Requires-Dist: bokeh~=3.7; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"
 Requires-Dist: PyLaTeX~=1.4; extra == "full"

{lime_stable-2.0.dev4.dist-info → lime_stable-2.0.dev7.dist-info}/RECORD

@@ -1,26 +1,26 @@
-lime/__init__.py,sha256=XSdB2p1Pa7xRN2kUGBkjQ1DLBlf8PEdpRP6e7fmnA-I,1272
-lime/changelog.txt,sha256=odmxX7BukbjvY3HLcWe3_kwvY3Lgf8fgG7xdy43B_Bk,9620
+lime/__init__.py,sha256=i7iYJDoAYCsApb35OG33Y0repT6FpgLCsFMTk0Nu0rM,1279
+lime/changelog.txt,sha256=e02y8w_romtBvZLt7wrDxfL0Kry5ccTUkaajX_XwHbs,9657
 lime/io.py,sha256=9bH51m6DAYXJBLDXVQLmaOB0xw6_XoJiMoZlXDQ7Up4,32708
-lime/lime.toml,sha256=27Au6pwBvRINCnatm4AzhCoYZOSwCf5cUouHKe0c6hw,52
+lime/lime.toml,sha256=YZ4ISkDoWKzFX_o2XTfOzUGpZQvFYzH0ee1dkLaEcV4,52
 lime/observations.py,sha256=2XV1V7FsQYwi1plcGPHATNeLn-XccUhcKtzjds3D3YU,64552
-lime/tools.py,sha256=WbCHcRipTDmYtVGShziL060tmq3PhXCHUzKrKf1xwQA,33922
-lime/transitions.py,sha256=5fZt3ogpfhRU-I1kS0LSlnKb3SsJdhF1IX7kkA0kWLA,43881
-lime/workflow.py,sha256=nLbPkPKUFQQVCADOO62V4NtNq2lbJgSOaeGtE9Jioqc,64046
+lime/tools.py,sha256=5E7_YeXeLrzFo-2h5EAI8J-cPaK4i6g6OJ1uL2jXJ7o,34136
+lime/transitions.py,sha256=-TgVCqL9R0-i4o8jHQGkGllHrMyP-Bo9DqoWfVNxHe4,45634
+lime/workflow.py,sha256=x3es6Sgq9wI785WdTsIuOWnWvKdSYdnJHN_MSkIhcxM,65417
 lime/archives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/archives/read_fits.py,sha256=rYySOtmDTGaebwJUBrgwN0O_8qj6LBuUIiPlVBgUOg4,37945
+lime/archives/read_fits.py,sha256=TIJtP8iGokjE9Nj1ALYb7MHE2lUxZGHuz6cx5SZBb5U,37944
 lime/archives/tables.py,sha256=sn3dINNorARuhEA_NsUKnhz8pT5d9u_sNBNKgv3EtuA,14242
 lime/fitting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/fitting/lines.py,sha256=Rh3UkMWe6V9UI2zyffEClx-hpcdo-nRjAGX6qlC5shU,41336
+lime/fitting/lines.py,sha256=X1QI9ZqpLfxvfVsOMWMDmwLxXhR_gNvIYBdFA7A2GD8,41288
 lime/fitting/redshift.py,sha256=JBYQlESr63PrF3gRYVT-QLQr2yMi9YZKaeNxI8gFvgY,11639
 lime/inference/detection.py,sha256=m_Yz-53RGEvQQa6rgS_-nU2DwiRG45yuZIuneAvs0Dc,425
-lime/inference/intensity_threshold.py,sha256=2VW-uEQb6dLvxpNdC_l6myvjfX3YpczTAoLms6ws23k,8532
+lime/inference/intensity_threshold.py,sha256=9LqSjJQajfrM4SOHSqJWnverKFnrdrjnV472w56T79U,5047
 lime/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/plotting/bokeh_plots.py,sha256=lprs6omdNkeu60iIT-mLlGA6Nn9NomL8qosSbfplsPc,23257
-lime/plotting/format.py,sha256=bawpN8G_zHS8ujRapdaBvaYzjBgESssysL70MV8s_9M,7211
-lime/plotting/plots.py,sha256=J75hgxXimJPOMef79dbEbSUEsNoDO14-1BEbH-Zb2QM,87610
+lime/plotting/bokeh_plots.py,sha256=xJlFS90NW-kQLSBDrfYd3tkjixyHK0DUs1vm5ExmjOQ,23444
+lime/plotting/format.py,sha256=KM2UjhfJ7j2iEOIRTn8JfpLNmSRSlUFTHqB5EKxTq80,7296
+lime/plotting/plots.py,sha256=LruFJvee0NcZ8wkMeb_-bMqonwLsgB6cF92aPqZRAOk,87496
 lime/plotting/plots_interactive.py,sha256=wX_ckpv_lM6YgZZFEfx36dfGt1DpTB5e-R3DyDkWgMY,73357
 lime/plotting/theme_lime.toml,sha256=moyNfRDx0x0Gma3azW_DNfLQoKd1qnBRiX0DAkioBbs,3396
-lime/plotting/utils.py,sha256=LzSDvEb1IrPGmr2nlrq_8jl34al_0yiLSz3t4y6-Kdo,2081
+lime/plotting/utils.py,sha256=tPBXCvMlg7_onLWN9O2I7FoAurzkfF0Qe-JVYSLb1Xs,2069
 lime/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lime/resources/lines_database_formatting.py,sha256=vhdanmwQ9ih0eERRAOCUeIQoc-VmTdHv7GseWxDavoA,4357
 lime/resources/lines_database_v2.0.0.txt,sha256=grhl32eDMtHHnXOw-LVmSCPbYjqUgccJ8ba3d3vDnHI,30855
@@ -28,8 +28,8 @@ lime/resources/logo.py,sha256=buuJuwCjw0JFFtqvvIBpjb-LCuFgBwRFqnVOqCmSam8,3296
 lime/resources/types_params.txt,sha256=HgK-rr_cHnjNR3oLJomdYt6UvKwBn-FMWt40MkCR0wM,10111
 lime/retrieve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lime/retrieve/peaks.py,sha256=zERD2-GO-AtNrx8xwGqNbml0pB0nTCH4Oro-9fr69GU,8713
-lime_stable-2.0.dev4.dist-info/licenses/LICENSE.rst,sha256=B_kw459IXvKujLR27bhVUwXmTq9AM72DdCA1xGgBMKI,35608
-lime_stable-2.0.dev4.dist-info/METADATA,sha256=_Yl-LUpWXHMmwO3BvF338kqZ-w7mPKIOFQMTXfgftKQ,3931
-lime_stable-2.0.dev4.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-lime_stable-2.0.dev4.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
-lime_stable-2.0.dev4.dist-info/RECORD,,
+lime_stable-2.0.dev7.dist-info/licenses/LICENSE.rst,sha256=B_kw459IXvKujLR27bhVUwXmTq9AM72DdCA1xGgBMKI,35608
+lime_stable-2.0.dev7.dist-info/METADATA,sha256=pvUxdCfhIskIQOvSpTUiTH4EQdn8ejTi_WiPfedg4ag,3931
+lime_stable-2.0.dev7.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+lime_stable-2.0.dev7.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
+lime_stable-2.0.dev7.dist-info/RECORD,,

{lime_stable-2.0.dev4.dist-info → lime_stable-2.0.dev7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any