celldetective 1.5.0b0__tar.gz → 1.5.0b1__tar.gz

{celldetective-1.5.0b0 → celldetective-1.5.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celldetective
-Version: 1.5.0b0
+Version: 1.5.0b1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.5.0b1/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.5.0b1"

{celldetective-1.5.0b0 → celldetective-1.5.0b1}/celldetective/gui/InitWindow.py

@@ -256,7 +256,7 @@ class AppInitWindow(CelldetectiveMainWindow):
             DownloadProcess = self.bg_loader.DownloadProcess
         else:
             from celldetective.processes.downloader import DownloadProcess
-        from celldetective.gui.workers import ProgressWindow
+        from celldetective.gui.workers import GenericProgressWindow
 
         self.target_dir = str(
             QFileDialog.getExistingDirectory(self, "Select Folder for Download")
@@ -268,12 +268,12 @@ class AppInitWindow(CelldetectiveMainWindow):
             self.output_dir = self.target_dir
             self.file = "demo_ricm"
             process_args = {"output_dir": self.output_dir, "file": self.file}
-            self.job = ProgressWindow(
+            self.job = GenericProgressWindow(
                 DownloadProcess,
                 parent_window=self,
                 title="Download",
-                position_info=False,
                 process_args=process_args,
+                label_text="Downloading demo_ricm...",
             )
             result = self.job.exec_()
             if result == QDialog.Accepted:

{celldetective-1.5.0b0 → celldetective-1.5.0b1}/celldetective/gui/workers.py

@@ -316,3 +316,102 @@ class RunnerSignal(QObject):
 
     finished = pyqtSignal()
     error = pyqtSignal(str)
+
+
+class GenericProgressWindow(CelldetectiveDialog):
+
+    def __init__(
+        self,
+        process=None,
+        parent_window=None,
+        title="",
+        process_args=None,
+        label_text="Progress:",
+    ):
+
+        super().__init__()
+
+        self.setWindowTitle(f"{title}")
+        self.__process = process
+        self.parent_window = parent_window
+
+        self.__btn_stp = QPushButton("Cancel")
+        self.__label = QLabel("Idle")
+        self.progress_label = QLabel(label_text)
+
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setValue(0)
+        self.progress_bar.setFormat("%p%")
+
+        self.__runner = Runner(
+            process=self.__process,
+            process_args=process_args,
+        )
+        logger.info("Runner initialized...")
+        self.pool = QThreadPool.globalInstance()
+
+        self.__btn_stp.clicked.connect(self.__stp_net)
+        self.__runner.signals.finished.connect(self.__on_finished)
+        self.__runner.signals.error.connect(self.__on_error)
+        self.__runner.signals.update_status.connect(self.__label.setText)
+
+        # Connect update_pos for generic progress (Runner maps generic list progress to update_pos)
+        self.__runner.signals.update_pos.connect(self.progress_bar.setValue)
+
+        self.__btn_stp.setDisabled(True)
+
+        self.layout = QVBoxLayout()
+        self.layout.addWidget(self.progress_label)
+        self.layout.addWidget(self.progress_bar)
+
+        self.btn_layout = QHBoxLayout()
+        self.btn_layout.addWidget(self.__btn_stp)
+        self.btn_layout.addWidget(self.__label)
+
+        self.layout.addLayout(self.btn_layout)
+
+        self.setLayout(self.layout)
+        self.setFixedSize(QSize(400, 150))
+        self.show()
+        self.raise_()
+        self.activateWindow()
+        logger.info("GenericProgressWindow initialized and shown.")
+        self.__run_net()
+        self.setModal(True)
+
+    def closeEvent(self, evnt):
+        evnt.ignore()
+        self.setWindowState(Qt.WindowMinimized)
+
+    def __run_net(self):
+        self.__btn_stp.setEnabled(True)
+        self.__label.setText("Running...")
+        self.pool.start(self.__runner)
+
+    def __stp_net(self):
+        self.__runner.close()
+        logger.info("\n Job cancelled... Abort.")
+        self.reject()
+
+    def __on_finished(self):
+        self.__btn_stp.setDisabled(True)
+        self.__label.setText("\nFinished!")
+        self.__runner.close()
+        self.accept()
+
+    def __on_error(self, message="Error"):
+        self.__btn_stp.setDisabled(True)
+        self.__label.setText("\nError")
+        self.__runner.close()
+
+        # Show error in a message box to ensure it's seen
+        from PyQt5.QtWidgets import QMessageBox
+
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Critical)
+        msg.setText("Process failed")
+        msg.setInformativeText(str(message))
+        msg.setWindowTitle("Error")
+        msg.exec_()
+
+        self.reject()

celldetective-1.5.0b1/celldetective/processes/downloader.py

@@ -0,0 +1,137 @@
+import os
+import ssl
+from tqdm import tqdm
+from multiprocessing import Process
+from glob import glob
+import shutil
+from urllib.request import urlopen
+import zipfile
+import tempfile
+import time
+from pathlib import Path
+import json
+
+
+class DownloadProcess(Process):
+
+    def __init__(self, queue=None, process_args=None, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+
+        if process_args is not None:
+            for key, value in process_args.items():
+                setattr(self, key, value)
+
+        self.queue = queue
+        self.progress = True
+
+        # Get celldetective package root
+        current_dir = os.path.dirname(os.path.realpath(__file__))
+        package_root = os.path.dirname(current_dir)
+        zenodo_json = os.path.join(package_root, "links", "zenodo.json")
+        # print(f"{zenodo_json=}")
+
+        with open(zenodo_json, "r") as f:
+            zenodo_json = json.load(f)
+        all_files = list(zenodo_json["files"]["entries"].keys())
+        all_files_short = [f.replace(".zip", "") for f in all_files]
+        zenodo_url = zenodo_json["links"]["files"].replace("api/", "")
+        full_links = ["/".join([zenodo_url, f]) for f in all_files]
+        index = all_files_short.index(self.file)
+
+        self.zip_url = full_links[index]
+        self.path_to_zip_file = os.sep.join([self.output_dir, "temp.zip"])
+
+        self.sum_done = 0
+        self.t0 = time.time()
+
+    def download_url_to_file(self, url, dst):
+        try:
+            file_size = None
+            ssl._create_default_https_context = ssl._create_unverified_context
+            u = urlopen(url)
+            meta = u.info()
+            if hasattr(meta, "getheaders"):
+                content_length = meta.getheaders("Content-Length")
+            else:
+                content_length = meta.get_all("Content-Length")
+            if content_length is not None and len(content_length) > 0:
+                file_size = int(content_length[0])
+            # We deliberately save it in a temp file and move it after
+            dst = os.path.expanduser(dst)
+            dst_dir = os.path.dirname(dst)
+            f = tempfile.NamedTemporaryFile(delete=False, dir=dst_dir)
+
+            try:
+                with tqdm(
+                    total=file_size,
+                    disable=not self.progress,
+                    unit="B",
+                    unit_scale=True,
+                    unit_divisor=1024,
+                ) as pbar:
+                    while True:
+                        buffer = u.read(8192)  # 8192
+                        if len(buffer) == 0:
+                            break
+                        f.write(buffer)
+                        pbar.update(len(buffer))
+                        self.sum_done += len(buffer) / file_size * 100
+                        mean_exec_per_step = (time.time() - self.t0) / (
+                            self.sum_done * file_size / 100 + 1
+                        )
+                        pred_time = (
+                            file_size - (self.sum_done * file_size / 100 + 1)
+                        ) * mean_exec_per_step
+                        self.queue.put([self.sum_done, pred_time])
+                f.close()
+                shutil.move(f.name, dst)
+            finally:
+                f.close()
+                if os.path.exists(f.name):
+                    os.remove(f.name)
+        except Exception as e:
+            print("No internet connection: ", e)
+            return None
+
+    def run(self):
+
+        self.download_url_to_file(rf"{self.zip_url}", self.path_to_zip_file)
+        with zipfile.ZipFile(self.path_to_zip_file, "r") as zip_ref:
+            zip_ref.extractall(self.output_dir)
+
+        file_to_rename = glob(
+            os.sep.join(
+                [
+                    self.output_dir,
+                    self.file,
+                    "*[!.json][!.png][!.h5][!.csv][!.npy][!.tif][!.ini]",
+                ]
+            )
+        )
+        if (
+            len(file_to_rename) > 0
+            and not file_to_rename[0].endswith(os.sep)
+            and not self.file.startswith("demo")
+        ):
+            os.rename(
+                file_to_rename[0], os.sep.join([self.output_dir, self.file, self.file])
+            )
+
+        os.remove(self.path_to_zip_file)
+        self.queue.put([100, 0])
+        time.sleep(0.5)
+
+        # Send end signal
+        self.queue.put("finished")
+        self.queue.close()
+
+    def end_process(self):
+
+        self.terminate()
+        self.queue.put("finished")
+
+    def abort_process(self):
+
+        self.terminate()
+        self.queue.put("error")

{celldetective-1.5.0b0 → celldetective-1.5.0b1}/celldetective/utils/downloaders.py

@@ -159,6 +159,44 @@ def download_url_to_file(url, dst, progress=True):
 def download_zenodo_file(file, output_dir):
 
     logger.info(f"{file=} {output_dir=}")
+
+    # GUI Check
+    try:
+        from PyQt5.QtWidgets import QApplication, QDialog
+
+        app = QApplication.instance()
+        use_gui = app is not None
+    except ImportError:
+        use_gui = False
+
+    if use_gui:
+        try:
+            from celldetective.gui.workers import GenericProgressWindow
+            from celldetective.processes.downloader import DownloadProcess
+
+            # Find parent window if possible, else None is fine for a dialog
+            parent = app.activeWindow()
+
+            process_args = {"output_dir": output_dir, "file": file}
+            job = GenericProgressWindow(
+                DownloadProcess,
+                parent_window=parent,
+                title="Download",
+                process_args=process_args,
+                label_text=f"Downloading {file}...",
+            )
+            result = job.exec_()
+            if result == QDialog.Accepted:
+                return  # DownloadProcess handles the file operations
+            else:
+                logger.info("Download cancelled or failed.")
+                return
+
+        except Exception as e:
+            logger.error(f"Failed to use GUI downloader: {e}. Falling back to console.")
+            # Fallback to console implementation below if GUI fails
+
+    # Console Implementation
     zenodo_json = os.sep.join(
         [
             os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],

{celldetective-1.5.0b0 → celldetective-1.5.0b1}/celldetective.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celldetective
-Version: 1.5.0b0
+Version: 1.5.0b1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.5.0b0/celldetective/_version.py

@@ -1 +0,0 @@
-__version__ = "1.5.0b"

celldetective-1.5.0b0/celldetective/processes/downloader.py

@@ -1,111 +0,0 @@
-import os
-import ssl
-from tqdm import tqdm
-from multiprocessing import Process
-from glob import glob
-import shutil
-from urllib.request import urlopen
-import zipfile
-import tempfile
-import time
-from pathlib import Path
-import json
-
-class DownloadProcess(Process):
-
-	def __init__(self, queue=None, process_args=None, *args, **kwargs):
-		
-		super().__init__(*args, **kwargs)
-		
-		if process_args is not None:
-			for key, value in process_args.items():
-				setattr(self, key, value)
-
-		self.queue = queue
-		self.progress = True
-
-		file_path = Path(os.path.dirname(os.path.realpath(__file__)))
-		zenodo_json = os.sep.join([str(file_path.parents[2]),"celldetective", "links", "zenodo.json"])
-		print(f"{zenodo_json=}")
-		
-		with open(zenodo_json,"r") as f:
-			zenodo_json = json.load(f)
-		all_files = list(zenodo_json['files']['entries'].keys())
-		all_files_short = [f.replace(".zip","") for f in all_files]
-		zenodo_url = zenodo_json['links']['files'].replace('api/','')
-		full_links = ["/".join([zenodo_url, f]) for f in all_files]
-		index = all_files_short.index(self.file)
-		
-		self.zip_url = full_links[index]
-		self.path_to_zip_file = os.sep.join([self.output_dir, 'temp.zip'])
-
-		self.sum_done = 0
-		self.t0 = time.time()
-
-	def download_url_to_file(self, url, dst):
-		try:
-			file_size = None
-			ssl._create_default_https_context = ssl._create_unverified_context
-			u = urlopen(url)
-			meta = u.info()
-			if hasattr(meta, 'getheaders'):
-				content_length = meta.getheaders("Content-Length")
-			else:
-				content_length = meta.get_all("Content-Length")
-			if content_length is not None and len(content_length) > 0:
-				file_size = int(content_length[0])
-			# We deliberately save it in a temp file and move it after
-			dst = os.path.expanduser(dst)
-			dst_dir = os.path.dirname(dst)
-			f = tempfile.NamedTemporaryFile(delete=False, dir=dst_dir)
-
-			try:
-				with tqdm(total=file_size, disable=not self.progress,
-						  unit='B', unit_scale=True, unit_divisor=1024) as pbar:
-					while True:
-						buffer = u.read(8192) #8192
-						if len(buffer) == 0:
-							break
-						f.write(buffer)
-						pbar.update(len(buffer))
-						self.sum_done+=len(buffer) / file_size * 100
-						mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*file_size / 100 + 1)
-						pred_time = (file_size - (self.sum_done*file_size / 100 + 1)) * mean_exec_per_step
-						self.queue.put([self.sum_done, pred_time])
-				f.close()
-				shutil.move(f.name, dst)
-			finally:
-				f.close()
-				if os.path.exists(f.name):
-					os.remove(f.name)
-		except Exception as e:
-			print("No internet connection: ", e)
-			return None
-
-	def run(self):
-		
-		self.download_url_to_file(fr"{self.zip_url}",self.path_to_zip_file)
-		with zipfile.ZipFile(self.path_to_zip_file, 'r') as zip_ref:
-			zip_ref.extractall(self.output_dir)
-		
-		file_to_rename = glob(os.sep.join([self.output_dir,self.file,"*[!.json][!.png][!.h5][!.csv][!.npy][!.tif][!.ini]"]))
-		if len(file_to_rename)>0 and not file_to_rename[0].endswith(os.sep) and not self.file.startswith('demo'):
-			os.rename(file_to_rename[0], os.sep.join([self.output_dir,self.file,self.file]))
-
-		os.remove(self.path_to_zip_file)
-		self.queue.put([100,0])
-		time.sleep(0.5)
-
-		# Send end signal
-		self.queue.put("finished")
-		self.queue.close()
-
-	def end_process(self):
-
-		self.terminate()
-		self.queue.put("finished")
-
-	def abort_process(self):
-		
-		self.terminate()
-		self.queue.put("error")