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

setiastro/saspro/cosmicclarity.py

@@ -228,21 +228,116 @@ class WaitForFileWorker(QThread):
     fileFound = pyqtSignal(str)
     cancelled = pyqtSignal()
     error     = pyqtSignal(str)
-    def __init__(self, glob_pat: str, timeout_sec=1800, parent=None):
+
+    def __init__(
+        self,
+        glob_pat: str,
+        timeout_sec: int = 1800,
+        parent=None,
+        *,
+        poll_ms: int = 200,
+        stable_polls: int = 6,          # 6 * 200ms = ~1.2s of stability
+        stable_timeout_sec: int = 120,  # extra time after first detection
+    ):
         super().__init__(parent)
         self._glob = glob_pat
-        self._timeout = timeout_sec
+        self._timeout = int(timeout_sec)
+        self._poll_ms = int(poll_ms)
+        self._stable_polls = int(stable_polls)
+        self._stable_timeout = int(stable_timeout_sec)
         self._running = True
+
+    def stop(self):
+        self._running = False
+
+    def _best_candidate(self, paths: list[str]) -> str | None:
+        if not paths:
+            return None
+        # prefer biggest file; tie-break by newest mtime
+        def key(p):
+            try:
+                st = os.stat(p)
+                return (st.st_size, st.st_mtime)
+            except Exception:
+                return (-1, -1)
+        paths.sort(key=key, reverse=True)
+        return paths[0]
+
+    def _is_stable_and_readable(self, path: str) -> bool:
+        """
+        Consider stable when size+mtime unchanged for N polls in a row AND file is readable.
+        Handles slow writers + Windows "file still locked" issues.
+        """
+        stable = 0
+        last = None
+
+        t0 = time.monotonic()
+        while self._running and (time.monotonic() - t0) < self._stable_timeout:
+            try:
+                st = os.stat(path)
+                cur = (st.st_size, st.st_mtime)
+                if st.st_size <= 0:
+                    stable = 0
+                    last = cur
+                elif cur == last:
+                    stable += 1
+                else:
+                    stable = 0
+                    last = cur
+
+                if stable >= self._stable_polls:
+                    # extra “is it readable?” check (important on Windows)
+                    try:
+                        with open(path, "rb") as f:
+                            f.read(64)
+                        return True
+                    except PermissionError:
+                        # still locked by writer, keep waiting
+                        stable = 0
+                    except Exception:
+                        # transient weirdness: keep waiting, don’t declare failure yet
+                        stable = 0
+
+            except FileNotFoundError:
+                stable = 0
+                last = None
+            except Exception:
+                # don't crash the worker for stat weirdness
+                stable = 0
+
+            time.sleep(self._poll_ms / 1000.0)
+
+        return False
+
     def run(self):
-        start = time.time()
-        while self._running and (time.time() - start < self._timeout):
-            m = glob.glob(self._glob)
-            if m:
-                self.fileFound.emit(m[0]); return
-            time.sleep(1)
-        if self._running: self.error.emit("Output file not found within timeout.")
-        else:             self.cancelled.emit()
-    def stop(self): self._running = False
+        t_start = time.monotonic()
+        seen_first_candidate_at = None
+
+        while self._running and (time.monotonic() - t_start) < self._timeout:
+            matches = glob.glob(self._glob)
+            cand = self._best_candidate(matches)
+
+            if cand:
+                if seen_first_candidate_at is None:
+                    seen_first_candidate_at = time.monotonic()
+
+                if self._is_stable_and_readable(cand):
+                    self.fileFound.emit(cand)
+                    return
+
+                # If we've been seeing candidates for a while but none stabilize,
+                # keep looping until global timeout. (This is common on slow disks.)
+
+            time.sleep(self._poll_ms / 1000.0)
+
+        if not self._running:
+            self.cancelled.emit()
+        else:
+            extra = ""
+            if seen_first_candidate_at is not None:
+                extra = " (output appeared but never stabilized)"
+            self.error.emit("Output file not found within timeout." + extra)
+
 
 
 # =============================================================================
@@ -274,6 +369,10 @@ class CosmicClarityDialogPro(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         if icon: 
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -552,6 +651,12 @@ class CosmicClarityDialogPro(QDialog):
             QMessageBox.critical(self, "Cosmic Clarity", f"Executable not found:\n{exe_path}")
             return
 
+        # ✅ compute base early (we need it for purge + glob)
+        base = self._base_name()
+
+        # ✅ purge any stale outputs for THIS base name (avoids matching old files)
+        _purge_cc_io(self.cosmic_root, clear_input=False, clear_output=True, prefix=base)
+
         # Build args (SASv2 flags mirrored)
         args = []
         if mode == "sharpen":
@@ -595,7 +700,7 @@ class CosmicClarityDialogPro(QDialog):
 
         # Wait for output file
         base = self._base_name()
-        out_glob = os.path.join(self.cosmic_root, "output", f"{base}{suffix}.*")
+        out_glob = os.path.join(self.cosmic_root, "output", f"{base}*{suffix}*.*")
         self._wait = WaitDialog(f"Cosmic Clarity – {mode.title()}", self)
         self._wait.cancelled.connect(self._cancel_all)
         self._wait.show()
@@ -611,19 +716,25 @@ class CosmicClarityDialogPro(QDialog):
 
     def _read_proc_output(self, proc: QProcess, which="main"):
         out = proc.readAllStandardOutput().data().decode("utf-8", errors="replace")
-        if not self._wait: return
+        if not self._wait:
+            return
+
         for line in out.splitlines():
             line = line.strip()
-            if not line: continue
+            if not line:
+                continue
+
             if line.startswith("Progress:"):
                 try:
-                    pct = float(line.split()[1].replace("%",""))
+                    pct = float(line.split()[1].replace("%", ""))
                     self._wait.set_progress(int(pct))
                 except Exception:
                     pass
-            else:
-                self._wait.append_output(line)
-        print(f"[CC] {line}")        
+                continue  # <- skip echo
+
+            # non-progress lines: keep showing + printing
+            self._wait.append_output(line)
+            print(f"[CC] {line}")       
 
     def _on_proc_finished(self, mode, suffix, code, status):
         if code != 0:

setiastro/saspro/crop_dialog_pro.py

@@ -58,7 +58,8 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         self._rotating = False
         self._angle0 = 0.0
         self._pivot_scene = QPointF()
-
+        self._bounds_scene: QRectF | None = None
+        self._clamp_eps_deg = 0.25  # treat as "unrotated" if |angle| < eps (deg)
         self._grab_pad = 20              # ← extra hit slop in screen px
         self._edge_pad_px = EDGE_GRAB_PX
         self.setZValue(100)             # ← keep above pixmap
@@ -83,7 +84,26 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         dx = p1.x() - p0.x()
         dy = p1.y() - p0.y()
         return math.hypot(dx, dy)
-
+    def setBoundsSceneRect(self, r: QRectF | None):
+        """Set the scene-rect bounds we should stay within when unrotated."""
+        self._bounds_scene = QRectF(r) if r is not None else None
+
+    def _is_unrotated(self) -> bool:
+        # normalize angle to [-180, 180]
+        a = float(self.rotation()) % 360.0
+        if a > 180.0:
+            a -= 360.0
+        return abs(a) < self._clamp_eps_deg
+
+    def _bounds_local(self) -> QRectF | None:
+        """Bounds rect mapped into the item's local coordinates (only valid when unrotated)."""
+        if self._bounds_scene is None:
+            return None
+        # When unrotated, this is safe and stable.
+        tl = self.mapFromScene(self._bounds_scene.topLeft())
+        br = self.mapFromScene(self._bounds_scene.bottomRight())
+        return QRectF(tl, br).normalized()
+    
     def _edge_under_cursor(self, scene_pos: QPointF) -> Optional[str]:
         """
         Return 'l', 'r', 't', or 'b' if the pointer is near an edge (within px-tolerance),
@@ -218,12 +238,52 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
             QGraphicsItem.GraphicsItemChange.ItemTransformHasChanged,
         ):
             self._sync_handles()
+
+        if change == QGraphicsItem.GraphicsItemChange.ItemPositionChange:
+            if self._bounds_scene is not None and self._is_unrotated():
+                new_pos = QPointF(value)
+
+                # current scene rect of the item (at current pos)
+                sr0 = self.mapRectToScene(self.rect())  # QRectF in scene coords
+
+                # shift it by the delta between proposed pos and current pos
+                d = new_pos - self.pos()
+                sr = sr0.translated(d)
+
+                b = self._bounds_scene
+                dx = 0.0
+                dy = 0.0
+
+                if sr.left() < b.left():
+                    dx = b.left() - sr.left()
+                elif sr.right() > b.right():
+                    dx = b.right() - sr.right()
+
+                if sr.top() < b.top():
+                    dy = b.top() - sr.top()
+                elif sr.bottom() > b.bottom():
+                    dy = b.bottom() - sr.bottom()
+
+                if dx != 0.0 or dy != 0.0:
+                    return new_pos + QPointF(dx, dy)
+
+                return new_pos
+
         return super().itemChange(change, value)
 
     def _resize_via_handle(self, scene_pt: QPointF):
         r = self.rect()
         p = self.mapFromScene(scene_pt)
 
+        # Clamp handle drag to bounds only when unrotated.
+        if self._bounds_scene is not None and self._is_unrotated():
+            bL = self._bounds_local()
+            if bL is not None:
+                # NOTE: bL is in the same local coordinate space as r/p.
+                px = min(max(p.x(), bL.left()),  bL.right())
+                py = min(max(p.y(), bL.top()),   bL.bottom())
+                p = QPointF(px, py)
+
         # Corners
         if   self._active == "tl": r.setTopLeft(p)
         elif self._active == "tr": r.setTopRight(p)
@@ -277,10 +337,19 @@ class CropDialogPro(QDialog):
         self._main = parent
         self.doc = document
 
-        # Connect to active document change signal
+        self._follow_conn = False
         if hasattr(self._main, "currentDocumentChanged"):
-            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+            try:
+                self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+                self._follow_conn = True
+            except Exception:
+                self._follow_conn = False
 
+        self.finished.connect(self._cleanup_connections)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self._rect_item: Optional[ResizableRotatableRectItem] = None
         self._pix_item: Optional[QGraphicsPixmapItem] = None
         self._drawing = False
@@ -415,7 +484,7 @@ class CropDialogPro(QDialog):
         self.btn_prev.clicked.connect(self._load_previous)
         self.btn_apply.clicked.connect(self._apply_one)
         self.btn_batch.clicked.connect(self._apply_batch)
-        self.btn_close.clicked.connect(self.accept)
+        self.btn_close.clicked.connect(self.close)
 
         # seed image
         self._load_from_doc()
@@ -607,6 +676,7 @@ class CropDialogPro(QDialog):
                 if e.type() == QEvent.Type.MouseMove and self._drawing:
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=True, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._draw_live_rect(r)
 
                     # ⬇️ live dims from the temporary rect (axis-aligned TL,TR,BR,BL)
@@ -618,9 +688,12 @@ class CropDialogPro(QDialog):
                     self._drawing = False
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=False, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._clear_live_rect()
+
                     self._rect_item = ResizableRotatableRectItem(r)
                     self._rect_item.setZValue(10)
+                    self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
                     self._rect_item.setFixedAspectRatio(self._current_ar_value())
                     self.scene.addItem(self._rect_item)
 
@@ -706,6 +779,7 @@ class CropDialogPro(QDialog):
         if self._rect_item is None:
             self._rect_item = ResizableRotatableRectItem(r)
             self._rect_item.setZValue(10)
+            self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
             self.scene.addItem(self._rect_item)
         else:
             self._rect_item.setRotation(0.0)
@@ -749,6 +823,32 @@ class CropDialogPro(QDialog):
         if hasattr(self, "_live_rect") and self._live_rect:
             self.scene.removeItem(self._live_rect); self._live_rect = None
 
+    def _pixmap_scene_rect(self) -> QRectF | None:
+        """Scene rect occupied by the pixmap (image) item."""
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+    def _clamp_rect_to_pixmap(self, r: QRectF) -> QRectF:
+        """Intersect an axis-aligned QRectF with the pixmap scene rect."""
+        bounds = self._pixmap_scene_rect()
+        if bounds is None:
+            return r.normalized()
+        rr = r.normalized().intersected(bounds)
+        # avoid empty rects (keep at least 1x1 scene unit)
+        if rr.isNull() or rr.width() <= 1e-6 or rr.height() <= 1e-6:
+            # fallback: clamp to a 1x1 rect at the nearest point inside bounds
+            x = min(max(r.center().x(), bounds.left()),  bounds.right())
+            y = min(max(r.center().y(), bounds.top()),   bounds.bottom())
+            rr = QRectF(x, y, 1.0, 1.0)
+        return rr.normalized()
+
+    def _bounds_scene_rect(self) -> QRectF | None:
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+
     # ---------- preview toggles ----------
     def _toggle_autostretch(self):
         self._autostretch_on = not self._autostretch_on
@@ -768,6 +868,7 @@ class CropDialogPro(QDialog):
         r, ang, pos = state
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(ang)
         self._rect_item.setPos(pos)
@@ -785,6 +886,7 @@ class CropDialogPro(QDialog):
         r = QRectF(CropDialogPro._prev_rect)
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(CropDialogPro._prev_angle)
         self._rect_item.setPos(CropDialogPro._prev_pos)
@@ -803,6 +905,7 @@ class CropDialogPro(QDialog):
         sx, sy = w_img / pm.width(), h_img / pm.height()
         return np.array([pt_scene.x() * sx, pt_scene.y() * sy], dtype=np.float32)
 
+
     def _apply_one(self):
         if not self._rect_item:
             QMessageBox.warning(self, self.tr("No Selection"), self.tr("Draw & finalize a crop first."))
@@ -865,7 +968,7 @@ class CropDialogPro(QDialog):
             self.doc.apply_edit(out.copy(), metadata={**new_meta, "step_name": "Crop"}, step_name="Crop")
             self._maybe_notify_wcs_update(new_meta)
             self.crop_applied.emit(out)
-            self.accept()
+            self.close()
         except Exception as e:
             QMessageBox.critical(self, self.tr("Apply failed"), str(e))
 
@@ -951,7 +1054,7 @@ class CropDialogPro(QDialog):
         QMessageBox.information(self, self.tr("Batch Crop"), self.tr("Applied crop to all open images. Any Astrometric Solutions has been updated."))
         if last_cropped is not None:
             self.crop_applied.emit(last_cropped)
-        self.accept()
+        self.close()
 
     def _maybe_notify_wcs_update(self, meta: dict, batch_note: str | None = None):
         dbg = (meta or {}).get("__wcs_debug__")
@@ -981,3 +1084,16 @@ class CropDialogPro(QDialog):
         except Exception:
             # Be quiet if formatting fails
             pass
+
+    def _cleanup_connections(self):
+        try:
+            if self._follow_conn and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._follow_conn = False
+
+
+    def closeEvent(self, ev):
+        self._cleanup_connections()
+        super().closeEvent(ev)