setiastrosuitepro 1.6.2__py3-none-any.whl → 1.6.12__py3-none-any.whl

setiastro/saspro/wimi.py

@@ -2596,12 +2596,12 @@ class WIMIDialog(QDialog):
         button_layout = QHBoxLayout()
         
         # Load button
-        self.load_button = QPushButton("Load Image File")
+        self.load_button = QPushButton(self.tr("Load Image File"))
         self.load_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogStart))
         self.load_button.clicked.connect(self.open_image)
 
         self.load_from_view_btn = QToolButton()
-        self.load_from_view_btn.setText("Load from View")
+        self.load_from_view_btn.setText(self.tr("Load from View"))
         self.load_from_view_btn.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
         self.load_from_view_btn.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DirOpenIcon))
         self.load_from_view_menu = QMenu(self)
@@ -2611,7 +2611,7 @@ class WIMIDialog(QDialog):
         button_layout.addWidget(self.load_from_view_btn)
 
         # AutoStretch button
-        self.auto_stretch_button = QPushButton("AutoStretch")
+        self.auto_stretch_button = QPushButton(self.tr("AutoStretch"))
         self.auto_stretch_button.clicked.connect(self.toggle_autostretch)
 
         # Add both buttons to the horizontal layout
@@ -2622,7 +2622,7 @@ class WIMIDialog(QDialog):
         left_panel.addLayout(button_layout)
 
         # Create the instruction QLabel for search region
-        search_region_instruction_label = QLabel("Shift+Click to define a search region")
+        search_region_instruction_label = QLabel(self.tr("Shift+Click to define a search region"))
         search_region_instruction_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         search_region_instruction_label.setStyleSheet("font-size: 15px; color: gray;")
 
@@ -2632,12 +2632,12 @@ class WIMIDialog(QDialog):
 
 
         # Query Simbad button
-        self.query_button = QPushButton("Query Simbad")
+        self.query_button = QPushButton(self.tr("Query Simbad"))
         self.query_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogApplyButton))
         left_panel.addWidget(self.query_button)
         self.query_button.clicked.connect(lambda: self.query_simbad(self.get_defined_radius()))
 
-        self.legend_button = QPushButton("Legend")
+        self.legend_button = QPushButton(self.tr("Legend"))
         self.legend_button.clicked.connect(self.show_legend)
         left_panel.addWidget(self.legend_button)
 
@@ -2645,12 +2645,12 @@ class WIMIDialog(QDialog):
         show_clear_layout = QHBoxLayout()
 
         # Create the Show Object Names checkbox
-        self.show_names_checkbox = QCheckBox("Show Object Names")
+        self.show_names_checkbox = QCheckBox(self.tr("Show Object Names"))
         self.show_names_checkbox.stateChanged.connect(self.toggle_object_names)  # Connect to a function to toggle names
         show_clear_layout.addWidget(self.show_names_checkbox)
 
         # Create the Clear Results button
-        self.clear_results_button = QPushButton("Clear Results")
+        self.clear_results_button = QPushButton(self.tr("Clear Results"))
         self.clear_results_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton))
         self.clear_results_button.clicked.connect(self.clear_search_results)  # Connect to a function to clear results
         show_clear_layout.addWidget(self.clear_results_button)
@@ -2662,7 +2662,7 @@ class WIMIDialog(QDialog):
         button_layout = QHBoxLayout()
 
         # Show Visible Objects Only button
-        self.toggle_visible_objects_button = QPushButton("Show Visible Objects Only")
+        self.toggle_visible_objects_button = QPushButton(self.tr("Show Visible Objects Only"))
         self.toggle_visible_objects_button.setCheckable(True)  # Toggle button state
         self.toggle_visible_objects_button.setIcon(QIcon(eye_icon_path))
         self.toggle_visible_objects_button.clicked.connect(self.filter_visible_objects)
@@ -2670,7 +2670,7 @@ class WIMIDialog(QDialog):
         button_layout.addWidget(self.toggle_visible_objects_button)
 
         # Save CSV button
-        self.save_csv_button = QPushButton("Save CSV")
+        self.save_csv_button = QPushButton(self.tr("Save CSV"))
         self.save_csv_button.setIcon(QIcon(csv_icon_path))
         self.save_csv_button.clicked.connect(self.save_results_as_csv)
         button_layout.addWidget(self.save_csv_button)
@@ -2679,7 +2679,7 @@ class WIMIDialog(QDialog):
         left_panel.addLayout(button_layout)  
 
         # Advanced Search Button
-        self.advanced_search_button = QPushButton("Advanced Search")
+        self.advanced_search_button = QPushButton(self.tr("Advanced Search"))
         self.advanced_search_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogDetailedView))
         self.advanced_search_button.setCheckable(True)
         self.advanced_search_button.clicked.connect(self.toggle_advanced_search)
@@ -2693,14 +2693,14 @@ class WIMIDialog(QDialog):
         self.advanced_search_panel_widget.setVisible(False)  # Hide initially        
 
         # Status label
-        self.status_label = QLabel("Status: Ready")
+        self.status_label = QLabel(self.tr("Status: Ready"))
         left_panel.addWidget(self.status_label)
 
         # Create a horizontal layout
         button_layout = QHBoxLayout()
 
         # Copy RA/Dec to Clipboard button
-        self.copy_button = QPushButton("Copy RA/Dec to Clipboard", self)
+        self.copy_button = QPushButton(self.tr("Copy RA/Dec to Clipboard"), self)
         self.copy_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_CommandLink))
         self.copy_button.clicked.connect(self.copy_ra_dec_to_clipboard)
         button_layout.addWidget(self.copy_button)
@@ -2715,23 +2715,23 @@ class WIMIDialog(QDialog):
         left_panel.addLayout(button_layout)
         
          # Save Plate Solved Fits Button
-        self.save_plate_solved_button = QPushButton("Save Plate Solved Fits")
+        self.save_plate_solved_button = QPushButton(self.tr("Save Plate Solved Fits"))
         self.save_plate_solved_button.setIcon(QIcon(disk_icon_path))
         self.save_plate_solved_button.clicked.connect(self.save_plate_solved_fits)
         left_panel.addWidget(self.save_plate_solved_button)       
 
         # RA/Dec Labels
         ra_dec_layout = QHBoxLayout()
-        self.ra_label = QLabel("RA: N/A")
-        self.dec_label = QLabel("Dec: N/A")
-        self.orientation_label = QLabel("Orientation: N/A°")
+        self.ra_label = QLabel(self.tr("RA: N/A"))
+        self.dec_label = QLabel(self.tr("Dec: N/A"))
+        self.orientation_label = QLabel(self.tr("Orientation: N/A°"))
         ra_dec_layout.addWidget(self.ra_label)
         ra_dec_layout.addWidget(self.dec_label)
         ra_dec_layout.addWidget(self.orientation_label)
         left_panel.addLayout(ra_dec_layout)
 
         # Mini Preview
-        self.mini_preview = QLabel("Mini Preview")
+        self.mini_preview = QLabel(self.tr("Mini Preview"))
         self.mini_preview.setMaximumSize(300, 300)
         self.mini_preview.mousePressEvent = self.on_mini_preview_press
         self.mini_preview.mouseMoveEvent = self.on_mini_preview_drag
@@ -2746,9 +2746,9 @@ class WIMIDialog(QDialog):
 
         # Zoom buttons above the main preview
         zoom_controls_layout = QHBoxLayout()
-        self.zoom_in_button = QPushButton("Zoom In")
+        self.zoom_in_button = QPushButton(self.tr("Zoom In"))
         self.zoom_in_button.clicked.connect(self.zoom_in)
-        self.zoom_out_button = QPushButton("Zoom Out")
+        self.zoom_out_button = QPushButton(self.tr("Zoom Out"))
         self.zoom_out_button.clicked.connect(self.zoom_out)
         zoom_controls_layout.addWidget(self.zoom_in_button)
         zoom_controls_layout.addWidget(self.zoom_out_button)
@@ -2783,28 +2783,28 @@ class WIMIDialog(QDialog):
         save_buttons_layout = QHBoxLayout()
 
         # Button to toggle annotation tools section
-        self.show_annotations_button = QPushButton("Show Annotation Tools")
+        self.show_annotations_button = QPushButton(self.tr("Show Annotation Tools"))
         self.show_annotations_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogResetButton))
         self.show_annotations_button.clicked.connect(self.toggle_annotation_tools)
         save_buttons_layout.addWidget(self.show_annotations_button)
         
-        self.save_annotated_button = QPushButton("Save Annotated Image")
+        self.save_annotated_button = QPushButton(self.tr("Save Annotated Image"))
         self.save_annotated_button.setIcon(QIcon(annotated_path))
         self.save_annotated_button.clicked.connect(self.save_annotated_image)
         save_buttons_layout.addWidget(self.save_annotated_button)
         
-        self.save_collage_button = QPushButton("Save Collage of Objects")
+        self.save_collage_button = QPushButton(self.tr("Save Collage of Objects"))
         self.save_collage_button.setIcon(QIcon(collage_path))
         self.save_collage_button.clicked.connect(self.save_collage_of_objects)
         save_buttons_layout.addWidget(self.save_collage_button)
 
         # New 3D View Button
-        self.show_3d_view_button = QPushButton("3D Distance Model")
+        self.show_3d_view_button = QPushButton(self.tr("3D Distance Model"))
         self.show_3d_view_button.clicked.connect(self.show_3d_model_view)
         self.show_3d_view_button.setIcon(    QApplication.style().standardIcon(QStyle.StandardPixmap.SP_TitleBarNormalButton))
         save_buttons_layout.addWidget(self.show_3d_view_button)
 
-        self.show_hr_button = QPushButton("H-R Diagram")
+        self.show_hr_button = QPushButton(self.tr("H-R Diagram"))
         # Optionally give it an icon:
         self.show_hr_button.setIcon(QApplication.style().standardIcon(
             QStyle.StandardPixmap.SP_DesktopIcon))
@@ -2821,10 +2821,10 @@ class WIMIDialog(QDialog):
         label_layout = QHBoxLayout()
 
         # Create the label to display the count of objects
-        self.object_count_label = QLabel("Objects Found: 0")
+        self.object_count_label = QLabel(self.tr("Objects Found: 0"))
 
         # Create the label with instructions
-        self.instructions_label = QLabel("Right Click a Row for More Options")
+        self.instructions_label = QLabel(self.tr("Right Click a Row for More Options"))
 
         # Add both labels to the horizontal layout
         label_layout.addWidget(self.object_count_label)
@@ -2850,61 +2850,61 @@ class WIMIDialog(QDialog):
         self.annotation_tools_section = QWidget()
         annotation_tools_layout = QGridLayout(self.annotation_tools_section)
 
-        annotation_instruction_label = QLabel("Ctrl+Click to add items, Alt+Click to measure distance")
+        annotation_instruction_label = QLabel(self.tr("Ctrl+Click to add items, Alt+Click to measure distance"))
         annotation_instruction_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         annotation_instruction_label.setStyleSheet("font-size: 10px; color: gray;")        
 
-        self.draw_ellipse_button = QPushButton("Draw Ellipse")
+        self.draw_ellipse_button = QPushButton(self.tr("Draw Ellipse"))
         self.draw_ellipse_button.tool_name = "Ellipse"
         self.draw_ellipse_button.clicked.connect(lambda: self.set_tool("Ellipse"))
         self.annotation_buttons.append(self.draw_ellipse_button)
 
-        self.freehand_button = QPushButton("Freehand (Lasso)")
+        self.freehand_button = QPushButton(self.tr("Freehand (Lasso)"))
         self.freehand_button.tool_name = "Freehand"
         self.freehand_button.clicked.connect(lambda: self.set_tool("Freehand"))
         self.annotation_buttons.append(self.freehand_button)
 
-        self.draw_rectangle_button = QPushButton("Draw Rectangle")
+        self.draw_rectangle_button = QPushButton(self.tr("Draw Rectangle"))
         self.draw_rectangle_button.tool_name = "Rectangle"
         self.draw_rectangle_button.clicked.connect(lambda: self.set_tool("Rectangle"))
         self.annotation_buttons.append(self.draw_rectangle_button)
 
-        self.draw_arrow_button = QPushButton("Draw Arrow")
+        self.draw_arrow_button = QPushButton(self.tr("Draw Arrow"))
         self.draw_arrow_button.tool_name = "Arrow"
         self.draw_arrow_button.clicked.connect(lambda: self.set_tool("Arrow"))
         self.annotation_buttons.append(self.draw_arrow_button)
 
-        self.place_compass_button = QPushButton("Place Celestial Compass")
+        self.place_compass_button = QPushButton(self.tr("Place Celestial Compass"))
         self.place_compass_button.tool_name = "Compass"
         self.place_compass_button.clicked.connect(lambda: self.set_tool("Compass"))
         self.annotation_buttons.append(self.place_compass_button)
 
-        self.add_text_button = QPushButton("Add Text")
+        self.add_text_button = QPushButton(self.tr("Add Text"))
         self.add_text_button.tool_name = "Text"
         self.add_text_button.clicked.connect(lambda: self.set_tool("Text"))
         self.annotation_buttons.append(self.add_text_button)
 
         # Add Color and Font buttons
-        self.color_button = QPushButton("Select Color")
+        self.color_button = QPushButton(self.tr("Select Color"))
         self.color_button.setIcon(QIcon(colorwheel_path))
         self.color_button.clicked.connect(self.select_color)
 
-        self.font_button = QPushButton("Select Font")
+        self.font_button = QPushButton(self.tr("Select Font"))
         self.font_button.setIcon(QIcon(font_path))
         self.font_button.clicked.connect(self.select_font)
 
         # Undo button
-        self.undo_button = QPushButton("Undo")
+        self.undo_button = QPushButton(self.tr("Undo"))
         self.undo_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_ArrowLeft))  # Left arrow icon for undo
         self.undo_button.clicked.connect(self.main_preview.undo_annotation)  # Connect to undo_annotation in CustomGraphicsView
 
         # Clear Annotations button
-        self.clear_annotations_button = QPushButton("Clear Annotations")
+        self.clear_annotations_button = QPushButton(self.tr("Clear Annotations"))
         self.clear_annotations_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_TrashIcon))  # Trash icon
         self.clear_annotations_button.clicked.connect(self.main_preview.clear_annotations)  # Connect to clear_annotations in CustomGraphicsView
 
         # Delete Selected Object button
-        self.delete_selected_object_button = QPushButton("Delete Selected Object(s)")
+        self.delete_selected_object_button = QPushButton(self.tr("Delete Selected Items"))
         self.delete_selected_object_button.setIcon(QApplication.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton))  # Trash icon
         self.delete_selected_object_button.clicked.connect(self.main_preview.delete_selected_objects)
 
@@ -2928,12 +2928,12 @@ class WIMIDialog(QDialog):
         right_panel.addWidget(self.annotation_tools_section)
 
         # Advanced Search Panel
-        self.advanced_param_label = QLabel("Advanced Search Parameters")
+        self.advanced_param_label = QLabel(self.tr("Advanced Search Parameters"))
         self.advanced_search_panel.addWidget(self.advanced_param_label)
 
         # TreeWidget for object types
         self.object_tree = QTreeWidget()
-        self.object_tree.setHeaderLabels(["Object Type", "Description"])
+        self.object_tree.setHeaderLabels([self.tr("Object Type"), self.tr("Description")])
         self.object_tree.setColumnWidth(0, 150)
         self.object_tree.setSortingEnabled(True)
 
@@ -2949,17 +2949,17 @@ class WIMIDialog(QDialog):
         toggle_buttons_layout = QHBoxLayout()
 
         # Toggle All
-        self.toggle_all_button = QPushButton("Toggle All")
+        self.toggle_all_button = QPushButton(self.tr("Toggle All"))
         self.toggle_all_button.clicked.connect(self.toggle_all_items)
         toggle_buttons_layout.addWidget(self.toggle_all_button)
 
         # Save Custom List
-        self.save_list_button = QPushButton("Save List…")
+        self.save_list_button = QPushButton(self.tr("Save List…"))
         self.save_list_button.clicked.connect(self.save_custom_list)
         toggle_buttons_layout.addWidget(self.save_list_button)
 
         # Load Custom List
-        self.load_list_button = QPushButton("Load List…")
+        self.load_list_button = QPushButton(self.tr("Load List…"))
         self.load_list_button.clicked.connect(self.load_custom_list)
         toggle_buttons_layout.addWidget(self.load_list_button)
 
@@ -2968,11 +2968,11 @@ class WIMIDialog(QDialog):
         # Add Simbad Search buttons below the toggle buttons
         search_button_layout = QHBoxLayout()
 
-        self.simbad_defined_region_button = QPushButton("Search Defined Region")
+        self.simbad_defined_region_button = QPushButton(self.tr("Search Defined Region"))
         self.simbad_defined_region_button.clicked.connect(self.search_defined_region)
         search_button_layout.addWidget(self.simbad_defined_region_button)
 
-        self.simbad_entire_image_button = QPushButton("Search Entire Image")
+        self.simbad_entire_image_button = QPushButton(self.tr("Search Entire Image"))
         self.simbad_entire_image_button.clicked.connect(self.search_entire_image)
         search_button_layout.addWidget(self.simbad_entire_image_button)
 
@@ -2981,17 +2981,17 @@ class WIMIDialog(QDialog):
         # ─────────────────────────────
         # Minor Planets / Comets block
         # ─────────────────────────────
-        self.minor_group = QGroupBox("Minor Planets / Comets")
+        self.minor_group = QGroupBox(self.tr("Minor Planets / Comets"))
         minor_layout = QGridLayout(self.minor_group)
 
         # --- DB info + buttons ---
-        self.minor_db_label = QLabel("Database: not downloaded")
+        self.minor_db_label = QLabel(self.tr("Database: not downloaded"))
         self.minor_db_label.setStyleSheet("font-size: 10px; color: gray;")
 
-        self.btn_minor_download = QPushButton("Download Catalog")
+        self.btn_minor_download = QPushButton(self.tr("Download Catalog"))
         self.btn_minor_download.clicked.connect(self.download_minor_body_catalog)
 
-        self.btn_minor_search = QPushButton("Search Minor Bodies")
+        self.btn_minor_search = QPushButton(self.tr("Search Minor Bodies"))
         self.btn_minor_search.clicked.connect(self.perform_minor_body_search)
 
         # Row 0: status label across full width
@@ -3002,18 +3002,18 @@ class WIMIDialog(QDialog):
         minor_layout.addWidget(self.btn_minor_search,   1, 2, 1, 2)
 
         # --- Search scope (Defined Circle vs Entire Image) ---
-        scope_label = QLabel("Search scope:")
+        scope_label = QLabel(self.tr("Search scope:"))
         self.minor_scope_combo = QComboBox()
         self.minor_scope_combo.addItems([
-            "Defined Region",
-            "Entire Image",
+            self.tr("Defined Region"),
+            self.tr("Entire Image"),
         ])
 
         minor_layout.addWidget(scope_label,          2, 0)
         minor_layout.addWidget(self.minor_scope_combo, 2, 1, 1, 3)
 
         # --- Limits row 1: asteroid H_max + max count ---
-        ast_H_label = QLabel("Asteroid H \u2264")
+        ast_H_label = QLabel(self.tr("Asteroid H \u2264"))
         self.minor_ast_H_spin = QDoubleSpinBox()
         self.minor_ast_H_spin.setRange(0.0, 40.0)
         self.minor_ast_H_spin.setDecimals(1)
@@ -3022,7 +3022,7 @@ class WIMIDialog(QDialog):
             float(self.settings.value("wimi/minor/asteroid_H_max", 20.0))
         )
 
-        ast_max_label = QLabel("Max asteroids:")
+        ast_max_label = QLabel(self.tr("Max asteroids:"))
         self.minor_ast_max_spin = QSpinBox()
         self.minor_ast_max_spin.setRange(100, 2000000)
         self.minor_ast_max_spin.setSingleStep(1000)
@@ -3036,7 +3036,7 @@ class WIMIDialog(QDialog):
         minor_layout.addWidget(self.minor_ast_max_spin, 3, 3)
 
         # --- Limits row 2: comet H_max + max count ---
-        com_H_label = QLabel("Comet H \u2264")
+        com_H_label = QLabel(self.tr("Comet H \u2264"))
         self.minor_com_H_spin = QDoubleSpinBox()
         self.minor_com_H_spin.setRange(0.0, 40.0)
         self.minor_com_H_spin.setDecimals(1)
@@ -3045,7 +3045,7 @@ class WIMIDialog(QDialog):
             float(self.settings.value("wimi/minor/comet_H_max", 15.0))
         )
 
-        com_max_label = QLabel("Max comets:")
+        com_max_label = QLabel(self.tr("Max comets:"))
         self.minor_com_max_spin = QSpinBox()
         self.minor_com_max_spin.setRange(100, 100000)
         self.minor_com_max_spin.setSingleStep(500)
@@ -3059,14 +3059,14 @@ class WIMIDialog(QDialog):
         minor_layout.addWidget(self.minor_com_max_spin, 4, 3)
 
         # --- Optional specific target (designation / name) ---
-        target_label = QLabel("Target (optional):")
+        target_label = QLabel(self.tr("Target (optional):"))
         self.minor_target_edit = QLineEdit()
         self.minor_target_edit.setPlaceholderText("e.g. 584, Semiramis, C/2023 A3...")
 
         minor_layout.addWidget(target_label,          5, 0)
         minor_layout.addWidget(self.minor_target_edit, 5, 1, 1, 3)
 
-        self.minor_count_button = QPushButton("Count Objects Brighter Than Limits")
+        self.minor_count_button = QPushButton(self.tr("Count Objects Brighter Than Limits"))
         self.minor_count_button.setToolTip(
             "Show how many catalog objects are brighter than the selected H limits."
         )
@@ -3075,7 +3075,7 @@ class WIMIDialog(QDialog):
         minor_layout.addWidget(self.minor_count_button, 6, 0, 1, 4)
 
         # --- Time offset (hours) for ephemerides ---
-        time_offset_label = QLabel("Time offset (hours):")
+        time_offset_label = QLabel(self.tr("Time offset (hours):"))
         self.minor_time_offset_spin = QDoubleSpinBox()
         self.minor_time_offset_spin.setRange(-24.0, 24.0)
         self.minor_time_offset_spin.setDecimals(2)
@@ -3099,7 +3099,7 @@ class WIMIDialog(QDialog):
         self._load_minor_db_path()
 
         # Adding the "Deep Vizier Search" button below the other search buttons
-        self.deep_vizier_button = QPushButton("Caution - Deep Vizier Search")
+        self.deep_vizier_button = QPushButton(self.tr("Caution - Deep Vizier Search"))
         self.deep_vizier_button.setIcon(QIcon(nuke_path))  # Assuming `nuke_path` is the correct path for the icon
         self.deep_vizier_button.setToolTip("Perform a deep search with Vizier. Caution: May return large datasets.")
 
@@ -3109,7 +3109,7 @@ class WIMIDialog(QDialog):
         # Add the Deep Vizier button to the advanced search layout
         self.advanced_search_panel.addWidget(self.deep_vizier_button)
 
-        self.mast_search_button = QPushButton("Search M.A.S.T Database")
+        self.mast_search_button = QPushButton(self.tr("Search M.A.S.T Database"))
         self.mast_search_button.setIcon(QIcon(hubble_path))
         self.mast_search_button.clicked.connect(self.perform_mast_search)
         self.mast_search_button.setToolTip("Search Hubble, JWST, Spitzer, TESS and More.")
@@ -3604,15 +3604,15 @@ class WIMIDialog(QDialog):
         menu = QMenu(self)
 
         # Define actions
-        open_website_action = QAction("Open Website", self)
+        open_website_action = QAction(self.tr("Open Website"), self)
         open_website_action.triggered.connect(lambda: self.results_tree.itemDoubleClicked.emit(item, 0))
         menu.addAction(open_website_action)
 
-        zoom_to_object_action = QAction("Zoom to Object", self)
+        zoom_to_object_action = QAction(self.tr("Zoom to Object"), self)
         zoom_to_object_action.triggered.connect(lambda: self.zoom_to_object(item))
         menu.addAction(zoom_to_object_action)
 
-        copy_info_action = QAction("Copy Object Information", self)
+        copy_info_action = QAction(self.tr("Copy Object Information"), self)
         copy_info_action.triggered.connect(lambda: self.copy_object_information(item))
         menu.addAction(copy_info_action)
 
@@ -6524,509 +6524,6 @@ class WIMIDialog(QDialog):
         print(f"[MinorBodies] objects inside cone: {kept}")
         return results
 
-    def _get_astap_exe(self) -> str:
-        s = self._settings()
-        # preferred key (what SettingsDialog writes)
-        p = s.value("paths/astap", "", type=str)
-        if p:
-            return p
-        # migrate legacy key if present
-        legacy = s.value("astap/exe_path", "", type=str)
-        if legacy:
-            s.setValue("paths/astap", legacy)
-            s.remove("astap/exe_path")
-            s.sync()
-            return legacy
-        return ""
-
-    def _set_astap_exe(self, path: str) -> None:
-        s = self._settings()
-        s.setValue("paths/astap", path)
-        s.sync()
-
-    def plate_solve_image(self):
-        """
-        Attempts to plate-solve the loaded image using ASTAP,
-        first trying a seeded solve (RA, SPD, scale, binning),
-        then falling back to a blind solve if anything is missing.
-        On success, updates self.header and self.wcs.
-        """
-        if not hasattr(self, 'image_path') or not self.image_path:
-            return
-
-        # 1) Ensure ASTAP path
-        astap_exe = self._get_astap_exe()
-        if not astap_exe or not os.path.exists(astap_exe):
-            # last-resort browse if nothing in settings (keeps existing behavior)
-            filt = "Executables (*.exe);;All Files (*)" if sys.platform.startswith("win") else "Executables (*)"
-            new_path, _ = QFileDialog.getOpenFileName(self, "Select ASTAP Executable", "", filt)
-            if not new_path:
-                return
-            astap_exe = new_path
-            self._set_astap_exe(astap_exe)
-
-        # 2) Write out the normalized FITS for ASTAP
-        normalized = self.stretch_image(self.image_data.astype(np.float32))
-        try:
-            tmp_path = self.save_temp_fits_image(normalized, self.image_path)
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error saving temp FITS: {e}")
-            return
-
-        # 3) Seed arguments from header
-        raw_hdr = None
-        if isinstance(self.original_header, fits.Header):
-            raw_hdr = self.original_header
-        elif self.image_path.lower().endswith(('.fits','.fit')):
-            with fits.open(self.image_path, memmap=False) as hdul:
-                raw_hdr = hdul[0].header
-
-        seed_args = []
-        if isinstance(raw_hdr, fits.Header):
-            # debug-dump
-            print("🔍 Raw header contents:")
-            for k,v in raw_hdr.items():
-                print(f"    {k} = {v}")
-
-            try:
-                # RA→hours, SPD
-                ra_deg = float(raw_hdr["CRVAL1"])
-                dec_deg= float(raw_hdr["CRVAL2"])
-                ra_h    = ra_deg / 15.0
-                spd     = dec_deg + 90.0
-
-                # plate scale from CD matrix (°/px→″/px)
-                cd1 = float(raw_hdr.get("CD1_1", raw_hdr.get("CDELT1",0)))
-                cd2 = float(raw_hdr.get("CD2_1", raw_hdr.get("CDELT2",0)))
-                scale = np.hypot(cd1, cd2) * 3600.0
-
-                # apply XBINNING/YBINNING
-                bx = int(raw_hdr.get("XBINNING", 1))
-                by = int(raw_hdr.get("YBINNING", bx))
-                if bx != by:
-                    print(f"⚠️ Unequal binning: {bx}×{by}, averaging.")
-                binf = (bx+by)/2.0
-                scale *= binf
-
-                seed_args = [
-                    "-ra",    f"{ra_h:.6f}",
-                    "-spd",   f"{spd:.6f}",
-                    "-scale", f"{scale:.3f}"
-                ]
-                print(f"🔸 Seeding ASTAP: RA={ra_h:.6f}h, SPD={spd:.6f}°, scale={scale:.3f}\"/px (×{binf} bin)")
-            except Exception as e:
-                print("⚠️ Failed to build seed args, will do blind solve:", e)
-
-        # 4) Build ASTAP args
-        if seed_args:
-            args = ["-f", tmp_path] + seed_args + ["-wcs", "-sip"]
-        else:
-            args = ["-f", tmp_path, "-r", "179", "-fov", "0", "-z", "0", "-wcs", "-sip"]
-
-        print("▶️ Running ASTAP with arguments:", args)
-
-        # create and launch the process
-        process = QProcess(self)
-        process.start(astap_exe, args)
-        if not process.waitForStarted(5000):
-            #QMessageBox.critical(self, "Plate Solve", "Failed to start ASTAP process.")
-            os.remove(tmp_path)
-            
-            return None
-        if not process.waitForFinished(300000):
-            #QMessageBox.critical(self, "Plate Solve", "ASTAP process timed out.")
-            os.remove(tmp_path)
-            return None
-
-        exit_code = process.exitCode()
-        stdout = process.readAllStandardOutput().data().decode()
-        stderr = process.readAllStandardError().data().decode()
-        print("ASTAP exit code:", exit_code)
-        print("ASTAP STDOUT:\n", stdout)
-        print("ASTAP STDERR:\n", stderr)
-        
-        if exit_code != 0:
-            os.remove(tmp_path)
-            #QMessageBox.warning(self, "Plate Solve", "ASTAP failed. Falling back to blind solve.")
-            
-            return None
-
-        # --- Retrieve the initial solved header from the temporary FITS file ---
-        try:
-            with fits.open(tmp_path, memmap=False) as hdul:
-                solved_header = dict(hdul[0].header)
-            for key in ["COMMENT", "HISTORY", "END"]:
-                solved_header.pop(key, None)
-            print("Initial solved header retrieved from temporary FITS file:")
-            for key, value in solved_header.items():
-                print(f"{key} = {value}")
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error reading solved header: {e}")
-            os.remove(tmp_path)
-            
-            return None
-
-        # --- Check for a .wcs file and merge its header if present ---
-        wcs_path = os.path.splitext(tmp_path)[0] + ".wcs"
-        if os.path.exists(wcs_path):
-            try:
-                wcs_header = {}
-                with open(wcs_path, "r") as f:
-                    text = f.read()
-                    # Matches a FITS header keyword and its value (with an optional comment).
-                    pattern = r"(\w+)\s*=\s*('?[^/']*'?)[\s/]"
-                    for match in re.finditer(pattern, text):
-                        key = match.group(1).strip().upper()
-                        val = match.group(2).strip()
-                        if val.startswith("'") and val.endswith("'"):
-                            val = val[1:-1].strip()
-                        wcs_header[key] = val
-                wcs_header.pop("END", None)
-                print("WCS header retrieved from .wcs file:")
-                for key, value in wcs_header.items():
-                    print(f"{key} = {value}")
-                # Merge the parsed WCS header into the solved header.
-                solved_header.update(wcs_header)
-            except Exception as e:
-                print("Error reading .wcs file:", e)
-        else:
-            print("No .wcs file found; using header from temporary FITS.")
-
-        # --- If loaded from a slot, merge the original file path from slot metadata ---
-        if getattr(self, "_from_slot", False) and hasattr(self, "_slot_meta"):
-            if "file_path" not in solved_header and "file_path" in self._slot_meta:
-                solved_header["file_path"] = self._slot_meta["file_path"]
-                print("Merged file_path from slot metadata into solved header.")
-
-        # --- Add any missing required WCS keywords ---
-        required_keys = {
-            "CTYPE1": "RA---TAN",
-            "CTYPE2": "DEC--TAN",
-            "RADECSYS": "ICRS",
-            "WCSAXES": 2,
-            # CRVAL1, CRVAL2, CRPIX1, CRPIX2 are ideally provided by ASTAP.
-        }
-        for key, default in required_keys.items():
-            if key not in solved_header:
-                solved_header[key] = default
-                print(f"Added missing key {key} with default value {default}.")
-
-        # --- Convert keys that are expected to be numeric from strings to numbers ---
-        expected_numeric_keys = {
-            "CRPIX1", "CRPIX2", "CRVAL1", "CRVAL2", "CROTA1", "CROTA2",
-            "CDELT1", "CDELT2", "CD1_1", "CD1_2", "CD2_1", "CD2_2", "WCSAXES"
-        }
-        for key in expected_numeric_keys:
-            if key in solved_header:
-                try:
-                    # For keys that should be integers, you can use int(float(...)) if necessary.
-                    solved_header[key] = float(solved_header[key])
-                except ValueError:
-                    print(f"Warning: Could not convert {key} value '{solved_header[key]}' to float.")
-
-        # --- Ensure integer keywords are stored as integers ---
-        for key in ["WCSAXES", "NAXIS", "NAXIS1", "NAXIS2", "NAXIS3"]:
-            if key in solved_header:
-                try:
-                    solved_header[key] = int(float(solved_header[key]))
-                except ValueError:
-                    print(f"Warning: Could not convert {key} value '{solved_header[key]}' to int.")
-
-
-        os.remove(tmp_path)
-        print("ASTAP plate solving successful. Final solved header:")
-        for key, value in solved_header.items():
-            print(f"{key} = {value}")
-
-        # --------------------------------------------------------------------
-        # 1) Make sure A_ORDER/B_ORDER exist in pairs:
-        if "B_ORDER" in solved_header and "A_ORDER" not in solved_header:
-            solved_header["A_ORDER"] = solved_header["B_ORDER"]
-        if "A_ORDER" in solved_header and "B_ORDER" not in solved_header:
-            solved_header["B_ORDER"] = solved_header["A_ORDER"]
-
-        # 2) Convert SIP‐order keywords to ints:
-        for key in ("A_ORDER","B_ORDER","AP_ORDER","BP_ORDER"):
-            if key in solved_header:
-                solved_header[key] = int(float(solved_header[key]))
-
-        # 3) Convert every SIP coefficient to float:
-        for k in list(solved_header):
-            if re.match(r"^(?:A|B|AP|BP)_[0-9]+_[0-9]+$", k):
-                solved_header[k] = float(solved_header[k])
-
-        # --------------------------------------------------------------------
-        # 4) Now rebuild your FITS header from the dict, preserving ordering:
-        new_hdr = fits.Header()
-        for key, val in solved_header.items():
-            # skip any stray non‑FITS metadata
-            if key == "file_path":
-                continue
-            new_hdr[key] = val
-
-        # 5) Finally swap in the new header and re-init WCS (with SIP!)
-        self.header = new_hdr
-        try:
-            self.apply_wcs_header(self.header)
-            self.status_label.setText("Status: ASTAP solve succeeded.")
-        except Exception as e:
-            QMessageBox.critical(self, "Plate Solve", f"Error initializing WCS from solved header:\n{e}")
-            return
-
-        return solved_header
-
-
-    def save_temp_fits_image(self, normalized_image, image_path: str):
-        """
-        Save the normalized_image as a FITS file to a temporary file.
-        
-        If the original image is FITS, this method retrieves the stored metadata
-        from the ImageManager and passes it directly to save_image().
-        If not, it generates a minimal header.
-        
-        Returns the path to the temporary FITS file.
-        """
-        # Always save as FITS.
-        selected_format = "fits"
-        bit_depth = "32-bit floating point"
-        is_mono = (normalized_image.ndim == 2 or 
-                   (normalized_image.ndim == 3 and normalized_image.shape[2] == 1))
-        
-        # If the original image is FITS, try to get its stored metadata.
-        original_header = None
-        if image_path.lower().endswith((".fits", ".fit")):
-            if self.parent() and hasattr(self.parent(), "image_manager"):
-                # Use the metadata from the current slot.
-                _, meta = self.parent().image_manager.get_current_image_and_metadata()
-                # Assume that meta already contains a proper 'original_header'
-                # (or the entire meta is the header).
-                original_header = meta.get("original_header", None)
-            # If nothing is stored, fall back to creating a minimal header.
-            if original_header is None:
-                print("No stored FITS header found; creating a minimal header.")
-                original_header = self.create_minimal_fits_header(normalized_image, is_mono)
-        else:
-            # For non-FITS images, generate a minimal header.
-            original_header = self.create_minimal_fits_header(normalized_image, is_mono)
-        
-        # Create a temporary filename.
-        tmp_file = tempfile.NamedTemporaryFile(suffix=".fits", delete=False)
-        tmp_path = tmp_file.name
-        tmp_file.close()
-        
-        try:
-            # Call your global save_image() exactly as in AstroEditingSuite.
-            save_image(
-                img_array=normalized_image,
-                filename=tmp_path,
-                original_format=selected_format,
-                bit_depth=bit_depth,
-                original_header=original_header,
-                is_mono=is_mono
-                # (image_meta and file_meta can be omitted if not needed)
-            )
-            print(f"Temporary normalized FITS saved to: {tmp_path}")
-        except Exception as e:
-            print("Error saving temporary FITS file using save_image():", e)
-            raise e
-        return tmp_path
-
-    def create_minimal_fits_header(self, img_array, is_mono=False):
-        """
-        Creates a minimal FITS header when the original header is missing.
-        """
-
-        header = Header()
-        header['SIMPLE'] = (True, 'Standard FITS file')
-        header['BITPIX'] = -32  # 32-bit floating-point data
-        header['NAXIS'] = 2 if is_mono else 3
-        header['NAXIS1'] = img_array.shape[2] if img_array.ndim == 3 and not is_mono else img_array.shape[1]  # Image width
-        header['NAXIS2'] = img_array.shape[1] if img_array.ndim == 3 and not is_mono else img_array.shape[0]  # Image height
-        if not is_mono:
-            header['NAXIS3'] = img_array.shape[0] if img_array.ndim == 3 else 1  # Number of color channels
-        header['BZERO'] = 0.0  # No offset
-        header['BSCALE'] = 1.0  # No scaling
-        header.add_comment("Minimal FITS header generated by AstroEditingSuite.")
-
-        return header
-
-    def stretch_image(self, image):
-        """
-        Perform an unlinked linear stretch on the image.
-        Each channel is stretched independently by subtracting its own minimum,
-        recording its own median, and applying the stretch formula.
-        Returns the stretched image in [0,1].
-        """
-        was_single_channel = False  # Flag to check if image was single-channel
-
-        # If the image is 2D or has one channel, convert to 3-channel
-        if image.ndim == 2 or (image.ndim == 3 and image.shape[2] == 1):
-            was_single_channel = True
-            image = np.stack([image] * 3, axis=-1)
-
-        image = np.asarray(image, dtype=np.float32)
-        stretched_image = image.copy()  # Need copy for in-place modification
-        self.stretch_original_mins = []
-        self.stretch_original_medians = []
-        target_median = 0.02
-
-        for c in range(3):
-            channel_min = np.min(stretched_image[..., c])
-            self.stretch_original_mins.append(channel_min)
-            stretched_image[..., c] -= channel_min
-            channel_median = np.median(stretched_image[..., c])
-            self.stretch_original_medians.append(channel_median)
-            if channel_median != 0:
-                numerator = (channel_median - 1) * target_median * stretched_image[..., c]
-                denominator = (
-                    channel_median * (target_median + stretched_image[..., c] - 1)
-                    - target_median * stretched_image[..., c]
-                )
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                stretched_image[..., c] = numerator / denominator
-            else:
-                print(f"Channel {c} - Median is zero. Skipping stretch.")
-
-        stretched_image = np.clip(stretched_image, 0.0, 1.0)
-        self.was_single_channel = was_single_channel
-        return stretched_image
-
-    def unstretch_image(self, image):
-        """
-        Undo the unlinked linear stretch using stored parameters.
-        Returns the unstretched image.
-        """
-        original_mins = self.stretch_original_mins
-        original_medians = self.stretch_original_medians
-        was_single_channel = self.was_single_channel
-
-        image = np.asarray(image, dtype=np.float32)
-
-        if image.ndim == 2:
-            channel_median = np.median(image)
-            original_median = original_medians[0]
-            original_min = original_mins[0]
-            if channel_median != 0 and original_median != 0:
-                numerator = (channel_median - 1) * original_median * image
-                denominator = channel_median * (original_median + image - 1) - original_median * image
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                image = numerator / denominator
-            else:
-                print("Channel median or original median is zero. Skipping unstretch.")
-            image += original_min
-            image = np.clip(image, 0, 1)
-            return image
-
-        for c in range(3):
-            channel_median = np.median(image[..., c])
-            original_median = original_medians[c]
-            original_min = original_mins[c]
-            if channel_median != 0 and original_median != 0:
-                numerator = (channel_median - 1) * original_median * image[..., c]
-                denominator = (
-                    channel_median * (original_median + image[..., c] - 1)
-                    - original_median * image[..., c]
-                )
-                denominator = np.where(denominator == 0, 1e-6, denominator)
-                image[..., c] = numerator / denominator
-            else:
-                print(f"Channel {c} - Median or original median is zero. Skipping unstretch.")
-            image[..., c] += original_min
-
-        image = np.clip(image, 0, 1)
-        if was_single_channel and image.ndim == 3:
-            image = np.mean(image, axis=2, keepdims=True)
-        return image
-
-    def retrieve_and_apply_wcs(self, job_id):
-        """Download the wcs.fits file from Astrometry.net, extract WCS header data, and apply it."""
-        try:
-            wcs_url = f"https://nova.astrometry.net/wcs_file/{job_id}"
-            wcs_filepath = "wcs.fits"
-            max_retries = 10
-            delay = 10  # seconds
-            
-            for attempt in range(max_retries):
-                response = requests.get(wcs_url, stream=True)
-                response.raise_for_status()
-
-                with open(wcs_filepath, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-
-                try:
-                    with fits.open(wcs_filepath, ignore_missing_simple=True, ignore_missing_end=True) as hdul:
-                        wcs_header = hdul[0].header
-                        print("WCS header successfully retrieved.")
-                        # 🔁 use common path
-                        self.apply_wcs_header(wcs_header)
-                        return wcs_header
-                except Exception as e:
-                    print(f"Attempt {attempt + 1}: Failed to process WCS file - possibly HTML instead of FITS. Retrying in {delay} seconds...")
-                    print(f"Error: {e}")
-                    time.sleep(delay)
-            
-            print("Failed to download a valid WCS FITS file after multiple attempts.")
-            return None
-
-        except requests.exceptions.RequestException as e:
-            print(f"Error downloading WCS file: {e}")
-        except Exception as e:
-            print(f"Error processing WCS file: {e}")
-            
-        return None
-
-
-
-    def apply_wcs_header(self, wcs_header):
-        """
-        Apply a solved WCS header.  Sets self.wcs, self.pixscale (arcsec/pix),
-        self.orientation, and updates the orientation label.
-        """
-        # 1) Initialize the WCS object
-        self.wcs = WCS(wcs_header, naxis=2, relax=True)
-
-        # 2) Derive pixel scale (arcsec/pixel)
-        if 'CDELT1' in wcs_header:
-            # CDELT1 is degrees/pixel
-            self.pixscale = abs(float(wcs_header['CDELT1'])) * 3600.0
-        elif 'CD1_1' in wcs_header and 'CD2_2' in wcs_header:
-            # approximate from CD matrix determinant
-            det = (wcs_header['CD1_1'] * wcs_header['CD2_2']
-                - wcs_header['CD1_2'] * wcs_header['CD2_1'])
-            pixscale_deg = math.sqrt(abs(det))
-            self.pixscale = pixscale_deg * 3600.0
-        else:
-            self.pixscale = None
-            print("Warning: could not derive pixscale from header.")
-
-        # 3) Extract orientation (CROTA2 if present)
-        if 'CROTA2' in wcs_header:
-            self.orientation = float(wcs_header['CROTA2'])
-        else:
-            # fallback to your custom function
-            self.orientation = calculate_orientation(wcs_header)
-
-        # 4) Update the GUI label
-        if self.orientation is not None:
-            self.orientation_label.setText(f"Orientation: {self.orientation:.2f}°")
-        else:
-            self.orientation_label.setText("Orientation: N/A")
-
-        print(f" -> pixscale = {self.pixscale} arcsec/pixel")
-        print(f" -> orientation = {self.orientation}°")
-        try:
-            cr1 = wcs_header.get('CRVAL1')
-            cr2 = wcs_header.get('CRVAL2')
-            if cr1 is not None and cr2 is not None:
-                self.center_ra  = float(cr1)
-                self.center_dec = float(cr2)
-                print(f" -> center RA/Dec = {self.center_ra:.6f}, {self.center_dec:.6f}")
-        except Exception:
-            print("Warning: could not extract CRVAL1/CRVAL2")        
-
-
-
     def calculate_pixel_from_ra_dec(self, ra, dec):
         """Convert RA/Dec to pixel coordinates using the WCS data."""
         if not hasattr(self, "wcs") or self.wcs is None:
@@ -7059,117 +6556,6 @@ class WIMIDialog(QDialog):
 
         return int(round(x_val)), int(round(y_val))
 
-    def login_to_astrometry(self, api_key):
-        try:
-            response = requests.post(
-                ASTROMETRY_API_URL + "login",
-                data={'request-json': json.dumps({"apikey": api_key})}
-            )
-            response_data = response.json()
-            if response_data.get("status") == "success":
-                return response_data["session"]
-            else:
-                raise ValueError("Login failed: " + response_data.get("error", "Unknown error"))
-        except Exception as e:
-            raise Exception("Login to Astrometry.net failed: " + str(e))
-
-
-    def upload_image_to_astrometry(self, image_path, session_key):
-        try:
-            # Check if the file is XISF format
-            file_extension = os.path.splitext(image_path)[-1].lower()
-            if file_extension == ".xisf":
-                # Load the XISF image
-                xisf = XISF(image_path)
-                im_data = xisf.read_image(0)
-                
-                # Convert to a temporary TIFF file for upload
-                temp_image_path = os.path.splitext(image_path)[0] + "_converted.tif"
-                if im_data.dtype == np.float32 or im_data.dtype == np.float64:
-                    im_data = np.clip(im_data, 0, 1) * 65535
-                im_data = im_data.astype(np.uint16)
-
-                # Save as TIFF
-                if im_data.shape[-1] == 1:  # Grayscale
-                    tiff.imwrite(temp_image_path, np.squeeze(im_data, axis=-1))
-                else:  # RGB
-                    tiff.imwrite(temp_image_path, im_data)
-
-                print(f"Converted XISF file to TIFF at {temp_image_path} for upload.")
-                image_path = temp_image_path  # Use the converted file for upload
-
-            # Upload the image file
-            with open(image_path, 'rb') as image_file:
-                files = {'file': image_file}
-                data = {
-                    'request-json': json.dumps({
-                        "publicly_visible": "y",
-                        "allow_modifications": "d",
-                        "session": session_key,
-                        "allow_commercial_use": "d"
-                    })
-                }
-                response = requests.post(ASTROMETRY_API_URL + "upload", files=files, data=data)
-                response_data = response.json()
-                if response_data.get("status") == "success":
-                    return response_data["subid"]
-                else:
-                    raise ValueError("Image upload failed: " + response_data.get("error", "Unknown error"))
-
-        except Exception as e:
-            raise Exception("Image upload to Astrometry.net failed: " + str(e))
-
-        finally:
-            # Clean up temporary file if created
-            if file_extension == ".xisf" and os.path.exists(temp_image_path):
-                os.remove(temp_image_path)
-                print(f"Temporary TIFF file {temp_image_path} deleted after upload.")
-
-
-
-    def poll_submission_status(self, subid):
-        """Poll Astrometry.net to retrieve the job ID once the submission is processed."""
-        max_retries = 90  # Adjust as necessary
-        retries = 0
-        while retries < max_retries:
-            try:
-                response = requests.get(ASTROMETRY_API_URL + f"submissions/{subid}")
-                response_data = response.json()
-                jobs = response_data.get("jobs", [])
-                if jobs and jobs[0] is not None:
-                    return jobs[0]
-                else:
-                    print(f"Polling attempt {retries + 1}: Job not ready yet.")
-            except Exception as e:
-                print(f"Error while polling submission status: {e}")
-            
-            retries += 1
-            time.sleep(10)  # Wait 10 seconds between retries
-        
-        return None
-
-    def poll_calibration_data(self, job_id):
-        """Poll Astrometry.net to retrieve the calibration data once it's available."""
-        max_retries = 90  # Retry for up to 15 minutes (90 * 10 seconds)
-        retries = 0
-        while retries < max_retries:
-            try:
-                response = requests.get(ASTROMETRY_API_URL + f"jobs/{job_id}/calibration/")
-                response_data = response.json()
-                if response_data and 'ra' in response_data and 'dec' in response_data:
-                    print("Calibration data retrieved:", response_data)
-                    return response_data  # Calibration data is complete
-                else:
-                    print(f"Calibration data not available yet (Attempt {retries + 1})")
-            except Exception as e:
-                print(f"Error retrieving calibration data: {e}")
-
-            retries += 1
-            time.sleep(10)  # Wait 10 seconds between retries
-
-        return None
-
-
     #If originally a fits file update the header
     def update_fits_with_wcs(self, filepath, calibration_data):
         if not filepath.lower().endswith(('.fits', '.fit')):
@@ -7391,23 +6777,43 @@ class WIMIDialog(QDialog):
                 CIRCLE('ICRS', {ra_center}, {dec_center}, {radius_deg})
             ) = 1
         """
+
+        result = None
+        last_err = None
+
         for attempt in range(5):
             try:
                 result = Simbad.query_tap(query)
+                last_err = None
                 break
             except Exception as e:
+                last_err = e
                 if attempt < 4:
-                    time.sleep(1)
+                    time.sleep(1)  # or QThread.msleep(1000) if you want less UI freeze
                 else:
-                    QMessageBox.critical(
+                    # After 5 attempts total, stop with a helpful message
+                    err_txt = str(last_err) if last_err is not None else "Unknown error"
+                    QMessageBox.warning(
                         self,
-                        "Query Failed",
-                        f"Try again later:\n{e}"
-            )
+                        "SIMBAD network error",
+                        (
+                            "We couldn't reach SIMBAD due to a network or service error.\n\n"
+                            "We tried 5 times and then stopped.\n\n"
+                            "What to try:\n"
+                            " • Check your internet connection / VPN / firewall\n"
+                            " • Verify SIMBAD is reachable: https://simbad.cds.unistra.fr/simbad/\n"
+                            " • Then try again\n\n"
+                            f"Last error:\n{err_txt}"
+                        )
+                    )
+                    return
 
         if result is None or len(result) == 0:
-            QMessageBox.information(self, "No Results",
-                                    "No objects found in the specified area.")
+            QMessageBox.information(
+                self,
+                "No Results",
+                "No objects found in the specified area."
+            )
             return
 
         # ——— 3a) list of all “star” & binary/variable OTYPE codes ———
@@ -7912,41 +7318,6 @@ class WIMIDialog(QDialog):
             self.status_label.setText(f"Status: Blind solve failed — {res}")
 
 
-def extract_wcs_data(file_path):
-    try:
-        # Open the FITS file with minimal validation to ignore potential errors in non-essential parts
-        with fits.open(file_path, ignore_missing_simple=True, ignore_missing_end=True) as hdul:
-            header = hdul[0].header
-
-            # Extract essential WCS parameters
-            wcs_params = {}
-            keys_to_extract = [
-                'WCSAXES', 'CTYPE1', 'CTYPE2', 'EQUINOX', 'LONPOLE', 'LATPOLE',
-                'CRVAL1', 'CRVAL2', 'CRPIX1', 'CRPIX2', 'CUNIT1', 'CUNIT2',
-                'CD1_1', 'CD1_2', 'CD2_1', 'CD2_2', 'A_ORDER', 'A_0_0', 'A_0_1', 
-                'A_0_2', 'A_1_0', 'A_1_1', 'A_2_0', 'B_ORDER', 'B_0_0', 'B_0_1', 
-                'B_0_2', 'B_1_0', 'B_1_1', 'B_2_0', 'AP_ORDER', 'AP_0_0', 'AP_0_1', 
-                'AP_0_2', 'AP_1_0', 'AP_1_1', 'AP_2_0', 'BP_ORDER', 'BP_0_0', 
-                'BP_0_1', 'BP_0_2', 'BP_1_0', 'BP_1_1', 'BP_2_0'
-            ]
-            for key in keys_to_extract:
-                if key in header:
-                    wcs_params[key] = header[key]
-
-            # Manually create a minimal header with WCS information
-            wcs_header = fits.Header()
-            for key, value in wcs_params.items():
-                wcs_header[key] = value
-
-            # Initialize WCS with this custom header
-            wcs = WCS(wcs_header)
-            print("WCS successfully initialized with minimal header.")
-            return wcs
-
-    except Exception as e:
-        print(f"Error processing WCS file: {e}")
-        return None
-
 # Function to calculate comoving radial distance (in Gly)
 def calculate_comoving_distance(z):
     z = abs(z)