FeatureRank 0.1.1__tar.gz → 0.1.4__tar.gz

{featurerank-0.1.1 → featurerank-0.1.4}/FeatureRank/GUI.py

@@ -6,8 +6,6 @@ still performed by ``scripts.FeatureRank`` and the existing ``src`` modules.
 
 from __future__ import annotations
 
-import contextlib
-import io
 import os
 from pathlib import Path
 import queue
@@ -21,6 +19,7 @@ from tkinter import filedialog, messagebox, ttk
 
 PERCENT_VALUES = tuple(str(value) for value in range(10, 101, 10))
 BLOCK_VALUES = ("5", "10", "20")
+NO_DATASET_LABEL = "No Dataset"
 MODE_LABELS = {
     "GL": "GL — Global Feature Ranking",
     "DC": "DC — Divide & Combine Feature Ranking",
@@ -33,22 +32,6 @@ TASK_LABELS = {
 _WINDOW_OPENED = False
 
 
-class _QueueWriter(io.TextIOBase):
-    """Forward workflow output to the GUI queue without changing the workflow."""
-
-    def __init__(self, messages: queue.Queue[tuple[str, object]]) -> None:
-        super().__init__()
-        self.messages = messages
-
-    def write(self, text: str) -> int:
-        if text:
-            self.messages.put(("log", text))
-        return len(text)
-
-    def flush(self) -> None:
-        return None
-
-
 def _dataset_choices() -> list[str]:
     """Find the repository's paired raw datasets for the dropdown."""
     project_root = Path(__file__).resolve().parent.parent
@@ -58,9 +41,42 @@ def _dataset_choices() -> list[str]:
         if not directory.exists():
             continue
         for data_file in sorted(directory.glob("*_data.csv")):
-            if data_file.is_file() and data_file.name not in choices:
-                choices.append(data_file.name)
-    return choices or ["breast_cancer_data.csv"]
+            absolute_path = str(data_file.resolve())
+            if data_file.is_file() and absolute_path not in choices:
+                choices.append(absolute_path)
+    return choices or [NO_DATASET_LABEL]
+
+
+def _resolve_dataset_path(dataset: str) -> str:
+    """Use an absolute path when the selected file exists locally."""
+    requested = Path(dataset).expanduser()
+    if requested.is_file():
+        return str(requested.resolve())
+
+    project_root = Path(__file__).resolve().parent.parent
+    candidates = (
+        Path.cwd() / requested,
+        Path.cwd() / "data" / "raw" / requested,
+        project_root / requested,
+        project_root / "data" / "raw" / requested,
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return str(candidate.resolve())
+    return dataset
+
+
+def _worker_python() -> Path:
+    """Find a project virtual-environment interpreter before the system one."""
+    project_root = Path(__file__).resolve().parent.parent
+    executable_name = "python.exe" if os.name == "nt" else "python"
+    candidates = (
+        Path.cwd() / ".venv" / ("Scripts" if os.name == "nt" else "bin") / executable_name,
+        project_root / ".venv" / ("Scripts" if os.name == "nt" else "bin") / executable_name,
+        Path(sys.executable).with_name("python"),
+        Path(sys.executable),
+    )
+    return next((candidate for candidate in candidates if candidate.is_file()), candidates[-1])
 
 
 def _open_folder(path: Path) -> None:
@@ -97,16 +113,27 @@ class FeatureRankGUI:
     def __init__(self, root: tk.Tk) -> None:
         self.root = root
         self.root.title("FeatureRank")
-        self.root.geometry("780x720")
-        self.root.minsize(700, 620)
+        # Keep the first view compact; the log can still grow when resized.
+        self.root.geometry("760x680")
+        self.root.minsize(680, 600)
 
         self.messages: queue.Queue[tuple[str, object]] = queue.Queue()
         self.worker: threading.Thread | None = None
         self.last_output_dir: Path | None = None
         self.block_count = 10
         self.blocks_seen = 0
+        self.progress_value = 0.0
+        self.progress_started_at: float | None = None
+        self.progress_job: str | None = None
+        self.progress_running = False
+
+        dataset_paths = _dataset_choices()
+        self.dataset_paths = {
+            Path(path).name: path for path in dataset_paths if path != NO_DATASET_LABEL
+        }
+        self.dataset_labels = [NO_DATASET_LABEL, *self.dataset_paths]
 
-        self.dataset_var = tk.StringVar(value=_dataset_choices()[0])
+        self.dataset_var = tk.StringVar(value=NO_DATASET_LABEL)
         self.percent_var = tk.StringVar(value="20")
         self.task_var = tk.StringVar(value="Classification")
         self.mode_var = tk.StringVar(value=MODE_LABELS["GL"])
@@ -139,16 +166,56 @@ class FeatureRankGUI:
             style.theme_use("clam")
         except tk.TclError:
             pass
-        style.configure("Title.TLabel", font=("Helvetica", 20, "bold"), foreground="#1f2937")
-        style.configure("Subtitle.TLabel", font=("Helvetica", 10), foreground="#4b5563")
-        style.configure("Stage.TLabel", font=("Helvetica", 11, "bold"), foreground="#1f4e79")
-        style.configure("Run.TButton", font=("Helvetica", 11, "bold"), padding=(18, 8))
+        # A restrained palette gives the form a clean surface on all platforms.
+        self.root.configure(background="#f4f6f8")
+        style.configure("TFrame", background="#f4f6f8")
+        style.configure("TLabel", background="#ffffff", foreground="#1f2937")
+        style.configure("TLabelframe", background="#ffffff")
+        style.configure("TLabelframe.Label", background="#ffffff", foreground="#1f2937")
+        style.configure(
+            "Title.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 20, "bold"),
+            foreground="#1f2937",
+        )
+        style.configure(
+            "Subtitle.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 10),
+            foreground="#4b5563",
+        )
+        style.configure(
+            "Stage.TLabel",
+            background="#f4f6f8",
+            font=("Helvetica", 11, "bold"),
+            foreground="#1f4e79",
+        )
+        style.configure(
+            "Run.TButton",
+            background="#1f4e79",
+            foreground="#ffffff",
+            font=("Helvetica", 11, "bold"),
+            padding=(16, 6),
+        )
+        style.map(
+            "Run.TButton",
+            background=[("active", "#173a5c"), ("disabled", "#b9c3cf")],
+            foreground=[("disabled", "#eef2f6")],
+        )
+        style.configure(
+            "Horizontal.TProgressbar",
+            background="#1f4e79",
+            troughcolor="#e5e7eb",
+            bordercolor="#d1d5db",
+            lightcolor="#1f4e79",
+            darkcolor="#1f4e79",
+        )
 
     def _build_window(self) -> None:
         self.root.columnconfigure(0, weight=1)
         self.root.rowconfigure(3, weight=1)
 
-        header = ttk.Frame(self.root, padding=(28, 24, 28, 12))
+        header = ttk.Frame(self.root, padding=(24, 18, 24, 8))
         header.grid(row=0, column=0, sticky="ew")
         ttk.Label(header, text="FeatureRank", style="Title.TLabel").pack(anchor="w")
         ttk.Label(
@@ -157,53 +224,55 @@ class FeatureRankGUI:
             style="Subtitle.TLabel",
         ).pack(anchor="w", pady=(4, 0))
 
-        options = ttk.LabelFrame(self.root, text="Experiment", padding=18)
-        options.grid(row=1, column=0, padx=28, pady=8, sticky="ew")
+        options = ttk.LabelFrame(self.root, text="Experiment", padding=14)
+        options.grid(row=1, column=0, padx=24, pady=6, sticky="ew")
         options.columnconfigure(1, weight=1)
 
-        ttk.Label(options, text="Dataset").grid(row=0, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Dataset").grid(row=0, column=0, sticky="w", pady=5)
         self.dataset_combo = ttk.Combobox(
-            options, textvariable=self.dataset_var, values=_dataset_choices(), state="readonly"
+            options, textvariable=self.dataset_var, values=self.dataset_labels, state="readonly"
         )
-        self.dataset_combo.grid(row=0, column=1, sticky="ew", padx=(14, 8), pady=7)
+        self.dataset_combo.grid(row=0, column=1, sticky="ew", padx=(10, 6), pady=5)
         ttk.Button(options, text="Browse…", command=self._browse_dataset).grid(
-            row=0, column=2, pady=7
+            row=0, column=2, pady=5
         )
 
-        ttk.Label(options, text="Task").grid(row=1, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Task").grid(row=1, column=0, sticky="w", pady=5)
         ttk.Combobox(
             options,
             textvariable=self.task_var,
             values=tuple(TASK_LABELS),
             state="readonly",
-        ).grid(row=1, column=1, sticky="ew", padx=(14, 8), pady=7)
+        ).grid(row=1, column=1, sticky="ew", padx=(10, 6), pady=5)
 
-        ttk.Label(options, text="Feature Percent").grid(row=2, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Feature Percent").grid(row=2, column=0, sticky="w", pady=5)
         ttk.Combobox(
             options,
             textvariable=self.percent_var,
             values=PERCENT_VALUES,
             state="readonly",
             width=12,
-        ).grid(row=2, column=1, sticky="w", padx=(14, 8), pady=7)
+        ).grid(row=2, column=1, sticky="w", padx=(10, 6), pady=5)
 
-        ttk.Label(options, text="Mode").grid(row=3, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Mode").grid(row=3, column=0, sticky="w", pady=5)
         self.mode_combo = ttk.Combobox(
             options,
             textvariable=self.mode_var,
             values=tuple(MODE_LABELS.values()),
             state="readonly",
         )
-        self.mode_combo.grid(row=3, column=1, sticky="ew", padx=(14, 8), pady=7)
+        self.mode_combo.grid(row=3, column=1, sticky="ew", padx=(10, 6), pady=5)
         self.mode_combo.bind("<<ComboboxSelected>>", self._mode_changed)
 
-        ttk.Label(options, text="Block Count").grid(row=4, column=0, sticky="w", pady=7)
+        ttk.Label(options, text="Block Count").grid(row=4, column=0, sticky="w", pady=5)
         self.block_combo = ttk.Combobox(
             options, textvariable=self.block_var, values=BLOCK_VALUES, state="disabled", width=12
         )
-        self.block_combo.grid(row=4, column=1, sticky="w", padx=(14, 8), pady=7)
+        self.block_combo.grid(row=4, column=1, sticky="w", padx=(10, 6), pady=5)
 
-        action_row = ttk.Frame(self.root, padding=(28, 8, 28, 8))
+        # Keep the run controls in a shallow toolbar so START is not surrounded
+        # by a large empty band.
+        action_row = ttk.Frame(self.root, padding=(24, 2, 24, 2))
         action_row.grid(row=2, column=0, sticky="ew")
         action_row.columnconfigure(1, weight=1)
         self.start_button = ttk.Button(
@@ -214,14 +283,14 @@ class FeatureRankGUI:
             row=0, column=1, sticky="e", padx=(12, 0)
         )
 
-        progress_frame = ttk.Frame(self.root, padding=(28, 0, 28, 12))
+        progress_frame = ttk.Frame(self.root, padding=(24, 0, 24, 8))
         progress_frame.grid(row=3, column=0, sticky="nsew")
         progress_frame.columnconfigure(0, weight=1)
         progress_frame.rowconfigure(2, weight=1)
         self.progress = ttk.Progressbar(progress_frame, mode="determinate", maximum=100)
         self.progress.grid(row=0, column=0, sticky="ew")
         ttk.Label(progress_frame, textvariable=self.status_var, style="Subtitle.TLabel").grid(
-            row=1, column=0, sticky="w", pady=(6, 8)
+            row=1, column=0, sticky="w", pady=(5, 6)
         )
 
         log_frame = ttk.LabelFrame(progress_frame, text="Log / Output", padding=8)
@@ -230,7 +299,7 @@ class FeatureRankGUI:
         log_frame.rowconfigure(0, weight=1)
         self.log_text = tk.Text(
             log_frame,
-            height=13,
+            height=8,
             wrap="word",
             state="disabled",
             background="#f8fafc",
@@ -244,19 +313,19 @@ class FeatureRankGUI:
         scrollbar.grid(row=0, column=1, sticky="ns")
         self.log_text.configure(yscrollcommand=scrollbar.set)
 
-        summary = ttk.LabelFrame(self.root, text="Summary", padding=14)
-        summary.grid(row=4, column=0, padx=28, pady=(0, 10), sticky="ew")
+        summary = ttk.LabelFrame(self.root, text="Summary", padding=12)
+        summary.grid(row=4, column=0, padx=24, pady=(0, 8), sticky="ew")
         summary.columnconfigure(1, weight=1)
         for row, (key, value) in enumerate(self.summary_vars.items()):
             ttk.Label(summary, text=key).grid(row=row // 2, column=(row % 2) * 2, sticky="w")
             ttk.Label(summary, textvariable=value, foreground="#1f4e79").grid(
-                row=row // 2, column=(row % 2) * 2 + 1, sticky="w", padx=(8, 26), pady=2
+                row=row // 2, column=(row % 2) * 2 + 1, sticky="w", padx=(8, 22), pady=2
             )
 
         self.open_button = ttk.Button(
             self.root, text="Open Results Folder", command=self._open_results, state="disabled"
         )
-        self.open_button.grid(row=5, column=0, padx=28, pady=(0, 18), sticky="w")
+        self.open_button.grid(row=5, column=0, padx=24, pady=(0, 14), sticky="w")
 
     def _browse_dataset(self) -> None:
         selected = filedialog.askopenfilename(
@@ -264,14 +333,20 @@ class FeatureRankGUI:
             filetypes=[("CSV files", "*.csv"), ("Text files", "*.txt"), ("All files", "*.*")],
         )
         if selected:
-            self.dataset_var.set(selected)
+            # Keep the full path internally, but show only the file name in
+            # the form so the selected dataset remains readable.
+            self.dataset_paths[Path(selected).name] = selected
+            self.dataset_labels = [NO_DATASET_LABEL, *self.dataset_paths]
+            self.dataset_combo.configure(values=self.dataset_labels)
+            self.dataset_var.set(Path(selected).name)
 
     def _mode_changed(self, _event: object = None) -> None:
         is_dc = self.mode_var.get().startswith("DC")
         self.block_combo.configure(state="readonly" if is_dc else "disabled")
 
     def _start(self) -> None:
-        dataset = self.dataset_var.get().strip()
+        dataset_label = self.dataset_var.get().strip()
+        dataset = self.dataset_paths.get(dataset_label, "")
         if not dataset:
             messagebox.showerror("FeatureRank", "Please select a dataset.")
             return
@@ -291,10 +366,13 @@ class FeatureRankGUI:
         self.last_output_dir = None
         self.open_button.configure(state="disabled")
         self.start_button.configure(state="disabled")
-        self.progress.configure(value=2)
+        self.progress_value = 2.0
+        self.progress.configure(value=self.progress_value)
         self.stage_var.set("Loading Dataset")
         self.status_var.set("The experiment is running. You can follow progress in the log.")
         self._clear_log()
+        self.progress_started_at = time.perf_counter()
+        self.progress_running = True
 
         self.worker = threading.Thread(
             target=self._run_experiment,
@@ -302,23 +380,24 @@ class FeatureRankGUI:
             daemon=True,
         )
         self.worker.start()
+        self._animate_progress()
         self.root.after(100, self._poll_messages)
 
     def _run_experiment(
         self, dataset: str, percent: float, task: str, mode: str, block_count: int
     ) -> None:
         started_at = time.perf_counter()
-        writer = _QueueWriter(self.messages)
+        output_lines: list[str] = []
         try:
-            # These imports intentionally stay inside the worker.  Importing
-            # FeatureRank remains quick, and all computation reuses the CLI
-            # orchestration and task implementations already in the project.
-            from scripts.FeatureRank import metric_name_for_task, run_workflow
+            # Keep TensorFlow out of the Tk process.  On macOS, loading a model
+            # from a GUI thread can terminate the native Python process.  The
+            # existing FeatureRank CLI runs in a separate worker instead; its
+            # stdout is streamed back into this window.
             from src.Config import ExperimentConfig
-            from src.OutputPaths import metric_runs_path
 
+            dataset_path = _resolve_dataset_path(dataset)
             config = ExperimentConfig(
-                dataset_name=dataset,
+                dataset_name=dataset_path,
                 task=task,
                 feature_percent=percent,
                 random_state=42,
@@ -328,16 +407,59 @@ class FeatureRankGUI:
                 cluster_k=None,
                 save_details=False,
             )
-            metric_path = metric_runs_path(config.task, Path(dataset).stem, percent)
-            with contextlib.redirect_stdout(writer), contextlib.redirect_stderr(writer):
-                values, average = run_workflow(
-                    config=config,
-                    mode=mode,
-                    repeat_runs=1,
-                    metric_name=metric_name_for_task(config.task),
-                    metric_path=metric_path,
-                    block_count=block_count,
-                )
+            python_executable = _worker_python()
+            command = [
+                str(python_executable),
+                "-m",
+                "scripts.FeatureRank",
+                "--dataset-name",
+                dataset_path,
+                "--task",
+                task,
+                "--feature-percent",
+                str(percent),
+                "--random-state",
+                "42",
+                "--dc" if mode == "dc" else "--global",
+            ]
+            if mode == "dc":
+                command.extend(["--block-count", str(block_count)])
+
+            worker_environment = os.environ.copy()
+            worker_environment["PYTHONUNBUFFERED"] = "1"
+            package_root = str(Path(__file__).resolve().parent.parent)
+            existing_python_path = worker_environment.get("PYTHONPATH")
+            worker_environment["PYTHONPATH"] = os.pathsep.join(
+                path for path in (package_root, existing_python_path) if path
+            )
+            self.messages.put(("log", f"Worker: {python_executable}"))
+            process = subprocess.Popen(
+                command,
+                cwd=Path.cwd(),
+                env=worker_environment,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+            )
+            assert process.stdout is not None
+            for line in process.stdout:
+                output_lines.append(line.rstrip())
+                self.messages.put(("log", line))
+            return_code = process.wait()
+            if return_code != 0:
+                if return_code in {139, -11}:
+                    raise RuntimeError(
+                        "TensorFlow Anaconda ortaminda baslatilamadi (native crash). "
+                        "Anaconda TensorFlow paketini guncelleyin veya uyumlu bir "
+                        "Python yorumlayicisi kullanin."
+                    )
+                recent_output = "\n".join(line for line in output_lines[-12:] if line.strip())
+                details = f"\n\nSon worker çıktısı:\n{recent_output}" if recent_output else ""
+                raise RuntimeError(f"FeatureRank worker stopped with code {return_code}.{details}")
+
+            average = 0.0
+            values: list[float] = []
             summary = self._read_summary(
                 config,
                 mode,
@@ -476,11 +598,31 @@ class FeatureRankGUI:
         elif "metrik" in lower or "metric" in lower or "tamamlandi" in lower:
             self._set_progress("Calculating Results", 95)
 
+    def _animate_progress(self) -> None:
+        """Advance the bar smoothly while the worker is still running.
+
+        Workflow messages move the bar to meaningful stages.  This timer fills
+        the gaps between those messages based on elapsed time, then waits near
+        90% until the worker reports completion instead of pretending to know
+        the exact duration of every dataset.
+        """
+        if not self.progress_running or self.progress_started_at is None:
+            return
+        elapsed = time.perf_counter() - self.progress_started_at
+        time_based_value = min(90.0, 2.0 + elapsed * 1.2)
+        if time_based_value > self.progress_value:
+            self.progress_value = time_based_value
+            self.progress.configure(value=self.progress_value)
+        self.status_var.set(f"The experiment is running. Elapsed time: {elapsed:.0f} s.")
+        self.progress_job = self.root.after(200, self._animate_progress)
+
     def _set_progress(self, stage: str, value: int) -> None:
         self.stage_var.set(stage)
-        self.progress.configure(value=min(value, 99))
+        self.progress_value = max(self.progress_value, float(min(value, 99)))
+        self.progress.configure(value=self.progress_value)
 
     def _completed(self, summary: dict[str, str]) -> None:
+        self._stop_progress_animation()
         for key, value in summary.items():
             self.summary_vars[key].set(value)
         output = summary.get("Output Directory", "N/A")
@@ -493,13 +635,22 @@ class FeatureRankGUI:
         self.start_button.configure(state="normal")
 
     def _failed(self, error: str) -> None:
+        self._stop_progress_animation()
         self.progress.configure(value=0)
+        self.progress_value = 0.0
         self.stage_var.set("Failed")
         self.status_var.set("The experiment could not be completed.")
         self._append_log(f"ERROR: {error}")
         self.start_button.configure(state="normal")
         messagebox.showerror("FeatureRank", error)
 
+    def _stop_progress_animation(self) -> None:
+        self.progress_running = False
+        self.progress_started_at = None
+        if self.progress_job is not None:
+            self.root.after_cancel(self.progress_job)
+            self.progress_job = None
+
     def _clear_log(self) -> None:
         self.log_text.configure(state="normal")
         self.log_text.delete("1.0", tk.END)

{featurerank-0.1.1 → featurerank-0.1.4}/FeatureRank/__init__.py

@@ -11,7 +11,7 @@ import sys
 
 from .GUI import Launch
 
-__version__ = "0.1.1"
+__version__ = "0.1.4"
 
 
 def _run_cli(arguments: list[str] | None = None) -> None: