lime-stable 2.2.dev2__py3-none-any.whl → 2.2.dev5__py3-none-any.whl

lime/archives/read_fits.py

@@ -7,6 +7,7 @@ from astropy.wcs import WCS
 
 from lime.io import LiMe_Error, lime_cfg
 from urllib.parse import urlparse
+from io import BytesIO
 
 try:
     import requests
@@ -265,7 +266,6 @@ 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:
@@ -280,14 +280,12 @@ def load_txt(text_address, **kwargs):
     out_array = np.loadtxt(text_address, **kwargs)
 
     # File address
-    if not type(text_address).__name__ == "UploadedFile":
+    if isinstance(text_address, BytesIO) or (type(text_address).__name__ == "UploadedFile"):
+        lines = text_address.getvalue().decode("utf-8").splitlines()
+    else:
         with open(text_address, "r") as f:
             lines = f.readlines()
 
-    # Uploaded file
-    else:
-        lines = text_address.getvalue().decode("utf-8").splitlines()
-
     # Reverse loop over the lines
     params_dict = {}
     for line in reversed(lines):
@@ -297,19 +295,6 @@ def load_txt(text_address, **kwargs):
         key, value = line[1:].split(":", 1)
         params_dict[key.strip()] = value.strip()
 
-    # # Transform foot comments as dictionary data
-    # params_dict = {}
-    # with open(text_address, "r") as f:
-    #
-    #     # Reverse loop while the lines start by a "#"
-    #     for line in reversed(f.readlines()):
-    #         line = line.strip()
-    #         if not line.startswith("#") or (line.startswith("# LiMe")):
-    #             break
-    #
-    #         # Extract key-value pairs
-    #         key, value = line[1:].split(":", 1)  # Split at the first ':'
-    #         params_dict[key.strip()] = value.strip()
 
     return out_array, params_dict
 

lime/fitting/lines.py

@@ -232,7 +232,7 @@ def voigt_area(line, idx, n_steps):
     sigma = np.random.normal(line.sigma[idx], line.sigma_err[idx], n_steps)
     gamma = np.random.normal(line.gamma[idx], line.gamma_err[idx], n_steps)
 
-    return gaussian_area(amp, sigma) + lorentz_area(amp, gamma)
+    return gaussian_area(amp, sigma, n_steps) + lorentz_area(amp, gamma, n_steps)
 
 
 def pseudo_voigt_area(line, idx, n_steps):
@@ -268,7 +268,7 @@ def pseudo_power_area(line, idx, n_steps):
 
 def velocity_to_wavelength_band(n_sigma, band_velocity_sigma, lambda_obs, delta_instr):
 
-    return n_sigma * ((band_velocity_sigma / c_KMpS) * lambda_obs + delta_instr)
+    return n_sigma * np.sqrt(np.square((band_velocity_sigma / c_KMpS) * lambda_obs) + np.square(delta_instr))
 
 
 ALL_PARAMS = np.array(['m_cont', 'n_cont', 'amp', 'center', 'sigma', 'gamma', 'alpha', 'frac', 'a', 'b', 'c'])

lime/lime.toml

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

lime/observations.py

@@ -340,6 +340,10 @@ class Spectrum:
         internally for fitting and removed in reported measurements.
     crop_waves : tuple or numpy.ndarray, optional
         Two-element ``(min, max)`` wavelength range used to crop the input arrays.
+    crop_flux : tuple, optional
+        Two-element ``(min_percentile, max_percentile)`` range used to clip the flux array
+        by percentile. Defaults to ``None``, equivalent to ``(1, 100)`` (i.e. the 1st to
+        100th percentile).
     res_power : float or numpy.ndarray, optional
         Instrument resolving power :math:`R = \\lambda/\\Delta\\lambda`. If provided,
         it can be used to compute and apply an instrumental broadening correction
@@ -923,14 +927,18 @@ class Spectrum:
 
             # Confirm the lines in the log match the one of the spectrum
             if line_0.units_wave != self.units_wave:
-                _logger.warning(f'Different units in the spectrum dispersion ({self.units_wave}) axis and the lines log'
-                                f' in {line_0.units_wave[0]}')
-
-            # Confirm all the log lines have the same units
-            au_str = 'A' if line_0.units_wave == 'Angstrom' else str(line_0.units_wave)
-            same_units_check = np.flatnonzero(np.core.defchararray.find(line_list.astype(str), au_str) != -1).size == line_list.size
-            if not same_units_check:
-                _logger.warning(f'The log has lines with different units')
+                _logger.critical(f'Different units in the spectrum dispersion ({self.units_wave}) axis and the lines log'
+                                 f' in {line_0.units_wave[0]}')
+
+            # # Confirm all the log lines have the same units This fails if blended or merged in table
+            # au_str = 'A' if line_0.units_wave == 'Angstrom' else str(line_0.units_wave)
+            # same_units_check = np.flatnonzero(np.core.defchararray.find(line_list.astype(str), au_str) != -1).size == line_list.size
+            # same_units_check = np.char.find(line_list.astype(str), au_str)
+            # (np.char.find(line_list.astype(str), au_str) != -1).all()
+            # np.array([str(l) for l in line_list]).astype(str)
+            #
+            # if not same_units_check:
+            #     _logger.warning(f'The log has lines with different units')
 
             # Assign the log
             self.frame = log_df
@@ -957,7 +965,7 @@ class Spectrum:
             if frame is not None:
                 if line_label in frame.index:
                     bands_limits = frame.loc[line_label, 'w1':'w6']
-                    idcs_bands = np.searchsorted(self._spec.wave.data, bands_limits * (1 + self._spec.redshift))
+                    idcs_bands = np.searchsorted(self.wave.data, bands_limits * (1 + self.redshift))
                     idcs = (idcs_bands[0], idcs_bands[5])
                     line_measured = True
                 else:
@@ -973,9 +981,9 @@ class Spectrum:
             line_list = line.list_comps
 
             # Compute the linear components
-            gaussian_arr = profiles_computation(line_list, frame, 1 + self._spec.redshift, line.profile,
-                                                x_array=self._spec.wave.data[idcs[0]: idcs[1]])
-            linear_arr = linear_continuum_computation(line_list, frame, 1 + self._spec.redshift, x_array=self._spec.wave.data[idcs[0]: idcs[1]])
+            gaussian_arr = profiles_computation(line_list, frame, 1 + self.redshift, line.profile,
+                                                x_array=self.wave.data[idcs[0]: idcs[1]])
+            linear_arr = linear_continuum_computation(line_list, frame, 1 + self.redshift, x_array=self.wave.data[idcs[0]: idcs[1]])
 
             # Determine which component you want to extract:
             if split_components is False:
@@ -1145,13 +1153,14 @@ class Spectrum:
         >>> spec.frame.shape
         (0, 10)
         """
+        if self.frame is not None:
 
-        if line_data:
-            self.frame = self.frame[0:0]
+            if line_data:
+                self.frame = self.frame[0:0]
 
-        if cont_data:
-            self.cont = None
-            self.cont_std = None
+            if cont_data:
+                self.cont = None
+                self.cont_std = None
 
         return
 

lime/plotting/bokeh_plots.py

@@ -39,6 +39,10 @@ category_conf_styles = {0: 'dotted',
                         1: 'dashed',
                         2: 'solid'}
 
+def ensure_list(x):
+    return x if isinstance(x, list) else [x]
+
+
 def update_bokeh_figure(figure_obj, config_dict):
 
     # Set general figure properties
@@ -48,30 +52,40 @@ def update_bokeh_figure(figure_obj, config_dict):
         if isinstance(value, dict):
             match key:
                 case "xaxis":
-                    for axis in figure_obj.xaxis:  # Update all x-axes
-                        for attr, val in value.items():
-                            setattr(axis, attr, val)
+                    for item_obj in ensure_list(figure_obj):
+                        if item_obj is not None:
+                            for axis in item_obj.xaxis:  # Update all x-axes
+                                for attr, val in value.items():
+                                    setattr(axis, attr, val)
 
                 case "yaxis":
-                    for axis in figure_obj.yaxis:  # Update all y-axes
-                        for attr, val in value.items():
-                            setattr(axis, attr, val)
+                    for item_obj in ensure_list(figure_obj):
+                        if item_obj is not None:
+                            for axis in item_obj.yaxis:  # Update all y-axes
+                                for attr, val in value.items():
+                                    setattr(axis, attr, val)
 
                 case "title":
                     for attr, val in value.items():
-                        setattr(figure_obj.title, attr, val)
+                        for item_obj in ensure_list(figure_obj):
+                            if item_obj is not None:
+                                setattr(item_obj.title, attr, val)
 
                 case "xgrid":
-                    for grid in figure_obj.xgrid:  # Update all x-grids
-                        for attr, val in value.items():
-                            val = None if val == 'None' else val
-                            setattr(grid, attr, val)
+                    for item_obj in ensure_list(figure_obj):
+                        if item_obj is not None:
+                            for grid in item_obj.xgrid:  # Update all x-grids
+                                for attr, val in value.items():
+                                    val = None if val == 'None' else val
+                                    setattr(grid, attr, val)
 
                 case "ygrid":
-                    for grid in figure_obj.ygrid:  # Update all y-grids
-                        for attr, val in value.items():
-                            val = None if val == 'None' else val
-                            setattr(grid, attr, val)
+                    for item_obj in ensure_list(figure_obj):
+                        if item_obj is not None:
+                            for grid in item_obj.ygrid:  # Update all y-grids
+                                for attr, val in value.items():
+                                    val = None if val == 'None' else val
+                                    setattr(grid, attr, val)
 
         # Single value entries
         else:
@@ -86,7 +100,12 @@ def update_bokeh_figure(figure_obj, config_dict):
                     case 'active_tap':
                         figure_obj.toolbar.active_tap = figure_obj.select_one(getattr(models, value))
                     case _ :
-                        setattr(figure_obj, key, value)
+                        if isinstance(figure_obj, list):
+                            for ax in figure_obj:
+                                if ax is not None:
+                                    setattr(ax, key, value)
+                        else:
+                         setattr(figure_obj, key, value)
 
     # # Set zoom and pan as active
     # figure_obj.toolbar.active_scroll = figure_obj.select_one(WheelZoomTool)  # Activate zoom wheel
@@ -129,6 +148,7 @@ def save_close_fig_swicth(file_path, fig_obj, display_check):
 
     return
 
+
 def bokeh_bands(fig, bands, x, y, z_corr, redshift):
 
     # Open the bands file the bands
@@ -314,6 +334,61 @@ def profile_bokeh(fig, line, z_cor, log, redshift, norm_flux):
     return line_single
 
 
+def redshift_fit_evaluation_bokeh(spectrum, z_infered, data_mask, gauss_arr, z_arr, flux_sum_arr, rest_frame=True):
+
+    # gauss_arr_max = compute_z_key(z_infer, theo_lambda, wave_matrix, 1, sigma_arr)
+
+    wave_plot, flux_plot, z_corr, idcs_mask = frame_mask_switch(spectrum.wave, spectrum.flux, z_infered, rest_frame)
+    wave_corr = wave_plot / z_corr
+    flux_corr = flux_plot * z_corr
+
+    # Masked flux (red overlay)
+    y_mask = np.full(flux_plot.size, np.nan)
+    y_mask[data_mask] = flux_corr[data_mask]
+
+    # --- Top panel: spectrum ---
+    p1 = figure(width=800, height=300,
+                x_axis_label=str(spectrum.units_wave),
+                y_axis_label=str(spectrum.units_flux),
+                tools="xpan,xwheel_zoom,reset,save")
+
+    # Full spectrum
+    p1.step(wave_corr, flux_corr, color='white', line_width=1, mode='center', legend_label='Spectrum')
+
+    # Masked region
+    p1.step(wave_corr, y_mask, color='red', line_width=1, mode='center', legend_label='Mask')
+
+    p1.legend.location = "top_right"
+    p1.legend.click_policy = "hide"
+
+    # --- Twin axis equivalent: gauss_arr on secondary y ---
+    # Bokeh doesn't have true twinx, so we normalize gauss_arr to flux scale for overlay
+    flux_max = np.nanmax(flux_corr)
+    gauss_scaled = gauss_arr * flux_max  # scale to flux range
+
+    p1.step(wave_corr, gauss_scaled, color='yellow', line_width=1, mode='center', legend_label='Bands')
+
+    # --- Bottom panel: redshift search ---
+    title = f'z_prediction = {z_infered:.3f}'
+    p2 = figure(width=800, height=200, title=title,
+                x_axis_label='Redshift range',
+                y_axis_label='F_sum / max(F_sum)',
+                tools="xpan,xwheel_zoom,reset,save")
+
+    flux_sum_norm = flux_sum_arr / np.max(flux_sum_arr)
+
+    p2.step(z_arr, flux_sum_norm, color='white', line_width=1, mode='center')
+
+    # Peak marker
+    p2.scatter([z_infered], [1], marker='circle', color='red', size=10)
+
+    # y ticks
+    p2.yaxis.ticker = [0, 1]
+
+    # Link x ranges if rest_frame shares a common axis (optional)
+    # p2.x_range = p1.x_range  # uncomment if x axes are the same
+
+    # streamlit_bokeh(column(p1, p2), use_container_width=True)
 
 
 # Sentinel object for non input figures

lime/plotting/format.py

@@ -201,8 +201,6 @@ class Themer:
         # Figure colors for bokeh
         colors_bokeh = nested_dict(deepcopy(self.conf['bokeh']['colors']), self.colors)
         self.active_conf['bokeh'].update(colors_bokeh)
-                # for key, value in self.conf['bokeh']['colors'].items():
-                #     self.active_conf['bokeh'][key] = self.colors.get(value, value)
 
         # Set the size
         if self.scale[0] in self.conf['matplotlib']['size']:
@@ -211,7 +209,6 @@ class Themer:
         if self.scale[0] in self.conf['bokeh']['size']:
             self.bokeh = self.conf['bokeh']['size'][self.scale[0]]
 
-
         return
 
 

lime/plotting/theme_lime.toml

@@ -58,7 +58,7 @@ default."label_lines" = 10
 [bokeh]
 default."width" = 600
 default."height" = 300
-default."tools" = 'fullscreen,pan,wheel_zoom,box_zoom,xzoom_in,yzoom_in,reset,save'
+default."tools" = 'fullscreen,pan,wheel_zoom,box_zoom,xwheel_zoom,reset,save'
 default.'active_drag' = 'PanTool'
 default.'active_scroll' = 'WheelZoomTool'
 

lime/retrieve/line_bands.py

@@ -18,6 +18,63 @@ def deblend_criteria(mu_arr, sigma_arr, Rayleigh_threshold):
     return resolvable
 
 
+def find_sharing_groups(lines: np.ndarray, matrix: np.ndarray) -> list[np.ndarray]:
+    superdiag = np.diag(matrix, k=1).astype(bool)
+    breaks = np.where(np.diff(superdiag.astype(int), prepend=0, append=0) != 0)[0]
+    starts, ends = breaks[0::2], breaks[1::2]
+    return [lines[s:e + 1] for s, e in zip(starts, ends) if superdiag[s]]
+
+
+def blend_merge_dict(line_list: np.ndarray, relation_list: np.ndarray) -> dict:
+    """
+    Build a blend/merge dictionary from a list of lines and their relations.
+
+    Parameters
+    ----------
+    line_list : np.ndarray
+        Ordered array of line names.
+    relation_list : np.ndarray of bool
+        Connections between consecutive lines. True=blended, False=merged.
+        Length must be len(line_list) - 1.
+
+    Returns
+    -------
+    dict
+        Keys/values describing blend and merge groupings.
+    """
+    # All True: single blended group
+    if relation_list.all():
+        return {f"{line_list[0]}_b": "+".join(line_list)}
+
+    # All False: single merge group
+    if not relation_list.any():
+        return {f"{line_list[0]}_m": "+".join(line_list)}
+
+    # Mixed: find contiguous False entries
+    false_mask = ~relation_list
+    edges = np.diff(false_mask.astype(int), prepend=0, append=0)
+    starts = np.where(edges == 1)[0]
+    ends   = np.where(edges == -1)[0]
+
+    # Build merge entries: each False run covers lines[start : end+1]
+    merge_entries = {f"{line_list[s]}_m": "+".join(line_list[s:e + 1]) for s, e in zip(starts, ends)}
+
+    # Build blend parts: replace merged subgroups with their key (Mark hidden in a merge subgroup)
+    hidden = np.zeros(len(line_list), dtype=bool)
+    for s, e in zip(starts, ends):
+        hidden[s + 1:e + 1] = True  # keep the first line as anchor, absorb the rest
+
+    # For non-hidden lines: use line name, but swap merge-subgroup anchors for their key
+    is_anchor = np.zeros(len(line_list), dtype=bool)
+    is_anchor[starts] = True
+
+    blend_parts = np.where(is_anchor, np.array([f"{l}_m" for l in line_list]), line_list)
+    blend_value = "+".join(blend_parts[~hidden])
+
+    blend_key = f"{line_list[0]}_b"
+    return {blend_key: blend_value, **merge_entries}
+
+
 def determine_line_groups(spec, bands, fit_conf, composite_lines, automatic_grouping, n_sigma, Rayleigh_threshold):
 
     # Check if the input configuration has a list of lines
@@ -42,7 +99,7 @@ def determine_line_groups(spec, bands, fit_conf, composite_lines, automatic_grou
         line_list, group_lines = [], []
         group_names, group_blended_check = [], []
         for comp, group_label in fit_conf.items():
-            if comp.endswith(('_b', '_m')):
+            if comp.endswith(('_b', '_m')) and groups_dict.get(comp) is None:
 
                 # No kinematic groups
 
@@ -162,6 +219,47 @@ def determine_line_groups(spec, bands, fit_conf, composite_lines, automatic_grou
     return groups_dict
 
 
+def get_spectrum_line_groups(wave_rest, bands, n_sigma=4, Rayleigh_threshold=2):
+
+    # Get limits of the bands on the spectrum wavelength range
+    idx3_arr = np.searchsorted(wave_rest, bands.w3.to_numpy())
+    idx4_arr = np.searchsorted(wave_rest, bands.w4.to_numpy())
+
+    # Generate binary matrix with the line bands location
+    wave_matrix = np.zeros((bands.index.size, wave_rest.size))
+    cols = np.arange(wave_matrix.shape[1])
+    wave_matrix[(cols >= idx3_arr[:, None]) & (cols <= idx4_arr[:, None])] = 1
+
+    # Compute the decision matrix with the common pixels
+    decision_matrix = wave_matrix @ wave_matrix.T
+
+    (np.diagonal(decision_matrix, offset=1) > 0).sum() + 1
+
+    grouped_lines = find_sharing_groups(bands.index.to_numpy(), decision_matrix)
+
+    idx3_arr = np.searchsorted(wave_rest, bands.w3.to_numpy())
+    idx4_arr = np.searchsorted(wave_rest, bands.w4.to_numpy())
+
+    relation_list = []
+    for group in grouped_lines:
+        idcs = bands.index.isin(group)
+        w3_arr = idx3_arr[idcs]
+        w4_arr = idx4_arr[idcs]
+        mu_arr = np.searchsorted(wave_rest, bands.loc[group, 'wavelength'].to_numpy())
+        obs_group_blend_chek = deblend_criteria(mu_arr=mu_arr,
+                                                sigma_arr=(w4_arr - w3_arr) / (n_sigma * 2),
+                                                Rayleigh_threshold=Rayleigh_threshold)
+        relation_list.append(obs_group_blend_chek)
+
+    group_dict = {}
+    for line_list, relation_list in zip(grouped_lines, relation_list):
+        group_dict.update(blend_merge_dict(line_list, relation_list))
+
+    group_dict = None if len(group_dict) == 0 else group_dict
+
+    return group_dict
+
+
 def groupify_lines_df(bands, fit_cfg, groups_dict, spec, save_group_label=False):
 
     # Containers for the requested changes
@@ -181,8 +279,11 @@ def groupify_lines_df(bands, fit_cfg, groups_dict, spec, save_group_label=False)
         # Extract the single components ignoring extra kinmatics
         unique_comp_list = []
         for trans in line.list_comps:
-            if trans.kinem == 0:
-                unique_comp_list.append(trans.label)
+            if trans.group == 'm':
+                unique_comp_list += [sub_comp.label for sub_comp in trans.list_comps]
+            else:
+                if trans.kinem == 0:
+                    unique_comp_list.append(trans.label)
         unique_comp_list = np.unique(unique_comp_list)
 
         # Only apply corrections if components are present

lime/tools.py

@@ -224,6 +224,7 @@ def normalize_fluxes(log, line_list=None, norm_list=None, flux_column='profile_f
         raise LiMe_Error(f'Input log is missing "{flux_column}" or "{flux_column}_err" columns')
 
     # Check the normalization for the lines
+    line_list = log.index.to_numpy() if line_list is None else line_list
     line_array, norm_array = check_lines_normalization(line_list, norm_list, log)
 
     # Add new columns if necessary

lime/workflow.py

@@ -228,10 +228,54 @@ def continuum_model_fit(x_array, y_array, idcs, degree):
 
 def res_power_approx(wavelength_arr):
 
+    """
+    Estimate the spectral resolving power R = λ / Δλ approximation for a wavelength array.
+
+    The dispersion per pixel (Δλ/pixel) is computed from the finite differences
+    of the wavelength array. The resolution element is assumed to be Nyquist-sampled
+    by 2 pixels, so the FWHM resolution element is 2 * (Δλ/pixel), giving:
+
+        R ≈ λ / (2 * Δλ_pixel)
+
+    Note: This is an approximation. The true R depends on the slit width,
+    detector sampling, and optical quality of the spectrograph. For precise
+    instrumental broadening estimates, an empirical LSF from arc/sky lines
+    is preferred.
+
+    Parameters
+    ----------
+    wavelength_arr : np.ndarray
+        1D array of wavelengths, assumed to be in a consistent unit (e.g. Å).
+        Must be monotonically increasing and uniformly or smoothly sampled.
+
+    Returns
+    -------
+    res_power : np.ndarray
+        1D array of resolving power R at each pixel, same shape as wavelength_arr.
+        Dimensionless.
+
+    Notes
+    -----
+    - The last pixel is extrapolated by repeating the second-to-last dispersion
+      value, since np.ediff1d produces N-1 differences for an N-element array.
+    - If the wavelength array has non-uniform sampling (e.g. from a non-linear
+      dispersion solution), R will vary across the array accordingly.
+    - Assumes 2 pixels per resolution element (Nyquist sampling). If your
+      spectrograph samples the LSF with a different number of pixels, replace
+      the factor of 2 with the appropriate value.
+
+    Examples
+    --------
+    >>> wave = np.linspace(4000, 7000, 3000)   # 1 Å/pixel
+    >>> R = res_power_approx(wave)
+    >>> print(R[0])   # expect ~2000 at 4000 Å with 1 Å/pixel dispersion
+    2000.0
+
+    """
+
     delta_lambda = np.ediff1d(wavelength_arr, to_end=0)
     delta_lambda[-1] = delta_lambda[-2]
-
-    return wavelength_arr/delta_lambda
+    return wavelength_arr / (2 * delta_lambda)
 
 
 
@@ -250,6 +294,120 @@ class SpecRetriever:
                     update_labels=False, update_latex=False, rejected_lines=None, Rayleigh_threshold=2, lines_redshift=None,
                     map_origin=None, components=None, save_group_label=False):
 
+        """
+        Return a bands dataframe with the spectral lines within the spectrum wavelength range.
+
+        If the user does not provide a ``ref_bands`` This method queries the `LiMe bands database <https://lime-stable.readthedocs.io/en/latest/inputs/n_inputs3_line_bands.html>`_
+        and returns a :class:`pandas.DataFrame` of transitions visible within the spectrum's observed
+        wavelength interval, taking into account the spectrum redshift, units, and pixel mask.
+
+        The central bands (``w3``–``w4``) are optionally adjusted to match the expected line width,
+        accounting for the emitting and/or absorbing medium velocity dispersion (``band_vsigma``) and instrumental broadening
+        (``instrumental_correction``). Lines whose central band falls entirely within a masked
+        pixel region can be excluded via ``exclude_bands_masked``.
+
+        If a fitting configuration (``fit_cfg``) is provided, blended or merged line groups are
+        resolved and the bands table is updated accordingly.
+
+        Parameters
+        ----------
+        band_vsigma : float, optional
+            Velocity sigma in km/s used to set the half-width of the central band (``w3``–``w4``).
+            Default is ``70``.
+        n_sigma : int, optional
+            Number of sigma used to compute the band half-width from ``band_vsigma``. Default is ``4``.
+        adjust_central_band : bool, optional
+            If ``True`` (default), recompute ``w3`` and ``w4`` from ``band_vsigma``, ``n_sigma``,
+            and the instrumental broadening.
+        instrumental_correction : bool, optional
+            If ``True`` (default), include the instrumental broadening (derived from ``res_power``)
+            when adjusting the central band width.
+        exclude_bands_masked : bool, optional
+            If ``True`` (default), remove lines whose central band pixels are entirely masked.
+        map_band_vsigma : dict, optional
+            Per-line overrides for ``band_vsigma``, keyed by line label. Lines not present in the
+            dict use the global ``band_vsigma`` value.
+        grouped_lines : dict, optional
+            Explicit line grouping definitions. If ``None``, grouping is read from ``fit_cfg`` if
+            available.
+        automatic_grouping : bool, optional
+            If ``True``, automatically decide the blended or merged line groups which match the observation. Default is ``False``.
+        fit_cfg : dict or str or pathlib.Path, optional
+            Fitting configuration. Can be a dictionary or a path to a configuration file. When
+            provided, grouped lines and rejected lines are read from this configuration unless
+            explicitly overridden.
+        default_cfg_prefix : str, optional
+            Prefix for default parameter entries in ``fit_cfg``. Default is ``"default"``.
+        obj_cfg_prefix : str, optional
+            Prefix for object-specific parameter entries in ``fit_cfg``. Default is ``None``.
+        update_default : bool, optional
+            If ``True`` (default), object-specific configuration entries override default entries.
+        line_list : list or numpy.ndarray, optional
+            Restrict the output to these line labels. Must follow
+            `LiMe notation <https://lime-stable.readthedocs.io/en/latest/inputs/n_inputs2_line_labels.html>`_.
+        particle_list : list or numpy.ndarray, optional
+            Restrict the output to transitions from these ionic species (e.g. ``["H1", "O3"]``).
+        sig_digits : int, optional
+            Number of decimal figures in the line labels. Default is ``4``.
+        ref_bands : pandas.DataFrame, str, or pathlib.Path, optional
+            Alternative reference bands database. Defaults to the internal LiMe database.
+        vacuum_waves : bool, optional
+            If ``True``, convert wavelengths and band limits to vacuum values. Default is ``False``.
+        update_labels : bool, optional
+            If ``True``, recompute line labels from the transition data. Default is ``False``.
+        update_latex : bool, optional
+            If ``True``, recompute the ``latex_label`` column. Default is ``False``.
+        rejected_lines : list, optional
+            Line labels to exclude from the output. If ``None``, falls back to the value in
+            ``fit_cfg`` if present.
+        Rayleigh_threshold : float, optional
+            Minimum wavelength separation (in units of ``band_vsigma``) below which two lines
+            are considered blended via Rayleigh's criterion. Default is ``2``.
+        lines_redshift : float, optional
+            Redshift applied to the transition wavelengths when adjusting the central band, if
+            no per-line ``z_line`` column is present in the bands table. Falls back to the
+            spectrum redshift if ``None``.
+        map_origin : dict, optional
+            Mapping of origin labels to redshifts for multi-origin line queries.
+        components : list, optional
+            List of spectral shape components (e.g. ``["emission", "absorption"]``) used to
+            filter lines by the predicted profile type from the feature detection algorithm.
+            Requires ``spec.infer.pred_arr`` to have been computed beforehand.
+        save_group_label : bool, optional
+            If ``True``, store the group label in the bands table for grouped lines. Default is
+            ``False``.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Bands dataframe with one row per transition, indexed by line label, containing
+            wavelength, band limits (``w1``–``w6``), and metadata columns.
+
+        Notes
+        -----
+        - If ``res_power`` is not set on the spectrum, an approximate resolving power is
+          computed from the wavelength array when ``instrumental_correction=True`` or
+          ``fit_cfg`` is provided.
+        - ``components`` filtering requires the aspect package and a prior call to the
+          component detection algorithm; a :exc:`LiMe_Error` is raised otherwise.
+        - Per-line redshifts in a ``z_line`` column (added by ``map_origin``) take precedence
+          over ``lines_redshift`` and the spectrum redshift when adjusting central bands.
+
+        Examples
+        --------
+        Get all lines in the spectrum wavelength range:
+
+        >>> bands = spec.fit.lines_frame()
+
+        Restrict to hydrogen and oxygen transitions with a wider velocity band:
+
+        >>> bands = spec.fit.lines_frame(particle_list=["H1", "O3"], band_vsigma=120)
+
+        Use a fitting configuration to resolve blended lines:
+
+        >>> bands = spec.fit.lines_frame(fit_cfg="my_cfg.toml")
+        """
+
 
         # Remove the mask from the wavelength array if necessary
         wave_intvl = self._spec.wave.compressed()
@@ -258,6 +416,7 @@ class SpecRetriever:
         in_cfg = check_fit_conf(fit_cfg, default_cfg_prefix, obj_cfg_prefix, update_default) if fit_cfg else None
 
         # Generate the table of single lines taking into account possible origins
+        rejected_lines = rejected_lines if rejected_lines is not None else (in_cfg or {}).get('rejected_lines')
         bands = multi_origin_lines_frame(map_origin, line_list, self._spec.redshift, wave_intvl=wave_intvl,
                                          particle_list=particle_list, units_wave=self._spec.units_wave,
                                          sig_digits=sig_digits, ref_bands=ref_bands, vacuum_waves=vacuum_waves,
@@ -302,7 +461,6 @@ class SpecRetriever:
                 delta_lambda_inst = 0
 
             # Use unique or specific velocity sigma for the bands
-            # map_band_vsigma = in_cfg['map_band_vsigma'] if in_cfg and ('map_band_vsigma' in in_cfg) else map_band_vsigma
             map_band_vsigma = map_band_vsigma if map_band_vsigma else (in_cfg or {}).get('map_band_vsigma')
 
             if map_band_vsigma is not None:
@@ -363,7 +521,6 @@ class SpecRetriever:
 
         return bands
 
-
     def spectrum(self, redshift=None, norm_flux=None, crop_waves=None, crop_flux=None, pixel_mask=None, mask_intvls=None,
                  obj_redshift=False,):
 

{lime_stable-2.2.dev2.dist-info → lime_stable-2.2.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.2.dev2
+Version: 2.2.dev5
 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.7.dev1; extra == "full"
+Requires-Dist: aspect-stable~=0.7.dev2; 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.2.dev2.dist-info → lime_stable-2.2.dev5.dist-info}/RECORD

@@ -1,26 +1,26 @@
 lime/__init__.py,sha256=oTUSuAwbROsVVLsPKzeUEIVYhJyTN4Rgqqz_G13qFnk,1099
 lime/changelog.txt,sha256=XUYFC9rr23PVBkFAICOG3aljHS2Dh9-6zgF_hSNIbdE,10615
 lime/io.py,sha256=xLYMDfdFR2cjfcWwqwnTldH3NoIvsQnAcwhjpjbfWTY,36199
-lime/lime.toml,sha256=tq4a2HKg71VUbkoGbBovO_16jdOTPPJaDp9P03FcuWM,2309
-lime/observations.py,sha256=k6a3CNklAXn-UO5zLQSfGC_v0KjwsnTkQgUQdrNg4MA,98114
+lime/lime.toml,sha256=QYPXHds95MbDPyDtNfgIHNgSUw0xml0-8cTYqQhxriQ,2309
+lime/observations.py,sha256=o0P97ZYPUL-ht6BYqrEdPSz9wNifE1CZw40bda92Y_U,98652
 lime/rsrc_manager.py,sha256=lTy6byVCoV-Dc43tq5stmocufvPr8gp5cpLmD25FzR8,70
-lime/tools.py,sha256=PXgspRmRiF6z4n3Ii0XIxNJir_D5JLnwITQR00DnqOM,39574
+lime/tools.py,sha256=7DCI-97iueiR4mkB30aFk_XU6AjbKL1AGO8Cx3pWKbk,39647
 lime/transitions.py,sha256=RSkvpWbuA4k5eUZV5RV7J2wsjl5HrQDN14C9h_Ipfik,81433
-lime/workflow.py,sha256=fhOsC1BmWh9NCxiChjHQ35ZVeonzmDmlP4bKSkanj08,71208
+lime/workflow.py,sha256=DQSK18AX5gBp_tRmaFyw8oCC1EHUcUsJEPGUCNv9ZdM,79624
 lime/archives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/archives/read_fits.py,sha256=C6xvZBJd7hKlw0CmZs021vFocGcxTNEgQPV7RBx_beo,50164
+lime/archives/read_fits.py,sha256=rPSym_ooPFqxHpvWApTUEk8gOZXZI-aI3JSpbE92maI,49622
 lime/archives/tables.py,sha256=j8axa1FvxOCZYaJE69JJVTOOp4OXlEKdx-m3GhOMFM0,14254
 lime/fitting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/fitting/lines.py,sha256=ZVJtYRiCLUgynU0OEC9JzxDKZcjfYg_Px_X9HOTMnmg,49597
+lime/fitting/lines.py,sha256=NxbkLOoduX_nqGzC7ovQcj5ElSfVTSAyaNVZB7OF2h4,49644
 lime/fitting/redshift.py,sha256=mzo81MOZScQBsk-XSkVo4Y7lLjU9sV10PAaw9IMBRJo,12366
 lime/inference/detection.py,sha256=evcDl9GfHYo6Zfa0c3L9WA47i-0TEE2JRzH-UZp8zqg,841
 lime/inference/intensity_threshold.py,sha256=Qnax2rimu6yga-4rAgB_AE6TFxqoRp7vChaYM83GQGQ,5308
 lime/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/plotting/bokeh_plots.py,sha256=EwqyHArAuX43bQK3ggZosWGNSsAD9B4n6g6KBofXUAE,29853
-lime/plotting/format.py,sha256=40RL7s8yVt91ZhjDgKH-v-cYC2meE5uRTIwhgOBzKOU,7574
+lime/plotting/bokeh_plots.py,sha256=HUYjMvLr90vpV5d4zeHgzvcG0Uv1NzAa36XayyK8_Z8,33019
+lime/plotting/format.py,sha256=Y85t6ah-MVWW4cJIsxsT2RUANlZ9QLal-Bk9SofdipM,7414
 lime/plotting/plots.py,sha256=L_iy_M2g5E9NgbozhQkKDN9zaKIn4Q8BoNIjAoKkjuE,109861
 lime/plotting/plots_interactive.py,sha256=H1NQpaAjoIAgpbPYrRGYvo-mpKHB8MQ8VF8vvWNtcjA,53873
-lime/plotting/theme_lime.toml,sha256=X6j8M2d42xDkjXK8iODrFBHuCRIQJpJ995t6FVs0XfY,3939
+lime/plotting/theme_lime.toml,sha256=tuc2nG4vazYXF56-YBizhgJCz1GEUHOgb21WUb_gMAs,3933
 lime/plotting/utils.py,sha256=n8NYheQ_E__aJOxlgm-4Yn6BzJBlfCanBqW17dHiIHw,2203
 lime/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lime/resources/generator_db.py,sha256=JZnVx_BEWsxldKnB7y79jGiQILg7M89Wyy5PktvBqvo,5939
@@ -29,9 +29,9 @@ lime/resources/lines_database_v2.0.0.txt,sha256=kcE9lxsl4NEh_Gs0Jo65r9UW1k9JlfYD
 lime/resources/lines_database_v2.0.6.txt,sha256=iEQEjQSd0LFtpnb_4bmH2A0BzcTPLXsmNZbVlWt3o-U,71831
 lime/resources/types_params.txt,sha256=X2-KQhRQLKLnO4kP3olndfLEUEi5gn7dFA73BcM1mls,10237
 lime/retrieve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/retrieve/line_bands.py,sha256=-1XZuYgtj6UrnD-rJW5GwcYYvADwMg_LDD8gVHoSyPU,13014
-lime_stable-2.2.dev2.dist-info/licenses/LICENSE.rst,sha256=seOLF7CWBhO2ouy8K_seWP3undpeEXppbpb7lYgH5vg,35413
-lime_stable-2.2.dev2.dist-info/METADATA,sha256=aKOtU4E-C--WYuqRPD24pW0M56DRdQQxorzwNJgj7Io,3830
-lime_stable-2.2.dev2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-lime_stable-2.2.dev2.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
-lime_stable-2.2.dev2.dist-info/RECORD,,
+lime/retrieve/line_bands.py,sha256=s4QfruLbYiliVl0jT2d_PIBcBDjg7skh5w-1lV1HdKM,17046
+lime_stable-2.2.dev5.dist-info/licenses/LICENSE.rst,sha256=seOLF7CWBhO2ouy8K_seWP3undpeEXppbpb7lYgH5vg,35413
+lime_stable-2.2.dev5.dist-info/METADATA,sha256=YaOfuSxRwG0AdlU1tk6MDQOGWcfi2-hmoEusE2aE7Ek,3830
+lime_stable-2.2.dev5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lime_stable-2.2.dev5.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
+lime_stable-2.2.dev5.dist-info/RECORD,,