lime-stable 2.0.dev2__tar.gz → 2.0.dev4__tar.gz

{lime_stable-2.0.dev2/src/lime_stable.egg-info → lime_stable-2.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev2
+Version: 2.0.dev4
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later
@@ -15,10 +15,10 @@ Requires-Dist: matplotlib~=3.10
 Requires-Dist: numpy~=2.2
 Requires-Dist: pandas~=2.2
 Requires-Dist: scipy~=1.15
+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: aspect-stable~=0.3.0; extra == "full"
 Requires-Dist: bokeh~=3.6; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.dev2"
+version = "2.0.dev4"
 readme = "README.rst"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"
@@ -17,6 +17,7 @@ dependencies = ["astropy~=7.0",
                 "numpy~=2.2",
                 "pandas~=2.2",
                 "scipy~=1.15",
+                "aspect-stable~=0.3.1",
                 "tomli >= 2.0.0 ; python_version < '3.11'"]
 
 classifiers = ["Programming Language :: Python :: 3",
@@ -24,7 +25,6 @@ classifiers = ["Programming Language :: Python :: 3",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "aspect-stable~=0.3.0",
         "bokeh~=3.6",
         "mplcursors~=0.6",
         "openpyxl~=3.1",

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/archives/read_fits.py

@@ -4,6 +4,7 @@ import numpy as np
 from astropy.io import fits
 from astropy.wcs import WCS
 import logging
+from io import IOBase
 
 from lime.io import LiMe_Error
 from urllib.parse import urlparse
@@ -180,7 +181,7 @@ def check_fits_location(fits_address, lime_object=None, source=None):
                 output = None, False
 
         # Streamlit BytesIO input
-        elif type(fits_address).__name__ == 'UploadedFile':
+        elif (type(fits_address).__name__ == 'UploadedFile') or isinstance(fits_address, IOBase):
             output = fits_address, False
 
         # File address or url

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/archives/tables.py

@@ -122,6 +122,9 @@ def table_fluxes(lines_df, table_address, header_format_latex, table_type='pdf',
         except:
             print('\n-- PDF compilation failure')
 
+    elif table_type == 'tex':
+        pdf.pdfDoc.generate_tex(table_address.as_posix())
+
     return
 
 

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/changelog.txt

@@ -105,4 +105,8 @@ LiMe Mayor update - 2.0.0 - XX/XX/XXXX
     - The central wavelenght bands are now calculated assuming a bands_vsigma=70 and n_sigma=4
     - The function lime.Spectrum.retrieve.spectrum() returns the spectrum axes as a recarray or saves it into a text file if the user provides a file address.
     - lime.Spectrum.from_file("fname", instrument='text') can now read the file from a text file following the format from the lime.Spectrum.retrieve.spectrum() function.
-    - Bug the .plot.spectrum(include_fittings) does not show the combined profile
+    - Bug the .plot.spectrum(include_fittings) does not show the combined profile
+    - 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

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/fitting/lines.py

@@ -418,7 +418,9 @@ def sigma_corrections(line, idcs_line, wave_arr, R_arr, temperature):
         if np.isscalar(R_arr):
             line.sigma_instr = np.mean(wave_arr.compressed() / (R_arr * k_gFWHM))
         else:
-            line.sigma_instr = np.mean(wave_arr[idcs_line].compressed() / (R_arr[idcs_line] * k_gFWHM))
+            mask_data = ~wave_arr.mask
+            line.sigma_instr = np.mean(wave_arr[mask_data] / (R_arr[idcs_line][mask_data] * k_gFWHM))
+            wave_arr[mask_data] / (R_arr[idcs_line][mask_data] * k_gFWHM)
     else:
         line.sigma_instr = np.nan
 

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/fitting/redshift.py

@@ -283,6 +283,9 @@ class RedshiftFitting:
             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
+
         # Set the type of fitting and the components to use
         if mode == 'key':
             components = components if components is not None else ['emission', 'doublet']

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/io.py

@@ -446,8 +446,8 @@ def save_frame(fname, dataframe, page='FRAME', parameters='all', header=None, co
                 output_file.write(string_DF.encode('UTF-8'))
 
         # Pdf fluxes table
-        elif file_type == '.pdf':
-            table_fluxes(lines_log, log_path.parent / log_path.stem, header_format_latex=_LOG_COLUMNS_LATEX,
+        elif file_type == '.pdf' or  file_type == '.tex':
+            table_fluxes(lines_log, log_path.parent / log_path.stem, table_type=file_type[1:],  header_format_latex=_LOG_COLUMNS_LATEX,
                          lines_notation=log.latex_label.values, **kwargs)
 
         # Log in a fits format
@@ -601,7 +601,8 @@ def check_file_dataframe(df_variable, variable_type=pd.DataFrame, ext='FRAME', s
     return output
 
 
-def check_fit_conf(fit_conf, default_key, group_key, group_list=None, fit_cfg_suffix='_line_fitting', line_detection=False):
+def check_fit_conf(fit_conf, default_key, obj_key, update_default=True, group_list=None, fit_cfg_suffix='_line_fitting',
+                   line_detection=False):
 
     # Check that there is an input configuration
     if fit_conf is not None:
@@ -634,33 +635,30 @@ def check_fit_conf(fit_conf, default_key, group_key, group_list=None, fit_cfg_su
 
         # Recover the configuration expected for the object
         default_cfg = input_cfg.get(f'{default_key}_line_fitting') if default_key is not None else None
-        mask_cfg = input_cfg.get(f'{group_key}_line_fitting') if group_key is not None else None
+        custom_cfg = input_cfg.get(f'{obj_key}_line_fitting') if obj_key is not None else None
 
-        # Case there are not leveled entries
-        if (default_cfg is None) and (mask_cfg is None):
+        # Case there are not level entries
+        if (default_cfg is None) and (custom_cfg is None):
             output_cfg = input_cfg
 
         # Proceed to update the levels
         else:
 
             # Default configuration
-            output_cfg = {} if default_cfg is None else default_cfg
-            default_detect = output_cfg.get('line_detection')
+            default_cfg = {} if default_cfg is None else default_cfg
+            default_detect = default_cfg.get('line_detection', {})
 
-            # Mask conf
-            mask_conf = {} if mask_cfg is None else mask_cfg
-            mask_detect = mask_conf.get('line_detection')
+            # Custom configuration
+            custom_cfg = {} if custom_cfg is None else custom_cfg
+            custom_detect = custom_cfg.get('line_detection', {})
 
-            # Update the levels
-            output_cfg = {**output_cfg, **mask_conf}
+            # Update default configuration if requested else use only custom
+            output_cfg = {**default_cfg, **custom_cfg} if update_default else (custom_cfg if custom_cfg else default_cfg)
 
-            # If no line detection don't add it # TODO this is wrong lower should update upper
-            if mask_detect is not None:
-                output_cfg['line_detection'] = mask_detect
-            elif default_detect is not None:
-                output_cfg['line_detection'] = default_detect
-            else:
-                pass
+            # Update default detection if requested else use only custom
+            if line_detection:
+                output_cfg['line_detection'] = default_detect.update(custom_detect) if update_default else\
+                                                                    (custom_detect if custom_detect else default_detect)
 
     else:
         output_cfg = {}

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/lime.toml

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

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/observations.py

@@ -142,7 +142,7 @@ def check_inputs_arrays(wave, flux, err_flux, pixel_mask, lime_object):
     # Check not all the pixels are masked
     if mask_check:
         if np.all(output_pixel_mask):
-            raise LiMe_Error(f'All the input observation pixels are masked. Please check that only bad pixels entries'
+            _logger.critical(f'All the input observation pixels are masked. Please check that only bad pixels entries'
                              f' are masked (in numpy arrays flux_arr[pixel_mask] = bad_entries)')
 
     return output_pixel_mask
@@ -1347,6 +1347,8 @@ class Sample(UserDict, OpenFits):
         else:
             obs = load_function_output
 
+
+
         return obs
 
     def __getitem__(self, id_key):

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/plotting/bokeh_plots.py

@@ -270,7 +270,7 @@ class BokehFigures:
 
     def spectrum(self, output_address=None, label=None, bands=None, rest_frame=False, log_scale=False,
                  include_fits=True, include_cont=False, include_components=False, return_fig=False, fig_cfg=None, ax_cfg=None, maximize=False,
-                 detection_band=None, show_masks=True, show_categories=False):
+                 detection_band=None, show_masks=True, show_categories=False, show_err=False):
 
 
         # Set figure format with the user inputs overwriting the default conf
@@ -298,6 +298,14 @@ class BokehFigures:
         if bands is not None:
             bokeh_bands(fig, bands, wave_plot, flux_plot, z_corr, self._spec.redshift)
 
+        # Show uncertainty
+        if show_err and (self._spec.err_flux is not None):
+            err_plot = self._spec.err_flux.data
+            fig.varea_step(x=wave_plot / z_corr,
+                           y1=(flux_plot - err_plot) * z_corr,
+                           y2=(flux_plot + err_plot) * z_corr,
+                           step_mode="center", fill_alpha=0.2, color=theme.colors['err_area'])
+
         # Include the continuum
         if include_cont and self._spec.cont is not None:
             fig.line(wave_plot/z_corr, self._spec.cont*z_corr, legend_label="Continuum.",

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/plotting/plots.py

@@ -654,7 +654,7 @@ def redshift_permu_evaluation(spectrum, z_infered, obs_wave_arr, theo_wave_arr,
     return
 
 
-def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=False, color_dict=theme.colors):
+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:
@@ -673,8 +673,9 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
             low_lim = m * x_interval + n
 
         # Central bands
-        axis.fill_between(x_interval/z_corr, low_lim*z_corr, y_interval*z_corr,
-                          facecolor=color_dict['line_band'], step='mid', alpha=0.25)
+        if show_central:
+            axis.fill_between(x_interval/z_corr, low_lim*z_corr, y_interval*z_corr,
+                              facecolor=color_dict['line_band'], step='mid', alpha=0.25)
 
         # Continua bands exclusion
         if exclude_continua is False:
@@ -767,8 +768,8 @@ class Plotter:
     def _line_matching_plot(self, axis, bands, x, y, z_corr, redshift):
 
         # Open the bands file the bands
-        match_log = self._spec.retrieve.line_bands(ref_bands=bands, fit_conf=None, instrumental_correction=False,
-                                                   adjust_central_bands=False)
+        match_log = self._spec.retrieve.line_bands(ref_bands=bands, fit_cfg=None, instrumental_correction=False,
+                                                   adjust_central_band=False)
         # Compute bands limits
         w3 = match_log.w3.values * (1 + redshift)
         w4 = match_log.w4.values * (1 + redshift)
@@ -782,6 +783,7 @@ 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
@@ -881,7 +883,7 @@ class SpectrumFigures(Plotter):
 
         """
 
-        This function plots the spectrum flux versus wavelength.
+        This function plots the spectrum flux versus wavelength.z
 
         The user can include the line bands on the plot if added via the ``line_bands`` attribute.
 
@@ -1274,7 +1276,7 @@ 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):
+              ax_cfg=None, in_fig=None, maximize=False, show_err=True):
 
         """
 
@@ -1333,6 +1335,12 @@ class SpectrumFigures(Plotter):
         # Check which line should be plotted
         line = parse_bands_arguments(label, log, ref_bands, norm_flux)
 
+        # Check the observation has uncertainty to display
+        if show_err and (self._spec.err_flux is None):
+            if self._spec.err_flux is None:
+                _logger.info('Input observation does not include uncertainty to display')
+                show_err = False
+
         # Proceed to plot
         if line is not None:
 
@@ -1375,7 +1383,14 @@ class SpectrumFigures(Plotter):
                               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)
+                bands_filling_plot(in_ax[0], wave_plot, flux_plot, z_corr, idcs_bands, line, color_dict=theme.colors,
+                                   show_central=not show_err)
+
+                if show_err:
+                    err_plot = self._spec.err_flux.data
+                    in_ax[0].fill_between(x=wave_plot[idcs_bands[2]:idcs_bands[3]] / z_corr, y1=(flux_plot[idcs_bands[2]:idcs_bands[3]] - err_plot[idcs_bands[2]:idcs_bands[3]]) * z_corr,
+                                       y2=(flux_plot[idcs_bands[2]:idcs_bands[3]] + err_plot[idcs_bands[2]:idcs_bands[3]]) * z_corr,
+                                       step='mid', alpha=1, color=theme.colors['line_band'], ec=None)
 
                 # Add the fitting results
                 if include_fits:

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/plotting/plots_interactive.py

@@ -20,23 +20,31 @@ from ..transitions import label_decomposition, Line
 _logger = logging.getLogger('LiMe')
 
 
-def establish_selection_lines(spec, input_log, band_vsigma=70, n_sigma=4, fit_conf=None,
-                             default_conf_prefix='default', obj_conf_prefix=None, adjust_central_bands=True,
-                             instrumental_correction=True, components_detection=False, line_list=None,
-                             particle_list=None, sig_digits=None, vacuum_waves=False, ref_bands=None, update_labels=True,
-                             update_latex=False):
+def establish_selection_lines(spec, input_log, band_vsigma, n_sigma, adjust_central_band, instrumental_correction,
+                              components_detection, composite_lines, fit_cfg, default_cfg_prefix, obj_cfg_prefix,
+                              update_default, line_list, particle_list, decimals, vacuum_waves, ref_bands, update_labels,
+                              update_latex, vacuum_label):
 
     # Use the default database crop for the observation if none provided
-    ref_bands = spec.retrieve.line_bands(band_vsigma, n_sigma, None, None, None,
-                   adjust_central_bands, instrumental_correction, False, line_list,
-                   particle_list, sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+    ref_bands = spec.retrieve.line_bands(band_vsigma=band_vsigma, n_sigma=n_sigma, adjust_central_band=adjust_central_band,
+                                         instrumental_correction=instrumental_correction, components_detection=False,
+                                         composite_lines=None, fit_cfg=None, default_cfg_prefix=None,
+                                         obj_cfg_prefix=None, update_default=True,
+                                         line_list=line_list, particle_list=particle_list, decimals=decimals,
+                                         vacuum_waves=vacuum_waves, ref_bands=ref_bands, update_labels=update_labels,
+                                         update_latex=update_latex, vacuum_label=vacuum_label)
+
 
     # Load input log or copy the reference one
     in_bands = check_file_dataframe(input_log, verbose=False)
     if in_bands is None:
-        in_bands = spec.retrieve.line_bands(band_vsigma, n_sigma, fit_conf, default_conf_prefix, obj_conf_prefix,
-                               adjust_central_bands, instrumental_correction, components_detection, line_list,
-                               particle_list, sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+        in_bands = spec.retrieve.line_bands(band_vsigma=band_vsigma, n_sigma=n_sigma, adjust_central_band=adjust_central_band,
+                                         instrumental_correction=instrumental_correction, components_detection=components_detection,
+                                         composite_lines=composite_lines, fit_cfg=fit_cfg, default_cfg_prefix=default_cfg_prefix,
+                                         obj_cfg_prefix=obj_cfg_prefix, update_default=update_default,
+                                         line_list=line_list, particle_list=particle_list, decimals=decimals,
+                                         vacuum_waves=vacuum_waves, ref_bands=ref_bands, update_labels=update_labels,
+                                         update_latex=update_latex, vacuum_label=vacuum_label)
         default_status = 1 if components_detection else 0
     else:
         default_status = 1
@@ -78,6 +86,11 @@ def establish_selection_lines(spec, input_log, band_vsigma=70, n_sigma=4, fit_co
     active_lines = active_lines[sorted_indexes].astype(bool)
     labels_arr = labels_arr[sorted_indexes]
 
+    # Set NaN entries in dataframe as None
+    if 'group_label' in log.columns:
+        idcs_nan = log.group_label.isnull()
+        log.loc[idcs_nan, 'group_label'] = 'none'
+
     return log, labels_arr,  active_lines
 
 
@@ -180,17 +193,20 @@ class BandsInspection:
         self._color_bg = {True: theme.colors['inspection_positive'],
                           False: theme.colors['inspection_negative']}
 
+        self._out_params = ["wavelength", "wave_vac", "w1", "w2", "w3", "w4", "w5", "w6",
+                            "units_wave", "particle", "transition", "rel_int"]
+
         return
 
-    def bands(self, bands_file, band_vsigma=70, n_sigma=4, fit_conf=None, default_conf_prefix='default', obj_conf_prefix=None,
-              adjust_central_bands=True, instrumental_correction=True, components_detection=False, line_list=None,
-              particle_list=None, sig_digits=None, vacuum_waves=False, ref_bands=None, update_labels=True,
-              update_latex=False, y_scale='auto', n_cols=6, n_rows=None, col_row_scale=(1, 0.5),
-              exclude_continua=False,  n_pixels=10, fig_cfg=None, in_fig=None, maximize=False):
+    def bands(self, bands_file, band_vsigma=70, n_sigma=4, adjust_central_band=True, instrumental_correction=True,
+              components_detection=False, composite_lines=None, fit_cfg=None, default_cfg_prefix='default',
+              obj_cfg_prefix=None, update_default=True, line_list=None, particle_list=None, decimals=None,
+              vacuum_waves=False, ref_bands=None, update_labels=False, update_latex=False, vacuum_label=False,
+              y_scale='auto', n_cols=6, n_rows=None, col_row_scale=(1, 0.5),
+              exclude_continua=False, n_pixels=10, fig_cfg=None, in_fig=None, maximize=False):
 
 
         """
-
         This function launches an interactive plot from which to select the line bands on the observed spectrum. If this
         function is run a second time, the user selections won't be overwritten.
 
@@ -266,10 +282,11 @@ class BandsInspection:
                     raise LiMe_Error(f'Input bands file directory does not exist ({self._log_address.parent.as_posix()})')
 
         # Establish the reference lines log to inspect the mask
-        self.log, self.line_list, self.active_lines = establish_selection_lines(self._spec, self._log_address,  band_vsigma, n_sigma, fit_conf,
-                                                        default_conf_prefix, obj_conf_prefix, adjust_central_bands,
-                                                        instrumental_correction, components_detection, line_list, particle_list,
-                                                        sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+        self.log, self.line_list, self.active_lines = establish_selection_lines(self._spec, self._log_address,
+                                                      band_vsigma, n_sigma, adjust_central_band, instrumental_correction,
+                                                      components_detection, composite_lines, fit_cfg, default_cfg_prefix,
+                                                      obj_cfg_prefix, update_default, line_list, particle_list, decimals,
+                                                      vacuum_waves, ref_bands, update_labels, update_latex, vacuum_label)
 
         # Proceed if there are lines in the mask for the object spectrum wavelength range
         if len(self.log.index) > 0:
@@ -430,7 +447,7 @@ class BandsInspection:
                     _logger.info(f'Unsuccessful line selection: {self.line}: w_low: {w_low}, w_high: {w_high}')
 
             # Save the log to the file
-            save_or_clear_log(self.log, self._log_address, self.active_lines)
+            save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
             # Redraw the line measurement
             self._ax.clear()
@@ -470,7 +487,7 @@ class BandsInspection:
                 self.active_lines[idx] = np.invert(self.active_lines[idx])
 
             # Save the log to the file
-            save_or_clear_log(self.log, self._log_address, self.active_lines)
+            save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
             # Plot the line selection with the new Background
             self._ax.clear()
@@ -516,7 +533,7 @@ class BandsInspection:
         self._fig.canvas.draw()
 
         # Save the log to the file
-        save_or_clear_log(self.log, self._log_address, self.active_lines)
+        save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
         return
 
@@ -549,7 +566,7 @@ class RedshiftInspectionSingle:
 
     def redshift(self, reference_lines, output_file_log=None, output_idcs=None, redshift_column='redshift',
                  none_value=np.nan, unknown_value=0.0, legend_handle='levels', maximize=False, title_label=None,
-                 output_address=None, plt_cfg={}, ax_cfg={}, in_fig=None):
+                 output_address=None, fig_cfg={}, ax_cfg={}, in_fig=None):
 
         # Assign the attributes
         self._obj_idcs = None
@@ -581,16 +598,12 @@ class RedshiftInspectionSingle:
         idcs_sorted = np.argsort(_waves_array)
         self._waves_array, self._latex_array = _waves_array[idcs_sorted], _latex_array[idcs_sorted]
 
-        # Set figure format with the user inputs overwriting the default conf
-        plt_cfg.setdefault('figure.figsize', (10, 6))
-        plt_cfg.setdefault('axes.labelsize', 12)
-        plt_cfg.setdefault('xtick.labelsize', 10)
-        plt_cfg.setdefault('ytick.labelsize', 10)
+        # Set the plot format where the user's overwrites the default
+        size_conf = {'figure.figsize': (10, 6), 'axes.labelsize': 12, 'xtick.labelsize': 10, 'ytick.labelsize': 10}
+        size_conf = size_conf if fig_cfg is None else {**size_conf, **fig_cfg}
 
-        norm_flux = self._sample.load_params.get('norm_flux')
-        units_wave, units_flux = self._sample.load_params.get('units_wave'), self._sample.load_params.get('units_flux')
-        PLT_CONF, self._AXES_CONF = self._figure_format(plt_cfg, ax_cfg, norm_flux=norm_flux, units_wave=units_wave,
-                                                        units_flux=units_flux)
+        PLT_CONF = theme.fig_defaults(size_conf)
+        self._AXES_CONF = theme.ax_defaults(ax_cfg, self._spec.units_wave, self._spec.units_flux, self._spec.norm_flux, fig_type=None)
 
         # Create and fill the figure
         with rc_context(PLT_CONF):
@@ -601,15 +614,12 @@ class RedshiftInspectionSingle:
             self._ax = self._fig.add_subplot(gs[0])
             self._ax.set(**self._AXES_CONF)
 
-            # Line Selection axis
+            # Create the RadioButtons widget for the lines
             buttoms_ax = self._fig.add_subplot(gs[1])
-            buttons_list = [r'$None$'] + list(self._latex_array) + [r'$Unknown$']
-            radio = RadioButtons(buttoms_ax, buttons_list)
-            for circle in radio.circles:  # Make the buttons a bit rounder
-                circle.set_height(0.025)
-                circle.set_width(0.075)
-            for r in radio.labels:
-                r.set_fontsize(6)
+            labels_buttons = [r'$None$'] + list(self._latex_array) + [r'$Unknown$']
+            radio_props = {'s': [10] * len(labels_buttons)}
+            label_props = {'fontsize': [6] * len(labels_buttons)}
+            radio = RadioButtons(buttoms_ax, labels_buttons, radio_props=radio_props, label_props=label_props)
 
             # Plot the spectrum
             self._launch_plots_ZI()
@@ -828,9 +838,13 @@ class RedshiftInspection:
 
     def redshift(self, obj_idcs, reference_lines, output_file_log=None, output_idcs=None, redshift_column='redshift',
                  initial_z=None, none_value=np.nan, unknown_value=0.0,  legend_handle='levels', maximize=False, title=None,
-                 output_address=None, n_pixels=10, fig_cfg={}, ax_cfg={}, in_fig=None):
+                 output_address=None, n_pixels=10, fig_cfg={}, ax_cfg={}, in_fig=None, **kwargs):
 
 
+        # Check if input tuple
+        if isinstance(obj_idcs, tuple):
+            obj_idcs = pd.MultiIndex.from_tuples([obj_idcs], names=self._sample.index.names)
+
         # Assign the attributes
         self._obj_idcs = obj_idcs if isinstance(obj_idcs, pd.MultiIndex) else self._sample.loc[obj_idcs].index
         self._column_log = redshift_column
@@ -840,6 +854,10 @@ class RedshiftInspection:
         self._legend_handle = legend_handle
         self._user_point = None
 
+        # Parameters for the load function
+        self._load_params = {**self._sample.load_params, **kwargs}
+        self._load_params['redshift'] = 0
+
         # Output Log params
         self._log_address = output_file_log
 
@@ -894,16 +912,12 @@ class RedshiftInspection:
             self._ax = self._fig.add_subplot(gs[0])
             self._ax.set(**self._AXES_CONF)
 
-            # Line Selection axis
+            # Create the RadioButtons widget for the lines
             buttoms_ax = self._fig.add_subplot(gs[1])
-            buttons_list = [r'$None$'] + list(self._latex_array) + [r'$Unknown$']
-            radio = RadioButtons(buttoms_ax, buttons_list)
-            for circle in radio.circles:  # Make the buttons a bit rounder
-                circle.set_height(0.025)
-                circle.set_width(0.075)
-                circle.set_edgecolor(theme.colors['fg'])  # or any color like 'black', '#333333', etc.
-            for r in radio.labels:
-                r.set_fontsize(6)
+            labels_buttons = [r'$None$'] + list(self._latex_array) + [r'$Unknown$']
+            radio_props = {'s': [10] * len(labels_buttons)}
+            label_props = {'fontsize': [6] * len(labels_buttons)}
+            radio = RadioButtons(buttoms_ax, labels_buttons, radio_props=radio_props, label_props=label_props)
 
             # Plot the spectrum
             self._launch_plots_ZI()
@@ -915,9 +929,6 @@ class RedshiftInspection:
             # Plot on screen unless an output address is provided
             save_close_fig_swicth(output_address, 'tight', self._fig, maximise=maximize)
 
-        # else:
-        #     _logger.warning(f'The sample does not have objects. The redshift check could not be done')
-
         return
 
     def _launch_plots_ZI(self):
@@ -955,8 +966,7 @@ class RedshiftInspection:
         for i, obj_idx in enumerate(self._obj_idcs):
 
             # Load the spectrum with a zero redshift
-            load_params = {**self._sample.load_params, **{'redshift': 0}}
-            spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **load_params)
+            spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **self._load_params)
 
             # Plot on the observed frame with reshift = 0
             wave_plot, flux_plot, z_corr, idcs_mask = frame_mask_switch(spec.wave, spec.flux, spec.redshift, 'observed')
@@ -977,8 +987,7 @@ class RedshiftInspection:
             for obj_idx in self._obj_idcs:
 
                 # Load the spectrum
-                load_params = {**self._sample.load_params, **{'redshift': 0}}
-                spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **load_params)
+                spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **self._load_params)
 
                 wavelength = spec.wave.data
                 wavelength = wavelength[~np.isnan(wavelength)]
@@ -1053,13 +1062,12 @@ class RedshiftInspection:
             _redshift_pred = redshift_output
 
         # Store the new redshift
-        #
+
         self._sample.loc[self._output_idcs, self._column_log] = _redshift_pred
 
         # Save to file if provided
         if self._log_address is not None:
             save_frame(self._log_address, self._sample.frame)
-
         return
 
     def _button_ZI(self, line_selection):
@@ -1349,10 +1357,12 @@ class CubeInspection:
             # Buttons axis if provided
             if len(self.masks_dict) > 0:
                 self._ax2 = self._fig.add_subplot(gs_image[1])
-                radio = RadioButtons(self._ax2, list(self.masks_dict.keys()))
 
-                for r in radio.labels:
-                    r.set_fontsize(5)
+                # Create the RadioButtons widget with the specified properties
+                labels_buttons = list(self.masks_dict.keys())
+                radio_props = {'s': [10] * len(labels_buttons)}
+                label_props = {'fontsize': [5] * len(labels_buttons)}
+                radio = RadioButtons(self._ax2, labels_buttons, radio_props=radio_props, label_props=label_props)
 
             # Plot the data
             self.data_plots()
@@ -1733,7 +1743,7 @@ class MaskInspection:
         return
 
 
-class SpectrumCheck(Plotter, RedshiftInspection, BandsInspection):
+class SpectrumCheck(Plotter, RedshiftInspectionSingle, BandsInspection):
 
     def __init__(self, spectrum):
 

{lime_stable-2.0.dev2 → lime_stable-2.0.dev4}/src/lime/plotting/theme_lime.toml

@@ -109,6 +109,7 @@ mask_marker = '#FF0000'
 inspection_positive = '#FFFFFF'
 inspection_negative = '#ff796c' # 'xkcd:salmon'
 fade_fg = "#FFE5B4"
+err_area = "#00FF00"
 
 [colors.dark] # Dark theme
 bg = "#2B2B2B"
@@ -128,4 +129,5 @@ comps_map = 'PuRd'
 mask_marker = '#FF0000'
 inspection_positive = "#2B2B2B"
 inspection_negative = '#840000'
-fade_fg = "#73879B"
+fade_fg = "#73879B"
+err_area = "#00FF00"