masster 0.5.10__tar.gz → 0.5.11__tar.gz

{masster-0.5.10 → masster-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.5.10
+Version: 0.5.11
 Summary: Mass spectrometry data analysis package
 Project-URL: homepage, https://github.com/zamboni-lab/masster
 Project-URL: repository, https://github.com/zamboni-lab/masster

{masster-0.5.10 → masster-0.5.11}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "masster"
-version = "0.5.10"
+version = "0.5.11"
 description = "Mass spectrometry data analysis package"
 authors = [
     { name = "Zamboni Lab" }

{masster-0.5.10 → masster-0.5.11}/src/masster/_version.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 
-__version__ = "0.5.10"
+__version__ = "0.5.11"
 
 
 def get_version():

{masster-0.5.10 → masster-0.5.11}/src/masster/sample/plot.py

@@ -1041,7 +1041,9 @@ def plot_2d(
     height=600,
     width=750,
     mz_range=None,
-    rt_range=None
+    rt_range=None,
+    legend=None,
+    colorby=None
 ):
     """
     Plot a two-dimensional visualization of MS1 survey scan data with optional overlays
@@ -1087,6 +1089,13 @@ def plot_2d(
             Maximum pixel size for dynamic rasterization when using dynspread.
         raster_threshold (float, default 0.8):
             Threshold used for the dynspread process in dynamic rasterization.
+        legend (str, optional): 
+            Legend position for categorical feature coloring ("top_right", "bottom_left", etc.) or None.
+            Only applies when colorby is not None and contains categorical data.
+        colorby (str, optional):
+            Feature property to use for coloring. If None (default), uses current green/red scheme
+            for features with/without MS2 data. If specified and contains categorical data, applies
+            categorical coloring with legend support (similar to plot_2d_oracle).
     Behavior:
         - Checks for a loaded mzML file by verifying that self.file_obj is not None.
         - Converts internal MS1 data (a Polars DataFrame) to a Pandas DataFrame and filters out low-intensity
@@ -1203,6 +1212,12 @@ def plot_2d(
 
     color_1 = "forestgreen"
     color_2 = "darkorange"
+    
+    # Handle colorby parameter for feature coloring
+    use_categorical_coloring = False
+    feature_colors = {}
+    categorical_groups = []
+    
     if filename is not None:
         dyn = False
         if not filename.endswith(".html"):
@@ -1270,74 +1285,203 @@ def plot_2d(
             feats = feats[(feats["rt"] >= rt_range[0]) & (feats["rt"] <= rt_range[1])]
         # keep only iso==0, i.e. the main
         feats = feats[feats["iso"] == 0]
-        # find features with ms2_scans not None  and iso==0
-        features_df = feats[feats["ms2_scans"].notnull()]
-        # Create feature points with proper sizing method
-        feature_hover_1 = HoverTool(
-            tooltips=[
-                ("rt", "@rt"),
-                ("m/z", "@mz{0.0000}"),
-                ("feature_uid", "@feature_uid"),
-                ("inty", "@inty"),
-                ("iso", "@iso"),
-                ("adduct", "@adduct"),
-                ("chrom_coherence", "@chrom_coherence"),
-                ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
-            ],
-        )
-        feature_points_1 = hv.Points(
-            features_df,
-            kdims=["rt", "mz"],
-            vdims=[
-                "feature_uid",
-                "inty",
-                "iso",
-                "adduct",
-                "ms2_scans",
-                "chrom_coherence",
-                "chrom_prominence_scaled",
-            ],
-            label="Features with MS2 data",
-        ).options(
-            color=color_1,
-            marker=marker_type,
-            size=size_1,
-            tools=[feature_hover_1],
-            hooks=hooks,
-        )
-        # find features without MS2 data
-        features_df = feats[feats["ms2_scans"].isnull()]
-        feature_hover_2 = HoverTool(
-            tooltips=[
-                ("rt", "@rt"),
-                ("m/z", "@mz{0.0000}"),
-                ("feature_uid", "@feature_uid"),
-                ("inty", "@inty"),
-                ("iso", "@iso"),
-                ("adduct", "@adduct"),
-                ("chrom_coherence", "@chrom_coherence"),
-                ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
-            ],
-        )
-        feature_points_2 = hv.Points(
-            features_df,
-            kdims=["rt", "mz"],
-            vdims=[
-                "feature_uid",
-                "inty",
-                "iso",
-                "adduct",
-                "chrom_coherence",
-                "chrom_prominence_scaled",
-            ],
-            label="Features without MS2 data",
-        ).options(
-            color="red",
-            marker=marker_type,
-            size=size_2,
-            tools=[feature_hover_2],
-            hooks=hooks,
-        )
+
+        # Handle colorby parameter
+        if colorby is not None and colorby in feats.columns:
+            # Check if colorby data is categorical (string-like)
+            colorby_values = feats[colorby].dropna()
+            is_categorical = (
+                feats[colorby].dtype in ["object", "string", "category"] or
+                (len(colorby_values) > 0 and isinstance(colorby_values.iloc[0], str))
+            )
+            
+            if is_categorical:
+                use_categorical_coloring = True
+                # Get unique categories, sorted
+                categorical_groups = sorted(feats[colorby].dropna().unique())
+                
+                # Set up colors for categorical data using matplotlib colormap
+                from matplotlib.colors import to_hex
+                try:
+                    from matplotlib.cm import get_cmap
+                    colormap_func = get_cmap(cmap if cmap != 'iridescent' else 'tab20')
+                    feature_colors = {}
+                    for i, group in enumerate(categorical_groups):
+                        if len(categorical_groups) <= 20:
+                            # Use qualitative colors for small number of categories
+                            color_val = colormap_func(i / max(1, len(categorical_groups) - 1))
+                        else:
+                            # Use continuous colormap for many categories
+                            color_val = colormap_func(i / max(1, len(categorical_groups) - 1))
+                        feature_colors[group] = to_hex(color_val)
+                except Exception as e:
+                    self.logger.warning(f"Could not set up categorical coloring: {e}, using default colors")
+                    use_categorical_coloring = False
+
+        if use_categorical_coloring and colorby is not None:
+            # Create separate feature points for each category
+            for i, group in enumerate(categorical_groups):
+                group_features = feats[feats[colorby] == group]
+                if len(group_features) == 0:
+                    continue
+                    
+                # Split by MS2 status
+                group_with_ms2 = group_features[group_features["ms2_scans"].notnull()]
+                group_without_ms2 = group_features[group_features["ms2_scans"].isnull()]
+                
+                group_color = feature_colors.get(group, color_1)
+                
+                if len(group_with_ms2) > 0:
+                    feature_hover = HoverTool(
+                        tooltips=[
+                            ("rt", "@rt"),
+                            ("m/z", "@mz{0.0000}"),
+                            ("feature_uid", "@feature_uid"),
+                            ("inty", "@inty"),
+                            ("iso", "@iso"),
+                            ("adduct", "@adduct"),
+                            ("chrom_coherence", "@chrom_coherence"),
+                            ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
+                            (colorby, f"@{colorby}"),
+                        ],
+                    )
+                    group_points_ms2 = hv.Points(
+                        group_with_ms2,
+                        kdims=["rt", "mz"],
+                        vdims=[
+                            "feature_uid",
+                            "inty",
+                            "iso",
+                            "adduct",
+                            "ms2_scans",
+                            "chrom_coherence",
+                            "chrom_prominence_scaled",
+                            colorby,
+                        ],
+                        label=f"{group} (MS2)",
+                    ).options(
+                        color=group_color,
+                        marker=marker_type,
+                        size=size_1,
+                        tools=[feature_hover],
+                        hooks=hooks,
+                    )
+                    if feature_points_1 is None:
+                        feature_points_1 = group_points_ms2
+                    else:
+                        feature_points_1 = feature_points_1 * group_points_ms2
+                        
+                if len(group_without_ms2) > 0:
+                    feature_hover = HoverTool(
+                        tooltips=[
+                            ("rt", "@rt"),
+                            ("m/z", "@mz{0.0000}"),
+                            ("feature_uid", "@feature_uid"),
+                            ("inty", "@inty"),
+                            ("iso", "@iso"),
+                            ("adduct", "@adduct"),
+                            ("chrom_coherence", "@chrom_coherence"),
+                            ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
+                            (colorby, f"@{colorby}"),
+                        ],
+                    )
+                    group_points_no_ms2 = hv.Points(
+                        group_without_ms2,
+                        kdims=["rt", "mz"],
+                        vdims=[
+                            "feature_uid",
+                            "inty",
+                            "iso",
+                            "adduct",
+                            "chrom_coherence",
+                            "chrom_prominence_scaled",
+                            colorby,
+                        ],
+                        label=f"{group} (no MS2)",
+                    ).options(
+                        color=group_color,
+                        marker=marker_type,
+                        size=size_2,
+                        tools=[feature_hover],
+                        hooks=hooks,
+                    )
+                    if feature_points_2 is None:
+                        feature_points_2 = group_points_no_ms2
+                    else:
+                        feature_points_2 = feature_points_2 * group_points_no_ms2
+        else:
+            # Use original green/red coloring scheme for MS2 presence
+            # find features with ms2_scans not None  and iso==0
+            features_df = feats[feats["ms2_scans"].notnull()]
+            # Create feature points with proper sizing method
+            feature_hover_1 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("m/z", "@mz{0.0000}"),
+                    ("feature_uid", "@feature_uid"),
+                    ("inty", "@inty"),
+                    ("iso", "@iso"),
+                    ("adduct", "@adduct"),
+                    ("chrom_coherence", "@chrom_coherence"),
+                    ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
+                ],
+            )
+            if len(features_df) > 0:
+                feature_points_1 = hv.Points(
+                    features_df,
+                    kdims=["rt", "mz"],
+                    vdims=[
+                        "feature_uid",
+                        "inty",
+                        "iso",
+                        "adduct",
+                        "ms2_scans",
+                        "chrom_coherence",
+                        "chrom_prominence_scaled",
+                    ],
+                    label="Features with MS2 data",
+                ).options(
+                    color=color_1,
+                    marker=marker_type,
+                    size=size_1,
+                    tools=[feature_hover_1],
+                    hooks=hooks,
+                )
+            
+            # find features without MS2 data
+            features_df = feats[feats["ms2_scans"].isnull()]
+            feature_hover_2 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("m/z", "@mz{0.0000}"),
+                    ("feature_uid", "@feature_uid"),
+                    ("inty", "@inty"),
+                    ("iso", "@iso"),
+                    ("adduct", "@adduct"),
+                    ("chrom_coherence", "@chrom_coherence"),
+                    ("chrom_prominence_scaled", "@chrom_prominence_scaled"),
+                ],
+            )
+            if len(features_df) > 0:
+                feature_points_2 = hv.Points(
+                    features_df,
+                    kdims=["rt", "mz"],
+                    vdims=[
+                        "feature_uid",
+                        "inty",
+                        "iso",
+                        "adduct",
+                        "chrom_coherence",
+                        "chrom_prominence_scaled",
+                    ],
+                    label="Features without MS2 data",
+                ).options(
+                    color="red",
+                    marker=marker_type,
+                    size=size_2,
+                    tools=[feature_hover_2],
+                    hooks=hooks,
+                )
 
         if show_isotopes:
             # Use proper Polars filter syntax to avoid boolean indexing issues
@@ -1451,6 +1595,31 @@ def plot_2d(
     if title is not None:
         overlay = overlay.opts(title=title)
 
+    # Handle legend positioning for categorical coloring
+    if legend is not None and use_categorical_coloring and len(categorical_groups) > 1:
+        # Map legend position parameter to HoloViews legend position
+        legend_position_map = {
+            "top_right": "top_right",
+            "top_left": "top_left", 
+            "bottom_right": "bottom_right",
+            "bottom_left": "bottom_left",
+            "right": "right",
+            "left": "left",
+            "top": "top",
+            "bottom": "bottom"
+        }
+        
+        hv_legend_pos = legend_position_map.get(legend, "bottom_right")
+        
+        # Apply legend configuration to the overlay
+        overlay = overlay.opts(
+            legend_position=hv_legend_pos,
+            legend_opts={'title': '', 'padding': 2, 'spacing': 2}
+        )
+    elif legend is None and use_categorical_coloring:
+        # Explicitly hide legend when legend=None but categorical coloring is used
+        overlay = overlay.opts(show_legend=False)
+
     # Handle slider functionality
     if use_slider_sizing:
         # For slider functionality, we need to work with the feature points directly

{masster-0.5.10 → masster-0.5.11}/src/masster/study/export.py

@@ -496,7 +496,7 @@ def export_mgf(self, **kwargs):
             # Write END IONS
             f.write("END IONS\n\n")
 
-    self.logger.info(f"Exported {len(mgf_data)} spectra to {filename}")
+    self.logger.success(f"Exported {len(mgf_data)} spectra to {filename}")
 
 
 def export_mztab(self, filename: str | None = None, include_mgf=True, **kwargs) -> None:
@@ -1183,7 +1183,7 @@ def export_mztab(self, filename: str | None = None, include_mgf=True, **kwargs)
             for line in mgf_lines:
                 f.write(line + "\n")
 
-    self.logger.info(f"Exported mzTab-M to {filename}")
+    self.logger.success(f"Exported mzTab-M to {filename}")
 
 
 def export_xlsx(self, filename: str | None = None) -> None:
@@ -1311,7 +1311,7 @@ def export_xlsx(self, filename: str | None = None) -> None:
                     f"Written worksheet '{sheet_name}' with shape {data.shape}",
                 )
 
-        self.logger.info(f"Study exported to {filename}")
+        self.logger.success(f"Study exported to {filename}")
 
     except Exception as e:
         self.logger.error(f"Error writing Excel file: {e}")
@@ -1424,8 +1424,6 @@ def export_parquet(self, filename: str | None = None) -> None:
 
     # Report results
     if exported_files:
-        self.logger.info(f"Study exported to {len(exported_files)} Parquet files:")
-        for file_path in exported_files:
-            self.logger.info(f"  - {file_path}")
+        self.logger.success(f"Study exported to {len(exported_files)} Parquet files.")
     else:
         self.logger.error("No Parquet files were created - no data available to export")

{masster-0.5.10 → masster-0.5.11}/src/masster/study/h5.py

@@ -834,6 +834,19 @@ def _create_dataframe_with_objects(data: dict, object_columns: list) -> pl.DataF
     object_data = {k: v for k, v in data.items() if k in object_columns}
     regular_data = {k: v for k, v in data.items() if k not in object_columns}
 
+    # Final check: ensure no numpy object arrays in regular_data
+    problematic_cols = []
+    for k, v in regular_data.items():
+        if hasattr(v, 'dtype') and str(v.dtype) == 'object':
+            problematic_cols.append(k)
+    
+    if problematic_cols:
+        # Move these to object_data
+        for col in problematic_cols:
+            object_data[col] = _reconstruct_object_column(regular_data[col], col)
+            del regular_data[col]
+            object_columns.append(col)
+
     # Determine expected length from regular data or first object column
     expected_length = None
     if regular_data:
@@ -1185,9 +1198,29 @@ def _load_dataframe_from_group(
                 logger.debug(
                     f"Object column '{col}': length={len(data[col]) if data[col] is not None else 'None'}",
                 )
+        
+        # Debug: check for problematic data types in all columns before DataFrame creation
+        for col, values in data.items():
+            if hasattr(values, 'dtype') and str(values.dtype) == 'object':
+                logger.warning(f"Column '{col}' has numpy object dtype but is not in object_columns: {object_columns}")
+                if col not in object_columns:
+                    object_columns.append(col)
+        
         df = _create_dataframe_with_objects(data, object_columns)
     else:
-        df = pl.DataFrame(data)
+        # Debug: check for problematic data types when no object columns are expected
+        for col, values in data.items():
+            if hasattr(values, 'dtype') and str(values.dtype) == 'object':
+                logger.warning(f"Column '{col}' has numpy object dtype but no object_columns specified!")
+                # Treat as object column
+                if object_columns is None:
+                    object_columns = []
+                object_columns.append(col)
+        
+        if object_columns:
+            df = _create_dataframe_with_objects(data, object_columns)
+        else:
+            df = pl.DataFrame(data)
 
     # Clean null values and apply schema
     df = _clean_string_nulls(df)

{masster-0.5.10 → masster-0.5.11}/src/masster/study/helpers.py

@@ -2663,7 +2663,7 @@ def features_filter(
     removed_count = initial_count - final_count
     
     self.logger.info(
-        f"Filtered features: kept {final_count:,}, removed {removed_count:,}"
+        f"Filtered features. Kept: {final_count:,}. Removed: {removed_count:,}."
     )
 
 

{masster-0.5.10 → masster-0.5.11}/src/masster/study/merge.py

@@ -427,9 +427,13 @@ def merge(study, **kwargs) -> None:
         # Feature maps will be generated on-demand within each merge method
     
     study.logger.info(
-        f"Merge: {params.method}, samples={params.min_samples}, rt_tol={params.rt_tol}s, mz_tol={params.mz_tol}Da"
-    )
-    
+            f"Merging samples using {params.method}, min_samples={params.min_samples}, rt_tol={params.rt_tol}s, mz_tol={params.mz_tol}Da"
+        )
+    if "chunked" in params.method:
+        study.logger.info(
+            f"threads={params.threads}, chunk_size={params.chunk_size}, dechunking='{params.dechunking}'"
+        )
+        
     # Initialize    
     study.consensus_df = pl.DataFrame()
     study.consensus_ms2 = pl.DataFrame()
@@ -751,7 +755,7 @@ def _merge_kd_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
     
     else:
         # Parallel processing
-        study.logger.info(f"Processing chunks in parallel using {params.threads} processes")
+        #study.logger.info(f"Processing chunks in parallel using {params.threads} processes")
         
         # Prepare chunk data for parallel processing using features_df slices
         chunk_data_list = []
@@ -812,7 +816,7 @@ def _merge_kd_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
                         serialized_chunk_results.append((chunk_start_idx, consensus_features))
                         completed_chunks += 1
                         n_samples_in_chunk = len(chunk_data_list[chunk_idx]['chunk_samples_data'])
-                        study.logger.success(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
+                        study.logger.info(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
                     except Exception as exc:
                         # Check if this is a BrokenProcessPool exception from Windows multiprocessing issues
                         if isinstance(exc, BrokenProcessPool) or "process pool" in str(exc).lower():
@@ -846,7 +850,7 @@ def _merge_kd_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
                             serialized_chunk_results.append((chunk_start_idx, consensus_features))
                             completed_chunks += 1
                             n_samples_in_chunk = len(chunk_data_list[chunk_idx]['chunk_samples_data'])
-                            study.logger.success(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
+                            study.logger.info(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
                         except Exception as exc:
                             study.logger.error(f"Chunk {chunk_idx} generated an exception: {exc}")
                             raise exc
@@ -926,7 +930,7 @@ def _merge_qt_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
     
     else:
         # Parallel processing
-        study.logger.info(f"Processing chunks in parallel using {params.threads} processes")
+        #study.logger.info(f"Processing chunks in parallel using {params.threads} processes")
         
         # Prepare chunk data for parallel processing using features_df slices
         chunk_data_list = []
@@ -987,7 +991,7 @@ def _merge_qt_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
                         serialized_chunk_results.append((chunk_start_idx, consensus_features))
                         completed_chunks += 1
                         n_samples_in_chunk = len(chunk_data_list[chunk_idx]['chunk_samples_data'])
-                        study.logger.success(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
+                        study.logger.info(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
                     except Exception as exc:
                         # Check if this is a BrokenProcessPool exception from Windows multiprocessing issues
                         if isinstance(exc, BrokenProcessPool) or "process pool" in str(exc).lower():
@@ -1021,7 +1025,7 @@ def _merge_qt_chunked(study, params: merge_defaults, cached_adducts_df=None, cac
                             serialized_chunk_results.append((chunk_start_idx, consensus_features))
                             completed_chunks += 1
                             n_samples_in_chunk = len(chunk_data_list[chunk_idx]['chunk_samples_data'])
-                            study.logger.success(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
+                            study.logger.info(f"Completed chunk {completed_chunks}/{total_chunks} (samples {chunk_start_idx + 1}-{chunk_start_idx + n_samples_in_chunk})")
                         except Exception as exc:
                             study.logger.error(f"Chunk {chunk_idx} generated an exception: {exc}")
                             raise exc
@@ -2259,7 +2263,7 @@ def _perform_adduct_grouping(study, rt_tol, mz_tol):
             )
 
         # Use optimized adduct grouping
-        study.logger.info(f"About to call adduct grouping for {len(consensus_data)} consensus features")
+        #study.logger.info(f"About to call adduct grouping for {len(consensus_data)} consensus features")
         adduct_group_list, adduct_of_list = __merge_adduct_grouping(
             study, consensus_data, rt_tol/3, mz_tol
         )

{masster-0.5.10 → masster-0.5.11}/src/masster/study/processing.py

@@ -86,8 +86,6 @@ def align(self, **kwargs):
         self.logger.error(f"Unknown alignment algorithm '{algorithm}'")
         return
 
-    self.logger.success("Alignment completed.")
-
     # Reset consensus data structures after alignment since RT changes invalidate consensus
     consensus_reset_count = 0
     if not self.consensus_df.is_empty():
@@ -681,16 +679,15 @@ def _align_pose_clustering(study_obj, params):
     params_oms.setValue("pairfinder:distance_RT:exponent", 2.0)
 
     aligner = oms.MapAlignmentAlgorithmPoseClustering()
-    study_obj.logger.info("Starting alignment with PoseClustering")
+    study_obj.logger.info(
+        f"Align RTs with Pose clustering: rt_tol={params.get('rt_tol')}",
+    )
 
     # Set ref_index to feature map index with largest number of features
     ref_index = [
         i[0] for i in sorted(enumerate([fm.size() for fm in fmaps]), key=lambda x: x[1])
     ][-1]
-    study_obj.logger.debug(
-        f"Reference map is {study_obj.samples_df.row(ref_index, named=True)['sample_name']}",
-    )
-
+    
     aligner.setParameters(params_oms)
     aligner.setReference(fmaps[ref_index])
     study_obj.logger.debug(f"Parameters for alignment: {params}")
@@ -836,6 +833,12 @@ def _align_pose_clustering(study_obj, params):
     # Clean up temporary feature maps to release memory
     del fmaps
     study_obj.logger.debug("Temporary feature maps deleted to release memory")
+    
+    # Resolve reference sample UID from the reference index
+    ref_sample_uid = sample_uid_lookup.get(ref_index)
+    study_obj.logger.success(
+        f"Alignment completed. Reference sample UID {ref_sample_uid}.",
+    )
 
 
 def _align_kd_algorithm(study_obj, params):
@@ -879,7 +882,7 @@ def _align_kd_algorithm(study_obj, params):
         _raw_mp = None
     max_points = int(_raw_mp) if _raw_mp is not None else 1000
     study_obj.logger.info(
-        f"KD align: rt_tol={params.get('rt_tol')}, max_points={max_points}",
+        f"Align RTs with KD-Tree: rt_tol={params.get('rt_tol')}, max_points={max_points}",
     )
 
     # Work directly with features_df instead of feature maps
@@ -1092,7 +1095,7 @@ def _align_kd_algorithm(study_obj, params):
     )
 
     study_obj.logger.success(
-        f"Alignment completed. Reference sample UID {ref_sample_uid} (index {ref_index}).",
+        f"Alignment completed. Reference sample UID {ref_sample_uid}.",
     )
 
 

{masster-0.5.10 → masster-0.5.11}/uv.lock

@@ -1420,7 +1420,7 @@ wheels = [
 
 [[package]]
 name = "masster"
-version = "0.5.10"
+version = "0.5.11"
 source = { editable = "." }
 dependencies = [
     { name = "alpharaw" },