diff options
| -rwxr-xr-x | bin/shyaml | 251 |
1 files changed, 251 insertions, 0 deletions
diff --git a/bin/shyaml b/bin/shyaml new file mode 100755 index 00000000..83171394 --- /dev/null +++ b/bin/shyaml @@ -0,0 +1,251 @@ +#!/usr/bin/env python + +## Note: to launch test, you can use: +## python -m doctest -d shyaml.py +## or +## nosetests + +from __future__ import print_function + +import sys +import yaml +import os.path +import re + +EXNAME = os.path.basename(sys.argv[0]) + + +def tokenize(s): + r"""Returns an iterable in all subpart of a '.' separated string + + So: + + >>> list(tokenize('foo.bar.wiz')) + ['foo', 'bar', 'wiz'] + + this function has to deal with any type of data in the string. So it + actually interprets the string. Characters with meaning are '.' and '\'. + Both of these can be included in a token by quoting them with '\'. + + So dot of slashes can be contained in token: + + >>> print('\n'.join(tokenize(r'foo.dot<\.>.slash<\\>'))) + foo + dot<.> + slash<\> + + Notice that empty keys are also supported: + + >>> list(tokenize(r'foo..bar')) + ['foo', '', 'bar'] + + Given an empty string: + + >>> list(tokenize(r'')) + [''] + + And a None value: + + >>> list(tokenize(None)) + [] + + """ + if s is None: + raise StopIteration + tokens = (re.sub(r'\\(\\|\.)', r'\1', m.group(0)) + for m in re.finditer(r'((\\.|[^.\\])*)', s)) + ## an empty string superfluous token is added after all non-empty string token: + for token in tokens: + if len(token) != 0: + next(tokens) + yield token + + +def mget(dct, key, default=None): + r"""Allow to get values deep in a dict with doted keys + + Accessing leaf values is quite straightforward: + + >>> dct = {'a': {'x': 1, 'b': {'c': 2}}} + >>> mget(dct, 'a.x') + 1 + >>> mget(dct, 'a.b.c') + 2 + + But you can also get subdict if your key is not targeting a + leaf value: + + >>> mget(dct, 'a.b') + {'c': 2} + + As a special feature, list access is also supported by providing a + (possibily signed) integer, it'll be interpreted as usual python + sequence access using bracket notation: + + >>> mget({'a': {'x': [1, 5], 'b': {'c': 2}}}, 'a.x.-1') + 5 + >>> mget({'a': {'x': 1, 'b': [{'c': 2}]}}, 'a.b.0.c') + 2 + + Keys that contains '.' can be accessed by escaping them: + + >>> dct = {'a': {'x': 1}, 'a.x': 3, 'a.y': 4} + >>> mget(dct, 'a.x') + 1 + >>> mget(dct, r'a\.x') + 3 + >>> mget(dct, r'a.y') + >>> mget(dct, r'a\.y') + 4 + + As a consequence, if your key contains a '\', you should also escape it: + + >>> dct = {r'a\x': 3, r'a\.x': 4, 'a.x': 5, 'a\\': {'x': 6}} + >>> mget(dct, r'a\\x') + 3 + >>> mget(dct, r'a\\\.x') + 4 + >>> mget(dct, r'a\\.x') + 6 + >>> mget({'a\\': {'b': 1}}, r'a\\.b') + 1 + >>> mget({r'a.b\.c': 1}, r'a\.b\\\.c') + 1 + + And even empty strings key are supported: + + >>> dct = {r'a': {'': {'y': 3}, 'y': 4}, 'b': {'': {'': 1}}, '': 2} + >>> mget(dct, r'a..y') + 3 + >>> mget(dct, r'a.y') + 4 + >>> mget(dct, r'') + 2 + >>> mget(dct, r'b..') + 1 + + mget support also default value if the key is not found: + + >>> mget({'a': 1}, 'b.y', default='N/A') + 'N/A' + + but will complain if you are trying to get into a leaf: + + >>> mget({'a': 1}, 'a.y', default='N/A') # doctest: +ELLIPSIS + Traceback (most recent call last): + ... + TypeError: 'int' object ... + + if the key is None, the whole dct should be sent back: + + >>> mget({'a': 1}, None) + {'a': 1} + + """ + return aget(dct, tokenize(key), default) + + +def aget(dct, key, default=None): + r"""Allow to get values deep in a dict with iterable keys + + Accessing leaf values is quite straightforward: + + >>> dct = {'a': {'x': 1, 'b': {'c': 2}}} + >>> aget(dct, ('a', 'x')) + 1 + >>> aget(dct, ('a', 'b', 'c')) + 2 + + If key is empty, it returns unchanged the ``dct`` value. + + >>> aget({'x': 1}, ()) + {'x': 1} + + """ + key = iter(key) + try: + head = next(key) + except StopIteration: + return dct + try: + value = dct[int(head)] if isinstance(dct, list) else dct[head] + except KeyError: + return default + return aget(value, key, default) + + +def stderr(msg): + sys.stderr.write(msg + "\n") + + +def die(msg, errlvl=1, prefix="Error: "): + stderr("%s%s" % (prefix, msg)) + sys.exit(errlvl) + +SIMPLE_TYPES = (str, int, float) +COMPLEX_TYPES = (list, dict) + + +def dump(value): + return value if isinstance(value, SIMPLE_TYPES) \ + else yaml.dump(value, default_flow_style=False) + +def type_name(value): + """Returns pseudo-YAML type name of given value.""" + return "struct" if isinstance(value, dict) else \ + "sequence" if isinstance(value, (tuple, list)) else \ + type(value).__name__ + +def stdout(value): + sys.stdout.write(value) + +def main(args): + usage = """usage: + %(exname)s {get-value{,-0},get-type,keys{,-0},values{,-0}} KEY DEFAULT + """ % {"exname": EXNAME} + if len(args) == 0: + die(usage, errlvl=0, prefix="") + action = args[0] + key_value = None if len(args) == 1 else args[1] + default = args[2] if len(args) > 2 else "" + contents = yaml.load(sys.stdin) + try: + value = mget(contents, key_value, default) + except IndexError: + die("list index error in path %r." % key_value) + except (KeyError, TypeError): + die("invalid path %r." % key_value) + + tvalue = type_name(value) + termination = "\0" if action.endswith("-0") else "\n" + + if action == "get-value": + print(dump(value), end='') + elif action in ("get-values", "get-values-0"): + if isinstance(value, dict): + for k, v in value.iteritems(): + stdout("%s%s%s%s" % (dump(k), termination, + dump(v), termination)) + elif isinstance(value, list): + for l in value: + stdout("%s%s" % (dump(l), termination)) + else: + die("%s does not support %r type. " + "Please provide or select a sequence or struct." + % (action, tvalue)) + elif action == "get-type": + print(tvalue) + elif action in ("keys", "keys-0", "values", "values-0"): + if isinstance(value, dict): + method = value.keys if action.startswith("keys") else value.values + for k in method(): + stdout("%s%s" % (dump(k), termination)) + else: + die("%s does not support %r type. " + "Please provide or select a struct." % (action, tvalue)) + else: + die("Invalid argument.\n%s" % usage) + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) |