jwutils: Move to jwutils -> jw.util

Move all implementation source code from the jwutils module to jw.util. For compatibility with existing Python modules, keep a thin, autogenerated compatibility shim under jwutils.
Signed-off-by: Jan Lindemann <jan@janware.com>

src/python/jw/util/Options.py

@@ -0,0 +1,168 @@
+import re
+import json
+from collections import OrderedDict
+from .log import *
+import shlex
+import traceback
+
+class Options: # export
+
+    class OrderedData:
+
+        def __init__(self, pairs = None):
+            self.__pairs = [] if pairs is None else pairs
+
+        def add(self, lhs, rhs):
+            self.__pairs.append((lhs, rhs))
+
+        def dump(self):
+            for p in self.__pairs:
+                print(p)
+
+        @property
+        def pairs(self):
+            return self.__pairs
+
+    def __parse_json(self, spec, cls):
+        spec = spec.strip()
+        if len(spec) < 3:
+            return None
+        if spec[0] != '{':
+            spec = '{' + spec + '}'
+        try:
+            return json.loads(spec, object_pairs_hook=cls)
+        except:
+            pass
+        return None
+
+    def __parse(self, opts_str, cls):
+        r = self.__parse_json(opts_str, cls)
+        if r is not None:
+            return r
+        r = cls()
+        try:
+            opt_strs = shlex.split(opts_str)
+        except Exception as e:
+            slog_m(ERR, traceback.format_exc())
+            slog(ERR, 'Failed to split options string >{}<'.format(opts_str))
+            raise
+        for opt_str in opt_strs:
+            opt_str = re.sub(r'\s*=\s*', '=', opt_str)
+            sides = opt_str.split('=')
+            lhs = sides[0].strip()
+            if not len(lhs):
+                continue
+            if self.__allowed_keys and not lhs in self.__allowed_keys:
+                raise Exception('Field "{}" not supported'.format(lhs))
+            rhs = ' '.join(sides[1:]).strip() if len(sides) > 1 else self.__true_val
+            if cls == OrderedDict:
+                r[lhs] = rhs
+            elif cls == self.OrderedData:
+                r.add(lhs, rhs)
+        return r
+
+    def __recache(self):
+        self.__list.clear()
+        self.__dict.clear()
+        for key, val in self.__data.pairs:
+            self.__list.append(key)
+            if key not in self.__dict.keys():
+                self.__dict[key] = val
+            else:
+                cur = self.__dict[key]
+                if isinstance(cur, str):
+                    cur = [cur, val]
+                elif isinstance(cur, set):
+                    cur.add(val)
+                elif isinstance(cur, list):
+                    cur.append(val)
+                else:
+                    cur = [cur, val]
+                self.__dict[key] = cur
+        self.__str = self.__str__()
+
+    def __getitem__(self, key):
+        if not key in self.__dict.keys():
+            return None
+        return self.__dict[key]
+
+    def __str__(self):
+        return ', '.join(str(p[0]) + ': ' + str(p[1]) for p in self.__data.pairs)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __format__(self, fmt):
+        return self.__str__()
+
+    def __len__(self):
+        return len(self.__data.pairs)
+
+    def __contains__(self, keys):
+        if not type(keys) in [list, set]:
+            return keys in self.__dict.keys()
+        for key in keys:
+            if not key in self.__dict.keys():
+                return False
+        return True
+
+    def __iter__(self):
+        return iter(self.__list)
+
+    def __next__(self):
+        return next(self.__list)
+
+    def __init__(self, spec=None, delimiter=',', allowed_keys=None, true_val=True):
+        self.__true_val = true_val
+        self.__allowed_keys = None
+        self.__delimiter = delimiter
+        self.__data = self.OrderedData() if spec is None else self.__parse(spec, self.OrderedData)
+        self.__dict = {}
+        #self.__dict = OrderedDict() if spec is None else self.__parse(spec, OrderedDict)
+        self.__list = []
+        self.__str = None
+        self.__recache()
+
+    def dump(self, prio, caller=None):
+        if caller is None:
+            caller = get_caller_pos()
+        for key, val in self.__data.pairs:
+            slog(prio, "{}=\"{}\"".format(key, val), caller=caller)
+
+    def keys(self):
+        return self.__dict.keys()
+
+    def items(self):
+        #return self.__dict.items()
+        return self.__data.pairs
+
+    def get(self, key, default=None, by_index=False):
+        if by_index:
+            if type(key) != int:
+                raise KeyError('Tried to get value from options string with ' +
+                        'index {} of type "{}": {}'.format(key, type(key), str(self)))
+            if key >= len(self.__data.pairs):
+                if default is not None:
+                    return default
+                raise KeyError('Tried to get value from options string with ' +
+                        'index {} of {}: {}'.format(key, len(self.__data.pairs), str(self)))
+            return self.__list[key]
+        if key in self.__dict.keys():
+            return self.__dict[key]
+        if default is not None:
+            return default
+        raise KeyError('Key "{}" is not present in options string: {}'.format(key, str(self)))
+
+    def update(self, rhs):
+        if hasattr(rhs, 'items'):
+            for key, val in rhs.items():
+                self.__dict[key] = val
+            return
+        if isinstance(rhs, str):
+            self.update(self.__parse(rhs))
+            return
+        raise Exception('Tried to update options with object of incompatible type {}'.format(type(rhs)))
+
+    def append_to(self, obj):
+        for opt in self.__list:
+            setattr(obj, opt[0], opt[1])