Ejemplo n.º 1
0
 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')
     try:
         self.label = yaml.full_load(f)
     except AttributeError:
         self.label = yaml.load(f)
     f.close()
Ejemplo n.º 2
0
def test_transformer():
    o = Transformer({})
    with pytest.raises(Exception):
        o.process([])

    class Transformer1(Transformer):
        def process(self, file):
            pass
    with pytest.raises(Exception):
        class Transformer1(Transformer):
            def process(self, file):
                pass
Ejemplo n.º 3
0
    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
Ejemplo n.º 4
0
    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)
Ejemplo n.º 5
0
                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)
Ejemplo n.º 6
0
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')
        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)
Ejemplo n.º 7
0
            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)