Python sre_parse.SubPattern() Examples
The following are 30
code examples of sre_parse.SubPattern().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
sre_parse
, or try the search function
.
.
Example #1
| Source File: re.py From Imogen with MIT License | 7 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
if isinstance(flags, RegexFlag):
flags = flags.value
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, 0, 0, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #2
| Source File: __init__.py From hacking-tools with MIT License | 6 votes |
|
def sub_values(self, parsed):
"""This knows how to convert one piece of parsed pattern."""
# If this is a subpattern object, we just want its data
if isinstance(parsed, sre_parse.SubPattern):
parsed = parsed.data
# A list indicates sequential elements of a string
if isinstance(parsed, list):
elements = [self.sub_values(p) for p in parsed]
return CombinatoricsSequence(*elements)
# If not a list, a tuple represents a specific match type
if isinstance(parsed, tuple) and parsed:
matcher, arguments = parsed
if not isinstance(arguments, tuple):
arguments = (arguments,)
if matcher in self.backends:
return self.backends[matcher](*arguments)
# No idea what to do here
raise ParseError(repr(parsed))
Example #3
| Source File: __init__.py From sre_yield with Apache License 2.0 | 6 votes |
|
def sub_values(self, parsed):
"""This knows how to convert one piece of parsed pattern."""
# If this is a subpattern object, we just want its data
if isinstance(parsed, sre_parse.SubPattern):
parsed = parsed.data
# A list indicates sequential elements of a string
if isinstance(parsed, list):
elements = [self.sub_values(p) for p in parsed]
return CombinatoricsSequence(*elements)
# If not a list, a tuple represents a specific match type
if isinstance(parsed, tuple) and parsed:
matcher, arguments = parsed
if not isinstance(arguments, tuple):
arguments = (arguments,)
if matcher in self.backends:
if not self.relaxed:
self.check_anchor_state(matcher, arguments)
return self.backends[matcher](*arguments)
# No idea what to do here
raise ParseError(repr(parsed)) # pragma: no cover
Example #4
| Source File: re.py From GraphicDesignPatternByPython with MIT License | 6 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
if isinstance(flags, RegexFlag):
flags = flags.value
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, 0, 0, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #5
| Source File: re.py From PokemonGo-DesktopMap with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #6
| Source File: re.py From CTFCrackTools-V2 with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #7
| Source File: re.py From CTFCrackTools-V2 with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #8
| Source File: detect.py From dlint with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def build_op_tree(node, subpattern):
for op, av in subpattern.data:
args = []
subpatterns = []
if op is sre_constants.BRANCH:
for a in av[1]:
subpatterns.append(a)
elif op is sre_constants.GROUPREF_EXISTS:
condgroup, item_yes, item_no = av
subpatterns.append(item_yes)
if item_no:
subpatterns.append(item_no)
elif isinstance(av, (tuple, list)):
for a in av:
if isinstance(a, sre_parse.SubPattern):
subpatterns.append(a)
else:
args.append(a)
else:
args.append(av)
new_node = OpNode(op, tuple(args))
for sp in subpatterns:
build_op_tree(new_node, sp)
node.children.append(new_node)
Example #9
| Source File: re.py From syntheticmass with Apache License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #10
| Source File: re.py From medicare-demo with Apache License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #11
| Source File: re.py From CTFCrackTools with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #12
| Source File: re.py From Project-New-Reign---Nemesis-Main with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #13
| Source File: re.py From jawfish with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #14
| Source File: re.py From PhonePi_SampleServer with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #15
| Source File: re.py From Splunking-Crime with GNU Affero General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #16
| Source File: compat.py From Splunking-Crime with GNU Affero General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #17
| Source File: re.py From CTFCrackTools with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #18
| Source File: re.py From ImageFusion with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #19
| Source File: re.py From ironpython3 with Apache License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #20
| Source File: re.py From telegram-robot-rss with Mozilla Public License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #21
| Source File: re.py From scylla with Apache License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #22
| Source File: re.py From Fluid-Designer with GNU General Public License v3.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #23
| Source File: re.py From pmatic with GNU General Public License v2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #24
| Source File: re.py From Safejumper-for-Desktop with GNU General Public License v2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #25
| Source File: re.py From oss-ftp with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #26
| Source File: re.py From BinderFilter with MIT License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #27
| Source File: re.py From kobo-predict with BSD 2-Clause "Simplified" License | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #28
| Source File: re.py From ironpython2 with Apache License 2.0 | 5 votes |
|
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
]))
s.groups = len(p)+1
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
Example #29
| Source File: regexp.py From razzy-spinner with GNU General Public License v3.0 | 5 votes |
|
def _compile(regexp):
parsed = sre_parse.parse(regexp)
parsed = _remove_group_identifiers(parsed)
# Add grouping parentheses around the regexp; this will allow
# us to access the material that was split on.
# Need to set the Pattern to expect a single group
pattern = sre_parse.Pattern()
pattern.groups += 1
grouped = sre_parse.SubPattern(pattern)
grouped.append((sre_constants.SUBPATTERN, (1, parsed)))
return sre_compile.compile(grouped, re.UNICODE | re.MULTILINE | re.DOTALL)
Example #30
| Source File: regexp.py From razzy-spinner with GNU General Public License v3.0 | 4 votes |
|
def _remove_group_identifiers(parsed_re):
"""
Modifies the given parsed regular expression, replacing all groupings
(as indicated by parenthesis in the regular expression string) with
non-grouping variants (indicated with '(?:...)'). This works on the
output of sre_parse.parse, modifing the group indentifier in
SUBPATTERN structures to None.
@param parsed_re: the output of sre_parse.parse(string)
@type parsed_re: C{SubPattern}
"""
if isinstance(parsed_re, sre_parse.SubPattern):
# If it's a SubPattern, replace each item with its processed
# equivalent. These classes are mutable, so that in-place
# modification is allowed.
for i in range(len(parsed_re)):
parsed_re[i] = _remove_group_identifiers(parsed_re[i])
return parsed_re
elif isinstance(parsed_re, list) or isinstance(parsed_re, tuple):
# Otherwise, if it's a sequence, check for the tell-tale
# SUBPATTERN item and repair the sub item if needed
to_process = list(parsed_re)
if to_process[0] == sre_constants.SUBPATTERN:
# replace next int with None
sub_item = list(to_process[1])
sub_item[0] = None
to_process[1] = tuple(sub_item)
# Process each item, in the case of nested SUBPATTERNS
processed = map(_remove_group_identifiers, to_process)
# Coerce back into the original type
if isinstance(parsed_re, list):
return processed
else:
return tuple(processed)
else:
# Don't need to do anything to other types
return parsed_re
# Replace any grouping parentheses with non-grouping ones. We
# need to do this, because the list returned by re.sub will
# contain an element corresponding to every set of grouping
# parentheses. We must not touch escaped parentheses, and
# need to handle the case of escaped escapes (e.g. "\\(").
# We also need to handle nested parentheses, which means our
# regexp contexts must be zero-width. There are also issues with
# parenthesis appearing in bracketed contexts, hence we've
# operated on the intermediate parse structure from sre_parse.
