Add loan-advisor-agent
Browse files- .gitattributes +2 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/__init__.py +3 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/__init__.cpython-312.pyc +0 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/_main.cpython-312.pyc +0 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/_regex_core.cpython-312.pyc +3 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/_main.py +756 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/_regex.cp312-win_amd64.pyd +3 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/_regex_core.py +0 -0
- loan-advisor-agent/.venv/Lib/site-packages/regex/tests/test_regex.py +0 -0
.gitattributes
CHANGED
|
@@ -551,3 +551,5 @@ loan-advisor-agent/.venv/Lib/site-packages/pythonwin/win32ui.pyd filter=lfs diff
|
|
| 551 |
loan-advisor-agent/.venv/Lib/site-packages/PyWin32.chm filter=lfs diff=lfs merge=lfs -text
|
| 552 |
loan-advisor-agent/.venv/Lib/site-packages/pywin32_system32/pythoncom312.dll filter=lfs diff=lfs merge=lfs -text
|
| 553 |
loan-advisor-agent/.venv/Lib/site-packages/pywin32_system32/pywintypes312.dll filter=lfs diff=lfs merge=lfs -text
|
|
|
|
|
|
|
|
|
| 551 |
loan-advisor-agent/.venv/Lib/site-packages/PyWin32.chm filter=lfs diff=lfs merge=lfs -text
|
| 552 |
loan-advisor-agent/.venv/Lib/site-packages/pywin32_system32/pythoncom312.dll filter=lfs diff=lfs merge=lfs -text
|
| 553 |
loan-advisor-agent/.venv/Lib/site-packages/pywin32_system32/pywintypes312.dll filter=lfs diff=lfs merge=lfs -text
|
| 554 |
+
loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/_regex_core.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
|
| 555 |
+
loan-advisor-agent/.venv/Lib/site-packages/regex/_regex.cp312-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
|
loan-advisor-agent/.venv/Lib/site-packages/regex/__init__.py
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import regex._main
|
| 2 |
+
from regex._main import *
|
| 3 |
+
__all__ = regex._main.__all__
|
loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/__init__.cpython-312.pyc
ADDED
|
Binary file (308 Bytes). View file
|
|
|
loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/_main.cpython-312.pyc
ADDED
|
Binary file (33.2 kB). View file
|
|
|
loan-advisor-agent/.venv/Lib/site-packages/regex/__pycache__/_regex_core.cpython-312.pyc
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:7225f5945e07808fabc9d91d7a87b1a5ab1233d42acff678c05727bbdd136830
|
| 3 |
+
size 203196
|
loan-advisor-agent/.venv/Lib/site-packages/regex/_main.py
ADDED
|
@@ -0,0 +1,756 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#
|
| 2 |
+
# Secret Labs' Regular Expression Engine
|
| 3 |
+
#
|
| 4 |
+
# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
|
| 5 |
+
#
|
| 6 |
+
# This version of the SRE library can be redistributed under CNRI's
|
| 7 |
+
# Python 1.6 license. For any other use, please contact Secret Labs
|
| 8 |
+
# AB (info@pythonware.com).
|
| 9 |
+
#
|
| 10 |
+
# Portions of this engine have been developed in cooperation with
|
| 11 |
+
# CNRI. Hewlett-Packard provided funding for 1.6 integration and
|
| 12 |
+
# other compatibility work.
|
| 13 |
+
#
|
| 14 |
+
# 2010-01-16 mrab Python front-end re-written and extended
|
| 15 |
+
|
| 16 |
+
r"""Support for regular expressions (RE).
|
| 17 |
+
|
| 18 |
+
This module provides regular expression matching operations similar to those
|
| 19 |
+
found in Perl. It supports both 8-bit and Unicode strings; both the pattern and
|
| 20 |
+
the strings being processed can contain null bytes and characters outside the
|
| 21 |
+
US ASCII range.
|
| 22 |
+
|
| 23 |
+
Regular expressions can contain both special and ordinary characters. Most
|
| 24 |
+
ordinary characters, like "A", "a", or "0", are the simplest regular
|
| 25 |
+
expressions; they simply match themselves. You can concatenate ordinary
|
| 26 |
+
characters, so last matches the string 'last'.
|
| 27 |
+
|
| 28 |
+
There are a few differences between the old (legacy) behaviour and the new
|
| 29 |
+
(enhanced) behaviour, which are indicated by VERSION0 or VERSION1.
|
| 30 |
+
|
| 31 |
+
The special characters are:
|
| 32 |
+
"." Matches any character except a newline.
|
| 33 |
+
"^" Matches the start of the string.
|
| 34 |
+
"$" Matches the end of the string or just before the
|
| 35 |
+
newline at the end of the string.
|
| 36 |
+
"*" Matches 0 or more (greedy) repetitions of the preceding
|
| 37 |
+
RE. Greedy means that it will match as many repetitions
|
| 38 |
+
as possible.
|
| 39 |
+
"+" Matches 1 or more (greedy) repetitions of the preceding
|
| 40 |
+
RE.
|
| 41 |
+
"?" Matches 0 or 1 (greedy) of the preceding RE.
|
| 42 |
+
*?,+?,?? Non-greedy versions of the previous three special
|
| 43 |
+
characters.
|
| 44 |
+
*+,++,?+ Possessive versions of the previous three special
|
| 45 |
+
characters.
|
| 46 |
+
{m,n} Matches from m to n repetitions of the preceding RE.
|
| 47 |
+
{m,n}? Non-greedy version of the above.
|
| 48 |
+
{m,n}+ Possessive version of the above.
|
| 49 |
+
{...} Fuzzy matching constraints.
|
| 50 |
+
"\\" Either escapes special characters or signals a special
|
| 51 |
+
sequence.
|
| 52 |
+
[...] Indicates a set of characters. A "^" as the first
|
| 53 |
+
character indicates a complementing set.
|
| 54 |
+
"|" A|B, creates an RE that will match either A or B.
|
| 55 |
+
(...) Matches the RE inside the parentheses. The contents are
|
| 56 |
+
captured and can be retrieved or matched later in the
|
| 57 |
+
string.
|
| 58 |
+
(?flags-flags) VERSION1: Sets/clears the flags for the remainder of
|
| 59 |
+
the group or pattern; VERSION0: Sets the flags for the
|
| 60 |
+
entire pattern.
|
| 61 |
+
(?:...) Non-capturing version of regular parentheses.
|
| 62 |
+
(?>...) Atomic non-capturing version of regular parentheses.
|
| 63 |
+
(?flags-flags:...) Non-capturing version of regular parentheses with local
|
| 64 |
+
flags.
|
| 65 |
+
(?P<name>...) The substring matched by the group is accessible by
|
| 66 |
+
name.
|
| 67 |
+
(?<name>...) The substring matched by the group is accessible by
|
| 68 |
+
name.
|
| 69 |
+
(?P=name) Matches the text matched earlier by the group named
|
| 70 |
+
name.
|
| 71 |
+
(?#...) A comment; ignored.
|
| 72 |
+
(?=...) Matches if ... matches next, but doesn't consume the
|
| 73 |
+
string.
|
| 74 |
+
(?!...) Matches if ... doesn't match next.
|
| 75 |
+
(?<=...) Matches if preceded by ....
|
| 76 |
+
(?<!...) Matches if not preceded by ....
|
| 77 |
+
(?(id)yes|no) Matches yes pattern if group id matched, the (optional)
|
| 78 |
+
no pattern otherwise.
|
| 79 |
+
(?(DEFINE)...) If there's no group called "DEFINE", then ... will be
|
| 80 |
+
ignored, but any group definitions will be available.
|
| 81 |
+
(?|...|...) (?|A|B), creates an RE that will match either A or B,
|
| 82 |
+
but reuses capture group numbers across the
|
| 83 |
+
alternatives.
|
| 84 |
+
(*FAIL) Forces matching to fail, which means immediate
|
| 85 |
+
backtracking.
|
| 86 |
+
(*F) Abbreviation for (*FAIL).
|
| 87 |
+
(*PRUNE) Discards the current backtracking information. Its
|
| 88 |
+
effect doesn't extend outside an atomic group or a
|
| 89 |
+
lookaround.
|
| 90 |
+
(*SKIP) Similar to (*PRUNE), except that it also sets where in
|
| 91 |
+
the text the next attempt at matching the entire
|
| 92 |
+
pattern will start. Its effect doesn't extend outside
|
| 93 |
+
an atomic group or a lookaround.
|
| 94 |
+
|
| 95 |
+
The fuzzy matching constraints are: "i" to permit insertions, "d" to permit
|
| 96 |
+
deletions, "s" to permit substitutions, "e" to permit any of these. Limits are
|
| 97 |
+
optional with "<=" and "<". If any type of error is provided then any type not
|
| 98 |
+
provided is not permitted.
|
| 99 |
+
|
| 100 |
+
A cost equation may be provided.
|
| 101 |
+
|
| 102 |
+
Examples:
|
| 103 |
+
(?:fuzzy){i<=2}
|
| 104 |
+
(?:fuzzy){i<=1,s<=2,d<=1,1i+1s+1d<3}
|
| 105 |
+
|
| 106 |
+
VERSION1: Set operators are supported, and a set can include nested sets. The
|
| 107 |
+
set operators, in order of increasing precedence, are:
|
| 108 |
+
|| Set union ("x||y" means "x or y").
|
| 109 |
+
~~ (double tilde) Symmetric set difference ("x~~y" means "x or y, but not
|
| 110 |
+
both").
|
| 111 |
+
&& Set intersection ("x&&y" means "x and y").
|
| 112 |
+
-- (double dash) Set difference ("x--y" means "x but not y").
|
| 113 |
+
|
| 114 |
+
Implicit union, ie, simple juxtaposition like in [ab], has the highest
|
| 115 |
+
precedence.
|
| 116 |
+
|
| 117 |
+
VERSION0 and VERSION1:
|
| 118 |
+
The special sequences consist of "\\" and a character from the list below. If
|
| 119 |
+
the ordinary character is not on the list, then the resulting RE will match the
|
| 120 |
+
second character.
|
| 121 |
+
\number Matches the contents of the group of the same number if
|
| 122 |
+
number is no more than 2 digits, otherwise the character
|
| 123 |
+
with the 3-digit octal code.
|
| 124 |
+
\a Matches the bell character.
|
| 125 |
+
\A Matches only at the start of the string.
|
| 126 |
+
\b Matches the empty string, but only at the start or end of a
|
| 127 |
+
word.
|
| 128 |
+
\B Matches the empty string, but not at the start or end of a
|
| 129 |
+
word.
|
| 130 |
+
\d Matches any decimal digit; equivalent to the set [0-9] when
|
| 131 |
+
matching a bytestring or a Unicode string with the ASCII
|
| 132 |
+
flag, or the whole range of Unicode digits when matching a
|
| 133 |
+
Unicode string.
|
| 134 |
+
\D Matches any non-digit character; equivalent to [^\d].
|
| 135 |
+
\f Matches the formfeed character.
|
| 136 |
+
\g<name> Matches the text matched by the group named name.
|
| 137 |
+
\G Matches the empty string, but only at the position where
|
| 138 |
+
the search started.
|
| 139 |
+
\h Matches horizontal whitespace.
|
| 140 |
+
\K Keeps only what follows for the entire match.
|
| 141 |
+
\L<name> Named list. The list is provided as a keyword argument.
|
| 142 |
+
\m Matches the empty string, but only at the start of a word.
|
| 143 |
+
\M Matches the empty string, but only at the end of a word.
|
| 144 |
+
\n Matches the newline character.
|
| 145 |
+
\N{name} Matches the named character.
|
| 146 |
+
\p{name=value} Matches the character if its property has the specified
|
| 147 |
+
value.
|
| 148 |
+
\P{name=value} Matches the character if its property hasn't the specified
|
| 149 |
+
value.
|
| 150 |
+
\r Matches the carriage-return character.
|
| 151 |
+
\s Matches any whitespace character; equivalent to
|
| 152 |
+
[ \t\n\r\f\v].
|
| 153 |
+
\S Matches any non-whitespace character; equivalent to [^\s].
|
| 154 |
+
\t Matches the tab character.
|
| 155 |
+
\uXXXX Matches the Unicode codepoint with 4-digit hex code XXXX.
|
| 156 |
+
\UXXXXXXXX Matches the Unicode codepoint with 8-digit hex code
|
| 157 |
+
XXXXXXXX.
|
| 158 |
+
\v Matches the vertical tab character.
|
| 159 |
+
\w Matches any alphanumeric character; equivalent to
|
| 160 |
+
[a-zA-Z0-9_] when matching a bytestring or a Unicode string
|
| 161 |
+
with the ASCII flag, or the whole range of Unicode
|
| 162 |
+
alphanumeric characters (letters plus digits plus
|
| 163 |
+
underscore) when matching a Unicode string. With LOCALE, it
|
| 164 |
+
will match the set [0-9_] plus characters defined as
|
| 165 |
+
letters for the current locale.
|
| 166 |
+
\W Matches the complement of \w; equivalent to [^\w].
|
| 167 |
+
\xXX Matches the character with 2-digit hex code XX.
|
| 168 |
+
\X Matches a grapheme.
|
| 169 |
+
\Z Matches only at the end of the string.
|
| 170 |
+
\z Matches only at the end of the string. Alias of \Z.
|
| 171 |
+
\\ Matches a literal backslash.
|
| 172 |
+
|
| 173 |
+
This module exports the following functions:
|
| 174 |
+
match Match a regular expression pattern at the beginning of a string.
|
| 175 |
+
prefixmatch Match a regular expression pattern at the beginning of a string.
|
| 176 |
+
Alias of match.
|
| 177 |
+
fullmatch Match a regular expression pattern against all of a string.
|
| 178 |
+
search Search a string for the presence of a pattern.
|
| 179 |
+
sub Substitute occurrences of a pattern found in a string using a
|
| 180 |
+
template string.
|
| 181 |
+
subf Substitute occurrences of a pattern found in a string using a
|
| 182 |
+
format string.
|
| 183 |
+
subn Same as sub, but also return the number of substitutions made.
|
| 184 |
+
subfn Same as subf, but also return the number of substitutions made.
|
| 185 |
+
split Split a string by the occurrences of a pattern. VERSION1: will
|
| 186 |
+
split at zero-width match; VERSION0: won't split at zero-width
|
| 187 |
+
match.
|
| 188 |
+
splititer Return an iterator yielding the parts of a split string.
|
| 189 |
+
findall Find all occurrences of a pattern in a string.
|
| 190 |
+
finditer Return an iterator yielding a match object for each match.
|
| 191 |
+
compile Compile a pattern into a Pattern object.
|
| 192 |
+
purge Clear the regular expression cache.
|
| 193 |
+
escape Backslash all non-alphanumerics or special characters in a
|
| 194 |
+
string.
|
| 195 |
+
|
| 196 |
+
Most of the functions support a concurrent parameter: if True, the GIL will be
|
| 197 |
+
released during matching, allowing other Python threads to run concurrently. If
|
| 198 |
+
the string changes during matching, the behaviour is undefined. This parameter
|
| 199 |
+
is not needed when working on the builtin (immutable) string classes.
|
| 200 |
+
|
| 201 |
+
Some of the functions in this module take flags as optional parameters. Most of
|
| 202 |
+
these flags can also be set within an RE:
|
| 203 |
+
A a ASCII Make \w, \W, \b, \B, \d, and \D match the
|
| 204 |
+
corresponding ASCII character categories. Default
|
| 205 |
+
when matching a bytestring.
|
| 206 |
+
B b BESTMATCH Find the best fuzzy match (default is first).
|
| 207 |
+
D DEBUG Print the parsed pattern.
|
| 208 |
+
E e ENHANCEMATCH Attempt to improve the fit after finding the first
|
| 209 |
+
fuzzy match.
|
| 210 |
+
F f FULLCASE Use full case-folding when performing
|
| 211 |
+
case-insensitive matching in Unicode.
|
| 212 |
+
I i IGNORECASE Perform case-insensitive matching.
|
| 213 |
+
L L LOCALE Make \w, \W, \b, \B, \d, and \D dependent on the
|
| 214 |
+
current locale. (One byte per character only.)
|
| 215 |
+
M m MULTILINE "^" matches the beginning of lines (after a newline)
|
| 216 |
+
as well as the string. "$" matches the end of lines
|
| 217 |
+
(before a newline) as well as the end of the string.
|
| 218 |
+
P p POSIX Perform POSIX-standard matching (leftmost longest).
|
| 219 |
+
R r REVERSE Searches backwards.
|
| 220 |
+
S s DOTALL "." matches any character at all, including the
|
| 221 |
+
newline.
|
| 222 |
+
U u UNICODE Make \w, \W, \b, \B, \d, and \D dependent on the
|
| 223 |
+
Unicode locale. Default when matching a Unicode
|
| 224 |
+
string.
|
| 225 |
+
V0 V0 VERSION0 Turn on the old legacy behaviour.
|
| 226 |
+
V1 V1 VERSION1 Turn on the new enhanced behaviour. This flag
|
| 227 |
+
includes the FULLCASE flag.
|
| 228 |
+
W w WORD Make \b and \B work with default Unicode word breaks
|
| 229 |
+
and make ".", "^" and "$" work with Unicode line
|
| 230 |
+
breaks.
|
| 231 |
+
X x VERBOSE Ignore whitespace and comments for nicer looking REs.
|
| 232 |
+
|
| 233 |
+
This module also defines an exception 'error'.
|
| 234 |
+
|
| 235 |
+
"""
|
| 236 |
+
|
| 237 |
+
# Public symbols.
|
| 238 |
+
__all__ = ["cache_all", "compile", "DEFAULT_VERSION", "escape", "findall",
|
| 239 |
+
"finditer", "fullmatch", "match", "prefixmatch", "purge", "search", "split", "splititer",
|
| 240 |
+
"sub", "subf", "subfn", "subn", "template", "Scanner", "A", "ASCII", "B",
|
| 241 |
+
"BESTMATCH", "D", "DEBUG", "E", "ENHANCEMATCH", "S", "DOTALL", "F",
|
| 242 |
+
"FULLCASE", "I", "IGNORECASE", "L", "LOCALE", "M", "MULTILINE", "P", "POSIX",
|
| 243 |
+
"R", "REVERSE", "T", "TEMPLATE", "U", "UNICODE", "V0", "VERSION0", "V1",
|
| 244 |
+
"VERSION1", "X", "VERBOSE", "W", "WORD", "error", "Regex", "__version__",
|
| 245 |
+
"__doc__", "RegexFlag"]
|
| 246 |
+
|
| 247 |
+
__version__ = "2026.4.4"
|
| 248 |
+
|
| 249 |
+
# --------------------------------------------------------------------
|
| 250 |
+
# Public interface.
|
| 251 |
+
|
| 252 |
+
def match(pattern, string, flags=0, pos=None, endpos=None, partial=False,
|
| 253 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 254 |
+
"""Try to apply the pattern at the start of the string, returning a match
|
| 255 |
+
object, or None if no match was found."""
|
| 256 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 257 |
+
return pat.match(string, pos, endpos, concurrent, partial, timeout)
|
| 258 |
+
|
| 259 |
+
def prefixmatch(pattern, string, flags=0, pos=None, endpos=None, partial=False,
|
| 260 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 261 |
+
"""Try to apply the pattern at the start of the string, returning a match
|
| 262 |
+
object, or None if no match was found. Alias of match()."""
|
| 263 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 264 |
+
return pat.match(string, pos, endpos, concurrent, partial, timeout)
|
| 265 |
+
|
| 266 |
+
def fullmatch(pattern, string, flags=0, pos=None, endpos=None, partial=False,
|
| 267 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 268 |
+
"""Try to apply the pattern against all of the string, returning a match
|
| 269 |
+
object, or None if no match was found."""
|
| 270 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 271 |
+
return pat.fullmatch(string, pos, endpos, concurrent, partial, timeout)
|
| 272 |
+
|
| 273 |
+
def search(pattern, string, flags=0, pos=None, endpos=None, partial=False,
|
| 274 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 275 |
+
"""Search through string looking for a match to the pattern, returning a
|
| 276 |
+
match object, or None if no match was found."""
|
| 277 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 278 |
+
return pat.search(string, pos, endpos, concurrent, partial, timeout)
|
| 279 |
+
|
| 280 |
+
def sub(pattern, repl, string, count=0, flags=0, pos=None, endpos=None,
|
| 281 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 282 |
+
"""Return the string obtained by replacing the leftmost (or rightmost with a
|
| 283 |
+
reverse pattern) non-overlapping occurrences of the pattern in string by the
|
| 284 |
+
replacement repl. repl can be either a string or a callable; if a string,
|
| 285 |
+
backslash escapes in it are processed; if a callable, it's passed the match
|
| 286 |
+
object and must return a replacement string to be used."""
|
| 287 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 288 |
+
return pat.sub(repl, string, count, pos, endpos, concurrent, timeout)
|
| 289 |
+
|
| 290 |
+
def subf(pattern, format, string, count=0, flags=0, pos=None, endpos=None,
|
| 291 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 292 |
+
"""Return the string obtained by replacing the leftmost (or rightmost with a
|
| 293 |
+
reverse pattern) non-overlapping occurrences of the pattern in string by the
|
| 294 |
+
replacement format. format can be either a string or a callable; if a string,
|
| 295 |
+
it's treated as a format string; if a callable, it's passed the match object
|
| 296 |
+
and must return a replacement string to be used."""
|
| 297 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 298 |
+
return pat.subf(format, string, count, pos, endpos, concurrent, timeout)
|
| 299 |
+
|
| 300 |
+
def subn(pattern, repl, string, count=0, flags=0, pos=None, endpos=None,
|
| 301 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 302 |
+
"""Return a 2-tuple containing (new_string, number). new_string is the string
|
| 303 |
+
obtained by replacing the leftmost (or rightmost with a reverse pattern)
|
| 304 |
+
non-overlapping occurrences of the pattern in the source string by the
|
| 305 |
+
replacement repl. number is the number of substitutions that were made. repl
|
| 306 |
+
can be either a string or a callable; if a string, backslash escapes in it
|
| 307 |
+
are processed; if a callable, it's passed the match object and must return a
|
| 308 |
+
replacement string to be used."""
|
| 309 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 310 |
+
return pat.subn(repl, string, count, pos, endpos, concurrent, timeout)
|
| 311 |
+
|
| 312 |
+
def subfn(pattern, format, string, count=0, flags=0, pos=None, endpos=None,
|
| 313 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 314 |
+
"""Return a 2-tuple containing (new_string, number). new_string is the string
|
| 315 |
+
obtained by replacing the leftmost (or rightmost with a reverse pattern)
|
| 316 |
+
non-overlapping occurrences of the pattern in the source string by the
|
| 317 |
+
replacement format. number is the number of substitutions that were made. format
|
| 318 |
+
can be either a string or a callable; if a string, it's treated as a format
|
| 319 |
+
string; if a callable, it's passed the match object and must return a
|
| 320 |
+
replacement string to be used."""
|
| 321 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 322 |
+
return pat.subfn(format, string, count, pos, endpos, concurrent, timeout)
|
| 323 |
+
|
| 324 |
+
def split(pattern, string, maxsplit=0, flags=0, concurrent=None, timeout=None,
|
| 325 |
+
ignore_unused=False, **kwargs):
|
| 326 |
+
"""Split the source string by the occurrences of the pattern, returning a
|
| 327 |
+
list containing the resulting substrings. If capturing parentheses are used
|
| 328 |
+
in pattern, then the text of all groups in the pattern are also returned as
|
| 329 |
+
part of the resulting list. If maxsplit is nonzero, at most maxsplit splits
|
| 330 |
+
occur, and the remainder of the string is returned as the final element of
|
| 331 |
+
the list."""
|
| 332 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 333 |
+
return pat.split(string, maxsplit, concurrent, timeout)
|
| 334 |
+
|
| 335 |
+
def splititer(pattern, string, maxsplit=0, flags=0, concurrent=None,
|
| 336 |
+
timeout=None, ignore_unused=False, **kwargs):
|
| 337 |
+
"Return an iterator yielding the parts of a split string."
|
| 338 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 339 |
+
return pat.splititer(string, maxsplit, concurrent, timeout)
|
| 340 |
+
|
| 341 |
+
def findall(pattern, string, flags=0, pos=None, endpos=None, overlapped=False,
|
| 342 |
+
concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 343 |
+
"""Return a list of all matches in the string. The matches may be overlapped
|
| 344 |
+
if overlapped is True. If one or more groups are present in the pattern,
|
| 345 |
+
return a list of groups; this will be a list of tuples if the pattern has
|
| 346 |
+
more than one group. Empty matches are included in the result."""
|
| 347 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 348 |
+
return pat.findall(string, pos, endpos, overlapped, concurrent, timeout)
|
| 349 |
+
|
| 350 |
+
def finditer(pattern, string, flags=0, pos=None, endpos=None, overlapped=False,
|
| 351 |
+
partial=False, concurrent=None, timeout=None, ignore_unused=False, **kwargs):
|
| 352 |
+
"""Return an iterator over all matches in the string. The matches may be
|
| 353 |
+
overlapped if overlapped is True. For each match, the iterator returns a
|
| 354 |
+
match object. Empty matches are included in the result."""
|
| 355 |
+
pat = _compile(pattern, flags, ignore_unused, kwargs, True)
|
| 356 |
+
return pat.finditer(string, pos, endpos, overlapped, concurrent, partial,
|
| 357 |
+
timeout)
|
| 358 |
+
|
| 359 |
+
def compile(pattern, flags=0, ignore_unused=False, cache_pattern=None, **kwargs):
|
| 360 |
+
"Compile a regular expression pattern, returning a pattern object."
|
| 361 |
+
if cache_pattern is None:
|
| 362 |
+
cache_pattern = _cache_all
|
| 363 |
+
return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
|
| 364 |
+
|
| 365 |
+
def purge():
|
| 366 |
+
"Clear the regular expression cache"
|
| 367 |
+
_cache.clear()
|
| 368 |
+
_locale_sensitive.clear()
|
| 369 |
+
|
| 370 |
+
# Whether to cache all patterns.
|
| 371 |
+
_cache_all = True
|
| 372 |
+
|
| 373 |
+
def cache_all(value=True):
|
| 374 |
+
"""Sets whether to cache all patterns, even those are compiled explicitly.
|
| 375 |
+
Passing None has no effect, but returns the current setting."""
|
| 376 |
+
global _cache_all
|
| 377 |
+
|
| 378 |
+
if value is None:
|
| 379 |
+
return _cache_all
|
| 380 |
+
|
| 381 |
+
_cache_all = value
|
| 382 |
+
|
| 383 |
+
def template(pattern, flags=0):
|
| 384 |
+
"Compile a template pattern, returning a pattern object."
|
| 385 |
+
return _compile(pattern, flags | TEMPLATE, False, {}, False)
|
| 386 |
+
|
| 387 |
+
def escape(pattern, special_only=True, literal_spaces=False):
|
| 388 |
+
"""Escape a string for use as a literal in a pattern. If special_only is
|
| 389 |
+
True, escape only special characters, else escape all non-alphanumeric
|
| 390 |
+
characters. If literal_spaces is True, don't escape spaces."""
|
| 391 |
+
# Convert it to Unicode.
|
| 392 |
+
if isinstance(pattern, bytes):
|
| 393 |
+
p = pattern.decode("latin-1")
|
| 394 |
+
else:
|
| 395 |
+
p = pattern
|
| 396 |
+
|
| 397 |
+
s = []
|
| 398 |
+
if special_only:
|
| 399 |
+
for c in p:
|
| 400 |
+
if c == " " and literal_spaces:
|
| 401 |
+
s.append(c)
|
| 402 |
+
elif c in _METACHARS or c.isspace():
|
| 403 |
+
s.append("\\")
|
| 404 |
+
s.append(c)
|
| 405 |
+
else:
|
| 406 |
+
s.append(c)
|
| 407 |
+
else:
|
| 408 |
+
for c in p:
|
| 409 |
+
if c == " " and literal_spaces:
|
| 410 |
+
s.append(c)
|
| 411 |
+
elif c in _ALNUM:
|
| 412 |
+
s.append(c)
|
| 413 |
+
else:
|
| 414 |
+
s.append("\\")
|
| 415 |
+
s.append(c)
|
| 416 |
+
|
| 417 |
+
r = "".join(s)
|
| 418 |
+
# Convert it back to bytes if necessary.
|
| 419 |
+
if isinstance(pattern, bytes):
|
| 420 |
+
r = r.encode("latin-1")
|
| 421 |
+
|
| 422 |
+
return r
|
| 423 |
+
|
| 424 |
+
# --------------------------------------------------------------------
|
| 425 |
+
# Internals.
|
| 426 |
+
|
| 427 |
+
from regex import _regex_core
|
| 428 |
+
from regex import _regex
|
| 429 |
+
from threading import RLock as _RLock
|
| 430 |
+
from locale import getpreferredencoding as _getpreferredencoding
|
| 431 |
+
from regex._regex_core import *
|
| 432 |
+
from regex._regex_core import (_ALL_VERSIONS, _ALL_ENCODINGS, _FirstSetError,
|
| 433 |
+
_UnscopedFlagSet, _check_group_features, _compile_firstset,
|
| 434 |
+
_compile_replacement, _flatten_code, _fold_case, _get_required_string,
|
| 435 |
+
_parse_pattern, _shrink_cache)
|
| 436 |
+
from regex._regex_core import (ALNUM as _ALNUM, Info as _Info, OP as _OP, Source
|
| 437 |
+
as _Source, Fuzzy as _Fuzzy)
|
| 438 |
+
|
| 439 |
+
# Version 0 is the old behaviour, compatible with the original 're' module.
|
| 440 |
+
# Version 1 is the new behaviour, which differs slightly.
|
| 441 |
+
|
| 442 |
+
DEFAULT_VERSION = RegexFlag.VERSION0
|
| 443 |
+
|
| 444 |
+
_METACHARS = frozenset("()[]{}?*+|^$\\.-#&~")
|
| 445 |
+
|
| 446 |
+
_regex_core.DEFAULT_VERSION = DEFAULT_VERSION
|
| 447 |
+
|
| 448 |
+
# Caches for the patterns and replacements.
|
| 449 |
+
_cache = {}
|
| 450 |
+
_cache_lock = _RLock()
|
| 451 |
+
_named_args = {}
|
| 452 |
+
_replacement_cache = {}
|
| 453 |
+
_locale_sensitive = {}
|
| 454 |
+
|
| 455 |
+
# Maximum size of the cache.
|
| 456 |
+
_MAXCACHE = 500
|
| 457 |
+
_MAXREPCACHE = 500
|
| 458 |
+
|
| 459 |
+
def _compile(pattern, flags, ignore_unused, kwargs, cache_it):
|
| 460 |
+
"Compiles a regular expression to a PatternObject."
|
| 461 |
+
|
| 462 |
+
global DEFAULT_VERSION
|
| 463 |
+
try:
|
| 464 |
+
from regex import DEFAULT_VERSION
|
| 465 |
+
except ImportError:
|
| 466 |
+
pass
|
| 467 |
+
|
| 468 |
+
# We won't bother to cache the pattern if we're debugging.
|
| 469 |
+
if (flags & DEBUG) != 0:
|
| 470 |
+
cache_it = False
|
| 471 |
+
|
| 472 |
+
# What locale is this pattern using?
|
| 473 |
+
locale_key = (type(pattern), pattern)
|
| 474 |
+
if _locale_sensitive.get(locale_key, True) or (flags & LOCALE) != 0:
|
| 475 |
+
# This pattern is, or might be, locale-sensitive.
|
| 476 |
+
pattern_locale = _getpreferredencoding()
|
| 477 |
+
else:
|
| 478 |
+
# This pattern is definitely not locale-sensitive.
|
| 479 |
+
pattern_locale = None
|
| 480 |
+
|
| 481 |
+
def complain_unused_args():
|
| 482 |
+
if ignore_unused:
|
| 483 |
+
return
|
| 484 |
+
|
| 485 |
+
# Complain about any unused keyword arguments, possibly resulting from a typo.
|
| 486 |
+
unused_kwargs = set(kwargs) - {k for k, v in args_needed}
|
| 487 |
+
if unused_kwargs:
|
| 488 |
+
any_one = next(iter(unused_kwargs))
|
| 489 |
+
raise ValueError('unused keyword argument {!a}'.format(any_one))
|
| 490 |
+
|
| 491 |
+
if cache_it:
|
| 492 |
+
try:
|
| 493 |
+
# Do we know what keyword arguments are needed?
|
| 494 |
+
args_key = pattern, type(pattern), flags
|
| 495 |
+
args_needed = _named_args[args_key]
|
| 496 |
+
|
| 497 |
+
# Are we being provided with its required keyword arguments?
|
| 498 |
+
args_supplied = set()
|
| 499 |
+
if args_needed:
|
| 500 |
+
for k, v in args_needed:
|
| 501 |
+
try:
|
| 502 |
+
args_supplied.add((k, frozenset(kwargs[k])))
|
| 503 |
+
except KeyError:
|
| 504 |
+
raise error("missing named list: {!r}".format(k))
|
| 505 |
+
|
| 506 |
+
complain_unused_args()
|
| 507 |
+
|
| 508 |
+
args_supplied = frozenset(args_supplied)
|
| 509 |
+
|
| 510 |
+
# Have we already seen this regular expression and named list?
|
| 511 |
+
pattern_key = (pattern, type(pattern), flags, args_supplied,
|
| 512 |
+
DEFAULT_VERSION, pattern_locale)
|
| 513 |
+
return _cache[pattern_key]
|
| 514 |
+
except KeyError:
|
| 515 |
+
# It's a new pattern, or new named list for a known pattern.
|
| 516 |
+
pass
|
| 517 |
+
|
| 518 |
+
# Guess the encoding from the class of the pattern string.
|
| 519 |
+
if isinstance(pattern, str):
|
| 520 |
+
guess_encoding = UNICODE
|
| 521 |
+
elif isinstance(pattern, bytes):
|
| 522 |
+
guess_encoding = ASCII
|
| 523 |
+
elif isinstance(pattern, Pattern):
|
| 524 |
+
if flags:
|
| 525 |
+
raise ValueError("cannot process flags argument with a compiled pattern")
|
| 526 |
+
|
| 527 |
+
return pattern
|
| 528 |
+
else:
|
| 529 |
+
raise TypeError("first argument must be a string or compiled pattern")
|
| 530 |
+
|
| 531 |
+
# Set the default version in the core code in case it has been changed.
|
| 532 |
+
_regex_core.DEFAULT_VERSION = DEFAULT_VERSION
|
| 533 |
+
|
| 534 |
+
global_flags = flags
|
| 535 |
+
|
| 536 |
+
while True:
|
| 537 |
+
caught_exception = None
|
| 538 |
+
try:
|
| 539 |
+
source = _Source(pattern)
|
| 540 |
+
info = _Info(global_flags, source.char_type, kwargs)
|
| 541 |
+
info.guess_encoding = guess_encoding
|
| 542 |
+
source.ignore_space = bool(info.flags & VERBOSE)
|
| 543 |
+
parsed = _parse_pattern(source, info)
|
| 544 |
+
break
|
| 545 |
+
except _UnscopedFlagSet:
|
| 546 |
+
# Remember the global flags for the next attempt.
|
| 547 |
+
global_flags = info.global_flags
|
| 548 |
+
except error as e:
|
| 549 |
+
caught_exception = e
|
| 550 |
+
|
| 551 |
+
if caught_exception:
|
| 552 |
+
raise error(caught_exception.msg, caught_exception.pattern,
|
| 553 |
+
caught_exception.pos)
|
| 554 |
+
|
| 555 |
+
if not source.at_end():
|
| 556 |
+
raise error("unbalanced parenthesis", pattern, source.pos)
|
| 557 |
+
|
| 558 |
+
# Check the global flags for conflicts.
|
| 559 |
+
version = (info.flags & _ALL_VERSIONS) or DEFAULT_VERSION
|
| 560 |
+
if version not in (0, VERSION0, VERSION1):
|
| 561 |
+
raise ValueError("VERSION0 and VERSION1 flags are mutually incompatible")
|
| 562 |
+
|
| 563 |
+
if (info.flags & _ALL_ENCODINGS) not in (0, ASCII, LOCALE, UNICODE):
|
| 564 |
+
raise ValueError("ASCII, LOCALE and UNICODE flags are mutually incompatible")
|
| 565 |
+
|
| 566 |
+
if isinstance(pattern, bytes) and (info.flags & UNICODE):
|
| 567 |
+
raise ValueError("cannot use UNICODE flag with a bytes pattern")
|
| 568 |
+
|
| 569 |
+
if not (info.flags & _ALL_ENCODINGS):
|
| 570 |
+
if isinstance(pattern, str):
|
| 571 |
+
info.flags |= UNICODE
|
| 572 |
+
else:
|
| 573 |
+
info.flags |= ASCII
|
| 574 |
+
|
| 575 |
+
reverse = bool(info.flags & REVERSE)
|
| 576 |
+
fuzzy = isinstance(parsed, _Fuzzy)
|
| 577 |
+
|
| 578 |
+
# Remember whether this pattern as an inline locale flag.
|
| 579 |
+
_locale_sensitive[locale_key] = info.inline_locale
|
| 580 |
+
|
| 581 |
+
# Fix the group references.
|
| 582 |
+
caught_exception = None
|
| 583 |
+
try:
|
| 584 |
+
parsed.fix_groups(pattern, reverse, False)
|
| 585 |
+
except error as e:
|
| 586 |
+
caught_exception = e
|
| 587 |
+
|
| 588 |
+
if caught_exception:
|
| 589 |
+
raise error(caught_exception.msg, caught_exception.pattern,
|
| 590 |
+
caught_exception.pos)
|
| 591 |
+
|
| 592 |
+
# Should we print the parsed pattern?
|
| 593 |
+
if flags & DEBUG:
|
| 594 |
+
parsed.dump(indent=0, reverse=reverse)
|
| 595 |
+
|
| 596 |
+
# Optimise the parsed pattern.
|
| 597 |
+
parsed = parsed.optimise(info, reverse)
|
| 598 |
+
parsed = parsed.pack_characters(info)
|
| 599 |
+
|
| 600 |
+
# Get the required string.
|
| 601 |
+
req_offset, req_chars, req_flags = _get_required_string(parsed, info.flags)
|
| 602 |
+
|
| 603 |
+
# Build the named lists.
|
| 604 |
+
named_lists = {}
|
| 605 |
+
named_list_indexes = [None] * len(info.named_lists_used)
|
| 606 |
+
args_needed = set()
|
| 607 |
+
for key, index in info.named_lists_used.items():
|
| 608 |
+
name, case_flags = key
|
| 609 |
+
values = frozenset(kwargs[name])
|
| 610 |
+
if case_flags:
|
| 611 |
+
items = frozenset(_fold_case(info, v) for v in values)
|
| 612 |
+
else:
|
| 613 |
+
items = values
|
| 614 |
+
named_lists[name] = values
|
| 615 |
+
named_list_indexes[index] = items
|
| 616 |
+
args_needed.add((name, values))
|
| 617 |
+
|
| 618 |
+
complain_unused_args()
|
| 619 |
+
|
| 620 |
+
# Check the features of the groups.
|
| 621 |
+
_check_group_features(info, parsed)
|
| 622 |
+
|
| 623 |
+
# Compile the parsed pattern. The result is a list of tuples.
|
| 624 |
+
code = parsed.compile(reverse)
|
| 625 |
+
|
| 626 |
+
# Is there a group call to the pattern as a whole?
|
| 627 |
+
key = (0, reverse, fuzzy)
|
| 628 |
+
ref = info.call_refs.get(key)
|
| 629 |
+
if ref is not None:
|
| 630 |
+
code = [(_OP.CALL_REF, ref)] + code + [(_OP.END, )]
|
| 631 |
+
|
| 632 |
+
# Add the final 'success' opcode.
|
| 633 |
+
code += [(_OP.SUCCESS, )]
|
| 634 |
+
|
| 635 |
+
# Compile the additional copies of the groups that we need.
|
| 636 |
+
for group, rev, fuz in info.additional_groups:
|
| 637 |
+
code += group.compile(rev, fuz)
|
| 638 |
+
|
| 639 |
+
# Flatten the code into a list of ints.
|
| 640 |
+
code = _flatten_code(code)
|
| 641 |
+
|
| 642 |
+
if not parsed.has_simple_start():
|
| 643 |
+
# Get the first set, if possible.
|
| 644 |
+
try:
|
| 645 |
+
fs_code = _compile_firstset(info, parsed.get_firstset(reverse))
|
| 646 |
+
fs_code = _flatten_code(fs_code)
|
| 647 |
+
code = fs_code + code
|
| 648 |
+
except _FirstSetError:
|
| 649 |
+
pass
|
| 650 |
+
|
| 651 |
+
# The named capture groups.
|
| 652 |
+
index_group = dict((v, n) for n, v in info.group_index.items())
|
| 653 |
+
|
| 654 |
+
# Create the PatternObject.
|
| 655 |
+
#
|
| 656 |
+
# Local flags like IGNORECASE affect the code generation, but aren't needed
|
| 657 |
+
# by the PatternObject itself. Conversely, global flags like LOCALE _don't_
|
| 658 |
+
# affect the code generation but _are_ needed by the PatternObject.
|
| 659 |
+
compiled_pattern = _regex.compile(pattern, info.flags | version, code,
|
| 660 |
+
info.group_index, index_group, named_lists, named_list_indexes,
|
| 661 |
+
req_offset, req_chars, req_flags, info.group_count)
|
| 662 |
+
|
| 663 |
+
# Do we need to reduce the size of the cache?
|
| 664 |
+
if len(_cache) >= _MAXCACHE:
|
| 665 |
+
with _cache_lock:
|
| 666 |
+
_shrink_cache(_cache, _named_args, _locale_sensitive, _MAXCACHE)
|
| 667 |
+
|
| 668 |
+
if cache_it:
|
| 669 |
+
if (info.flags & LOCALE) == 0:
|
| 670 |
+
pattern_locale = None
|
| 671 |
+
|
| 672 |
+
args_needed = frozenset(args_needed)
|
| 673 |
+
|
| 674 |
+
# Store this regular expression and named list.
|
| 675 |
+
pattern_key = (pattern, type(pattern), flags, args_needed,
|
| 676 |
+
DEFAULT_VERSION, pattern_locale)
|
| 677 |
+
_cache[pattern_key] = compiled_pattern
|
| 678 |
+
|
| 679 |
+
# Store what keyword arguments are needed.
|
| 680 |
+
_named_args[args_key] = args_needed
|
| 681 |
+
|
| 682 |
+
return compiled_pattern
|
| 683 |
+
|
| 684 |
+
def _compile_replacement_helper(pattern, template):
|
| 685 |
+
"Compiles a replacement template."
|
| 686 |
+
# This function is called by the _regex module.
|
| 687 |
+
|
| 688 |
+
# Have we seen this before?
|
| 689 |
+
key = pattern.pattern, pattern.flags, template
|
| 690 |
+
compiled = _replacement_cache.get(key)
|
| 691 |
+
if compiled is not None:
|
| 692 |
+
return compiled
|
| 693 |
+
|
| 694 |
+
if len(_replacement_cache) >= _MAXREPCACHE:
|
| 695 |
+
_replacement_cache.clear()
|
| 696 |
+
|
| 697 |
+
is_unicode = isinstance(template, str)
|
| 698 |
+
source = _Source(template)
|
| 699 |
+
if is_unicode:
|
| 700 |
+
def make_string(char_codes):
|
| 701 |
+
return "".join(chr(c) for c in char_codes)
|
| 702 |
+
else:
|
| 703 |
+
def make_string(char_codes):
|
| 704 |
+
return bytes(char_codes)
|
| 705 |
+
|
| 706 |
+
compiled = []
|
| 707 |
+
literal = []
|
| 708 |
+
while True:
|
| 709 |
+
ch = source.get()
|
| 710 |
+
if not ch:
|
| 711 |
+
break
|
| 712 |
+
if ch == "\\":
|
| 713 |
+
# '_compile_replacement' will return either an int group reference
|
| 714 |
+
# or a string literal. It returns items (plural) in order to handle
|
| 715 |
+
# a 2-character literal (an invalid escape sequence).
|
| 716 |
+
is_group, items = _compile_replacement(source, pattern, is_unicode)
|
| 717 |
+
if is_group:
|
| 718 |
+
# It's a group, so first flush the literal.
|
| 719 |
+
if literal:
|
| 720 |
+
compiled.append(make_string(literal))
|
| 721 |
+
literal = []
|
| 722 |
+
compiled.extend(items)
|
| 723 |
+
else:
|
| 724 |
+
literal.extend(items)
|
| 725 |
+
else:
|
| 726 |
+
literal.append(ord(ch))
|
| 727 |
+
|
| 728 |
+
# Flush the literal.
|
| 729 |
+
if literal:
|
| 730 |
+
compiled.append(make_string(literal))
|
| 731 |
+
|
| 732 |
+
_replacement_cache[key] = compiled
|
| 733 |
+
|
| 734 |
+
return compiled
|
| 735 |
+
|
| 736 |
+
# We define Pattern here after all the support objects have been defined.
|
| 737 |
+
_pat = _compile('', 0, False, {}, False)
|
| 738 |
+
Pattern = type(_pat)
|
| 739 |
+
Match = type(_pat.match(''))
|
| 740 |
+
del _pat
|
| 741 |
+
|
| 742 |
+
# Make Pattern public for typing annotations.
|
| 743 |
+
__all__.append("Pattern")
|
| 744 |
+
__all__.append("Match")
|
| 745 |
+
|
| 746 |
+
# We'll define an alias for the 'compile' function so that the repr of a
|
| 747 |
+
# pattern object is eval-able.
|
| 748 |
+
Regex = compile
|
| 749 |
+
|
| 750 |
+
# Register myself for pickling.
|
| 751 |
+
import copyreg as _copy_reg
|
| 752 |
+
|
| 753 |
+
def _pickle(pattern):
|
| 754 |
+
return _regex.compile, pattern._pickled_data
|
| 755 |
+
|
| 756 |
+
_copy_reg.pickle(Pattern, _pickle)
|
loan-advisor-agent/.venv/Lib/site-packages/regex/_regex.cp312-win_amd64.pyd
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:cb1c3f2edf7b926b4d92efc4a3a7668db0dd067f8886b38e530f26288084bb63
|
| 3 |
+
size 726528
|
loan-advisor-agent/.venv/Lib/site-packages/regex/_regex_core.py
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
loan-advisor-agent/.venv/Lib/site-packages/regex/tests/test_regex.py
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|