Homec4science
Diffusion Slides (line-numbering-platex) Browse

R3683/PythonLatex/generate_latex.py
53ceff8dd557line-numbering-platex

Last Change
Raw File

generate_latex.py
View Options

#! /usr/bin/python
import re as myre
import subprocess
import PythonLatex.latex_structure as tex
import matplotlib.pyplot as plt
import types
import sympy as sym
import hashlib,dill
################################################################
from sympy.printing.latex import LatexPrinter
from sympy import latex
from sympy.core.function import Derivative
class CustomStrPrinter(LatexPrinter):
def nbIdenticalDx(self,expr):
first_dx = expr.args[1:][0]
count = 0
for dx in expr.args[1:]:
if dx == first_dx:
count += 1
if count == len(expr.args[1:]):
return count,first_dx
return 0,None
def _print_Derivative(self, expr):
# print expr
# print LatexPrinter._print_Derivative(self,expr)
count,dx = self.nbIdenticalDx(expr)
f = expr.args[0]
if len(f.args) == 0:
return LatexPrinter._print_Derivative(self,expr)
dxf = f.args[0]
f_nargs = len(f.args)
# case where ' applies
if f_nargs == 1 and dx == dxf:
return latex(expr.args[0].func) + "'"*len(expr.args[1:]) + "(" + latex(dxf) + ")"
return LatexPrinter._print_Derivative(self,expr)
def _print_Subs(self,expr):
if not isinstance(expr.args[0],Derivative):
return LatexPrinter._print_Subs(self,expr)
# print expr
deriv = expr.args[0]
_dxs = deriv.args[1:]
# print _dxs
p1 = expr.args[1]
p2 = expr.args[2]
# print len(_dxs)
_subst = {}
_subst2 = {}
for i in range(0,len(p1)):
_subst[p1[i]] = p2[i]
#
if hasattr(p2[i],'args'):
_p2 = type(p2[i])
_subst2[p1[i]] = _p2
_dxs = [e.subs(_subst2) for e in _dxs ]
new_f = deriv.args[0].subs(_subst)
# print 'CCCCCCCCC'
# print new_f
# print _dxs
# print _subst
tmp = Derivative(new_f,*_dxs)
# print tmp
return latex(tmp)
# return LatexPrinter._print_Subs(self,expr)
################################################################
class PyCode(tex.LatexBlock):
"""
"""
def checkLine(self,line):
m = myre.match(r"\\end{python}",line)
if m:
return Block()
return Block.checkLine(self,line)
def checkValidity(self):
for c in self.content:
if type(c) == types.InstanceType:
raise Exception("python block cannot have subblocks")
def __str__(self):
return ""
def generateHashSource(self):
txt_content = self.content[0]
self.hash_source = hashlib.sha1(txt_content).hexdigest()
gl = globals()
self.global_keys_before = gl.keys()
self.local_keys_before = self.__dict__.keys()
def needReexecute(self):
if self.alias == 'header': return True
if 'loaded_hash_source' in self.__dict__:
return not self.loaded_hash_source == self.hash_source
return True
def saveBlockOutputInfo(self):
if self.alias == 'header': return
global_keys = globals().keys()
global_keys_to_save = set(global_keys) - set(self.global_keys_before)
global_keys_to_save = list(global_keys_to_save)
global_entries_to_save = dict([(e,globals()[e]) for e in global_keys_to_save])
local_keys = self.__dict__.keys()
local_keys_to_save = set(local_keys) - set(self.local_keys_before)
local_keys_to_save = list(local_keys_to_save)
local_entries_to_save = dict([(e,self.__dict__[e]) for e in local_keys_to_save])
try:
for k in global_entries_to_save:
try:
print 'try to save ',k,' ',latex(global_entries_to_save[k])
global_entries_to_save[k] = dill.dumps(global_entries_to_save[k])
print 'saved ',k
except Exception as e:
print e
self.global_block_result = dill.dumps(global_entries_to_save)
self.local_block_result = dill.dumps(local_entries_to_save)
self.global_hash_result = hashlib.sha1(self.global_block_result).hexdigest()
self.local_hash_result = hashlib.sha1(self.local_block_result).hexdigest()
except Exception as e:
print "cannot save block: {0}\n{1}".format(self.alias,e)
self.global_block_result = None
self.global_hash_result = None
self.local_block_result = None
self.local_hash_result = None
self.hash_source = None
filename = self.alias + '.pytex.out'
f = open(filename,'w')
# print "save symbols {0}: hash_source {1}".format(self.alias,self.hash_source)
raw_save = [self.hash_source,self.global_hash_result,self.global_block_result,self.local_hash_result,self.local_block_result]
dill.dump(raw_save,f)
f.close()
def loadBlockOutputInfo(self):
return
if self.alias == 'header': return
filename = self.alias + '.pytex.out'
try:
f = open(filename,'r')
self.loaded_hash_source,self.global_hash_result,self.global_block_result,self.local_hash_result,self.local_block_result = dill.load(f)
# print "loaded symbols"
#print "AAAAAAAAAAA " + str(self.loaded_hash_source)
globals().update(dill.loads(self.global_block_result))
self.__dict__.update(dill.loads(self.local_block_result))
# print pickle.loads(self.global_block_result).keys()
# print self.__dict__.keys()
f.close()
print 'loaded {0}'.format(filename)
except Exception as e:
# print "Could not load block " + self.alias
# print e
pass
def evalBlock(self):
txt_content = self.content[0]
self.generateHashSource()
self.loadBlockOutputInfo()
need_reexecute = self.needReexecute()
if need_reexecute or reexec:
print "execute block: {0}".format(self.alias)
gl = globals()
gl.update({'self':self})
try:
exec(txt_content,gl)
except Exception as e:
mesg = """For block '{0}' there was an execution problem
{1}
Block was:
************
{2}
""".format(self.alias,e,txt_content)
if (not continue_flag): raise Exception(mesg)
else: print (mesg)
del gl['self']
self.saveBlockOutputInfo()
def getContent(self,varname):
try:
c = self.__dict__[varname]
except Exception as e:
raise Exception("cannot retreive variable " + varname + " from block " + self.alias)
if (myre.search('sympy',str(type(c)))):
c = sym.latex(c)
return c
def __init__(self,name,parent,options):
tex.LatexBlock.__init__(self,name,parent,options)
if not self.name == 'python':
raise Exception('cannot create a PyCode block from block type ' + self.name)
if self.options is None:
raise Exception("not valid python block")
m = myre.match(r"{(.*?)}",self.options)
if not m:
raise Exception("not valid options " + self.options)
self.alias = m.group(1)
self.block_eval = None
################################################################
def evaluatePythonBlock(b):
if b.name == 'python':
globals()[b.alias] = b
b.evalBlock()
def replaceAliases(b,text):
if b.name == 'python':
return text
if type(text) == str:
# print text
regex = r'\\py{(.*?)}'
m = myre.findall(regex,text)
if not m:
return text
# print text
for expression in m:
# print expression
try:
exec("ans = " + expression)
except Exception as e:
print "Block " + str(b.name) + " Cannot parse expression '" + str(expression) + "'\n" + str(e)
rep = '\\py{' + expression + '}'
try:
ans_str = str(latex(ans))
except Exception as e:
print "AAAAAAAA " + str(e)
return text
# print "ans is now " + str(ans)
globals().update({'ans':ans})
# print "replace " + rep + " with " + cont
text = text.replace(rep,ans_str,1)
#print text
return text
################################################################
def collectScript(b,text):
if b.name == 'python':
globals()['total_python_script'] += "{0} = CodeEval()".format(b.alias)
globals()['total_python_script'] += text.replace('self',b.alias)
return text
if type(text) == str:
# print text
regex = r'\\py{(.*?)}'
m = myre.findall(regex,text)
if not m:
return text
# print m
for expression in m:
globals()['total_python_script'] += "print 'printing expression: {0}'\n".format(str(expression).replace("'","\\'"))
globals()['total_python_script'] += "ans = " + expression + "\n"
globals()['total_python_script'] += "print str(latex(ans)) + '\\n\\n'\n"
return text
################################################################
continue_flag = False
reexec = True
def interpretPython(filename,c_flag, reexec_flag):
continue_flag = c_flag
reexec = reexec_flag
tex_struct = tex.LatexStructure()
tex_struct.buildLatexBlocks(filename,{'python':PyCode})
total_python_script = """
from PythonLatex.generate_latex import *
class CodeEval:
pass
"""
globals().update({'total_python_script':total_python_script})
globals().update({'reexec':reexec})
globals().update({'continue_flag':continue_flag})
tex_struct.pathInBlock(ftext=collectScript)
tex_struct.pathInBlock(fbegin=evaluatePythonBlock,ftext=replaceAliases)
total_python_script = globals()['total_python_script']
#
# pyblocks = tex_struct.getBlocksFromType("python")
#
# for b in pyblocks:
# total_python_script += b.content[0]
#
tmp_file = open('python_script.py','w')
tmp_file.write(total_python_script)
tmp_file.close()
return str(tex_struct)
c4science · Help