simplesuit.sys v0.2.1

def human_size(octets):
    for unit in ["o", "Ko", "Mo", "Go", "To"]:
        if octets < 1024:
            return f"{octets:.1f} {unit}"
        octets /= 1024
    return f"{octets:.1f} Po"

def human_time(seconds):
    hours, rest = divmod(int(seconds), 3600)
    minutes = rest // 60
    if hours:
        return f"{hours}h{minutes:02d}"
    return f"{minutes}min"

def battery():
    bat = psutil.sensors_battery()
    return bat.percent if bat else None

def plugged():
    bat = psutil.sensors_battery()
    return bat.power_plugged if bat else None

def time_left():
    bat = psutil.sensors_battery()
    # secsleft est négatif quand le temps est inconnu ou illimité
    if bat is None or bat.secsleft < 0:
        return None
    return bat.secsleft

def time_left_text():
    seconds = time_left()
    return human_time(seconds) if seconds is not None else None

def cpu():
    return psutil.cpu_percent(interval=0.3)

def cpu_cores():
    return psutil.cpu_count()

def cpu_type():
    return platform.machine()

def ram():
    return psutil.virtual_memory().percent

def ram_used():
    mem = psutil.virtual_memory()
    return human_size(mem.total - mem.available)

def ram_total():
    return human_size(psutil.virtual_memory().total)

def disk(path="/"):
    usage = psutil.disk_usage(path)
    return round((usage.total - usage.free) / usage.total * 100, 1)

def disk_free(path="/"):
    return human_size(psutil.disk_usage(path).free)

def disk_total(path="/"):
    return human_size(psutil.disk_usage(path).total)

def online():
    try:
        socket.create_connection(("1.1.1.1", 53), timeout=2).close()
        return True
    except OSError:
        return False

def local_ip():
    try:
        # Astuce : on "vise" une adresse externe sans rien envoyer, juste pour savoir quelle IP on utilise
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
            s.connect(("1.1.1.1", 80))
            return s.getsockname()[0]
    except OSError:
        return None

def public_ip():
    try:
        with urllib.request.urlopen("https://api.ipify.org", timeout=3) as response:
            return response.read().decode()
    except OSError:
        return None

def wifi_connected():
    return _run(["ipconfig", "getifaddr", "en0"]) != ""

def wifi():
    for line in _run(["ipconfig", "getsummary", "en0"]).splitlines():
        line = line.strip()
        if line.startswith("SSID :"):
            name = line.split(":", 1)[1].strip()
            return None if name == "<redacted>" else name
    return None

def net_sent():
    return human_size(psutil.net_io_counters().bytes_sent)

def net_received():
    return human_size(psutil.net_io_counters().bytes_recv)

def hostname():
    return platform.node().removesuffix(".local")

def user():
    return getpass.getuser()

def os_name():
    names = {"Darwin": "macOS", "Windows": "Windows", "Linux": "Linux"}
    return names.get(platform.system(), platform.system())

def os_version():
    if platform.system() == "Darwin":
        return platform.mac_ver()[0]
    return platform.release()

def python_version():
    return platform.python_version()

def python_path():
    return sys.executable

def uptime():
    return time.time() - psutil.boot_time()

def uptime_text():
    return human_time(uptime())

def processes():
    return len(psutil.pids())

def home():
    return os.path.expanduser("~")

def volume():
    value = _run(["osascript", "-e", "output volume of (get volume settings)"])
    return int(value) if value.isdigit() else None

def muted():
    return _run(["osascript", "-e", "output muted of (get volume settings)"]) == "true"

def password(prompt="password > ", mask="*"):
    if not sys.stdin.isatty():  # Entrée redirigée (ex : echo 1234 | python3 main.py)
        return input(prompt)
    print(prompt, end="", flush=True)
    chars = []
    try:
        for char in _keys():
            if char in ("\r", "\n"):        # Entrée
                break
            if char == "\x03":               # Ctrl+C
                raise KeyboardInterrupt
            if char == "\x04" and not chars: # Ctrl+D sur un champ vide
                raise EOFError
            if char in ("\x7f", "\b"):       # Retour arrière
                if chars:
                    chars.pop()
                    print("\b \b", end="", flush=True)
            elif char == "\x15":             # Ctrl+U : tout effacer
                print("\b \b" * len(chars), end="", flush=True)
                chars.clear()
            elif char.isprintable():          # Ignore Tab, Échap...
                chars.append(char)
                print(mask, end="", flush=True)
    finally:
        print()  # Ici le terminal est déjà remis normal -> vrai retour à la ligne
    return "".join(chars)

def summary():
    bat, vol = battery(), volume()  # Une seule mesure chacun (au lieu de 2-3 appels)
    return {
        "user": user(),
        "hostname": hostname(),
        "os": f"{os_name()} {os_version()}",
        "python": python_version(),
        "cpu": f"{cpu()}% ({cpu_cores()} cores, {cpu_type()})",
        "ram": f"{ram()}% ({ram_used()} / {ram_total()})",
        "disk": f"{disk()}% ({disk_free()} free / {disk_total()})",
        "battery": f"{bat}%" + (" (plugged)" if plugged() else "") if bat is not None else "none",
        "time_left": time_left_text() or "-",
        "uptime": uptime_text(),
        "processes": processes(),
        "local_ip": local_ip() or "-",
        "online": online(),
        "volume": f"{vol}%" + (" (muted)" if muted() else "") if vol is not None else "-",
    }