setiastrosuitepro 1.6.4__py3-none-any.whl → 1.7.1.post2__py3-none-any.whl

setiastro/saspro/doc_manager.py

@@ -310,18 +310,133 @@ class ImageDocument(QObject):
 
     def close(self):
         """
-        Explicit cleanup of swap files.
+        Free all resources held by this document:
+        - delete swap states for undo/redo
+        - clear undo/redo stacks
+        - drop in-memory image array and any in-memory history
+        - clear heavy metadata (headers/WCS)
+        - clear any cached previews/pixmaps
+        - disconnect signals to help break reference cycles
         """
-        sm = get_swap_manager()
-        # Clean up undo stack
-        for swap_id, _, _ in self._undo:
-            sm.delete_state(swap_id)
-        self._undo.clear()
-        
-        # Clean up redo stack
-        for swap_id, _, _ in self._redo:
-            sm.delete_state(swap_id)
-        self._redo.clear()
+        # --- 0) Stop emitting while we tear down (best-effort) --------------
+        try:
+            self.blockSignals(True)
+        except Exception:
+            pass
+
+        # --- 1) Swap cleanup (your existing logic) --------------------------
+        try:
+            sm = get_swap_manager()
+        except Exception:
+            sm = None
+
+        # Undo stack
+        try:
+            for item in list(getattr(self, "_undo", [])):
+                try:
+                    swap_id = item[0]  # (swap_id, ..., ...)
+                except Exception:
+                    swap_id = None
+                if sm is not None and swap_id is not None:
+                    try:
+                        sm.delete_state(swap_id)
+                    except Exception:
+                        pass
+            getattr(self, "_undo", []).clear()
+        except Exception:
+            pass
+
+        # Redo stack
+        try:
+            for item in list(getattr(self, "_redo", [])):
+                try:
+                    swap_id = item[0]
+                except Exception:
+                    swap_id = None
+                if sm is not None and swap_id is not None:
+                    try:
+                        sm.delete_state(swap_id)
+                    except Exception:
+                        pass
+            getattr(self, "_redo", []).clear()
+        except Exception:
+            pass
+
+        # ROI preview stacks if you have them (your code uses _pundo/_predo on ROI docs)
+        for attr in ("_pundo", "_predo"):
+            try:
+                lst = getattr(self, attr, None)
+                if isinstance(lst, list):
+                    # If these also store swap states, delete them too (safe even if not)
+                    if sm is not None:
+                        for item in list(lst):
+                            try:
+                                swap_id = item[0]
+                            except Exception:
+                                swap_id = None
+                            if swap_id is not None:
+                                try:
+                                    sm.delete_state(swap_id)
+                                except Exception:
+                                    pass
+                    lst.clear()
+            except Exception:
+                pass
+
+        # --- 2) Drop the big in-memory image --------------------------------
+        # This is what actually frees the 2–10GB allocations (assuming no other refs).
+        try:
+            self.image = None
+        except Exception:
+            pass
+
+        # --- 3) Clear metadata that can keep large objects alive -------------
+        # fits.Header/WCS objects aren't huge like the image, but they can keep references
+        # and add up; also helps break cycles.
+        try:
+            md = getattr(self, "metadata", None)
+            if isinstance(md, dict):
+                for k in ("wcs", "original_header", "fits_header", "wcs_header", "header"):
+                    md.pop(k, None)
+                # If you keep derived/cached headers anywhere:
+                for k in ("_header_snapshot", "_wcs_snapshot", "roi_wcs_header"):
+                    md.pop(k, None)
+        except Exception:
+            pass
+
+        # --- 4) Clear any preview/pixmap/qimage caches -----------------------
+        # Adjust these attr names to match what your view/doc uses.
+        for attr in ("_qimage_cache", "_pixmap_cache", "_preview_cache", "_render_cache"):
+            try:
+                v = getattr(self, attr, None)
+                if isinstance(v, dict):
+                    v.clear()
+                setattr(self, attr, None)
+            except Exception:
+                pass
+
+        # --- 5) Disconnect signals (helps Qt reference cycles) ---------------
+        # If you connect doc.changed to closures (like ROI docs do), this helps.
+        try:
+            self.changed.disconnect()
+        except Exception:
+            pass
+
+        # If you have other signals, disconnect them similarly:
+        for sig_name in ("imageChanged", "metadataChanged"):
+            try:
+                sig = getattr(self, sig_name, None)
+                if sig is not None:
+                    sig.disconnect()
+            except Exception:
+                pass
+
+        # --- 6) Allow signals again (optional) -------------------------------
+        try:
+            self.blockSignals(False)
+        except Exception:
+            pass
+
 
     def __del__(self):
         # Fallback cleanup if close() wasn't called (though explicit close is better)
@@ -1555,6 +1670,9 @@ def debug_dump_metadata_print(meta: dict, context: str = ""):
 
         print("===== END METADATA DUMP ({}) =====".format(context))
 
+import time
+_DEBUG_DND_DUP = False
+
 class DocManager(QObject):
     documentAdded = pyqtSignal(object)   # ImageDocument
     documentRemoved = pyqtSignal(object) # ImageDocument
@@ -2266,6 +2384,46 @@ class DocManager(QObject):
         if hasattr(doc, "changed"):
             doc.changed.emit()
 
+    def _current_view_title_for_doc(self, source_doc: ImageDocument) -> str | None:
+        """
+        If the active MDI subwindow is showing 'source_doc' (or its parent/base),
+        return the current view's title (windowTitle), otherwise None.
+        """
+        sw = self._active_subwindow()
+        if sw is None:
+            return None
+
+        try:
+            w = sw.widget()
+        except Exception:
+            w = None
+
+        # Resolve what doc the active view corresponds to (base doc)
+        try:
+            base = (
+                getattr(w, "base_document", None)
+                or getattr(w, "_base_document", None)
+                or getattr(w, "document", None)
+                or getattr(sw, "document", None)
+            )
+            parent = getattr(base, "_parent_doc", None)
+            if isinstance(parent, ImageDocument):
+                base = parent
+        except Exception:
+            base = None
+
+        if base is not source_doc:
+            return None
+
+        # Prefer the actual subwindow title (includes [View N], etc.)
+        try:
+            title = sw.windowTitle()
+            title = title.strip() if isinstance(title, str) else ""
+            return title or None
+        except Exception:
+            return None
+
+
     def duplicate_document(self, source_doc: ImageDocument, new_name: str | None = None) -> ImageDocument:
         # DEBUG: log the source doc WCS before we touch anything
         if _DEBUG_WCS:
@@ -2275,19 +2433,33 @@ class DocManager(QObject):
                 name = "<src>"
             
             _debug_log_wcs_context("  source.metadata", getattr(source_doc, "metadata", {}))
-
+        if _DEBUG_DND_DUP:
+            try:
+                src_dn = source_doc.display_name() if hasattr(source_doc, "display_name") else None
+            except Exception:
+                src_dn = None
+            print("\n[DNDDBG:DUPLICATE_DOCUMENT]")
+            print("  source_doc:", source_doc, "id:", id(source_doc), "uid:", getattr(source_doc,"uid",None))
+            print("  source_doc.display_name():", src_dn)
+            print("  new_name arg:", new_name)
         # COPY-ON-WRITE: Share the source image instead of copying immediately.
         # The duplicate's apply_edit will copy when it first modifies the image.
         # This saves memory when duplicates are created but not modified.
         img_ref = source_doc.image  # Shared reference, no copy
 
         meta = dict(source_doc.metadata or {})
-        base = source_doc.display_name()
+
+        # ✅ Use CURRENT VIEW NAME if this doc is what's active; else fall back to doc display_name()
+        base = self._current_view_title_for_doc(source_doc) or source_doc.display_name()
+
         dup_title = (new_name or f"{base}_duplicate")
+
         # 🚫 strip any lingering emojis / link markers
         dup_title = dup_title.replace("🔗", "").strip()
-        meta["display_name"] = dup_title
 
+        meta["display_name"] = dup_title
+        if _DEBUG_DND_DUP:
+            print("  dup_title computed:", dup_title)
         # Remove anything that makes the view look "linked/preview"
         imi = dict(meta.get("image_meta") or {})
         for k in ("readonly", "view_kind", "derived_from", "layer", "layer_index", "linked"):
@@ -2311,7 +2483,13 @@ class DocManager(QObject):
         # Mark this duplicate as sharing image data with source
         dup._cow_source = source_doc
         self._register_doc(dup)
-
+        if _DEBUG_DND_DUP:
+            try:
+                dn = dup.display_name() if hasattr(dup, "display_name") else None
+            except Exception:
+                dn = None
+            print("  dup.metadata.display_name:", (dup.metadata or {}).get("display_name"))
+            print("  dup.display_name():", dn)
         # DEBUG: log the duplicate doc WCS
         if _DEBUG_WCS:
             try:
@@ -2370,7 +2548,58 @@ class DocManager(QObject):
     def create_document(self, image, metadata: dict | None = None, name: str | None = None) -> ImageDocument:
         return self.open_array(image, metadata=metadata, title=name)
 
+    def _drop_all_roi_for_parent(self, parent_doc):
+        dead = [k for k in list(self._roi_doc_cache.keys()) if k[0] == id(parent_doc)]
+        for k in dead:
+            roi_doc = self._roi_doc_cache.pop(k, None)
+            if roi_doc is not None:
+                try:
+                    roi_doc.close()   # you’ll implement doc.close() to release arrays
+                except Exception:
+                    pass
+
+    def _hard_memory_cleanup(self):
+        # 1) Drop Qt pixmap cache (can hold big chunks)
+        try:
+            from PyQt6.QtGui import QPixmapCache
+            QPixmapCache.clear()
+        except Exception:
+            pass
+
+        # 2) Let pending deleteLater() actually execute
+        try:
+            from PyQt6.QtWidgets import QApplication
+            QApplication.processEvents()
+        except Exception:
+            pass
+
+        # 3) Force Python GC to collect cycles (common with Qt signal/closure cycles)
+        try:
+            import gc
+            gc.collect()
+        except Exception:
+            pass
+
+        # 4) Optional: Linux heap trim (only helps on Linux/glibc)
+        try:
+            import sys
+            if sys.platform.startswith("linux"):
+                import ctypes
+                libc = ctypes.CDLL("libc.so.6")
+                libc.malloc_trim(0)
+        except Exception:
+            pass
+
     def close_document(self, doc):
+        # If ROI wrapper, close parent; if parent, purge ROI cache
+        try:
+            parent = getattr(doc, "_parent_doc", None)
+            if parent is not None:
+                doc = parent
+        except Exception:
+            pass
+
+        self._drop_all_roi_for_parent(doc)
         if doc in self._docs:
             self._docs.remove(doc)
             try:
@@ -2387,6 +2616,7 @@ class DocManager(QObject):
                     print(f"[DocManager] Failed to close document {doc}: {e}")
                     
             self.documentRemoved.emit(doc)
+            self._hard_memory_cleanup()
             
     # --- Active-document helpers (NEW) ---------------------------------
     def all_documents(self):

setiastro/saspro/exoplanet_detector.py

@@ -27,6 +27,7 @@ from astropy.coordinates import SkyCoord
 import astropy.units as u
 from astropy.wcs import WCS
 from astropy.timeseries import LombScargle, BoxLeastSquares
+import re
 
 from astroquery.simbad import Simbad
 from astroquery.vizier import Vizier
@@ -152,6 +153,41 @@ def _estimate_scale_arcsec_per_pix(h: fits.Header):
 
     return None
 
+_TZ_RE = re.compile(r'([+-])(\d{2})(\d{2})$')  # -0700 -> -07:00
+
+def _fix_iso_tz(s: str) -> str:
+    s = s.strip()
+    m = _TZ_RE.search(s)
+    if m:
+        s = s[:m.start()] + f"{m.group(1)}{m.group(2)}:{m.group(3)}"
+    return s
+
+def _parse_obs_time_from_header(hdr) -> Time | None:
+    # hdr can be fits.Header or your dict-ish header
+    def _get(key):
+        try:
+            return hdr.get(key)
+        except Exception:
+            return None
+
+    # 1) Prefer UT-OBS if present (already “UTC-ish”)
+    for key in ("UT-OBS", "DATE-OBS", "DATE-END"):
+        v = _get(key)
+        if isinstance(v, str) and v.strip():
+            try:
+                return Time(_fix_iso_tz(v), format="isot", scale="utc")
+            except Exception:
+                pass
+
+    # 2) MJD-OBS is super reliable
+    v = _get("MJD-OBS")
+    if v is not None:
+        try:
+            return Time(float(v), format="mjd", scale="utc")
+        except Exception:
+            pass
+
+    return None
 
 def _estimate_fov_deg(img_shape, scale_arcsec):
     """Rough FOV (deg) from image size and scale (max of X/Y)."""
@@ -646,9 +682,12 @@ class ExoPlanetWindow(QDialog):
         self.measure_btn.setVisible(is_raw)
 
     def load_and_measure_subs(self):
+        before = len(getattr(self, "image_paths", []))
         self.load_aligned_subs()
+        after = len(getattr(self, "image_paths", []))
+        if after == 0 or after == before and not self._cached_images:
+            return
         self.detect_stars()
-
     # --------------- I/O + Calibration ----------------
 
     def load_raw_subs(self):
@@ -682,13 +721,38 @@ class ExoPlanetWindow(QDialog):
                     ds      = hdr0.get('DATE-OBS')
                 except:
                     ds = None
+
+            # Use robust header time parsing (UT-OBS -> DATE-OBS -> MJD-OBS fallback)
             t = None
-            if isinstance(ds, str):
-                try:
-                    t = Time(ds, format='isot', scale='utc')
-                except Exception as e:
-                    print(f"[DEBUG] Failed to parse DATE-OBS for {p}: {e}")
+            try:
+                if ext == ".xisf":
+                    # Build a tiny dict-like header for the helper
+                    hdr_like = {}
+                    try:
+                        xisf     = XISF(p)
+                        img_meta = xisf.get_images_metadata()[0]
+                        kw       = img_meta.get("FITSKeywords", {}) or {}
+                        # XISF FITSKeywords layout: key -> [ {value: ...}, ... ]
+                        for k in ("UT-OBS", "DATE-OBS", "DATE-END", "MJD-OBS"):
+                            if k in kw and kw[k]:
+                                hdr_like[k] = kw[k][0].get("value")
+                    except Exception:
+                        hdr_like = {}
+                    t = _parse_obs_time_from_header(hdr_like)
+
+                elif ext in (".fit", ".fits", ".fz"):
+                    hdr0, _ = get_valid_header(p)
+                    t = _parse_obs_time_from_header(hdr0)
+
+                else:
+                    # TIFF etc. may not have FITS-like time headers; leave None
+                    t = None
+
+            except Exception as e:
+                print(f"[DEBUG] Failed to parse obs time for {p}: {e}")
+
             datelist.append((p, t))
+
             self.progress_bar.setValue(i)
             QApplication.processEvents()
 
@@ -768,24 +832,28 @@ class ExoPlanetWindow(QDialog):
             self.progress_bar.setValue(i)
             QApplication.processEvents()
 
-        iso_strs, mask_arr = [], []
-        for _, t in datelist:
-            if t is not None:
-                iso_strs.append(t.isot); mask_arr.append(False)
-            else:
-                iso_strs.append('');     mask_arr.append(True)
-        ma_strs = np.ma.MaskedArray(iso_strs, mask=mask_arr)
-        self.times = Time(ma_strs, format='isot', scale='utc', out_subfmt='date')
+        # Keep full timestamps (DO NOT truncate to date-only)
+        tlist = [t for _, t in datelist if t is not None]
+        if tlist:
+            self.times = Time(tlist)   # already utc scale from helper
+        else:
+            self.times = None
 
         self.progress_bar.setVisible(False)
         loaded = sum(1 for im in self._cached_images if im is not None)
         self.status_label.setText(f"Loaded {loaded}/{len(sorted_paths)} raw frames")
 
-    def load_aligned_subs(self):
+    def load_aligned_subs(self) -> bool:
         settings = QSettings()
         start_dir = settings.value("ExoPlanet/lastAlignedFolder", os.path.expanduser("~"), type=str)
-        paths, _ = QFileDialog.getOpenFileNames(self, "Select Aligned Frames", start_dir, "FITS or TIFF (*.fit *.fits *.tif *.tiff *.xisf)")
-        if not paths: return
+        paths, _ = QFileDialog.getOpenFileNames(
+            self, "Select Aligned Frames", start_dir,
+            "FITS or TIFF (*.fit *.fits *.tif *.tiff *.xisf)"
+        )
+        if not paths:
+            self.status_label.setText("Load canceled.")
+            return False
+
         settings.setValue("ExoPlanet/lastAlignedFolder", os.path.dirname(paths[0]))
 
         self.status_label.setText("Reading metadata from aligned frames…")
@@ -809,10 +877,35 @@ class ExoPlanetWindow(QDialog):
                     hdr0, _ = get_valid_header(p)
                     ds      = hdr0.get('DATE-OBS')
                 except: ds = None
+            # Use robust header time parsing (UT-OBS -> DATE-OBS -> MJD-OBS fallback)
             t = None
-            if isinstance(ds, str):
-                try: t = Time(ds, format='isot', scale='utc')
-                except Exception as e: print(f"[DEBUG] Failed to parse DATE-OBS for {p}: {e}")
+            try:
+                if ext == ".xisf":
+                    # Build a tiny dict-like header for the helper
+                    hdr_like = {}
+                    try:
+                        xisf     = XISF(p)
+                        img_meta = xisf.get_images_metadata()[0]
+                        kw       = img_meta.get("FITSKeywords", {}) or {}
+                        # XISF FITSKeywords layout: key -> [ {value: ...}, ... ]
+                        for k in ("UT-OBS", "DATE-OBS", "DATE-END", "MJD-OBS"):
+                            if k in kw and kw[k]:
+                                hdr_like[k] = kw[k][0].get("value")
+                    except Exception:
+                        hdr_like = {}
+                    t = _parse_obs_time_from_header(hdr_like)
+
+                elif ext in (".fit", ".fits", ".fz"):
+                    hdr0, _ = get_valid_header(p)
+                    t = _parse_obs_time_from_header(hdr0)
+
+                else:
+                    # TIFF etc. may not have FITS-like time headers; leave None
+                    t = None
+
+            except Exception as e:
+                print(f"[DEBUG] Failed to parse obs time for {p}: {e}")
+
             datelist.append((p, t))
             self.progress_bar.setValue(i)
             QApplication.processEvents()
@@ -889,18 +982,17 @@ class ExoPlanetWindow(QDialog):
             self.progress_bar.setValue(i)
             QApplication.processEvents()
 
-        iso_strs, mask_arr = [], []
-        for _, t in datelist:
-            if t is not None:
-                iso_strs.append(t.isot); mask_arr.append(False)
-            else:
-                iso_strs.append('');     mask_arr.append(True)
-        ma_strs = np.ma.MaskedArray(iso_strs, mask=mask_arr)
-        self.times = Time(ma_strs, format='isot', scale='utc', out_subfmt='date')
+        # Keep full timestamps (DO NOT truncate to date-only)
+        tlist = [t for _, t in datelist if t is not None]
+        if tlist:
+            self.times = Time(tlist)   # already utc scale from helper
+        else:
+            self.times = None
 
         self.progress_bar.setVisible(False)
         loaded = sum(1 for im in self._cached_images if im is not None)
         self.status_label.setText(f"Loaded {loaded}/{len(sorted_paths)} aligned frames")
+        return loaded > 0
 
     def load_masters(self):
         settings = QSettings()