FBRBMWCN

Function-Based Regex Builder Module Without a Clever Name

A tool to help you interactively develop regexes.

USAGE

compose()

Use compose() to join multiple patterns into one.

from rx import compose, group, match, maybe, then

prefix = compose(
    match('http'), group(match('s')), maybe(), then('://')
)

print(prefix) # 'http(s)?\:\/\/'

rx()

Use rx() to create a compiled regex object from a pattern.

from rx import compose, group, match, maybe, rx, then

prefix = compose(
    match('http'), group(match('s')), maybe(), then('://')
)

compiled_pattern = rx(prefix)

compiled_pattern == re.compile(r'http(s)?\:\/\/', re.UNICODE) # True

Example

In the US, one way a phone number can be expressed is as a sequence of:

• area code: three digits, possibly wrapped with parentheses
• separator: space(s), dash, dot, or non-existent
• prefix: three digits
• separator: space(s), dash, dot, or non-existent
• suffix: four digits

from rx import (compose, dot, digit, exactly_n_times,
                group, match, maybe, OR, rx, spaces, then)

area_code = compose(
    digit(), exactly_n_times(3),
    OR(),
    match('('), digit(), exactly_n_times(3), then(')')
)

print(area_code) # '\\d{3}|\\(\\d{3}\\)'

separator = compose(
    spaces(), OR(), dot(), OR(), match('-')
)

separator_maybe = compose(group(separator), maybe())

print(separator_maybe) # '(\\s+|\\.|\\-)?'

prefix = compose(digit(), exactly_n_times(3))

print(prefix) # '\\d{3}'

suffix = compose(digit(), exactly_n_times(4))

print(suffix) # '\\d{4}'

phone_number_pattern = compose(
    area_code,
    separator_maybe,
    prefix,
    separator_maybe,
    suffix
)

rx(phone_number_pattern) == re.compile('\\d{3}|\\(\\d{3}\\)(\\s+|\\.|\\-)?\\d{3}(\\s+|\\.|\\-)?\\d{4}') # True

PATTERN FUNCTIONS

Matching

Pattern Function	Example Input	Example Output
match(v)	match('Donuts+')	Donuts\\+
then(v) (alias of match(v))	then('Donuts+')	Donuts\\+

Character Classes

Pattern Function	Example Input	Example Output
any_of(v)	any_of('abcd')	[abcd]
anything_but(v)	anything_but('a backpack')	[^a\\ backpack]*
char_range(from, to)	char_range('A','Z')	A-Z
something_but(v)	something_but('nothing')	[^nothing]+

Groups

Pattern Function	Example Input	Example Output
group(*patterns)	group(match('p'), OR(), match('q'))	(p|q)
named_group(name, *patterns)	named_group('secure', match('https://'))	(?P<secure>https://)
non_capturing_group(*patterns)	non_capturing_group(match('http'))	(?:http)

Lookahead

Pattern Function	Example Input	Example Output
followed_by(v)	followed_by('...')	(?=\\.\\.\\.)
not_followed_by(v)	not_followed_by('...')	(?!\\.\\.\\.)

Lookbehind

Pattern Function	Example Input	Example Output
preceded_by(v)	preceded_by('...')	(?<=\\.\\.\\.)
not_preceded_by(v)	not_preceded_by('...')	(?<!\\.\\.\\.)

Modifiers

Pattern Function	Output
between_n_and_m_times(n,m)	{n,m}
between_n_and_m_times_lazy(n,m)	{n,m}?
maybe()	?
one_or_more_times()	+
OR()	|
zero_or_more_times()	*

Metacharacters

Pattern Function	Output
digit()	\d
end_of_line()	$
space()	\s
spaces()	\s+
start_of_line()	^
tab()	\t
word()	\w+
word_boundary()	\b

Common Patterns

Pattern Function	Output
anything()	.*
dot()	\\.
linebreak()	(?:(?:\n)|(?:\r\n))
something()	.+