advisor-scattering 0.5.2__py3-none-any.whl → 0.9.1__py3-none-any.whl

advisor/ui/dialogs/diffraction_test_dialog.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dialog for importing orientation from diffraction test data."""
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import (QDialog, QDoubleSpinBox, QFormLayout, QGroupBox,
+                             QHBoxLayout, QHeaderView, QLabel, QMessageBox,
+                             QPushButton, QTableWidget, QTableWidgetItem,
+                             QVBoxLayout)
+
+from advisor.domain.orientation import fit_orientation_from_diffraction_tests
+
+
+class DiffractionTestDialog(QDialog):
+    """Dialog for entering diffraction test data and calculating orientation.
+
+    This dialog allows users to input multiple diffraction tests (H, K, L, energy,
+    tth, theta, phi, chi) and calculates the optimal Euler angles (roll, pitch, yaw)
+    that best fit the data.
+    """
+
+    def __init__(self, lattice_params: dict, parent=None):
+        """Initialize the dialog.
+
+        Args:
+            lattice_params: Dictionary containing lattice parameters (a, b, c, alpha, beta, gamma)
+            parent: Parent widget
+        """
+        super().__init__(parent)
+        self.lattice_params = lattice_params
+        self.result = None  # Will store (roll, pitch, yaw) on success
+
+        self.setWindowTitle("Import Orientation from Diffraction Tests")
+        self.setMinimumWidth(800)
+        self.setMinimumHeight(550)
+
+        self._init_ui()
+
+    def _init_ui(self):
+        """Initialize the UI components."""
+        layout = QVBoxLayout(self)
+
+        # Instructions label
+        instructions = QLabel(
+            "Enter diffraction test data below. Each row represents a measurement "
+            "with known HKL indices and measured angles. At least one test is required."
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Table for diffraction tests
+        self.table = QTableWidget()
+        self.table.setColumnCount(8)
+        self.table.setHorizontalHeaderLabels(
+            ["H", "K", "L", "Energy (eV)", "tth (°)", "θ (°)", "φ (°)", "χ (°)"]
+        )
+
+        # Set column resize mode
+        header = self.table.horizontalHeader()
+        for i in range(8):
+            header.setSectionResizeMode(i, QHeaderView.Stretch)
+
+        # Add initial empty rows
+        self._add_row()
+        self._add_row()
+
+        layout.addWidget(self.table)
+
+        # Row management buttons
+        row_buttons_layout = QHBoxLayout()
+
+        add_row_btn = QPushButton("Add Row")
+        add_row_btn.clicked.connect(self._add_row)
+        row_buttons_layout.addWidget(add_row_btn)
+
+        remove_row_btn = QPushButton("Remove Selected Row")
+        remove_row_btn.clicked.connect(self._remove_selected_row)
+        row_buttons_layout.addWidget(remove_row_btn)
+
+        row_buttons_layout.addStretch()
+        layout.addLayout(row_buttons_layout)
+
+        # Results display area
+        self.results_group = QGroupBox("Calculated Orientation")
+        results_layout = QFormLayout(self.results_group)
+
+        self.roll_result = QDoubleSpinBox()
+        self.roll_result.setRange(-180, 180)
+        self.roll_result.setDecimals(4)
+        self.roll_result.setReadOnly(True)
+        self.roll_result.setSuffix(" °")
+        results_layout.addRow("Roll:", self.roll_result)
+
+        self.pitch_result = QDoubleSpinBox()
+        self.pitch_result.setRange(-180, 180)
+        self.pitch_result.setDecimals(4)
+        self.pitch_result.setReadOnly(True)
+        self.pitch_result.setSuffix(" °")
+        results_layout.addRow("Pitch:", self.pitch_result)
+
+        self.yaw_result = QDoubleSpinBox()
+        self.yaw_result.setRange(-180, 180)
+        self.yaw_result.setDecimals(4)
+        self.yaw_result.setReadOnly(True)
+        self.yaw_result.setSuffix(" °")
+        results_layout.addRow("Yaw:", self.yaw_result)
+
+        self.error_label = QLabel("Residual Error: --")
+        results_layout.addRow(self.error_label)
+
+        self.results_group.setVisible(False)
+        layout.addWidget(self.results_group)
+
+        # Action buttons
+        button_layout = QHBoxLayout()
+
+        self.calculate_btn = QPushButton("Calculate Orientation")
+        self.calculate_btn.clicked.connect(self._calculate_orientation)
+        button_layout.addWidget(self.calculate_btn)
+
+        self.apply_btn = QPushButton("Apply and Close")
+        self.apply_btn.clicked.connect(self._apply_and_close)
+        self.apply_btn.setEnabled(False)
+        button_layout.addWidget(self.apply_btn)
+
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        button_layout.addWidget(cancel_btn)
+
+        layout.addLayout(button_layout)
+
+    def _add_row(self):
+        """Add a new empty row to the table."""
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+
+        # Set default values (H, K, L, energy, tth, theta, phi, chi)
+        defaults = [0.0, 0.0, 0.0, 2200.0, 90.0, 45.0, 0.0, 0.0]
+        for col, default in enumerate(defaults):
+            item = QTableWidgetItem(str(default))
+            item.setTextAlignment(Qt.AlignCenter)
+            self.table.setItem(row, col, item)
+
+    def _remove_selected_row(self):
+        """Remove the currently selected row."""
+        current_row = self.table.currentRow()
+        if current_row >= 0:
+            self.table.removeRow(current_row)
+        elif self.table.rowCount() > 0:
+            # If no row selected, remove the last row
+            self.table.removeRow(self.table.rowCount() - 1)
+
+    def _get_diffraction_tests(self) -> list:
+        """Extract diffraction test data from the table.
+
+        Returns:
+            List of dictionaries containing test data, or None if validation fails.
+        """
+        tests = []
+        for row in range(self.table.rowCount()):
+            try:
+                test = {
+                    "H": float(self.table.item(row, 0).text()),
+                    "K": float(self.table.item(row, 1).text()),
+                    "L": float(self.table.item(row, 2).text()),
+                    "energy": float(self.table.item(row, 3).text()),
+                    "tth": float(self.table.item(row, 4).text()),
+                    "theta": float(self.table.item(row, 5).text()),
+                    "phi": float(self.table.item(row, 6).text()),
+                    "chi": float(self.table.item(row, 7).text()),
+                }
+                tests.append(test)
+            except (ValueError, AttributeError) as e:
+                QMessageBox.warning(
+                    self,
+                    "Invalid Input",
+                    f"Row {row + 1} contains invalid data. Please enter numeric values.\n\nError: {e}",
+                )
+                return None
+
+        if not tests:
+            QMessageBox.warning(
+                self,
+                "No Data",
+                "Please enter at least one diffraction test.",
+            )
+            return None
+
+        return tests
+
+    def _calculate_orientation(self):
+        """Calculate the optimal orientation from the entered data."""
+        tests = self._get_diffraction_tests()
+        if tests is None:
+            return
+
+        # Run the fitting algorithm
+        result = fit_orientation_from_diffraction_tests(
+            self.lattice_params, tests
+        )
+
+        if not result["success"]:
+            QMessageBox.warning(
+                self,
+                "Calculation Failed",
+                f"Failed to calculate orientation:\n\n{result.get('message', 'Unknown error')}",
+            )
+            return
+
+        # Display results (overwrites any previous results)
+        self.roll_result.setValue(result["roll"])
+        self.pitch_result.setValue(result["pitch"])
+        self.yaw_result.setValue(result["yaw"])
+        self.error_label.setText(f"Residual Error: {result['residual_error']:.6f}")
+
+        # Update group title to indicate results are current
+        self.results_group.setTitle("Calculated Orientation (Updated)")
+        self.results_group.setVisible(True)
+        self.apply_btn.setEnabled(True)
+
+        # Store result for later retrieval
+        self.result = {
+            "roll": result["roll"],
+            "pitch": result["pitch"],
+            "yaw": result["yaw"],
+        }
+
+        # Show detailed errors if available
+        if result.get("individual_errors"):
+            error_text = "Individual test errors:\n"
+            for i, err in enumerate(result["individual_errors"]):
+                error_text += (
+                    f"  Test {i+1}: ΔH={err['H_error']:.4f}, "
+                    f"ΔK={err['K_error']:.4f}, ΔL={err['L_error']:.4f}\n"
+                )
+            QMessageBox.information(
+                self,
+                "Calculation Complete",
+                f"Orientation calculated successfully!\n\n"
+                f"Roll: {result['roll']:.4f}°\n"
+                f"Pitch: {result['pitch']:.4f}°\n"
+                f"Yaw: {result['yaw']:.4f}°\n\n"
+                f"Residual Error: {result['residual_error']:.6f}\n\n"
+                f"{error_text}",
+            )
+
+    def _apply_and_close(self):
+        """Apply the calculated orientation and close the dialog."""
+        if self.result is not None:
+            self.accept()
+        else:
+            QMessageBox.warning(
+                self,
+                "No Result",
+                "Please calculate the orientation first.",
+            )
+
+    def get_result(self) -> dict:
+        """Get the calculated orientation.
+
+        Returns:
+            Dictionary with roll, pitch, yaw values, or None if not calculated.
+        """
+        return self.result

advisor/ui/init_window.py

@@ -19,6 +19,7 @@ from PyQt5.QtGui import QDragEnterEvent, QDropEvent
 from advisor.domain import UnitConverter
 from advisor.ui.utils import readcif
 from advisor.ui.visualizers import CoordinateVisualizer, UnitcellVisualizer
+from advisor.ui.dialogs import DiffractionTestDialog
 
 
 class DragDropLineEdit(QLineEdit):
@@ -219,6 +220,14 @@ class InitWindow(QWidget):
         self.yaw_input.valueChanged.connect(self.update_visualization)
         euler_layout.addRow("Yaw:", self.yaw_input)
 
+        # Add "Import from Diffraction Test" button
+        self.import_orientation_btn = QPushButton("Import from Diffraction Test")
+        self.import_orientation_btn.setToolTip(
+            "Calculate Euler angles from known diffraction measurements"
+        )
+        self.import_orientation_btn.clicked.connect(self.open_diffraction_test_dialog)
+        euler_layout.addRow(self.import_orientation_btn)
+
         # Add euler group to main layout at (0,2)
         layout.addWidget(euler_group, 0, 2)
 
@@ -283,6 +292,30 @@ class InitWindow(QWidget):
             self.file_path_input.setText(file_path)
             # on_cif_file_changed will be triggered by textChanged
 
+    @pyqtSlot()
+    def open_diffraction_test_dialog(self):
+        """Open the diffraction test dialog to import orientation from measurements."""
+        # Gather current lattice parameters
+        lattice_params = {
+            "a": self.a_input.value(),
+            "b": self.b_input.value(),
+            "c": self.c_input.value(),
+            "alpha": self.alpha_input.value(),
+            "beta": self.beta_input.value(),
+            "gamma": self.gamma_input.value(),
+        }
+
+        # Open the dialog
+        dialog = DiffractionTestDialog(lattice_params, self)
+        if dialog.exec_() == DiffractionTestDialog.Accepted:
+            result = dialog.get_result()
+            if result is not None:
+                # Apply the calculated Euler angles
+                self.roll_input.setValue(result["roll"])
+                self.pitch_input.setValue(result["pitch"])
+                self.yaw_input.setValue(result["yaw"])
+                # update_visualization will be triggered by valueChanged signals
+
     def set_lattice_inputs_enabled(self, enabled: bool):
         """Enable/disable lattice parameter inputs (a,b,c,alpha,beta,gamma)."""
         self.a_input.setEnabled(enabled)

{advisor_scattering-0.5.2.dist-info → advisor_scattering-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: advisor-scattering
-Version: 0.5.2
+Version: 0.9.1
 Summary: Advisor-Scattering: Advanced Visual X-ray Scattering Toolkit for Reciprocal-space visualization and calculation
 Author: Xunyang Hong
 License: MIT
@@ -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.2.dist-info → advisor_scattering-0.9.1.dist-info}/RECORD

@@ -2,28 +2,30 @@ advisor/__init__.py,sha256=9gmF8qfMHMVLbmvWW_20KkHU5zOCwUmmFHtju21klPQ,103
 advisor/__main__.py,sha256=FueZKRQwCGBKNtk4W_Z9yYpsI0YB5WiVREWyZXmSl8A,124
 advisor/app.py,sha256=52DxOOlZV_NHUzsnuYCCo_cI48D2THKE1m0-1ZVoNvE,1165
 advisor/controllers/__init__.py,sha256=DEzJDUTJcRrbe7ZYnYsQQ3NvnyayNwTafcQmY7aRtrw,198
-advisor/controllers/app_controller.py,sha256=cl7sKgfyz9J2o7RLgP18mExNjU_FDK5rUPrdmI15b1g,2344
+advisor/controllers/app_controller.py,sha256=CGqlhez9467JMZZeMbnbF-HwqwCayoYIfajy4vRBZtE,2433
 advisor/controllers/feature_controller.py,sha256=6_XOck8ipQxbef24y16tCE08q7OUT0gs285d5tF5XRs,642
-advisor/domain/__init__.py,sha256=Lkpnerzg6qHzk-u4jOAU1rg6rYY4iIorIECdOTPd2DY,536
+advisor/domain/__init__.py,sha256=SuMfLp1CJFqrpBE6UeyVe9BWdjbBlcwuHRTBN-UsOzg,733
 advisor/domain/geometry.py,sha256=E8YmecQpBh7PQeJIamOlPo2aBgJSbhyBlrYS02uxFMg,6856
+advisor/domain/orientation.py,sha256=PDPxosByY_Yo7FePUAZLsrN1OcH4_kUiF8TwC5jFGL8,7649
+advisor/domain/orientation_calculator.py,sha256=5AKd5OqsQWTKgB3kv83aM7eLq9TEAlPXJ-C79X65dV8,5872
 advisor/domain/unit_converter.py,sha256=D20FvdV7_ilAX7KDPxQ1GDCA6IxdjjcQ2QBiahb3lLI,2085
 advisor/domain/core/__init__.py,sha256=UPDQYo7-5f9Ghx3p6qlwljTLhHsxlGmEl_MvdaHM2Jg,173
-advisor/domain/core/lab.py,sha256=pLA5DhG_LMbJhbEABN53BU0FdTUAZbA38jiPjXzd29g,4871
-advisor/domain/core/lattice.py,sha256=UXxkZG6iHGLXwHPEH6VQLXAg274rD3BTpq4ObDIOxIg,2728
-advisor/domain/core/sample.py,sha256=iMPvQprPGllp6WfwnsESzNode4tujYNbVHhcNL6Uhuk,4105
-advisor/features/__init__.py,sha256=wQYN67pLXVgxmsoG70WJ51BnE9ACUgbpx-G740KHsEA,272
+advisor/domain/core/lab.py,sha256=_IbRVbPvffkM73f41uJ3R43ZeZ6LOxNOrywWz_DDT_8,5129
+advisor/domain/core/lattice.py,sha256=339_veWj1KFTAwuH37-vx5a9wjUfQzJI6MoSxMm8tX8,2757
+advisor/domain/core/sample.py,sha256=zz0qMlpeGHEXmmkoY1GtOBI5-uK4hhOVeLjuje6-Osc,4278
+advisor/features/__init__.py,sha256=Arhqas6uY2uJp58ttNEVap9gRYE0uOVw1dA6gtB9544,330
 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=pMpjq5HbutFzWubo-x7goOY2N_7OjqALYZN8zGQkfsQ,16044
+advisor/features/scattering_geometry/domain/core.py,sha256=2JdHNjdl_GnyhOr0iGRMgTK1JlYFg6WA0uWe0mYUgyY,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
@@ -49,10 +51,12 @@ advisor/resources/icons/sf_calculator.jpg,sha256=W7e89x2K6np5l200hklRfdh0pkA3SGz
 advisor/resources/icons/sf_calculator.png,sha256=ArnSfIQo8Gc8uWQhpG7DTCBNFcuVGXDIiQ7Yb-x9D_M,44466
 advisor/resources/qss/styles.qss,sha256=R29qftSIvN0AI1UVsLSsHcUImIYGnbbuF_1LvViF3mg,8070
 advisor/ui/__init__.py,sha256=isDNFKHsZq1s8Och-5tHcFC5FAJA653x4r5DYGsVowU,202
-advisor/ui/init_window.py,sha256=pOxGUfKcObnQKcGDKtEbBmQ18yOOfwEY1SxhHO3DRqs,22273
+advisor/ui/init_window.py,sha256=dQTTLNNiBVyDtSKqFOPicg3Su75ikfCKBB8Avy6_6_4,23751
 advisor/ui/main_window.py,sha256=I5vCpPPQCwaSag538YPQC_bgarVJGQ1ryuxjWxuMP-0,6170
 advisor/ui/tab_interface.py,sha256=8okMV0NurIyEGxRf-YXHrjftzWyMzXcea3cdt3i1FtE,1180
 advisor/ui/tips.py,sha256=5iP28xJvKBkdgvo3eDD2kzV52FEeT_Sd8ivtWlhi0Xs,742
+advisor/ui/dialogs/__init__.py,sha256=yFeoZOe0euOXeie-fqwJquZ9Vhl8mtszIWg1aunawXI,197
+advisor/ui/dialogs/diffraction_test_dialog.py,sha256=33MZCYlSn0ZhSp-Q5Cj1n0xbgbtSJugCD-KaiZCmxcY,9608
 advisor/ui/utils/__init__.py,sha256=U_IwI_KEtmKLMKw6e2ko7GkUa50-PvkeMFS_6QfHoyg,84
 advisor/ui/utils/readcif.py,sha256=tRuz1WSBr8XWkgf6VUOlS5aTf2LYDi8CY4peJ1_0bjI,4554
 advisor/ui/visualizers/HKLScan2DVisualizer.py,sha256=Q8_MWKiyzrFk4-3S50Ro7_4I_ERbSagG52686lPSuFo,8706
@@ -62,8 +66,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.2.dist-info/METADATA,sha256=0-JbQeeYH27llKjMRSoDGo4Hhs6jQ6ubMPFpiuNd3Q8,4786
-advisor_scattering-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-advisor_scattering-0.5.2.dist-info/entry_points.txt,sha256=b__0W6TTAPUTc0UIUyHdxvxtsVz025Y-QNrMKzt8b9o,83
-advisor_scattering-0.5.2.dist-info/top_level.txt,sha256=4YoJT7oclQ2yU-4KY0AB36cfAZG9yAI1tJNHrxEioMA,8
-advisor_scattering-0.5.2.dist-info/RECORD,,
+advisor_scattering-0.9.1.dist-info/METADATA,sha256=rg86280T-GTYofxoa9BMwSJcNEcP_Rmf8JoHECbDP60,4658
+advisor_scattering-0.9.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+advisor_scattering-0.9.1.dist-info/entry_points.txt,sha256=b__0W6TTAPUTc0UIUyHdxvxtsVz025Y-QNrMKzt8b9o,83
+advisor_scattering-0.9.1.dist-info/top_level.txt,sha256=4YoJT7oclQ2yU-4KY0AB36cfAZG9yAI1tJNHrxEioMA,8
+advisor_scattering-0.9.1.dist-info/RECORD,,

{advisor_scattering-0.5.2.dist-info → advisor_scattering-0.9.1.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