pyckster 26.2.2__py3-none-any.whl → 26.2.4__py3-none-any.whl

pyckster/__init__.py

@@ -15,7 +15,7 @@ except ImportError:
     pass  # matplotlib not available, that's fine
 
 # Define version and metadata in one place
-__version__ = "26.2.2"
+__version__ = "26.2.4"
 __author__ = "Sylvain Pasquet"
 __email__ = "sylvain.pasquet@sorbonne-universite.fr"
 __license__ = "GPLv3"

pyckster/core.py

@@ -1714,6 +1714,7 @@ class MainWindow(QMainWindow):
 
         # Create a QListWidget for file names and add it to the left
         self.fileListWidget = QListWidget()
+        self.fileListWidget.setSelectionMode(QListWidget.ExtendedSelection)  # Enable multi-selection
         self.fileListWidget.itemSelectionChanged.connect(self.onFileSelectionChanged)
         self.fileListWidget.setMinimumWidth(50)  # Set minimum width
         leftLayout.addWidget(self.fileListWidget)
@@ -2262,28 +2263,36 @@ class MainWindow(QMainWindow):
         self.openFileAction.triggered.connect(self.openFile)
 
         # Create QAction for importing ASCII matrix
-        self.importAsciiAction = QAction('Import ASCII matrix...', self)
+        self.importAsciiAction = QAction('Import ASCII matrix', self)
         self.fileMenu.addAction(self.importAsciiAction)
         self.importAsciiAction.triggered.connect(self.importAsciiMatrix)
 
         # Create QAction for importing ASCII archive
-        self.importAsciiArchiveAction = QAction('Import ASCII archive...', self)
+        self.importAsciiArchiveAction = QAction('Import ASCII archive', self)
         self.fileMenu.addAction(self.importAsciiArchiveAction)
         self.importAsciiArchiveAction.triggered.connect(self.importAsciiArchive)
         
         # Add separator
         self.fileMenu.addSeparator()
 
-        # Create QAction for stacking shots
-        self.stackShotsAction = QAction('Stack shots', self)
-        self.fileMenu.addAction(self.stackShotsAction)
+        # Create a submenu for stacking shots
+        self.stackSubMenu = self.fileMenu.addMenu('Stack...')
+
+        # Create QAction for stacking shots with same source position
+        self.stackShotsAction = QAction('shots at same position', self)
+        self.stackSubMenu.addAction(self.stackShotsAction)
         self.stackShotsAction.triggered.connect(self.stackShots)
 
+        # Create QAction for stacking selected shots
+        self.stackSelectedShotsAction = QAction('selected shots', self)
+        self.stackSubMenu.addAction(self.stackSelectedShotsAction)
+        self.stackSelectedShotsAction.triggered.connect(self.stackSelectedShots)
+
         # Add separator
         self.fileMenu.addSeparator()
 
         # Create a submenu for saving single files
-        self.saveSingleFileSubMenu = self.fileMenu.addMenu('Save current shot')
+        self.saveSingleFileSubMenu = self.fileMenu.addMenu('Save current shot...')
 
         # Create QAction for saving current file in SEGY
         self.saveSingleFileSegyAction = QAction('in a SEGY file', self)
@@ -2301,7 +2310,7 @@ class MainWindow(QMainWindow):
         self.saveSingleFileAsciiAction.triggered.connect(self.saveSingleFileASCII)
 
         # Create a submenu for saving all files
-        self.saveFileSubMenu = self.fileMenu.addMenu('Save all shots')
+        self.saveFileSubMenu = self.fileMenu.addMenu('Save all shots...')
 
         # Create QAction for saving all files in SEGY
         self.saveAllFilesSegyAction = QAction('in separate SEGY files', self)
@@ -2331,10 +2340,10 @@ class MainWindow(QMainWindow):
         # Add separator
         self.fileMenu.addSeparator()
 
-        # Create QAction for removing current file
-        self.removeShotAction = QAction('Remove current shot', self)
+        # Create QAction for removing selected files
+        self.removeShotAction = QAction('Remove selected shot(s)', self)
         self.fileMenu.addAction(self.removeShotAction)
-        self.removeShotAction.triggered.connect(self.removeShot)
+        self.removeShotAction.triggered.connect(self.removeSelectedShots)
 
         # Create QAction for clearing the memory
         self.clearMemoryAction = QAction('Clear memory', self)
@@ -11663,7 +11672,7 @@ class MainWindow(QMainWindow):
             self.skip_header_edit = QSpinBox()
             self.skip_header_edit.setRange(0, 1000)
             self.skip_header_edit.setValue(0)
-            self.skip_header_edit.setToolTip("Number of header lines to skip in the ASCII file")
+            self.skip_header_edit.setToolTip("Number of lines to skip from the beginning of the file (counts all lines including comments)")
             data_layout.addRow("Skip header lines:", self.skip_header_edit)
             
             self.delimiter_edit = QLineEdit()
@@ -11738,7 +11747,24 @@ class MainWindow(QMainWindow):
             successful_imports = 0
             failed_imports = []
             
-            for file_path in params['file_paths']:
+            # Create progress dialog for batch import
+            progress = None
+            if len(params['file_paths']) > 1:
+                progress = QProgressDialog("Importing ASCII matrices...", "Cancel", 0, len(params['file_paths']), self)
+                progress.setWindowTitle("Importing ASCII Matrices")
+                progress.setMinimumDuration(0)
+                progress.setWindowModality(QtCore.Qt.WindowModal)
+                progress.setValue(0)
+                progress.show()
+                QApplication.processEvents()
+            
+            for idx, file_path in enumerate(params['file_paths']):
+                if progress:
+                    progress.setValue(idx)
+                    if progress.wasCanceled():
+                        break
+                    progress.setLabelText(f"Importing file {idx+1} of {len(params['file_paths'])}...")
+                    QApplication.processEvents()
                 try:
                     # Load the ASCII matrix
                     QApplication.processEvents()
@@ -11760,13 +11786,15 @@ class MainWindow(QMainWindow):
                                 delimiter = None  # Let numpy handle it
                     
                     # Load the data with skiprows parameter
+                    # Set comments=None to disable automatic comment skipping (numpy default is comments='#')
+                    # This ensures skiprows counts ALL lines as documented
                     try:
-                        data_matrix = np.loadtxt(file_path, delimiter=delimiter, skiprows=params['skip_header'])
+                        data_matrix = np.loadtxt(file_path, delimiter=delimiter, skiprows=params['skip_header'], comments=None)
                     except ValueError:
                         # Try with different delimiters
                         for delim in [None, ',', '\t', ' ']:
                             try:
-                                data_matrix = np.loadtxt(file_path, delimiter=delim, skiprows=params['skip_header'])
+                                data_matrix = np.loadtxt(file_path, delimiter=delim, skiprows=params['skip_header'], comments=None)
                                 break
                             except ValueError:
                                 continue
@@ -11781,6 +11809,53 @@ class MainWindow(QMainWindow):
                     if data_matrix.ndim == 1:
                         data_matrix = data_matrix.reshape(-1, 1)
                     
+                    # Auto-detect orientation: number of traces should typically be less than number of time samples
+                    # This helps prevent memory overload from incorrect orientation
+                    n_rows, n_cols = data_matrix.shape
+                    if n_cols > n_rows:
+                        # More columns than rows suggests wrong orientation
+                        # This would mean more traces than time samples, which is unusual
+                        
+                        # Check if we should use "yes to all" from previous choice
+                        if not hasattr(self, '_transpose_yes_to_all'):
+                            self._transpose_yes_to_all = False
+                        
+                        if self._transpose_yes_to_all:
+                            # Automatically transpose based on previous "yes to all" choice
+                            data_matrix = data_matrix.T
+                            params['transpose'] = not params['transpose']
+                        else:
+                            # Ask user
+                            msg = QMessageBox()
+                            msg.setIcon(QMessageBox.Warning)
+                            msg.setWindowTitle("Potential Orientation Issue")
+                            msg.setText(
+                                f"The matrix has {n_cols} columns and {n_rows} rows.\n\n"
+                                f"This would result in {n_cols} traces with {n_rows} time samples each, "
+                                f"which is unusual (typically, traces < time samples).\n\n"
+                                f"Do you want to transpose the matrix?\n"
+                                f"(This would give {n_rows} traces with {n_cols} samples each)"
+                            )
+                            msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+                            msg.setDefaultButton(QMessageBox.Yes)
+                            
+                            # Add "Yes to All" checkbox for batch imports
+                            yes_to_all_checkbox = None
+                            if len(params['file_paths']) > 1:
+                                yes_to_all_checkbox = QCheckBox("Apply to all remaining files")
+                                msg.setCheckBox(yes_to_all_checkbox)
+                            
+                            result = msg.exec_()
+                            
+                            # Check if "Yes to All" was selected
+                            if yes_to_all_checkbox and yes_to_all_checkbox.isChecked():
+                                self._transpose_yes_to_all = True
+                            
+                            if result == QMessageBox.Yes:
+                                data_matrix = data_matrix.T
+                                # Update the effective transpose state for display later
+                                params['transpose'] = not params['transpose']
+                    
                     # Validate the data matrix
                     if data_matrix.size == 0:
                         raise ValueError("The loaded matrix is empty")
@@ -11850,6 +11925,10 @@ class MainWindow(QMainWindow):
                 except Exception as e:
                     failed_imports.append((os.path.basename(file_path), str(e)))
             
+            # Close progress dialog
+            if progress:
+                progress.setValue(len(params['file_paths']))
+            
             # After processing all files, update UI and show results
             if successful_imports > 0:
                 # Select the last imported file
@@ -11870,9 +11949,57 @@ class MainWindow(QMainWindow):
                 if len(failed_imports) > 5:
                     error_msg += f"\n\n... and {len(failed_imports) - 5} more"
                 QMessageBox.warning(self, "Import Complete with Errors", error_msg)
-            else:
-                QMessageBox.information(self, "Import Successful", 
-                    f"Successfully imported {successful_imports} ASCII file(s)")
+            elif successful_imports > 0:
+                # Calculate total traces and samples for successful imports
+                total_traces = 0
+                total_samples = 0
+                # Track different configurations
+                config_counts = {}  # (n_traces, n_samples): count
+                
+                for i in range(len(self.streams) - successful_imports, len(self.streams)):
+                    if i >= 0 and i < len(self.trace_position) and self.trace_position[i] is not None:
+                        n_traces = len(self.trace_position[i])
+                        total_traces += n_traces
+                    else:
+                        n_traces = 0
+                    
+                    if i >= 0 and i < len(self.n_sample) and self.n_sample[i] is not None:
+                        n_samples = self.n_sample[i]
+                        total_samples += n_samples
+                    else:
+                        n_samples = 0
+                    
+                    # Track configuration
+                    config = (n_traces, n_samples)
+                    config_counts[config] = config_counts.get(config, 0) + 1
+                
+                # Show detailed information
+                if successful_imports == 1:
+                    # Single file - show detailed info
+                    idx = len(self.streams) - 1
+                    n_traces = len(self.trace_position[idx]) if idx < len(self.trace_position) and self.trace_position[idx] else 0
+                    n_samp = self.n_sample[idx] if idx < len(self.n_sample) and self.n_sample[idx] else 0
+                    QMessageBox.information(
+                        self, "Import Successful",
+                        f"Successfully imported ASCII matrix\n\n"
+                        f"Traces: {n_traces}\n"
+                        f"Samples per trace: {n_samp}\n"
+                        f"Orientation: {'Transposed (traces were in rows)' if params['transpose'] else 'Standard (traces in columns)'}"
+                    )
+                else:
+                    # Multiple files - show configuration breakdown
+                    summary_msg = f"Successfully imported {successful_imports} ASCII file(s)\n\n"
+                    
+                    # Show configuration breakdown
+                    if len(config_counts) > 0:
+                        for (n_traces, n_samples), count in sorted(config_counts.items()):
+                            summary_msg += f"• {count} file(s): {n_traces} traces × {n_samples} samples\n"
+                    
+                    QMessageBox.information(self, "Import Successful", summary_msg.rstrip())
+            
+            # Reset transpose yes-to-all flag after batch import completes
+            if hasattr(self, '_transpose_yes_to_all'):
+                delattr(self, '_transpose_yes_to_all')
     
     def ascii_to_obspy_stream(self, data_matrix, params):
         """Convert ASCII matrix to ObsPy Stream object"""
@@ -11939,7 +12066,24 @@ class MainWindow(QMainWindow):
         successful_imports = 0
         failed_imports = []
         
-        for archive_path in archive_paths:
+        # Create progress dialog for batch archive import
+        progress = None
+        if len(archive_paths) > 1:
+            progress = QProgressDialog("Importing archives...", "Cancel", 0, len(archive_paths), self)
+            progress.setWindowTitle("Importing Archives")
+            progress.setMinimumDuration(0)
+            progress.setWindowModality(QtCore.Qt.WindowModal)
+            progress.setValue(0)
+            progress.show()
+            QApplication.processEvents()
+        
+        for idx, archive_path in enumerate(archive_paths):
+            if progress:
+                progress.setValue(idx)
+                if progress.wasCanceled():
+                    break
+                progress.setLabelText(f"Importing archive {idx+1} of {len(archive_paths)}...")
+                QApplication.processEvents()
             try:
                 QApplication.setOverrideCursor(Qt.WaitCursor)
                 
@@ -12101,6 +12245,10 @@ class MainWindow(QMainWindow):
             finally:
                 QApplication.restoreOverrideCursor()
         
+        # Close progress dialog
+        if progress:
+            progress.setValue(len(archive_paths))
+        
         # After processing all files, update UI and show results
         if successful_imports > 0:
             # Initialize plot labels if they don't exist
@@ -12119,19 +12267,70 @@ class MainWindow(QMainWindow):
             # Plot the new data
             self.updatePlots()
         
+        # Calculate total traces and samples for successful imports
+        total_traces = 0
+        total_samples = 0
+        # Track different configurations
+        config_counts = {}  # (n_traces, n_samples): count
+        
+        if successful_imports > 0:
+            # Count traces and samples from the newly imported files
+            # (last successful_imports files in the lists)
+            for i in range(len(self.streams) - successful_imports, len(self.streams)):
+                if i >= 0 and i < len(self.trace_position) and self.trace_position[i] is not None:
+                    n_traces = len(self.trace_position[i])
+                    total_traces += n_traces
+                else:
+                    n_traces = 0
+                    
+                if i >= 0 and i < len(self.n_sample) and self.n_sample[i] is not None:
+                    n_samples = self.n_sample[i]
+                    total_samples += n_samples * (len(self.trace_position[i]) if self.trace_position[i] else 0)
+                else:
+                    n_samples = 0
+                
+                # Track configuration
+                config = (n_traces, n_samples)
+                config_counts[config] = config_counts.get(config, 0) + 1
+        
         # Show import summary
         if failed_imports:
-            error_msg = f"Successfully imported {successful_imports} archive(s).\n\nFailed imports ({len(failed_imports)}):\n"
+            error_msg = f"Successfully imported {successful_imports} archive(s).\n\n"
+            
+            # Show configuration breakdown
+            if len(config_counts) > 0:
+                for (n_traces, n_samples), count in sorted(config_counts.items()):
+                    error_msg += f"• {count} archive(s): {n_traces} traces × {n_samples} samples\n"
+            
+            error_msg += "\n"
+            error_msg += f"Failed imports ({len(failed_imports)}):\n"
             for fname, error in failed_imports[:5]:  # Show first 5 errors
                 error_msg += f"\n• {fname}: {error}"
             if len(failed_imports) > 5:
                 error_msg += f"\n\n... and {len(failed_imports) - 5} more"
             QMessageBox.warning(self, "Import Complete with Errors", error_msg)
         elif successful_imports > 0:
-            QMessageBox.information(
-                self, "Import Successful", 
-                f"Successfully imported {successful_imports} ASCII archive(s)"
-            )
+            if len(archive_paths) > 1:
+                # Batch import summary
+                summary_msg = f"Successfully imported {successful_imports} ASCII archive(s)\n\n"
+                
+                # Show configuration breakdown
+                if len(config_counts) > 0:
+                    for (n_traces, n_samples), count in sorted(config_counts.items()):
+                        summary_msg += f"• {count} archive(s): {n_traces} traces × {n_samples} samples\n"
+                
+                QMessageBox.information(self, "Import Successful", summary_msg.rstrip())
+            else:
+                # Single archive - detailed info
+                idx = len(self.streams) - 1
+                n_traces = len(self.trace_position[idx]) if idx < len(self.trace_position) and self.trace_position[idx] else 0
+                n_samp = self.n_sample[idx] if idx < len(self.n_sample) and self.n_sample[idx] else 0
+                QMessageBox.information(
+                    self, "Import Successful",
+                    f"Imported {os.path.basename(archive_paths[0])}\n\n"
+                    f"Traces: {n_traces}\n"
+                    f"Samples per trace: {n_samp}"
+                )
 
     #######################################
     # File loading and processing functions
@@ -12461,9 +12660,6 @@ class MainWindow(QMainWindow):
                 # Close progress dialog
                 progress.setValue(len(fileNames_new))
 
-            # Success - dialogs removed for smoother workflow
-            # Files are now visible in the file list
-
             self.sortFiles()  # Sort the files based on the file names
             self.updateFileListDisplay() # Update the file list display
             self.sortFileList() # Sort the file list widget
@@ -12689,7 +12885,17 @@ class MainWindow(QMainWindow):
             if show_cursor:
                 QApplication.restoreOverrideCursor()
 
+    def getSelectedShotIndices(self):
+        """Helper function to get indices of selected shots in the file list.
+        Returns a sorted list of indices (0-based)."""
+        selected_items = self.fileListWidget.selectedItems()
+        if not selected_items:
+            return []
+        selected_indices = [self.fileListWidget.row(item) for item in selected_items]
+        return sorted(selected_indices)
+    
     def removeShot(self):
+        """Legacy function - kept for backward compatibility. Use removeSelectedShots instead."""
         if self.currentIndex is not None:
             # Remove the current file from the lists
             for attr in self.attributes_to_initialize:
@@ -12713,6 +12919,59 @@ class MainWindow(QMainWindow):
             else:
                 QMessageBox.information(self, "No Shots Remaining", "No shots remaining. Memory will be cleared.")
                 self.initMemory()
+    
+    def removeSelectedShots(self):
+        """Remove all selected shots from the file list."""
+        # Get selected row indices
+        selected_items = self.fileListWidget.selectedItems()
+        if not selected_items:
+            QMessageBox.warning(self, "No Selection", "No shots selected. Please select one or more shots to remove.")
+            return
+        
+        # Get the indices of selected items
+        selected_indices = [self.fileListWidget.row(item) for item in selected_items]
+        selected_indices.sort(reverse=True)  # Sort in reverse to remove from end first
+        
+        # Confirm removal if multiple shots selected
+        if len(selected_indices) > 1:
+            reply = QMessageBox.question(self, "Confirm Removal",
+                f"Are you sure you want to remove {len(selected_indices)} selected shot(s)?",
+                QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+            if reply == QMessageBox.No:
+                return
+        
+        # Remove selected shots (from end to beginning to maintain indices)
+        for idx in selected_indices:
+            for attr in self.attributes_to_initialize:
+                getattr(self, attr).pop(idx)
+        
+        # Update current index to the first remaining shot or 0
+        if self.streams:
+            # Set to the first valid index that's not removed
+            remaining_count = len(self.fileNames)
+            if remaining_count > 0:
+                # Try to select the shot after the last removed one, or the last available
+                new_index = min(selected_indices) if selected_indices else 0
+                self.currentIndex = min(new_index, remaining_count - 1)
+            else:
+                self.currentIndex = 0
+        else:
+            self.currentIndex = 0
+        
+        # Update the plot type dictionary
+        self.updatePlotTypeDict()
+        
+        # Update the file list display
+        self.updateFileListDisplay()
+        
+        # Update selected file in the list display
+        if self.streams:
+            self.fileListWidget.setCurrentRow(self.currentIndex)
+            # Update the plot
+            self.updatePlots()
+        else:
+            QMessageBox.information(self, "No Shots Remaining", "No shots remaining. Memory will be cleared.")
+            self.initMemory()
 
     #######################################
     # Saving shot functions
@@ -16619,9 +16878,18 @@ class MainWindow(QMainWindow):
 
     def batchEditFFID(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First FFID', 'initial_value': self.ffid[0], 'type': 'int'},
             {'label': 'Increment', 'initial_value': 1, 'type': 'int'}
             ]
@@ -16658,9 +16926,18 @@ class MainWindow(QMainWindow):
     
     def batchEditDelay(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'Delay (in s)', 'initial_value': self.delay[self.currentIndex], 'type': 'float'},
             ]
 
@@ -16738,9 +17015,18 @@ class MainWindow(QMainWindow):
 
     def batchEditSourcePosition(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'Skip every N sources', 'initial_value': 0, 'type': 'int'},
             {'label': 'First Source Position (in m)', 'initial_value': self.source_position[0], 'type': 'float'},
             {'label': 'Last Source Position (in m)', 'initial_value': '', 'type': 'float_or_empty'},
@@ -16846,9 +17132,18 @@ class MainWindow(QMainWindow):
 
     def batchEditTracePosition(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace #', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'},
             {'label': 'First Trace Position (in m)', 'initial_value': self.trace_position[self.currentIndex][0], 'type': 'float'},
@@ -16908,9 +17203,18 @@ class MainWindow(QMainWindow):
 
     def batchSwapTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to swap', 'initial_value': 1, 'type': 'int'},
             {'label': 'Second Trace # to swap', 'initial_value': 2, 'type': 'int'}
             ]
@@ -16976,9 +17280,18 @@ class MainWindow(QMainWindow):
 
     def batchRemoveTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to remove', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to remove', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'}
             ]
@@ -17042,9 +17355,18 @@ class MainWindow(QMainWindow):
 
     def batchMoveTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'New Position', 'initial_value': 1, 'type': 'int'}
@@ -17111,9 +17433,18 @@ class MainWindow(QMainWindow):
 
     def batchMuteTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to mute', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to mute', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'}
             ]
@@ -17163,11 +17494,20 @@ class MainWindow(QMainWindow):
     def batchInsertMutedTraces(self):
         """Batch insert zero traces for a range of shots."""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
             
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'Insert after Trace # (0 for beginning)', 'initial_value': n_traces, 'type': 'int'},
                 {'label': 'Number of traces to insert', 'initial_value': 1, 'type': 'int'}
             ]
@@ -17220,9 +17560,18 @@ class MainWindow(QMainWindow):
     def batchZeroPadTraces(self):
         """Batch zero pad all traces for a range of shots."""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
             ]
             
@@ -17283,11 +17632,20 @@ class MainWindow(QMainWindow):
     def batchReverseTraces(self):
         """Batch reverse trace data (flip data matrix left-to-right) while keeping headers in place"""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
             
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
                 {'label': 'Last Trace #', 'initial_value': n_traces, 'type': 'int'}
             ]
@@ -17651,6 +18009,203 @@ class MainWindow(QMainWindow):
         QMessageBox.information(self, "Stacking Complete", 
             f"Successfully created {stacked_shot_count} stacked shot(s).")
 
+    def stackSelectedShots(self):
+        """
+        Stack selected shots regardless of their source position.
+        Creates a new stacked shot with traces summed at identical receiver positions.
+        Uses the source position from the first selected shot.
+        """
+        import obspy
+        from obspy import Stream
+        
+        if not self.streams:
+            QMessageBox.information(self, "No Data", "No shots loaded. Please load shot data first.")
+            return
+        
+        # Get selected shot indices
+        selected_indices = self.getSelectedShotIndices()
+        
+        if len(selected_indices) < 2:
+            QMessageBox.warning(self, "Insufficient Selection", 
+                "Please select at least 2 shots to stack. Use Ctrl+Click to select multiple shots.")
+            return
+        
+        # Build a dictionary of receiver positions across all selected shots
+        # Key: receiver position, Value: list of (shot_idx, trace_idx) tuples
+        receiver_traces = {}
+        
+        for shot_idx in selected_indices:
+            for trace_idx, receiver_pos in enumerate(self.trace_position[shot_idx]):
+                if receiver_pos not in receiver_traces:
+                    receiver_traces[receiver_pos] = []
+                receiver_traces[receiver_pos].append((shot_idx, trace_idx))
+        
+        # Get unique receiver positions (sorted)
+        receiver_positions = sorted(receiver_traces.keys())
+        
+        if not receiver_positions:
+            QMessageBox.warning(self, "No Receiver Positions", 
+                "Could not find any receiver positions in selected shots.")
+            return
+        
+        # Use source position from first selected shot
+        first_shot_idx = selected_indices[0]
+        source_pos = self.source_position[first_shot_idx]
+        
+        # Show confirmation dialog
+        shot_indices_str = ', '.join(str(i + 1) for i in selected_indices)
+        reply = QMessageBox.question(self, "Confirm Stacking",
+            f"Stack {len(selected_indices)} selected shot(s) ({shot_indices_str})?\n\n"
+            f"Source position: {source_pos}m\n"
+            f"Number of unique receiver positions: {len(receiver_positions)}\n\n"
+            f"Traces at the same receiver position will be summed.",
+            QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+        
+        if reply == QMessageBox.No:
+            return
+        
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Create stacked stream
+            stacked_stream = obspy.Stream()
+            
+            # For each receiver position, sum all traces at that position
+            for receiver_pos in receiver_positions:
+                trace_list = receiver_traces[receiver_pos]
+                
+                # Get all traces at this receiver position
+                traces_to_sum = []
+                for shot_idx, trace_idx in trace_list:
+                    traces_to_sum.append(self.streams[shot_idx][trace_idx])
+                
+                # Sum the traces
+                if traces_to_sum:
+                    summed_trace = traces_to_sum[0].copy()
+                    for trace in traces_to_sum[1:]:
+                        summed_trace.data += trace.data
+                    stacked_stream.append(summed_trace)
+            
+            if len(stacked_stream) == 0:
+                QMessageBox.warning(self, "No Traces", "Could not create stacked traces.")
+                return
+            
+            # Find the maximum existing FFID and increment
+            max_ffid = max(self.ffid) if self.ffid else 0
+            new_ffid = max_ffid + 1
+            
+            # Get format from first shot
+            format_to_use = self.input_format[first_shot_idx]
+            
+            # Update FFID in headers for stacked stream
+            for trace in stacked_stream:
+                trace.stats[format_to_use].trace_header.original_field_record_number = new_ffid
+            
+            # Append to parallel arrays
+            stacked_shot_name = f"stacked_selected_{new_ffid}"
+            self.fileNames.append(stacked_shot_name)
+            self.streams.append(stacked_stream)
+            self.input_format.append(format_to_use)
+            
+            # Extract data from the stacked stream
+            n_sample_stacked = len(stacked_stream[0].data)
+            self.n_sample.append(n_sample_stacked)
+            
+            # Get sample interval from first shot
+            sample_interval_stacked = self.sample_interval[first_shot_idx]
+            self.sample_interval.append(sample_interval_stacked)
+            
+            # Get delay from first shot
+            delay_stacked = self.delay[first_shot_idx]
+            self.delay.append(delay_stacked)
+            
+            # Generate time array
+            time_stacked = np.arange(n_sample_stacked) * sample_interval_stacked + delay_stacked
+            self.time.append(time_stacked)
+            
+            # Get record length
+            record_length_stacked = self.record_length[first_shot_idx]
+            self.record_length.append(record_length_stacked)
+            
+            # FFID
+            self.ffid.append(new_ffid)
+            
+            # Source position (from first selected shot)
+            self.source_position.append(source_pos)
+            
+            # Trace numbering
+            shot_trace_numbers = [i + 1 for i in range(len(stacked_stream))]
+            self.shot_trace_number.append(shot_trace_numbers)
+            
+            # Trace positions (receiver positions, sorted)
+            self.trace_position.append(receiver_positions)
+            
+            # File trace numbers (sequential)
+            file_trace_numbers = list(range(1, len(stacked_stream) + 1))
+            self.file_trace_number.append(file_trace_numbers)
+            
+            # Initialize unique_trace_number (will be computed later)
+            self.unique_trace_number.append(None)
+            
+            # Trace elevations (from first occurrence of each position)
+            trace_elevations_stacked = []
+            for receiver_pos in receiver_positions:
+                # Find first occurrence of this position
+                for shot_idx, trace_idx in receiver_traces[receiver_pos]:
+                    trace_elevations_stacked.append(self.trace_elevation[shot_idx][trace_idx])
+                    break
+            self.trace_elevation.append(trace_elevations_stacked)
+            
+            # Source elevation (from first shot)
+            self.source_elevation.append(self.source_elevation[first_shot_idx])
+            
+            # Offset (distance from source to each receiver)
+            offsets_stacked = [abs(rp - source_pos) for rp in receiver_positions]
+            self.offset.append(offsets_stacked)
+            
+            # Initialize picks, errors, and UI items as None
+            self.picks.append(None)
+            self.error.append(None)
+            self.pickSeismoItems.append(None)
+            self.pickLayoutItems.append(None)
+            self.airWaveItems.append(None)
+            
+            # Update global trace numbering
+            self._updateAllUniqueTraceNumbers()
+            
+            # Sync headers
+            self.syncHeadersToStreams(len(self.streams) - 1)
+            self.headers_modified = True
+            
+            # Update display
+            self.updateFileListDisplay()
+            self.updatePlots()
+            
+            # Ask if user wants to remove the selected shots
+            reply = QMessageBox.question(self, "Remove Selected Shots",
+                "Remove the selected shots that were used in stacking?",
+                QMessageBox.Yes | QMessageBox.No)
+            
+            if reply == QMessageBox.Yes:
+                # Remove shots in reverse order to preserve indices
+                for idx in reversed(selected_indices):
+                    for attr in self.attributes_to_initialize:
+                        getattr(self, attr).pop(idx)
+                
+                # Update display
+                self.updateFileListDisplay()
+                if self.streams:
+                    self.currentIndex = min(self.currentIndex, len(self.streams) - 1)
+                    self.fileListWidget.setCurrentRow(self.currentIndex)
+                    self.updatePlots()
+            
+            QMessageBox.information(self, "Stacking Complete", 
+                f"Successfully stacked {len(selected_indices)} shot(s) into FFID {new_ffid}.\n"
+                f"Source position: {source_pos}m\n"
+                f"Number of traces: {len(receiver_positions)}")
+        
+        finally:
+            QApplication.restoreOverrideCursor()
+
     #######################################
     # Set parameters functions
     #######################################

pyckster/obspy_utils.py

@@ -2,6 +2,7 @@ import os
 import re
 import numpy as np
 import obspy
+import warnings
 
 #######################################
 # Obspy functions
@@ -63,39 +64,49 @@ def read_seismic_file(seismic_file, separate_sources=False):
     stream : obspy.Stream
         The stream object containing the seismic data.
     '''
-    # Validate .dat files are actually binary, not ASCII
-    file_ext = os.path.splitext(seismic_file)[1].lower()
-    if file_ext == '.dat':
-        if not is_valid_binary_seismic_file(seismic_file):
-            raise ValueError(
-                f"File '{os.path.basename(seismic_file)}' appears to be an ASCII text file, "
-                f"not a binary Seg2 seismic file. Please verify the file format."
-            )
-    
-    # Determine format based on file extension
-    format_map = {
-        '.sgy': 'SEGY',
-        '.seg': 'SEGY',
-        '.segy': 'SEGY',
-        '.su': 'SU',
-        '.seg2': 'SEG2',
-        '.sg2': 'SEG2',
-        '.dat': 'SEG2',  # .dat files are typically SEG2
-    }
-    
-    # Get format from extension, default to None (let obspy auto-detect)
-    file_format = format_map.get(file_ext, None)
-    
-    # Read the seismic file with explicit format if known
-    if file_format:
-        stream = obspy.read(seismic_file, format=file_format, unpack_trace_headers=True)
-    else:
-        stream = obspy.read(seismic_file, unpack_trace_headers=True)
+    # Suppress expected warnings from ObsPy's SEG2 reader
+    # These warnings are expected and handled by our code:
+    # 1. DELAY field warning - we manually extract and apply the delay
+    # 2. Custom header warning - we handle custom SEG2 headers appropriately
+    # 3. Creating trace header - expected during SEG2 to SEGY conversion
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', message='.*DELAY.*', category=UserWarning)
+        warnings.filterwarnings('ignore', message='.*custom defined SEG2 header.*', category=UserWarning)
+        warnings.filterwarnings('ignore', message='CREATING TRACE HEADER', category=UserWarning)
+        
+        # Validate .dat files are actually binary, not ASCII
+        file_ext = os.path.splitext(seismic_file)[1].lower()
+        if file_ext == '.dat':
+            if not is_valid_binary_seismic_file(seismic_file):
+                raise ValueError(
+                    f"File '{os.path.basename(seismic_file)}' appears to be an ASCII text file, "
+                    f"not a binary Seg2 seismic file. Please verify the file format."
+                )
+        
+        # Determine format based on file extension
+        format_map = {
+            '.sgy': 'SEGY',
+            '.seg': 'SEGY',
+            '.segy': 'SEGY',
+            '.su': 'SU',
+            '.seg2': 'SEG2',
+            '.sg2': 'SEG2',
+            '.dat': 'SEG2',  # .dat files are typically SEG2
+        }
+        
+        # Get format from extension, default to None (let obspy auto-detect)
+        file_format = format_map.get(file_ext, None)
+        
+        # Read the seismic file with explicit format if known
+        if file_format:
+            stream = obspy.read(seismic_file, format=file_format, unpack_trace_headers=True)
+        else:
+            stream = obspy.read(seismic_file, unpack_trace_headers=True)
 
     input_format = check_format(stream)
 
     if input_format == 'seg2':
-        # Preserve original SEG2 coordinate information before conversion
+        # Preserve original SEG2 coordinate information and delay before conversion
         original_seg2_coords = []
         for trace_index, trace in enumerate(stream):
             coord_info = {
@@ -105,13 +116,24 @@ def read_seismic_file(seismic_file, separate_sources=False):
                 'source_x': 0.0,
                 'source_y': 0.0,
                 'source_z': 0.0,
+                'delay': 0.0,
                 'trace_index': trace_index
             }
             
-            # Extract coordinates from SEG2 headers with multiple field name variations
+            # Extract coordinates and delay from SEG2 headers with multiple field name variations
             if hasattr(trace.stats, 'seg2'):
                 seg2 = trace.stats.seg2
                 
+                # Extract DELAY from SEG2 headers
+                delay_fields = ['DELAY', 'DELAY_TIME', 'RECORDING_DELAY']
+                for field in delay_fields:
+                    if hasattr(seg2, field):
+                        try:
+                            coord_info['delay'] = float(getattr(seg2, field))
+                            break
+                        except (ValueError, TypeError):
+                            continue
+                
                 # Try different field names for receiver location
                 receiver_location_fields = ['RECEIVER_LOCATION', 'RECEIVER_LOCATION_X', 'RECEIVER_X', 'REC_X']
                 for field in receiver_location_fields:
@@ -170,8 +192,11 @@ def read_seismic_file(seismic_file, separate_sources=False):
         else:
             ffid = 1
 
-        stream.write('tmp.sgy',format='SEGY',data_encoding=5, byteorder='>')
-        stream = obspy.read('tmp.sgy',unpack_trace_headers=True)
+        # Suppress warnings during SEG2 to SEGY conversion
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', message='CREATING TRACE HEADER', category=UserWarning)
+            stream.write('tmp.sgy',format='SEGY',data_encoding=5, byteorder='>')
+            stream = obspy.read('tmp.sgy',unpack_trace_headers=True)
         os.remove('tmp.sgy')
         
         # Calculate coordinate scalar for preserved coordinates
@@ -204,6 +229,8 @@ def read_seismic_file(seismic_file, separate_sources=False):
                 trace.stats[input_format].trace_header.source_coordinate_x = int(coord_info['source_x'] * coordinate_scalar)
                 trace.stats[input_format].trace_header.source_coordinate_y = int(coord_info['source_y'] * coordinate_scalar)
                 trace.stats[input_format].trace_header.surface_elevation_at_source = int(coord_info['source_z'] * coordinate_scalar)
+                # Apply delay from SEG2 header (convert to milliseconds for SEGY)
+                trace.stats[input_format].trace_header.delay_recording_time = int(coord_info['delay'] * 1000)
     
     if separate_sources:
         stream = separate_streams(stream)

{pyckster-26.2.2.dist-info → pyckster-26.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyckster
-Version: 26.2.2
+Version: 26.2.4
 Summary: A PyQt5-based GUI for the processing and analysis of active near-surface seismic data
 Home-page: https://gitlab.in2p3.fr/metis-geophysics/pyckster
 Author: Sylvain Pasquet

{pyckster-26.2.2.dist-info → pyckster-26.2.4.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pyckster/__init__.py,sha256=LO70RUeDFgSj8VdFhawOny6CVOPFksmbZ18sxkVpTBg,905
+pyckster/__init__.py,sha256=hyEyaD3gWhebOlI1NcoMePXDldgUNNoe7mZ-l0lIm-Y,905
 pyckster/__main__.py,sha256=zv3AGVKorKo2tgWOEIcVnkDbp15eepSqka3IoWH_adU,406
 pyckster/auto_picking.py,sha256=fyZiOj0Ib-SB_oxsKnUszECHbOjo4JE23JVQILGYZco,12754
 pyckster/bayesian_inversion.py,sha256=kdnKOlAZ0JlYLipuFDHlwS7dU8LtI-0aMb90bYpEHhE,163523
-pyckster/core.py,sha256=0D3vDbpaToJ-RuNvpL7C4uGPLlrQaPvxb2xBuOTFxsI,1240456
+pyckster/core.py,sha256=HDJz6UB2TaGM-i68BRgb9X2poM3CJQDiOE3Is_IwG7w,1268015
 pyckster/dispersion_stack_viewer.py,sha256=7Dh2e1tSct062D7Qh6nNrMdJcqKWcJvDIv84V8sC6C8,12645
 pyckster/inversion_app.py,sha256=ovM44oYBFsvfKxO7rjjThUhkJnLDLZZ0R6ZVp-5r66E,60676
 pyckster/inversion_manager.py,sha256=P8i1fqUJKMWkd-9PoDmNtmQuKglGKTeSuptUUA57D-8,15393
 pyckster/inversion_visualizer.py,sha256=vfKZIoJzKawbaEv29NsYYIGnWLDQCGef5bM2vY1aCBo,22135
 pyckster/ipython_console.py,sha256=tZyyoiXCjCl7ozxOj_h-YR4eGjoC4kpKe7nZ48eUAJc,9313
 pyckster/mpl_export.py,sha256=_WqPo9l9ABiSoU0ukLfm4caGV1-FKKbXjt8SoBHTR30,12346
-pyckster/obspy_utils.py,sha256=wm74oyLvvQmF97_ySXPZD95ya-8Aer-pLyVYlA3QWoM,35420
+pyckster/obspy_utils.py,sha256=Rb0-HAZpil7LxDOMtoKqxlSYL71LVe9rAMrT0PRHXbU,37132
 pyckster/pick_io.py,sha256=r7QoRCA2zaGeZlFKuAJ86KnAH_mh_l4qGvP02Q0mwVA,36001
 pyckster/pyqtgraph_utils.py,sha256=PAeE3n_wz7skHOC5eLnkFczbie7diVH1xvuL8jtJ4T8,6049
 pyckster/surface_wave_analysis.py,sha256=97BrDA-n5AZp89NdxQ2ekZPaCErMc7v8C6GmD5KTi-4,102695
@@ -17,9 +17,9 @@ pyckster/surface_wave_profiling.py,sha256=L9KidhKmfGvVoPZjf6us3c49VB7VPB_VcsDqRx
 pyckster/sw_utils.py,sha256=-2CpQ9BkmUHaMBrNy2qXx1R-g9qPX8D9igKi_G-iRHE,13213
 pyckster/tab_factory.py,sha256=NlCIC6F8BrEu7a8BYOJJdWy5ftpX_zKDLj7SbcwBbh8,14519
 pyckster/visualization_utils.py,sha256=bgODn21NAQx1FOMPj91kdDd0szKOgUyfZ3cQlyu2PF8,47947
-pyckster-26.2.2.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
-pyckster-26.2.2.dist-info/METADATA,sha256=mxaCepOXltujMuxOYLLnG-n4nehgEGZDfd38G8h-O8c,4567
-pyckster-26.2.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyckster-26.2.2.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
-pyckster-26.2.2.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
-pyckster-26.2.2.dist-info/RECORD,,
+pyckster-26.2.4.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
+pyckster-26.2.4.dist-info/METADATA,sha256=TKeHttAjV2XDga_kdw2glW3b3c6GMP2GczZCK2L0tVk,4567
+pyckster-26.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyckster-26.2.4.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
+pyckster-26.2.4.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
+pyckster-26.2.4.dist-info/RECORD,,