regex

  1from typing_extensions import Self
  2from typing import Tuple
  3import re
  4
  5"""
  6Docs for RegexGenerator
  7"""
  8
  9class RegexGen:
 10    """
 11    Start of the class
 12    """
 13    # ranges
 14    lowercaserange: str = "[a-z]"
 15    uppercaserange: str = "[A-Z]"
 16    digitsrange: str = "[0-9]"
 17    symbolsrange: str = "\W"
 18    alphanumeric: str = "\w"
 19    # ecape sequences
 20    block_word: str = "\b"
 21    nonblock_word: str = "\B"
 22    new_line: str = "\n"
 23    tab_space: str = "\t"
 24    carriage_return: str = "\r"
 25    whitespace = "\s"
 26
 27    def __init__(self):
 28        self.__regex_data: str = str()
 29
 30
 31
 32    def linestartwith(self):
 33        '''
 34        <code>linestartwith</code> adds a expression to indicate beginning of the string and is always added on a new line.<br></p>
 35        The function definition is:  
 36            `linestartwith(self)`
 37        <p>When this function is called, the function adds the expression '^' if no regex data exists already.</p>
 38        <p>If the regex data already exists then the function adds the expression '\\n^' indicating line is changed before signifying beginning of the string.  </p>
 39        <p><code>Linestartwith</code> function can be used in combination with other function to create a regex syntax to check if the expression starts with certain pattern.<br>
 40        </p>
 41        ```
 42        regex = RegexGen().linestartwith().text('foo').any(1,5).text('bar').endofline()
 43        ```       
 44        <p>This code checks for text starting with 'foo' and starting with 'bar' after any characters of length of min 1 and max 5 digits.</p>
 45        <p>The regex is displayed as:</p>
 46        <samp> regex = "^foo.{1,5}bar"</samp></p>
 47    ^ character symbolizes the start of the string or line.
 48    '''
 49        if not len(self.__regex_data):
 50            self.__regex_data += '^'
 51        else:
 52            self.__regex_data += '\n^'
 53        return self
 54
 55
 56
 57    def endofline(self):
 58        '''
 59        <p><code>endofline</code> adds a expression to indicates end of the string and end of the line.<br>
 60            The function definition is: 
 61          <code>
 62           endofline(self) 
 63           </code>
 64        <p>When this function is called, the function adds the expression '$' to the regex data.
 65        <p>If the regex data already exists then the function adds the expression '\n^' indicating line is changed before signifying beginning of the string.  
 66        <p><code>endofline</code> function can be used in combination with other function to create a regex syntax to check if the expression ends with certain pattern.<br>
 67        <pre><code><p>regex = RegexGen().regex.text('abc', 1, 1).endofline()</p></code></pre>           
 68        <p>This code checks for text ending with 'abc' after any characters of any length 
 69        <p>The regex is displayed as:<br>
 70        <samp> regex = "abc$"</samp><br>
 71        $ character symbolizes as end of a line
 72        </p></p></p></p></p>
 73        '''
 74        self.__regex_data += '$'
 75        return self
 76    
 77    @staticmethod
 78    def range(start: str, end: str) -> str:
 79        '''
 80        <code>Range</code> function provides syntax for defining range.<br><br>
 81            In the function definition, 
 82            <code>range(start: str, end: str)</code> <br>
 83                    1. start accepts string for starting range whose length must be 1.                           
 84                    2. end accepts string for ending range whose length must be 1.                             
 85                    3. return returns the range in format <start>-<end>
 86        
 87        <pre><code><p>regex = RegexGen().regex.range('a', 'z')</p></code></pre>           
 88        <p>The regex is displayed as:</p>
 89        <samp> regex = "[a-z]"</samp><br>
 90        Range for symbols will throw an error
 91        start : str // length must be 1
 92        end : str  //length must be 1
 93        return : str //returns the range in format <start>-<end>
 94    '''
 95        if (not start and not end) and (len(start) > 1 and len(end) > 1):
 96            raise Exception("In function {}, range_start : {}, range_end:{} => Characters cannot be None".format(
 97                RegexGen.range.__name__, start, end))
 98
 99        # check if range is valid
100        character_range = f"({start}-{end})"
101        if (valid_ranges(character_range, is_lower_case, is_upper_case, is_number)):
102            return character_range
103        raise Exception("In function {}, range_start : {}, range_end:{} => This is not a valid range. Valid ranges are 0-9,A-Z or a-z or \W".format(
104            RegexGen.range.__name__, start, end))
105
106
107    @staticmethod
108    def exclude(characters: str, pattern_prevent: bool = False) -> Tuple[str, bool]:
109        '''
110        <code>Exclude</code> function is a static function. It excludes certain pattern based upon the input of the user.<br>
111        In the function definition, <code>exclude(characters: str, pattern_prevent: bool = False) -> tuple</code>,
112            <ol><li> the characters : str signifies characters to be matched,</li> 
113            <li>pattern_prevent : str (default = False) Here, on True, prevents the characters sequence to match(The sequence must not contain a range) 
114                    and on false prevent piecewise occuring of characters.
115                    and returns a tuple   </li>                 
116                
117            
118    <pre><code><p>RegexGen().digits(1, 10, RegexGen.exclude("23", True), capture=True) </p></code></pre>           
119    
120    <p>The regex is displayed as:<br>
121    <samp> regex = "\b(?:(?![23])\d)+\b"</samp><br>
122        characters : str  //characters to be matched
123        pattern_prevent : bool  => default = False //On True, prevents the characters sequence to match(The sequence must not contain a range) 
124                                                //and on false prevent piecewise occuring of characters.
125        return : tuple
126    '''
127        if not characters:
128            raise Exception("In function {}, Character : {} => Characters cannot be None".format(
129                RegexGen.exclude.__name__, characters))
130        # check if charaters is a range
131        try:
132            if valid_ranges(characters, is_lower_case, is_upper_case, is_number) or characters.find(RegexGen.symbolsrange) != -1:
133                pattern_prevent = False
134        except (...):
135            raise
136
137        return characters, pattern_prevent
138
139    @staticmethod
140    def boundary_character(character: str, start: bool = True) -> str:
141        '''
142        <code>Boundary character</code> gives left or right boundary of the word as required.<br>
143        In the function definition, <code> boundary_character(character: str, start: bool = True) -> str: </code><br>
144        <ol>
145        <li> character: str signifies characters to be matched</li>
146        <li>start : bool (default = True) On true, the letter is the left boundary of the word<br> 
147                                        and on false the letter is the right boundary of the word.
148    '''
149        if len(character) > 2:
150            raise Exception("In function {}, start : {} => Character cannot be length greater than two",
151                            RegexGen.boundary_character.__name__, start)
152        elif len(character) == 2 and character not in {"\w", "\W", "\d", "\."}:
153            raise Exception("In function {}, start : {} => Character is not a \w or \W or \d or \.",
154                            RegexGen.boundary_character.__name__, start)
155
156        character_str = "\b" + character if start else character + "\b"
157        
158        return character_str
159
160    
161    def add_quantifier(self, min: int, max: int, **kwargs) -> str:
162        """
163            <code>__add_quantifier</code>adds quantifiers like ? + * x(n,m).<br>
164        The function definition is:  <code>__add_quantifier(self, min: int, max: int, **kwargs)</code>.<br>
165        The regex generated depends on the value of min and max.
166            <ol>
167                <li>min == max and max == 0:<br>
168                    If no characters exist then the exception is raised stating min and max can't be zero.       
169                    <pre> regex = " "</pre>         </li>      
170                 <li>max == min and min == 1:
171                    <pre> regex = "^foo.{1,5}bar"</pre></li>
172                <li>max == min:
173                    <pre> regex = "^foo.{1,5}bar"</pre></li>                
174                <li>min == 0 and max == 1:
175                    <pre> regex = "^foo.{1,5}bar"</pre></li>  
176                <>max == 0 and min > 0:
177                    <pre> regex = "^foo.{1,5}bar"</pre></li>  
178                <li>max > min and min > 0:
179                    <pre> regex = "^foo.{1,5}bar"</pre></li>  
180                <li>Else:  
181                    If no characters exist then the exception is raised stating min and max can't be zero.</li>                      
182                </ol>
183        <pre> regex = "^foo.{1,5}bar"</pre>
184        Add Quantifiers like {0},{0,1},?,*,+,{0,1}
185    """
186        regexchar: str = str()
187
188        if min == max and max == 0:
189            zeroormore = kwargs.get("zeroormore", False)
190            oneormore = kwargs.get("oneormore", False)
191            if zeroormore:
192                regexchar += '*'
193            elif oneormore:
194                regexchar += '+'
195            else:
196                raise Exception("In function {} => Min And Max Cannot be Zero"
197                                .format(self.__add_quantifier.__name__))
198        elif max == min and min == 1:
199            regexchar = ""
200        elif max == min:
201            regexchar = f"{{{min}}}"
202        elif min == 0 and max == 1:
203            regexchar = "?"
204        elif max == 0 and min > 0:
205            regexchar = f"{{{min},}}"
206        elif max > min and min > 0:
207            regexchar = f"{{{min},{max}}}"
208        else:
209            regexchar = f"{{,{max}}}"
210
211        return regexchar
212
213    def text(self, character: str, min: int = 0, max: int = 0, **kwargs) -> Self:
214        ''' 
215        <p><code>Text</code> function simply adds the input to regex syntax.</p>
216        <pre><code><p>RegexGen.text("This is a text.") </p></code></pre>           
217        
218        <p>The regex is displayed as:</p>
219        <pre> regex = "This is a text."</pre>
220        Text is generated using Characters function.
221        character : str // A character can be a word, alphabet, a digit or number and symbols or a range
222        min : int => default = 0  // if min and max are both zero it must pass a keyword argument as True 
223        max : int  => default = 0
224        capture : bool => default = False //On True enclose the character in parenthesis so that regex engine capture data
225        kwargs : dict => {
226            zeroormore : bool => default=False,
227            oneormore : bool => default=False
228        }
229        return : RegexGen
230    '''
231        letterstr: str = str()
232        temp: str = str()
233
234        if not character:
235            raise Exception("In function {}, Character : {} => Character cannot be None".format(
236                self.text.__name__, character))
237
238        letterstr = character
239
240        try:
241            temp = self.__add_quantifier(min, max, **kwargs)
242        except Exception as e:
243            raise
244
245        self.__regex_data += letterstr
246        self.__regex_data += temp
247
248        return self
249
250    def any(self, min: int = 0, max: int = 0, capture: bool = False, **kwargs) -> Self:
251        ''' 
252        <p><code>Any</code> function generates a regex which can be utilized to check if a certain character exists in the expression<br>
253            In the function definition, 
254            <code>any(self, min: int = 0, max: int = 0, capture: bool = False, **kwargs) -> Self:</code>
255            ,
256            <ol class="list-group list-group-numbered">
257                <li class="list-group-item d-flex justify-content-between align-items-start">
258                    <div class="ms-2 me-auto">
259                        the min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True max : int (default = 0). <br>
260                    </div></li>
261                <li class="list-group-item d-flex justify-content-between align-items-start">
262                    <div class="ms-2 me-auto">
263                        If on capture : bool (default=False) True is passed, it  enclose . in parenthesis so that regex engine capture data. <br>
264                    </div></li>
265                <li class="list-group-item d-flex justify-content-between align-items-start">
266                    <div class="ms-2 me-auto">
267                        The kwargs : dict accepts {<br>
268                            zeroormore : bool  (default=False), <br>
269                            oneormore : bool  (default=False)            
270                    </div></li>
271                    <li class="list-group-item d-flex justify-content-between align-items-start">
272                        <div class="ms-2 me-auto">
273                            The return returns RegexGen
274                        </div></li></ol><br></p>
275        <pre><code>regex = RegexGen()
276            regex = regex.any(min=0, max=12)</code></pre>           
277        
278        <p>The regex is displayed as:</p>
279        <pre>  regex = ".{0,12}"</pre> 
280        . character symbolizes any character
281        min : int => default = 0 // if min and max are both zero it must pass a keyword argument as True 
282        max : int => default = 0
283        capture : bool => default=False //On True enclose . in parenthesis so that regex engine capture data
284        kwargs : dict => {
285            zeroormore : bool => default=False,
286            oneormore : bool => default=False
287        }
288        return : RegexGen
289    '''
290        anystr: str = str()
291        temp: str = str()
292
293        try:
294            temp = self.__add_quantifier(min, max, **kwargs)
295        except (...):
296            raise
297
298        anystr = f"(.{temp})" if capture else f".{temp}"
299        self.__regex_data += anystr
300
301        return self
302
303
304    def digits(self, min: int = 0, max: int = 0, pattern: Tuple[str, bool] = None, capture: bool = False, **kwargs) -> Self:
305        '''
306        This function is used to match only numbers that may not contain a sequence of number or the each numbers existing independently.
307        min : int => default = 0 // if min and max are both zero it must pass a keyword argument as True 
308        max : int => default = 0
309        pattern : a tuple[str, bool] expected a return type from exclude static function
310        capture : bool => default=False //On True enclose the regex syntax in parenthesis so that regex engine capture data
311        kwargs : dict => {
312            zeroormore : bool => default=False,
313            oneormore : bool => default=False
314        }
315        return : RegexGen
316    '''
317        digitstr: str = str()
318        temp: str = str()
319
320        try:
321            temp = self.__add_quantifier(min, max, **kwargs)
322        except (...):
323            raise
324
325        if pattern is None:
326            digitstr = f"(\d{temp})" if capture else f"\d{temp}"
327        elif pattern[1]:
328            digitstr = f"((?!{pattern[0]})\d){temp}" if capture else f"(?:(?!{pattern[0]})\d){temp}"
329        else:
330            digitstr = f"((?![{pattern[0]}])\d){temp}" if capture else f"(?:(?![{pattern[0]}])\d){temp}"
331
332        self.__regex_data += digitstr
333
334        return self
335
336    def alphabets(self, min: int = 0, max: int = 0, pattern: Tuple[str, bool] = None, capture: bool = False, **kwargs) -> Self:
337        '''
338        <p><code>Alphabets</code> function matches only words(not numbers) that may not contain a sequence of letters or each of the letters exist independently.<br>
339                </p>
340        In the function definition, 
341        <code>alphabets(self, min: int = 0, max: int = 0, pattern: Tuple[str, bool] = None, capture: bool = False, **kwargs)</code>
342        , <br><br>
343        <ol class="list-group list-group-numbered">
344        <li class="list-group-item d-flex justify-content-between align-items-start">
345            <div class="ms-2 me-auto">
346                the min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True max : int (default = 0). <br>
347            </div></li>
348        <li class="list-group-item d-flex justify-content-between align-items-start">
349            <div class="ms-2 me-auto">
350                In pattern, a tuple[str, bool] is expected as a return type from exclude static function. <br>
351            </div></li>
352        <li class="list-group-item d-flex justify-content-between align-items-start">
353            <div class="ms-2 me-auto">
354                If on capture : bool (default=False), True is passed, it  encloses the regex syntax in parenthesis so that regex engine captures data.<br>
355            </div></li>
356        <li class="list-group-item d-flex justify-content-between align-items-start">
357            <div class="ms-2 me-auto">
358                The kwargs : dict accepts {<br>
359                    zeroormore : bool  (default=False), <br>
360                    oneormore : bool  (default=False)            
361            </div></li>
362            <li class="list-group-item d-flex justify-content-between align-items-start">
363                <div class="ms-2 me-auto">
364                    The return returns RegexGen
365                </div></li></ol><br>
366        <pre><code><p>regex = RegexGen().alphabets(1,5)</p></code></pre>           
367        <p>The regex is displayed as:</p>
368        <pre> regex = "[a-zA-Z]{1,5}"</pre>
369        This function is used to match only words(not numbers) that may not contain a sequence of letters or the each letters existing independently.
370        min : int => default = 0 // if min and max are both zero it must pass a keyword argument as True 
371        max : int => default = 0
372        pattern : a tuple[str, bool] expected a return type from exclude static function
373        capture : bool => default=False //On True enclose the regex syntax in parenthesis so that regex engine capture data
374        kwargs : dict => {
375            zeroormore : bool => default=False,
376            oneormore : bool => default=False
377        }
378        return : RegexGen
379    '''
380        characterstr: str = str()
381        temp: str = str()
382
383        try:
384            temp = self.__add_quantifier(min, max, **kwargs)
385        except (...):
386            raise
387
388        if pattern is None:
389            characterstr = f"([a-zA-Z]{temp})" if capture else f"[a-zA-Z]{temp}"
390        elif pattern[1]:
391            characterstr = f"((?!{pattern[0]})a-zA-Z){temp}" if capture else f"(?:(?!{pattern[0]})a-zA-Z){temp}"
392        else:
393            characterstr = f"((?![{pattern[0]}])a-zA-Z){temp}\b" if capture else f"(?:(?![{pattern[0]}])a-zA-Z){temp}"
394
395        self.__regex_data += characterstr
396
397        return self
398
399    def get_non_capturing_regex(self) -> str:
400        '''
401        If the program have capture parameters it will prevent regex engine from capturing index and patterns from the string 
402        reducing capturing overhead and hence increase efficiency
403        return : str 
404    '''
405        return f"(?:{self.__regex_data})"
406
407    def get_regex_data(self) -> str:
408        '''
409        Returns a regex syntax that may capture the text from the input string. 
410        return : str
411    '''
412        return self.__regex_data
413
414    def combine(self, regex: Self) -> Self:
415        '''
416        <p><code>Combine</code> function creates a regex syntax to combine two regex expressions in one to create a pattern.<br>
417                </p>
418        In the function definition, 
419        <code>combine(self, regex: Self)</code>
420        , the function accepts value of two different regex to perform the combination operation. <br>
421        <pre><code><p>regexa = RegexGen().digits(4,4).text(RegexGen.characters('-'))
422            regexb = RegexGen().digits(3,3)
423            regex = RegexGen.combine(regexa, regexb) </p></code></pre>           
424        
425        <p>The regex is displayed as:</p>
426        <pre> regex = "\d{4,4}-\d{3,3}"</pre>
427        regex : RegexGen //Object that has regex syntax which is addable
428        return : RegexGen 
429    '''
430        if len(regex.__regex_data) == 0:  # and regex.__regex_data[0] == '^':
431            raise Exception("Invalid regex to combine")
432
433        self.__regex_data += regex.__regex_data
434
435        return self
436
437    @staticmethod
438    def any_of(characters: str, capture: bool = False, **kwargs) -> str:
439        '''
440        <p><code>Any of</code> function is any_of_the_block with quantifiers or simply put, this function defines repetition of words in the list.</p> <br>
441        In the function definition, <code>any_of(characters: str, capture: bool = False, **kwargs) -> str:</code>,
442        <ol><li>The min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True .</li>
443        <li>In pattern, a tuple[str, bool] is expected as a return type from exclude static function.</li>
444        <li>If on capture : bool (default=False), True is passed, it encloses the regex syntax in parenthesis so that the regex engine captures data.</li>
445        <li>The kwargs : dict accepts { zeroormore : bool (default=False), oneormore : bool (default=False).</li>
446        <li>The return returns RegexGen.</li></ol>
447
448        '''
449        if valid_ranges(characters, is_number, is_lower_case, is_upper_case) or characters.find(RegexGen.symbolsrange) != -1:
450            pass
451
452        for character in characters:
453            if not type("a").isascii(character):
454                raise Exception("In function {}, character : {} => Non ascii character is not acceptable".format(
455                    RegexGen.any_of.__name__, character))
456        return f"([{characters}])" if capture else f"(?:[{characters}])"
457
458    @staticmethod
459    def characters(char: str) -> str:
460        '''
461        <p><code>Characters</code> function is a static function which is unable to create a regex syntax.<br>
462        Instead, a function like Text is used to submit to the regex syntax. <br>
463        Characters is used some characters predefined in the regex library are used and thus they need to be escaped.
464        <pre><code><p>RegexGen.text(RegexGen.characters("This+is{a$text.") </p></code></pre>           
465                        
466                        <p>The regex is displayed as:</p>
467                        <samp> regex = "This\+is\{a\$text\."</samp><br>
468        some characters are predefined in the regex library thus they need to be escaped
469        return : str 
470        </p>
471    '''
472        letters: str = str()
473        if not char:
474            raise Exception("In function {}, character : {} => Input cannot be none ".format(
475                RegexGen.character.__name__, char))
476
477        predefined_symbols: set = {
478            '\\', '.', '(', ')', '*', '{', '}', '^', '+', '?', '[', ']', '$', '|'}
479
480        for lettr in char:
481            if lettr in predefined_symbols:
482                letters += f"\\{lettr}"
483            else:
484                letters += lettr
485        return letters
486
487    def succeeded_by(self, preceeding: Tuple[str, bool], succeeding: Tuple[str, bool], min: int = 0, max: int = 0, capture: bool = False, invert: bool = False, **kwargs) -> Self:
488        '''
489        This function is used to match the pattern succeeded by another pattern.<br>
490        In the function definition, <code>succeeded_by(self, preceeding: Tuple[str, bool], succeeding: Tuple[str, bool], min: int = 0, max: int = 0, capture: bool = False, invert: bool = False, **kwargs) -> Self:</code>,
491        <ol><li>The min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True .</li>
492        <li>In pattern, a tuple[str, bool] is expected as a return type from exclude static function.</li>
493        <li>If on capture : bool (default=False), True is passed, it encloses the regex syntax in parenthesis so that the regex engine captures data.</li>
494        <li>The kwargs : dict accepts { zeroormore : bool (default=False), oneormore : bool (default=False).</li>
495        <li>The return returns RegexGen.</li></ol>
496    '''
497        if not preceeding or len(preceeding) != 2:
498            raise Exception("In function {} => characters1 tuple cannot be none or its length must be 2".format(
499                RegexGen.succeeded_by.__name__))
500        if not succeeding or len(succeeding) != 2:
501            raise Exception("In function {} => characters2 tuple cannot be none or its length must be 2".format(
502                RegexGen.succeeded_by.__name__))
503
504        characterstr: str = str()
505        temp: str = str()
506
507        try:
508            temp = self.__add_quantifier(min, max, **kwargs)
509        except (...):
510            raise
511
512        followblock: str = str()
513        if invert:
514            followblock = f"(?!{succeeding[0]})" if succeeding[1] else f"(?![{succeeding[0]}])"
515        else:
516            followblock = f"(?={succeeding[0]})" if succeeding[1] else f"(?=[{succeeding[0]}])"
517
518        precedingblock: str = f"{preceeding[0]}{temp}" if preceeding[1] else f"[{preceeding[0]}]{temp}"
519
520        if len(self.__regex_data) > len(precedingblock) and \
521                self.__regex_data.rindex(precedingblock) == len(self.__regex_data)-len(precedingblock)-1:
522            characterstr += followblock
523            self.__regex_data = self.__regex_data[:-1]
524            characterstr += ')'
525        else:
526            characterstr = precedingblock + followblock
527            characterstr = f"({characterstr})" if capture else f"(?:{characterstr})"
528        self.__regex_data += characterstr
529        return self
530
531    def preceded_by(self, preceding: Tuple[str, bool], succeeding: Tuple[str, bool], min: int = 0, max: int = 0, capture: bool = False, invert: bool = False, **kwargs) -> Self:
532        '''
533        This function is used to match pattern that is preceded by another pattern.<br>
534        If the pattern of the succeeded_by and preceeded_by matches the combination is union. <br>
535      In the function definition, <code>preceded_by(self, preceding: Tuple[str, bool], succeeding: Tuple[str, bool], min: int = 0, max: int = 0, capture: bool = False, invert: bool = False, **kwargs) -> Self:</code>,
536        <ol><li>The min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True .</li>
537        <li>In pattern, a tuple[str, bool] is expected as a return type from exclude static function.</li>
538        <li>If on capture : bool (default=False), True is passed, it encloses the regex syntax in parenthesis so that the regex engine captures data.</li>
539        <li>The kwargs : dict accepts { zeroormore : bool (default=False), oneormore : bool (default=False).</li>
540        <li>The return returns RegexGen.</li></ol>
541    '''
542        if not preceding or len(preceding) != 2:
543            raise Exception("In function {} => characters1 tuple cannot be none or its length must be 2".format(
544                RegexGen.preceded_by.__name__))
545        if not succeeding or len(succeeding) != 2:
546            raise Exception("In function {} => characters2 tuple cannot be none or its length must be 2".format(
547                RegexGen.preceded_by.__name__))
548
549        characterstr: str = str()
550        temp: str = str()
551
552        try:
553            temp = self.__add_quantifier(min, max, **kwargs)
554        except (...):
555            raise
556
557        preceedingblock: str = str()
558        if invert:
559            preceedingblock = f"(?<!{preceding[0]})" if preceding[1] else f"(?<![{preceding[0]}])"
560        else:
561            preceedingblock = f"(?<={preceding[0]})" if preceding[1] else f"(?<=[{preceding[0]}])"
562
563        followblock: str = f"{succeeding[0]}{temp}" if succeeding[1] else f"[{succeeding[0]}]{temp}"
564        characterstr = preceedingblock + followblock
565        characterstr = f"({characterstr})" if capture else f"(?:{characterstr})"
566        self.__regex_data += characterstr
567        return self
568
569    # @staticmethod
570    # def any_of(characters: tuple[dict], capture: bool = False, **kwargs) -> str:
571    #     '''
572    #     This function is any_of_the_block with quantifiers or this function defines repetition of words in the list. <br>
573    #     In the function definition, <code>any_of(characters: tuple[dict], capture: bool = False, **kwargs) -> str:</code>,
574    #     <ol><li>The min : int and max : int has default = 0. If min and max are both zero it must pass a keyword argument as True .</li>
575    #     <li>In pattern, a tuple[str, bool] is expected as a return type from exclude static function.</li>
576    #     <li>If on capture : bool (default=False), True is passed, it encloses the regex syntax in parenthesis so that the regex engine captures data.</li>
577    #     <li>The kwargs : dict accepts { zeroormore : bool (default=False), oneormore : bool (default=False).</li>
578    #     <li>The return returns RegexGen.</li></ol>
579    #     '''
580    #     character_str = str()
581    #     tempstr = str()
582
583    #     if not len(characters):
584    #         return ""
585
586    #     character_pair = list()
587    #     for index, listitem in enumerate(characters):
588    #         character = listitem.pop("character", None)
589    #         min = listitem.pop("min", 0)
590    #         max = listitem.pop("max", 0)
591    #         if character is None:
592    #             raise Exception("In function {}, at index {} doesn't have character pair.".format(
593    #                 RegexGen.any_of.__name__, index))
594    #         if len(character) == 0:
595    #             continue
596    #         elif len(character) == 1 or (len(character) == 2 and character in {"\s", "\d", "\w", "\W"}):
597    #             pass
598    #         elif len(character) == 3 and valid_ranges(character, is_lower_case, is_number, is_upper_case):
599    #             pass
600    #         else:
601    #             raise Exception("In function {}, at index {}, Unknown Character: {}.".format(
602    #                 RegexGen.any_of.__name__, index, character))
603    #         tempstr = RegexGen.__add_quantifier(min=min, max=max, **listitem)
604    #         character_pair.append(character+tempstr)
605
606    #     character_str = "|".join(character_pair)
607    #     return f"({character_str})" if capture else f"(?:{character_str})"