app.py

#!/usr/bin/env python3
"""RAMBar - Live RAM usage in the macOS menu bar."""

import os
import sys
import plistlib
import subprocess
import psutil
import rumps

LABEL = "com.rambar.menubar"
PLIST_PATH = os.path.expanduser(f"~/Library/LaunchAgents/{LABEL}.plist")
REFRESH_OPTIONS = [1, 3, 5, 10, 30]
DEFAULT_REFRESH = 5


class RAMBarApp(rumps.App):
    def __init__(self):
        super().__init__("RAMBar", quit_button=None)

        self._display_used = True
        self._refresh_interval = DEFAULT_REFRESH

        self._build_menu()

        self._timer = rumps.Timer(self._refresh, self._refresh_interval)
        self._timer.start()
        self._refresh(None)

    # ------------------------------------------------------------------ menu

    def _build_menu(self):
        # Display mode
        self._mode_used = rumps.MenuItem("Used RAM", callback=self._set_used)
        self._mode_avail = rumps.MenuItem("Available RAM", callback=self._set_available)
        self._mode_used.state = 1

        display_menu = rumps.MenuItem("Display")
        display_menu.add(self._mode_used)
        display_menu.add(self._mode_avail)

        # Refresh rate
        self._refresh_items: dict[int, rumps.MenuItem] = {}
        refresh_menu = rumps.MenuItem("Refresh Rate")
        for s in REFRESH_OPTIONS:
            label = f"Every {s} second{'s' if s != 1 else ''}"
            item = rumps.MenuItem(label, callback=self._set_refresh)
            item._seconds = s
            self._refresh_items[s] = item
            refresh_menu.add(item)
        self._refresh_items[DEFAULT_REFRESH].state = 1

        # Launch at login
        self._login_item = rumps.MenuItem("Launch at Login", callback=self._toggle_login)
        self._login_item.state = int(self._login_enabled())

        self.menu = [
            display_menu,
            None,
            refresh_menu,
            None,
            self._login_item,
            None,
            rumps.MenuItem("Quit RAMBar", callback=rumps.quit_application),
        ]

    # --------------------------------------------------------------- refresh

    def _refresh(self, _):
        mem = psutil.virtual_memory()
        if self._display_used:
            gb = mem.used / 1024 ** 3
            self.title = f"{gb:.1f}G used"
        else:
            gb = mem.available / 1024 ** 3
            self.title = f"{gb:.1f}G free"

    # --------------------------------------------------------- display mode

    def _set_used(self, _):
        self._display_used = True
        self._mode_used.state = 1
        self._mode_avail.state = 0
        self._refresh(None)

    def _set_available(self, _):
        self._display_used = False
        self._mode_used.state = 0
        self._mode_avail.state = 1
        self._refresh(None)

    # --------------------------------------------------------- refresh rate

    def _set_refresh(self, sender):
        self._refresh_interval = sender._seconds
        for item in self._refresh_items.values():
            item.state = 0
        sender.state = 1
        self._timer.stop()
        self._timer = rumps.Timer(self._refresh, self._refresh_interval)
        self._timer.start()

    # --------------------------------------------------------- login item

    def _login_enabled(self) -> bool:
        return os.path.isfile(PLIST_PATH)

    def _get_program_arguments(self) -> list[str]:
        """Return the ProgramArguments list suitable for a LaunchAgent plist."""
        # RESOURCEPATH is set by py2app when running inside a .app bundle
        resource_path = os.environ.get("RESOURCEPATH", "")
        if resource_path and ".app/Contents" in resource_path:
            idx = resource_path.index(".app/Contents")
            app_bundle = resource_path[:idx + 4]          # e.g. /Applications/RAMBar.app
            app_name = os.path.splitext(os.path.basename(app_bundle))[0]
            executable = os.path.join(app_bundle, "Contents", "MacOS", app_name)
            return [executable]
        # Running as plain script
        return [sys.executable, os.path.abspath(__file__)]

    def _toggle_login(self, _):
        if self._login_enabled():
            self._disable_login()
            self._login_item.state = 0
        else:
            self._enable_login()
            self._login_item.state = 1

    def _enable_login(self):
        plist = {
            "Label": LABEL,
            "ProgramArguments": self._get_program_arguments(),
            "RunAtLoad": True,
            "KeepAlive": False,
        }
        os.makedirs(os.path.dirname(PLIST_PATH), exist_ok=True)
        with open(PLIST_PATH, "wb") as f:
            plistlib.dump(plist, f)
        subprocess.run(["launchctl", "load", PLIST_PATH], check=False)

    def _disable_login(self):
        if os.path.isfile(PLIST_PATH):
            subprocess.run(["launchctl", "unload", PLIST_PATH], check=False)
            os.remove(PLIST_PATH)


if __name__ == "__main__":
    RAMBarApp().run()