Adding upstream version 1.4.2.

Signed-off-by: Daniel Baumann <daniel@debian.org>

dsc_datatool/transformer/re_ranger.py

@@ -0,0 +1,123 @@
+"""dsc_datatool.transformer.re_ranger
+
+See `man dsc-datatool-transformer reranger`.
+
+Part of dsc_datatool.
+
+:copyright: 2024 OARC, Inc.
+"""
+
+import re
+
+from dsc_datatool import Transformer, args
+
+
+_key_re = re.compile(r'^(?:(\d+)|(\d+)-(\d+))$')
+
+
+class ReRanger(Transformer):
+    key = None
+    func = None
+    allow_invalid_keys = None
+    range = None
+    split_by = None
+
+
+    def __init__(self, opts):
+        Transformer.__init__(self, opts)
+        self.key = opts.get('key', 'mid')
+        self.func = opts.get('func', 'sum')
+        self.allow_invalid_keys = opts.get('allow_invalid_keys', False)
+        self.range = opts.get('range', None)
+
+        if self.allow_invalid_keys != False:
+            self.allow_invalid_keys = True
+
+        if self.range is None:
+            raise Exception('range must be given')
+        m = re.match(r'^/(\d+)$', self.range)
+        if m is None:
+            raise Exception('invalid range')
+        self.split_by = int(m.group(1))
+
+        if self.key != 'low' and self.key != 'mid' and self.key != 'high':
+            raise Exception('invalid key %r' % self.key)
+
+        if self.func != 'sum':
+            raise Exception('invalid func %r' % self.func)
+
+
+    def _process(self, dimension):
+        global _key_re
+
+        if not dimension.values:
+            for d2 in dimension.dimensions:
+                self._process(d2)
+            return
+
+        values = dimension.values
+        dimension.values = {}
+        skipped = None
+
+        for k, v in values.items():
+            low = None
+            high = None
+
+            m = _key_re.match(k)
+            if m:
+                low, low2, high = m.group(1, 2, 3)
+                if high is None:
+                    low = int(low)
+                    high = low
+                else:
+                    low = int(low2)
+                    high = int(high)
+            elif k == args.skipped_key:
+                continue
+            elif k == args.skipped_sum_key:
+                if skipped is None:
+                    skipped = v
+                else:
+                    skipped += v
+                continue
+            elif self.allow_invalid_keys:
+                dimension.values[k] = v
+                continue
+            else:
+                raise Exception('invalid key %r' % k)
+
+            if self.key == 'low':
+                nkey = low
+            elif self.key == 'mid':
+                nkey = int(low + ( (high - low) / 2 ))
+            else:
+                nkey = high
+
+            nkey = int(nkey / self.split_by) * self.split_by
+            low = nkey
+            high = nkey + self.split_by - 1
+
+            if self.func == 'sum':
+                if low != high:
+                    nkey = '%d-%d' % (low, high)
+                else:
+                    nkey = str(nkey)
+
+                if nkey in dimension.values:
+                    dimension.values[nkey] += v
+                else:
+                    dimension.values[nkey] = v
+
+        if skipped:
+            dimension.values['skipped'] = skipped
+
+
+    def process(self, datasets):
+        for dataset in datasets:
+            for dimension in dataset.dimensions:
+                self._process(dimension)
+
+
+import sys
+if sys.version_info[0] == 3 and sys.version_info[1] == 5: # pragma: no cover
+    Transformer.__init_subclass__(ReRanger)