class RegexTemplate(Template):
"""A template using regex template syntax."""
#: The source template.
template = attr.ib(type=Text)
_template = attr.ib(
repr=False,
init=False,
default=attr.Factory(
lambda self: sre_parse.parse_template(self.template, _IdPattern), # pytype: disable=wrong-arg-types
takes_self=True))
def substitute_match(self, parsed, match, matches):
del match # unused
mapping = stringify_matches(matches)
empty_string = self.template[0:0] # bytes/unicode compatibility hack.
fillers, spaces = self._template
spaces = list(spaces)
for target, source in fillers:
spaces[target] = mapping[source]
return empty_string.join(spaces)
@cached_property.cached_property
def variables(self):
fillers, _ = self._template
return frozenset(source for _, source in fillers)
def __init__(self, pattern, template):
self.__original = template
self.__back_ref = set()
self.__add_back_references(CAP_TOKEN)
self.__template = self.__escape_template(template)
self.groups, self.literals = sre_parse.parse_template(
self.__template, pattern)
def _subn(pattern, template, string, count=0):
# internal: pattern.subn implementation hook
if callable(template):
filter = template
else:
template = sre_parse.parse_template(template, pattern)
def filter(match, template=template):
return sre_parse.expand_template(template, match)
n = i = 0
s = []
append = s.append
c = pattern.scanner(string)
while not count or n < count:
m = c.search()
if not m:
break
b, e = m.span()
if i < b:
append(string[i:b])
append(filter(m))
i = e
n = n + 1
append(string[i:])
return _join(s, string[:0]), n
def __init__(self, pattern, template):
"""Initialize."""
self.__original = template
self.__back_ref = set()
self.__add_back_references(CAP_TOKEN)
self.__template = self.__escape_template(template)
self.groups, self.literals = sre_parse.parse_template(self.__template, pattern)
def parse_template(self, pattern):
"""Parse template."""
i = ReplaceTokens(self._original, use_format=self.use_format)
iter(i)
self.result = [self._empty]
for t in i:
if len(t) > 1:
if self.use_format and t[0:1] == self._lc_bracket:
self.handle_format_group(t[1:-1].strip())
else:
c = t[1:]
first = c[0:1]
if first.isdigit() and (self.use_format or len(c) == 3):
value = int(c, 8)
if value > 0xFF:
if self.binary:
# Re fails on octal greater than 0o377 or 0xFF
raise ValueError("octal escape value outside of range 0-0o377!")
self.result.append(compat.uchr(value))
else:
self.result.append(self.string_convert('\\%03o' % value))
elif not self.use_format and (c[0:1].isdigit() or c[0:1] == self._group):
self.handle_group(t)
elif c == self._lc:
self.single_case(i, _LOWER)
elif c == self._lc_span:
self.span_case(i, _LOWER)
elif c == self._uc:
self.single_case(i, _UPPER)
elif c == self._uc_span:
self.span_case(i, _UPPER)
elif c == self._end:
# This is here just as a reminder that \E is ignored
pass
elif (
not self.binary and
(first == self._unicode_narrow or (not NARROW and first == self._unicode_wide))
):
value = int(t[2:], 16)
if value <= 0xFF:
self.result.append('\\%03o' % value)
else:
self.result.append(compat.uchr(value))
elif first == self._hex:
self.result.append('\\%03o' % int(t[2:], 16))
else:
self.result.append(t)
else:
self.result.append(t)
if len(self.result) > 1:
self.literal_slots.append(self._empty.join(self.result))
del self.result[:]
self.result.append(self._empty)
self.slot += 1
self._template = self._empty.join(self.literal_slots)
self.groups, self.literals = sre_parse.parse_template(self._template, pattern)
def _compile_repl(*key):
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
try:
p = sre_parse.parse_template(repl, pattern)
except error, v:
raise error, v
def _compile_repl(*key):
p = _cache_repl.get(key)
if (p is not None):
return p
(repl, pattern,) = key
try:
p = sre_parse.parse_template(repl, pattern)
except error, v:
raise error, v
def _compile_repl(repl, pattern):
try:
return _cache_repl[(repl, pattern)]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[(repl, pattern)] = p
return p
def _compile_repl(repl, pattern):
try:
return _cache_repl[(repl, pattern)]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[(repl, pattern)] = p
return p
def _compile_repl(*key):
# internal: compile replacement pattern
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
try:
p = sre_parse.parse_template(repl, pattern)
except error, v:
raise error, v # invalid expression
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
try:
return _cache_repl[repl, pattern]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[repl, pattern] = p
return p
def _compile_repl(*key):
# internal: compile replacement pattern
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[key] = p
return p
def _compile_repl(*key):
# internal: compile replacement pattern
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[key] = p
return p
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
try:
return _cache_repl[repl, pattern]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[repl, pattern] = p
return p
def _compile_repl(*key):
# internal: compile replacement pattern
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
try:
p = sre_parse.parse_template(repl, pattern)
except error as v:
raise_(error, v) # invalid expression
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[key] = p
return p
def _compile_repl(*key):
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
try:
p = sre_parse.parse_template(repl, pattern)
except error as v:
raise error, v
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[key] = p
return p
def _compile_repl(*key):
p = _cache_repl.get(key)
if p is not None:
return p
repl, pattern = key
try:
p = sre_parse.parse_template(repl, pattern)
except error as v:
raise error, v
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[key] = p
return p
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
try:
#fix me brython
#return _cache_repl[repl, pattern]
return _cache_repl["%s:%s" % (repl, pattern)]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl["%s:%s" % (repl, pattern)] = p
#fix me brython
#_cache_repl[repl, pattern] = p
return p
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
try:
#fix me brython
#return _cache_repl[repl, pattern]
return _cache_repl["%s:%s" % (repl, pattern)]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl["%s:%s" % (repl, pattern)] = p
#fix me brython
#_cache_repl[repl, pattern] = p
return p
def _expand(self, m, template):
# XXX This code depends on internals of the regular expression
# engine! There's no standard API to do a substitution when you
# have already found the match. One should be added.
# The solution here is designed to be backwards compatible
# with previous Python versions, e.g. 1.5.2.
# XXX This dynamic test should be done only once.
if getattr(re, "engine", "pre") == "pre":
return re.pcre_expand(m, template)
else: # sre
# XXX This import should be avoidable...
import sre_parse
# XXX This parses the template over and over...
ptemplate = sre_parse.parse_template(template, m.re)
return sre_parse.expand_template(ptemplate, m)
def _expand(self, m, template):
# XXX This code depends on internals of the regular expression
# engine! There's no standard API to do a substitution when you
# have already found the match. One should be added.
# The solution here is designed to be backwards compatible
# with previous Python versions, e.g. 1.5.2.
# XXX This dynamic test should be done only once.
if getattr(re, "engine", "pre") == "pre":
return re.pcre_expand(m, template)
else: # sre
# XXX This import should be avoidable...
import sre_parse
# XXX This parses the template over and over...
ptemplate = sre_parse.parse_template(template, m.re)
return sre_parse.expand_template(ptemplate, m)
def _compiledReplacement(self, regexField, replField):
repl = getattr(self, replField, None)
if not repl: return BLANK_PARSE_TEMPLATE
cache = self._compiledCache()
regex = getattr(self, regexField, None)
if replField in cache and (regex,repl) in cache[replField]:
return cache[replField][(regex,repl)]
else:
try:
compiled = parse_template(repl, self._compiledRegex(regexField))
cache[replField] = {(regex,repl) : compiled}
return compiled
except:
log.warn("Invalid %s on %s", replField, self)
cache[replField] = {(regex,repl) : None}
return None
def __init__(self, pattern, replacement):
self.pattern = pattern
self.replacement = replacement
self._re = re.compile(pattern)
backrefs, literals = parse_template(replacement, self._re)
self._backrefs = dict(backrefs)
self._segments = literals
# Get "trackable" capture groups; i.e., those that are
# transparent for characterization. For PET behavior, these
# must appear in strictly increasing order with no gaps
self._groupstack = []
for i, backref in enumerate(backrefs):
_, grpidx = backref
if i + 1 != grpidx:
break
self._groupstack.append(grpidx)
def __init__(self, pattern, template):
"""Initialize."""
if isinstance(template, binary_type):
self.binary = True
tokens = btokens
else:
self.binary = False
tokens = utokens
self._original = template
self._back_ref = set()
self._b_slash = tokens[_B_SLASH]
self._def_back_ref = tokens[_DEF_BACK_REF]
self._empty = tokens[_EMPTY]
self._add_back_references(tokens[_REPLACE_TOKENS])
self._template = self.__escape_template(template)
self.groups, self.literals = sre_parse.parse_template(self._template, pattern)
def _compiledReplacement(self, regexField, replField):
repl = getattr(self, replField, None)
if not repl: return BLANK_PARSE_TEMPLATE
cache = self._compiledCache()
regex = getattr(self, regexField, None)
if replField in cache and (regex, repl) in cache[replField]:
return cache[replField][(regex, repl)]
else:
try:
compiled = parse_template(repl,
self._compiledRegex(regexField))
cache[replField] = {(regex, repl): compiled}
return compiled
except:
log.warn("Invalid %s on %s", replField, self)
cache[replField] = {(regex, repl): None}
return None
def setup_template(self, pattern, template):
if isinstance(template, compat.binary_type):
self.binary = True
tokens = btokens
ctokens = ctok.btokens
else:
self.binary = False
tokens = utokens
ctokens = ctok.utokens
self._original = template
self._back_ref = set()
self._def_back_ref = tokens["def_back_ref"]
self._b_slash = ctokens["b_slash"]
self._empty = ctokens["empty"]
self._add_back_references(ctokens["replace_tokens"])
self._template = self._escape_template(template)
self.groups, self.literals = sre_parse.parse_template(self._template, pattern)
def setInfo(self, **data):
"""
Set attributes on a process.
This method accepts any keyword argument for the property that you wish
to set. The only required property is "uid".
@type uid: string
@keyword uid: Unique identifier of a process
@rtype: DirectResponse
@return: B{Properties}
- data: (dictionary) Object representing a process's new properties
"""
facade = self._getFacade()
processUid = data['uid']
for regexParam in ['includeRegex', 'excludeRegex', 'replaceRegex']:
regex = data.get(regexParam)
if regex:
try:
re.compile(regex)
except re.error as e:
m = "%s : %s" % (regexParam, e)
return DirectResponse.fail(msg=m)
replaceRegex = data.get('replaceRegex')
if replaceRegex:
replaceRegex = re.compile(replaceRegex)
replacement = data.get('replacement')
if replacement:
try:
groups, literals = parse_template(replacement,replaceRegex)
for index, group in groups:
if group > replaceRegex.groups:
m = "Group (%s) referenced in replacement must be defined in replaceRegex" % group
return DirectResponse.fail(msg=m)
except re.error as e:
m = "replacement : %s" % (e,)
return DirectResponse.fail(msg=m)
process = facade.getInfo(processUid)
audit('UI.Process.Edit', processUid, data_=data, skipFields_=('uid'))
return DirectResponse.succeed(data=Zuul.unmarshal(data, process))
def expand_sub(string, template, debug=0, mode='all'):
""" Given a regular expression and a replacement string, generate expansions of
the regular expression and for each one return it and its transformation
as applied by the replacement string.
string : regular expression to expand
template : transformation to apply to each regular expression
mode : can take 3 values
all : return all possible shortest strings that the regular expression
would match
first : return the first string that all would return
random : return one random string that the regular expression would match
"""
pattern = sre_parse.parse(string, flags=sre_parse.SRE_FLAG_VERBOSE)
pattern.mode = mode
template = sre_parse.parse_template(template, pattern)
if debug:
print(pattern)
print(template)
for s in _iterate(pattern, pattern.data, MatchObj(pattern, "")):
s.patient = 0
yield (s.string, sre_parse.expand_template(template, s))
def expand_sub(string, template, debug=0, mode='all') :
""" Given a regular expression and a replacement string, generate expansions of
the regular expression and for each one return it and its transformation
as applied by the replacement string.
string : regular expression to expand
template : transformation to apply to each regular expression
mode : can take 3 values
all : return all possible shortest strings that the regular expression
would match
first : return the first string that all would return
random : return one random string that the regular expression would match
"""
pattern = sre_parse.parse(string, flags=sre_parse.SRE_FLAG_VERBOSE)
pattern.mode = mode
template = sre_parse.parse_template(template, pattern)
if debug :
print pattern
print template
for s in _iterate(pattern, pattern.data, MatchObj(pattern, "")) :
s.patient = 0
yield (s.string, sre_parse.expand_template(template, s))
def parse_template(self, pattern):
"""Parse template."""
i = _util.StringIter((self._original.decode('latin-1')
if self.binary else self._original))
iter(i)
self.result = [""]
while True:
try:
t = next(i)
if self.use_format and t in _CURLY_BRACKETS:
self.handle_format(t, i)
elif t == '\\':
try:
t = next(i)
self.reference(t, i)
except StopIteration:
self.result.append(t)
raise
else:
self.result.append(t)
except StopIteration:
break
if len(self.result) > 1:
self.literal_slots.append("".join(self.result))
del self.result[:]
self.result.append("")
self.slot += 1
if self.binary:
self._template = "".join(self.literal_slots).encode('latin-1')
else:
self._template = "".join(self.literal_slots)
self.groups, self.literals = _sre_parse.parse_template(
self._template, pattern)
def parse_template(self, pattern):
"""Parse template."""
i = ReplaceTokens(self._original)
iter(i)
self.result = [self._empty]
for t in i:
if len(t) > 1:
c = t[1:]
if c[0:1].isdigit() or c[0:1] == self._group:
self.handle_group(t)
elif c == self._lc:
self.single_case(i, _LOWER)
elif c == self._lc_span:
self.span_case(i, _LOWER)
elif c == self._uc:
self.single_case(i, _UPPER)
elif c == self._uc_span:
self.span_case(i, _UPPER)
elif c == self._end:
# This is here just as a reminder that \E is ignored
pass
else:
self.result.append(t)
else:
self.result.append(t)
if len(self.result) > 1:
self.literal_slots.append(self._empty.join(self.result))
del self.result[:]
self.result.append(self._empty)
self.slot += 1
self._template = self._empty.join(self.literal_slots)
self.groups, self.literals = sre_parse.parse_template(
self._template, pattern)
def _subn(pattern, template, string, count=0):
# internal: pattern.subn implementation hook
if callable(template):
filter = template
else:
template = sre_parse.parse_template(template, pattern)
def filter(match, template=template):
return sre_parse.expand_template(template, match)
n = i = 0
s = []
append = s.append
c = pattern.scanner(string)
while not count or n < count:
m = c.search()
if not m:
break
b, e = m.span()
if i < b:
append(string[i:b])
append(filter(m))
i = e
n = n + 1
append(string[i:])
return _join(s, string[:0]), n
def __init__(self, pattern, replacement):
self.pattern = pattern
self.replacement = replacement
self._re = _compile(pattern)
groups, literals = parse_template(replacement, self._re)
# if a literal is None then it has a group, so make this
# easier to iterate over by making pairs of (literal, None) or
# (None, group)
group_map = dict(groups)
self._segments = [(literal, group_map.get(i))
for i, literal in enumerate(literals)]
# Get "trackable" capture groups; i.e., those that are
# transparent for characterization. For PET behavior, these
# must appear in strictly increasing order with no gaps
self._last_trackable = -1 # index of trackable segment, not group id
last_trackable_group = 0
for i, group in groups:
if group == last_trackable_group + 1:
self._last_trackable = i
last_trackable_group = group
else:
break
def parse_template(self, pattern):
"""Parse template."""
i = _util.StringIter((self._original.decode('latin-1') if self.binary else self._original))
iter(i)
self.result = [""]
while True:
try:
t = next(i)
if self.use_format and t in _CURLY_BRACKETS:
self.handle_format(t, i)
elif t == '\\':
try:
t = next(i)
self.reference(t, i)
except StopIteration:
self.result.append(t)
raise
else:
self.result.append(t)
except StopIteration:
break
if len(self.result) > 1:
self.literal_slots.append("".join(self.result))
del self.result[:]
self.result.append("")
self.slot += 1
if self.binary:
self._template = "".join(self.literal_slots).encode('latin-1')
else:
self._template = "".join(self.literal_slots)
self.groups, self.literals = _sre_parse.parse_template(self._template, pattern)
def parse_template(self, pattern):
"""Parse template."""
self.groups, self.literals = sre_parse.parse_template(self._template, pattern)
def update_event(self, inp=-1):
self.set_output_val(
0, sre_parse.parse_template(self.input(0), self.input(1)))
def _expand(pattern, match, template):
template = sre_parse.parse_template(template, pattern)
return sre_parse.expand_template(template, match)
#
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
return sre_parse.parse_template(repl, pattern)
def _compile_repl(repl, pattern):
# 内部:编译替换模式
return sre_parse.parse_template(repl, pattern)
def parse_template(self, pattern):
"""Parse template."""
self.groups, self.literals = sre_parse.parse_template(
self._template, pattern)
def _compile_repl(repl, pattern):
# internal: compile replacement pattern
return sre_parse.parse_template(repl, pattern)
def expand(self, template) :
template = sre_parse.parse_template(template, self.pattern)
return sre_parse.expand_template(template, self)
def _compile_repl(repl, pattern):
return sre_parse.parse_template(repl, pattern)
def expand(self, template):
template = sre_parse.parse_template(template, self.pattern)
return sre_parse.expand_template(template, self)
import string
def parse_template(self, pattern):
"""Parse template."""
i = ReplaceTokens(self._original, use_format=self.use_format)
iter(i)
self.result = [self._empty]
for t in i:
if len(t) > 1:
if self.use_format and t[0:1] == self._lc_bracket:
self.handle_format_group(t[1:-1].strip())
else:
c = t[1:]
first = c[0:1]
if first.isdigit() and (self.use_format or len(c) == 3):
value = int(c, 8)
if value > 0xFF:
if self.binary:
# Re fails on octal greater than 0o377 or 0xFF
raise ValueError(
"octal escape value outside of range 0-0o377!"
)
self.result.append(compat.uchr(value))
else:
self.result.append(
self.string_convert('\\%03o' % value))
elif not self.use_format and (c[0:1].isdigit()
or c[0:1] == self._group):
self.handle_group(t)
elif c == self._lc:
self.single_case(i, _LOWER)
elif c == self._lc_span:
self.span_case(i, _LOWER)
elif c == self._uc:
self.single_case(i, _UPPER)
elif c == self._uc_span:
self.span_case(i, _UPPER)
elif c == self._end:
# This is here just as a reminder that \E is ignored
pass
elif (not self.binary
and (first == self._unicode_narrow or
(not NARROW and first == self._unicode_wide))):
value = int(t[2:], 16)
if value <= 0xFF:
self.result.append('\\%03o' % value)
else:
self.result.append(compat.uchr(value))
elif first == self._hex:
self.result.append('\\%03o' % int(t[2:], 16))
else:
self.result.append(t)
else:
self.result.append(t)
if len(self.result) > 1:
self.literal_slots.append(self._empty.join(self.result))
del self.result[:]
self.result.append(self._empty)
self.slot += 1
self._template = self._empty.join(self.literal_slots)
self.groups, self.literals = sre_parse.parse_template(
self._template, pattern)
def _expand(pattern, match, template):
template = sre_parse.parse_template(template, pattern)
return sre_parse.expand_template(template, match)
def _expand(pattern, match, template):
# internal: match.expand implementation hook
template = sre_parse.parse_template(template, pattern)
return sre_parse.expand_template(template, match)
#
