FeatureRank 0.1.0__tar.gz → 0.1.1__tar.gz

featurerank-0.1.1/FeatureRank/GUI.py

@@ -0,0 +1,576 @@
+"""Small desktop interface for the existing FeatureRank workflows.
+
+The window only collects user choices.  Global and Divide & Combine work is
+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
+import subprocess
+import sys
+import threading
+import time
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+
+
+PERCENT_VALUES = tuple(str(value) for value in range(10, 101, 10))
+BLOCK_VALUES = ("5", "10", "20")
+MODE_LABELS = {
+    "GL": "GL — Global Feature Ranking",
+    "DC": "DC — Divide & Combine Feature Ranking",
+}
+TASK_LABELS = {
+    "Classification": "classification",
+    "Regression": "regression",
+    "Clustering": "clustering",
+}
+_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
+    directories = (Path.cwd() / "data" / "raw", project_root / "data" / "raw")
+    choices: list[str] = []
+    for directory in directories:
+        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"]
+
+
+def _open_folder(path: Path) -> None:
+    """Open a result directory using the current operating system."""
+    path.mkdir(parents=True, exist_ok=True)
+    if sys.platform == "darwin":
+        subprocess.Popen(["open", str(path)])
+    elif os.name == "nt":
+        os.startfile(str(path))  # type: ignore[attr-defined]
+    else:
+        subprocess.Popen(["xdg-open", str(path)])
+
+
+def _tk_window_is_safe() -> bool:
+    """Check Tk in a child process so a native Tk crash cannot kill the app."""
+    probe = "import tkinter as tk; " "root = tk.Tk(); " "root.withdraw(); " "root.destroy()"
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", probe],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    return result.returncode == 0
+
+
+class FeatureRankGUI:
+    """Tkinter view and controller for one FeatureRank experiment."""
+
+    def __init__(self, root: tk.Tk) -> None:
+        self.root = root
+        self.root.title("FeatureRank")
+        self.root.geometry("780x720")
+        self.root.minsize(700, 620)
+
+        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.dataset_var = tk.StringVar(value=_dataset_choices()[0])
+        self.percent_var = tk.StringVar(value="20")
+        self.task_var = tk.StringVar(value="Classification")
+        self.mode_var = tk.StringVar(value=MODE_LABELS["GL"])
+        self.block_var = tk.StringVar(value="10")
+        self.stage_var = tk.StringVar(value="Ready")
+        self.status_var = tk.StringVar(value="Select a dataset and start an experiment.")
+        self.summary_vars = {
+            key: tk.StringVar(value="N/A")
+            for key in (
+                "Dataset",
+                "Mode",
+                "Feature Percentage",
+                "Block Count",
+                "Original Feature Count",
+                "Selected Feature Count",
+                "Accuracy",
+                "RMSE",
+                "Cluster RMSE",
+                "Execution Time",
+                "Output Directory",
+            )
+        }
+
+        self._configure_style()
+        self._build_window()
+
+    def _configure_style(self) -> None:
+        style = ttk.Style(self.root)
+        try:
+            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))
+
+    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.grid(row=0, column=0, sticky="ew")
+        ttk.Label(header, text="FeatureRank", style="Title.TLabel").pack(anchor="w")
+        ttk.Label(
+            header,
+            text="Autoencoder-based feature ranking and selection",
+            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.columnconfigure(1, weight=1)
+
+        ttk.Label(options, text="Dataset").grid(row=0, column=0, sticky="w", pady=7)
+        self.dataset_combo = ttk.Combobox(
+            options, textvariable=self.dataset_var, values=_dataset_choices(), state="readonly"
+        )
+        self.dataset_combo.grid(row=0, column=1, sticky="ew", padx=(14, 8), pady=7)
+        ttk.Button(options, text="Browse…", command=self._browse_dataset).grid(
+            row=0, column=2, pady=7
+        )
+
+        ttk.Label(options, text="Task").grid(row=1, column=0, sticky="w", pady=7)
+        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)
+
+        ttk.Label(options, text="Feature Percent").grid(row=2, column=0, sticky="w", pady=7)
+        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)
+
+        ttk.Label(options, text="Mode").grid(row=3, column=0, sticky="w", pady=7)
+        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.bind("<<ComboboxSelected>>", self._mode_changed)
+
+        ttk.Label(options, text="Block Count").grid(row=4, column=0, sticky="w", pady=7)
+        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)
+
+        action_row = ttk.Frame(self.root, padding=(28, 8, 28, 8))
+        action_row.grid(row=2, column=0, sticky="ew")
+        action_row.columnconfigure(1, weight=1)
+        self.start_button = ttk.Button(
+            action_row, text="START", style="Run.TButton", command=self._start
+        )
+        self.start_button.grid(row=0, column=0, sticky="w")
+        ttk.Label(action_row, textvariable=self.stage_var, style="Stage.TLabel").grid(
+            row=0, column=1, sticky="e", padx=(12, 0)
+        )
+
+        progress_frame = ttk.Frame(self.root, padding=(28, 0, 28, 12))
+        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)
+        )
+
+        log_frame = ttk.LabelFrame(progress_frame, text="Log / Output", padding=8)
+        log_frame.grid(row=2, column=0, sticky="nsew")
+        log_frame.columnconfigure(0, weight=1)
+        log_frame.rowconfigure(0, weight=1)
+        self.log_text = tk.Text(
+            log_frame,
+            height=13,
+            wrap="word",
+            state="disabled",
+            background="#f8fafc",
+            foreground="#1f2937",
+            relief="flat",
+            padx=8,
+            pady=8,
+        )
+        self.log_text.grid(row=0, column=0, sticky="nsew")
+        scrollbar = ttk.Scrollbar(log_frame, orient="vertical", command=self.log_text.yview)
+        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.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
+            )
+
+        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")
+
+    def _browse_dataset(self) -> None:
+        selected = filedialog.askopenfilename(
+            title="Select dataset",
+            filetypes=[("CSV files", "*.csv"), ("Text files", "*.txt"), ("All files", "*.*")],
+        )
+        if selected:
+            self.dataset_var.set(selected)
+
+    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()
+        if not dataset:
+            messagebox.showerror("FeatureRank", "Please select a dataset.")
+            return
+        try:
+            percent = float(self.percent_var.get())
+            if not 0 < percent <= 100:
+                raise ValueError
+        except ValueError:
+            messagebox.showerror("FeatureRank", "Feature Percent must be between 10 and 100.")
+            return
+
+        mode = "dc" if self.mode_var.get().startswith("DC") else "global"
+        task = TASK_LABELS[self.task_var.get()]
+        block_count = int(self.block_var.get()) if mode == "dc" else 10
+        self.block_count = block_count
+        self.blocks_seen = 0
+        self.last_output_dir = None
+        self.open_button.configure(state="disabled")
+        self.start_button.configure(state="disabled")
+        self.progress.configure(value=2)
+        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.worker = threading.Thread(
+            target=self._run_experiment,
+            args=(dataset, percent, task, mode, block_count),
+            daemon=True,
+        )
+        self.worker.start()
+        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)
+        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
+            from src.Config import ExperimentConfig
+            from src.OutputPaths import metric_runs_path
+
+            config = ExperimentConfig(
+                dataset_name=dataset,
+                task=task,
+                feature_percent=percent,
+                random_state=42,
+                encoding_dim=8,
+                target_column="target",
+                id_column="ID",
+                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,
+                )
+            summary = self._read_summary(
+                config,
+                mode,
+                block_count,
+                average,
+                values,
+                time.perf_counter() - started_at,
+            )
+            self.messages.put(("done", summary))
+        except Exception as error:  # show a useful GUI message instead of a traceback window
+            self.messages.put(("error", str(error)))
+
+    def _read_summary(
+        self,
+        config: object,
+        mode: str,
+        block_count: int,
+        average: float,
+        values: list[float],
+        elapsed: float,
+    ) -> dict[str, str]:
+        import json
+
+        from src.OutputPaths import format_feature_percent_tag, task_output_dir
+
+        dataset_name = str(config.dataset_name)
+        task = str(config.task)
+        tag = format_feature_percent_tag(float(config.feature_percent))
+        folder = Path(dataset_name).stem
+        if mode == "dc":
+            from scripts.FeatureBlockDatasetTools import dataset_base_name
+
+            folder = f"{dataset_base_name(dataset_name)}_selected_features_combined_data"
+        metrics_dir = task_output_dir(task, folder) / "metrics"
+        metric_filename = (
+            f"top_{tag}_cluster_metrics.json"
+            if task == "clustering"
+            else f"top_{tag}_test_metrics.json"
+        )
+        metric_path = metrics_dir / metric_filename
+        if not metric_path.exists():
+            candidates = sorted(
+                (
+                    metrics_dir.parent.parent.rglob(f"top_{tag}*_metrics.json")
+                    if metrics_dir.parent.parent.exists()
+                    else []
+                ),
+                key=lambda item: item.stat().st_mtime,
+            )
+            metric_path = candidates[-1] if candidates else metric_path
+
+        metrics: dict[str, object] = {}
+        if metric_path.exists():
+            metrics = json.loads(metric_path.read_text(encoding="utf-8"))
+        selected_count = metrics.get("selected_feature_count", "N/A")
+        original_count = metrics.get("original_feature_count", "N/A")
+        if original_count == "N/A":
+            original_count = self._count_features(config)
+        accuracy = metrics.get("test_accuracy", average) if task == "classification" else "N/A"
+        rmse = metrics.get("regression_rmse", average) if task == "regression" else "N/A"
+        cluster_rmse = metrics.get("cluster_rmse", average) if task == "clustering" else "N/A"
+
+        return {
+            "Dataset": Path(dataset_name).name,
+            "Mode": "DC" if mode == "dc" else "GL",
+            "Feature Percentage": f"{float(config.feature_percent):g}%",
+            "Block Count": str(block_count) if mode == "dc" else "N/A",
+            "Original Feature Count": str(original_count),
+            "Selected Feature Count": str(selected_count),
+            "Accuracy": f"{float(accuracy):.6f}" if accuracy != "N/A" else "N/A",
+            "RMSE": f"{float(rmse):.6f}" if rmse != "N/A" else "N/A",
+            "Cluster RMSE": (f"{float(cluster_rmse):.6f}" if cluster_rmse != "N/A" else "N/A"),
+            "Execution Time": f"{float(metrics.get('elapsed_seconds', elapsed)):.2f} s",
+            "Output Directory": str(metric_path.parent.parent) if metric_path.exists() else "N/A",
+        }
+
+    @staticmethod
+    def _count_features(config: object) -> str:
+        try:
+            from src.DataLoader import load_data
+
+            frame = load_data(config.dataset_name, target_column=config.target_column)
+            excluded = {config.target_column}
+            if config.id_column:
+                excluded.add(config.id_column)
+            return str(len([column for column in frame.columns if column not in excluded]))
+        except Exception:
+            return "N/A"
+
+    def _poll_messages(self) -> None:
+        while True:
+            try:
+                kind, payload = self.messages.get_nowait()
+            except queue.Empty:
+                break
+            if kind == "log":
+                self._handle_log(str(payload))
+            elif kind == "done":
+                self._completed(payload)  # type: ignore[arg-type]
+            elif kind == "error":
+                self._failed(str(payload))
+
+        if self.worker and self.worker.is_alive():
+            self.root.after(100, self._poll_messages)
+
+    def _handle_log(self, text: str) -> None:
+        for line in text.splitlines():
+            line = line.strip()
+            if not line or self._is_debug_line(line):
+                continue
+            self._append_log(line)
+            self._update_progress(line)
+
+    @staticmethod
+    def _is_debug_line(line: str) -> bool:
+        lower = line.lower()
+        return any(
+            marker in lower
+            for marker in ("onednn", "cuda error", "cudnn", "cublas", "tensorflow/core")
+        )
+
+    def _update_progress(self, line: str) -> None:
+        lower = line.lower()
+        if "veri yukleniyor" in lower or "loading" in lower:
+            self._set_progress("Loading Dataset", 10)
+        elif "[dc] blok" in lower:
+            self.blocks_seen += 1
+            progress = 15 + int(50 * self.blocks_seen / max(self.block_count, 1))
+            self._set_progress(f"Processing Block {self.blocks_seen}/{self.block_count}", progress)
+        elif "autoencoder" in lower or "feature" in lower and "sec" in lower:
+            self._set_progress("Ranking Features", 55)
+        elif "birles" in lower or "combine" in lower:
+            self._set_progress("Combining Features", 75)
+        elif "egitim" in lower or "training" in lower or "classifier" in lower:
+            self._set_progress("Training Model", 85)
+        elif "metrik" in lower or "metric" in lower or "tamamlandi" in lower:
+            self._set_progress("Calculating Results", 95)
+
+    def _set_progress(self, stage: str, value: int) -> None:
+        self.stage_var.set(stage)
+        self.progress.configure(value=min(value, 99))
+
+    def _completed(self, summary: dict[str, str]) -> None:
+        for key, value in summary.items():
+            self.summary_vars[key].set(value)
+        output = summary.get("Output Directory", "N/A")
+        if output != "N/A":
+            self.last_output_dir = Path(output)
+            self.open_button.configure(state="normal")
+        self.progress.configure(value=100)
+        self.stage_var.set("Completed")
+        self.status_var.set("FeatureRank completed successfully.")
+        self.start_button.configure(state="normal")
+
+    def _failed(self, error: str) -> None:
+        self.progress.configure(value=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 _clear_log(self) -> None:
+        self.log_text.configure(state="normal")
+        self.log_text.delete("1.0", tk.END)
+        self.log_text.configure(state="disabled")
+
+    def _append_log(self, line: str) -> None:
+        self.log_text.configure(state="normal")
+        self.log_text.insert(tk.END, line + "\n")
+        self.log_text.see(tk.END)
+        self.log_text.configure(state="disabled")
+
+    def _open_results(self) -> None:
+        if self.last_output_dir is not None:
+            _open_folder(self.last_output_dir)
+
+
+def Launch() -> FeatureRankGUI | None:
+    """Open the FeatureRank desktop application.
+
+    ``None`` is returned in headless environments so importing the package
+    does not crash notebooks, documentation builders, or automated tests.
+    """
+    global _WINDOW_OPENED
+    if _WINDOW_OPENED:
+        return None
+    # Codex and other CI runners may expose Tkinter while lacking a window
+    # server.  Calling ``Tk()`` on macOS in that state can abort the process,
+    # so leave imports safe in those runners.
+    if os.environ.get("CODEX_CI") == "1":
+        return None
+
+    # Anaconda's macOS interpreter can crash inside Cocoa/Tk when a window is
+    # created from an interactive ``python`` process.  ``pythonw`` owns the
+    # application event loop, so launch the GUI there and keep the import
+    # process safe.  The child sets a guard and enters this function directly.
+    if sys.platform == "darwin" and os.environ.get("FEATURERANK_GUI_CHILD") != "1":
+        pythonw = Path(sys.executable).with_name("pythonw")
+        if pythonw.exists() and _tk_window_is_safe():
+            child_environment = os.environ.copy()
+            child_environment["FEATURERANK_NO_AUTO_GUI"] = "1"
+            child_environment["FEATURERANK_GUI_CHILD"] = "1"
+            try:
+                subprocess.Popen(
+                    [
+                        str(pythonw),
+                        "-c",
+                        "from FeatureRank.GUI import Launch; Launch()",
+                    ],
+                    env=child_environment,
+                    start_new_session=True,
+                )
+            except OSError:
+                pass
+            else:
+                _WINDOW_OPENED = True
+                return None
+
+    if sys.platform not in {"darwin", "win32"} and not (
+        os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
+    ):
+        return None
+    if not _tk_window_is_safe():
+        return None
+    try:
+        root = tk.Tk()
+    except tk.TclError:
+        return None
+    _WINDOW_OPENED = True
+    application = FeatureRankGUI(root)
+    root.mainloop()
+    return application
+
+
+__all__ = ["FeatureRankGUI", "Launch"]

featurerank-0.1.1/FeatureRank/__init__.py

@@ -0,0 +1,80 @@
+"""Public Python entry point for the FeatureRank project.
+
+On a normal desktop import the GUI opens automatically. The explicit
+``Launch`` function remains available for applications that want to control
+when the window is shown.
+"""
+
+import os
+from pathlib import Path
+import sys
+
+from .GUI import Launch
+
+__version__ = "0.1.1"
+
+
+def _run_cli(arguments: list[str] | None = None) -> None:
+    """Load the CLI only when a workflow is actually started."""
+    from scripts.FeatureRank import main as run_cli
+
+    run_cli(arguments)
+
+
+def run(
+    dataset_name: str,
+    feature_percent: float,
+    task: str = "classification",
+    mode: str = "global",
+    block_count: int = 10,
+    random_state: int | None = 42,
+) -> None:
+    """Start one FeatureRank experiment from Python code.
+
+    ``dataset_name`` and ``feature_percent`` are the only required values, so
+    a graphical interface can call this function directly. The remaining
+    arguments mirror the small set of choices exposed by the command line.
+    """
+    mode_name = mode.lower().strip()
+    if mode_name not in {"global", "dc"}:
+        raise ValueError("mode 'global' veya 'dc' olmali.")
+
+    arguments = [
+        "--dataset-name",
+        str(dataset_name),
+        "--task",
+        str(task),
+        "--feature-percent",
+        str(feature_percent),
+        "--random-state",
+        "none" if random_state is None else str(random_state),
+    ]
+    arguments.append("--dc" if mode_name == "dc" else "--global")
+    if mode_name == "dc":
+        arguments.extend(["--block-count", str(block_count)])
+
+    _run_cli(arguments)
+
+
+def main() -> None:
+    """Entry point used by the installed ``FeatureRank`` command."""
+    Launch()
+
+
+def _should_auto_launch() -> bool:
+    """Avoid surprise windows in tests and in ``python -m`` startup."""
+    if os.environ.get("FEATURERANK_NO_GUI", "").lower() in {"1", "true", "yes"}:
+        return False
+    if os.environ.get("FEATURERANK_NO_AUTO_GUI", "").lower() in {"1", "true", "yes"}:
+        return False
+    if "pytest" in sys.modules or os.environ.get("PYTEST_CURRENT_TEST"):
+        return False
+    command_name = Path(sys.argv[0]).name if sys.argv else ""
+    return command_name not in {"FeatureRank", "FeatureRank.exe", "__main__.py"}
+
+
+if _should_auto_launch():
+    Launch()
+
+
+__all__ = ["Launch", "main", "run", "__version__"]

featurerank-0.1.1/FeatureRank/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m FeatureRank`` to open the desktop application."""
+
+from . import Launch
+
+
+if __name__ == "__main__":
+    Launch()