openrvdas.logger.transforms.slice_transform

 1#!/usr/bin/env python3
 2"""Slice fields out of the specified text record."""
 3
 4import logging
 5import sys
 6
 7from logger.transforms.transform import Transform  # noqa: E402
 8
 9
10################################################################################
11class SliceTransform(Transform):
12    def __init__(self, fields=None, sep=None, **kwargs):
13        """
14        ```
15        fields    A comma-separated list of integers and/or ranges. A range
16                  is an int:int pair, where either or both of the ints may
17                  be omitted to mean the extreme values (0 or sys.maxsize).
18
19        sep       Field separator; if omitted, uses default behavior of split()
20                  which assumes all contiguous whitespace as a single separator.
21        ```
22        Example:
23        ```
24          transform = SliceTransform(':3,5:7,9,11:')
25
26          record = transform.transform('a b c d e f g h i j k l')
27        ```
28        should yield ``'a b c f g j l'``.
29
30        Note that Python slice indexing applies, so '-3:-1' is a valid spec.
31        Note also that there's nothing requiring that fields are in order,
32        non-overlapping and/or non-repeating. The following definition is just
33        fine.
34        ```
35        transform = SliceTransform('9,0,4,0,0:2')
36        ```
37        """
38        super().__init__(**kwargs)  # processes 'quiet' and type hints
39
40        if not fields:
41            fields = ':'
42
43        self.fields = []
44        self.sep = sep
45        try:
46            for field in fields.split(','):
47                logging.debug('SliceTransform parsing field "%s"', field)
48                # If field spec is a range, num:num, store as tuple of ints
49                if field.find(':') > -1:
50                    (start, end) = field.split(':')
51                    if start == '':  # if missing start, e.g.   ':5'
52                        start = 0
53                    if end == '':    # if missing end, e.g.   '1:'
54                        end = sys.maxsize
55                    self.fields.append((int(start), int(end)))
56
57                    # If field is a simple number
58                else:
59                    self.fields.append(int(field))
60        except ValueError as e:
61            logging.error('Bad field format "%s" - %s', field, e)
62            raise e
63
64    ############################
65    def transform(self, record: str) -> str:
66        """Strip and return only the requested fields."""
67
68        # See if it's something we can process, and if not, try digesting
69        if not self.can_process_record(record):  # inherited from BaseModule()
70            return self.digest_record(record)  # inherited from BaseModule()
71
72        in_record = record.split(self.sep)
73        out_record = []
74        for field in self.fields:
75            if type(field) is tuple:
76                slice = in_record[field[0]:field[1]]
77            else:
78                slice = [in_record[field]]
79
80            logging.debug('SliceTransform.write() selecting %s: %s', field, slice)
81            out_record.extend(slice)
82        separator = self.sep or ' '
83        return separator.join(out_record)