FeatureRank 0.1.2__tar.gz → 0.1.5__tar.gz

{featurerank-0.1.2 → featurerank-0.1.5}/FeatureRank/GUI.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import os
 from pathlib import Path
 import queue
+import shutil
 import subprocess
 import sys
 import threading
@@ -19,6 +20,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",
@@ -40,9 +42,99 @@ 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 _supported_python(path: Path) -> bool:
+    """Return whether an interpreter can run the TensorFlow worker."""
+    try:
+        result = subprocess.run(
+            [str(path), "-c", "import sys; print(f'{sys.version_info[0]}.{sys.version_info[1]}')"],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    try:
+        major, minor = (int(part) for part in result.stdout.strip().split(".", maxsplit=1))
+    except (ValueError, TypeError):
+        return False
+    return (3, 10) <= (major, minor) < (3, 14)
+
+
+def _discover_compatible_python() -> list[Path]:
+    """Find an installed Python 3.13–3.10 for a Python 3.14 GUI process."""
+    candidates: list[Path] = []
+    versions = ("3.13", "3.12", "3.11", "3.10")
+    if os.name == "nt":
+        launcher = shutil.which("py")
+        if launcher:
+            for version in versions:
+                try:
+                    result = subprocess.run(
+                        [launcher, f"-{version}", "-c", "import sys; print(sys.executable)"],
+                        stdin=subprocess.DEVNULL,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.DEVNULL,
+                        text=True,
+                        timeout=5,
+                        check=False,
+                    )
+                except (OSError, subprocess.TimeoutExpired):
+                    continue
+                executable = result.stdout.strip()
+                if executable:
+                    candidates.append(Path(executable))
+    else:
+        for version in versions:
+            executable = shutil.which(f"python{version}")
+            if executable:
+                candidates.append(Path(executable))
+    return candidates
+
+
+def _worker_python() -> Path | None:
+    """Find a compatible interpreter before falling back to the current 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),
+    ]
+    if sys.version_info >= (3, 14):
+        candidates.extend(_discover_compatible_python())
+    for candidate in candidates:
+        if candidate.is_file() and _supported_python(candidate):
+            return candidate
+    return None
 
 
 def _open_folder(path: Path) -> None:
@@ -79,16 +171,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"])
@@ -121,16 +224,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(
@@ -139,53 +282,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(
@@ -196,14 +341,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)
@@ -212,7 +357,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",
@@ -226,19 +371,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(
@@ -246,14 +391,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
@@ -273,10 +424,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,
@@ -284,12 +438,14 @@ 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()
+        output_lines: list[str] = []
         try:
             # Keep TensorFlow out of the Tk process.  On macOS, loading a model
             # from a GUI thread can terminate the native Python process.  The
@@ -297,8 +453,9 @@ class FeatureRankGUI:
             # stdout is streamed back into this window.
             from src.Config import ExperimentConfig
 
+            dataset_path = _resolve_dataset_path(dataset)
             config = ExperimentConfig(
-                dataset_name=dataset,
+                dataset_name=dataset_path,
                 task=task,
                 feature_percent=percent,
                 random_state=42,
@@ -308,15 +465,19 @@ class FeatureRankGUI:
                 cluster_k=None,
                 save_details=False,
             )
-            python_executable = Path(sys.executable).with_name("python")
-            if not python_executable.exists():
-                python_executable = Path(sys.executable)
+            python_executable = _worker_python()
+            if python_executable is None:
+                raise RuntimeError(
+                    "Python 3.14 GUI acildi, ancak TensorFlow worker'i icin Python 3.13, "
+                    "3.12, 3.11 veya 3.10 bulunamadi. FeatureRank'i calistirmak icin "
+                    "desteklenen bir Python surumu kurun."
+                )
             command = [
                 str(python_executable),
                 "-m",
                 "scripts.FeatureRank",
                 "--dataset-name",
-                dataset,
+                dataset_path,
                 "--task",
                 task,
                 "--feature-percent",
@@ -328,9 +489,18 @@ class FeatureRankGUI:
             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,
@@ -338,6 +508,7 @@ class FeatureRankGUI:
             )
             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:
@@ -347,7 +518,9 @@ class FeatureRankGUI:
                         "Anaconda TensorFlow paketini guncelleyin veya uyumlu bir "
                         "Python yorumlayicisi kullanin."
                     )
-                raise RuntimeError(f"FeatureRank worker stopped with code {return_code}.")
+                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] = []
@@ -489,11 +662,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")
@@ -506,13 +699,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.2 → featurerank-0.1.5}/FeatureRank/__init__.py

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