Adding upstream version 1.4.2.

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

dsc_datatool/transformer/labler.py

@@ -0,0 +1,69 @@
+"""dsc_datatool.transformer.labler
+
+See `man dsc-datatool-transformer labler`.
+
+Part of dsc_datatool.
+
+:copyright: 2024 OARC, Inc.
+"""
+
+import yaml
+
+from dsc_datatool import Transformer, encoding
+
+
+def _process(label, d):
+    l = label.get(d.name, None)
+    if d.values:
+        if l is None:
+            return
+
+        values = d.values
+        d.values = {}
+
+        for k, v in values.items():
+            nk = l.get(k, None)
+            d.values[nk or k] = v
+
+        return
+
+    if l:
+        v = l.get(d.value, None)
+        if v:
+            d.value = v
+    for d2 in d.dimensions:
+        _process(label, d2)
+
+
+class Labler(Transformer):
+    label = None
+
+
+    def __init__(self, opts):
+        Transformer.__init__(self, opts)
+        if not 'yaml' in opts:
+            raise Exception('yaml=file option required')
+        f = open(opts.get('yaml'), 'r', encoding=encoding)
+        try:
+            self.label = yaml.full_load(f)
+        except AttributeError:
+            self.label = yaml.load(f)
+        f.close()
+
+
+    def process(self, datasets):
+        if self.label is None:
+            return
+
+        for dataset in datasets:
+            label = self.label.get(dataset.name, None)
+            if label is None:
+                continue
+
+            for d in dataset.dimensions:
+                _process(label, d)
+
+
+import sys
+if sys.version_info[0] == 3 and sys.version_info[1] == 5: # pragma: no cover
+    Transformer.__init_subclass__(Labler)

dsc_datatool/transformer/net_remap.py

@@ -0,0 +1,77 @@
+"""dsc_datatool.transformer.net_remap
+
+See `man dsc-datatool-transformer netremap`.
+
+Part of dsc_datatool.
+
+:copyright: 2024 OARC, Inc.
+"""
+
+import ipaddress
+
+from dsc_datatool import Transformer, args
+
+
+class NetRemap(Transformer):
+    v4net = None
+    v6net = None
+    nonstrict = False
+
+
+    def __init__(self, opts):
+        Transformer.__init__(self, opts)
+        net = opts.get('net', None)
+        self.v4net = opts.get('v4net', net)
+        self.v6net = opts.get('v6net', net)
+
+        if not self.v4net:
+            raise Exception('v4net (or net) must be given')
+        if not self.v6net:
+            raise Exception('v6net (or net) must be given')
+
+        if opts.get('nonstrict', False):
+            self.nonstrict = True
+
+
+    def _process(self, dimension):
+        if not dimension.values:
+            for d2 in dimension.dimensions:
+                self._process(d2)
+            return
+
+        values = dimension.values
+        dimension.values = {}
+
+        for k, v in values.items():
+            if k == args.skipped_key:
+                continue
+            elif k == args.skipped_sum_key:
+                dimension.values['0'] = v
+                continue
+
+            try:
+                ip = ipaddress.ip_address(k)
+            except Exception as e:
+                if not self.nonstrict:
+                    raise e
+                continue
+            if ip.version == 4:
+                nkey = str(ipaddress.IPv4Network('%s/%s' % (ip, self.v4net), strict=False).network_address)
+            else:
+                nkey = str(ipaddress.IPv6Network('%s/%s' % (ip, self.v6net), strict=False).network_address)
+
+            if not nkey in dimension.values:
+                dimension.values[nkey] = v
+            else:
+                dimension.values[nkey] += v
+
+
+    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__(NetRemap)

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)