Skip to main content

Alternative regular expression module, to replace re.

Project description

Introduction

This regex implementation is backwards-compatible with the standard ‘re’ module, but offers additional functionality.

Note

The re module’s behaviour with zero-width matches changed in Python 3.7, and this module will follow that behaviour when compiled for Python 3.7.

Old vs new behaviour

In order to be compatible with the re module, this module has 2 behaviours:

  • Version 0 behaviour (old behaviour, compatible with the re module):

    Please note that the re module’s behaviour may change over time, and I’ll endeavour to match that behaviour in version 0.

    • Indicated by the VERSION0 or V0 flag, or (?V0) in the pattern.

    • Zero-width matches are not handled correctly in the re module before Python 3.7. The behaviour in those earlier versions is:

      • .split won’t split a string at a zero-width match.

      • .sub will advance by one character after a zero-width match.

    • Inline flags apply to the entire pattern, and they can’t be turned off.

    • Only simple sets are supported.

    • Case-insensitive matches in Unicode use simple case-folding by default.

  • Version 1 behaviour (new behaviour, possibly different from the re module):

    • Indicated by the VERSION1 or V1 flag, or (?V1) in the pattern.

    • Zero-width matches are handled correctly.

    • Inline flags apply to the end of the group or pattern, and they can be turned off.

    • Nested sets and set operations are supported.

    • Case-insensitive matches in Unicode use full case-folding by default.

If no version is specified, the regex module will default to regex.DEFAULT_VERSION.

Case-insensitive matches in Unicode

The regex module supports both simple and full case-folding for case-insensitive matches in Unicode. Use of full case-folding can be turned on using the FULLCASE or F flag, or (?f) in the pattern. Please note that this flag affects how the IGNORECASE flag works; the FULLCASE flag itself does not turn on case-insensitive matching.

In the version 0 behaviour, the flag is off by default.

In the version 1 behaviour, the flag is on by default.

Nested sets and set operations

It’s not possible to support both simple sets, as used in the re module, and nested sets at the same time because of a difference in the meaning of an unescaped "[" in a set.

For example, the pattern [[a-z]--[aeiou]] is treated in the version 0 behaviour (simple sets, compatible with the re module) as:

  • Set containing “[” and the letters “a” to “z”

  • Literal “–”

  • Set containing letters “a”, “e”, “i”, “o”, “u”

  • Literal “]”

but in the version 1 behaviour (nested sets, enhanced behaviour) as:

  • Set which is:

    • Set containing the letters “a” to “z”

  • but excluding:

    • Set containing the letters “a”, “e”, “i”, “o”, “u”

Version 0 behaviour: only simple sets are supported.

Version 1 behaviour: nested sets and set operations are supported.

Flags

There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.

The scoped flags are: FULLCASE, IGNORECASE, MULTILINE, DOTALL, VERBOSE, WORD.

The global flags are: ASCII, BESTMATCH, ENHANCEMATCH, LOCALE, POSIX, REVERSE, UNICODE, VERSION0, VERSION1.

If neither the ASCII, LOCALE nor UNICODE flag is specified, it will default to UNICODE if the regex pattern is a Unicode string and ASCII if it’s a bytestring.

The ENHANCEMATCH flag makes fuzzy matching attempt to improve the fit of the next match that it finds.

The BESTMATCH flag makes fuzzy matching search for the best match instead of the next match.

Notes on named capture groups

All capture groups have a group number, starting from 1.

Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.

The same name can be used by more than one group, with later captures ‘overwriting’ earlier captures. All of the captures of the group will be available from the captures method of the match object.

Group numbers will be reused across different branches of a branch reset, eg. (?|(first)|(second)) has only group 1. If capture groups have different group names then they will, of course, have different group numbers, eg. (?|(?P<foo>first)|(?P<bar>second)) has group 1 (“foo”) and group 2 (“bar”).

In the regex (\s+)(?|(?P<foo>[A-Z]+)|(\w+) (?P<foo>[0-9]+) there are 2 groups:

  • (\s+) is group 1.

  • (?P<foo>[A-Z]+) is group 2, also called “foo”.

  • (\w+) is group 2 because of the branch reset.

  • (?P<foo>[0-9]+) is group 2 because it’s called “foo”.

If you want to prevent (\w+) from being group 2, you need to name it (different name, different group number).

Multithreading

The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument concurrent=True. The behaviour is undefined if the string changes during matching, so use it only when it is guaranteed that that won’t happen.

Unicode

This module supports Unicode 12.1.0.

Full Unicode case-folding is supported.

Additional features

The issue numbers relate to the Python bug tracker, except where listed as “Hg issue”.

Added support for lookaround in conditional pattern (Hg issue 163)

The test of a conditional pattern can now be a lookaround.

Examples:

>>> regex.match(r'(?(?=\d)\d+|\w+)', '123abc')
<regex.Match object; span=(0, 3), match='123'>
>>> regex.match(r'(?(?=\d)\d+|\w+)', 'abc123')
<regex.Match object; span=(0, 6), match='abc123'>

This is not quite the same as putting a lookaround in the first branch of a pair of alternatives.

Examples:

>>> print(regex.match(r'(?:(?=\d)\d+\b|\w+)', '123abc'))
<regex.Match object; span=(0, 6), match='123abc'>
>>> print(regex.match(r'(?(?=\d)\d+\b|\w+)', '123abc'))
None

In the first example, the lookaround matched, but the remainder of the first branch failed to match, and so the second branch was attempted, whereas in the second example, the lookaround matched, and the first branch failed to match, but the second branch was not attempted.

Added POSIX matching (leftmost longest) (Hg issue 150)

The POSIX standard for regex is to return the leftmost longest match. This can be turned on using the POSIX flag ((?p)).

Examples:

>>> # Normal matching.
>>> regex.search(r'Mr|Mrs', 'Mrs')
<regex.Match object; span=(0, 2), match='Mr'>
>>> regex.search(r'one(self)?(selfsufficient)?', 'oneselfsufficient')
<regex.Match object; span=(0, 7), match='oneself'>
>>> # POSIX matching.
>>> regex.search(r'(?p)Mr|Mrs', 'Mrs')
<regex.Match object; span=(0, 3), match='Mrs'>
>>> regex.search(r'(?p)one(self)?(selfsufficient)?', 'oneselfsufficient')
<regex.Match object; span=(0, 17), match='oneselfsufficient'>

Note that it will take longer to find matches because when it finds a match at a certain position, it won’t return that immediately, but will keep looking to see if there’s another longer match there.

Added (?(DEFINE)...) (Hg issue 152)

If there’s no group called “DEFINE”, then … will be ignored, but any group definitions within it will be available.

Examples:

>>> regex.search(r'(?(DEFINE)(?P<quant>\d+)(?P<item>\w+))(?&quant) (?&item)', '5 elephants')
<regex.Match object; span=(0, 11), match='5 elephants'>

Added (*PRUNE), (*SKIP) and (*FAIL) (Hg issue 153)

(*PRUNE) discards the backtracking info up to that point. When used in an atomic group or a lookaround, it won’t affect the enclosing pattern.

(*SKIP) is similar to (*PRUNE), except that it also sets where in the text the next attempt to match will start. When used in an atomic group or a lookaround, it won’t affect the enclosing pattern.

(*FAIL) causes immediate backtracking. (*F) is a permitted abbreviation.

Added \K (Hg issue 151)

Keeps the part of the entire match after the position where \K occurred; the part before it is discarded.

It does not affect what capture groups return.

Examples:

>>> m = regex.search(r'(\w\w\K\w\w\w)', 'abcdef')
>>> m[0]
'cde'
>>> m[1]
'abcde'
>>>
>>> m = regex.search(r'(?r)(\w\w\K\w\w\w)', 'abcdef')
>>> m[0]
'bc'
>>> m[1]
'bcdef'

Added capture subscripting for expandf and subf/subfn (Hg issue 133)

You can now use subscripting to get the captures of a repeated capture group.

Examples:

>>> m = regex.match(r"(\w)+", "abc")
>>> m.expandf("{1}")
'c'
>>> m.expandf("{1[0]} {1[1]} {1[2]}")
'a b c'
>>> m.expandf("{1[-1]} {1[-2]} {1[-3]}")
'c b a'
>>>
>>> m = regex.match(r"(?P<letter>\w)+", "abc")
>>> m.expandf("{letter}")
'c'
>>> m.expandf("{letter[0]} {letter[1]} {letter[2]}")
'a b c'
>>> m.expandf("{letter[-1]} {letter[-2]} {letter[-3]}")
'c b a'

Added support for referring to a group by number using (?P=...).

This is in addition to the existing \g<...>.

Fixed the handling of locale-sensitive regexes.

The LOCALE flag is intended for legacy code and has limited support. You’re still recommended to use Unicode instead.

Added partial matches (Hg issue 102)

A partial match is one that matches up to the end of string, but that string has been truncated and you want to know whether a complete match could be possible if the string had not been truncated.

Partial matches are supported by match, search, fullmatch and finditer with the partial keyword argument.

Match objects have a partial attribute, which is True if it’s a partial match.

For example, if you wanted a user to enter a 4-digit number and check it character by character as it was being entered:

>>> pattern = regex.compile(r'\d{4}')

>>> # Initially, nothing has been entered:
>>> print(pattern.fullmatch('', partial=True))
<regex.Match object; span=(0, 0), match='', partial=True>

>>> # An empty string is OK, but it's only a partial match.
>>> # The user enters a letter:
>>> print(pattern.fullmatch('a', partial=True))
None
>>> # It'll never match.

>>> # The user deletes that and enters a digit:
>>> print(pattern.fullmatch('1', partial=True))
<regex.Match object; span=(0, 1), match='1', partial=True>
>>> # It matches this far, but it's only a partial match.

>>> # The user enters 2 more digits:
>>> print(pattern.fullmatch('123', partial=True))
<regex.Match object; span=(0, 3), match='123', partial=True>
>>> # It matches this far, but it's only a partial match.

>>> # The user enters another digit:
>>> print(pattern.fullmatch('1234', partial=True))
<regex.Match object; span=(0, 4), match='1234'>
>>> # It's a complete match.

>>> # If the user enters another digit:
>>> print(pattern.fullmatch('12345', partial=True))
None
>>> # It's no longer a match.

>>> # This is a partial match:
>>> pattern.match('123', partial=True).partial
True

>>> # This is a complete match:
>>> pattern.match('1233', partial=True).partial
False

* operator not working correctly with sub() (Hg issue 106)

Sometimes it’s not clear how zero-width matches should be handled. For example, should .* match 0 characters directly after matching >0 characters?

Examples:

# Python 3.7 and later
>>> regex.sub('.*', 'x', 'test')
'xx'
>>> regex.sub('.*?', '|', 'test')
'|||||||||'

# Python 3.6 and earlier
>>> regex.sub('(?V0).*', 'x', 'test')
'x'
>>> regex.sub('(?V1).*', 'x', 'test')
'xx'
>>> regex.sub('(?V0).*?', '|', 'test')
'|t|e|s|t|'
>>> regex.sub('(?V1).*?', '|', 'test')
'|||||||||'

Added capturesdict (Hg issue 86)

capturesdict is a combination of groupdict and captures:

groupdict returns a dict of the named groups and the last capture of those groups.

captures returns a list of all the captures of a group

capturesdict returns a dict of the named groups and lists of all the captures of those groups.

Examples:

>>> m = regex.match(r"(?:(?P<word>\w+) (?P<digits>\d+)\n)+", "one 1\ntwo 2\nthree 3\n")
>>> m.groupdict()
{'word': 'three', 'digits': '3'}
>>> m.captures("word")
['one', 'two', 'three']
>>> m.captures("digits")
['1', '2', '3']
>>> m.capturesdict()
{'word': ['one', 'two', 'three'], 'digits': ['1', '2', '3']}

Allow duplicate names of groups (Hg issue 87)

Group names can now be duplicated.

Examples:

>>> # With optional groups:
>>>
>>> # Both groups capture, the second capture 'overwriting' the first.
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['first', 'second']
>>> # Only the second group captures.
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", " or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['second']
>>> # Only the first group captures.
>>> m = regex.match(r"(?P<item>\w+)? or (?P<item>\w+)?", "first or ")
>>> m.group("item")
'first'
>>> m.captures("item")
['first']
>>>
>>> # With mandatory groups:
>>>
>>> # Both groups capture, the second capture 'overwriting' the first.
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)?", "first or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['first', 'second']
>>> # Again, both groups capture, the second capture 'overwriting' the first.
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", " or second")
>>> m.group("item")
'second'
>>> m.captures("item")
['', 'second']
>>> # And yet again, both groups capture, the second capture 'overwriting' the first.
>>> m = regex.match(r"(?P<item>\w*) or (?P<item>\w*)", "first or ")
>>> m.group("item")
''
>>> m.captures("item")
['first', '']

Added fullmatch (issue #16203)

fullmatch behaves like match, except that it must match all of the string.

Examples:

>>> print(regex.fullmatch(r"abc", "abc").span())
(0, 3)
>>> print(regex.fullmatch(r"abc", "abcx"))
None
>>> print(regex.fullmatch(r"abc", "abcx", endpos=3).span())
(0, 3)
>>> print(regex.fullmatch(r"abc", "xabcy", pos=1, endpos=4).span())
(1, 4)
>>>
>>> regex.match(r"a.*?", "abcd").group(0)
'a'
>>> regex.fullmatch(r"a.*?", "abcd").group(0)
'abcd'

Added subf and subfn

subf and subfn are alternatives to sub and subn respectively. When passed a replacement string, they treat it as a format string.

Examples:

>>> regex.subf(r"(\w+) (\w+)", "{0} => {2} {1}", "foo bar")
'foo bar => bar foo'
>>> regex.subf(r"(?P<word1>\w+) (?P<word2>\w+)", "{word2} {word1}", "foo bar")
'bar foo'

Added expandf to match object

expandf is an alternative to expand. When passed a replacement string, it treats it as a format string.

Examples:

>>> m = regex.match(r"(\w+) (\w+)", "foo bar")
>>> m.expandf("{0} => {2} {1}")
'foo bar => bar foo'
>>>
>>> m = regex.match(r"(?P<word1>\w+) (?P<word2>\w+)", "foo bar")
>>> m.expandf("{word2} {word1}")
'bar foo'

Detach searched string

A match object contains a reference to the string that was searched, via its string attribute. The detach_string method will ‘detach’ that string, making it available for garbage collection, which might save valuable memory if that string is very large.

Example:

>>> m = regex.search(r"\w+", "Hello world")
>>> print(m.group())
Hello
>>> print(m.string)
Hello world
>>> m.detach_string()
>>> print(m.group())
Hello
>>> print(m.string)
None

Recursive patterns (Hg issue 27)

Recursive and repeated patterns are supported.

(?R) or (?0) tries to match the entire regex recursively. (?1), (?2), etc, try to match the relevant capture group.

(?&name) tries to match the named capture group.

Examples:

>>> regex.match(r"(Tarzan|Jane) loves (?1)", "Tarzan loves Jane").groups()
('Tarzan',)
>>> regex.match(r"(Tarzan|Jane) loves (?1)", "Jane loves Tarzan").groups()
('Jane',)

>>> m = regex.search(r"(\w)(?:(?R)|(\w?))\1", "kayak")
>>> m.group(0, 1, 2)
('kayak', 'k', None)

The first two examples show how the subpattern within the capture group is reused, but is _not_ itself a capture group. In other words, "(Tarzan|Jane) loves (?1)" is equivalent to "(Tarzan|Jane) loves (?:Tarzan|Jane)".

It’s possible to backtrack into a recursed or repeated group.

You can’t call a group if there is more than one group with that group name or group number ("ambiguous group reference").

The alternative forms (?P>name) and (?P&name) are also supported.

Full Unicode case-folding is supported.

In version 1 behaviour, the regex module uses full case-folding when performing case-insensitive matches in Unicode.

Examples (in Python 3):

>>> regex.match(r"(?iV1)strasse", "stra\N{LATIN SMALL LETTER SHARP S}e").span()
(0, 6)
>>> regex.match(r"(?iV1)stra\N{LATIN SMALL LETTER SHARP S}e", "STRASSE").span()
(0, 7)

In version 0 behaviour, it uses simple case-folding for backward compatibility with the re module.

Approximate “fuzzy” matching (Hg issue 12, Hg issue 41, Hg issue 109)

Regex usually attempts an exact match, but sometimes an approximate, or “fuzzy”, match is needed, for those cases where the text being searched may contain errors in the form of inserted, deleted or substituted characters.

A fuzzy regex specifies which types of errors are permitted, and, optionally, either the minimum and maximum or only the maximum permitted number of each type. (You cannot specify only a minimum.)

The 3 types of error are:

  • Insertion, indicated by “i”

  • Deletion, indicated by “d”

  • Substitution, indicated by “s”

In addition, “e” indicates any type of error.

The fuzziness of a regex item is specified between “{” and “}” after the item.

Examples:

  • foo match “foo” exactly

  • (?:foo){i} match “foo”, permitting insertions

  • (?:foo){d} match “foo”, permitting deletions

  • (?:foo){s} match “foo”, permitting substitutions

  • (?:foo){i,s} match “foo”, permitting insertions and substitutions

  • (?:foo){e} match “foo”, permitting errors

If a certain type of error is specified, then any type not specified will not be permitted.

In the following examples I’ll omit the item and write only the fuzziness:

  • {d<=3} permit at most 3 deletions, but no other types

  • {i<=1,s<=2} permit at most 1 insertion and at most 2 substitutions, but no deletions

  • {1<=e<=3} permit at least 1 and at most 3 errors

  • {i<=2,d<=2,e<=3} permit at most 2 insertions, at most 2 deletions, at most 3 errors in total, but no substitutions

It’s also possible to state the costs of each type of error and the maximum permitted total cost.

Examples:

  • {2i+2d+1s<=4} each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4

  • {i<=1,d<=1,s<=1,2i+2d+1s<=4} at most 1 insertion, at most 1 deletion, at most 1 substitution; each insertion costs 2, each deletion costs 2, each substitution costs 1, the total cost must not exceed 4

You can also use “<” instead of “<=” if you want an exclusive minimum or maximum.

You can add a test to perform on a character that’s substituted or inserted.

Examples:

  • {s<=2:[a-z]} at most 2 substitutions, which must be in the character set [a-z].

  • {s<=2,i<=3:\d} at most 2 substitutions, at most 3 insertions, which must be digits.

By default, fuzzy matching searches for the first match that meets the given constraints. The ENHANCEMATCH flag will cause it to attempt to improve the fit (i.e. reduce the number of errors) of the match that it has found.

The BESTMATCH flag will make it search for the best match instead.

Further examples to note:

  • regex.search("(dog){e}", "cat and dog")[1] returns "cat" because that matches "dog" with 3 errors (an unlimited number of errors is permitted).

  • regex.search("(dog){e<=1}", "cat and dog")[1] returns " dog" (with a leading space) because that matches "dog" with 1 error, which is within the limit.

  • regex.search("(?e)(dog){e<=1}", "cat and dog")[1] returns "dog" (without a leading space) because the fuzzy search matches " dog" with 1 error, which is within the limit, and the (?e) then it attempts a better fit.

In the first two examples there are perfect matches later in the string, but in neither case is it the first possible match.

The match object has an attribute fuzzy_counts which gives the total number of substitutions, insertions and deletions.

>>> # A 'raw' fuzzy match:
>>> regex.fullmatch(r"(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 1)
>>> # 0 substitutions, 0 insertions, 1 deletion.

>>> # A better match might be possible if the ENHANCEMATCH flag used:
>>> regex.fullmatch(r"(?e)(?:cats|cat){e<=1}", "cat").fuzzy_counts
(0, 0, 0)
>>> # 0 substitutions, 0 insertions, 0 deletions.

The match object also has an attribute fuzzy_changes which gives a tuple of the positions of the substitutions, insertions and deletions.

>>> m = regex.search('(fuu){i<=2,d<=2,e<=5}', 'anaconda foo bar')
>>> m
<regex.Match object; span=(7, 10), match='a f', fuzzy_counts=(0, 2, 2)>
>>> m.fuzzy_changes
([], [7, 8], [10, 11])

What this means is that if the matched part of the string had been:

'anacondfuuoo bar'

it would’ve been an exact match.

However, there were insertions at positions 7 and 8:

'anaconda fuuoo bar'
        ^^

and deletions at positions 10 and 11:

'anaconda f~~oo bar'
           ^^

So the actual string was:

'anaconda foo bar'

Named lists (Hg issue 11)

\L<name>

There are occasions where you may want to include a list (actually, a set) of options in a regex.

One way is to build the pattern like this:

>>> p = regex.compile(r"first|second|third|fourth|fifth")

but if the list is large, parsing the resulting regex can take considerable time, and care must also be taken that the strings are properly escaped and properly ordered, for example, “cats” before “cat”.

The new alternative is to use a named list:

>>> option_set = ["first", "second", "third", "fourth", "fifth"]
>>> p = regex.compile(r"\L<options>", options=option_set)

The order of the items is irrelevant, they are treated as a set. The named lists are available as the .named_lists attribute of the pattern object :

>>> print(p.named_lists)
# Python 3
{'options': frozenset({'fifth', 'first', 'fourth', 'second', 'third'})}
# Python 2
{'options': frozenset(['fifth', 'fourth', 'second', 'third', 'first'])}

If there are any unused keyword arguments, ValueError will be raised unless you tell it otherwise:

>>> option_set = ["first", "second", "third", "fourth", "fifth"]
>>> p = regex.compile(r"\L<options>", options=option_set, other_options=[])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python37\lib\site-packages\regex\regex.py", line 348, in compile
    return _compile(pattern, flags, ignore_unused, kwargs)
  File "C:\Python37\lib\site-packages\regex\regex.py", line 585, in _compile
    raise ValueError('unused keyword argument {!a}'.format(any_one))
ValueError: unused keyword argument 'other_options'
>>> p = regex.compile(r"\L<options>", options=option_set, other_options=[], ignore_unused=True)
>>>

Start and end of word

\m matches at the start of a word.

\M matches at the end of a word.

Compare with \b, which matches at the start or end of a word.

Unicode line separators

Normally the only line separator is \n (\x0A), but if the WORD flag is turned on then the line separators are \x0D\x0A, \x0A, \x0B, \x0C and \x0D, plus \x85, \u2028 and \u2029 when working with Unicode.

This affects the regex dot ".", which, with the DOTALL flag turned off, matches any character except a line separator. It also affects the line anchors ^ and $ (in multiline mode).

Set operators

Version 1 behaviour only

Set operators have been added, and a set [...] can include nested sets.

The operators, in order of increasing precedence, are:

  • || for union (“x||y” means “x or y”)

  • ~~ (double tilde) for symmetric difference (“x~~y” means “x or y, but not both”)

  • && for intersection (“x&&y” means “x and y”)

  • -- (double dash) for difference (“x–y” means “x but not y”)

Implicit union, ie, simple juxtaposition like in [ab], has the highest precedence. Thus, [ab&&cd] is the same as [[a||b]&&[c||d]].

Examples:

  • [ab] # Set containing ‘a’ and ‘b’

  • [a-z] # Set containing ‘a’ .. ‘z’

  • [[a-z]--[qw]] # Set containing ‘a’ .. ‘z’, but not ‘q’ or ‘w’

  • [a-z--qw] # Same as above

  • [\p{L}--QW] # Set containing all letters except ‘Q’ and ‘W’

  • [\p{N}--[0-9]] # Set containing all numbers except ‘0’ .. ‘9’

  • [\p{ASCII}&&\p{Letter}] # Set containing all characters which are ASCII and letter

regex.escape (issue #2650)

regex.escape has an additional keyword parameter special_only. When True, only ‘special’ regex characters, such as ‘?’, are escaped.

Examples:

>>> regex.escape("foo!?", special_only=False)
'foo\\!\\?'
>>> regex.escape("foo!?", special_only=True)
'foo!\\?'

regex.escape (Hg issue 249)

regex.escape has an additional keyword parameter literal_spaces. When True, spaces are not escaped.

Examples:

>>> regex.escape("foo bar!?", literal_spaces=False)
'foo\\ bar!\\?'
>>> regex.escape("foo bar!?", literal_spaces=True)
'foo bar!\\?'

Repeated captures (issue #7132)

A match object has additional methods which return information on all the successful matches of a repeated capture group. These methods are:

  • matchobject.captures([group1, ...])

    • Returns a list of the strings matched in a group or groups. Compare with matchobject.group([group1, ...]).

  • matchobject.starts([group])

    • Returns a list of the start positions. Compare with matchobject.start([group]).

  • matchobject.ends([group])

    • Returns a list of the end positions. Compare with matchobject.end([group]).

  • matchobject.spans([group])

    • Returns a list of the spans. Compare with matchobject.span([group]).

Examples:

>>> m = regex.search(r"(\w{3})+", "123456789")
>>> m.group(1)
'789'
>>> m.captures(1)
['123', '456', '789']
>>> m.start(1)
6
>>> m.starts(1)
[0, 3, 6]
>>> m.end(1)
9
>>> m.ends(1)
[3, 6, 9]
>>> m.span(1)
(6, 9)
>>> m.spans(1)
[(0, 3), (3, 6), (6, 9)]

Atomic grouping (issue #433030)

(?>...)

If the following pattern subsequently fails, then the subpattern as a whole will fail.

Possessive quantifiers.

(?:...)?+ ; (?:...)*+ ; (?:...)++ ; (?:...){min,max}+

The subpattern is matched up to ‘max’ times. If the following pattern subsequently fails, then all of the repeated subpatterns will fail as a whole. For example, (?:...)++ is equivalent to (?>(?:...)+).

Scoped flags (issue #433028)

(?flags-flags:...)

The flags will apply only to the subpattern. Flags can be turned on or off.

Definition of ‘word’ character (issue #1693050)

The definition of a ‘word’ character has been expanded for Unicode. It now conforms to the Unicode specification at http://www.unicode.org/reports/tr29/.

Variable-length lookbehind

A lookbehind can match a variable-length string.

Flags argument for regex.split, regex.sub and regex.subn (issue #3482)

regex.split, regex.sub and regex.subn support a ‘flags’ argument.

Pos and endpos arguments for regex.sub and regex.subn

regex.sub and regex.subn support ‘pos’ and ‘endpos’ arguments.

‘Overlapped’ argument for regex.findall and regex.finditer

regex.findall and regex.finditer support an ‘overlapped’ flag which permits overlapped matches.

Splititer

regex.splititer has been added. It’s a generator equivalent of regex.split.

Subscripting for groups

A match object accepts access to the captured groups via subscripting and slicing:

>>> m = regex.search(r"(?P<before>.*?)(?P<num>\d+)(?P<after>.*)", "pqr123stu")
>>> print(m["before"])
pqr
>>> print(len(m))
4
>>> print(m[:])
('pqr123stu', 'pqr', '123', 'stu')

Named groups

Groups can be named with (?<name>...) as well as the current (?P<name>...).

Group references

Groups can be referenced within a pattern with \g<name>. This also allows there to be more than 99 groups.

Named characters

\N{name}

Named characters are supported. (Note: only those known by Python’s Unicode database are supported.)

Unicode codepoint properties, including scripts and blocks

\p{property=value}; \P{property=value}; \p{value} ; \P{value}

Many Unicode properties are supported, including blocks and scripts. \p{property=value} or \p{property:value} matches a character whose property property has value value. The inverse of \p{property=value} is \P{property=value} or \p{^property=value}.

If the short form \p{value} is used, the properties are checked in the order: General_Category, Script, Block, binary property:

  • Latin, the ‘Latin’ script (Script=Latin).

  • BasicLatin, the ‘BasicLatin’ block (Block=BasicLatin).

  • Alphabetic, the ‘Alphabetic’ binary property (Alphabetic=Yes).

A short form starting with Is indicates a script or binary property:

  • IsLatin, the ‘Latin’ script (Script=Latin).

  • IsAlphabetic, the ‘Alphabetic’ binary property (Alphabetic=Yes).

A short form starting with In indicates a block property:

  • InBasicLatin, the ‘BasicLatin’ block (Block=BasicLatin).

POSIX character classes

[[:alpha:]]; [[:^alpha:]]

POSIX character classes are supported. These are normally treated as an alternative form of \p{...}.

The exceptions are alnum, digit, punct and xdigit, whose definitions are different from those of Unicode.

[[:alnum:]] is equivalent to \p{posix_alnum}.

[[:digit:]] is equivalent to \p{posix_digit}.

[[:punct:]] is equivalent to \p{posix_punct}.

[[:xdigit:]] is equivalent to \p{posix_xdigit}.

Search anchor

\G

A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:

>>> regex.findall(r"\w{2}", "abcd ef")
['ab', 'cd', 'ef']
>>> regex.findall(r"\G\w{2}", "abcd ef")
['ab', 'cd']
  • The search starts at position 0 and matches 2 letters ‘ab’.

  • The search continues at position 2 and matches 2 letters ‘cd’.

  • The search continues at position 4 and fails to match any letters.

  • The anchor stops the search start position from being advanced, so there are no more results.

Reverse searching

Searches can now work backwards:

>>> regex.findall(r".", "abc")
['a', 'b', 'c']
>>> regex.findall(r"(?r).", "abc")
['c', 'b', 'a']

Note: the result of a reverse search is not necessarily the reverse of a forward search:

>>> regex.findall(r"..", "abcde")
['ab', 'cd']
>>> regex.findall(r"(?r)..", "abcde")
['de', 'bc']

Matching a single grapheme

\X

The grapheme matcher is supported. It now conforms to the Unicode specification at http://www.unicode.org/reports/tr29/.

Branch reset

(?|...|...)

Capture group numbers will be reused across the alternatives, but groups with different names will have different group numbers.

Examples:

>>> regex.match(r"(?|(first)|(second))", "first").groups()
('first',)
>>> regex.match(r"(?|(first)|(second))", "second").groups()
('second',)

Note that there is only one group.

Default Unicode word boundary

The WORD flag changes the definition of a ‘word boundary’ to that of a default Unicode word boundary. This applies to \b and \B.

Timeout (Python 3)

The matching methods and functions support timeouts. The timeout (in seconds) applies to the entire operation:

>>> from time import sleep
>>>
>>> def fast_replace(m):
...     return 'X'
...
>>> def slow_replace(m):
...     sleep(0.5)
...     return 'X'
...
>>> regex.sub(r'[a-z]', fast_replace, 'abcde', timeout=2)
'XXXXX'
>>> regex.sub(r'[a-z]', slow_replace, 'abcde', timeout=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Python37\lib\site-packages\regex\regex.py", line 276, in sub
    endpos, concurrent, timeout)
TimeoutError: regex timed out

Project details


Release history Release notifications | RSS feed

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

regex-2020.1.8.tar.gz (681.1 kB view details)

Uploaded Source

Built Distributions

regex-2020.1.8-cp38-cp38-win_amd64.whl (268.0 kB view details)

Uploaded CPython 3.8Windows x86-64

regex-2020.1.8-cp38-cp38-win32.whl (250.8 kB view details)

Uploaded CPython 3.8Windows x86

regex-2020.1.8-cp38-cp38-manylinux2010_x86_64.whl (705.6 kB view details)

Uploaded CPython 3.8manylinux: glibc 2.12+ x86-64

regex-2020.1.8-cp38-cp38-manylinux2010_i686.whl (599.5 kB view details)

Uploaded CPython 3.8manylinux: glibc 2.12+ i686

regex-2020.1.8-cp38-cp38-manylinux1_x86_64.whl (705.6 kB view details)

Uploaded CPython 3.8

regex-2020.1.8-cp38-cp38-manylinux1_i686.whl (599.5 kB view details)

Uploaded CPython 3.8

regex-2020.1.8-cp37-cp37m-win_amd64.whl (271.6 kB view details)

Uploaded CPython 3.7mWindows x86-64

regex-2020.1.8-cp37-cp37m-win32.whl (255.4 kB view details)

Uploaded CPython 3.7mWindows x86

regex-2020.1.8-cp37-cp37m-manylinux2010_x86_64.whl (690.1 kB view details)

Uploaded CPython 3.7mmanylinux: glibc 2.12+ x86-64

regex-2020.1.8-cp37-cp37m-manylinux2010_i686.whl (587.9 kB view details)

Uploaded CPython 3.7mmanylinux: glibc 2.12+ i686

regex-2020.1.8-cp37-cp37m-manylinux1_x86_64.whl (690.1 kB view details)

Uploaded CPython 3.7m

regex-2020.1.8-cp37-cp37m-manylinux1_i686.whl (587.9 kB view details)

Uploaded CPython 3.7m

regex-2020.1.8-cp36-cp36m-win_amd64.whl (271.9 kB view details)

Uploaded CPython 3.6mWindows x86-64

regex-2020.1.8-cp36-cp36m-win32.whl (255.5 kB view details)

Uploaded CPython 3.6mWindows x86

regex-2020.1.8-cp36-cp36m-manylinux2010_x86_64.whl (689.7 kB view details)

Uploaded CPython 3.6mmanylinux: glibc 2.12+ x86-64

regex-2020.1.8-cp36-cp36m-manylinux2010_i686.whl (586.7 kB view details)

Uploaded CPython 3.6mmanylinux: glibc 2.12+ i686

regex-2020.1.8-cp36-cp36m-manylinux1_x86_64.whl (689.7 kB view details)

Uploaded CPython 3.6m

regex-2020.1.8-cp36-cp36m-manylinux1_i686.whl (586.7 kB view details)

Uploaded CPython 3.6m

regex-2020.1.8-cp27-cp27m-win_amd64.whl (256.5 kB view details)

Uploaded CPython 2.7mWindows x86-64

regex-2020.1.8-cp27-cp27m-win32.whl (238.7 kB view details)

Uploaded CPython 2.7mWindows x86

File details

Details for the file regex-2020.1.8.tar.gz.

File metadata

  • Download URL: regex-2020.1.8.tar.gz
  • Upload date:
  • Size: 681.1 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8.tar.gz
Algorithm Hash digest
SHA256 d0f424328f9822b0323b3b6f2e4b9c90960b24743d220763c7f07071e0778351
MD5 73abc3d7e902e94b4281fd2652f5a94f
BLAKE2b-256 73d9b58289d885180b5d538aa6df07974b5fe6088547ac846c0f76f77259c304

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-win_amd64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-win_amd64.whl
  • Upload date:
  • Size: 268.0 kB
  • Tags: CPython 3.8, Windows x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp38-cp38-win_amd64.whl
Algorithm Hash digest
SHA256 e7c7661f7276507bce416eaae22040fd91ca471b5b33c13f8ff21137ed6f248c
MD5 4179f3236e888e6b567ecd9356b813bf
BLAKE2b-256 8894d00c80ac7aff74acea2296445ce90b7940f8ce4a4b110e1aaa6a5bf38458

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-win32.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-win32.whl
  • Upload date:
  • Size: 250.8 kB
  • Tags: CPython 3.8, Windows x86
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp38-cp38-win32.whl
Algorithm Hash digest
SHA256 d58e4606da2a41659c84baeb3cfa2e4c87a74cec89a1e7c56bee4b956f9d7461
MD5 0a57f23117e6da3e592a79f62a748ae0
BLAKE2b-256 c56bdf13af755f8e28784151873e87d1d36186ededef98a4e71892514b06cde8

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-manylinux2010_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-manylinux2010_x86_64.whl
  • Upload date:
  • Size: 705.6 kB
  • Tags: CPython 3.8, manylinux: glibc 2.12+ x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp38-cp38-manylinux2010_x86_64.whl
Algorithm Hash digest
SHA256 0932941cdfb3afcbc26cc3bcf7c3f3d73d5a9b9c56955d432dbf8bbc147d4c5b
MD5 2a84056ccb3441966679df8a4346f4bd
BLAKE2b-256 7c303e825eb8913325c7ba50e283561a8fedaf7dde5cb365cefd532e798095a7

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-manylinux2010_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-manylinux2010_i686.whl
  • Upload date:
  • Size: 599.5 kB
  • Tags: CPython 3.8, manylinux: glibc 2.12+ i686
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp38-cp38-manylinux2010_i686.whl
Algorithm Hash digest
SHA256 6a6ae17bf8f2d82d1e8858a47757ce389b880083c4ff2498dba17c56e6c103b9
MD5 acece7513a44f7d572b5980fd734d46b
BLAKE2b-256 6c5388656d2b4ea181d42de43f3dcc87497553e4cea7fabcfe9d725134fec1bb

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-manylinux1_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-manylinux1_x86_64.whl
  • Upload date:
  • Size: 705.6 kB
  • Tags: CPython 3.8
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp38-cp38-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 6a6ba91b94427cd49cd27764679024b14a96874e0dc638ae6bdd4b1a3ce97be1
MD5 aa9e7ae874a462bc05d2e12a7794a1f0
BLAKE2b-256 a98cd1aa639d8df87189ffa46b121983f526e9f5995e22084f64e7b5e56b1960

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp38-cp38-manylinux1_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp38-cp38-manylinux1_i686.whl
  • Upload date:
  • Size: 599.5 kB
  • Tags: CPython 3.8
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp38-cp38-manylinux1_i686.whl
Algorithm Hash digest
SHA256 98b8ed7bb2155e2cbb8b76f627b2fd12cf4b22ab6e14873e8641f266e0fb6d8f
MD5 f86081fc51351e69d2862148f96f1d51
BLAKE2b-256 62de9a5f5d9e68d9e8586fc0f58d7bf0cfad4ea90b2de192f3cb6b07f1abd5c8

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-win_amd64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-win_amd64.whl
  • Upload date:
  • Size: 271.6 kB
  • Tags: CPython 3.7m, Windows x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-win_amd64.whl
Algorithm Hash digest
SHA256 10671601ee06cf4dc1bc0b4805309040bb34c9af423c12c379c83d7895622bb5
MD5 444f4c4ca8aad7fcaf54080da4b1ced2
BLAKE2b-256 8761a3d8311dccec246605983a39b074eb175338f21cba774db0163e5ad0a139

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-win32.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-win32.whl
  • Upload date:
  • Size: 255.4 kB
  • Tags: CPython 3.7m, Windows x86
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-win32.whl
Algorithm Hash digest
SHA256 7bcd322935377abcc79bfe5b63c44abd0b29387f267791d566bbb566edfdd146
MD5 6a2909e990d881bee651c6fc199edfcd
BLAKE2b-256 d645ab3c633c1fb32eed497968c4a74bf3b5980d81123b3c13a8b9d594b19403

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-manylinux2010_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-manylinux2010_x86_64.whl
  • Upload date:
  • Size: 690.1 kB
  • Tags: CPython 3.7m, manylinux: glibc 2.12+ x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-manylinux2010_x86_64.whl
Algorithm Hash digest
SHA256 26ff99c980f53b3191d8931b199b29d6787c059f2e029b2b0c694343b1708c35
MD5 ce2f6f0880078d8dfe67f4f61939a758
BLAKE2b-256 976e2f8d8e86621ab6eb84a2200c78b24343f74dd722f493a7fbbac37036dc13

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-manylinux2010_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-manylinux2010_i686.whl
  • Upload date:
  • Size: 587.9 kB
  • Tags: CPython 3.7m, manylinux: glibc 2.12+ i686
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-manylinux2010_i686.whl
Algorithm Hash digest
SHA256 ecc6de77df3ef68fee966bb8cb4e067e84d4d1f397d0ef6fce46913663540d77
MD5 3a894e384a8c005ed00cc362ad228937
BLAKE2b-256 3b9f1a2692b15c362f673cdd8818de73664a6935e46135a445079a168a2338bb

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-manylinux1_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-manylinux1_x86_64.whl
  • Upload date:
  • Size: 690.1 kB
  • Tags: CPython 3.7m
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 e3cd21cc2840ca67de0bbe4071f79f031c81418deb544ceda93ad75ca1ee9f7b
MD5 942623877d3b46592bcd980321de7677
BLAKE2b-256 32198468e5f523c30edf3d0b5a6d77bf3ed95aa53240d437c0d5607b658a277b

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp37-cp37m-manylinux1_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp37-cp37m-manylinux1_i686.whl
  • Upload date:
  • Size: 587.9 kB
  • Tags: CPython 3.7m
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp37-cp37m-manylinux1_i686.whl
Algorithm Hash digest
SHA256 0e182d2f097ea8549a249040922fa2b92ae28be4be4895933e369a525ba36576
MD5 e10e4725d417ead423aa9ea49e8f7e8f
BLAKE2b-256 a495b03aaa3d25535b52158c754b8cdbbed22f09964865dec4910a3ab1fd30b2

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-win_amd64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-win_amd64.whl
  • Upload date:
  • Size: 271.9 kB
  • Tags: CPython 3.6m, Windows x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-win_amd64.whl
Algorithm Hash digest
SHA256 27429b8d74ba683484a06b260b7bb00f312e7c757792628ea251afdbf1434003
MD5 f33891eaf4e6bb1c0b670196b7d03757
BLAKE2b-256 c11f9d3c93fb4a6021e1ea49c616d5ba44785d18d59ab40650df1cc7bcf5e108

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-win32.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-win32.whl
  • Upload date:
  • Size: 255.5 kB
  • Tags: CPython 3.6m, Windows x86
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-win32.whl
Algorithm Hash digest
SHA256 23e2c2c0ff50f44877f64780b815b8fd2e003cda9ce817a7fd00dea5600c84a0
MD5 b51c28002463cdc4b0339c6949575634
BLAKE2b-256 67df1b694e2e3c76c78edd4bcd87a061bd839e1a548730ab80e81fd53f572eb5

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-manylinux2010_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-manylinux2010_x86_64.whl
  • Upload date:
  • Size: 689.7 kB
  • Tags: CPython 3.6m, manylinux: glibc 2.12+ x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-manylinux2010_x86_64.whl
Algorithm Hash digest
SHA256 07b39bf943d3d2fe63d46281d8504f8df0ff3fe4c57e13d1656737950e53e525
MD5 0d930616ccdf3751fcd7892ce8e65a5d
BLAKE2b-256 ad641b0eb918ebdfba27b4c148853ed93cc38d83aa452882f2a9dc64acaa9b2f

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-manylinux2010_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-manylinux2010_i686.whl
  • Upload date:
  • Size: 586.7 kB
  • Tags: CPython 3.6m, manylinux: glibc 2.12+ i686
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-manylinux2010_i686.whl
Algorithm Hash digest
SHA256 3e77409b678b21a056415da3a56abfd7c3ad03da71f3051bbcdb68cf44d3c34d
MD5 02106c101f70d8bc590ebb27ea6c1db5
BLAKE2b-256 4b400fa665354a142bf6f6ccbedcc3fff79feed30df35c031e361adcf5757dbf

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-manylinux1_x86_64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-manylinux1_x86_64.whl
  • Upload date:
  • Size: 689.7 kB
  • Tags: CPython 3.6m
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-manylinux1_x86_64.whl
Algorithm Hash digest
SHA256 bd25bb7980917e4e70ccccd7e3b5740614f1c408a642c245019cff9d7d1b6149
MD5 80be24b12b0c497b51642a24ec0fbea0
BLAKE2b-256 63ae057469010c579f6f6f37fc9b63b2d70af4ec20f2a7e2f3a1c4f364b4dde0

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp36-cp36m-manylinux1_i686.whl.

File metadata

  • Download URL: regex-2020.1.8-cp36-cp36m-manylinux1_i686.whl
  • Upload date:
  • Size: 586.7 kB
  • Tags: CPython 3.6m
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/3.1.1 pkginfo/1.5.0.1 requests/2.22.0 setuptools/44.0.0 requests-toolbelt/0.9.1 tqdm/4.41.1 CPython/3.8.1

File hashes

Hashes for regex-2020.1.8-cp36-cp36m-manylinux1_i686.whl
Algorithm Hash digest
SHA256 4eae742636aec40cf7ab98171ab9400393360b97e8f9da67b1867a9ee0889b26
MD5 cafcf85450077d7e2d7f7b65e2dafd9b
BLAKE2b-256 aa1000d76595ee3f19cfeeb0e9466052692b91cfabe6da5fabc18e6dc9fd7d34

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp27-cp27m-win_amd64.whl.

File metadata

  • Download URL: regex-2020.1.8-cp27-cp27m-win_amd64.whl
  • Upload date:
  • Size: 256.5 kB
  • Tags: CPython 2.7m, Windows x86-64
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp27-cp27m-win_amd64.whl
Algorithm Hash digest
SHA256 e6c02171d62ed6972ca8631f6f34fa3281d51db8b326ee397b9c83093a6b7242
MD5 5d4df90cf51054089d58c78806861cae
BLAKE2b-256 dfc46146e358e8d51090207c4ea1c479f352f448b38ad52884082c342ca0065d

See more details on using hashes here.

File details

Details for the file regex-2020.1.8-cp27-cp27m-win32.whl.

File metadata

  • Download URL: regex-2020.1.8-cp27-cp27m-win32.whl
  • Upload date:
  • Size: 238.7 kB
  • Tags: CPython 2.7m, Windows x86
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/2.0.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/42.0.2 requests-toolbelt/0.9.1 tqdm/4.36.1 CPython/3.8.0

File hashes

Hashes for regex-2020.1.8-cp27-cp27m-win32.whl
Algorithm Hash digest
SHA256 4e8f02d3d72ca94efc8396f8036c0d3bcc812aefc28ec70f35bb888c74a25161
MD5 94327fbab58d0a784e2eda741f952d9b
BLAKE2b-256 2a52d25a9a8a0f11efbc060001c77601a774e9f338c5e9a98d0b0925a2009ed0

See more details on using hashes here.

Supported by

AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Pingdom Monitoring Sentry Error logging StatusPage Status page