4. Regex Representation in Python

In this laboratory we will be using Python3 classes to introduce a possible representation of regular expressions inside code and ways to work with those Regexes.

We will start with a base class Regex that will function as an interface for future descendents:

class Regex:
    '''Base class for Regex ADT'''
 
    def __str__(self) -> str:
        '''Returns the string representation of the regular expression'''
        pass
 
    def gen(self) -> [str]:
        '''Return a representative set of strings that the regular expression can generate'''
        pass
 
    def eval_gen(self):
        '''Prints the set of strings that the regular expression can generate'''
        pass

We remark the following aspects:

Your task is to implement the missing pieces of code from the regex.py file following the comments in the TODOS:

# This is an auxiliary method used to generate our strings by length and alphabetically
# E.g: (b | aa)* = [b, aa, bb, aab, bbb, aaaa, ...]
def convert_to_sorted_set(lst: [str]) -> [str]:
    '''Converts a list to a sorted set'''
    crt_lst = list(set(lst))
    return sorted(crt_lst, key = lambda x: (len(x), x))
 
# Global variable used to threshold the number of Star items
INNER_STAR_NO_ITEMS = 3
 
class Regex:
    '''Base class for Regex ADT'''
 
    def __str__(self) -> str:
        '''Returns the string representation of the regular expression'''
        pass
 
    def gen(self) -> [str]:
        '''Return a representative set of strings that the regular expression can generate'''
        pass
 
    def eval_gen(self):
        '''Prints the set of strings that the regular expression can generate'''
        pass
 
# TODO 0: Implementati Clasa Void dupa blueprint-ul de mai sus
class Void(Regex):
    '''Represents the empty regular expression'''
 
    # Va returna Void ca string
    def __str__(self) -> str:
        pass
 
    # Va genera un obiect din Python corespunzatoar clasei void
    def gen(self) -> [str]:
        pass
 
    def eval_gen(self):
        print("Void generates nothing")
 
 
# TODO 1: Implementati Clasa Epsilon-String (Empty) dupa blueprint-ul de mai sus
class Empty(Regex):
    '''Represents the empty string regular expression'''
 
    # Va returna Empty ca string
    def __str__(self) -> str:
        pass
 
    # Va returna o lista corespunzatoare a ce stringuri produce sirul vid
    def gen(self) -> [str]:
        pass
 
    def eval_gen(self):
        print("Empty string generates ''.")
 
# TODO 2: Implementati functionalitatile necesare pentru Clasa Symbol dupa blueprint-ul de mai sus
class Symbol(Regex):
    '''Represents a symbol in the regular expression'''
 
    def __init__(self, char: str):
        self.char = char
 
    # TODO 2: Completati metodele __str__ si gen pentru clasa Symbol    
    def __str__(self) -> str:
        pass
 
    def gen(self) -> [str]:
        pass
 
    def eval_gen(self):
        self.gen()
 
	# Dorim sa pastram in atributul words al clasei curente stringurile generate cu gen(self)
        return "Symbol {self.char} generates {self.words}"
 
# TODO 3: Implementati functionalitatile necesare pentru Clasa Union dupa blueprint-ul de mai sus
class Union(Regex):
    '''Represents the union of two regular expressions'''
    def __init__(self, *arg: [Regex]):
        self.components = arg
 
    # TODO 3: Completati metodele __str__, gen si eval_gen pentru clasa Union    
    def __str__(self) -> str:
        pass
 
    def gen(self) -> [str]:
	pass
 
    # Dupa modelul de la Symbol, vom dori ca urmatoarele eval sa implementeze
    # return "Class {varianta toString() a clasei) generates {self.words}"
    def eval_gen(self) -> str:
	pass
 
# TODO 4: Implementati functionalitatile necesare pentru Clasa Concat dupa blueprint-ul de mai sus
class Concat(Regex):
    '''Represents the concatenation of two regular expressions'''
 
    def __init__(self, *arg : [Regex]):
        self.components = arg
 
    # TODO 4: Completati metodele __str__, gen si eval_gen pentru clasa Concat
    def __str__(self) -> str:
        pass
 
    def gen(self) -> [str]:
	pass
 
    def eval_gen(self) -> str:
	pass
 
# TODO 5: Implementati functionalitatile necesare pentru Clasa Star dupa blueprint-ul de mai sus
class Star(Regex):
    '''Represents the Kleene star (zero or more repetitions) of a regular expression'''
    def __init__(self, regex: Regex):
        self.regex = regex
        self.base_words = [""]
        self.base_gen()
        self.words = []
 
 
    # TODO 5: Completati metodele __str__, gen, eval_gen pentru clasa Star
    def __str__(self):
        pass
 
    def base_gen(self):
        '''To memorize the base words generated by the regex inside the star, we store them in a list'''
        if type(self.regex) == Star:
	    # Implement Star.gen with a limiting threshold
	    pass
 
	# Implement Regex.gen for the rest
	pass            
 
 
    def gen(self, no_items = 10):
	pass
 
    def eval_gen(self, no_items = 10):
	pass
 
 
if __name__ == "__main__":
 
    # Example usage
 
    r1 = Symbol('a')
    r2 = Symbol('b')
    regex_union = Union(r1, r2)
    regex_union.eval_gen()
 
    e2 = Union(Symbol('a'),Symbol('b'), Symbol('c'))
    e4 = Concat(r1, e2)
    e4.eval_gen()
 
    e5 = Concat(e2, e2, r2)
    e5.eval_gen()
 
    star_ex = Star(r1)
    star_ex.eval_gen()
 
    regex_concat = Concat(regex_union, star_ex)
    regex_concat.eval_gen()
 
    last_expr = Concat(Star(Union(Symbol('a'), Symbol('b'))), Symbol('b'), Star(Symbol('c')))
    last_expr.eval_gen()
 

OBSERVATII DESPRE CUM ARATA ASTEA → CONCAT STAR ETC

EXEMPLU DE OUTPUT PENTRU MAIN

DE SCRIS DESPRE CUM DACA PREFERA ALTFEL SA IMPLEMENTEZE CHAR, LEGATURA CU UNION SI CONCAT ( DE CE E CHAR LISTA), A*, SI NR DE PARAMETRII IN CONCATENARI/UNION POT FACE CUM VOR EI.