Skip to content

Reference

BooleanParser

Bases: TextParser

Convert "TRUE" or "FALSE" (with any case combination) to boolean objects.

Examples

>>> parser.parse('True')
True
>>> parser.parse('FALSE')
False
Source code in regexparser/regexparser.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
class BooleanParser(TextParser):
    """
    Convert "TRUE" or "FALSE" (with any case combination) to boolean objects.

    Examples
    --------
    ```python
    >>> parser.parse('True')
    True
    >>> parser.parse('FALSE')
    False
    ```
    """
    def parseBoolean(self, text: str, match: re.Match) -> bool:
        r'^[Tt][Rr][Uu][eE]|[Ff][Aa][Ll][Ss][Ee]$'
        return eval(text.lower().capitalize())

parseBoolean(text, match)

^[Tt][Rr][Uu][eE]|[Ff][Aa][Ll][Ss][Ee]$

Source code in regexparser/regexparser.py 
84
85
86
def parseBoolean(self, text: str, match: re.Match) -> bool:
    r'^[Tt][Rr][Uu][eE]|[Ff][Aa][Ll][Ss][Ee]$'
    return eval(text.lower().capitalize())

NumberParser

Bases: TextParser

Convert text with numbers to int and float objects.

Examples

>>> parser.parse('1')
1
>>> parser.parse('- 1.1')
-1.1
>>> parser.parse('1,000.1')
1000.1
Source code in regexparser/regexparser.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
class NumberParser(TextParser):
    """
    Convert text with numbers to int and float objects.

    Examples
    --------
    ```python
    >>> parser.parse('1')
    1
    >>> parser.parse('- 1.1')
    -1.1
    >>> parser.parse('1,000.1')
    1000.1
    ```
    """
    def parseInteger(self, text: str, match: re.Match) -> int:
        r'^-?\s*\d+$'
        return eval(text)

    def parse_number_decimal(self, text: str, match: re.Match) -> float:
        r'^-?\s*\d+\.\d+?$'
        return eval(text)

    def parse_number_with_thousands(self, text: str, match: re.Match) -> float:
        r'^-?\s*(\d+[,])+\d+[\.]\d+?$'
        text = text.replace(',', '')
        return eval(text)

parseInteger(text, match)

^-?\s*\d+$

Source code in regexparser/regexparser.py 
104
105
106
def parseInteger(self, text: str, match: re.Match) -> int:
    r'^-?\s*\d+$'
    return eval(text)

parse_number_decimal(text, match)

^-?\s*\d+.\d+?$

Source code in regexparser/regexparser.py 
108
109
110
def parse_number_decimal(self, text: str, match: re.Match) -> float:
    r'^-?\s*\d+\.\d+?$'
    return eval(text)

parse_number_with_thousands(text, match)

^-?\s*(\d+[,])+\d+[.]\d+?$

Source code in regexparser/regexparser.py 
112
113
114
115
def parse_number_with_thousands(self, text: str, match: re.Match) -> float:
    r'^-?\s*(\d+[,])+\d+[\.]\d+?$'
    text = text.replace(',', '')
    return eval(text)

PortugueseRulesParser

Bases: TextParser

Convert text to float and boolean according to Brazilian Portuguese conventions.

Examples

>>> parser.parse('1,1')
1,1
>>> parser.parse('- 1.000,1')
-1000.1
>>> parser.parse('Sim')
True
>>> parser.parse('Não')
False
Source code in regexparser/regexparser.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
class PortugueseRulesParser(TextParser):
    """
    Convert text to float and boolean according to Brazilian Portuguese conventions.

    Examples
    --------
    ```python
    >>> parser.parse('1,1')
    1,1
    >>> parser.parse('- 1.000,1')
    -1000.1
    >>> parser.parse('Sim')
    True
    >>> parser.parse('Não')
    False
    ```
    """
    def parseBoolean_ptBR(self, text: str, match: re.Match) -> bool:
        r'^(sim|Sim|SIM|n.o|N.o|N.O)$'
        return text[0].lower() == 's'

    def parseBoolean_ptBR2(self, text: str, match: re.Match) -> bool:
        r'^(verdadeiro|VERDADEIRO|falso|FALSO|V|F|v|f)$'
        return text[0].lower() == 'v'

    def parse_number_with_thousands_ptBR(self, text: str, match: re.Match) -> float:
        r'^-?\s*(\d+\.)+\d+,\d+?$'
        text = text.replace('.', '')
        text = text.replace(',', '.')
        return eval(text)

    def parse_number_decimal_ptBR(self, text: str, match: re.Match) -> float:
        r'^-?\s*\d+,\d+?$'
        text = text.replace(',', '.')
        return eval(text)

parseBoolean_ptBR(text, match)

^(sim|Sim|SIM|n.o|N.o|N.O)$

Source code in regexparser/regexparser.py 
135
136
137
def parseBoolean_ptBR(self, text: str, match: re.Match) -> bool:
    r'^(sim|Sim|SIM|n.o|N.o|N.O)$'
    return text[0].lower() == 's'

parseBoolean_ptBR2(text, match)

^(verdadeiro|VERDADEIRO|falso|FALSO|V|F|v|f)$

Source code in regexparser/regexparser.py 
139
140
141
def parseBoolean_ptBR2(self, text: str, match: re.Match) -> bool:
    r'^(verdadeiro|VERDADEIRO|falso|FALSO|V|F|v|f)$'
    return text[0].lower() == 'v'

parse_number_decimal_ptBR(text, match)

^-?\s*\d+,\d+?$

Source code in regexparser/regexparser.py 
149
150
151
152
def parse_number_decimal_ptBR(self, text: str, match: re.Match) -> float:
    r'^-?\s*\d+,\d+?$'
    text = text.replace(',', '.')
    return eval(text)

parse_number_with_thousands_ptBR(text, match)

^-?\s*(\d+.)+\d+,\d+?$

Source code in regexparser/regexparser.py 
143
144
145
146
147
def parse_number_with_thousands_ptBR(self, text: str, match: re.Match) -> float:
    r'^-?\s*(\d+\.)+\d+,\d+?$'
    text = text.replace('.', '')
    text = text.replace(',', '.')
    return eval(text)

TextParser

Builds parsers based on regular expressions. The regular expression, used to match the text pattern, is specified in the method's __doc__ attribute. The name of these parser methods must start with parser.

The parser class inherits TextParser and implements the parser methods defining the regular expression in the method's __doc__.

The parser method has two arguments, the first is the given text that is parsed and the second is one instance of the re.Match class. The regular expression attributes can be accessed in this argument. The parser method is called once the regular expression returns a valid Match object.

If one regular expression matches the given text, the method associated to that regular expression is executed, the given text is parsed according to its implementation and the parsed value is returned. Otherwise, the passed text is returned without changes.

Examples

Creat a class to parse integers.

>>> class IntParser(TextParser):
>>>     def parseInteger(self, text, match):
>>>         r'^-?\s*\d+$'
>>>         return eval(text)

Instanciate and call the parse method to convert the given text.

>>> parser = IntParser()
>>> parser.parse('1')
1
>>> parser.parse('a')
'a'
Source code in regexparser/regexparser.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class TextParser:
    """
    Builds parsers based on regular expressions.
    The regular expression, used to match the text pattern, is specified in the
    method's `__doc__` attribute.
    The name of these *parser methods* must start with `parser`.

    The parser class inherits TextParser and implements the parser methods
    defining the regular expression in the method's `__doc__`.

    The parser method has two arguments, the first is the given text that is
    parsed and the second is one instance of the re.Match class.
    The regular expression attributes can be accessed in this argument.
    The parser method is called once the regular expression returns a valid
    Match object.

    If one regular expression matches the given text, the method associated
    to that regular expression is executed, the given text is parsed according to its
    implementation and the parsed value is returned.
    Otherwise, the passed text is returned without changes.

    Examples
    --------
    Creat a class to parse integers.

    ```python
    >>> class IntParser(TextParser):
    >>>     def parseInteger(self, text, match):
    >>>         r'^-?\\s*\\d+$'
    >>>         return eval(text)
    ```

    Instanciate and call the parse method to convert the given text.

    ```python
    >>> parser = IntParser()
    >>> parser.parse('1')
    1
    >>> parser.parse('a')
    'a'
    ```
    """
    def __init__(self):
        self.parsers = self.__createMethodAnalyzers()

    def __createMethodAnalyzers(self) -> List:
        pairs = []
        for methodName in dir(self):
            method = getattr(self, methodName)
            if methodName.startswith('parse') and type(method) is MethodType and method.__doc__:
                pairs.append(buildparser(method.__doc__, method))
        return pairs

    def parse(self, text: str) -> Any:
        for parser in self.parsers:
            val = parser(text)
            if val != text:
                return val
        return self.parseText(text)

    def parseText(self, text: str) -> str:
        return text

buildparser(regex, func)

Builds a parser that parses a given text according to regex and func.

Parameters

str

Regular expression to match the desired pattern.

Callable[[str, re.Match], Any]

Function that parses the given text once it matches the regular expression.

Returns

Callable[[str], Any] Returns a callable object that receives the text to be parsed and returns the result of the parsing.

Examples

>>> num_parser = textparser.buildparser(r'^-?\s*\d+[\.,]\d+?$', lambda t, m: eval(t.replace(',', '.')))
>>> num_parser('1.1')
1.1
Source code in regexparser/regexparser.py 
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
def buildparser(regex: str, func: Callable[[str, re.Match], Any]) -> Callable[[str], Any]:
    """
    Builds a parser that parses a given text according to regex and func.

    Parameters
    ----------
    regex: str
        Regular expression to match the desired pattern.
    func: Callable[[str, re.Match], Any]
        Function that parses the given text once it matches the regular expression.

    Returns
    -------
    Callable[[str], Any]
        Returns a callable object that receives the text to be parsed and returns
        the result of the parsing.

    Examples
    --------
    ```python
    >>> num_parser = textparser.buildparser(r'^-?\\s*\\d+[\\.,]\\d+?$', lambda t, m: eval(t.replace(',', '.')))
    >>> num_parser('1.1')
    1.1
    ```
    """
    _regex = re.compile(regex)
    def _func(text):
        match = _regex.match(text)
        return func(text, match) if match else text
    return _func

textparse(text, regex, func)

Parses the argument text with the function func once it matches the regular expression regex.

Parameters

str

Given text to be parsed.

str

Regular expression to match the desired pattern.

Callable[[str, re.Match], Any]

Function that parses the given text once it matches the regular expression.

Returns

Any Returns the parsed object as result of the parsing.

Examples

>>> textparser.textparse('TRUe', r'^[Tt][Rr][Uu][eE]|[Ff][Aa][Ll][Ss][Ee]$', lambda t, m: eval(t.lower().capitalize()))
True
>>> textparser.textparse('1,1', r'^-?\s*\d+[\.,]\d+?$', lambda t, m: eval(t.replace(',', '.')))
1.1
Source code in regexparser/regexparser.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
def textparse(text: str, regex: str, func: Callable[[str, re.Match], Any]) -> Any:
    """
    Parses the argument text with the function func once it matches the 
    regular expression regex.

    Parameters
    ----------
    text: str
        Given text to be parsed.
    regex: str
        Regular expression to match the desired pattern.
    func: Callable[[str, re.Match], Any]
        Function that parses the given text once it matches the regular expression.

    Returns
    -------
    Any
        Returns the parsed object as result of the parsing.

    Examples
    --------
    ```python
    >>> textparser.textparse('TRUe', r'^[Tt][Rr][Uu][eE]|[Ff][Aa][Ll][Ss][Ee]$', lambda t, m: eval(t.lower().capitalize()))
    True
    >>> textparser.textparse('1,1', r'^-?\\s*\\d+[\\.,]\\d+?$', lambda t, m: eval(t.replace(',', '.')))
    1.1
    ```
    """
    parser = buildparser(regex, func)
    return parser(text)