def test_accent():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\hat{a}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'block'
assert cv[0].get_children()[0].content == 'a'
assert cv[0].accent == 'hat'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\acute a'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].accent == 'acute'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\hat{ab}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'block'
assert cv[0].accent == 'hat'
assert cv[0].get_children()[0].content == 'a'
assert cv[0].get_children()[1].content == 'b'
def test_style():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\mathit{a}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'block'
assert cv[0].style == 'mathit'
assert cv[0].get_children()[0].content == 'a'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\mathbf a'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].style == 'mathbf'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'\mathrm{ab}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'block'
assert cv[0].style == 'mathrm'
assert cv[0].get_children()[0].content == 'a'
assert cv[0].get_children()[1].content == 'b'
def test_binom():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\binom \Leftrightarrow \Gamma'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'binom'
assert len(cv1[0].get_children()) == 2
assert cv1[0].get_children()[0].content == 'Leftrightarrow'
assert cv1[0].get_children()[1].content == 'Gamma'
latex_string2 = r'\binom \Leftrightarrow {\Gamma}'
cv2 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'binom'
assert len(cv2[0].get_children()) == 2
assert cv2[0].get_children()[0].content == 'Leftrightarrow'
assert cv2[0].get_children()[1].content == 'Gamma'
latex_string3 = r'\binom {\Leftrightarrow} \Gamma'
cv3 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv3) is list
assert cv3[0].content == 'binom'
assert len(cv3[0].get_children()) == 2
assert cv3[0].get_children()[0].content == 'Leftrightarrow'
assert cv3[0].get_children()[1].content == 'Gamma'
latex_string4 = r'\binom {\Leftrightarrow} {\Gamma}'
cv4 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv4) is list
assert cv4[0].content == 'binom'
assert len(cv4[0].get_children()) == 2
assert cv4[0].get_children()[0].content == 'Leftrightarrow'
assert cv4[0].get_children()[1].content == 'Gamma'
def test_token_sqrt():
simple_sqrt = '\sqrt a'
simple_sqrt_tokens = ['ROOT', 'CHAR']
lexer_test = lexer.get_lexer()
lexer_test.input(simple_sqrt)
list_of_tokens = get_list_token(lexer_test)
assert list_of_tokens == simple_sqrt_tokens
def test_frac():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\frac 1 a'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'fraction'
assert cv1[0].get_children()[0].content == '1'
assert cv1[0].get_children()[1].content == 'a'
latex_string2 = r'\frac \alpha {\bigcap}'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'fraction'
assert cv2[0].get_children()[0].content == 'alpha'
assert cv2[0].get_children()[1].content == 'block'
assert cv2[0].get_children()[1].get_children()[0].content == 'bigcap'
latex_string3 = r'\frac {\sqcap} \ni '
cv3 = custom_parser.parse(latex_string3, custom_lexer)
assert type(cv3) is list
assert cv3[0].content == 'fraction'
assert cv3[0].get_children()[0].content == 'block'
assert cv3[0].get_children()[0].get_children()[0].content == 'sqcap'
assert cv3[0].get_children()[1].content == 'ni'
latex_string4 = r'\frac {\leftarrow}{\rangle}'
cv4 = custom_parser.parse(latex_string4, custom_lexer)
assert type(cv4) is list
assert cv4[0].content == 'fraction'
assert cv4[0].get_children()[0].content == 'block'
assert cv4[0].get_children()[0].get_children()[0].content == 'leftarrow'
assert cv4[0].get_children()[1].content == 'block'
assert cv4[0].get_children()[1].get_children()[0].content == 'rangle'
def test_kbinop():
custom_parser = parser.get_parser()
latex_string = 'x+3'
custom_lexer = lexer.get_lexer()
cv = custom_parser.parse(latex_string,custom_lexer)
assert cv.left.content == 'x'
assert cv.content == '+'
assert cv.right.content == '3'
def test_block():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = '{a}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'block'
assert cv[0].get_children()[0].content == 'a'
def test_compound_indexes():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = 'a^b_c'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].superscript[0].content == 'b'
assert cv[0].subscript[0].content == 'c'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'a_c^b'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].superscript[0].content == 'b'
assert cv[0].subscript[0].content == 'c'
def test_sqrt():
custom_parser = parser.get_parser()
latex_string = '\sqrt[8]{x}'
custom_lexer = lexer.get_lexer()
cv = custom_parser.parse(latex_string,custom_lexer)
assert cv.left is None
assert cv.content == 'sqrt'
assert cv.superscript.content == '8'
assert cv.right.content == 'x'
def test_simple_indexes():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = 'a^b'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].superscript[0].content == 'b'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'a^{b}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].superscript[0].content == 'block'
assert cv[0].superscript[0].get_children()[0].content == 'b'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = 'a_b'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].subscript[0].content == 'b'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'a_{b}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].subscript[0].content == 'block'
assert cv[0].subscript[0].get_children()[0].content == 'b'
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string = r'a_{b^c}'
cv = custom_parser.parse(latex_string, custom_lexer)
assert type(cv) is list
assert cv[0].content == 'a'
assert cv[0].subscript[0].content == 'block'
assert cv[0].subscript[0].get_children()[0].content == 'b'
assert cv[0].subscript[0].get_children()[0].superscript[0].content == 'c'
def test_label():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\label{my label}'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'label'
assert cv1[0].get_children(
) == 'label{my label}' #A label it is not a math object.
def test_symbol():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = 'a'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'a'
latex_string2 = '1'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == '1'
latex_string3 = r'\alpha'
cv3 = custom_parser.parse(latex_string3, custom_lexer)
assert type(cv2) is list
assert cv3[0].content == 'alpha'
def test_concatenation():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'ab'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'a'
assert cv1[1].content == 'b'
latex_string2 = r'a^2b_i^3'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert cv2[0].content == 'a'
assert cv2[0].superscript[0].content == '2'
assert cv2[1].content == 'b'
assert cv2[1].subscript[0].content == 'i'
assert cv2[1].superscript[0].content == '3'
def test_pmod():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\pmod \epsilon'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'pmod'
assert cv1[0].get_children()[0].content == 'epsilon'
assert len(cv1[0].get_children()) == 1
latex_string2 = r'\pmod {\oplus}'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'pmod'
assert cv2[0].get_children()[0].content == 'block'
assert cv2[0].get_children()[0].get_children()[0].content == 'oplus'
assert len(cv2[0].get_children()) == 1
def test_root():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\sqrt \wp'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'root'
assert len(cv1[0].children) == 1
assert cv1[0].get_children()[0].content == 'wp'
latex_string2 = r'\sqrt{\clubsuit}'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'root'
assert len(cv2[0].get_children()) == 1
assert cv2[0].get_children()[0].content == 'block'
assert cv2[0].get_children()[0].get_children()[0].content == 'clubsuit'
latex_string3 = r'\sqrt [\sum] \uplus'
cv3 = custom_parser.parse(latex_string3, custom_lexer)
assert type(cv3) is list
assert cv3[0].content == 'root'
assert len(cv3[0].get_children()) == 2
assert cv3[0].get_children()[0].content == 'sum'
assert cv3[0].get_children()[1].content == 'uplus'
latex_string4 = r'\sqrt [\sum] {\uplus}'
cv4 = custom_parser.parse(latex_string4, custom_lexer)
assert type(cv4) is list
assert cv4[0].content == 'root'
assert len(cv4[0].get_children()) == 2
assert cv4[0].get_children()[0].content == 'sum'
assert cv4[0].get_children()[1].content == 'block'
assert cv4[0].get_children()[1].get_children()[0].content == 'uplus'
latex_string5 = r'\sqrt [[] ]'
cv5 = custom_parser.parse(latex_string5, custom_lexer)
assert type(cv5) is list
assert cv5[0].content == 'root'
assert len(cv5[0].get_children()) == 2
assert cv5[0].get_children()[0].content == '['
assert cv5[0].get_children()[1].content == ']'
def test_text():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'\text a'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'text'
assert cv1[0].get_children(
) == 'a' #A text character it is not a math object.
#assert len(cv1[0].get_children()) == 1
latex_string2 = r'\textrm {zb c 1 2 34 (d5)}'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'text'
#assert len(cv2[0].get_children()) == 1
assert cv2[0].get_children(
) == 'zb c 1 2 34 (d5)' #A text character it is not a math object.
def test_choose():
custom_parser = parser.get_parser()
custom_lexer = lexer.get_lexer()
latex_string1 = r'a \choose b'
cv1 = custom_parser.parse(latex_string1, custom_lexer)
assert type(cv1) is list
assert cv1[0].content == 'choose'
assert len(cv1[0].get_children()) == 2
assert cv1[0].get_children()[0].content == 'a'
assert cv1[0].get_children()[1].content == 'b'
latex_string2 = r'{\oint \choose \leftrightarrow}'
cv2 = custom_parser.parse(latex_string2, custom_lexer)
assert type(cv2) is list
assert cv2[0].content == 'block'
assert cv2[0].get_children()[0].content == 'choose'
assert len(cv2[0].get_children()) == 1
assert len(cv2[0].get_children()[0].get_children()) == 2
assert cv2[0].get_children()[0].get_children()[0].content == 'oint'
assert cv2[0].get_children()[0].get_children(
)[1].content == 'leftrightarrow'
def test_t_SUP():
SUP = '^'
lexer_test = lexer.get_lexer()
lexer_test.input(SUP)
list_of_tokens = get_list_token(lexer_test)
assert all(['SUP' == token for token in list_of_tokens ])
def test_t_KBINOP():
KBINOP = '+-*/'
lexer_test = lexer.get_lexer()
lexer_test.input(KBINOP)
list_of_tokens = get_list_token(lexer_test)
assert all(['KBINOP' == token for token in list_of_tokens ])
def test_t_NUM():
NUM = '1234567890'
lexer_test = lexer.get_lexer()
lexer_test.input(NUM)
list_of_tokens = get_list_token(lexer_test)
assert all(['NUM' == token for token in list_of_tokens ])
def test_t_CHAR():
CHAR = 'blindtex'
lexer_test = lexer.get_lexer()
lexer_test.input(CHAR)
list_of_tokens = get_list_token(lexer_test)
assert all(['CHAR' == token for token in list_of_tokens ])
def test_t_KDELIMITER():
KDELIMITER = '()[]'
lexer_test = lexer.get_lexer()
lexer_test.input(KDELIMITER)
list_of_tokens = get_list_token(lexer_test)
assert all(['KDELIMITER' == token for token in list_of_tokens ])
def latex2list(latex_srt):
par = parser.get_parser()
lex = lexer.get_lexer()
return par.parse(latex_srt, lex)
def test_t_command_LABEL():
command_LABEL = r'\label{my label}'
lexer_test = lexer.get_lexer()
lexer_test.input(command_LABEL)
list_of_tokens = get_list_token(lexer_test)
assert all(['LABEL' == token for token in list_of_tokens])
def test_t_KDELIMITER():
KDELIMITER = '()' #For reasons [ and ] must be taken.
lexer_test = lexer.get_lexer()
lexer_test.input(KDELIMITER)
list_of_tokens = get_list_token(lexer_test)
assert all(['KDELIMITER' == token for token in list_of_tokens])
def test_t_COMMAND():
COMMAND = '\\'
lexer_test = lexer.get_lexer()
lexer_test.input(COMMAND)
list_of_tokens = get_list_token(lexer_test)
assert all(['COMMAND' == token for token in list_of_tokens ])
def test_t_command_ROOT():
command_ROOT = '\\sqrt'
lexer_test = lexer.get_lexer()
lexer_test.input(command_ROOT)
list_of_tokens = get_list_token(lexer_test)
assert all(['ROOT' == token for token in list_of_tokens ])
def test_t_BEGINBLOCK():
BEGINBLOCK = '{'
lexer_test = lexer.get_lexer()
lexer_test.input(BEGINBLOCK)
list_of_tokens = get_list_token(lexer_test)
assert all(['BEGINBLOCK' == token for token in list_of_tokens ])
| TEXT ANYTHING'''
p[0] = MathObject(content='text')
p[0].append_child(p[2])
def p_label(p):
'''label : LABEL '''
p[0] = MathObject(content='label')
p[0].append_child(p[1])
def get_parser():
return ply.yacc.yacc()
if __name__ == "__main__":
parser = get_parser()
lexer = lexer.get_lexer()
#cv = parser.parse(latex_string,custom_lexer)#,debug=1)
while True:
try:
try:
s = raw_input()
except NameError: # Python3
s = input('spi> ')
cv_s = parser.parse(s, lexer)
print(cv_s)
except EOFError:
break
def test_t_ENDBLOCK():
ENDBLOCK = '}'
lexer_test = lexer.get_lexer()
lexer_test.input(ENDBLOCK)
list_of_tokens = get_list_token(lexer_test)
assert all(['ENDBLOCK' == token for token in list_of_tokens ])
