dtu-env 0.1.0__tar.gz

dtu_env-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,36 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+      - name: Install build dependencies
+        run: pip install build
+      - name: Build sdist and wheel
+        run: python -m build
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0

dtu_env-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+dist/
+*.egg-info/
+__pycache__/
+*.pyc
+build/

dtu_env-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, DTU Python Support
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

dtu_env-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: dtu-env
+Version: 0.1.0
+Summary: DTU course environment manager — install and manage conda environments for DTU courses
+Project-URL: Homepage, https://pythonsupport.dtu.dk
+Project-URL: Repository, https://github.com/philipnickel/dtu-env
+Project-URL: Bug Tracker, https://github.com/philipnickel/dtu-env/issues
+Author-email: DTU Python Support <pythonsupport@dtu.dk>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: System :: Installation/Setup
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.80.0
+Description-Content-Type: text/markdown
+
+# dtu-env
+
+DTU course environment manager. Interactive TUI to browse and install conda environments for DTU courses.
+
+## Usage
+
+```bash
+dtu-env
+```
+
+This launches an interactive terminal interface where you can:
+
+1. See your currently installed conda environments
+2. Browse available DTU course environments (fetched from GitHub)
+3. Filter/search by course number, name, or semester
+4. Multi-select environments and install them
+
+## Install
+
+```bash
+pip install dtu-env
+```
+
+Or with conda (once available on conda-forge):
+
+```bash
+conda install dtu-env
+```
+
+## How it works
+
+Course environment definitions (YAML files) are maintained in the
+[dtudk/pythonsupport-page](https://github.com/dtudk/pythonsupport-page) repository.
+`dtu-env` fetches these at runtime and uses `mamba`/`conda` to create the environments.

dtu_env-0.1.0/README.md

@@ -0,0 +1,34 @@
+# dtu-env
+
+DTU course environment manager. Interactive TUI to browse and install conda environments for DTU courses.
+
+## Usage
+
+```bash
+dtu-env
+```
+
+This launches an interactive terminal interface where you can:
+
+1. See your currently installed conda environments
+2. Browse available DTU course environments (fetched from GitHub)
+3. Filter/search by course number, name, or semester
+4. Multi-select environments and install them
+
+## Install
+
+```bash
+pip install dtu-env
+```
+
+Or with conda (once available on conda-forge):
+
+```bash
+conda install dtu-env
+```
+
+## How it works
+
+Course environment definitions (YAML files) are maintained in the
+[dtudk/pythonsupport-page](https://github.com/dtudk/pythonsupport-page) repository.
+`dtu-env` fetches these at runtime and uses `mamba`/`conda` to create the environments.

dtu_env-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dtu-env"
+version = "0.1.0"
+description = "DTU course environment manager — install and manage conda environments for DTU courses"
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">=3.10"
+authors = [
+    { name = "DTU Python Support", email = "pythonsupport@dtu.dk" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Education",
+    "Topic :: System :: Installation/Setup",
+]
+dependencies = [
+    "textual>=0.80.0",
+    "rich>=13.0",
+    "pyyaml>=6.0",
+    "requests>=2.28.0",
+]
+
+[project.scripts]
+dtu-env = "dtu_env.cli:main"
+
+[project.urls]
+Homepage = "https://pythonsupport.dtu.dk"
+Repository = "https://github.com/philipnickel/dtu-env"
+"Bug Tracker" = "https://github.com/philipnickel/dtu-env/issues"

dtu_env-0.1.0/recipe.yaml

@@ -0,0 +1,48 @@
+context:
+  version: "0.1.0"
+
+package:
+  name: dtu-env
+  version: ${{ version }}
+
+source:
+  url: https://pypi.org/packages/source/d/dtu-env/dtu_env-${{ version }}.tar.gz
+  sha256: PLACEHOLDER
+
+build:
+  noarch: python
+  script: python -m pip install . -vv --no-deps --no-build-isolation
+  python:
+    entry_points:
+      - dtu-env = dtu_env.cli:main
+
+requirements:
+  host:
+    - python >=3.10
+    - pip
+    - hatchling
+  run:
+    - python >=3.10
+    - textual >=0.80.0
+    - rich >=13.0
+    - pyyaml >=6.0
+    - requests >=2.28.0
+
+tests:
+  - python:
+      imports:
+        - dtu_env
+        - dtu_env.cli
+        - dtu_env.api
+        - dtu_env.tui
+      pip_check: true
+
+about:
+  homepage: https://pythonsupport.dtu.dk
+  license: BSD-3-Clause
+  license_file: LICENSE
+  summary: DTU course environment manager
+  description: |
+    Interactive TUI tool for browsing and installing course-specific
+    conda environments for DTU (Technical University of Denmark) courses.
+  repository: https://github.com/philipnickel/dtu-env

dtu_env-0.1.0/src/dtu_env/__init__.py

@@ -0,0 +1,3 @@
+"""dtu-env: DTU course environment manager."""
+
+__version__ = "0.1.0"

dtu_env-0.1.0/src/dtu_env/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as `python -m dtu_env`."""
+
+from dtu_env.cli import main
+
+if __name__ == "__main__":
+    main()

dtu_env-0.1.0/src/dtu_env/api.py

@@ -0,0 +1,65 @@
+"""Fetch course environment data from GitHub."""
+
+from __future__ import annotations
+
+import os
+
+import requests
+import yaml
+
+from dtu_env.config import GITHUB_API_URL, GITHUB_RAW_URL
+from dtu_env.models import CourseEnvironment
+
+
+def _api_headers() -> dict[str, str]:
+    """build headers for GitHub API requests, using token if available"""
+    headers = {"Accept": "application/vnd.github.v3+json"}
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"token {token}"
+    return headers
+
+
+def fetch_environment_list() -> list[str]:
+    """fetch the list of .yml filenames from the GitHub environments directory"""
+    response = requests.get(GITHUB_API_URL, headers=_api_headers(), timeout=15)
+    response.raise_for_status()
+    entries = response.json()
+    return sorted(
+        entry["name"]
+        for entry in entries
+        if isinstance(entry, dict) and entry.get("name", "").endswith(".yml")
+    )
+
+
+def fetch_environment_yaml(filename: str) -> dict:
+    """fetch and parse a single environment YAML file via raw.githubusercontent.com"""
+    url = f"{GITHUB_RAW_URL}/{filename}"
+    response = requests.get(url, timeout=15)
+    response.raise_for_status()
+    return yaml.safe_load(response.text)
+
+
+def parse_environment(data: dict, filename: str) -> CourseEnvironment:
+    """parse a YAML dict into a CourseEnvironment"""
+    meta = data.get("metadata", {})
+    return CourseEnvironment(
+        name=str(data.get("name", filename.removesuffix(".yml"))),
+        course_number=meta.get("course_number", ""),
+        course_full_name=meta.get("course_full_name", ""),
+        course_year=meta.get("course_year", ""),
+        course_semester=meta.get("course_semester", ""),
+        channels=data.get("channels", []),
+        dependencies=data.get("dependencies", []),
+        filename=filename,
+    )
+
+
+def fetch_all_environments() -> list[CourseEnvironment]:
+    """fetch and parse all available course environments"""
+    filenames = fetch_environment_list()
+    environments = []
+    for filename in filenames:
+        data = fetch_environment_yaml(filename)
+        environments.append(parse_environment(data, filename))
+    return environments

dtu_env-0.1.0/src/dtu_env/cli.py

@@ -0,0 +1,34 @@
+"""CLI entry point for dtu-env."""
+
+from __future__ import annotations
+
+import sys
+
+from dtu_env import __version__
+
+
+def main() -> int:
+    # Only handle --version / --help, everything else is the TUI
+    if len(sys.argv) > 1 and sys.argv[1] in ("-V", "--version"):
+        print(f"dtu-env {__version__}")
+        return 0
+    if len(sys.argv) > 1 and sys.argv[1] in ("-h", "--help"):
+        print("dtu-env — DTU Course Environment Manager")
+        print()
+        print("Usage: dtu-env")
+        print()
+        print("Launches an interactive browser to view installed")
+        print("environments and install new course environments.")
+        print()
+        print("Options:")
+        print("  -V, --version  Show version and exit")
+        print("  -h, --help     Show this help and exit")
+        return 0
+
+    from dtu_env.tui import run_tui
+    run_tui()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dtu_env-0.1.0/src/dtu_env/config.py

@@ -0,0 +1,17 @@
+"""Configuration constants for dtu-env."""
+
+# GitHub repository serving course environment YAML files
+GITHUB_USER = "dtudk"
+GITHUB_REPO = "pythonsupport-page"
+GITHUB_BRANCH = "main"
+GITHUB_ENV_DIR = "docs/_static/environments"
+
+# Constructed URLs
+GITHUB_API_URL = (
+    f"https://api.github.com/repos/{GITHUB_USER}/{GITHUB_REPO}"
+    f"/contents/{GITHUB_ENV_DIR}?ref={GITHUB_BRANCH}"
+)
+GITHUB_RAW_URL = (
+    f"https://raw.githubusercontent.com/{GITHUB_USER}/{GITHUB_REPO}"
+    f"/{GITHUB_BRANCH}/{GITHUB_ENV_DIR}"
+)

dtu_env-0.1.0/src/dtu_env/installer.py

@@ -0,0 +1,67 @@
+"""Install conda environments for DTU courses."""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+from rich.console import Console
+
+from dtu_env.config import GITHUB_RAW_URL
+from dtu_env.models import CourseEnvironment
+from dtu_env.utils import find_conda_executable
+
+console = Console()
+
+
+def install_environment(env: CourseEnvironment) -> bool:
+    """install a course environment using mamba/conda"""
+    exe = find_conda_executable()
+    if not exe:
+        console.print(
+            "[red]Error:[/red] No conda or mamba executable found. "
+            "Is Miniforge3 installed and on your PATH?"
+        )
+        return False
+
+    exe_name = Path(exe).stem
+    url = f"{GITHUB_RAW_URL}/{env.filename}"
+
+    console.print(f"\nInstalling [bold cyan]{env.name}[/bold cyan] "
+                  f"({env.course_full_name})...")
+    console.print(f"Using: [dim]{exe_name}[/dim]")
+    console.print(f"Source: [dim]{url}[/dim]\n")
+
+    # Download the YAML to a temp file so conda can read it
+    import requests
+    response = requests.get(url, timeout=15)
+    response.raise_for_status()
+
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".yml", delete=False, prefix=f"dtu-env-{env.name}-"
+    ) as f:
+        f.write(response.text)
+        tmp_path = f.name
+
+    try:
+        cmd = [exe, "env", "create", "-f", tmp_path, "--yes"]
+        console.print(f"Running: [dim]{' '.join(cmd)}[/dim]\n")
+
+        result = subprocess.run(
+            cmd,
+            text=True,
+            check=False,
+        )
+
+        if result.returncode == 0:
+            console.print(
+                f"\n[green]Success![/green] Environment [bold]{env.name}[/bold] installed."
+            )
+            console.print(f"Activate it with: [bold cyan]conda activate {env.name}[/bold cyan]")
+            return True
+        else:
+            console.print(f"\n[red]Error:[/red] Environment creation failed (exit code {result.returncode}).")
+            return False
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)

dtu_env-0.1.0/src/dtu_env/models.py

@@ -0,0 +1,29 @@
+"""Data models for course environments."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CourseEnvironment:
+    """a single course environment parsed from a YAML file"""
+
+    name: str
+    course_number: str
+    course_full_name: str
+    course_year: str
+    course_semester: str
+    channels: list[str] = field(default_factory=list)
+    dependencies: list[str] = field(default_factory=list)
+    filename: str = ""
+
+    @property
+    def display_name(self) -> str:
+        """human-readable display string"""
+        return f"{self.course_number} - {self.course_full_name} ({self.course_semester} {self.course_year})"
+
+    @property
+    def short_label(self) -> str:
+        """short label for menus"""
+        return f"[bold]{self.name}[/bold]  {self.course_full_name}"

dtu_env-0.1.0/src/dtu_env/tui.py

@@ -0,0 +1,355 @@
+"""Textual TUI for interactive course environment management."""
+
+from __future__ import annotations
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import (
+    Button,
+    Checkbox,
+    Footer,
+    Header,
+    Input,
+    Label,
+    ListItem,
+    ListView,
+    Static,
+)
+
+from dtu_env.api import fetch_all_environments
+from dtu_env.installer import install_environment
+from dtu_env.models import CourseEnvironment
+from dtu_env.utils import get_installed_environments
+
+
+# ---------------------------------------------------------------------------
+# Home screen — shows installed environments
+# ---------------------------------------------------------------------------
+
+class HomeScreen(Screen):
+    """main screen showing installed environments"""
+
+    CSS = """
+    #home-content {
+        padding: 1 2;
+    }
+    #installed-title {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    #installed-list {
+        height: 1fr;
+        margin-bottom: 1;
+    }
+    #install-btn {
+        margin-top: 1;
+    }
+    .env-item {
+        padding: 0 1;
+    }
+    #home-status {
+        dock: bottom;
+        height: 1;
+        background: $accent;
+        color: $text;
+        padding: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("i", "install_new", "Install new"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("q", "quit_app", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with VerticalScroll(id="home-content"):
+            yield Label("Installed Conda Environments", id="installed-title")
+            yield ListView(id="installed-list")
+            yield Button("Install course environments", id="install-btn", variant="primary")
+        yield Static("[dim]i Install new | r Refresh | q Quit[/dim]", id="home-status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.refresh_installed()
+
+    @work(thread=True)
+    def refresh_installed(self) -> None:
+        self.app.call_from_thread(
+            self.query_one("#home-status", Static).update,
+            "Loading installed environments...",
+        )
+        installed = get_installed_environments()
+        self.app.call_from_thread(self._populate_installed, installed)
+
+    def _populate_installed(self, envs: list[str]) -> None:
+        lv = self.query_one("#installed-list", ListView)
+        lv.clear()
+        if not envs:
+            lv.append(ListItem(Label("[dim]No environments found[/dim]")))
+        else:
+            for name in envs:
+                lv.append(ListItem(Label(f"  {name}", classes="env-item")))
+        self.query_one("#home-status", Static).update(
+            f"[dim]{len(envs)} environments installed | i Install new | r Refresh | q Quit[/dim]"
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "install-btn":
+            self.app.push_screen(InstallScreen())
+
+    def action_install_new(self) -> None:
+        self.app.push_screen(InstallScreen())
+
+    def action_refresh(self) -> None:
+        self.refresh_installed()
+
+    def action_quit_app(self) -> None:
+        self.app.exit()
+
+
+# ---------------------------------------------------------------------------
+# Install screen — fetch available envs, multi-select, install
+# ---------------------------------------------------------------------------
+
+class EnvCheckbox(Horizontal):
+    """a checkbox row for a course environment"""
+
+    DEFAULT_CSS = """
+    EnvCheckbox {
+        height: 1;
+        padding: 0 1;
+    }
+    EnvCheckbox .env-name {
+        width: 16;
+        text-style: bold;
+        color: $text;
+    }
+    EnvCheckbox .env-course {
+        width: 1fr;
+    }
+    EnvCheckbox .env-semester {
+        width: 20;
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, env: CourseEnvironment) -> None:
+        super().__init__()
+        self.env = env
+
+    def compose(self) -> ComposeResult:
+        yield Checkbox(self.env.name, value=False)
+        yield Label(self.env.course_full_name, classes="env-course")
+        yield Label(
+            f"{self.env.course_semester} {self.env.course_year}",
+            classes="env-semester",
+        )
+
+
+class InstallScreen(Screen):
+    """screen for browsing and installing course environments"""
+
+    CSS = """
+    #install-content {
+        padding: 1 2;
+    }
+    #install-title {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    #search {
+        margin-bottom: 1;
+    }
+    #env-scroll {
+        height: 1fr;
+        margin-bottom: 1;
+    }
+    #btn-bar {
+        height: 3;
+        align-horizontal: left;
+    }
+    #btn-bar Button {
+        margin-right: 1;
+    }
+    #install-status {
+        dock: bottom;
+        height: 1;
+        background: $accent;
+        color: $text;
+        padding: 0 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "go_back", "Back"),
+        Binding("a", "select_all", "Select all"),
+        Binding("n", "select_none", "Select none"),
+    ]
+
+    environments: list[CourseEnvironment] = []
+    installed_names: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(id="install-content"):
+            yield Label("Install Course Environments", id="install-title")
+            yield Input(
+                placeholder="Filter by course number, name, or semester...",
+                id="search",
+            )
+            yield VerticalScroll(id="env-scroll")
+            with Horizontal(id="btn-bar"):
+                yield Button("Install selected", id="do-install", variant="primary")
+                yield Button("Back", id="go-back", variant="default")
+        yield Static("[dim]Loading...[/dim]", id="install-status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.fetch_environments()
+
+    @work(thread=True)
+    def fetch_environments(self) -> None:
+        self.app.call_from_thread(
+            self.query_one("#install-status", Static).update,
+            "Fetching available environments from GitHub...",
+        )
+        try:
+            envs = fetch_all_environments()
+            installed = get_installed_environments()
+            self.app.call_from_thread(self._populate, envs, set(installed))
+        except Exception as e:
+            self.app.call_from_thread(
+                self.query_one("#install-status", Static).update,
+                f"[red]Error: {e}[/red]",
+            )
+
+    def _populate(self, envs: list[CourseEnvironment], installed: set[str]) -> None:
+        self.environments = envs
+        self.installed_names = installed
+        self._render_list(envs)
+        self.query_one("#install-status", Static).update(
+            f"[dim]{len(envs)} available | a Select all | n None | Esc Back[/dim]"
+        )
+
+    def _render_list(self, envs: list[CourseEnvironment]) -> None:
+        scroll = self.query_one("#env-scroll", VerticalScroll)
+        scroll.remove_children()
+        for env in envs:
+            row = EnvCheckbox(env)
+            scroll.mount(row)
+            # Pre-check if already installed
+            if env.name in self.installed_names:
+                cb = row.query_one(Checkbox)
+                cb.value = True
+                cb.disabled = True
+                cb.label = f"{env.name} [dim](installed)[/dim]"
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        query = event.value.strip().lower()
+        if not query:
+            filtered = self.environments
+        else:
+            filtered = [
+                env for env in self.environments
+                if query in env.name.lower()
+                or query in env.course_number.lower()
+                or query in env.course_full_name.lower()
+                or query in env.course_semester.lower()
+                or query in env.course_year.lower()
+            ]
+        self._render_list(filtered)
+
+    def _get_selected_envs(self) -> list[CourseEnvironment]:
+        selected = []
+        for row in self.query(EnvCheckbox):
+            cb = row.query_one(Checkbox)
+            if cb.value and not cb.disabled:
+                selected.append(row.env)
+        return selected
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "do-install":
+            self._install_selected()
+        elif event.button.id == "go-back":
+            self.app.pop_screen()
+
+    def _install_selected(self) -> None:
+        selected = self._get_selected_envs()
+        if not selected:
+            self.query_one("#install-status", Static).update(
+                "[yellow]No environments selected[/yellow]"
+            )
+            return
+        self._do_install(selected)
+
+    @work(thread=True)
+    def _do_install(self, envs: list[CourseEnvironment]) -> None:
+        total = len(envs)
+        succeeded = 0
+        failed = 0
+
+        for i, env in enumerate(envs, 1):
+            self.app.call_from_thread(
+                self.query_one("#install-status", Static).update,
+                f"[yellow]Installing {env.name} ({i}/{total})...[/yellow]",
+            )
+
+            with self.app.suspend():
+                success = install_environment(env)
+
+            if success:
+                succeeded += 1
+                self.app.call_from_thread(self.installed_names.add, env.name)
+            else:
+                failed += 1
+
+        # Refresh the checkboxes to show newly installed
+        self.app.call_from_thread(self._render_list, self.environments)
+
+        summary = f"[green]{succeeded} installed[/green]"
+        if failed:
+            summary += f", [red]{failed} failed[/red]"
+        self.app.call_from_thread(
+            self.query_one("#install-status", Static).update,
+            f"Done: {summary} | Esc to go back",
+        )
+
+    def action_go_back(self) -> None:
+        self.app.pop_screen()
+
+    def action_select_all(self) -> None:
+        for row in self.query(EnvCheckbox):
+            cb = row.query_one(Checkbox)
+            if not cb.disabled:
+                cb.value = True
+
+    def action_select_none(self) -> None:
+        for row in self.query(EnvCheckbox):
+            cb = row.query_one(Checkbox)
+            if not cb.disabled:
+                cb.value = False
+
+
+# ---------------------------------------------------------------------------
+# Main app
+# ---------------------------------------------------------------------------
+
+class DtuEnvApp(App):
+    """DTU course environment manager"""
+
+    TITLE = "DTU Course Environments"
+    SUB_TITLE = "dtu-env"
+
+    def on_mount(self) -> None:
+        self.push_screen(HomeScreen())
+
+
+def run_tui() -> None:
+    """launch the interactive TUI"""
+    app = DtuEnvApp()
+    app.run()

dtu_env-0.1.0/src/dtu_env/utils.py

@@ -0,0 +1,37 @@
+"""Utility helpers for dtu-env."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+
+def find_conda_executable() -> str | None:
+    """find mamba or conda executable, preferring mamba"""
+    for name in ("mamba", "conda"):
+        path = shutil.which(name)
+        if path:
+            return path
+    return None
+
+
+def get_installed_environments() -> list[str]:
+    """return list of installed conda environment names"""
+    exe = find_conda_executable()
+    if not exe:
+        return []
+    result = subprocess.run(
+        [exe, "env", "list", "--json"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return []
+    import json
+    data = json.loads(result.stdout)
+    envs = []
+    for env_path in data.get("envs", []):
+        name = env_path.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+        envs.append(name)
+    return envs