init

.config/i3blocks/usb/usb

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2015 James Murphy
+# Licensed under the terms of the GNU GPL v2 only.
+#
+# i3blocks blocklet script to output connected usb storage device info.
+
+import os
+
+
+def _default(name, default='', arg_type=str):
+    val = default
+    if name in os.environ:
+        val = os.environ[name]
+    return arg_type(val)
+
+###############################################################################
+# BEGIN CONFIG
+# Most of these can be specified as command line options, run with --help for
+# more information.
+# You may edit any of the following entries.  DO NOT delete any of them, else
+# the main script will have unpredictable behavior.
+###############################################################################
+
+
+# Color options, can be a color name or #RRGGBB
+INFO_TEXT_COLOR = _default("INFO_TEXT_COLOR", "white")
+MOUNTED_COLOR = _default("MOUNTED_COLOR", "green")
+PLUGGED_COLOR = _default("PLUGGED_COLOR", "gray")
+LOCKED_COLOR = _default("LOCKED_COLOR", "gray")
+UNLOCKED_NOT_MOUNTED_COLOR = _default("UNLOCKED_NOT_MOUNTED_COLOR", "yellow")
+PARTITIONLESS_COLOR = _default("PARTITIONLESS_COLOR", "red")
+
+# Default texts
+PARTITIONLESS_TEXT = _default("PARTITIONLESS_TEXT", "no partitions")
+SEPARATOR = _default("SEPARATOR", "<span color='gray'> | </span>")
+
+# Indicate whether an encrypted partition is locked/unlocked, "" is allowed.
+LOCKED_INDICATOR = _default("LOCKED_INDICATOR", "\uf023 ")
+UNLOCKED_INDICATOR = _default("UNLOCKED_INDICATOR", "\uf09c ")
+
+# Shows instead of space available when a partition is mounted readonly
+READONLY_INDICATOR = _default("READONLY_INDICATOR", "ro")
+
+# Maximum length of a filesystem label to display. Use None to disable
+# truncation, a positive integer to right truncate to that many characters, or
+# a negative integer to left truncate to that many characters. Setting this
+# option to 0 will disable the displaying of filesystem labels.
+TRUNCATE_FS_LABELS = _default("TRUNCASE_FS_LABELS", None)
+
+# List of devices to ignore. Must be a valid python3 representation of a list
+# of strings
+IGNORE_LIST = _default("IGNORE_LIST", "[]")
+if IGNORE_LIST:
+    import ast
+    IGNORE_LIST = list(map(lambda p:
+                           p if p.startswith("/")
+                           else "/dev/{}".format(p),
+                           ast.literal_eval(IGNORE_LIST)
+                           ))
+
+
+# Edit this function to ignore certain devices (e.g. those that are always
+# plugged in).
+# The dictionary udev_attributes_dict contains all the attributes given by
+# udevadm info --query=propery --name=$path
+def ignore(path, udev_attributes_dict):
+    # E.g. how to ignore devices whose device name begins with /dev/sda
+    # if udev_attributes_dict["DEVNAME"].startswith("/dev/sda"):
+    #     return True
+    return False
+
+# Edit this function to ignore devices before the udev attributes are
+# computed in order to save time and memory.
+def fastIgnore(path):
+    if path in IGNORE_LIST:
+        return True
+
+    # E.g. how to to ignore devices whose path begins with /dev/sda
+    # if path.startswith("/dev/sda"):
+    #     return True
+
+    # E.g. how to ignore a fixed set of paths
+    # if path in [ "/dev/path1", "/dev/path2", "/dev/path3" ]:
+    #     return True
+    return False
+
+###############################################################################
+# END CONFIG
+# DO NOT EDIT ANYTHING AFTER THIS POINT UNLESS YOU KNOW WHAT YOU ARE DOING
+###############################################################################
+
+from subprocess import check_output
+import argparse
+
+def pangoEscape(text):
+    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def getLeafDevicePaths():
+    lines = check_output(['lsblk', '-lpno', 'NAME'], universal_newlines=True)
+    lines = lines.split("\n")
+    lines = filter(lambda s: s[:4]=='/dev', lines)
+    lines = map(lambda s: s.split(' ')[0], lines)
+    lines = filter(None, lines)
+    return lines
+
+
+def getKernelName(path):
+    return check_output(['lsblk', '-lndo', 'KNAME', path],
+            universal_newlines=True).rstrip("\n")
+
+
+def getDeviceType(path):
+    return check_output(['lsblk', '-no', 'TYPE', path],
+                        universal_newlines=True).strip()
+
+
+def getFSType(path):
+    global attributeMaps
+    return attributeMaps[path].get("ID_FS_TYPE")
+
+
+def isLUKSPartition(path):
+    return getFSType(path) == "crypto_LUKS"
+
+
+def isSwapPartition(path):
+    return getFSType(path) == "swap"
+
+
+def getFSLabel(path):
+    global attributeMaps
+    label = attributeMaps[path].get("ID_FS_LABEL_ENC", "")
+    if label:
+        label = label.encode().decode("unicode-escape")
+        if type(TRUNCATE_FS_LABELS) == int:
+            if TRUNCATE_FS_LABELS >= 0:
+                label = label[:TRUNCATE_FS_LABELS]
+            elif TRUNCATE_FS_LABELS < 0:
+                label = label[TRUNCATE_FS_LABELS:]
+    return label
+
+
+def getFSOptions(path):
+    lines = check_output(['findmnt', '-no', 'FS-OPTIONS', path],
+                         universal_newlines=True).strip()
+    lines = lines.split(",")
+    return lines
+
+
+def isReadOnly(path):
+    return "ro" in getFSOptions(path)
+
+
+def isExtendedPartitionMarker(path):
+    global attributeMaps
+    MARKERS = ["0xf", "0x5"]
+    return attributeMaps[path].get("ID_PART_ENTRY_TYPE") in MARKERS
+
+
+def getMountPoint(path):
+    return check_output(['lsblk', '-ndo', 'MOUNTPOINT', path],
+                        universal_newlines=True).rstrip("\n")
+
+
+def getSpaceAvailable(path):
+    lines = check_output(['df', '-h', '--output=avail', path],
+                         universal_newlines=True)
+    lines = lines.split("\n")
+    if len(lines) != 3:
+        return ""
+    else:
+        return lines[1].strip()
+
+
+def getLockedCryptOutput(path):
+    form = "<span color='{}'>[{}{}]</span>"
+    kname = pangoEscape(getKernelName(path))
+    output = form.format(LOCKED_COLOR, LOCKED_INDICATOR, kname)
+    return output
+
+
+def getParentKernelName(path):
+    lines = check_output(['lsblk', '-nso', 'KNAME', path],
+                         universal_newlines=True)
+    lines = lines.split("\n")
+    if len(lines) > 2:
+        return lines[1].rstrip("\n")
+    else:
+        return ""
+
+
+def getUnlockedCryptOutput(path):
+    mountPoint = getMountPoint(path)
+    if mountPoint:
+        color = MOUNTED_COLOR
+        if isReadOnly(path):
+            spaceAvail = READONLY_INDICATOR
+        else:
+            spaceAvail = pangoEscape(getSpaceAvailable(path))
+        mountPoint = "<i>{}</i>:".format(pangoEscape(mountPoint))
+    else:
+        color = UNLOCKED_NOT_MOUNTED_COLOR
+        spaceAvail = ""
+    kernelName = pangoEscape(getKernelName(path))
+    parentKernelName = pangoEscape(getParentKernelName(path))
+
+    block = "<span color='{}'>[{}{}:{}]</span>"
+    block = block.format(color, UNLOCKED_INDICATOR,
+                         parentKernelName, kernelName)
+
+    label = pangoEscape(getFSLabel(path))
+    if label:
+        label = '"{}"'.format(label)
+
+    items = [block, label, mountPoint, spaceAvail]
+    return " ".join(filter(None, items))
+
+
+def getSwapOutput(path):
+    return ""
+
+
+def getUnencryptedPartitionOutput(path):
+    mountPoint = getMountPoint(path)
+    if mountPoint:
+        color = MOUNTED_COLOR
+        if isReadOnly(path):
+            spaceAvail = READONLY_INDICATOR
+        else:
+            spaceAvail = pangoEscape(getSpaceAvailable(path))
+        mountPoint = "<i>{}</i>:".format(pangoEscape(mountPoint))
+    else:
+        color = PLUGGED_COLOR
+        spaceAvail = ""
+    kernelName = pangoEscape(getKernelName(path))
+
+    block = "<span color='{}'>[{}]</span>"
+    block = block.format(color, kernelName)
+
+    label = pangoEscape(getFSLabel(path))
+    if label:
+        label = '"{}"'.format(label)
+
+    items = [block, label, mountPoint, spaceAvail]
+    return " ".join(filter(None, items))
+
+
+def getDiskWithNoPartitionsOutput(path):
+    form = "<span color='{}'>[{}] {}</span>"
+    kernelName = pangoEscape(getKernelName(path))
+    return form.format(PARTITIONLESS_COLOR, kernelName, PARTITIONLESS_TEXT)
+
+
+def getOutput(path):
+    if isSwapPartition(path):
+        return getSwapOutput(path)
+    t = getDeviceType(path)
+    if t == "part":
+        if isExtendedPartitionMarker(path):
+            return ""
+        elif isLUKSPartition(path):
+            return getLockedCryptOutput(path)
+        else:
+            return getUnencryptedPartitionOutput(path)
+    elif t == "disk":
+        return getDiskWithNoPartitionsOutput(path)
+    elif t == "crypt":
+        return getUnlockedCryptOutput(path)
+    elif t == "rom":
+        return ""
+
+
+def makeAttributeMap(path):
+    attributeMap = {}
+    lines = check_output(
+        ['udevadm', 'info', '--query=property', '--name={}'.format(path)],
+        universal_newlines=True)
+    lines = lines.split("\n")
+    for line in lines:
+        if line:
+            key, val = line.split("=", maxsplit=1)
+            attributeMap[key] = val
+    return attributeMap
+
+
+def getAttributeMaps(paths):
+    return {path: makeAttributeMap(path) for path in paths}
+
+
+def parseArguments():
+    dsc = " ".join(["i3blocks blocklet script",
+                    "to output connected usb storage device info"])
+    parser = argparse.ArgumentParser(prog="usb.py", description=dsc)
+
+    def unArg(flag, text, default, *args, **kwargs):
+        parser.add_argument(flag, nargs=1,
+                            help="{}. Default: {}"
+                            .format(text, default), *args, **kwargs)
+
+    def unArgs(flagTempl, textTempl, vals):
+        for flag, text, default in vals:
+            unArg(flagTempl.format(flag), textTempl.format(text), default)
+
+    unArgs("--{}-color", "Set the color of {}",
+           [("info-text", "info text", INFO_TEXT_COLOR),
+            ("mounted", "mounted devices", MOUNTED_COLOR),
+            ("plugged", "plugged devices", PLUGGED_COLOR),
+            ("locked", "locked crypt devices", LOCKED_COLOR),
+            ("unlocked-not-mounted", "unlocked not mounted crypt devices",
+             UNLOCKED_NOT_MOUNTED_COLOR),
+            ("partitionless", "devices with no partitions",
+             PARTITIONLESS_COLOR)
+            ])
+
+    unArg("--partitionless-text",
+          "Set the text to display for a device with no partitions",
+          PARTITIONLESS_TEXT)
+    unArg("--separator", "Set the separator between devices", SEPARATOR)
+
+    unArgs("--{}-indicator", "Set the indicator to use for {}",
+           [("locked", "a locked crypt device", LOCKED_INDICATOR),
+            ("unlocked", "an unlocked crypt device", UNLOCKED_INDICATOR),
+            ("readonly", "a readonly device", READONLY_INDICATOR)
+            ])
+
+    unArg("--truncate-fs-labels",
+          "(integer) Trucate device labels to a certain number of characters",
+          TRUNCATE_FS_LABELS, type=int)
+    ignoreText = " ".join([
+        "Ignore a device by path.",
+        "If path doesn't begin with / then it is assumed to be in /dev/"])
+    parser.add_argument("-i", "--ignore", action="append", help=ignoreText)
+    args = parser.parse_args()
+    setParsedArgs(args)
+
+
+def setParsedArgs(args):
+    if args.info_text_color is not None:
+        global INFO_TEXT_COLOR
+        INFO_TEXT_COLOR = args.info_text_color[0]
+    if args.mounted_color is not None:
+        global MOUNTED_COLOR
+        MOUNTED_COLOR = args.mounted_color[0]
+    if args.plugged_color is not None:
+        global PLUGGED_COLOR
+        PLUGGED_COLOR = args.plugged_color[0]
+    if args.locked_color is not None:
+        global LOCKED_COLOR
+        LOCKED_COLOR = args.locked_color[0]
+    if args.unlocked_not_mounted_color is not None:
+        global UNLOCKED_NOT_MOUNTED_COLOR
+        UNLOCKED_NOT_MOUNTED_COLOR = args.unlocked_not_mounted_color[0]
+    if args.partitionless_color is not None:
+        global PARTITIONLESS_COLOR
+        PARTITIONLESS_COLOR = args.partitionless_color[0]
+    if args.partitionless_text is not None:
+        global PARTITIONLESS_TEXT
+        PARTITIONLESS_TEXT = args.partitionless_text[0]
+    if args.separator is not None:
+        global SEPARATOR
+        SEPARATOR = args.separator[0]
+    if args.locked_indicator is not None:
+        global LOCKED_INDICATOR
+        LOCKED_INDICATOR = args.locked_indicator[0]
+    if args.unlocked_indicator is not None:
+        global UNLOCKED_INDICATOR
+        UNLOCKED_INDICATOR = args.unlocked_indicator[0]
+    if args.readonly_indicator is not None:
+        global READONLY_INDICATOR
+        READONLY_INDICATOR = args.readonly_indicator[0]
+    if args.truncate_fs_labels is not None:
+        global TRUNCATE_FS_LABELS
+        TRUNCATE_FS_LABELS = args.truncate_fs_labels[0]
+    if args.ignore is not None:
+        args.ignore = list(map(lambda p:
+                               p if p.startswith("/") else "/dev/{}".format(p),
+                               args.ignore))
+        global fastIgnore
+        oldFastIgnore = fastIgnore
+
+        def newFastIgnore(path):
+            return oldFastIgnore(path) or path in args.ignore
+        fastIgnore = newFastIgnore
+
+
+parseArguments()
+leaves = getLeafDevicePaths()
+leaves = [path for path in leaves if not fastIgnore(path)]
+attributeMaps = getAttributeMaps(leaves)
+leaves = (path for path in leaves if not ignore(path, attributeMaps[path]))
+outputs = filter(None, map(getOutput, leaves))
+output = SEPARATOR.join(outputs)
+if output:
+    output = "<span color='{}'>{}</span>".format(INFO_TEXT_COLOR, output)
+print(output)
+print(output)