Python sre_constants.BRANCH Examples
The following are 29
code examples of sre_constants.BRANCH().
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_constants
, 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: detect.py From dlint with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def mutually_inclusive_alternation_helper(node, nested_quantifier):
if not node.children:
return False
nested_quantifier = (
nested_quantifier
or (node.op in sre_parse._REPEATCODES and large_repeat(node))
)
inclusive_alternation = False
if node.op is sre_constants.BRANCH:
inclusive_alternation = inclusive_alternation_branch(node)
return any(
(nested_quantifier and inclusive_alternation)
or mutually_inclusive_alternation_helper(child, nested_quantifier)
for child in node.children
)
Example #3
| 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 #4
| 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 #5
| 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 #6
| 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 #7
| 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 #8
| 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 #9
| 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 #10
| 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 #11
| 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 #12
| 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 #13
| 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 #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 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 #18
| 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 #19
| 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 #20
| 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 #21
| 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 #22
| Source File: re_inverse.py From pycopia with Apache License 2.0 | 5 votes |
|
def _make_match_string_from_pattern(parsetree, makebad=False, groups=None):
collect = []
if groups is None:
groups = {}
for op, val in parsetree:
if op is sre_constants.LITERAL:
if makebad:
collect.append(chr((val ^ 4) & 0xFF)) # flip bit 4
if random.randint(0,9) == 0:
makebad = False # don't error everything
else:
collect.append(chr(val))
elif op is sre_constants.CATEGORY:
collect.append(get_substitute(val, makebad))
elif op is sre_constants.IN:
if val[0][0] is sre_constants.CATEGORY:
collect.append(_make_match_string_from_pattern(val, False, groups))
else:
collect.append(chr(random.choice(val)[1]))
elif op is sre_constants.BRANCH:
collect.append(_make_match_string_from_pattern(val[1][random.randint(0,1)], False, groups))
elif op is sre_constants.SUBPATTERN:
string = _make_match_string_from_pattern(val[1], False, groups)
groups[val[0]] = string
collect.append(string)
elif op is sre_constants.MAX_REPEAT or op is sre_constants.MIN_REPEAT:
for i in xrange(random.randint(val[0], min(val[1], 10))):
collect.append(_make_match_string_from_pattern(val[2], False, groups))
elif op is sre_constants.ANY:
collect.append(random.choice(ANYCHAR))
elif op is sre_constants.GROUPREF:
collect.append(groups[val])
elif op is sre_constants.AT:
pass # ignore anchors
else:
raise UnhandledOpError("Unhandled RE op: %r" % (op,))
if makebad: # in case it didn't get done yet.
collect.insert(random.randrange(0, len(collect)), random.choice(ascii.printable))
return "".join(collect)
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: __init__.py From hacking-tools with MIT License | 4 votes |
|
def __init__(self, pattern, flags=0, charset=CHARSET, max_count=None):
# If the RE module cannot compile it, we give up quickly
self.matcher = re.compile(r'(?:%s)\Z' % pattern, flags)
if not flags & re.DOTALL:
charset = ''.join(c for c in charset if c != '\n')
self.charset = charset
self.named_group_lookup = self.matcher.groupindex
if flags & re.IGNORECASE:
raise ParseError('Flag "i" not supported. https://github.com/google/sre_yield/issues/4')
elif flags & re.UNICODE:
raise ParseError('Flag "u" not supported. https://github.com/google/sre_yield/issues/3')
elif flags & re.LOCALE:
raise ParseError('Flag "l" not supported. https://github.com/google/sre_yield/issues/5')
if max_count is None:
self.max_count = MAX_REPEAT_COUNT
else:
self.max_count = max_count
self.has_groupref = False
# Configure the parser backends
self.backends = {
sre_constants.LITERAL: lambda y: [chr(y)],
sre_constants.RANGE: lambda l, h: [chr(c) for c in range(l, h+1)],
sre_constants.SUBPATTERN: self.maybe_save,
sre_constants.BRANCH: self.branch_values,
sre_constants.MIN_REPEAT: self.max_repeat_values,
sre_constants.MAX_REPEAT: self.max_repeat_values,
sre_constants.AT: self.empty_list,
sre_constants.ASSERT: self.empty_list,
sre_constants.ASSERT_NOT: self.empty_list,
sre_constants.ANY:
lambda _: self.in_values(((sre_constants.NEGATE,),)),
sre_constants.IN: self.in_values,
sre_constants.NOT_LITERAL: self.not_literal,
sre_constants.CATEGORY: self.category,
sre_constants.GROUPREF: self.groupref,
}
# Now build a generator that knows all possible patterns
self.raw = self.sub_values(sre_parse.parse(pattern, flags))
# Configure this class instance to know about that result
self.length = self.raw.__len__()
