scripts: Adopted Attr class changes in all scripts

Mainly the addition of Attr.getall, Attr.get, and changing
Attr.__getitem__ to raise KeyError (just like a normal dict).

scripts/codemap.py

@@ -270,13 +270,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -301,10 +302,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):
@@ -1279,8 +1319,8 @@ def main_(f, paths, *,
                 char=(t.char if getattr(t, 'char', None) is not None
                     else True if braille or dots
                     else t.key[len(by)-1][0] if t.key and t.key[len(by)-1]
-                    else chars_[0]),
+                    else chars_.get(0)),
-                color=t.color if t.color is not None else colors_[0])
+                color=t.color if t.color is not None else colors_.get(0))
 
         if label or (labels and not no_label):
             if t.label is not None:

scripts/codemapd3.py

@@ -162,13 +162,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -193,10 +194,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):

scripts/dbgbmap.py

@@ -3793,13 +3793,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -3824,10 +3825,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):
@@ -4597,7 +4637,7 @@ def main_(f, disk, mroots=None, *,
     for b in bmap.values():
         b.chars = {}
         for type in [b.type] + (['unused'] if args.get('usage') else []):
-            char__ = chars_[b.block, (type, '0x%x' % b.block)]
+            char__ = chars_.get((b.block, (type, '0x%x' % b.block)))
             if char__ is not None:
                 if isinstance(char__, str):
                     # don't punescape unless we have to
@@ -4610,7 +4650,7 @@ def main_(f, disk, mroots=None, *,
     for b in bmap.values():
         b.colors = {}
         for type in [b.type] + (['unused'] if args.get('usage') else []):
-            color__ = colors_[b.block, (type, '0x%x' % b.block)]
+            color__ = colors_.get((b.block, (type, '0x%x' % b.block)))
             if color__ is not None:
                 # don't punescape unless we have to
                 if '%' in color__:

scripts/dbgbmapd3.py

@@ -3703,13 +3703,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -3734,10 +3735,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):
@@ -4912,7 +4952,7 @@ def main(disk, output, mroots=None, *,
 
     # assign colors based on block type
     for b in bmap.values():
-        color__ = colors_[b.block, (b.type, '0x%x' % b.block)]
+        color__ = colors_.get((b.block, (b.type, '0x%x' % b.block)))
         if color__ is not None:
             if '%' in color__:
                 color__ = punescape(color__, b.attrs)
@@ -4920,7 +4960,7 @@ def main(disk, output, mroots=None, *,
 
     # assign labels
     for b in bmap.values():
-        label__ = labels_[b.block, (b.type, '0x%x' % b.block)]
+        label__ = labels_.get((b.block, (b.type, '0x%x' % b.block)))
         if label__ is not None:
             if '%' in label__:
                 label__ = punescape(label__, b.attrs)

scripts/plot.py

@@ -447,13 +447,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -478,10 +479,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):

scripts/plotmpl.py

@@ -354,13 +354,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -385,10 +386,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):

scripts/tracebd.py

@@ -234,7 +234,6 @@ class RingIO:
                 sys.stdout.write('\x1b[%dB' % (len(lines)-1-i))
         sys.stdout.flush()
 
-# TODO sync, espcially the getitem vs get changes
 # a representation of optionally key-mapped attrs
 class Attr:
     def __init__(self, attrs, defaults=None):

scripts/treemap.py

@@ -339,13 +339,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -370,10 +371,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):
@@ -1155,8 +1195,8 @@ def main_(f, csv_paths, *,
                 char=(t.char if getattr(t, 'char', None) is not None
                     else True if braille or dots
                     else t.key[len(by)-1][0] if t.key and t.key[len(by)-1]
-                    else chars_[0]),
+                    else chars_.get(0)),
-                color=t.color if t.color is not None else colors_[0])
+                color=t.color if t.color is not None else colors_.get(0))
 
         if label or (labels and not no_label):
             if t.label is not None:

scripts/treemapd3.py

@@ -230,13 +230,14 @@ class Attr:
         if isinstance(key, tuple):
             if len(key) > 0 and not isinstance(key[0], str):
                 i, key = key
-            else:
-                i, key = 0, key
-        else:
-            i, key = key, ()
-
                 if not isinstance(key, tuple):
                     key = (key,)
+            else:
+                i, key = 0, key
+        elif isinstance(key, str):
+            i, key = 0, (key,)
+        else:
+            i, key = key, ()
 
         # try to lookup by key
         best = None
@@ -261,10 +262,49 @@ class Attr:
         if self.defaults is not None:
             return self.defaults[i, key]
 
-        return None
+        raise KeyError(i, key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
 
     def __contains__(self, key):
-        return self.__getitem__(key) is not None
+        try:
+            self.__getitem__(key)
+            return True
+        except KeyError:
+            return False
+
+    # get all results for a given key
+    def getall(self, key, default=None):
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # try to lookup by key
+        best = None
+        for ks, vs in self.keyed.items():
+            prefix = []
+            for j, k in enumerate(ks):
+                if j < len(key) and fnmatch.fnmatchcase(key[j], k):
+                    prefix.append(k)
+                else:
+                    prefix = None
+                    break
+
+            if prefix is not None and (
+                    best is None or len(prefix) >= len(best[0])):
+                best = (prefix, vs)
+
+        if best is not None:
+            return best[1]
+
+        # fallback to defaults?
+        if self.defaults is not None:
+            return self.defaults.getall(key, default)
+
+        raise default
 
     # a key function for sorting by key order
     def key(self, key):