netdata/python.d/python_modules/pyyaml2/resolver.py at master · ellerbrock/netdata · GitHub

History

224 lines (200 loc) · 8.76 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

__all__ = ['BaseResolver', 'Resolver']

from error import *

from nodes import *

import re

class ResolverError(YAMLError):

pass

class BaseResolver(object):

DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'

DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq'

DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map'

yaml_implicit_resolvers = {}

yaml_path_resolvers = {}

def __init__(self):

self.resolver_exact_paths = []

self.resolver_prefix_paths = []

def add_implicit_resolver(cls, tag, regexp, first):

if not 'yaml_implicit_resolvers' in cls.__dict__:

cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy()

if first is None:

first = [None]

for ch in first:

cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))

add_implicit_resolver = classmethod(add_implicit_resolver)

def add_path_resolver(cls, tag, path, kind=None):

# Note: `add_path_resolver` is experimental. The API could be changed.

# `new_path` is a pattern that is matched against the path from the

# root to the node that is being considered. `node_path` elements are

# tuples `(node_check, index_check)`. `node_check` is a node class:

# `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None`

# matches any kind of a node. `index_check` could be `None`, a boolean

# value, a string value, or a number. `None` and `False` match against

# any _value_ of sequence and mapping nodes. `True` matches against

# any _key_ of a mapping node. A string `index_check` matches against

# a mapping value that corresponds to a scalar key which content is

# equal to the `index_check` value. An integer `index_check` matches

# against a sequence value with the index equal to `index_check`.

if not 'yaml_path_resolvers' in cls.__dict__:

cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()

new_path = []

for element in path:

if isinstance(element, (list, tuple)):

if len(element) == 2:

node_check, index_check = element

elif len(element) == 1:

node_check = element[0]

index_check = True

else:

raise ResolverError("Invalid path element: %s" % element)

else:

node_check = None

index_check = element

if node_check is str:

node_check = ScalarNode

elif node_check is list:

node_check = SequenceNode

elif node_check is dict:

node_check = MappingNode

elif node_check not in [ScalarNode, SequenceNode, MappingNode] \

and not isinstance(node_check, basestring) \

and node_check is not None:

raise ResolverError("Invalid node checker: %s" % node_check)

if not isinstance(index_check, (basestring, int)) \

and index_check is not None:

raise ResolverError("Invalid index checker: %s" % index_check)

new_path.append((node_check, index_check))

if kind is str:

kind = ScalarNode

elif kind is list:

kind = SequenceNode

elif kind is dict:

kind = MappingNode

elif kind not in [ScalarNode, SequenceNode, MappingNode] \

and kind is not None:

raise ResolverError("Invalid node kind: %s" % kind)

cls.yaml_path_resolvers[tuple(new_path), kind] = tag

add_path_resolver = classmethod(add_path_resolver)

def descend_resolver(self, current_node, current_index):

if not self.yaml_path_resolvers:

return

exact_paths = {}

prefix_paths = []

if current_node:

depth = len(self.resolver_prefix_paths)

for path, kind in self.resolver_prefix_paths[-1]:

if self.check_resolver_prefix(depth, path, kind,

current_node, current_index):

if len(path) > depth:

prefix_paths.append((path, kind))

else:

exact_paths[kind] = self.yaml_path_resolvers[path, kind]

else:

for path, kind in self.yaml_path_resolvers:

if not path:

exact_paths[kind] = self.yaml_path_resolvers[path, kind]

else:

prefix_paths.append((path, kind))

self.resolver_exact_paths.append(exact_paths)

self.resolver_prefix_paths.append(prefix_paths)

def ascend_resolver(self):

if not self.yaml_path_resolvers:

return

self.resolver_exact_paths.pop()

self.resolver_prefix_paths.pop()

def check_resolver_prefix(self, depth, path, kind,

current_node, current_index):

node_check, index_check = path[depth-1]

if isinstance(node_check, basestring):

if current_node.tag != node_check:

return

elif node_check is not None:

if not isinstance(current_node, node_check):

return

if index_check is True and current_index is not None:

return

if (index_check is False or index_check is None) \

and current_index is None:

return

if isinstance(index_check, basestring):

if not (isinstance(current_index, ScalarNode)

and index_check == current_index.value):

return

elif isinstance(index_check, int) and not isinstance(index_check, bool):

if index_check != current_index:

return

return True

def resolve(self, kind, value, implicit):

if kind is ScalarNode and implicit[0]:

if value == u'':

resolvers = self.yaml_implicit_resolvers.get(u'', [])

else:

resolvers = self.yaml_implicit_resolvers.get(value[0], [])

resolvers += self.yaml_implicit_resolvers.get(None, [])

for tag, regexp in resolvers:

if regexp.match(value):

return tag

implicit = implicit[1]

if self.yaml_path_resolvers:

exact_paths = self.resolver_exact_paths[-1]

if kind in exact_paths:

return exact_paths[kind]

if None in exact_paths:

return exact_paths[None]

if kind is ScalarNode:

return self.DEFAULT_SCALAR_TAG

elif kind is SequenceNode:

return self.DEFAULT_SEQUENCE_TAG

elif kind is MappingNode:

return self.DEFAULT_MAPPING_TAG

class Resolver(BaseResolver):

pass

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:bool',

re.compile(ur'''^(?:yes|Yes|YES|no|No|NO

|on|On|ON|off|Off|OFF)$''', re.X),

list(u'yYnNtTfFoO'))

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:float',

re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?

|\.[0-9_]+(?:[eE][-+][0-9]+)?

|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*

|[-+]?\.(?:inf|Inf|INF)

|\.(?:nan|NaN|NAN))$''', re.X),

list(u'-+0123456789.'))

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:int',

re.compile(ur'''^(?:[-+]?0b[0-1_]+

|[-+]?0[0-7_]+

|[-+]?(?:0|[1-9][0-9_]*)

|[-+]?0x[0-9a-fA-F_]+

|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),

list(u'-+0123456789'))

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:merge',

re.compile(ur'^(?:<<)$'),

[u'<'])

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:null',

re.compile(ur'''^(?: ~

|null|Null|NULL

| )$''', re.X),

[u'~', u'n', u'N', u''])

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:timestamp',

re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]

|[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?

(?:[Tt]|[ \t]+)[0-9][0-9]?

:[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?

(?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),

list(u'0123456789'))

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:value',

re.compile(ur'^(?:=)$'),

[u'='])

# The following resolver is only for documentation purposes. It cannot work

# because plain scalars cannot start with '!', '&', or '*'.

Resolver.add_implicit_resolver(

u'tag:yaml.org,2002:yaml',

re.compile(ur'^(?:!|&|\*)$'),

list(u'!&*'))

netdata/python.d/python_modules/pyyaml2/resolver.py at master · ellerbrock/netdata · GitHub

Expand file tree

Breadcrumbs

resolver.py

Latest commit

History

Breadcrumbs

resolver.py

File metadata and controls