lime-stable 2.0.dev6__tar.gz → 2.0.dev8__tar.gz

{lime_stable-2.0.dev6/src/lime_stable.egg-info → lime_stable-2.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev6
+Version: 2.0.dev8
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.dev6"
+version = "2.0.dev8"
 readme = "README.rst"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/archives/read_fits.py

@@ -257,35 +257,44 @@ def check_fits_instructions(fits_source, online_provider=False):
     else:
         fits_reader = None
 
-    # # Check for url location for surveys function
-    # if online_provider:
-    #     if hasattr(UrlFitsSurvey, fits_source):
-    #         url_locator = getattr(UrlFitsSurvey, fits_source)
-    #     else:
-    #         raise LiMe_Error(f'Input {fits_source} does not have a url manager for LiMe could not be created.')
-    # else:
-    #     url_locator = None
-
     return fits_reader
 
-def load_txt(text_address):
+def load_txt(text_address, **kwargs):
 
     # Columns
-    out_array = np.loadtxt(text_address)
+    out_array = np.loadtxt(text_address, **kwargs)
 
-    # Transform foot comments as dictionary data
-    params_dict = {}
-    with open(text_address, "r") as f:
+    # File address
+    if not type(text_address).__name__ == "UploadedFile":
+        with open(text_address, "r") as f:
+            lines = f.readlines()
 
-        # 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
+    # Uploaded file
+    else:
+        lines = text_address.getvalue().decode("utf-8").splitlines()
 
-            # Extract key-value pairs
-            key, value = line[1:].split(":", 1)  # Split at the first ':'
-            params_dict[key.strip()] = value.strip()
+    # Reverse loop over the lines
+    params_dict = {}
+    for line in reversed(lines):
+        line = line.strip()
+        if not line.startswith("#") or line.startswith("# LiMe"):
+            break
+        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
 
@@ -362,10 +371,10 @@ class OpenFits:
 
         return
 
-    def parse_data_from_file(self, file_address, pixel_mask=None):
+    def parse_data_from_file(self, file_address, pixel_mask, **kwargs):
 
         # Read the fits data
-        wave_array, flux_array, err_array, header_list, fits_params = self.fits_reader(file_address)
+        wave_array, flux_array, err_array, header_list, fits_params = self.fits_reader(file_address, **kwargs)
         pixel_mask = pixel_mask if pixel_mask is not None else fits_params['pixel_mask']
 
         # Mask requested entries
@@ -441,10 +450,10 @@ class OpenFits:
         return fits_args
 
     @staticmethod
-    def text(file_address):
+    def text(file_address, **kwargs):
 
         # Read text file dividing the columns into the spectrum axis and the comments as its parameters
-        data_arr, params_dict = load_txt(file_address)
+        data_arr, params_dict = load_txt(file_address, **kwargs)
 
         # Unpack the columns into the spectrum axes
         wave_array, flux_array = data_arr[:, 0], data_arr[:, 1]
@@ -456,16 +465,13 @@ class OpenFits:
         # Convert strings to expected format
         params_dict['redshift'] = float(params_dict['redshift']) if 'redshift' in params_dict else None
         params_dict['norm_flux'] = float(params_dict['norm_flux']) if 'norm_flux' in params_dict else None
-        params_dict['id_label'] = params_dict['id_label'] if 'norm_flux' in params_dict else None
+        params_dict['id_label'] = params_dict['id_label'] if 'id_label' in params_dict else None
         params_dict['pixel_mask'] = mask_array
 
-        # metadata['units_wave'] = au.Unit(metadata['units_wave']) if 'units_wave' in metadata else au.Unit('AA')
-        # metadata['units_flux'] = au.Unit(metadata['units_flux']) if 'units_flux' in metadata else au.Unit('FLAM')
-
         return wave_array, flux_array, err_array, None, params_dict
 
     @staticmethod
-    def nirspec(fits_address, data_ext_list=1, hdr_ext_list=(0, 1), pixel_mask=None):
+    def nirspec(fits_address, data_ext_list=1, hdr_ext_list=(0, 1), **kwargs):
 
         """
 
@@ -503,7 +509,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def isis(fits_address, data_ext_list=0, hdr_ext_list=0, pixel_mask=None):
+    def isis(fits_address, data_ext_list=0, hdr_ext_list=0, **kwargs):
 
         """
 
@@ -548,7 +554,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def osiris(fits_address, data_ext_list=0, hdr_ext_list=0, pixel_mask=None):
+    def osiris(fits_address, data_ext_list=0, hdr_ext_list=0, **kwargs):
 
         """
 
@@ -593,7 +599,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def sdss(fits_address, data_ext_list=(1, 2), hdr_ext_list=(0), pixel_mask=None):
+    def sdss(fits_address, data_ext_list=(1, 2), hdr_ext_list=(0), **kwargs):
 
         """
 
@@ -645,7 +651,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def manga(fits_address, data_ext_list=('WAVE', 'FLUX', 'IVAR'), hdr_ext_list=('FLUX'), pixel_mask=None):
+    def manga(fits_address, data_ext_list=('WAVE', 'FLUX', 'IVAR'), hdr_ext_list=('FLUX'), **kwargs):
 
         """
 
@@ -692,7 +698,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def muse(fits_address, data_ext_list=(1, 2), hdr_ext_list=1, pixel_mask=None):
+    def muse(fits_address, data_ext_list=(1, 2), hdr_ext_list=1, **kwargs):
 
         """
 
@@ -737,7 +743,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def megara(fits_address, data_ext_list=0, hdr_ext_list=(0, 1), pixel_mask=None):
+    def megara(fits_address, data_ext_list=0, hdr_ext_list=(0, 1), **kwargs):
 
         """
 
@@ -781,7 +787,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def miri(fits_address, data_ext_list=(1,2), hdr_ext_list=(1), pixel_mask=None):
+    def miri(fits_address, data_ext_list=(1,2), hdr_ext_list=(1), **kwargs):
 
         """
 

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/fitting/lines.py

@@ -608,7 +608,6 @@ class ProfileModelCompiler:
                 line.eqw = np.full(self.n_comps, np.nan)
                 line.eqw_err = np.full(self.n_comps, np.nan)
                 line.FWHM_p = np.full(self.n_comps, np.nan)
-                # line.sigma_thermal = np.full(self.n_comps, np.nan)
 
             # Check for negative -0.0 # TODO this needs a better place # FIXME -0.0 error
             if np.signbit(line.sigma_err[i]):
@@ -825,12 +824,6 @@ class LineFitting:
         line.intg_flux = areasArray.mean()
         line.intg_flux_err = areasArray.std()
 
-        # # Compute the integrated signal to noise # TODO is this an issue for absorptions
-        # amp_ref = line.peak_flux - line.cont
-        # if emission_check:
-        #     if amp_ref < 0:
-        #         amp_ref = line.peak_flux
-
         # Compute SN_r
         line.snr_line = signal_to_noise_rola(line.peak_flux - line.cont, line.cont_err, line.n_pixels)
         line.snr_cont = line.cont/line.cont_err
@@ -842,20 +835,14 @@ class LineFitting:
         else:
             line._narrow_check = False
 
-        # # Line width to the pixel below the continuum (or mask size if not happening) # TODO Lime2.0 skip all this if narrow
-        # idx_0 = compute_FWHM0(peakIdx, emis_flux, -1, cont_arr, emission_check)
-        # idx_f = compute_FWHM0(peakIdx, emis_flux, 1, cont_arr, emission_check)
-        #
-        # # Velocity calculations
-        # velocArray = c_KMpS * (emis_wave[idx_0:idx_f] - line.peak_wave) / line.peak_wave
-        # self.velocity_profile_calc(line, velocArray, emis_flux[idx_0:idx_f], cont_arr[idx_0:idx_f], emission_check)
+        # Velocity calculations
         if (line.n_pixels >= min_array_dim) and (line._narrow_check is False):
             self.velocity_profile_calc(line, peakIdx, emis_wave, emis_flux, cont_arr, emission_check, min_array_dim=min_array_dim)
 
         # Pixel velocity # TODO we are not using this one
         line.pixel_vel = c_KMpS * line.pixelWidth/line.peak_wave
 
-        # Equivalent width computation (it must be an 1d array to avoid conflict in blended lines) # TODO Lime2.0 put all this on its function
+        # Equivalent width computation (it must be an 1d array to avoid conflict in blended lines)
         lineContinuumMatrix = cont_arr + normalNoise
         eqwMatrix = areasArray / lineContinuumMatrix.mean(axis=1)
 

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/io.py

@@ -569,10 +569,13 @@ def results_to_log(line, log, norm_flux):
 
             # Converting None entries to str (9 = group_label)
             if j == 9:
+
                 if param_value is None:
                     param_value = 'none'
 
-            # print(comp, param, param_value)
+                if line.sub_comps[i] is not None:
+                    param_value = line.sub_comps[i].group_label
+
             log.at[comp, param] = param_value
 
     return

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/lime.toml

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

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/observations.py

@@ -411,7 +411,8 @@ class Spectrum:
         return spec
 
     @classmethod
-    def from_file(cls, file_address, instrument, mask_flux_entries=None, **kwargs):
+    def from_file(cls, file_address, instrument, redshift=None, norm_flux=None, crop_waves=None, res_power=None,
+                  units_wave=None, units_flux=None, pixel_mask=None, id_label=None, wcs=None, **kwargs):
 
         """
 
@@ -446,13 +447,19 @@ class Spectrum:
         cls._fitsMgr = OpenFits(file_address, instrument, cls.__name__)
 
         # Load the scientific data from the file
-        fits_args = cls._fitsMgr.parse_data_from_file(cls._fitsMgr.file_address, mask_flux_entries)
+        fits_args = cls._fitsMgr.parse_data_from_file(cls._fitsMgr.file_address, pixel_mask, **kwargs)
 
-        # Update the parameters file parameters with the user parameters
-        obs_args = {**fits_args, **kwargs}
+        # Update the file parameters with the user parameters
+        input_args = dict(redshift=redshift, norm_flux=norm_flux, crop_waves=crop_waves, res_power=res_power,
+                            units_wave=units_wave, units_flux=units_flux, id_label=id_label, wcs=wcs)
+
+        if cls._fitsMgr.spectrum_check:
+            input_args.pop('wcs')
+
+        input_args = {**fits_args, **{k: v for k, v in input_args.items() if v is not None}}
 
         # Create the LiMe object
-        return cls(**obs_args)
+        return cls(**input_args)
 
     @classmethod
     def from_survey(cls, target_id, survey, mask_flux_entries=None, **kwargs):

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/plotting/bokeh_plots.py

@@ -117,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,
@@ -186,7 +195,7 @@ class BokehFigures:
 
         return
 
-    def bands(self, label, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, log_scale=True,
+    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):
 
 
@@ -198,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:

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/plotting/plots.py

@@ -657,9 +657,10 @@ 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, show_central=True):
+def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=True, color_dict=theme.colors, show_central=True):
 
     # Security check for low selection
+    # TODO check this error crashing
     if y[idcs_mask[2]:idcs_mask[3]].size > 1:
 
         # Lower limit for the filled region
@@ -768,8 +769,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_cfg=None, instrumental_correction=False,
-                                                   adjust_central_band=False)
+        match_log = check_file_dataframe(bands)
+
         # Compute bands limits
         w3 = match_log.w3.values * (1 + redshift)
         w4 = match_log.w4.values * (1 + redshift)
@@ -1008,43 +1009,6 @@ 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.')
-
             # Show components
             if show_categories and self._spec.infer.pred_arr is not None:
 
@@ -1269,8 +1233,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=False):
+    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):
 
         """
 
@@ -1327,7 +1291,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):
@@ -1372,13 +1336,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_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/lime/plotting/plots_interactive.py

@@ -1536,7 +1536,7 @@ class CubeInspection:
             self._ax0.set_ylim(self.axlim_dict['image_ylim'])
             self._ax1.set_xlim(self.axlim_dict['spec_xlim'])
 
-            if not self.maintain_y_zoom:
+            if self.maintain_y_zoom:
                 self._ax1.set_ylim(self.axlim_dict['spec_ylim'])
 
         else:

{lime_stable-2.0.dev6 → lime_stable-2.0.dev8}/src/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())