Aluode/PerceptionLabPortable

1 2__all__ = ['BaseResolver', 'Resolver']3 4from .error import *5from .nodes import *6 7import re8 9class ResolverError(YAMLError):10    pass11 12class BaseResolver:13 14    DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'15    DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'16    DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'17 18    yaml_implicit_resolvers = {}19    yaml_path_resolvers = {}20 21    def __init__(self):22        self.resolver_exact_paths = []23        self.resolver_prefix_paths = []24 25    @classmethod26    def add_implicit_resolver(cls, tag, regexp, first):27        if not 'yaml_implicit_resolvers' in cls.__dict__:28            implicit_resolvers = {}29            for key in cls.yaml_implicit_resolvers:30                implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:]31            cls.yaml_implicit_resolvers = implicit_resolvers32        if first is None:33            first = [None]34        for ch in first:35            cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))36 37    @classmethod38    def add_path_resolver(cls, tag, path, kind=None):39        # Note: `add_path_resolver` is experimental.  The API could be changed.40        # `new_path` is a pattern that is matched against the path from the41        # root to the node that is being considered.  `node_path` elements are42        # tuples `(node_check, index_check)`.  `node_check` is a node class:43        # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`.  `None`44        # matches any kind of a node.  `index_check` could be `None`, a boolean45        # value, a string value, or a number.  `None` and `False` match against46        # any _value_ of sequence and mapping nodes.  `True` matches against47        # any _key_ of a mapping node.  A string `index_check` matches against48        # a mapping value that corresponds to a scalar key which content is49        # equal to the `index_check` value.  An integer `index_check` matches50        # against a sequence value with the index equal to `index_check`.51        if not 'yaml_path_resolvers' in cls.__dict__:52            cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()53        new_path = []54        for element in path:55            if isinstance(element, (list, tuple)):56                if len(element) == 2:57                    node_check, index_check = element58                elif len(element) == 1:59                    node_check = element[0]60                    index_check = True61                else:62                    raise ResolverError("Invalid path element: %s" % element)63            else:64                node_check = None65                index_check = element66            if node_check is str:67                node_check = ScalarNode68            elif node_check is list:69                node_check = SequenceNode70            elif node_check is dict:71                node_check = MappingNode72            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \73                    and not isinstance(node_check, str) \74                    and node_check is not None:75                raise ResolverError("Invalid node checker: %s" % node_check)76            if not isinstance(index_check, (str, int))  \77                    and index_check is not None:78                raise ResolverError("Invalid index checker: %s" % index_check)79            new_path.append((node_check, index_check))80        if kind is str:81            kind = ScalarNode82        elif kind is list:83            kind = SequenceNode84        elif kind is dict:85            kind = MappingNode86        elif kind not in [ScalarNode, SequenceNode, MappingNode]    \87                and kind is not None:88            raise ResolverError("Invalid node kind: %s" % kind)89        cls.yaml_path_resolvers[tuple(new_path), kind] = tag90 91    def descend_resolver(self, current_node, current_index):92        if not self.yaml_path_resolvers:93            return94        exact_paths = {}95        prefix_paths = []96        if current_node:97            depth = len(self.resolver_prefix_paths)98            for path, kind in self.resolver_prefix_paths[-1]:99                if self.check_resolver_prefix(depth, path, kind,100                        current_node, current_index):101                    if len(path) > depth:102                        prefix_paths.append((path, kind))103                    else:104                        exact_paths[kind] = self.yaml_path_resolvers[path, kind]105        else:106            for path, kind in self.yaml_path_resolvers:107                if not path:108                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]109                else:110                    prefix_paths.append((path, kind))111        self.resolver_exact_paths.append(exact_paths)112        self.resolver_prefix_paths.append(prefix_paths)113 114    def ascend_resolver(self):115        if not self.yaml_path_resolvers:116            return117        self.resolver_exact_paths.pop()118        self.resolver_prefix_paths.pop()119 120    def check_resolver_prefix(self, depth, path, kind,121            current_node, current_index):122        node_check, index_check = path[depth-1]123        if isinstance(node_check, str):124            if current_node.tag != node_check:125                return126        elif node_check is not None:127            if not isinstance(current_node, node_check):128                return129        if index_check is True and current_index is not None:130            return131        if (index_check is False or index_check is None)    \132                and current_index is None:133            return134        if isinstance(index_check, str):135            if not (isinstance(current_index, ScalarNode)136                    and index_check == current_index.value):137                return138        elif isinstance(index_check, int) and not isinstance(index_check, bool):139            if index_check != current_index:140                return141        return True142 143    def resolve(self, kind, value, implicit):144        if kind is ScalarNode and implicit[0]:145            if value == '':146                resolvers = self.yaml_implicit_resolvers.get('', [])147            else:148                resolvers = self.yaml_implicit_resolvers.get(value[0], [])149            wildcard_resolvers = self.yaml_implicit_resolvers.get(None, [])150            for tag, regexp in resolvers + wildcard_resolvers:151                if regexp.match(value):152                    return tag153            implicit = implicit[1]154        if self.yaml_path_resolvers:155            exact_paths = self.resolver_exact_paths[-1]156            if kind in exact_paths:157                return exact_paths[kind]158            if None in exact_paths:159                return exact_paths[None]160        if kind is ScalarNode:161            return self.DEFAULT_SCALAR_TAG162        elif kind is SequenceNode:163            return self.DEFAULT_SEQUENCE_TAG164        elif kind is MappingNode:165            return self.DEFAULT_MAPPING_TAG166 167class Resolver(BaseResolver):168    pass169 170Resolver.add_implicit_resolver(171        'tag:yaml.org,2002:bool',172        re.compile(r'''^(?:yes|Yes|YES|no|No|NO173                    |true|True|TRUE|false|False|FALSE174                    |on|On|ON|off|Off|OFF)$''', re.X),175        list('yYnNtTfFoO'))176 177Resolver.add_implicit_resolver(178        'tag:yaml.org,2002:float',179        re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?180                    |\.[0-9][0-9_]*(?:[eE][-+][0-9]+)?181                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*182                    |[-+]?\.(?:inf|Inf|INF)183                    |\.(?:nan|NaN|NAN))$''', re.X),184        list('-+0123456789.'))185 186Resolver.add_implicit_resolver(187        'tag:yaml.org,2002:int',188        re.compile(r'''^(?:[-+]?0b[0-1_]+189                    |[-+]?0[0-7_]+190                    |[-+]?(?:0|[1-9][0-9_]*)191                    |[-+]?0x[0-9a-fA-F_]+192                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),193        list('-+0123456789'))194 195Resolver.add_implicit_resolver(196        'tag:yaml.org,2002:merge',197        re.compile(r'^(?:<<)$'),198        ['<'])199 200Resolver.add_implicit_resolver(201        'tag:yaml.org,2002:null',202        re.compile(r'''^(?: ~203                    |null|Null|NULL204                    | )$''', re.X),205        ['~', 'n', 'N', ''])206 207Resolver.add_implicit_resolver(208        'tag:yaml.org,2002:timestamp',209        re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]210                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?211                     (?:[Tt]|[ \t]+)[0-9][0-9]?212                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?213                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),214        list('0123456789'))215 216Resolver.add_implicit_resolver(217        'tag:yaml.org,2002:value',218        re.compile(r'^(?:=)$'),219        ['='])220 221# The following resolver is only for documentation purposes. It cannot work222# because plain scalars cannot start with '!', '&', or '*'.223Resolver.add_implicit_resolver(224        'tag:yaml.org,2002:yaml',225        re.compile(r'^(?:!|&|\*)$'),226        list('!&*'))227 228