lime-stable 2.2.dev1__tar.gz → 2.2.dev5__tar.gz

{lime_stable-2.2.dev1 → lime_stable-2.2.dev5}/MANIFEST.in

@@ -3,4 +3,4 @@ include src/lime/changelog.txt
 include src/lime/plotting/theme_lime.toml
 include src/lime/resources/parent_mask.txt
 include src/lime/resources/types_params.txt
-include src/lime/resources/lines_database_v2.0.0.txt
+include src/lime/resources/lines_database_v2.0.6.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.2.dev1
+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.dev1 → lime_stable-2.2.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.2.dev1"
+version = "2.2.dev5"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 license = {text = "GPL-3.0-or-later"}
@@ -24,7 +24,7 @@ dependencies = ["astropy~=7.1",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "aspect-stable~=0.7.dev1",
+        "aspect-stable~=0.7.dev2",
         "bokeh~=3.8",
         "mplcursors~=0.6",
         "openpyxl~=3.1",

{lime_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/lime/lime.toml

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

{lime_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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_stable-2.2.dev1 → lime_stable-2.2.dev5}/src/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'