advisor-scattering 0.5.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

advisor/features/scattering_geometry/ui/components/hkl_to_angles_components.py

@@ -15,9 +15,12 @@ from PyQt5.QtWidgets import (
     QHeaderView,
     QRadioButton,
     QButtonGroup,
+    QDialog,
+    QScrollArea,
+    QFrame,
 )
 from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtGui import QColor, QBrush
+from PyQt5.QtGui import QColor, QBrush, QFont
 class HKLToAnglesControls(QWidget):
     """Widget for HKL to Angles calculation controls."""
 
@@ -208,83 +211,102 @@ class HKLToAnglesControls(QWidget):
             self.L_input.setValue(L)
 
 
-class HKLToAnglesResultsTable(QTableWidget):
-    """Table to display HKL to Angles calculation results."""
+class HistoryDialog(QDialog):
+    """Dialog to display history of all calculation results."""
 
-    # Signal emitted when a solution is selected
-    solutionSelected = pyqtSignal(dict)
-
-    def __init__(self, parent=None):
+    def __init__(self, history, parent=None):
         super().__init__(parent)
-        # Set up table
-        self.setColumnCount(4)
-        self.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "φ (°)", "χ (°)"])
-        self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
-
-        # Hide vertical header (row numbers)
-        self.verticalHeader().setVisible(False)
-
-        # Connect selection change signal
-        self.itemSelectionChanged.connect(self.on_selection_changed)
-
-        # Store the last results for reference
-        self.last_results = None
-
-    def display_results(self, results):
-        """Append calculation results to the table."""
-        # Don't clear table - append new results
-        self.last_results = results
-
-        # Check if we have results
-        if not results or not results.get("success", False):
-            return
-
-
-
-        # Add rows for each new solution
-        row_position = self.rowCount()
-        self.insertRow(row_position)
-
-        # Add solution data
-        self.setItem(row_position, 0, QTableWidgetItem(f"{results['tth']:.1f}"))
-        self.setItem(row_position, 1, QTableWidgetItem(f"{results['theta']:.1f}"))
-        self.setItem(row_position, 2, QTableWidgetItem(f"{results['phi']:.1f}"))
-        self.setItem(row_position, 3, QTableWidgetItem(f"{results['chi']:.1f}"))
-
-        # Highlight new solutions with light blue background
-        feasible_brush = QBrush(QColor(198, 239, 206))  # light green
-        infeasible_brush = QBrush(QColor(255, 199, 206))  # light red
-        row_color = feasible_brush if results["feasible"] else infeasible_brush
-        for col in range(self.columnCount()):
-            item = self.item(row_position, col)
-            if item:
-                item.setBackground(row_color)
-
-        # Scroll to the bottom to show the new results
-        self.scrollToBottom()
-
-    def on_selection_changed(self):
-        """Handle selection change in the table."""
-        current_row = self.currentRow()
-        if current_row >= 0 and self.last_results:
-            if current_row < 1:
-                selected_solution = self.last_results
-                self.solutionSelected.emit(selected_solution)
-
-    def clear_results(self):
-        """Clear all results from the table."""
-        self.setRowCount(0)
-        self.last_results = None
+        self.setWindowTitle("Calculation History")
+        self.setMinimumSize(600, 400)
+        
+        layout = QVBoxLayout(self)
+        
+        # Create scroll area
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll_content = QWidget()
+        scroll_layout = QVBoxLayout(scroll_content)
+        
+        if not history:
+            no_history_label = QLabel("No history available.")
+            no_history_label.setAlignment(Qt.AlignCenter)
+            scroll_layout.addWidget(no_history_label)
+        else:
+            # Display history in reverse order (newest first)
+            for run_idx, entry in enumerate(reversed(history)):
+                run_num = len(history) - run_idx
+                run_frame = QFrame()
+                run_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
+                run_layout = QVBoxLayout(run_frame)
+                
+                # Header with HKL values
+                header_label = QLabel(f"Run #{run_num}: H={entry['H']:.4f}, K={entry['K']:.4f}, L={entry['L']:.4f}")
+                header_font = QFont()
+                header_font.setBold(True)
+                header_label.setFont(header_font)
+                run_layout.addWidget(header_label)
+                
+                # Number of solutions
+                num_solutions = entry.get('number_of_solutions', 1)
+                solutions_label = QLabel(f"Solutions found: {num_solutions}")
+                run_layout.addWidget(solutions_label)
+                
+                # Create table for solutions
+                table = QTableWidget()
+                table.setColumnCount(5)
+                table.setHorizontalHeaderLabels(["#", "tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+                table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+                table.verticalHeader().setVisible(False)
+                table.setMaximumHeight(100)
+                
+                # Add rows for each solution
+                tth_list = entry.get('tth', [])
+                theta_list = entry.get('theta', [])
+                phi_list = entry.get('phi', [])
+                chi_list = entry.get('chi', [])
+                feasible_list = entry.get('feasible', [])
+                
+                for i in range(len(tth_list)):
+                    table.insertRow(i)
+                    table.setItem(i, 0, QTableWidgetItem(f"{i + 1}"))
+                    table.setItem(i, 1, QTableWidgetItem(f"{tth_list[i]:.2f}"))
+                    table.setItem(i, 2, QTableWidgetItem(f"{theta_list[i]:.2f}"))
+                    table.setItem(i, 3, QTableWidgetItem(f"{phi_list[i]:.2f}"))
+                    table.setItem(i, 4, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+                    
+                    # Color based on feasibility
+                    feasible = feasible_list[i] if i < len(feasible_list) else True
+                    color = QColor(198, 239, 206) if feasible else QColor(255, 199, 206)
+                    for col in range(5):
+                        item = table.item(i, col)
+                        if item:
+                            item.setBackground(QBrush(color))
+                
+                run_layout.addWidget(table)
+                scroll_layout.addWidget(run_frame)
+        
+        scroll_layout.addStretch()
+        scroll.setWidget(scroll_content)
+        layout.addWidget(scroll)
+        
+        # Close button
+        close_btn = QPushButton("Close")
+        close_btn.clicked.connect(self.accept)
+        layout.addWidget(close_btn)
 
 
 class HKLToAnglesResultsWidget(QWidget):
-    """Complete results widget with table and clear button."""
+    """Results widget showing current solutions and history button."""
 
     # Signal emitted when a solution is selected
     solutionSelected = pyqtSignal(dict)
 
     def __init__(self, parent=None):
         super().__init__(parent)
+        
+        # Store history of all results
+        self.history = []
+        self.current_result = None
 
         # Main layout
         layout = QVBoxLayout(self)
@@ -293,23 +315,97 @@ class HKLToAnglesResultsWidget(QWidget):
         results_group = QGroupBox("Results")
         results_layout = QVBoxLayout(results_group)
 
-        # Create table
-        self.results_table = HKLToAnglesResultsTable(self)
-        self.results_table.solutionSelected.connect(self.solutionSelected.emit)
+        # Number of solutions label
+        self.solutions_label = QLabel("No results yet")
+        self.solutions_label.setAlignment(Qt.AlignCenter)
+        results_layout.addWidget(self.solutions_label)
+
+        # Current solutions display (table for up to 2 solutions)
+        self.results_table = QTableWidget()
+        self.results_table.setColumnCount(4)
+        self.results_table.setHorizontalHeaderLabels(["tth (°)", "θ (°)", "φ (°)", "χ (°)"])
+        self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.results_table.verticalHeader().setVisible(False)
+        self.results_table.setMaximumHeight(90)
+        self.results_table.itemSelectionChanged.connect(self._on_selection_changed)
         results_layout.addWidget(self.results_table)
 
-        # Add clear button
-        self.clear_button = QPushButton("Clear Results")
-        self.clear_button.clicked.connect(self.clear_results)
-        self.clear_button.setObjectName("clearButton")
-        results_layout.addWidget(self.clear_button)
+        # Show history button
+        self.history_button = QPushButton("Show History")
+        self.history_button.clicked.connect(self._show_history)
+        self.history_button.setObjectName("historyButton")
+        results_layout.addWidget(self.history_button)
 
         layout.addWidget(results_group)
 
     def display_results(self, results):
-        """Display calculation results."""
-        self.results_table.display_results(results)
+        """Display current calculation results and add to history."""
+        if not results or not results.get("success", False):
+            return
+        
+        self.current_result = results
+        
+        # Add to history
+        self.history.append(results)
+        
+        # Update solutions label
+        num_solutions = results.get('number_of_solutions', 1)
+        self.solutions_label.setText(f"Found {num_solutions} solution(s)")
+        
+        # Clear and populate table
+        self.results_table.setRowCount(0)
+        
+        tth_list = results.get('tth', [])
+        theta_list = results.get('theta', [])
+        phi_list = results.get('phi', [])
+        chi_list = results.get('chi', [])
+        feasible_list = results.get('feasible', [])
+        
+        for i in range(len(tth_list)):
+            row = self.results_table.rowCount()
+            self.results_table.insertRow(row)
+            
+            self.results_table.setItem(row, 0, QTableWidgetItem(f"{tth_list[i]:.2f}"))
+            self.results_table.setItem(row, 1, QTableWidgetItem(f"{theta_list[i]:.2f}"))
+            self.results_table.setItem(row, 2, QTableWidgetItem(f"{phi_list[i]:.2f}"))
+            self.results_table.setItem(row, 3, QTableWidgetItem(f"{chi_list[i]:.2f}"))
+            
+            # Color based on feasibility
+            feasible = feasible_list[i] if i < len(feasible_list) else True
+            color = QColor(198, 239, 206) if feasible else QColor(255, 199, 206)
+            for col in range(4):
+                item = self.results_table.item(row, col)
+                if item:
+                    item.setBackground(QBrush(color))
+
+    def _on_selection_changed(self):
+        """Handle selection change in the table."""
+        current_row = self.results_table.currentRow()
+        if current_row >= 0 and self.current_result:
+            tth_list = self.current_result.get('tth', [])
+            theta_list = self.current_result.get('theta', [])
+            phi_list = self.current_result.get('phi', [])
+            chi_list = self.current_result.get('chi', [])
+            
+            if current_row < len(tth_list):
+                selected_solution = {
+                    'tth': tth_list[current_row],
+                    'theta': theta_list[current_row],
+                    'phi': phi_list[current_row],
+                    'chi': chi_list[current_row],
+                    'H': self.current_result.get('H'),
+                    'K': self.current_result.get('K'),
+                    'L': self.current_result.get('L'),
+                }
+                self.solutionSelected.emit(selected_solution)
+
+    def _show_history(self):
+        """Show history dialog."""
+        dialog = HistoryDialog(self.history, self)
+        dialog.exec_()
 
     def clear_results(self):
-        """Clear all results."""
-        self.results_table.clear_results()
+        """Clear current results (but keep history)."""
+        self.results_table.setRowCount(0)
+        self.solutions_label.setText("No results yet")
+        self.current_result = None

advisor/features/scattering_geometry/ui/scattering_geometry_tab.py

@@ -2,52 +2,30 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=no-name-in-module, import-error
 import matplotlib
-from PyQt5.QtWidgets import (
-    QWidget,
-    QGridLayout,
-    QFormLayout,
-    QLabel,
-    QLineEdit,
-    QPushButton,
-    QTabWidget,
-    QDoubleSpinBox,
-    QGroupBox,
-    QRadioButton,
-    QButtonGroup,
-    QFileDialog,
-    QMessageBox,
-    QComboBox,
-    QVBoxLayout,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QHeaderView,
-    QFrame,
-)
-from PyQt5.QtCore import Qt, pyqtSlot, QMimeData
-from PyQt5.QtGui import QDragEnterEvent, QDropEvent, QFont, QColor, QBrush
+from PyQt5.QtCore import QMimeData, Qt, pyqtSlot
+from PyQt5.QtGui import QBrush, QColor, QDragEnterEvent, QDropEvent, QFont
+from PyQt5.QtWidgets import (QButtonGroup, QComboBox, QDoubleSpinBox,
+                             QFileDialog, QFormLayout, QFrame, QGridLayout,
+                             QGroupBox, QHBoxLayout, QHeaderView, QLabel,
+                             QLineEdit, QMessageBox, QPushButton, QRadioButton,
+                             QTableWidget, QTableWidgetItem, QTabWidget,
+                             QVBoxLayout, QWidget)
 
 # Tell matplotlib to render plots using the Qt5 framework with the Agg backend for drawing
 matplotlib.use("Qt5Agg")
 
 from advisor.features.scattering_geometry.domain import BrillouinCalculator
 from advisor.ui.tab_interface import TabInterface
-from advisor.ui.visualizers import (
-    ScatteringVisualizer,
-    UnitcellVisualizer,
-    HKLScan2DVisualizer,
-)
 from advisor.ui.tips import Tips, set_tip
-from .components import (
-    HKLScanControls,
-    HKLScanResultsTable,
-    HKAnglesControls,
-    HKAnglesResultsWidget,
-    AnglesToHKLControls,
-    AnglesToHKLResults,
-    HKLToAnglesControls,
-    HKLToAnglesResultsWidget,
-)
+from advisor.ui.visualizers import (HKLScan2DVisualizer, ScatteringVisualizer,
+                                    UnitcellVisualizer)
+
+from .components import (AnglesToHKLControls, AnglesToHKLResults,
+                         HKAnglesControls, HKAnglesResultsWidget,
+                         HKLScanControls, HKLScanResultsTable,
+                         HKLToAnglesControls, HKLToAnglesResultsWidget)
+
+
 class DragDropLineEdit(QLineEdit):
     """Custom QLineEdit that accepts drag and drop events."""
 
@@ -288,8 +266,8 @@ class ScatteringGeometryTab(TabInterface):
         right_layout.addWidget(self.angles_to_hkl_unitcell_viz)
 
         # Add columns to main layout
-        angles_layout.addWidget(left_column, 1)  # Left column takes 1 part
-        angles_layout.addWidget(right_column, 1.5)  # Right column takes 1.5 parts
+        angles_layout.addWidget(left_column, 2)  # Left column takes 1 part
+        angles_layout.addWidget(right_column, 3)  # Right column takes 1.5 parts
 
         # Add to tab widget
         self.tab_widget.addTab(angles_tab, "Angles → HKL")
@@ -391,6 +369,17 @@ class ScatteringGeometryTab(TabInterface):
         self.hkl_scan_results_table = HKLScanResultsTable(parent=self)
         results_layout.addWidget(self.hkl_scan_results_table, 1)
         
+        # Reminder notes below results table
+        notes_layout = QVBoxLayout()
+        notes_layout.setSpacing(2)
+        note1 = QLabel("Note: Each HKL point may have up to two solutions.")
+        note1.setStyleSheet("color: gray; font-size: 11px; font-style: italic;")
+        note2 = QLabel("Some HKL points may be unreachable due to the momentum transfer limit at current energy.")
+        note2.setStyleSheet("color: gray; font-size: 11px; font-style: italic;")
+        notes_layout.addWidget(note1)
+        notes_layout.addWidget(note2)
+        results_layout.addLayout(notes_layout)
+        
         # 2D visualizer section
         self.hkl_scan_visualizer = HKLScan2DVisualizer(parent=self)
         results_layout.addWidget(self.hkl_scan_visualizer, 1)
@@ -567,16 +556,27 @@ class ScatteringGeometryTab(TabInterface):
             )
             return
         self.hkl_to_angles_results.display_results(result)
+        
         # Update visualization with the first solution
+        # Extract first solution for visualization
+        first_solution = {
+            "tth": result["tth"][0],
+            "theta": result["theta"][0],
+            "phi": result["phi"][0],
+            "chi": result["chi"][0],
+            "H": result["H"],
+            "K": result["K"],
+            "L": result["L"],
+        }
         self.hkl_to_angles_visualizer.visualize_lab_system(
-            is_clear=True, chi=result["chi"], phi=result["phi"], plot_basis=False, plot_k_basis=True
+            is_clear=True, chi=first_solution["chi"], phi=first_solution["phi"], plot_basis=False, plot_k_basis=True
         )
         self.hkl_to_angles_visualizer.visualize_scattering_geometry(
-            scattering_angles=result, is_clear=False
+            scattering_angles=first_solution, is_clear=False
         )
         self.hkl_to_angles_unitcell_viz.visualize_unitcell()
         self.hkl_to_angles_unitcell_viz.visualize_scattering_geometry(
-            scattering_angles=result
+            scattering_angles=first_solution
         ) 
     @pyqtSlot()
     def calculate_angles_tth_fixed(self):
@@ -610,7 +610,6 @@ class ScatteringGeometryTab(TabInterface):
             fixed_angle_name=fixed_angle_name,
             fixed_angle=fixed_angle_value,
         )
-        print("result", result)
         if not result["success"]:
             QMessageBox.warning(
                 self, "Warning", result.get("error", "No solution found")
@@ -619,15 +618,25 @@ class ScatteringGeometryTab(TabInterface):
         self.hk_angles_results.display_results(result)
 
         # Update visualization with the first solution
+        # Extract first solution for visualization
+        first_solution = {
+            "tth": result["tth"][0],
+            "theta": result["theta"][0],
+            "phi": result["phi"][0],
+            "chi": result["chi"][0],
+            "H": result["H"],
+            "K": result["K"],
+            "L": result["L"],
+        }
         self.hk_fixed_tth_visualizer.visualize_lab_system(
-            is_clear=True, chi=result["chi"], phi=result["phi"], plot_basis=False, plot_k_basis=True
+            is_clear=True, chi=first_solution["chi"], phi=first_solution["phi"], plot_basis=False, plot_k_basis=True
         )
         self.hk_fixed_tth_visualizer.visualize_scattering_geometry(
-            scattering_angles=result, is_clear=False
+            scattering_angles=first_solution, is_clear=False
         )
         self.hk_fixed_tth_unitcell_viz.visualize_unitcell()
         self.hk_fixed_tth_unitcell_viz.visualize_scattering_geometry(
-            scattering_angles=result
+            scattering_angles=first_solution
         ) 
     @pyqtSlot()
     def on_angle_solution_selected(self, solution):

{advisor_scattering-0.5.0.dist-info → advisor_scattering-0.5.3.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.5.0
-Summary: Advisor-Scattering: Advanced Visual Scattering Toolkit for Reciprocal-space
+Version: 0.5.3
+Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
-License: Proprietary
+License: MIT
 Project-URL: Homepage, https://github.com/HongXunyang/advisor
 Project-URL: Documentation, https://advisor-scattering.readthedocs.io/en/latest/
-Keywords: scattering,reciprocal-space,pyqt,visualization
+Keywords: scattering,reciprocal-space,pyqt,visualization,x-ray scattering,x-ray diffraction
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: Other/Proprietary License
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.8
@@ -42,25 +42,17 @@ or use the link below to view the demo video.
 ## Install
 - Python 3.8+ with PyQt5, numpy, scipy, matplotlib, Dans_Diffraction (see `requirements.txt`).
 
-From PyPI:
+It is recommened to install from PyPI:
 ```bash
 pip install advisor-scattering
 ```
 
-From source:
-```bash
-python -m venv .venv
-source .venv/bin/activate  # .venv\Scripts\activate on Windows
-pip install -r requirements.txt
-pip install .
-```
-
 ## Run
 ```bash
-advisor-scattering
-# or
 advisor
 # or
+advisor-scattering
+# or
 python -m advisor
 ```
 

{advisor_scattering-0.5.0.dist-info → advisor_scattering-0.5.3.dist-info}/RECORD

@@ -15,15 +15,15 @@ advisor/features/__init__.py,sha256=wQYN67pLXVgxmsoG70WJ51BnE9ACUgbpx-G740KHsEA,
 advisor/features/scattering_geometry/controllers/__init__.py,sha256=2V9KZMlxjHpsBIdkphveylQgL9z6BV09DaufqQcLX_Y,169
 advisor/features/scattering_geometry/controllers/scattering_geometry_controller.py,sha256=QGcm5_y8EPNYUF_FM9xViVzPJs6qh1dB_OA3fjoKAEg,1076
 advisor/features/scattering_geometry/domain/__init__.py,sha256=BsK0j9-RJiK0-g0qB3DH8qoSqlEZNAPBQb7eXYrg0oU,142
-advisor/features/scattering_geometry/domain/brillouin_calculator.py,sha256=zkLtk1aBEbj_SMFb9Zs4gy3-rkB0D1zjhLf9rs9NinY,12760
-advisor/features/scattering_geometry/domain/core.py,sha256=iRVzEDgwbGJ2TeQAV_p_tM3E8ftlo7N-NK1u1c4zfVM,18647
+advisor/features/scattering_geometry/domain/brillouin_calculator.py,sha256=_vpR8T1j1h-agZOlxk4xfpBq1XmbrZsssgookIqYwr0,15620
+advisor/features/scattering_geometry/domain/core.py,sha256=OQ7gZ19XwZPtC3mXukkzlmOiDmgjvKBrVzRNJRi1OuU,20149
 advisor/features/scattering_geometry/ui/__init__.py,sha256=9Lm-sc1Q3KeQ-0kKJneD10MWuqyDgh29QDAVdHghh1Q,154
-advisor/features/scattering_geometry/ui/scattering_geometry_tab.py,sha256=Ya0ad12y6aZi3YdA6JRI9zjajEi5t2yhXQZP9LS3H3E,28020
+advisor/features/scattering_geometry/ui/scattering_geometry_tab.py,sha256=GHczdi74GxCxo3svF7oBdXrbTilLZ4ODkTuatJrfTkE,29448
 advisor/features/scattering_geometry/ui/components/__init__.py,sha256=OsX27CeUv5gznYXmkZWqeXwcskf4DmxOH6xJ0-cUwDg,358
 advisor/features/scattering_geometry/ui/components/angles_to_hkl_components.py,sha256=l6kPM7b95nvNsp1Eg0kmWIfFPTtmuGQyDol_mnx7lOs,4889
-advisor/features/scattering_geometry/ui/components/hk_angles_components.py,sha256=xq7rthCPYgHG6vvz8GziD6e8Q18XURaAktAni0CdC74,15751
-advisor/features/scattering_geometry/ui/components/hkl_scan_components.py,sha256=GU8vgGgy5sAuG15ohLrqQJXEjYDRe8Zfxwb3NEEqT90,19119
-advisor/features/scattering_geometry/ui/components/hkl_to_angles_components.py,sha256=rIh9-4zgidVlvvddF_fzBNlksKMRrsDva9UijkUvXJs,11101
+advisor/features/scattering_geometry/ui/components/hk_angles_components.py,sha256=ZkzRASVeII5dF5_WfwmVBrRwYWTCDNvE05VNa6idxGo,20538
+advisor/features/scattering_geometry/ui/components/hkl_scan_components.py,sha256=JLzbkK1zM8CZm2WZvDyRg-Twwmt46KNKGr1DG7MPfXs,20522
+advisor/features/scattering_geometry/ui/components/hkl_to_angles_components.py,sha256=0J-CXiBCTOoLjFK5-PgY0PjZSG1aU7sYrE-MilJSAEA,15834
 advisor/features/structure_factor/controllers/__init__.py,sha256=aGyA8cXJ64HfULWo6_6D4azt4Hs8qJ6wH_OW6BClv9Y,158
 advisor/features/structure_factor/controllers/structure_factor_controller.py,sha256=4PBHg8lPXcQA7Tpocu3A3GzGQP2IZP8CNPH6PILHyWw,975
 advisor/features/structure_factor/domain/__init__.py,sha256=lNxY4RcTYCSboXpAWJfib29WqYg6o4jesbNk-Z279rU,159
@@ -62,8 +62,8 @@ advisor/ui/visualizers/scattering_visualizer.py,sha256=iyjTgy1WbqI7G0BpiJ59CKFCI
 advisor/ui/visualizers/structure_factor_visualizer.py,sha256=Rt9ui7Qv4vvDCWiuIngoYzHJlFVef8M_h3BBRcmuFTc,15866
 advisor/ui/visualizers/structure_factor_visualizer_2d.py,sha256=xA1hrp7pKIfgD1G_Pt-uemHggmKf-7QC94dS-GasZI4,8119
 advisor/ui/visualizers/unitcell_visualizer.py,sha256=gwpMkU1YIu-8zkKVu5bHpyu_iLbzYEYTbVArchNMLOI,21384
-advisor_scattering-0.5.0.dist-info/METADATA,sha256=p3_-h7Es7v_XPvW_0lLCANgS8m-OpY8E37EqsqVNSp0,4721
-advisor_scattering-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-advisor_scattering-0.5.0.dist-info/entry_points.txt,sha256=b__0W6TTAPUTc0UIUyHdxvxtsVz025Y-QNrMKzt8b9o,83
-advisor_scattering-0.5.0.dist-info/top_level.txt,sha256=4YoJT7oclQ2yU-4KY0AB36cfAZG9yAI1tJNHrxEioMA,8
-advisor_scattering-0.5.0.dist-info/RECORD,,
+advisor_scattering-0.5.3.dist-info/METADATA,sha256=flwNil7WdTQXXr4pfw32egU2fBC6B7ewfvzcwMLH1Fg,4658
+advisor_scattering-0.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+advisor_scattering-0.5.3.dist-info/entry_points.txt,sha256=b__0W6TTAPUTc0UIUyHdxvxtsVz025Y-QNrMKzt8b9o,83
+advisor_scattering-0.5.3.dist-info/top_level.txt,sha256=4YoJT7oclQ2yU-4KY0AB36cfAZG9yAI1tJNHrxEioMA,8
+advisor_scattering-0.5.3.dist-info/RECORD,,

{advisor_scattering-0.5.0.dist-info → advisor_scattering-0.5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any