forked from EngineX-Cambricon/enginex-mlu370-vllm
3553 lines
156 KiB
Python
3553 lines
156 KiB
Python
#!/usr/bin/python
|
||
# -*- coding: UTF-8
|
||
'''
|
||
注意：
|
||
修改该文件，print打印信息中不能包含中文，否则在不支持中文的操作系统中会出现如下的错误，
|
||
导致编译失败或者达不到预期的显示效果。
|
||
'ascii' codec can't encode characters in position
|
||
|
||
2023年12月04日 修改历史
|
||
------------------------------------
|
||
|
||
主要修改以下bug：
|
||
1. 当表格通过class属性设置为longtable，但是表头用“-”分割而不是用“=”分割的时候，在sphinx5.3.0以下版本编译失败的问题。
|
||
如果没有替换最新的parsejson.py文件，该bug在sphinx 5.3.0以下版本，可以采用以下方式规避：
|
||
当表格设置为longtable时，表头改用“=”分割，而不是“-”分割，可以规避该问题。
|
||
如果替换了最新的parsejson.py文件，则不存在该问题，无需刻意规避。
|
||
2. 修复了当表头为两行，并且合并列单元格放在表格的最前几列的时候，表头中的横线制表符没有画的bug。
|
||
|
||
优化了以下实现方式：
|
||
1. 将sphinx 5.3.0之后版本，为了适配表格改动所做的修改，固定在该文件的ModifyReplacePackage函数中。
|
||
这样只需替换该文件，而无需再修改conf.json文件，即可兼容sphinx5.3.0之前及之后版本，做到全版本兼容。
|
||
2. 当有合并单元格的表头时，如果用“widths”参数设置的列宽，则表头中的标题不会自动换行，必须手动换行。
|
||
如果用“tabularcolumns”指令设置的列宽，则默认会自动换行。之前的行为是默认都会自动换行。
|
||
因此当前的实现要想使表头能够自动换行，必须采用tabularcolumns指令设置每一列的列宽。如果用“widths”设置列宽，只能手动换行。
|
||
修改原因：
|
||
因为如果要实现自动换行，每一列的列宽必须以“m{0.1\textwidth}”这种方式实现，之前是把“widths”设置的列宽进行了转换。
|
||
这种转换对于列比较少的表格没什么问题。但是当表格比较大，列比较多时，这种转换就导致表格的显示超出了页面可显示的宽度，
|
||
而且也会导致如何修改“widths”的值，都没什么效果。因此修改了自动换行的规则。
|
||
结论：
|
||
对于列比较多而且表头有合并单元格的表格，建议用“tabularcolumns”设置每一列的列宽，因为该指令相当于latex的原始指令，设置的列宽直接反应每一列的实际宽度。
|
||
对于表头没有合并单元格的表格，建议用“widths”设置列宽比较简单，让sphinx转化实际的列宽，同时对latex和html都生效。
|
||
|
||
2023年11月15日 修改历史
|
||
----------------------------
|
||
将路径字符串相加的赋值方式，修改为os.path.join的方式，解决编译文档提示如下告警的问题：
|
||
RemovedInSphinx80Warning: Sphinx 8 will drop support for representing paths as strings. Use "pathlib.Path" or "os.fspath" instead.
|
||
sphinx 8之后将不再支持字符串表示路径。
|
||
使用os.path.join的方式一定要特别注意以下几点：
|
||
1.join函数会自动添加“/”符号，因此一定不要再添加多余的“/”，否则可能得到的路径是错误的。
|
||
2.join可以链接超过两个的路径，但是最后一个要链接的路径一定不能加“/”符号，否则前面的路径都失效。举例如下：
|
||
path1 = "home"
|
||
path2 = "rst"
|
||
path3 = "/meerkat"
|
||
path = os.path.join(path1,path2,path3)
|
||
则得到的path为“/meerkat”，因此最后一个被链接的路径一定不能加“/”。
|
||
|
||
'''
|
||
|
||
from __future__ import print_function
|
||
|
||
import os
|
||
import sys
|
||
import json
|
||
import re
|
||
import codecs
|
||
import shutil
|
||
import platform
|
||
import traceback
|
||
import datetime as dt
|
||
from subprocess import Popen, PIPE, STDOUT
|
||
#import importlib
|
||
|
||
try:
|
||
import sphinx
|
||
sphinx_version = sphinx.__display_version__[0:3]
|
||
except Exception as e:
|
||
sphinx_version = ""
|
||
|
||
Py_version = sys.version_info
|
||
Py_v_info = str(Py_version.major) + '.' + str(Py_version.minor) + '.' + str(Py_version.micro)
|
||
|
||
#if Py_version >= (3,5,0) and Py_version <(3,7,0):
|
||
# print(False)
|
||
#
|
||
#if Py_version >= (3,7,0):
|
||
# print(True)
|
||
#
|
||
#if platform.system().lower() == 'windows':
|
||
# print("windows")
|
||
#elif platform.system().lower() == 'linux':
|
||
# print("linux")
|
||
|
||
filepathlist=os.path.split(os.path.realpath(__file__))
|
||
currfilepath=filepathlist[0]
|
||
latexfontsize={'tiny','scriptsize','footnotesize','small','normalsize','large','Large','LARGE','huge','Huge'}
|
||
|
||
def __dictIsHasKey__(dict,key):
|
||
if Py_version >= (3,0,0):
|
||
return dict.__contains__(key)
|
||
else:
|
||
return dict.has_key(key)
|
||
|
||
def __openconfjsonfile__(filepath = ''):
|
||
jsonfile = filepath
|
||
if filepath == '':
|
||
jsonfile = currfilepath+'/conf.json'
|
||
|
||
with codecs.open(jsonfile,"r+",encoding = 'utf-8') as load_f:
|
||
load_dict = json.load(load_f)
|
||
return load_dict
|
||
|
||
def getignorewarning():
|
||
return __load_dict__["ignorewarnkey"]
|
||
|
||
def GetOtherIncludePackage():
|
||
# packagearr = __load_dict__['package']
|
||
# for package in packagearr:
|
||
# print(package)
|
||
return __load_dict__['package']
|
||
|
||
def GetReplacePackage():
|
||
return __load_dict__['replacepackage']
|
||
|
||
def GetCustomOptions():
|
||
return __load_dict__['customoptions']
|
||
|
||
def GetIsTocContents():
|
||
return __load_dict__['isfiguretabletoc']
|
||
|
||
def GetSensitiveword():
|
||
#得到敏感词数组，便于搜索文档中是否有敏感词存在
|
||
return __load_dict__['sensitivewords']
|
||
|
||
def GetTablesContent():
|
||
return __load_dict__['tables']
|
||
|
||
def GetTablerowtype():
|
||
# packagearr = __load_dict__['tables']['rowtype']
|
||
# print(packagearr)
|
||
return __load_dict__['tables']['rowtype']
|
||
|
||
def GetTableheadtype():
|
||
# packagearr = __load_dict__['tables']['headtype']
|
||
# print(packagearr)
|
||
return __load_dict__['tables']['headtype']
|
||
|
||
def GetTableHeadFontColor():
|
||
return __load_dict__['tables']['headfontcolor']
|
||
|
||
def GetTableStylesArr():
|
||
# packagearr = __load_dict__['tables']['styles']
|
||
# for package in packagearr:
|
||
# print(package)
|
||
return __load_dict__['tables']['styles']
|
||
|
||
def GetImageStyleArr():
|
||
# packagearr = __load_dict__['image']['styles']
|
||
# for package in packagearr:
|
||
# print(package)
|
||
return __load_dict__['image']['styles']
|
||
|
||
#判断是否有忽略告警的类
|
||
class clsIgnoreWarn:
|
||
|
||
def __init__(self,warnfile):
|
||
self.warnfile = warnfile #保存告警文件
|
||
|
||
#判断该关键字是否在告警中，在告警中则返回true，不在告警中则返回fasle
|
||
def __JudgeWarnKey(self,keystr,warnstr):
|
||
|
||
#先判断是否为组合关键字
|
||
if "&&" in keystr:
|
||
#解析组合关键字为字符串列表
|
||
keyls = keystr.split("&&")
|
||
isignore = True #默认该告警为忽略，如果组合关键字其中一个关键字没匹配上，则该告警不能忽略。
|
||
for i in range(0,len(keyls)):
|
||
if keyls[i].strip().lower() not in warnstr.lower():
|
||
isignore =False
|
||
break
|
||
return isignore
|
||
else:
|
||
if keystr.lower() in warnstr.lower():
|
||
return True #忽略告警在告警字符串里面，则返回true，表示该告警可以忽略
|
||
else:
|
||
return False
|
||
|
||
#解析告警文件
|
||
def parsewarnfile(self,ignorekey):
|
||
'''
|
||
#make latex命令产生的告警都会保存在stderr文件中，只要判断该文件中的告警是否在忽略告警里就可以了，不在忽略告警里，则肯定有错误，停止执行
|
||
'''
|
||
if not os.path.exists(self.warnfile):
|
||
return True
|
||
|
||
fs = codecs.open(self.warnfile,"r",encoding = 'utf-8')
|
||
fstr = fs.read() #先将所有内容读取到字符串中，方便正则表达式查找
|
||
fs.close()
|
||
|
||
#查找带warning的内容
|
||
pattern = re.compile(r"([\s\S].*)[WARNING:|ERROR:]([\s\S].*)", re.I | re.U | re.M)
|
||
mobjarr = pattern.finditer(fstr)
|
||
|
||
errstr = '' #保存不能被忽略的告警
|
||
isNotError = True
|
||
for mobj in mobjarr:
|
||
amarr = mobj.group()
|
||
|
||
if amarr == '':
|
||
continue
|
||
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() #再去掉首尾空格，避免多余的空格出现
|
||
|
||
#判断该告警是否在忽略列表里，不在忽略列表里，保存在errstr字符串中
|
||
|
||
if ("WARNING:" not in amarr) and ("ERROR:" not in amarr): #直接忽略
|
||
continue
|
||
|
||
isWrite = False #默认不能忽略
|
||
for igkey in ignorekey:
|
||
isWrite = self.__JudgeWarnKey(igkey,amarr)
|
||
if isWrite:
|
||
break
|
||
|
||
if isWrite is False:
|
||
#写入stderr文件
|
||
isNotError = False
|
||
#fe.writelines(amarr+'\n')
|
||
errstr += amarr
|
||
|
||
if errstr != '':
|
||
#如果有不能被忽略的告警，则将不能忽略的告警重新写入warnfile文件中
|
||
#先删除源文件，避免原文件无法写入
|
||
fw = codecs.open(self.warnfile, "w",encoding = 'utf-8')
|
||
fw.write(errstr)
|
||
fw.close()
|
||
else:
|
||
#如果所有的告警都能忽略则删除之前的告警文件
|
||
#该功能暂时不实现，还是保存原始的告警文件，方便查找。
|
||
#os.remove(self.warnfile)
|
||
pass
|
||
|
||
return isNotError
|
||
|
||
#该函数暂时未用
|
||
def __parsepdfarg(stdout,stderr,ignorelist,ignorekey):
|
||
'''
|
||
make all-pdf命令产生的所有输出都只会保存在stdout中，因此从stdout中判断是否有告警内容
|
||
'''
|
||
stdoutfilepath = currfilepath+'/'+stdout
|
||
stderrfilepath = currfilepath+'/'+stderr
|
||
|
||
if not os.path.exists(stdoutfilepath):
|
||
return True
|
||
|
||
fs = codecs.open(stdoutfilepath, "r+",encoding = 'utf-8')
|
||
fstr = fs.read() #先将所有内容读取到字符串中，方便正则表达式查找
|
||
fs.close
|
||
#查找latexmk的位置，latexmk位置的开始即make all-pdf打印输出的开始
|
||
searchstr = r"latexmk"
|
||
m = re.search(searchstr, fstr, re.I|re.U )
|
||
if m == None:
|
||
return True
|
||
|
||
spos = m.span() #获取位置
|
||
latexcont = fstr[spos[0]:len(fstr)] #获取到make all-pdf产生的内容
|
||
|
||
#查找带warning的内容
|
||
pattern = re.compile(r'([\s\S].*)Warning([\s\S].*)', re.I|re.U)
|
||
mobjarr = pattern.finditer(latexcont)
|
||
|
||
#打开stderr文件，方便后续写
|
||
fe = codecs.open(stderrfilepath, "a+",encoding = 'utf-8')
|
||
isNotError = True
|
||
for mobj in mobjarr:
|
||
amarr = mobj.group()
|
||
if amarr == '':
|
||
continue
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() #再去掉首尾空格，避免多余的空格出现
|
||
|
||
#判断该告警是否在忽略列表里，不在忽略列表里，要写入stderr文件
|
||
if amarr.lower() not in [elem.lower() for elem in ignorelist]: #如果错误不在忽略告警里面
|
||
#如果不能整行匹配，再判断该行是否包含需忽略的告警的关键字
|
||
isWrite = False #默认不能忽略
|
||
for igkey in ignorekey:
|
||
|
||
isWrite = self.__JudgeWarnKey(igkey,amarr)
|
||
if isWrite:
|
||
break;
|
||
|
||
if isWrite == False:
|
||
#写入stderr文件
|
||
isNotError = False
|
||
fe.writelines(amarr)
|
||
fe.close
|
||
|
||
return isNotError
|
||
|
||
def warn_main(warnfile,app=None):
|
||
|
||
global __load_dict__
|
||
|
||
if len(__load_dict__) ==0:
|
||
GetConfjsondict(app)
|
||
|
||
ignorekey = getignorewarning()
|
||
clswarn = clsIgnoreWarn(warnfile)
|
||
|
||
if not clswarn.parsewarnfile(ignorekey):
|
||
#如果存在不可忽略的告警，则返回True，否则返回False
|
||
return True
|
||
|
||
return False
|
||
|
||
|
||
class clsTableattr:
|
||
|
||
def __init__(self, tables):
|
||
self.rowtype = tables['rowtype']
|
||
if __dictIsHasKey__(tables,'headtype'):
|
||
self.headtype = tables['headtype']
|
||
else:
|
||
self.headtype = ""
|
||
if __dictIsHasKey__(tables,'headfontcolor'):
|
||
self.headfontcolor = tables['headfontcolor']
|
||
else:
|
||
self.headfontcolor = ""
|
||
if __dictIsHasKey__(tables,'styles'):
|
||
self.tablestyles = tables['styles']
|
||
else:
|
||
self.tablestyles = None
|
||
if __dictIsHasKey__(tables,'isname'):
|
||
self.isname = tables['isname']
|
||
else:
|
||
self.isname = False
|
||
if __dictIsHasKey__(tables,'fontsize'):
|
||
self.fontsize = tables['fontsize']
|
||
else:
|
||
self.fontsize = ""
|
||
|
||
if __dictIsHasKey__(tables,'ismulticolleftalign'):
|
||
self.ismulticolleftalign = tables['ismulticolleftalign']
|
||
else:
|
||
self.ismulticolleftalign = False
|
||
|
||
if __dictIsHasKey__(tables,'ismultirowautowrap'):
|
||
self.ismultirowautowrap = tables['ismultirowautowrap']
|
||
else:
|
||
self.ismultirowautowrap = True
|
||
|
||
if __dictIsHasKey__(tables,'ismultirowatupcell'):
|
||
self.ismultirowatupcell = tables['ismultirowatupcell']
|
||
else:
|
||
self.ismultirowatupcell = False
|
||
|
||
if __dictIsHasKey__(tables,'ismultirowatlowcell'):
|
||
self.ismultirowatlowcell = tables['ismultirowatlowcell']
|
||
else:
|
||
self.ismultirowatlowcell = False
|
||
|
||
class clsModifyTex:
|
||
|
||
def __init__(self, content,app=None):
|
||
self.content = content
|
||
self.app = app
|
||
self.tablesattrobj = clsTableattr(GetTablesContent())
|
||
|
||
#构建模板字符串
|
||
#自动换行模板
|
||
self.autolinetemplat =r'''\renewcommand{\arraystretch}{0.8}
|
||
\begin{tabular}[c]{@{}l@{}}%(autocontent)s\end{tabular}'''
|
||
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
fontcolor = fontcolor.replace('{}', '{%(content)s}', 1)
|
||
self.commonstr = r'''%(sphinxstyletheadfamily)s\cellcolor''' + \
|
||
self.tablesattrobj.headtype + "\n{" + fontcolor + "}"
|
||
|
||
# multirow模板
|
||
self.multirowstr = r'''\multirow{-%(count)s}{%(coluwidth)s}%(raggedright)s{
|
||
''' + self.commonstr + "}"
|
||
|
||
self.simplemultirow = r'''\multirow{%(count)s}{%(coluwidth)s}{\cellcolor''' + \
|
||
self.tablesattrobj.headtype + "}"
|
||
|
||
# multicolumn模板
|
||
self.multicolumnstr = r'''\multicolumn{%(count)s}{%(flag)s}{%(prefix)s''' + \
|
||
self.commonstr + r'''%(suffix)s'''
|
||
|
||
# 为了普通标题文本看起来和使用了multicolum你的位置一致，对于非multirow和multicolumn单元格的内容，都用multicolumn{1}{|l|}标志
|
||
self.normalstr = r'''\multicolumn{1}{%(flag)s}{
|
||
\begin{varwidth}[c]{%(colwidth)s}
|
||
''' + self.commonstr + r'''
|
||
\par
|
||
\vskip-\baselineskip\vbox{\hbox{\strut}}\end{varwidth}}'''
|
||
self.comcolstr = r'''\multicolumn{%(count)s}{%(flag)s}{''' + self.commonstr +"}"
|
||
# 空的单元格内容,multirow位置变换后，会有空的单元格
|
||
self.emptystr = r"\cellcolor" + self.tablesattrobj.headtype+"{}"
|
||
|
||
#删除字符串列表。有时候sphinx生成的文本内容里会带有特殊的latex指令，该指令不支持设置字体颜色，需要删除。删除不影响内容显示。
|
||
self.delstrlst=[r'\begin{quote}',r'\end{quote}']
|
||
|
||
def __checktpacknameandparam(self,packlist,packname,*packarg):
|
||
'''
|
||
检查指定的包是否需要增加或者修改参数
|
||
:param packlist: 已经读出的包含的package
|
||
:param packname: 要修改或者添加的包
|
||
:param packarg: 要修改或者添加的包参数，可变参数。不会覆盖已有参数
|
||
'''
|
||
if len(packarg) == 0:
|
||
#如果没有参数则直接添加该包
|
||
loadpackagestr = "\\\\usepackage{" + packname + "}"
|
||
if loadpackagestr not in packlist:
|
||
packlist.append(loadpackagestr)
|
||
return
|
||
|
||
params = ",".join(packarg)
|
||
loadpackagestr = "\\\\usepackage[" + params + "]{" + packname + "}"
|
||
#print(loadpackagestr)
|
||
packstr = ",".join(packlist)
|
||
#print(packstr)
|
||
searchstr = r'\\\\usepackage(\[[\S, ][^\\]+\])?\{'+packname+'\}'
|
||
match = re.search(searchstr,packstr)
|
||
if match is None:
|
||
#如果根本没有加载packname包，则加载该包
|
||
packlist.append(loadpackagestr)
|
||
return
|
||
latexpack = match.group()
|
||
#print(latexpack)
|
||
if match.group(1) is None:
|
||
#如果该包没有携带参数，则重新加载该包
|
||
#得到老包的位置，尽量原位置插入，避免因为位置问题导致编译失败
|
||
index = packlist.index(latexpack)
|
||
del packlist[index]
|
||
#再重新加载新的包
|
||
packlist.insert(index,loadpackagestr)
|
||
return
|
||
#如果携带了参数，则更新该参数
|
||
#为了兼容后续新添加参数，并防止覆盖已有参数，将每个参数进行比较添加
|
||
paramstr = match.group(1)
|
||
searchstr = '\[([\S, ]+)?\]'
|
||
match = re.search(searchstr,paramstr)
|
||
if match.group(1).strip() == params:
|
||
#print('-------------enter-----------')
|
||
#为了提高运行效率，两个参数相等直接返回，不再走下面的循环
|
||
return
|
||
params = match.group(1)
|
||
for param in packarg:
|
||
if param not in params:
|
||
params += "," + param
|
||
#print(params)
|
||
loadpackagestr = "\\\\usepackage[" + params+"]{" + packname +"}"
|
||
#先删除旧包，原位置插入，避免因位置错误导致的编译失败。
|
||
index = packlist.index(latexpack)
|
||
del packlist[index]
|
||
packlist.insert(index,loadpackagestr)
|
||
|
||
#加入其它包
|
||
def AddPackageToTex(self):
|
||
#得到需要包的数组
|
||
packarr = GetOtherIncludePackage()
|
||
if len(packarr)==0:
|
||
return False
|
||
|
||
self.__checktpacknameandparam(packarr,"multirow")
|
||
self.__checktpacknameandparam(packarr,"tcolorbox","most","skins","breakable")
|
||
|
||
#如果数组有内容，就需要将包添加到latex文件的导言区
|
||
#搜索\usepackage{sphinx}，将包加在它的前面，用正则表达式搜索它的位置
|
||
#采用正则表达式替换的方式，替换搜索到的字符串，因此需要先构建字符串
|
||
#python认为\u后面为unicode字符，因此需要多加一个转义字符\，python才认为是整个的字符串
|
||
#searchstr = r'\\usepackage\[dontkeepoldnames\]{sphinx}'
|
||
searchstr = r'\\usepackage(\[\S*\]*)?{sphinx}'
|
||
matchstr = re.search(searchstr,self.content)
|
||
|
||
replacestr=""
|
||
for package in packarr:
|
||
replacestr += package+'\n'
|
||
|
||
if Py_version >= (3,7,0):
|
||
replacestr += "\\" + matchstr.group(0)
|
||
else:
|
||
replacestr += matchstr.group(0)
|
||
|
||
|
||
self.content = re.sub(searchstr, replacestr, self.content, 1, re.M | re.I|re.U)
|
||
|
||
return True
|
||
|
||
#加入自定义选项,包放在了sphinx包的前面，因此选项放在sphinx包的后面
|
||
def AddCustormOptionsToTex(self):
|
||
#得到需要包的数组
|
||
packarr = GetCustomOptions()
|
||
if len(packarr)==0:
|
||
return False
|
||
|
||
#如果数组有内容，就需要将包添加到latex文件的导言区
|
||
#搜索\usepackage{sphinx}，将自定义参数放在它的后面，用正则表达式搜索它的位置
|
||
#采用正则表达式替换的方式，替换搜索到的字符串，因此需要先构建字符串
|
||
#python认为\u后面为unicode字符，因此需要多加一个转义字符\，python才认为是整个的字符串
|
||
searchstr = r'\\usepackage(\[\S*\]*)?{sphinx}'
|
||
matchstr = re.search(searchstr,self.content)
|
||
|
||
replacestr=""
|
||
for package in packarr:
|
||
replacestr += package+'\n'
|
||
|
||
if Py_version >= (3,7,0):
|
||
replacestr = "\\" + matchstr.group(0)+'\n'+replacestr
|
||
else:
|
||
replacestr = matchstr.group(0)+'\n'+replacestr
|
||
|
||
self.content = re.sub(searchstr, replacestr, self.content, 1, re.M | re.I|re.U)
|
||
return True
|
||
|
||
#增加figure和table toc到tex
|
||
def AddOtherTocToTex(self):
|
||
#得到需要包的数组
|
||
packarr = GetIsTocContents()
|
||
if len(packarr)==0:
|
||
return False
|
||
|
||
replacestr = ""
|
||
if packarr['isfigurestoc']:
|
||
figlst = packarr['figurestoc']
|
||
for figstr in figlst:
|
||
replacestr += figstr + '\n'
|
||
|
||
if packarr['istablestoc']:
|
||
figlst = packarr['tablestoc']
|
||
for figstr in figlst:
|
||
replacestr += figstr + '\n'
|
||
if replacestr == "":
|
||
return
|
||
|
||
#如果数组有内容，就需要将包添加到latex文件的导言区
|
||
#搜索\usepackage{sphinx}，将包加在它的前面，用正则表达式搜索它的位置
|
||
#采用正则表达式替换的方式，替换搜索到的字符串，因此需要先构建字符串
|
||
#python认为\u后面为unicode字符，因此需要多加一个转义字符\，python才认为是整个的字符串
|
||
searchstr = r'\\sphinxtableofcontents'
|
||
matchstr = re.search(searchstr,self.content)
|
||
|
||
if Py_version >= (3,7,0):
|
||
replacestr = "\\" + matchstr.group(0) + '\n' + replacestr
|
||
else:
|
||
replacestr = matchstr.group(0) + '\n' + replacestr
|
||
|
||
self.content = re.sub(searchstr, replacestr, self.content, 1, re.M | re.I|re.U)
|
||
return True
|
||
|
||
def __IsRequireReplace(self, value):
|
||
"""
|
||
根据sphinx版本判断是否需要替换,有两种写法：
|
||
1. {sphinx:5.3.0}:这种写法是当前sphinx版本大于等于5.3.0版本时，才执行替换。
|
||
2. {5.3.0:sphinx}:这种写法是当前sphinx版本小于5.3.0时，才进行替换
|
||
:return: 返回True需要替换，和需要替换的实际value;或者返回fasle，不需要替换
|
||
"""
|
||
#根据正则表达式得到需要替换的sphinx的最小版本号
|
||
if len(sphinx_version)==0:
|
||
return True,value
|
||
#按大于等于版本号进行匹配查找
|
||
searchstr = r"\{sphinx:([0-9\.]+)\}([\s\S]+)"
|
||
match = re.match(searchstr,value,re.I | re.U)
|
||
if match is not None:
|
||
#print(match.group(1),match.group(2))
|
||
try:
|
||
require_version = match.group(1)[:3]
|
||
if sphinx_version >= require_version:
|
||
return True, match.group(2)
|
||
else:
|
||
return False, ""
|
||
except Exception as e:
|
||
print(e)
|
||
return True,value
|
||
|
||
else:
|
||
#按小于版本号进行匹配查找
|
||
searchstr = r"\{([0-9\.]+):sphinx\}([\s\S]+)"
|
||
match = re.match(searchstr, value, re.I | re.U)
|
||
if match is not None:
|
||
try:
|
||
require_version = match.group(1)[:3]
|
||
if sphinx_version < require_version:
|
||
return True, match.group(2)
|
||
else:
|
||
return False, ""
|
||
except Exception as e:
|
||
print(e)
|
||
return True, value
|
||
else:
|
||
return True,value
|
||
|
||
|
||
def ModifyReplacePackage(self):
|
||
#得到字典值
|
||
#得到需要替换的包，用正则表达式替换
|
||
redict = GetReplacePackage()
|
||
if len(redict) ==0:
|
||
return
|
||
|
||
#为了兼容sphinx5.3.0版本，固定添加以下配置
|
||
keys = redict.keys()
|
||
if "\\\\sphinxtoprule" not in keys:
|
||
redict["\\\\sphinxtoprule"] = "\\\\hline"
|
||
if "\\\\sphinxmidrule" not in keys:
|
||
redict["\\\\sphinxmidrule"] = "\\\\hline"
|
||
if "\\\\sphinxbottomrule" not in keys:
|
||
redict["\\\\sphinxbottomrule"] = "\\\\hline"
|
||
if "\\\\sphinxhline" not in keys:
|
||
redict["\\\\sphinxhline"] = "\\\\hline"
|
||
if "\\\\sphinxhyphen" not in keys:
|
||
redict["\\\\sphinxhyphen"] = "{sphinx:5.3.0}\\\\PYGZhy"
|
||
|
||
#返回字典中所有键值的列表
|
||
keylst = list(redict)
|
||
for key in keylst:
|
||
if key == 'comment' :
|
||
continue
|
||
keyvalue = redict[key] #得到键对应的值
|
||
result,keyvalue = self.__IsRequireReplace(keyvalue)
|
||
if result :
|
||
#对键值进行替换
|
||
self.content = re.sub(key, keyvalue, self.content, 0, re.I|re.U)
|
||
return
|
||
|
||
def __GetReplacedContent(self,afterstr,replacelst):
|
||
"""
|
||
对需要替换的内容进行替换
|
||
:param afterstr: 需要替换的字符串
|
||
:return:
|
||
"""
|
||
if len(afterstr) ==0 or len(replacelst)==0:
|
||
return afterstr
|
||
for replacelist in replacelst:
|
||
if len(replacelist) !=2:
|
||
continue
|
||
replacedstr = replacelist[0]
|
||
replacestr = replacelist[1]
|
||
if len(replacedstr) ==0 or len(replacestr)==0:
|
||
continue
|
||
afterstr = re.sub(replacedstr, replacestr, afterstr, 0, re.U | re.M)
|
||
|
||
return afterstr
|
||
|
||
def __ParseStyleForSpecialFunction(self,isshaded,apidict,linecontent):
|
||
|
||
if isshaded:
|
||
envstartstr = "\n\\begin{shaded}\n" # 环境起始字符串
|
||
envendstr = "\n\\end{shaded}\n" # 环境结束字符串
|
||
else:
|
||
envstartstr = "" # 环境起始字符串
|
||
envendstr = "" # 环境结束字符串
|
||
|
||
afterstr = linecontent
|
||
|
||
if apidict is None or len(apidict)==0:
|
||
return envstartstr,envendstr,afterstr
|
||
|
||
if not __dictIsHasKey__(apidict, "isenter") or \
|
||
(__dictIsHasKey__(apidict, "isenter") and \
|
||
apidict['isenter'] is True):
|
||
afterstr = self.__strreplacepos(afterstr,r"pysiglinewithargsret",r",",r",\\")
|
||
if __dictIsHasKey__(apidict, "istcolorbox") and \
|
||
apidict['istcolorbox'] is True:
|
||
envstartstr, envendstr = self.__GettcolorboxForFunction(apidict)
|
||
elif __dictIsHasKey__(apidict, "fontsize") and \
|
||
apidict['fontsize'] in latexfontsize:
|
||
envstartstr += "\\" + apidict['fontsize'] + "\n"
|
||
|
||
#检查是否有替换，有替换的话，对内容进行替换
|
||
if __dictIsHasKey__(apidict, "replace"):
|
||
replacelst = apidict['replace']
|
||
if len(replacelst) > 0:
|
||
afterstr = self.__GetReplacedContent(afterstr,replacelst)
|
||
|
||
return envstartstr,envendstr,afterstr
|
||
|
||
def __ModifyFunctionBkColorByPython(self,isshaded,apilst,newcontent,linecontent,curpos,prepos):
|
||
#根据python生成的格式为类和函数声明添加灰底，并按逗号换行
|
||
|
||
'''
|
||
根据正则表达式获得以\pysiglinewithargsret开头，以“{}”结尾的中间字符串
|
||
对中间字符串添加灰底和换行
|
||
'''
|
||
if isshaded:
|
||
envstartstr = "\n\\begin{shaded}\n" # 环境起始字符串
|
||
envendstr = "\n\\end{shaded}\n" # 环境结束字符串
|
||
else:
|
||
envstartstr = "" # 环境起始字符串
|
||
envendstr = "" # 环境结束字符串
|
||
|
||
startmultiline = '\\pysigstartmultiline\n'
|
||
stopmultiline = '\n\\pysigstopmultiline'
|
||
#searchstr = r'(?=\\pysiglinewithargsret).*(?<={})'
|
||
searchstr=r'(?=\\pysiglinewithargsret).*'
|
||
match = re.search(searchstr, linecontent, re.I|re.U)
|
||
if match is not None:
|
||
#重新组合linecontent
|
||
#pos = match.span()
|
||
isapi, apidict = self.__IsSpecialFunction(apilst, linecontent)
|
||
if isapi is True and apidict is not None:
|
||
envstartstr,envendstr,afterstr = self.__ParseStyleForSpecialFunction(isshaded,apidict,match.group())
|
||
newstr = '\n' + linecontent[:match.start()] + envstartstr + startmultiline + afterstr+ stopmultiline + envendstr+ linecontent[match.end():len(linecontent)]
|
||
else:
|
||
newstr = '\n' + linecontent[:match.start()] + envstartstr+ startmultiline + match.group().replace(r",",r",\\") + stopmultiline + envendstr + linecontent[match.end():len(linecontent)]
|
||
#计算替换前的内容
|
||
if len(prepos)==0:
|
||
newcontent = self.content[:curpos[0]-1] + newstr
|
||
else:
|
||
newcontent += self.content[prepos[1]:curpos[0]-1] + newstr
|
||
|
||
return newcontent
|
||
|
||
def __strreplacepos(self,srcstr,posstr,oldstr,newstr):
|
||
|
||
# 从指定字符串开始对行内字符串进行替换
|
||
'''
|
||
srcstr：原始字符串
|
||
posstr：从该字符串开始进行替换
|
||
oldstr：被替换字符串
|
||
newstr：替换字符串
|
||
'''
|
||
#查找字符串的起始位置
|
||
pos = srcstr.find(posstr)
|
||
if pos == -1:
|
||
return "" #如果查找的字符串没有找到，则返回空。
|
||
|
||
#根据找到的位置进行字符串拆分
|
||
startstr = srcstr[0:pos]
|
||
beforestr = srcstr[pos:len(srcstr)]
|
||
#对字符串进行替换
|
||
afterstr = beforestr.replace(oldstr,newstr)
|
||
return startstr+afterstr
|
||
|
||
def __GetleftrightValueForSpecialapi(self,str):
|
||
"""
|
||
得到conf.json specialapi配置中left和right的值
|
||
字符串格式为“[-][数字][单位]”，根据这个格式查找值和单位
|
||
:param str:
|
||
:return:
|
||
"""
|
||
if len(str) ==0:
|
||
return 0,""
|
||
|
||
searchstr = r'[-]{0,1}([0-9]{1,2})([A-Za-z]{1,2})'
|
||
match = re.search(searchstr, str, re.I)
|
||
if match is not None:
|
||
value = int(match.group(1))
|
||
unit = match.group(2)
|
||
return value,unit
|
||
else:
|
||
return 0,""
|
||
|
||
def __GettcolorboxForFunction(self,apidict):
|
||
#判断有没有设置页面左右边距,的左右边距
|
||
#必须通过\geometry指令设置，否则按默认处理
|
||
|
||
leftvalue = 0
|
||
leftunit = "mm"
|
||
left = "0mm"
|
||
|
||
rightvalue = 0
|
||
rightunit = "mm"
|
||
right="0mm"
|
||
|
||
isleftset = False
|
||
isrightset = False
|
||
|
||
if __dictIsHasKey__(apidict, "left") and \
|
||
len(apidict['left']) > 0:
|
||
leftvalue,leftunit=self.__GetleftrightValueForSpecialapi(apidict['left'])
|
||
if len(leftunit) > 0:
|
||
left = str(leftvalue)+leftunit
|
||
isleftset = True
|
||
|
||
if isleftset is not True:
|
||
leftvalue = 9 #默认值
|
||
leftunit="mm"
|
||
left = str(leftvalue)+leftunit
|
||
|
||
searchstr = r'\\geometry{[\s\S]*left=([0-9]{1,2})([A-Za-z]{1,2})[\s\S]*}'
|
||
match = re.search(searchstr, self.content, re.I | re.M)
|
||
if match is not None:
|
||
left = match.group(1) + match.group(2)
|
||
leftvalue = int(match.group(1))
|
||
leftunit = match.group(2)
|
||
|
||
#print(left)
|
||
|
||
if __dictIsHasKey__(apidict,"right") and \
|
||
len(apidict['right']) >0 :
|
||
rightvalue, rightunit = self.__GetleftrightValueForSpecialapi(apidict['right'])
|
||
if len(rightunit) > 0:
|
||
right = str(rightvalue) + rightunit
|
||
isrightset = True
|
||
|
||
if isrightset is not True:
|
||
rightvalue = leftvalue - 1 # 为了使显示效果更好看
|
||
right = str(rightvalue)+leftunit
|
||
|
||
searchstr = r'\\geometry{[\s\S]*right=([0-9]{1,2})([A-Za-z]{1,2})[\s\S]*}'
|
||
match =re.search(searchstr,self.content,re.I|re.M)
|
||
if match is not None:
|
||
rightvalue = int(match.group(1)) -2
|
||
rightunit = match.group(2)
|
||
right = str(rightvalue) + rightunit
|
||
#print(right)
|
||
|
||
fontsize = ""
|
||
if __dictIsHasKey__(apidict, "fontsize") and \
|
||
apidict['fontsize'] in latexfontsize:
|
||
fontsize = "fontupper=\\" + apidict['fontsize']
|
||
|
||
envstartstr = "\n\\begin{tcolorbox}[arc=0mm,boxrule=-1mm,left skip=-" \
|
||
+ str(leftvalue+1) + leftunit +",left="+left +",right=-" +right \
|
||
+ ",colback=shadecolor," + fontsize +"]\n"
|
||
envendstr = "\n\\end{tcolorbox}\n"
|
||
#print("=====================")
|
||
#print(envstartstr)
|
||
#print(envendstr)
|
||
#print("=====================")
|
||
return envstartstr,envendstr
|
||
|
||
|
||
def __IsSpecialFunction(self,apilst,linecontent):
|
||
'''
|
||
判断是否为特殊api
|
||
:param apilst:
|
||
:param linecontent:
|
||
:return:
|
||
'''
|
||
if len(apilst)==0:
|
||
return False,None
|
||
|
||
for apidict in apilst:
|
||
if __dictIsHasKey__(apidict,"latexapiname"):
|
||
apistr=apidict['latexapiname'] #有可能以逗号分割的多个函数名称
|
||
apiarr=apistr.split(",") #以逗号分割函数名称列表
|
||
for api in apiarr:
|
||
if api in linecontent:
|
||
return True,apidict
|
||
return False,None
|
||
|
||
def __RemoveLastSpace(self,headstr):
|
||
"""
|
||
删除最后的空格，避免函数含义和关键字间有大的空行
|
||
:param headstr:
|
||
:return:
|
||
"""
|
||
headlist = headstr.split('\n')
|
||
index = 0
|
||
for i in range(len(headlist)-1,0,-1):
|
||
str = headlist[i].strip('\r')
|
||
if len(str) == 0:
|
||
index = i
|
||
break
|
||
if index > 0:
|
||
headlist.pop(index)
|
||
return '\n'.join(headlist)
|
||
else:
|
||
return headstr
|
||
|
||
def __ModifyParamPos(self,paramcontent):
|
||
"""
|
||
调整参数位置在最前面，为了适配breathe 4.24.1之后版本
|
||
:param paramcontent:
|
||
:return:
|
||
"""
|
||
#查找第一个\begin{description}\n\sphinxlineitem{}字符串
|
||
searchstr = r"(\\begin\{quote\})?(\r\n|\n)?\\begin\{description\}(\r\n|\n)?\\sphinxlineitem\{(\sphinxstylestrong\{)?(?P<paramkey>[\s\S].+)?(\})?\}(\r\n|\n)?[\s\S]+?(\\end\{description\}){1}(\r\n|\n)?(\\end\{quote\})?"
|
||
match = re.search(searchstr,paramcontent,re.I|re.M|re.U)
|
||
if match is not None:
|
||
|
||
if "\\begin{quote}" in match.group():
|
||
#删掉缩进
|
||
otherstr = match.group()[len('\\begin{quote}'):len(match.group())-len('\\end{quote}')]
|
||
else:
|
||
otherstr = match.group()
|
||
|
||
paramkey = match.group('paramkey')
|
||
headstr = paramcontent[0:match.start()]
|
||
headstr = self.__RemoveLastSpace(headstr)
|
||
if "Parameters" in paramkey:
|
||
#说明参数本身在第一个位置，不做处理
|
||
return headstr + '\n' + otherstr + paramcontent[match.end():len(paramcontent)]
|
||
|
||
#如果参数不在第一个位置，查找参数的位置并将第一个位置记录下来
|
||
searchstr = r"(\\begin\{quote\})?(\r\n|\n)?\\begin\{description\}(\r\n|\n)?\\sphinxlineitem\{(\sphinxstylestrong\{)?(?P<paramkey>Parameters)?(\})?\}(\r\n|\n)?[\s\S]+?(\\end\{description\}){1}(\r\n|\n)?(\\end\{quote\})?"
|
||
matchparam = re.search(searchstr,paramcontent,re.I|re.M|re.U)
|
||
if matchparam is None:
|
||
return headstr + '\n' + otherstr + paramcontent[match.end():len(paramcontent)]
|
||
|
||
if "\\begin{quote}" in matchparam.group():
|
||
#删掉缩进
|
||
paramstr = matchparam.group()[len('\\begin{quote}'):len(matchparam.group())-len('\\end{quote}')]
|
||
else:
|
||
paramstr = matchparam.group()
|
||
|
||
#重新组合字符串,将参数放在第一位
|
||
newparamcontent = headstr + '\n' +paramstr + '\n' +otherstr \
|
||
+ paramcontent[match.end():matchparam.start()] \
|
||
+ paramcontent[matchparam.end():len(paramcontent)]
|
||
|
||
return newparamcontent
|
||
else:
|
||
return paramcontent
|
||
|
||
def ModifyFunctionBackColor(self):
|
||
'''
|
||
该函数用来修改函数的背景色，并根据参数换行
|
||
* c/c++ sphinx生成的函数都被以下三行包围：
|
||
\pysigstartmultiline
|
||
\pysiglinewithargsret{xxxxx}
|
||
\pysigstopmultiline
|
||
因此利用正则表达式查找这三行所在的位置进行替换。
|
||
注意：
|
||
要实现该功能，latex必须包含framed和color包，同时定义以下颜色：
|
||
\definecolor{shadecolor}{RGB}{220,220,220}
|
||
如果shadecolor颜色未定义，则该函数执行失败。
|
||
* python生成的latex文件中函数或者类的声明，有\pysiglinewithargsret指令，但是没有pysigstartmultiline指令。
|
||
因此需要在\pysiglinewithargsret指令句子的结束，前后先添加pysigstartmultiline和pysigstopmultiline。再添加\begin{shaded}和\end{shaded}
|
||
一句的结束根据"{}"来判断，遇到"{}"即为句末。
|
||
'''
|
||
#判断是否有特殊API需要处理
|
||
apilst = []
|
||
isshaded = True
|
||
if __dictIsHasKey__(__load_dict__,"specialapi"):
|
||
if __dictIsHasKey__(__load_dict__["specialapi"],"styles"):
|
||
apilst=list(__load_dict__["specialapi"]["styles"])
|
||
if __dictIsHasKey__(__load_dict__["specialapi"],"isshaded"):
|
||
isshaded = __load_dict__["specialapi"]["isshaded"]
|
||
|
||
pythontype = False
|
||
newcontent = ""
|
||
prepos=[] #定义需要替换的字符串列表，该列表中的每一个元素都包含上面提到的三行。
|
||
#searchstr = r'^(?=.*\\pysiglinewithargsret).*$'
|
||
#该正则表达式可以把pysiglinewithargsret或者带template的识别出来。有template的会被pysigline标签标识
|
||
#该修改也兼容sphinx 5.3.0及以后版本。否则5.3.0版本之后将无法使用。
|
||
#searchstr=r'(\\pysigline[\s\S].*){0,1}[\n]{0,1}(\\pysiglinewithargsret[\s\S].*)[\n]'
|
||
searchstr=r'(\\pysigstartsignatures){0,1}[\r\n|\n]{0,1}(\\pysigstartmultiline){0,1}(\r\n|\n){0,1}((\\pysigline[\s\S].*){0,1}[\n]{0,1}(\\pysiglinewithargsret[\s\S].*))[\n](\\pysigstopmultiline){0,1}[\r\n|\n]{0,1}(\\pysigstopsignatures){0,1}'
|
||
m = re.finditer(searchstr, self.content, re.M|re.I|re.U)
|
||
for match in m:
|
||
|
||
linecontent = match.group()
|
||
#判断是否添加了pysigstartmultiline和pysigstopmultiline，没有添加的话需要添加才能添加灰色背景
|
||
#multilen=len(r'\pysigstartmultiline')
|
||
#startmultistr = self.content[match.start()-multilen-1:match.start()]
|
||
#如果上一行不是\pysigstartmultiline则需要按python风格修改，添加该标志
|
||
#print(startmultistr.strip())
|
||
if match.group(2) is None:
|
||
#print('is python')
|
||
# 计算替换前的内容
|
||
newcontent = self.\
|
||
__ModifyFunctionBkColorByPython(isshaded,apilst,newcontent,linecontent,match.span(),prepos)
|
||
prepos = match.span()
|
||
pythontype = True
|
||
else:
|
||
#tablestr = match.groups()
|
||
#计算替换前的内容
|
||
if len(prepos)==0:
|
||
newcontent = self.content[0:match.start()]
|
||
else:
|
||
# 得到参数信息内容，方便后面调整位置，此时调整的参数为上一个函数的参数位置
|
||
paramcontent = self.content[prepos[1]:match.start()]
|
||
# breathe 4.24.1之后版本将parameters放在了最后面，
|
||
# 为了适配breathe 4.24.1之后版本对格式的调整
|
||
# 检查参数是否在后面，是的话，需要将参数放到最前面
|
||
# breathe 4.24.1之后版本将doxygen的标签都放在\begin{description}\n\sphinxlineitem{}标志对里面
|
||
# 因此对该标志对进行搜索
|
||
newparamcontent = self.__ModifyParamPos(paramcontent)
|
||
newcontent += newparamcontent
|
||
|
||
|
||
#当有template的时候，pysiglinewithargsret不一定在行首，因此需要从pysiglinewithargsret开始替换逗号，加强制换行符
|
||
if isshaded:
|
||
envstartstr = "\n\\begin{shaded}\n" # 环境起始字符串
|
||
envendstr = "\n\\end{shaded}\n" # 环境结束字符串
|
||
else:
|
||
envstartstr = "" # 环境起始字符串
|
||
envendstr = "" # 环境结束字符串
|
||
|
||
isapi,apidict = self.__IsSpecialFunction(apilst,linecontent)
|
||
if isapi is True and apidict is not None:
|
||
envstartstr,envendstr,afterstr=self.__ParseStyleForSpecialFunction(isshaded,apidict,linecontent)
|
||
newstr = envstartstr + afterstr + envendstr
|
||
else:
|
||
afterstr=self.__strreplacepos(linecontent,r"pysiglinewithargsret",r",",r",\\")
|
||
#得到替换后的字符串
|
||
newstr = envstartstr + afterstr + envendstr
|
||
#得到替换后的内容
|
||
newcontent += newstr
|
||
prepos = match.span()
|
||
pythontype = False
|
||
|
||
if len(prepos) > 0:
|
||
paramcontent = self.content[prepos[1]:len(self.content)]
|
||
newparamcontent = self.__ModifyParamPos(paramcontent)
|
||
self.content = newcontent + newparamcontent
|
||
#self.content = newcontent + self.content[prepos[1]:len(self.content)]
|
||
#print('===============================================')
|
||
|
||
def __GetTableCaption(self,tablecontent):
|
||
'''
|
||
得到表格的caption，方便输出打印
|
||
:param tablecontent: 表格内容
|
||
:return: 返回表格的caption
|
||
'''
|
||
tablecaption = ""
|
||
searchstr = r'(\\sphinxcaption|\\caption)\{(?P<caption>[\s\S]*?)\}(?=\\label|\\\\)'
|
||
matchcaption = re.search(searchstr, tablecontent, re.M | re.I | re.U)
|
||
if matchcaption is not None:
|
||
tablecaption = matchcaption.group('caption') #得到caption的值
|
||
#长表格caption后面会添加\struct的后缀，去掉
|
||
tablecaption = tablecaption.replace(r"\strut","")
|
||
|
||
return tablecaption
|
||
|
||
def ModifyTablesAttributes(self):
|
||
#修改表格属性
|
||
newcontent = self.content
|
||
searchstr = r'(\\begin{savenotes})([\s\S]*?)(\\sphinxattablestart|\\sphinxatlongtablestart)([\s\S]*?)(\\sphinxattableend|\\sphinxatlongtableend)([\s\S]*?)(\\end{savenotes})'
|
||
matchobj = re.finditer(searchstr, self.content, re.M|re.I|re.U)
|
||
#outputstr = "\033[34mModifying Table:\033[0m"
|
||
#print(outputstr, end="")
|
||
icount = 0
|
||
for match in matchobj:
|
||
try:
|
||
icount = icount + 1
|
||
tablestr = match.groups()
|
||
tablecontent = tablestr[0]+tablestr[1]+tablestr[2]+tablestr[3]+tablestr[4]
|
||
columnwidthlst,newtablecontent = self.__GetColumnParameters(tablecontent)
|
||
#得到表格caption
|
||
tablecaption=self.__GetTableCaption(tablecontent)
|
||
#print(tablecaption)
|
||
#outputtable="\033[34m[" + tablecaption +"];\033[0m"
|
||
#print(outputtable, end="")
|
||
#为了兼容纯英文linux系统，在打印信息中不能包含中文，因此按自动计数累加表示表格，
|
||
#避免表格标题中有中文时导致修改表格失败。
|
||
prstr = "\033[34m[Modifying table"+str(icount)+":... ...];\033[0m"
|
||
print(prstr, end="\r")
|
||
if self.tablesattrobj.tablestyles is None:
|
||
#先修改表格的通用属性
|
||
newtableattr,islongtable = self.__StartModifyTableAttr(newtablecontent,columnwidthlst, False)
|
||
newcontent = newcontent.replace(tablecontent, newtableattr)
|
||
else:
|
||
caption_dict = self.__CreateTableCaptionDict(self.tablesattrobj.tablestyles)
|
||
if len(caption_dict ) > 0 :
|
||
newtableattr = self.__ModifySingleTableattr(newtablecontent, columnwidthlst, caption_dict ) #tablestr也是3个内容的数组，因为正则表达式被分为了3组，只取中间分组的内容。
|
||
#重新组成新的字符串
|
||
newcontent = newcontent.replace(tablecontent, newtableattr)
|
||
|
||
except Exception as e:
|
||
print(e)
|
||
traceback.print_exc()
|
||
|
||
print("\r\n")
|
||
self.content = newcontent
|
||
|
||
#替换表格中字体大小
|
||
def __ModifyTableFontSize(self,singletablecontent,fontsize):
|
||
|
||
searchstr = r'(\\begin{savenotes})([\s\S]*?)(\\sphinxattablestart|\\sphinxatlongtablestart)'
|
||
m = re.search(searchstr,singletablecontent, re.M|re.I|re.U)
|
||
tablestr = m.groups()
|
||
#替换表格中的字体
|
||
#同时也要使表格的caption字体大小保持一致，修改表格的caption需要添加如下指令：\renewcommand{\tablename}{\scriptsize{表} }
|
||
captionfont = "\n\\renewcommand{\\tablename}{\\" + fontsize + "{Table} }\n"
|
||
if doc_language=='zh_CN':
|
||
captionfont="\n\\renewcommand{\\tablename}{\\" + fontsize + "{表} }\n"
|
||
|
||
tablefontsize = '\\'+fontsize + captionfont
|
||
|
||
return tablestr[0]+tablefontsize+tablestr[2]+singletablecontent[m.end():len(singletablecontent)]
|
||
|
||
def __CreateTableCaptionDict(self, tablestylesarr):
|
||
#根据caption生成表格字典，key=caption，value=属性数组
|
||
cap_dict = {}
|
||
|
||
for tablestyle_dict in tablestylesarr:
|
||
captionarr = tablestyle_dict['caption']
|
||
#该caption可能是一个逗号分隔的字符串数组，因此需要做拆分
|
||
captionlist = captionarr.split(",")
|
||
for caption in captionlist:
|
||
cap_dict[caption] = tablestyle_dict #以caption为key重新生成字典，便于查找
|
||
return cap_dict
|
||
|
||
#查找表格caption是否被匹配
|
||
def __JudgeIsCaption(self,caption_dict,tablecaption):
|
||
|
||
captionlst=caption_dict.keys() #得到json配置的所有caption
|
||
for caption in captionlst:
|
||
tablestyle_dict = caption_dict[caption]
|
||
if __dictIsHasKey__(tablestyle_dict, 'ispartial') and tablestyle_dict['ispartial']==True:
|
||
if caption in tablecaption:
|
||
return True,tablestyle_dict
|
||
else:
|
||
if caption == tablecaption:
|
||
return True,tablestyle_dict
|
||
return False,None
|
||
|
||
def __ModifySingleTableattr(self, singletablecontent, columnwidthlst, caption_dict):
|
||
#修改单个表格属性
|
||
#从单个表格里用正则表达式找caption
|
||
#定义正则表达式,查找caption内容
|
||
tablecaption = ''
|
||
new_singletablecontent = singletablecontent
|
||
if self.tablesattrobj.isname:
|
||
searchstr = r'.*\\label.*?:(?P<caption>[\s\S].*)}}.*'
|
||
matchcaption = re.search(searchstr, singletablecontent, re.M | re.I | re.U)
|
||
if matchcaption is not None:
|
||
tablecaption = matchcaption.group('caption') # 得到caption的值
|
||
else:
|
||
tablecaption = ''
|
||
else:
|
||
tablecaption = self.__GetTableCaption(singletablecontent)
|
||
|
||
#stylefontsize = False
|
||
iscaption = False
|
||
iscaption,tablestyle_dict=self.__JudgeIsCaption(caption_dict,tablecaption)
|
||
if iscaption:
|
||
|
||
#if __dictIsHasKey__(tablestyle_dict,'fontsize') and (tablestyle_dict['fontsize'] in latexfontsize):
|
||
# stylefontsize = True
|
||
# tablestyle_dict['isLongTable'] = True #只有长表格的\caption指令，设置的字体才能生效，所以如果要设置表格字体，需要强制设置为长表格。
|
||
jsonmultirow = [] #保存需要设置自动换行的合并单元格的列号。
|
||
if __dictIsHasKey__(tablestyle_dict, 'multirowcolumn'):
|
||
jsonmultirow = tablestyle_dict['multirowcolumn']
|
||
|
||
if __dictIsHasKey__(tablestyle_dict, 'isLongTable') is not True:
|
||
tablestyle_dict['isLongTable'] = False
|
||
|
||
if __dictIsHasKey__(tablestyle_dict, 'isCusHead') is not True:
|
||
tablestyle_dict['isCusHead'] = False
|
||
|
||
#修改表格通用属性
|
||
new_singletablecontent,islongtable= self.__StartModifyTableAttr(new_singletablecontent,
|
||
columnwidthlst,
|
||
tablestyle_dict['isLongTable'],
|
||
tablestyle_dict['isCusHead'],
|
||
jsonmultirow,
|
||
tablestyle_dict)
|
||
#设置该表格定制字体
|
||
if __dictIsHasKey__(tablestyle_dict,'fontsize') and (tablestyle_dict['fontsize'] in latexfontsize):
|
||
new_singletablecontent=self.__ModifyTableFontSize(new_singletablecontent,tablestyle_dict['fontsize'])
|
||
|
||
#渲染竖型表格的第一列
|
||
if __dictIsHasKey__(tablestyle_dict,'isVertical') and tablestyle_dict['isVertical']==True:
|
||
if islongtable:
|
||
# 长表格自定义sphinxcolwidth的第2个参数默认为5，否则无法实现自动换行
|
||
#self.normalstr = self.normalstr % {
|
||
# 'flag': '%(flag)s',
|
||
# 'colwidth': '5',
|
||
# 'sphinxstyletheadfamily': '%(sphinxstyletheadfamily)s',
|
||
# 'content': '%(content)s'
|
||
#}
|
||
new_singletablecontent = self.__ModifyVerticalLongTable(new_singletablecontent,tablestyle_dict,columnwidthlst)
|
||
else:
|
||
# 普通表格自定义sphinxcolwidth的第2个参数默认为3，否则无法实现自动换行
|
||
#self.normalstr = self.normalstr % {
|
||
# 'flag': '%(flag)s',
|
||
# 'colwidth': '3',
|
||
# 'sphinxstyletheadfamily': '%(sphinxstyletheadfamily)s',
|
||
# 'content': '%(content)s'
|
||
#}
|
||
new_singletablecontent = self.__ModifyTableByLine(new_singletablecontent,True,False,tablestyle_dict,columnwidthlst)
|
||
|
||
if __dictIsHasKey__(tablestyle_dict,'isnewpage') and tablestyle_dict['isnewpage']==True:
|
||
new_singletablecontent = '\\newpage\n' + new_singletablecontent
|
||
|
||
#最后修改表格的行高
|
||
if __dictIsHasKey__(tablestyle_dict, 'ht_rowno') and tablestyle_dict['ht_rowno'] is not None:
|
||
new_singletablecontent = self.__ModifyTableRowHeight(islongtable,new_singletablecontent,tablestyle_dict['ht_rowno'])
|
||
else:
|
||
#修改表格的通用属性
|
||
new_singletablecontent,islongtable = self.__StartModifyTableAttr(singletablecontent, columnwidthlst, False)
|
||
if new_singletablecontent == '':
|
||
new_singletablecontent = singletablecontent
|
||
|
||
return new_singletablecontent
|
||
|
||
def __NormaltableRowHeight(self,rowno,rowheightinfo,singletablecontent):
|
||
#自定义长表格，第一行以“\hline”开头，因此从第一个“\hline”开头进行替换。
|
||
searchstr = r'\\hline'
|
||
match = re.search(searchstr,singletablecontent,re.I | re.U)
|
||
if match is None:
|
||
return singletablecontent
|
||
|
||
#latex表格属性内容
|
||
tablehead = singletablecontent[0:match.start()]
|
||
#表格内容
|
||
tablecontent = singletablecontent[match.start():len(singletablecontent)]
|
||
tablecontent = self.__ModifyNormalRowHeight(rowno,rowheightinfo,0,tablecontent)
|
||
|
||
return tablehead + tablecontent
|
||
|
||
def __ModifyNormalRowHeight(self, rowno, rowheightinfo, startline, tablecontent):
|
||
# 修改除表格外其它行的行高，并返回修改后的内容
|
||
searchstr = r'\\\\'
|
||
pattern = re.compile(searchstr, re.I | re.U)
|
||
matchiter = pattern.finditer(tablecontent)
|
||
i = startline
|
||
for m in matchiter:
|
||
i += 1
|
||
if rowno == i:
|
||
# 开始设置该行的行高
|
||
# 获取起始和结束位置
|
||
posstart = m.start()
|
||
posend = m.end()
|
||
tablecontent = tablecontent[0:posstart] + rowheightinfo + tablecontent[posend:len(tablecontent)]
|
||
break
|
||
|
||
return tablecontent
|
||
|
||
def __JudgeRowlistRule(self,rowlist):
|
||
#判断行号和行高信息是否符合规则
|
||
|
||
if len(rowlist)!=2:
|
||
return False
|
||
rowno = rowlist[0] #得到行号
|
||
rowhtstr=rowlist[1] #得到行高信息
|
||
|
||
#判断是否为异常信息
|
||
#设置的最大行高不能超过10，因为10的行高太高，正常不需要这么高的行高。而且sphinx会根据换行自动调整行高，该方法只用户行高的微调。
|
||
if rowno <= 0 or len(rowhtstr) == 0 or not rowhtstr.isdigit() or (int(rowhtstr) > 99):
|
||
return False
|
||
return True
|
||
|
||
def __ModifyLongTableRowHeight(self,rowno,rowheightinfo,singletablecontent):
|
||
|
||
# 判断是自定义长表格还是sphinx生成的长表格。
|
||
# sphinx自动生成的长表格有两个表头，第一个表头以“\endfirsthead”结尾。
|
||
# 自定义的长表格没有“\endfirsthead”标志
|
||
searchstr = r'\\endfirsthead'
|
||
matchobj = re.search(searchstr, singletablecontent, re.I | re.U)
|
||
if matchobj is None:
|
||
# 可能是自定义长表格，自定义长表格没有endfirsthead和endhead需要单独设置
|
||
singletablecontent = self.__NormaltableRowHeight(rowno,rowheightinfo,singletablecontent)
|
||
return singletablecontent
|
||
|
||
if rowno==1: #因为长表格有两个表头，因此两个表头都要设置，避免换页后表头格式不一致。
|
||
#修改长表格的表头
|
||
firsthead = singletablecontent[0:matchobj.end()]
|
||
rpos = firsthead.rfind(r"\\")
|
||
firsthead = firsthead[0:rpos] + rowheightinfo + firsthead[rpos+len(r"\\"):len(firsthead)]
|
||
|
||
#查找第2个表头，第2个表头以“\endhead”结尾
|
||
searchstr = r'\\endhead'
|
||
matchobj2 = re.search(searchstr, singletablecontent, re.I | re.U)
|
||
endhead = singletablecontent[matchobj.end():matchobj2.end()]
|
||
rpos = endhead.rfind(r"\\")
|
||
|
||
endhead = endhead[0:rpos]+rowheightinfo+ endhead[rpos+len(r"\\"):len(firsthead)]
|
||
|
||
singletablecontent = firsthead+endhead+singletablecontent[matchobj2.end():len(singletablecontent)]
|
||
|
||
if rowno > 1:
|
||
#长表格先将表头去除掉，否则表头会包含很多“\\”，但不代表行。
|
||
#长表格的表头以“\endlastfoot”结尾
|
||
searchstr = r'\\endlastfoot'
|
||
matchobj = re.search(searchstr, singletablecontent, re.I | re.U)
|
||
tablehead = singletablecontent[0:matchobj.end()]
|
||
othercontent = singletablecontent[matchobj.end():len(singletablecontent)]
|
||
|
||
#修改表格内容，因为长表格有两个表头，因此表头后的行号起始行从1开始。
|
||
othercontent = self.__ModifyNormalRowHeight(rowno,rowheightinfo,1,othercontent)
|
||
|
||
singletablecontent = tablehead + othercontent
|
||
return singletablecontent
|
||
|
||
def __ModifyTableRowHeight(self,islongtable,singletablecontent, rowlistarry):
|
||
|
||
#解析行信息，包含行号和行高信息
|
||
for rowlist in rowlistarry:
|
||
|
||
if not self.__JudgeRowlistRule(rowlist):
|
||
continue
|
||
rowno = rowlist[0]
|
||
rowheightinfo = r"\\[" + rowlist[1] +r"ex]" #要替换的行高信息
|
||
#根据正则表达式，查找换行符"\\",每一个“\\"代表表格的一行，需要在“\\”的末尾添加行高数据：“\\[rowhtstr+ex]”
|
||
if islongtable:
|
||
singletablecontent = self.__ModifyLongTableRowHeight(rowno, rowheightinfo,singletablecontent)
|
||
else:
|
||
singletablecontent = self.__NormaltableRowHeight(rowno,rowheightinfo,singletablecontent)
|
||
|
||
return singletablecontent
|
||
|
||
def __StartModifyTableAttr(self, singletablecontent, columnwidthlst, islongtable, isCusHead=True,jsonmultirow=None,tablestyle_dict=None):
|
||
#修改表格的通用属性
|
||
searchstr = r'(\\begin{tabular}|\\begin{tabulary})(\[[a-z]\]|{\\linewidth}\[[a-z]\])([\s\S].*)'
|
||
#为了添加表格的通用属性，先对字符串做分割
|
||
#python会把正则表达式中的分组自动分割，因此上面的正则表达式会自动分割为三个字符串
|
||
#加上头尾字符串总共分为5个字符串数组。要修改第1维字符串为\\being{longtable},
|
||
#第2维字符串直接删除，第3维字符串不变
|
||
splittable = re.split(searchstr, singletablecontent,0, re.M | re.I|re.U )
|
||
if splittable is None or len(splittable) < 5:
|
||
#再修改长表格属性
|
||
searchstr = r'\\begin{longtable}([\s\S].*)'
|
||
#为了添加表格的通用属性，先对字符串做分割
|
||
#python会把正则表达式中的分组自动分割，因此上面的正则表达式会自动分割为三个字符串
|
||
#加上头尾字符串总共分为5个字符串数组。要修改第1维字符串为\\being{longtable},第2维字符串直接删除，
|
||
#第3维字符串不变
|
||
splittable = re.split(searchstr, singletablecontent,0, re.M | re.I|re.U )
|
||
if len(splittable) < 3:
|
||
#至少是3维的数组，否则不是预想的内容，不做处理
|
||
return singletablecontent
|
||
if isCusHead:
|
||
newtable4 = self.__ModifyLongTableHead(splittable[2],
|
||
columnwidthlst,
|
||
self.tablesattrobj.headtype,
|
||
jsonmultirow,
|
||
tablestyle_dict)
|
||
# begin{longtable}必须再加上，因为Python并不认为它是正则表达式，因此不再分组里面第0个分组为空。
|
||
singletablecontent = splittable[0]+r'\begin{longtable}'+splittable[1]+newtable4
|
||
if self.tablesattrobj.fontsize !="":
|
||
#设置表格字体
|
||
singletablecontent=self.__ModifyTableFontSize(singletablecontent,self.tablesattrobj.fontsize)
|
||
return singletablecontent,True
|
||
|
||
#拆分后splittable应该为5个字符串的数组，拆分后便于添加通用属性
|
||
if self.tablesattrobj.rowtype != '':
|
||
splittable[0] += self.tablesattrobj.rowtype + '\n'
|
||
|
||
if isCusHead is True:
|
||
#修改表头字体颜色为白色加粗
|
||
newtable4 = self.__ModifyTableHead(splittable[4],
|
||
columnwidthlst,
|
||
self.tablesattrobj.headtype,
|
||
jsonmultirow,
|
||
tablestyle_dict)
|
||
else:
|
||
newtable4 = splittable[4]
|
||
|
||
singletablecontent = splittable[0]+splittable[1]+splittable[2]+splittable[3]+newtable4
|
||
#根据配置设置表格为长表格，现在基本通过将sphinx的class属性设置为longtable实现，不再通过手动设置完成。
|
||
if islongtable is True:
|
||
singletablecontent = self.__ModifyTableLongHeadAndTail(singletablecontent)
|
||
|
||
if self.tablesattrobj.fontsize !="":
|
||
#设置表格字体
|
||
singletablecontent=self.__ModifyTableFontSize(singletablecontent,self.tablesattrobj.fontsize)
|
||
|
||
return singletablecontent,False
|
||
|
||
def __ModifyTableLongHeadAndTail(self,singletablecontent):
|
||
#长表格的头尾都要替换，因此单独封装成一个函数，否则长表格的表格序号将加2
|
||
#替换第一行为长表格
|
||
searchstr = r'(\\begin{savenotes}[\S]*?\\sphinxattablestart)'
|
||
splittable = re.search(searchstr, singletablecontent,re.M | re.I|re.U )
|
||
firstend =splittable.end()
|
||
#替换为长表格
|
||
tablefirstline = re.sub(r'\\sphinxattablestart',r'\n\\sphinxatlongtablestart\n', splittable.group(0), 1,re.M|re.I|re.U)
|
||
if r'\sphinxthistablewithglobalstyle' in singletablecontent:
|
||
tablefirstline += '\\sphinxthistablewithglobalstyle\n'
|
||
if r'\sphinxthistablewithvlinesstyle' in singletablecontent:
|
||
tablefirstline += '\\sphinxthistablewithvlinesstyle\n'
|
||
#替换第2行为长表格
|
||
searchstr = r'(\\begin{tabular}|\\begin{tabulary})(\[[a-z]\]|{\\linewidth}\[[a-z]\])([\s\S].*)'
|
||
splittable = re.search(searchstr, singletablecontent,re.I|re.U )
|
||
#记录表头的位置
|
||
headstartpos= splittable.start()
|
||
headlastpos = splittable.end()
|
||
tablesecondline = re.sub(r'\\begin{tabular}|\\begin{tabulary}',r'\\begin{longtable}', splittable.group(0), 1,re.I|re.U)
|
||
tablesecondline = re.sub(r'\{\\linewidth\}',r'', tablesecondline, 1,re.I|re.U)
|
||
|
||
#查找caption
|
||
searchstr = r'\\sphinxcaption([\s\S].*)'
|
||
splittable = re.search(searchstr, singletablecontent, re.I|re.U)
|
||
if splittable is not None:
|
||
longcaption = re.sub(r'\\sphinxcaption',r'\\caption', splittable.group(0), 1,re.I|re.U)
|
||
#添加长表格专用指令
|
||
longcaption += r"\\*[\sphinxlongtablecapskipadjust]"
|
||
|
||
#构建长表个的表头部分
|
||
longhead = tablefirstline + tablesecondline + '\n' + r'\sphinxthelongtablecaptionisattop' + '\n'+ longcaption+'\n'
|
||
else:
|
||
#如果没有caption需要把中间的内容加上，否则会丢失label导致连接失效
|
||
longhead = tablefirstline + singletablecontent[firstend:headstartpos]+tablesecondline + '\n'
|
||
|
||
#替换表尾
|
||
newtablecontent = singletablecontent[headlastpos:len(singletablecontent)]
|
||
index = newtablecontent.rfind('\\end{tabulary}')
|
||
if index > 0:
|
||
endtable = newtablecontent[index:len(newtablecontent)]
|
||
othercontent = newtablecontent[0:index]
|
||
endtable = re.sub(r'(\\end{tabular}|\\end{tabulary})', r'\\end{longtable}', endtable, 1,re.M | re.I | re.U)
|
||
endtable = re.sub(r'\\par', r'', endtable, 1, re.M | re.I | re.U)
|
||
endtable = re.sub(r'\\sphinxattableend', r'\\sphinxatlongtableend', endtable, 1, re.M | re.I | re.U)
|
||
newtablecontent = othercontent + endtable
|
||
else:
|
||
index = newtablecontent.rfind('\\end{tabular}')
|
||
if index >0:
|
||
endtable = newtablecontent[index:len(newtablecontent)]
|
||
othercontent = newtablecontent[0:index]
|
||
endtable = re.sub(r'(\\end{tabular}|\\end{tabulary})', r'\\end{longtable}', endtable, 1,re.M | re.I | re.U)
|
||
endtable = re.sub(r'\\par', r'', endtable, 1, re.M | re.I | re.U)
|
||
endtable = re.sub(r'\\sphinxattableend', r'\\sphinxatlongtableend', endtable, 1, re.M | re.I | re.U)
|
||
newtablecontent = othercontent + endtable
|
||
|
||
singletablecontent = longhead + newtablecontent
|
||
return singletablecontent
|
||
|
||
#为表格增加h属性对齐方式，避免表格浮动，让表格在当前位置显示
|
||
def __AddHAttrForTable(self,content):
|
||
|
||
newcontent=""
|
||
searchstr = r'(\\begin{tabular}|\\begin{tabulary}|\\begin{longtable})({\\linewidth})?(\[(?P<attr>[a-z]{1,4})\])?([\s\S].*)'
|
||
m = re.search(searchstr, content, re.M|re.I|re.U )
|
||
attrcontent = m.group('attr')
|
||
posarr = m.span()
|
||
if m.group(3) == '': #group(3)是[htp]的组合，如果没有表格属性则添加上表格属性
|
||
newcontent = content[0:posarr[0]]+m.group(1)+m.group(2)+r'[h]'+m.group(5)+content[posarr[1]:len(content)]
|
||
else:
|
||
replacestr = m.group(4) #需要被替换的表格属性
|
||
#判断该表格是否有P属性，如果有p属性需要删掉
|
||
replacestr.replace('p','')
|
||
#给该表格添加h属性，避免表格浮动，让表格在当前位置显示
|
||
replacestr = 'h'+replacestr
|
||
newcontent = content[0:posarr[0]]+m.group(1)+m.group(2)+'['+replacestr+']'+m.group(5)+content[posarr[1]:len(content)]
|
||
|
||
return newcontent
|
||
def __GetColumnParaByWidths(self,content):
|
||
# 可能用的widths参数设置的列宽，再根据widths参数解析列宽
|
||
columnwidthlst = []
|
||
# 如果列宽不等于100，为了使表格不超过页面显示范围，以100为基数重新调整各列的列宽
|
||
newcolumnwidth = "|"
|
||
isadjustcol = False
|
||
newcontent = content
|
||
try:
|
||
searchstr = r'(?<=\|)\\X\{(?P<count1>[0-9]*)\}\{(?P<count2>[0-9]*)\}(?=\|)'
|
||
pattern = re.compile(searchstr, re.I | re.U)
|
||
match = pattern.finditer(content)
|
||
if match is None:
|
||
return [],content
|
||
for m in match:
|
||
count1 = int(m.group('count1'))
|
||
count2 = int(m.group('count2'))
|
||
|
||
tempcount = round(count1/count2,2)
|
||
colwidth = "%(float)s\\textwidth"
|
||
colwidth = colwidth % {
|
||
'float': str(tempcount)
|
||
}
|
||
columnwidthlst.append(colwidth)
|
||
if count2 != 100:
|
||
isadjustcol = True
|
||
#重新调整count1和count2的值，并加入列表
|
||
percolwidth = r"\X{" + str(int(tempcount * 100)) + "}{100}|"
|
||
newcolumnwidth = newcolumnwidth + percolwidth
|
||
|
||
if isadjustcol is True:
|
||
searchstr = r"(?<=\{)\|\\X[\s\S]*?\|(?=\})"
|
||
match = re.search(searchstr,content,re.I | re.U)
|
||
if match is not None:
|
||
newcontent = content.replace(match.group(),newcolumnwidth,1)
|
||
|
||
except Exception as e:
|
||
print(e)
|
||
finally:
|
||
return columnwidthlst,newcontent
|
||
|
||
def __GetColumnParameters(self,content):
|
||
'''
|
||
得到通过tablecolumns参数设置的列宽，multirow的自动换行，必须有列宽参数，否则无法实现自动换行。
|
||
而且不能通过widths参数设置每列的列宽，否则生成的列宽无法用于multirow，依然无法实现multirow的自动换行
|
||
:param content:
|
||
:return:
|
||
'''
|
||
# 默认ismultirowautowrap为自动换行
|
||
# 如果表格用tabluarcolumns指令设置的列宽，因为每列的宽度有具体的值，则默认自动换行
|
||
# 如果表格用widths指令设置的列宽，因为每列的宽度不具体，则默认不自动换行，需要手动换行
|
||
self.tablesattrobj.ismultirowautowrap = True #默认ismultirowautowrap为自动换行
|
||
newcontent = content
|
||
columnwidthlst=[] #保存每一列宽度的列表
|
||
#根据表格内容，得到每一列宽度参数，方便multirow的时候自动换行
|
||
#m垂直居中，p垂直靠上，b垂直靠下
|
||
searchstr= r'(?<=\|)[\s\S]*?[m|p|b]\{(?P<width>[\s\S]*?)\}[\s\S]*?(?=\|)'
|
||
pattern = re.compile(searchstr,re.I | re.U)
|
||
match = pattern.finditer(content)
|
||
if match is None:
|
||
#columnwidthlst,newcontent = self.__GetColumnParaByWidths(content)
|
||
self.tablesattrobj.ismultirowautowrap = False #则默认需要手动换行
|
||
return [],newcontent
|
||
|
||
for m in match:
|
||
columnwidthlst.append(m.group('width'))
|
||
if len(columnwidthlst) ==0:
|
||
#columnwidthlst,newcontent= self.__GetColumnParaByWidths(content)
|
||
self.tablesattrobj.ismultirowautowrap = False #则默认需要手动换行
|
||
return [],newcontent
|
||
return columnwidthlst,newcontent
|
||
|
||
def __FindTableHeadForFamily(self,content,isLongTable):
|
||
'''
|
||
根据sphinxstyletheadfamily标志查找表格的表头，有sphinxstyletheadfamily标志的表头，源文件必须以“======”分割。
|
||
具有合并单元格的表头，源文件必须以“===”分割，而且表头最多支持两行，否则合并单元格的表头不支持渲染。
|
||
:param content: 表格内容
|
||
:return: headcontent 表格内容
|
||
'''
|
||
#查找表头的起始位置，以第一个\hline开始。
|
||
if isLongTable is True:
|
||
searchstr =r"(\\hline[\s\S]*)(?=\\endfirsthead)"
|
||
matchobj = re.search(searchstr, content, re.I|re.M|re.U)
|
||
tablehead = matchobj.group()
|
||
else:
|
||
searchstr = r'\\hline'
|
||
matchobj = re.search(searchstr,content,re.I)
|
||
if matchobj is None:
|
||
return ""
|
||
startpos = matchobj.start() #表头的起始位置
|
||
familypos = content.rfind(r'\sphinxstyletheadfamily') #查找最后一个sphinxstyletheadfamily出现的位置
|
||
if familypos ==-1:
|
||
return ""
|
||
|
||
#从familypos开始，查找到的第一个“\\”，则为表头的行结束符号。
|
||
endpos = content.find(r"\hline",familypos)
|
||
# 得到表头内容，表头内容从起始\hline开始，到\hline结束，这种查找方式，兼容表头为两行的情况。
|
||
tablehead = content[startpos:endpos+len(r"\hline")]
|
||
|
||
return tablehead
|
||
|
||
def __FindAndFlagPos(self,tablehead,andpos):
|
||
if andpos != -1:
|
||
# 查找&前面有没有转义字符，有转义字符，则&不为单元格分割符，需要再继续查找
|
||
preflag = tablehead[andpos-1]
|
||
if preflag == '\\':
|
||
#如果是\&说明这个&不是单元格的分隔符,则需要继续查找
|
||
newpos=tablehead.find("&",andpos+1)
|
||
andpos = self.__FindAndFlagPos(tablehead,newpos)
|
||
return andpos
|
||
else:
|
||
return andpos
|
||
return andpos
|
||
|
||
def __FindCellContentForHead(self,tablehead,startpos):
|
||
#查找每个单元格的内容
|
||
if startpos == -1:
|
||
return 0,-1,None
|
||
|
||
# 查找&和\\的位置，&为单元格的分割标志,\\为行结束标志，一个单元格的分割标志可能是&，也可能是\\
|
||
cellcontent = []
|
||
andpos = tablehead.find("&", startpos)
|
||
# 得到实际的分隔符位置，避免&内容里面的符号，而不是单元格分隔符
|
||
andpos = self.__FindAndFlagPos(tablehead, andpos)
|
||
linepos = tablehead.find(r"\\", startpos)
|
||
|
||
if andpos ==-1 and linepos ==-1:
|
||
return 0,-1,None
|
||
|
||
newpos = -1
|
||
lineflag = 0 # 是否启动新行的标志。0说明在当前行；1说明遇到了\\，需要启动新的一行
|
||
if andpos == -1 or linepos < andpos:
|
||
# 该单元格的分割符为\\
|
||
cellcontent.append(tablehead[startpos:linepos])
|
||
cellcontent.append(r"\\")
|
||
newpos = linepos + len(r"\\")
|
||
lineflag = 1
|
||
else:
|
||
cellcontent.append(tablehead[startpos:andpos])
|
||
cellcontent.append(r"&")
|
||
newpos = andpos + len(r"&")
|
||
return lineflag,newpos,cellcontent
|
||
'''
|
||
#暂时注释，不在使用该函数，使用上面函数的写法
|
||
def __delNotMustStrFromContent(self, content):
|
||
content = content.strip().strip("\n").strip("\r")
|
||
for delstr in self.delstrlst:
|
||
if delstr in content:
|
||
content = content.replace(delstr,"")
|
||
|
||
content = content.strip().strip("\n").strip("\r")
|
||
print('content=%s' % content)
|
||
strlst = content.split('\n')
|
||
newcontent = ""
|
||
for i in strlst:
|
||
if i != "":
|
||
i.strip("\r")
|
||
if i != strlst[-1] and i != "":
|
||
i = i + r"\\ "
|
||
newcontent = newcontent + i
|
||
content = self.autolinetemplat % {
|
||
'autocontent': newcontent
|
||
}
|
||
return content
|
||
'''
|
||
|
||
def __delNotMustrowStrFromContent(self, content, ismanualwraplst=None):
|
||
"""
|
||
该函数用于multirow的手动换行，为了更好的显示效果，multicolumn的手动换行请参见__delNotMustStrFromContent
|
||
:param content:
|
||
:param ismanualwraplst: list类型，只有一个元素。是否有手动换行，为了回传，并兼容之前的调用，设计了list类型。
|
||
:return:
|
||
"""
|
||
# 实现自动换行
|
||
# 去掉首尾换行和空白字符
|
||
content = content.strip().strip("\n").strip("\r")
|
||
# 删除单元格内容里非必须的成分
|
||
for delstr in self.delstrlst:
|
||
if delstr in content:
|
||
content = content.replace(delstr, "")
|
||
# 正则匹配既是加了“r”，也要用转义字符，因为r只是去掉了python的转义，
|
||
# 但正则本身也需要一层转义
|
||
content = content.strip().strip("\n").strip("\r")
|
||
searchstr = r"\\sphinxAtStartPar"
|
||
match = re.search(searchstr, content, re.I | re.M)
|
||
if match is not None:
|
||
# 说明在字符串的起始位置匹配成功
|
||
content = content[match.end():len(content)]
|
||
# 再去掉首尾空格和换行
|
||
content = content.strip().strip("\n").strip("\r")
|
||
if r"\sphinxAtStartPar" in content:
|
||
# 字符串替换比较，如果用了r则无需再加一次转义字符
|
||
# 替换所有的回车换行符，否则autolinetemplat中间不能有回车换行，否则将导致错误
|
||
content = content.replace("\n", "").replace("\r", "")
|
||
content = content.replace(r"\sphinxAtStartPar", r"\newline ")
|
||
if ismanualwraplst is not None:
|
||
ismanualwraplst[0] = True
|
||
else:
|
||
strlst = content.split('\n')
|
||
newcontent = ""
|
||
for i in range(0, len(strlst)):
|
||
str = strlst[i].strip("\r")
|
||
if str != "":
|
||
strlst[i] = str
|
||
else:
|
||
if i > 0 and i < (len(strlst) - 1) and strlst[i - 1] != r"\newline ":
|
||
strlst[i] = r"\newline "
|
||
|
||
content = "".join(strlst)
|
||
if r"\newline" in content and ismanualwraplst is not None:
|
||
ismanualwraplst[0] = True
|
||
|
||
return content
|
||
|
||
def __delNotMustStrFromContent(self,content,ismanualwraplst=None):
|
||
"""
|
||
该函数用于multicolumn的手动换行，为了更好的显示效果，multirow的手动换行请参见__delNotMustrowStrFromContent
|
||
:param content:
|
||
:param ismanualwraplst: list类型，只有一个元素。是否有手动换行，为了回传，并兼容之前的调用，设计了list类型。
|
||
:return:
|
||
"""
|
||
#实现自动换行
|
||
#去掉首尾换行和空白字符
|
||
content = content.strip().strip("\n").strip("\r")
|
||
#删除单元格内容里非必须的成分
|
||
for delstr in self.delstrlst:
|
||
if delstr in content:
|
||
content = content.replace(delstr,"")
|
||
# 正则匹配既是加了“r”，也要用转义字符，因为r只是去掉了python的转义，
|
||
# 但正则本身也需要一层转义
|
||
content = content.strip().strip("\n").strip("\r")
|
||
searchstr = r"\\sphinxAtStartPar"
|
||
match = re.search(searchstr,content,re.I|re.M)
|
||
if match is not None:
|
||
#说明在字符串的起始位置匹配成功
|
||
content = content[match.end():len(content)]
|
||
# 再去掉首尾空格和换行
|
||
content = content.strip().strip("\n").strip("\r")
|
||
if r"\sphinxAtStartPar" in content:
|
||
#字符串替换比较，如果用了r则无需再加一次转义字符
|
||
#替换所有的回车换行符，否则autolinetemplat中间不能有回车换行，否则将导致错误
|
||
content=content.replace("\n","").replace("\r","")
|
||
content = content.replace(r"\sphinxAtStartPar", r"\\ ")
|
||
content = self.autolinetemplat % {
|
||
'autocontent': content
|
||
}
|
||
if ismanualwraplst is not None:
|
||
ismanualwraplst[0] = True
|
||
else:
|
||
strlst = content.split('\n')
|
||
newcontent = ""
|
||
for i in range(0,len(strlst)):
|
||
str = strlst[i].strip("\r")
|
||
if str != "":
|
||
strlst[i]=str
|
||
else:
|
||
if i>0 and i< (len(strlst)-1) and strlst[i-1] != r"\\ ":
|
||
strlst[i]=r"\\ "
|
||
|
||
newcontent = "".join(strlst)
|
||
if r"\\ " in newcontent:
|
||
content = self.autolinetemplat % {
|
||
'autocontent': newcontent
|
||
}
|
||
if ismanualwraplst is not None:
|
||
ismanualwraplst[0] = True
|
||
else:
|
||
content = newcontent
|
||
|
||
return content
|
||
|
||
def __ModifySphinxMultirow(self,cellstr,contentdict,columnwidthlst,jsonmultirow,lineindex,colindex,multirowindex,tablestyle_dict,isvertical=False):
|
||
'''
|
||
修改multirow内容
|
||
取出关键内容合并单元格的数量和单元格内容
|
||
:param isvertical:如果是渲染第一列，multirow加\raggedright参数为了对齐
|
||
渲染行，无需加该参数，显示效果没明显差别。
|
||
'''
|
||
#searchstr=r"(?<=\\sphinxmultirow){(?P<count>[0-9]*)}{(?P<flag>[0-9]*)}([\s\S]*?)\\sphinxstyletheadfamily(?P<content>[\s\S]*?)\\par([\s\S]*?)(?=\}\%)"
|
||
searchstr=r"(?<=\\sphinxmultirow){(?P<count>[1-9]*)}{(?P<flag>[0-9]*)}{([\s\S]*?){\\sphinxcolwidth{[0-9]*}{[0-9]*}}[\s]*(\\sphinxstyletheadfamily)?(?P<content>[\s\S]*?)\\par([\s\S]*?)(?=\}\%)"
|
||
match = re.finditer(searchstr, cellstr, re.M | re.I | re.U)
|
||
count = ""
|
||
flag = ""
|
||
content = ""
|
||
for m in match:
|
||
if count == "":
|
||
count = m.group('count')
|
||
if flag == "":
|
||
flag = m.group('flag')
|
||
if content == "":
|
||
content = m.group('content')
|
||
|
||
#如果是自动换行，设置列宽
|
||
coluwidth = "*"
|
||
if len(columnwidthlst) > 0:
|
||
if tablestyle_dict is not None and \
|
||
__dictIsHasKey__(tablestyle_dict,"ismultirowautowrap"):
|
||
if tablestyle_dict['ismultirowautowrap'] is True:
|
||
coluwidth = columnwidthlst[colindex-1]
|
||
else:
|
||
if self.tablesattrobj.ismultirowautowrap is True:
|
||
coluwidth = columnwidthlst[colindex-1]
|
||
|
||
#if (jsonmultirow is not None) and \
|
||
# (multirowindex>=0 and len(jsonmultirow)>multirowindex) and \
|
||
# (len(columnwidthlst)>jsonmultirow[multirowindex]-1):
|
||
# #得到要设置自动换行multirow的列号
|
||
# coluwidth = columnwidthlst[jsonmultirow[multirowindex]-1]
|
||
# #print("coluwidth = %s" % coluwidth)
|
||
#else:
|
||
# coluwidth = "*"
|
||
|
||
#if r"\sphinxstyletheadfamily" in cellstr:
|
||
#实测，multirow要支持渲染背景色，必须带上sphinxstyletheadfamily，否则会编译失败
|
||
sphinxstyletheadfamily = r"\sphinxstyletheadfamily"
|
||
raggedright = ""
|
||
if (isvertical is True) or \
|
||
(tablestyle_dict is not None and \
|
||
__dictIsHasKey__(tablestyle_dict, "ismultirowatupcell") and \
|
||
tablestyle_dict['ismultirowatupcell'] is True) or \
|
||
self.tablesattrobj.ismultirowatupcell is True:
|
||
#raggedright = r"{\raggedright}"
|
||
# 得到单元格内容
|
||
cellstr = self.commonstr % {
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': self.__delNotMustrowStrFromContent(content)
|
||
}
|
||
multistr = self.multirowstr % {
|
||
'count': count,
|
||
'coluwidth': coluwidth,
|
||
'raggedright': raggedright,
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': ""
|
||
}
|
||
#将flag对应的内容加到字典里，以方便后续交换
|
||
contentdict[flag] = str(int(count) + lineindex-1) + "," + multistr #为了支持超过两行的合并单元格，将count数量也带出去。第一个","之前的就是count数量
|
||
|
||
#返回空的字符串
|
||
return cellstr
|
||
else:
|
||
ismanualwraplst = [False]
|
||
if (tablestyle_dict is not None and \
|
||
__dictIsHasKey__(tablestyle_dict, "ismultirowatlowcell") and \
|
||
tablestyle_dict['ismultirowatlowcell'] is True ) or \
|
||
self.tablesattrobj.ismultirowatlowcell is True:
|
||
|
||
simplemultirow = self.simplemultirow % {
|
||
'count': count,
|
||
'coluwidth': coluwidth
|
||
}
|
||
|
||
cellstr = self.commonstr % {
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': self.__delNotMustrowStrFromContent(content, ismanualwraplst)
|
||
}
|
||
|
||
contentdict[flag] = str(int(count) + lineindex - 1) + "," + cellstr
|
||
|
||
return simplemultirow
|
||
|
||
multistr = self.multirowstr % {
|
||
'count': count,
|
||
'coluwidth': coluwidth,
|
||
'raggedright': raggedright,
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': self.__delNotMustStrFromContent(content)
|
||
}
|
||
# 将flag对应的内容加到字典里，以方便后续交换
|
||
contentdict[flag] = str(int(count) + lineindex - 1) + "," + multistr # 为了支持超过两行的合并单元格，将count数量也带出去。第一个","之前的就是count数量
|
||
|
||
# 返回空的字符串
|
||
return self.emptystr
|
||
|
||
|
||
|
||
def __ModifyMulticolumn(self,cellstr,tablestyle_dict):
|
||
'''
|
||
:param cellstr:
|
||
:return:
|
||
'''
|
||
searchstr = r"(?<=\\multicolumn){(?P<count>[1-9]*)}\{(?P<flag>[\s\S]*?)\}\{%(?P<prefix>[\s\S]*?)\\sphinxstyletheadfamily(?P<content>[\s\S]*?)\\par(?P<suffix>[\s\S]*)"
|
||
match = re.finditer(searchstr, cellstr, re.M | re.I | re.U)
|
||
count = ""
|
||
content = ""
|
||
flag=""
|
||
prefix=""
|
||
suffix=""
|
||
for m in match:
|
||
if count == "":
|
||
count = m.group('count')
|
||
if flag == "":
|
||
flag = m.group('flag')
|
||
if content == "":
|
||
content = m.group('content')
|
||
if prefix == "":
|
||
prefix = m.group('prefix')
|
||
#如果有\begin{varwidth}[t],替换为\begin{varwidth}[c]
|
||
#[t]会使得当自动换行的时候，单元格上面会有很大的空白
|
||
#print('===========================================')
|
||
#print(prefix)
|
||
searchstr = r"\\begin{varwidth}\[t\]"
|
||
replstr = r"\\begin{varwidth}[c]"
|
||
prefix = re.sub(searchstr,replstr,prefix,1,re.I|re.U|re.M)
|
||
#print(prefix)
|
||
#print('===========================================')
|
||
if suffix == "":
|
||
suffix = '\n\\par' + m.group('suffix') #因为正则表达式把\par去掉了，再加上
|
||
|
||
#行合并单元格，改成居中显示
|
||
newflag=re.sub(r"[a-z]",r"c",flag,1,re.I)
|
||
#newflag = flag
|
||
if (tablestyle_dict is not None and \
|
||
__dictIsHasKey__(tablestyle_dict,'ismulticolleftalign') and \
|
||
tablestyle_dict['ismulticolleftalign'] is True) or \
|
||
self.tablesattrobj.ismulticolleftalign is True:
|
||
#multistr = self.comcolstr % {
|
||
# 'count': count,
|
||
# 'flag': flag,
|
||
# 'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(content)
|
||
#}
|
||
multistr = self.multicolumnstr % {
|
||
'count':count,
|
||
'flag': flag,
|
||
'prefix':prefix,
|
||
'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
'content':self.__delNotMustStrFromContent(content),
|
||
'suffix':suffix
|
||
}
|
||
else:
|
||
multistr = self.multicolumnstr % {
|
||
'count':count,
|
||
'flag': newflag,
|
||
'prefix':prefix,
|
||
'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
'content':self.__delNotMustStrFromContent(content),
|
||
'suffix':suffix
|
||
}
|
||
|
||
#multistr = self.comcolstr % {
|
||
# 'count': count,
|
||
# 'flag': flag,
|
||
# 'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(content)
|
||
#}
|
||
return multistr
|
||
|
||
def __ModifyCellContentForMergeCell(self,cellcontent,
|
||
tablestyle_dict,islongtable,
|
||
contentdict,columnwidthlst,jsonmultirow,
|
||
colindex,lineindex,multirowindex,ismulticol = False):
|
||
'''
|
||
修改单元格内容
|
||
:param cellcontent:
|
||
:param ismulticol: 当前行是否有列合并单元格。
|
||
如果有列合并单元格，则独立的单元格需要用multcolumn命令，否则无法对齐。
|
||
:return:
|
||
'''
|
||
multirowflag = False #是否是multirow单元格
|
||
cellstr = cellcontent[0] #取得单元格内容
|
||
#print('===========================')
|
||
#print(cellstr)
|
||
|
||
#查找有没有\cline指令，如果有这个指令，为了划线清晰在前面再多加一个。
|
||
searchstr= r"\\cline\{[\s\S]*?\}"
|
||
match = re.search(searchstr,cellstr,re.I | re.M)
|
||
if match is not None:
|
||
cline = match.group()
|
||
#去掉开头的换行符，否则影响后面的正则表达式,导致正则表达式查找失败
|
||
cellstr = cellstr.lstrip()
|
||
cellstr = cline + cellstr
|
||
|
||
sphinxstyletheadfamily=""
|
||
if r'\sphinxmultirow' in cellstr:
|
||
cellcontent[0] = self.__ModifySphinxMultirow(cellstr,
|
||
contentdict,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
lineindex,
|
||
colindex,
|
||
multirowindex,
|
||
tablestyle_dict)
|
||
multirowflag = True
|
||
elif r'\multicolumn' in cellstr:
|
||
cellcontent[0] = self.__ModifyMulticolumn(cellstr,tablestyle_dict)
|
||
else:
|
||
if colindex == 1:
|
||
if len(columnwidthlst)>0 and colindex > 0:
|
||
flag = "|m{" + columnwidthlst[colindex - 1] + "}|"
|
||
else:
|
||
flag = "|l|"
|
||
else:
|
||
if len(columnwidthlst) > 0 and colindex > 0:
|
||
flag = "m{" + columnwidthlst[colindex - 1] + "}|"
|
||
else:
|
||
flag = "l|"
|
||
|
||
#查找\sphinxAtStartPar位置
|
||
precell = ""
|
||
pos = cellstr.find(r'\sphinxstyletheadfamily')
|
||
#print("cellstr = %s" % cellstr)
|
||
#print("pos=%d" % pos)
|
||
if pos > 0:
|
||
#说明前面还有内容，需要把前面的内容保存下来
|
||
precell = cellstr[0:pos] + "\n"
|
||
if pos != -1:
|
||
cellstr = cellstr[pos+len(r'\sphinxstyletheadfamily'):len(cellstr)]
|
||
sphinxstyletheadfamily = "\\sphinxstyletheadfamily"
|
||
|
||
ismanualwraplst=[False]
|
||
self.__delNotMustStrFromContent(cellstr,ismanualwraplst)
|
||
if ismanualwraplst[0] is True:
|
||
if colindex == 1:
|
||
flag = "|l|"
|
||
else:
|
||
flag = "l|"
|
||
colwidth = ""
|
||
if (len(columnwidthlst) > 0) and (colindex > 0):
|
||
colwidth = columnwidthlst[colindex-1]
|
||
|
||
fullcontentstr = self.normalstr % {
|
||
'flag': flag,
|
||
'colwidth': colwidth,
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': self.__delNotMustStrFromContent(cellstr)
|
||
}
|
||
else:
|
||
fullcontentstr = self.comcolstr % {
|
||
'count': "1",
|
||
'flag': flag,
|
||
'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
'content': self.__delNotMustStrFromContent(cellstr)
|
||
}
|
||
#if ismulticol is True:
|
||
#必须用multicolumn命令，否则当单元格后面还有列的时候，刷新会出现问题
|
||
#fullcontentstr = self.comcolstr % {
|
||
# 'count': "1",
|
||
# 'flag': flag,
|
||
# 'sphinxstyletheadfamily': sphinxstyletheadfamily,
|
||
# 'content': self.__delNotMustStrFromContent(cellstr)
|
||
#}
|
||
#else:
|
||
# fullcontentstr = self.commonstr % {
|
||
# 'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(contentstr)
|
||
# }
|
||
cellcontent[0] =precell + fullcontentstr
|
||
#print('===========================')
|
||
return multirowflag
|
||
|
||
def __FindMergeRowCountAndContent(self,multirowstr):
|
||
#找出合并行的数量和合并单元格的内容
|
||
count = 0
|
||
newmultistr = multirowstr
|
||
|
||
try:
|
||
searchstr = "([1-9]*?)(?=,)"
|
||
match = re.match(searchstr,newmultistr,re.I)
|
||
if match is not None:
|
||
count = int(match.group(0))
|
||
startpos = match.end()
|
||
newmultistr = multirowstr[startpos+1:len(multirowstr)]
|
||
finally:
|
||
return count,newmultistr
|
||
|
||
def __AdjustMultirowContent(self,cellcontent,contentdict,lineindex,colindex,columnwidthlst):
|
||
'''
|
||
调整multirow单元格到对应的下面的单元格
|
||
'''
|
||
#查找flag数量
|
||
cellstr = cellcontent[0]
|
||
#查找有没有\cline指令，如果有这个指令，为了划线清晰在前面再多加一个。
|
||
searchstr= r"\\cline\{[\s\S]*?\}"
|
||
match = re.search(searchstr,cellstr,re.I | re.M)
|
||
if match is not None:
|
||
cline = match.group()
|
||
#去掉开头的换行符，否则影响后面的正则表达式,导致正则表达式查找失败
|
||
cellstr = cellstr.lstrip()
|
||
cellstr = cline + cellstr
|
||
|
||
searchstr = r"\\sphinxtablestrut\{(?P<flag>[0-9]*)\}"
|
||
matchobj = re.search(searchstr, cellstr, re.I | re.M | re.U)
|
||
flag = matchobj.group('flag')
|
||
#得到修改后的multirow内容
|
||
if __dictIsHasKey__(contentdict,flag):
|
||
multirowstr = contentdict[flag]
|
||
#替换实际列号
|
||
replstr = r'\\sphinxtablestrut{' + str(colindex)+'}'
|
||
cellstr = re.sub(searchstr,replstr,cellstr,1,re.I|re.U|re.M)
|
||
#找出合并行的最大数量
|
||
count,multirowstr = self.__FindMergeRowCountAndContent(multirowstr)
|
||
if lineindex == count: #是最后一行了再合并，否则会重复
|
||
cellcontent[0] = cellstr+"\n"+multirowstr
|
||
else:
|
||
cellcontent[0] = cellstr+'\n' + r"\cellcolor" + self.tablesattrobj.headtype + "{}"
|
||
|
||
return cellcontent
|
||
|
||
def __GetFactColIndex(self,cellcontent):
|
||
'''
|
||
得到真实的列索引。当有multicolumn的时候，列索引需要加合并单元格的数量。
|
||
返回合并单元格的数量，没合并单元格返回1
|
||
:para cellcontent: 单元格内容字符串
|
||
'''
|
||
if len(cellcontent) ==0:
|
||
return 0
|
||
searchstr = r"\\multicolumn{(?P<count>[1-9]+)}"
|
||
match = re.search(searchstr,cellcontent,re.I|re.U)
|
||
if match is None:
|
||
return 1 #不是合并单元格，默认加1列
|
||
factcount = 1
|
||
try:
|
||
factcount = int(match.group('count'))
|
||
except Exception as e:
|
||
print('------------------')
|
||
print(e)
|
||
# traceback.print_stack()
|
||
traceback.print_exc()
|
||
print('------------------')
|
||
|
||
return factcount
|
||
def __ModifyTableHeadForFamilyList(self,tablehead,isLongtable,columnwidthlst,jsonmultirow,tablestyle_dict):
|
||
'''
|
||
用列表的方式逐个拆解每个单元格内容，列表格式为[['cell content','分割符号&或者\\'],[],[]]
|
||
:param tablehead:
|
||
:return:
|
||
'''
|
||
#内容的起始位置
|
||
startpos = tablehead.find(r'\\hline') + len(r'\\hline')
|
||
|
||
contentdict ={} #创建一个字典，用来保存mlutirow交换内容
|
||
#得到每个单元格的内容
|
||
colindex = 0 #是否第一个单元格的索引
|
||
lineindex = 1 #行索引，为了支持多行合并，默认起始在第一行
|
||
# multirowindex：第几个multirow单元格的索引号，用于作为conf.json中multirowcolumn字段的索引值，
|
||
# 取出当前multirow单元格真实所在列
|
||
#得到该列的列宽，填写到multirow指令里面，实现multirow指令中的内容自动换行
|
||
multirowindex = 0
|
||
lineflag = 0
|
||
newtablehead = "\\hline\n"
|
||
while startpos !=-1:
|
||
multirowflag = False # 是否是multirow处理，是的话__ModifyCellContentForMergeCell返回true，默认返回false
|
||
lineflag,startpos,cellcontent = self.__FindCellContentForHead(tablehead,startpos)
|
||
if cellcontent is not None:
|
||
factcolcount = self.__GetFactColIndex(cellcontent[0])
|
||
colindex = colindex+factcolcount #当前列号
|
||
if r"\sphinxtablestrut" in cellcontent[0]:
|
||
# 需要将multirow的内容copy到该单元格
|
||
self.__AdjustMultirowContent(cellcontent, contentdict,lineindex,colindex,columnwidthlst)
|
||
else:
|
||
|
||
multirowflag = self.__ModifyCellContentForMergeCell(cellcontent,
|
||
tablestyle_dict,
|
||
isLongtable,
|
||
contentdict,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
colindex,
|
||
lineindex,
|
||
multirowindex)
|
||
newtablehead = newtablehead+cellcontent[0] + "\n" + cellcontent[1]+ "\n"
|
||
|
||
if multirowflag is True:
|
||
multirowindex = multirowindex+1
|
||
lineindex = lineindex + lineflag # 计算新的行数
|
||
if lineflag:
|
||
# 如果开启了新行，则列索引从0开始计算
|
||
colindex = 0
|
||
|
||
#组成新的表头内容
|
||
newtablehead =newtablehead + "\\hline\n"
|
||
return newtablehead
|
||
def __modifyTableHeadForMinusSign(self,content,isLongTable,headtype,tablestyle_dict):
|
||
"""
|
||
如果表头不是用“=”分割的，而是用“-”分割，调用该函数修改表头
|
||
"""
|
||
# 先找出第一行
|
||
if isLongTable:
|
||
searchstr = r'\\endlastfoot[\s]+(\\sphinxtableatstartofbodyhook)?(?P<content>[\s\S]*?)\\hline'
|
||
else:
|
||
searchstr = r'\\hline(?P<content>[\s\S]*?)\\hline'
|
||
m = re.search(searchstr, content, re.M | re.I | re.U)
|
||
headcontent = m.group('content') # 匹配到的第一个即为表头内容
|
||
posarr = m.span('content') # 保存起始位置和结束位置，便于组成新的内容
|
||
|
||
if 'multicolumn' in headcontent:
|
||
return content
|
||
|
||
if r'\sphinxstyletheadfamily' in headcontent:
|
||
pattern = re.compile(r'(?<=\\sphinxstyletheadfamily)(?P<value>[\s\S]*?)(?=(\\unskip|&)|\\\\)',
|
||
re.M | re.I | re.U)
|
||
aftercontent = headcontent
|
||
# pattern = re.compile(r'(?<=\\sphinxstylethead{\\sphinxstyletheadfamily)([\s\S]*?)(?=\\unskip}\\relax &)', re.M | re.I|re.U)
|
||
else:
|
||
aftercontent = headcontent.replace(r'\\', '&', 1)
|
||
pattern = re.compile(r'(?P<value>[\s\S]*?)(&\s{1})', re.M | re.I | re.U)
|
||
# pattern = re.compile(r'[\s\S]*?&|\\unskip', re.M | re.I|re.U)
|
||
|
||
mobjarr = pattern.finditer(aftercontent)
|
||
headlist = []
|
||
preposlist = []
|
||
fontcolor = ""
|
||
for mobj in mobjarr:
|
||
amarr = mobj.group('value')
|
||
curposlist = [mobj.start(), mobj.start() + len(amarr)]
|
||
|
||
# 用表头内容数组替换
|
||
if self.tablesattrobj.headfontcolor != "":
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
# 先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() # 再去掉首尾空格，避免多余的空格出现
|
||
if amarr == '':
|
||
continue
|
||
amarr = self.__delNotMustStrFromContent(amarr)
|
||
fontcolor = fontcolor.replace('{}', '{' + amarr + '}', 1)
|
||
# 当表头没有合并单元格时，不能用cellcolor，否则表头不对齐
|
||
# fontcolor = self.commonstr % {
|
||
# 'sphinxstyletheadfamily':'',
|
||
# 'content': self.__delNotMustStrFromContent(amarr)
|
||
# }
|
||
if len(preposlist) > 0:
|
||
headlist.append(headcontent[preposlist[1]:curposlist[0]])
|
||
else:
|
||
headlist.append(headcontent[0:curposlist[0]])
|
||
headlist.append(fontcolor)
|
||
preposlist = curposlist
|
||
|
||
headlist.append(headcontent[preposlist[1]:len(headcontent)]) # 把最后一个字符串加上
|
||
headcontent = ''
|
||
for prelist in headlist:
|
||
headcontent = headcontent + prelist + '\n'
|
||
newcontent = content[0:posarr[0]] + r'\rowcolor' + headtype + '\n' + headcontent + content[
|
||
posarr[1]:len(content)]
|
||
return newcontent
|
||
#修改sphinx自动生成的长表格表头
|
||
def __ModifyLongTableHead(self,content,columnwidthlst,headtype,jsonmultirow,tablestyle_dict):
|
||
|
||
tablehead = self.__FindTableHeadForFamily(content,True)
|
||
if tablehead != "" and (r"\sphinxmultirow" in tablehead or r"\multicolumn" in tablehead):
|
||
#长表格自定义sphinxcolwidth的第2个参数默认为5，否则无法实现自动换行
|
||
#self.normalstr= self.normalstr % {
|
||
# 'flag': '%(flag)s',
|
||
# 'colwidth':'5',
|
||
# 'sphinxstyletheadfamily':'%(sphinxstyletheadfamily)s',
|
||
# 'content':'%(content)s'
|
||
#}
|
||
newtablehead = self.__ModifyTableHeadForFamilyList(tablehead,
|
||
True,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
tablestyle_dict)
|
||
return content.replace(tablehead,newtablehead,2)
|
||
|
||
#先找出第一行
|
||
if tablehead.strip() == r"\hline":
|
||
#进入该分支，说明表格设置为了长表格，但是表头没有用“=”分割，用“-”做的分割。
|
||
return self.__modifyTableHeadForMinusSign(content,True,headtype,tablestyle_dict)
|
||
|
||
searchstr = r'\\hline(?P<content>[\s\S]*?)\\hline'
|
||
pattern = re.compile(searchstr,re.M | re.I|re.U)
|
||
matchiter = pattern.finditer(content)
|
||
posarr = []
|
||
i = 0
|
||
for m in matchiter:
|
||
|
||
if i > 1:
|
||
break
|
||
|
||
posarr.append([])
|
||
posarr[i] = m.span() #保存起始位置和结束位置，便于组成新的内容
|
||
|
||
if i ==0:
|
||
newcontent = content[0:posarr[i][0]]
|
||
else:
|
||
newcontent = newcontent+content[posarr[i-1][1]:posarr[i][0]]
|
||
|
||
newcontent += r'\hline\rowcolor'+headtype
|
||
headcontent = m.group(1) #匹配到的第一个即为表头内容
|
||
|
||
if 'multicolumn' in headcontent:
|
||
return content
|
||
|
||
headlist = []
|
||
|
||
if r'\sphinxstyletheadfamily' in headcontent:
|
||
pattern = re.compile(r'(?<=\\sphinxstyletheadfamily)(?P<value>[\s\S]*?)(?=(\\unskip|&)|\\\\)', re.M | re.I|re.U)
|
||
aftercontent = headcontent
|
||
mobjarr = pattern.finditer(aftercontent)
|
||
|
||
preposlist = []
|
||
for mobj in mobjarr:
|
||
amarr = mobj.group('value')
|
||
curposlist = mobj.span()
|
||
|
||
#用表头内容数组替换
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
#先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() #再去掉首尾空格，避免多余的空格出现
|
||
if amarr == '':
|
||
continue
|
||
amarr = self.__delNotMustStrFromContent(amarr)
|
||
fontcolor = fontcolor.replace('{}','{'+ amarr+'}',1)
|
||
# 当表头没有合并单元格时，不能用cellcolor，否则表头不对齐
|
||
#fontcolor = self.commonstr % {
|
||
# 'sphinxstyletheadfamily': '',
|
||
# 'content': self.__delNotMustStrFromContent(amarr)
|
||
#}
|
||
if len(preposlist) > 0:
|
||
headlist.append(headcontent[preposlist[1]:curposlist[0]])
|
||
else:
|
||
headlist.append(headcontent[0:curposlist[0]])
|
||
headlist.append(fontcolor)
|
||
preposlist = curposlist
|
||
headlist.append(headcontent[preposlist[1]:len(headcontent)]) #把最后一个字符串加上
|
||
headcontent = ''
|
||
for prelist in headlist:
|
||
headcontent = headcontent + prelist + '\n'
|
||
newcontent += headcontent+r'\hline'
|
||
i +=1
|
||
newcontent += content[posarr[i-1][1]:len(content)]
|
||
return newcontent
|
||
|
||
def __ModifyTableHead(self, content,columnwidthlst, headtype,jsonmultirow,tablestyle_dict):
|
||
|
||
tablehead = self.__FindTableHeadForFamily(content,False)
|
||
if tablehead != "" and (r"\sphinxmultirow" in tablehead or r"\multicolumn" in tablehead):
|
||
#为了实现自动换行，普通表格自定义sphinxcolwidth的第2个参数默认为3，否则无法实现自动换行
|
||
#self.normalstr= self.normalstr % {
|
||
# 'flag': '%(flag)s',
|
||
# 'colwidth':'3',
|
||
# 'sphinxstyletheadfamily':'%(sphinxstyletheadfamily)s',
|
||
# 'content':'%(content)s'
|
||
#}
|
||
# 得到每一列的列宽供multirow自动换行使用
|
||
newtablehead = self.__ModifyTableHeadForFamilyList(tablehead,
|
||
False,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
tablestyle_dict)
|
||
return content.replace(tablehead,newtablehead,2)
|
||
|
||
return self.__modifyTableHeadForMinusSign(content,False,headtype,tablestyle_dict)
|
||
"""
|
||
#先找出第一行
|
||
searchstr = r'\\hline(?P<content>[\s\S]*?)\\hline'
|
||
m = re.search(searchstr, content, re.M|re.I|re.U )
|
||
headcontent = m.group(1) #匹配到的第一个即为表头内容
|
||
posarr = m.span(1) #保存起始位置和结束位置，便于组成新的内容
|
||
|
||
if 'multicolumn' in headcontent:
|
||
return content
|
||
|
||
if r'\sphinxstyletheadfamily' in headcontent:
|
||
pattern = re.compile(r'(?<=\\sphinxstyletheadfamily)(?P<value>[\s\S]*?)(?=(\\unskip|&)|\\\\)', re.M | re.I|re.U)
|
||
aftercontent = headcontent
|
||
#pattern = re.compile(r'(?<=\\sphinxstylethead{\\sphinxstyletheadfamily)([\s\S]*?)(?=\\unskip}\\relax &)', re.M | re.I|re.U)
|
||
else:
|
||
aftercontent = headcontent.replace(r'\\','&',1)
|
||
pattern = re.compile(r'(?P<value>[\s\S]*?)(&\s{1})', re.M | re.I|re.U)
|
||
#pattern = re.compile(r'[\s\S]*?&|\\unskip', re.M | re.I|re.U)
|
||
|
||
mobjarr = pattern.finditer(aftercontent)
|
||
headlist = []
|
||
preposlist = []
|
||
fontcolor=""
|
||
for mobj in mobjarr:
|
||
amarr = mobj.group('value')
|
||
curposlist = [mobj.start(),mobj.start()+len(amarr)]
|
||
|
||
#用表头内容数组替换
|
||
if self.tablesattrobj.headfontcolor !="":
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
#先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() #再去掉首尾空格，避免多余的空格出现
|
||
if amarr == '':
|
||
continue
|
||
amarr = self.__delNotMustStrFromContent(amarr)
|
||
fontcolor = fontcolor.replace('{}','{'+ amarr+'}',1)
|
||
#当表头没有合并单元格时，不能用cellcolor，否则表头不对齐
|
||
#fontcolor = self.commonstr % {
|
||
# 'sphinxstyletheadfamily':'',
|
||
# 'content': self.__delNotMustStrFromContent(amarr)
|
||
#}
|
||
if len(preposlist) > 0:
|
||
headlist.append(headcontent[preposlist[1]:curposlist[0]])
|
||
else:
|
||
headlist.append(headcontent[0:curposlist[0]])
|
||
headlist.append(fontcolor)
|
||
preposlist = curposlist
|
||
|
||
headlist.append(headcontent[preposlist[1]:len(headcontent)]) #把最后一个字符串加上
|
||
headcontent = ''
|
||
for prelist in headlist:
|
||
headcontent = headcontent + prelist + '\n'
|
||
newcontent = content[0:posarr[0]]+r'\rowcolor'+headtype+'\n'+headcontent+content[posarr[1]:len(content)]
|
||
return newcontent
|
||
"""
|
||
|
||
def __ModifySecondTableHeadForLongTable(self,headcontent):
|
||
#如果表头没有渲染过，对于只渲染第一列的长表格，分页的表格不能有重复的表头内容，需要将其删除
|
||
startpos = headcontent.find(r"\hline")
|
||
newhead = headcontent[0:startpos] + "\\hline\n\\endhead" #因为前面删除了行结束符，最后再添加上
|
||
return newhead
|
||
|
||
def __GetTableRowCount(self,tablecontent):
|
||
'''
|
||
得到传进来的表格行数量
|
||
统计原则：latex以“\\”+回车换行为表格的一行，因此以"\\CRLF"或者“\\LF”作为一行，
|
||
正则表达式统计"\\CRLF"或者“\\LF”的数量作为行的数量。
|
||
:param tablecontent: 表格内容，必须去除了latex表格的前面参数部分，否则得到的第一行也包含其内容
|
||
:return: 返回行的数量和每一行内容的列表，如果找不到的话，返回0和None。
|
||
'''
|
||
#以下正则表达式还可以解析出表格的每一行内容
|
||
#在末尾补充一个换行符，避免如果最后一行以“\\”结尾，漏掉最后一行。
|
||
tablecontent = tablecontent+'\n'
|
||
searchstr = "[\s\S]*?(?<count>\\\\[\r|\r\n|\n|\n\r])[\s\S]*?"
|
||
pattern = re.compile(searchstr,re.I | re.M |re.U)
|
||
linelst = pattern.findall(tablecontent)
|
||
if linelst is not None:
|
||
return len(linelst),linelst
|
||
|
||
return 0,None
|
||
|
||
|
||
def __ModifyVerticalLongTable(self, singletablecontent,tablestyle_dict,columnwidthlst):
|
||
#修改长表格的第一列
|
||
#查找长表格的表头，如果是通过sphinx指令设置的长表格，表头分为三个部分，
|
||
#第一个表头以第一个\hline开始，以\endfirsthead结束
|
||
#第二个表头，以\endfirsthead后续的内容开始，\endhead结束
|
||
#下页继续的说明，以\endhead后续内容开始，以\endlastfoot结束，该部分内容不做处理
|
||
#以\endlastfoot后续内容的第一部分即第一列的内容，需要添加背景色和字体颜色。后续的\hline按正常处理即可
|
||
#先将所有表头内容找出来
|
||
isCusHead = tablestyle_dict['isCusHead']
|
||
headstartpos = singletablecontent.find(r"\hline")
|
||
headendpos = singletablecontent.find(r"\endfirsthead")
|
||
fcontent = singletablecontent[0:headstartpos] #字符串起始内容
|
||
fhead = singletablecontent[headstartpos:headendpos+len(r"\endfirsthead")] #第一个表头内容
|
||
#修改第一个表头内容
|
||
if not isCusHead: #如果表头已经渲染过了，则不再对第一个单元格再渲染一边。
|
||
fhead = self.__ModifyTableByLine(fhead,True,True,tablestyle_dict,columnwidthlst)
|
||
|
||
#获得第2个表头的原始内容
|
||
headstartpos = singletablecontent.find(r"\endhead")
|
||
shead = singletablecontent[headendpos+len(r"\endfirsthead"):headstartpos+len(r"\endhead")] #第2个表头的内容
|
||
#修改第2个表头内容
|
||
if not isCusHead: #如果表头已经渲染过了，则不再对第一个单元格再渲染一遍。
|
||
shead = self.__ModifySecondTableHeadForLongTable(shead)
|
||
#获得第3部分内容
|
||
headendpos = singletablecontent.find(r"\endlastfoot")
|
||
thead = singletablecontent[headstartpos+len(r"\endhead"):headendpos+len(r"\endlastfoot")] #第3部分表头内容
|
||
othercontent = singletablecontent[headendpos+len(r"\endlastfoot"):len(singletablecontent)] #其它表格内容
|
||
|
||
#因为第3部分后续紧跟的内容即为下一行的内容，为了统一处理，在前面固定添加行元素，再修改完成后，再将其删除
|
||
othercontent = "\\hline\n" + othercontent
|
||
#修改表格内容部分
|
||
othercontent = self.__ModifyTableByLine(othercontent,True,True,tablestyle_dict,columnwidthlst)
|
||
#修改完成后，去掉固定添加的内容
|
||
othercontent = othercontent[len("\\hline\n"):len(othercontent)]
|
||
return fcontent + fhead + shead + thead + othercontent
|
||
|
||
def __RenderTableHeadByLine(self, linecontent, lineindex, isLongtable, columnwidthlst, jsonmultirow, tablestyle_dict, contentdict):
|
||
'''
|
||
该函数暂时未用
|
||
用列表的方式逐个拆解每个单元格内容，列表格式为[['cell content','分割符号&或者\\'],[],[]]
|
||
:return:
|
||
'''
|
||
# 内容的起始位置
|
||
searchstr = r"(\\hline|\\cline|\\sphinxcline)"
|
||
match = re.match(searchstr,linecontent)
|
||
if match is None:
|
||
return linecontent
|
||
if match.group() == r"\hline":
|
||
startpos = match.end()
|
||
newtablehead = "\\hline\n"
|
||
else:
|
||
startpos = 0
|
||
newtablehead = ""
|
||
|
||
# 得到每个单元格的内容
|
||
colindex = 0 # 是否第一个单元格的索引
|
||
lineindex = 1 # 行索引，为了支持多行合并，默认起始在第一行
|
||
# multirowindex：第几个multirow单元格的索引号，用于作为conf.json中multirowcolumn字段的索引值，
|
||
# 取出当前multirow单元格真实所在列
|
||
# 得到该列的列宽，填写到multirow指令里面，实现multirow指令中的内容自动换行
|
||
multirowindex = 0
|
||
lineflag = 0
|
||
|
||
while startpos != -1:
|
||
multirowflag = False # 是否是multirow处理，是的话__ModifyCellContentForMergeCell返回true，默认返回false
|
||
lineflag, startpos, cellcontent = self.__FindCellContentForHead(linecontent, startpos)
|
||
if cellcontent is not None:
|
||
factcolcount = self.__GetFactColIndex(cellcontent[0])
|
||
colindex = colindex + factcolcount # 当前列号
|
||
if r"\sphinxtablestrut" in cellcontent[0]:
|
||
# 需要将multirow的内容copy到该单元格
|
||
self.__AdjustMultirowContent(cellcontent, contentdict, lineindex,colindex,columnwidthlst)
|
||
else:
|
||
|
||
multirowflag = self.__ModifyCellContentForMergeCell(cellcontent,
|
||
tablestyle_dict,
|
||
isLongtable,
|
||
contentdict,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
colindex,
|
||
lineindex,
|
||
multirowindex)
|
||
newtablehead = newtablehead + cellcontent[0] + "\n" + cellcontent[1] + "\n"
|
||
|
||
if multirowflag is True:
|
||
multirowindex = multirowindex + 1
|
||
lineindex = lineindex + lineflag # 计算新的行数
|
||
if lineflag:
|
||
# 如果开启了新行，则列索引从0开始计算
|
||
colindex = 0
|
||
|
||
# 组成新的表头内容
|
||
#newtablehead = newtablehead + "\\hline\n"
|
||
return newtablehead
|
||
|
||
def __ModifyLineContent(self,linecontent,isvertical,islongtable,lineindex,columnwidthlst,colno,maxcolno,tablestyle_dict,rowdict):
|
||
'''
|
||
修改行内容，当colno为-1时，则修改整行内容，否则根据colno的值修改单元格
|
||
:param linecontent: 该行的内容，以行结束标志“\\”结束。
|
||
:param columnwidthlst: 保存的每一列的列宽内容，根据tablecolumns参数解析出来
|
||
如果实现自动换行，必须用tablecolumns这个参数，不能用widths参数
|
||
:param colno: 要修改的列号，如果为-1，则修改整行内容。否则根据colno的值修改单元格。
|
||
如果该行有合并列单元格，则colno为合并单元格后的列号。
|
||
:param maxcolno: 将合并单元格拆分后，得到的最大的列号，该列号为了取得列宽，使multirow内容自动换行。
|
||
:param rowdict: 传出参数，如果是multirow的合并单元格，则返回单元格的内容
|
||
:return: 返回修改后的行的内容。
|
||
'''
|
||
if isvertical is False:
|
||
#修改行，暂时不支持修改任意行，表头的渲染由其他函数完成
|
||
#按表头内容渲染
|
||
|
||
jsonmultirow = [] # 保存需要设置自动换行的合并单元格的列号。
|
||
if __dictIsHasKey__(tablestyle_dict, 'multirowcolumn'):
|
||
jsonmultirow = tablestyle_dict['multirowcolumn']
|
||
newlinecontent = self.__RenderTableHeadByLine(linecontent,
|
||
lineindex,
|
||
islongtable,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
tablestyle_dict,
|
||
rowdict)
|
||
return newlinecontent
|
||
|
||
#下面的内容修改列，即只修改行的第一个单元格
|
||
linecontentstr=linecontent
|
||
#startpos = linecontent.find('\\hline')
|
||
#lineprefix = ""
|
||
#if startpos != -1:
|
||
# linecontentstr = linecontent[startpos + len("\\hline"):len(linecontent)]
|
||
# lineprefix = linecontent[0:startpos+len("\\hline")]
|
||
#得到行内容和前缀
|
||
lineprefix = ""
|
||
searchstr=r"\\hline|\\cline{\S+?}|\\sphinxcline{\S+?}\\sphinxfixclines{\d+?}"
|
||
match = re.search(searchstr,linecontent,re.I|re.U|re.M)
|
||
if match is not None:
|
||
linecontentstr = linecontent[match.end():len(linecontent)]
|
||
lineprefix = linecontent[0:match.start()+ len(match.group())]
|
||
|
||
othercontent = ""
|
||
newlinecontent = ""
|
||
|
||
#暂时仅支持修改第一列
|
||
lineflag,nextpos,cellcontent = self.__FindCellContentForHead(linecontentstr,0)
|
||
if (cellcontent is None) or (r"\cellcolor" in cellcontent[0]):
|
||
#说明该单元格已经修改过了，直接返回
|
||
return linecontent
|
||
|
||
othercontent = linecontentstr[nextpos:len(linecontentstr)]
|
||
|
||
if r"\sphinxtablestrut" in cellcontent[0]:
|
||
# 需要将multirow的内容copy到该单元格
|
||
self.__AdjustMultirowContent(cellcontent, rowdict, lineindex,maxcolno,columnwidthlst)
|
||
else:
|
||
jsonmultirow =[1]
|
||
cellstr = cellcontent[0] # 取得单元格内容
|
||
|
||
if r'\sphinxmultirow' in cellstr:
|
||
cellcontent[0] = self.__ModifySphinxMultirow(cellstr,
|
||
rowdict,
|
||
columnwidthlst,
|
||
jsonmultirow,
|
||
lineindex,
|
||
maxcolno,
|
||
0,
|
||
tablestyle_dict,
|
||
isvertical)
|
||
else:
|
||
coluwidth = "*"
|
||
if len(columnwidthlst) > 0:
|
||
coluwidth = columnwidthlst[0]
|
||
# 查找\sphinxAtStartPar位置
|
||
pos = cellstr.find(r'\sphinxstyletheadfamily')
|
||
if pos != -1:
|
||
contentstr = cellstr[pos + len(r'\sphinxstyletheadfamily'):len(cellstr)]
|
||
|
||
fullcontentstr = self.commonstr % {
|
||
'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
'content': self.__delNotMustStrFromContent(contentstr)
|
||
}
|
||
#fullcontentstr = self.multirowstr % {
|
||
# 'count': 1,
|
||
# 'coluwidth': coluwidth,
|
||
# 'sphinxstyletheadfamily': r"\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(contentstr)
|
||
#}
|
||
#fullcontentstr = self.normalstr % {
|
||
# 'flag': '|l|',
|
||
# 'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(contentstr)
|
||
#}
|
||
|
||
cellcontent[0] = fullcontentstr
|
||
else:
|
||
fullcontentstr = self.commonstr % {
|
||
'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
'content': self.__delNotMustStrFromContent(cellstr)
|
||
}
|
||
#fullcontentstr = self.multirowstr % {
|
||
# 'count': 1,
|
||
# 'coluwidth': coluwidth,
|
||
# 'sphinxstyletheadfamily': r"\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(cellstr)
|
||
#}
|
||
#fullcontentstr = self.normalstr % {
|
||
# 'flag': '|l|',
|
||
# 'sphinxstyletheadfamily': "\\sphinxstyletheadfamily",
|
||
# 'content': self.__delNotMustStrFromContent(cellstr)
|
||
#}
|
||
|
||
cellcontent[0] = fullcontentstr
|
||
|
||
newlinecontent = lineprefix +"\n" + cellcontent[0] + "\n" + cellcontent[1] + "\n" + othercontent
|
||
return newlinecontent
|
||
|
||
|
||
def __ModifyTableByLine(self,tablecontent,isvertical,islongtable,tablestyle_dict,columnwidthlst):
|
||
'''
|
||
按行渲染每一个单元格。根据正则表达式解析出每一行的内容，
|
||
然后再解析这一行中每一个单元格的内容，根据条件判断是否需要渲染该单元格
|
||
:param tablecontent:
|
||
表格内容，对于长表格去除表格头的表格，对于普通表格，整个表格内容
|
||
:param isvertical:
|
||
是否修改列还是修改行
|
||
:return: 返回修改后的内容
|
||
'''
|
||
#找出每一行的内容
|
||
|
||
searchstr = r'(\\hline|\\cline{\S+}|\\sphinxcline{\S+})(?P<content>[\s\S]*?)(?=\\hline|\\cline{\S+}|\\sphinxcline{\S+})'
|
||
pattern = re.compile(searchstr,re.M | re.I|re.U)
|
||
# 得到每一行的内容，以\hline或者\cline开头，以\\结尾
|
||
linelst = pattern.findall(tablecontent)
|
||
if len(linelst) ==0:
|
||
return tablecontent
|
||
|
||
tableprefix = "" #得到latex表格的前缀参数部分，除表格内容外的部分
|
||
tablepostfix = "" #得到latex表格的后缀参数部分，出表格内容外的部分
|
||
prepos = tablecontent.find(''.join(linelst[0]))
|
||
if prepos > 0:
|
||
tableprefix = tablecontent[0:prepos]
|
||
lastline = ''.join(linelst[-1])
|
||
postpos = tablecontent.find(lastline)
|
||
if (postpos+len(lastline)) < len(tablecontent):
|
||
tablepostfix = tablecontent[postpos+len(lastline):len(tablecontent)]
|
||
|
||
newtablecontent = ""
|
||
rowdict = {} #保存合并单元格的字典，用于multirow
|
||
for lineindex in range(0,len(linelst)):
|
||
line =''.join(linelst[lineindex])
|
||
newline= self.__ModifyLineContent(line,isvertical,islongtable,lineindex+1,columnwidthlst,1,1,tablestyle_dict,rowdict)
|
||
newtablecontent = newtablecontent + newline
|
||
|
||
newtablecontent = tableprefix + newtablecontent+tablepostfix
|
||
return newtablecontent
|
||
|
||
#渲染树型表格的第一列
|
||
def __ModifyVerticalTable(self, singletablecontent, tablestyle_dict, columnwidthlst):
|
||
|
||
#找出每一行的内容
|
||
searchstr = r'(\\hline|\\cline{\S+}|\\sphinxcline{\S+})(?P<content>[\s\S]*?)(?=\\hline|\\cline{\S+}|\\sphinxcline{\S+})'
|
||
pattern = re.compile(searchstr,re.M | re.I|re.U)
|
||
matchiter = pattern.finditer(singletablecontent)
|
||
posarr=[] #保存位置，便于组合
|
||
i = 0
|
||
for m in matchiter:
|
||
|
||
posarr.append([])
|
||
posarr[i] = m.span()
|
||
|
||
if i ==0:
|
||
newcontent = singletablecontent[0:posarr[i][0]]+m.group(1)
|
||
else:
|
||
newcontent = newcontent+singletablecontent[posarr[i-1][1]:posarr[i][0]]+m.group(1)
|
||
|
||
cellcontent = m.group('content')
|
||
#匹配到的第一个即为表头内容
|
||
#将第一个单元格内容渲染成蓝底白字
|
||
firstcellcontent = self.__ModifyFirstColumnType(cellcontent)
|
||
newcontent += firstcellcontent
|
||
i+=1
|
||
newcontent += singletablecontent[posarr[i-1][1]:len(singletablecontent)]
|
||
return newcontent
|
||
|
||
#渲染第一个单元格内容
|
||
def __ModifyFirstColumnType(self,cellcontent):
|
||
|
||
new_cellcontent = ""
|
||
|
||
if r'\sphinxstyletheadfamily' in cellcontent:
|
||
|
||
searchstr = r'(?<=\\sphinxstyletheadfamily)(?P<value>[\s\S]*?)(?=(\\unskip|&)|\\\\)'
|
||
|
||
aftercontent = cellcontent.strip()
|
||
aftercontent = aftercontent.strip('\r')
|
||
aftercontent = aftercontent.strip('\n')
|
||
aftercontent = aftercontent.strip()
|
||
mobj = re.search(searchstr, aftercontent, re.M|re.I|re.U ) #匹配到的第一个既是需要修改的内容
|
||
|
||
#修改字体颜色
|
||
amarr = mobj.group('value')
|
||
posarr = mobj.span()
|
||
new_cellcontent = aftercontent[0:posarr[0]]+'\n'+r'\cellcolor'+self.tablesattrobj.headtype
|
||
#用表头内容数组替换
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
#先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
amarr = amarr.strip()
|
||
amarr = amarr.strip('\r')
|
||
amarr = amarr.strip('\n')
|
||
amarr = amarr.strip() #再去掉首尾空格，避免多余的空格出现
|
||
#if amarr == '':
|
||
# continue
|
||
if (r'\textbf' or r'\textcolor') in amarr:
|
||
return cellcontent
|
||
fontcolor = fontcolor.replace('{}','{'+ amarr+'}',1)
|
||
new_cellcontent +=r'{'+fontcolor + '}\n' + aftercontent[posarr[1]:len(aftercontent)]
|
||
else:
|
||
aftercontent = cellcontent.replace(r'\\','&',1)
|
||
#去掉首尾空格和换行符
|
||
aftercontent = aftercontent.strip()
|
||
aftercontent = aftercontent.strip('\r')
|
||
aftercontent = aftercontent.strip('\n')
|
||
aftercontent = aftercontent.strip()
|
||
|
||
tmplist = re.split(r'&',aftercontent)
|
||
|
||
preposlist = 0
|
||
#只对第一个做修改
|
||
onelist = tmplist[0]
|
||
#先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
onelist = onelist.strip()
|
||
onelist = onelist.strip('\r')
|
||
onelist = onelist.strip('\n')
|
||
onelist = onelist.strip() #再去掉首尾空格，避免多余的空格出现
|
||
#if onelist == '':
|
||
# continue
|
||
if (r'\textbf' or r'\textcolor') in onelist:
|
||
return cellcontent
|
||
new_cellcontent = self.__ModifyFirstColumnContentPart(onelist)
|
||
|
||
for i in range(1,len(tmplist)):
|
||
if len(tmplist[i])>0:
|
||
new_cellcontent += '&' +tmplist[i]
|
||
new_cellcontent+=r'\\' #将最后被替换掉的\\再加上
|
||
|
||
return new_cellcontent + '\n'
|
||
|
||
def __ModifyFirstColumnContentPart(self,firstcontent):
|
||
#查找firtcontent的内容部分，因为如果存在合并单元格，第一列的内容起始部分不一定是内容，可能是latex的其它标签。
|
||
#sphinx生成的latex表格都以“\sphinxAtStartPar”标识开始
|
||
startpos = firstcontent.find(r"\sphinxAtStartPar")
|
||
firstpart = ""
|
||
if startpos==-1:
|
||
contentpart = firstcontent
|
||
else:
|
||
firstpart = firstcontent[0:startpos]
|
||
contentpart=firstcontent[startpos:len(firstcontent)]
|
||
fontcolor = self.tablesattrobj.headfontcolor
|
||
# 先去掉首尾空格，避免首尾有空格无法去掉回车换行符
|
||
new_cellcontent = '\n'+r'\cellcolor'+self.tablesattrobj.headtype+r'{'+fontcolor.replace('{}','{'+ contentpart+'}',1)+r'}'+'\n'
|
||
return firstpart+new_cellcontent
|
||
|
||
def __ModifyReplaceContent(self):
|
||
'''
|
||
修改replace内容。为了删除sphinx在替换时多加的空格，在替换时，每个替换内容前后都加了"@@"。
|
||
对于前后都加了“@@”的内容，删除前后的"@@"，同时删除前后的空格。
|
||
:return:
|
||
'''
|
||
searchstr = r"@@(?P<content>[\s\S]+?)@@"
|
||
pattern = re.compile(searchstr)
|
||
match = pattern.search(self.content)
|
||
if match is None:
|
||
return None
|
||
str = match.group()
|
||
replace = match.group('content')
|
||
|
||
prepos = match.start()
|
||
endpos = match.end()
|
||
replaceed = str
|
||
if prepos > 1:
|
||
#判断前一个字符是否为空格
|
||
prechar = self.content[prepos-1]
|
||
if prechar==" ":
|
||
replaceed = " "+replaceed
|
||
|
||
endchar = self.content[endpos]
|
||
if endchar == " ":
|
||
replaceed = replaceed + " "
|
||
|
||
#进行替换
|
||
self.content = self.content.replace(replaceed,replace)
|
||
|
||
return self.content
|
||
|
||
|
||
def ModifyReplaceContent(self):
|
||
|
||
while True:
|
||
'''
|
||
可能会有多个需要替换，直到找不到为止
|
||
'''
|
||
result = self.__ModifyReplaceContent()
|
||
if result is None:
|
||
break
|
||
|
||
class clsSensitiveWords:
|
||
|
||
def __init__(self,entext):
|
||
self.passkey="Hello123"
|
||
self.entext = entext
|
||
self.jsonwords = GetSensitiveword()
|
||
|
||
def GetFullSensitiveWords(self):
|
||
senwords = "|".join(self.jsonwords)
|
||
detext = ""
|
||
if self.entext !="":
|
||
command="echo '" + self.entext +"'| openssl aes-128-cbc -d -base64 -pbkdf2 -k " + self.passkey
|
||
process = Popen(command, stdout=PIPE, stderr=STDOUT, shell=True)
|
||
with process.stdout:
|
||
for line in iter(process.stdout.readline, b''):
|
||
detext = detext + line.decode().strip()
|
||
senwords = senwords + '|' + detext
|
||
|
||
return senwords
|
||
|
||
class clsCheckDocCopyrightYear:
|
||
'''
|
||
检查文档是否符合规范。
|
||
2022年07月12日更新
|
||
-------------------
|
||
增加对当前年份的检查，如果年份不符合要求，自动修改conf.py和copyright.rst文档中的年份。
|
||
'''
|
||
def __init__(self,app,copyrightfile):
|
||
self.app=app
|
||
self.confdir = app.confdir
|
||
self.language = app.config.language
|
||
self.confright = app.config.copyright
|
||
if (app.config.latex_elements is not None) and __dictIsHasKey__(app.config.latex_elements,'preamble'):
|
||
self.latex_preamble = app.config.latex_elements['preamble']
|
||
else:
|
||
self.latex_preamble = ""
|
||
|
||
if len(copyrightfile) > 0:
|
||
self.copyrightfile = copyrightfile
|
||
elif hasattr(app.config,"copyfile_path") and len(app.config.copyfile_path)>0:
|
||
self.copyrightfile = app.config.copyfile_path
|
||
else:
|
||
self.copyrightfile = ""
|
||
|
||
def __FindCopyrightFile(self):
|
||
'''
|
||
#如果copyrightfile为空，则查找copyrightfile文件
|
||
'''
|
||
if self.copyrightfile =="":
|
||
|
||
copyrightpre = "copyright/copyright"
|
||
filepath = os.path.join(self.app.srcdir,copyrightpre + ".rst")
|
||
|
||
if os.path.isfile(filepath):
|
||
return filepath
|
||
|
||
if self.language=="zh_CN":
|
||
filepath = os.path.join(self.app.srcdir,copyrightpre + "_zh.rst")
|
||
else:
|
||
filepath = os.path.join(self.app.srcdir,copyrightpre +"_en.rst")
|
||
|
||
if os.path.isfile(filepath):
|
||
return filepath
|
||
else:
|
||
return ""
|
||
else:
|
||
filepath = os.path.join(self.confdir , self.copyrightfile)
|
||
|
||
#转为绝对路径
|
||
filepath = os.path.abspath(filepath)
|
||
if os.path.isfile(filepath):
|
||
return filepath
|
||
else:
|
||
return ""
|
||
|
||
def __IsModifyfootYear(self,year):
|
||
'''
|
||
查找lfoot设置版权的语句年份是否需要修改
|
||
:return: True - 需要修改年份
|
||
False - 不需要修改年份
|
||
'''
|
||
|
||
ismodify = False
|
||
searchstr = r'\\lfoot{[ ]*Copyright [\s\S]*?}'
|
||
pattern = re.compile(searchstr,re.I|re.U)
|
||
matchiter = pattern.finditer(self.latex_preamble)
|
||
if matchiter is None:
|
||
return ismodify
|
||
|
||
for m in matchiter:
|
||
lfoot = m.group()
|
||
if year in lfoot:
|
||
#如果当前年份已在脚注中，则认为年份已修改，则不再修改。
|
||
break
|
||
else:
|
||
# 如果当前年份不在脚注中，则认为年份还未修改，需要修改。
|
||
ismodify = True
|
||
break
|
||
return ismodify
|
||
|
||
def __ModifyYearofConfforDetail(self,year,ispremble=False):
|
||
'''
|
||
修改conf.py中的年份
|
||
:param ispremble: 是否只修改ispremble中脚注的年份。
|
||
True-只修改脚注的年份；False-同时修改copyright和脚注的年份。
|
||
'''
|
||
#打开文件
|
||
conffile = self.confdir +"/conf.py"
|
||
fo = codecs.open(conffile, "r+", encoding='utf-8')
|
||
textcontent = fo.read()
|
||
fo.close()
|
||
|
||
if ispremble is False:
|
||
#修改copyright的年份
|
||
searchstr = r"[0-9]{4}"
|
||
matchobj = re.search(searchstr,self.confright)
|
||
if matchobj is not None:
|
||
copyright = re.sub(searchstr,year,self.confright)
|
||
textcontent=textcontent.replace(self.confright,copyright,1)
|
||
#为了看到最终效果，同时修改已经读取的变量，因为调用该函数前，conf.py的配置已经被sphinx读取
|
||
self.app.config.copyright=copyright
|
||
|
||
#开始替换脚注中的年份
|
||
#得到脚注中带有年份的声明
|
||
searchstr = r'\\lfoot{[ ]*Copyright [\s\S]*?}'
|
||
pattern = re.compile(searchstr, re.I | re.U)
|
||
matchiter = pattern.finditer(self.latex_preamble)
|
||
if matchiter is not None:
|
||
for m in matchiter:
|
||
lfoot = m.group()
|
||
searchstr= r"[0-9]{4}"
|
||
matchobj = re.search(searchstr,lfoot)
|
||
if matchobj is not None:
|
||
newlfoot = re.sub(searchstr,year,lfoot)
|
||
textcontent=textcontent.replace(lfoot,newlfoot)
|
||
#两个脚注相同，因此只替换一次即可
|
||
# 为了看到最终效果，同时修改已经读取的变量，因为调用该函数前，conf.py的配置已经被sphinx读取
|
||
self.app.config.latex_elements['preamble'] = self.latex_preamble.replace(lfoot,newlfoot)
|
||
break
|
||
#将替换后的内容重新写入文件
|
||
fw = codecs.open(conffile, "w+", encoding='utf-8')
|
||
fw.write(textcontent)
|
||
fw.close()
|
||
|
||
def __ModifyYearofCopyright(self,year):
|
||
|
||
#得到copyright绝对文件名
|
||
filepath = self.__FindCopyrightFile()
|
||
if filepath == "":
|
||
return
|
||
|
||
fo = codecs.open(filepath, "r+", encoding='utf-8')
|
||
textcontent = fo.read()
|
||
fo.close()
|
||
#新的版权年份
|
||
newyear = '© ' + year
|
||
#if newyear in textcontent:
|
||
# return
|
||
isupdate = False
|
||
#避免替换错误，循环找到最后一个进行替换
|
||
searchstr = "©( )*([0-9]{4})"
|
||
pattern = re.compile(searchstr, re.I | re.U)
|
||
matchiter = pattern.finditer(textcontent)
|
||
for m in matchiter:
|
||
oldyear = m.group()
|
||
if oldyear == newyear:
|
||
continue
|
||
textcontent = textcontent.replace(oldyear,newyear,1)
|
||
isupdate = True
|
||
|
||
if isupdate:
|
||
fw = codecs.open(filepath, "w+", encoding='utf-8')
|
||
fw.write(textcontent)
|
||
fw.close()
|
||
#pattern = re.compile(searchstr, re.I | re.U)
|
||
#matchlst = pattern.findall(textcontent)
|
||
#if len(matchlst)==0:
|
||
# #如果没有找到四数字的年份，直接返回
|
||
# return
|
||
|
||
#i=0
|
||
#content=""
|
||
#matchiter = pattern.finditer(textcontent)
|
||
#for m in matchiter:
|
||
# if (i+1)==len(matchlst):
|
||
# #对最后一个年份进行替换
|
||
# content = textcontent[0:m.start()] + year + textcontent[m.end():len(textcontent)]
|
||
# break
|
||
# else:
|
||
# i = i+1
|
||
|
||
#fw = codecs.open(filepath, "w+", encoding='utf-8')
|
||
#fw.write(content)
|
||
#fw.close
|
||
|
||
def __ModifyYearofConf(self,year):
|
||
#开始修改conf.py中的年份
|
||
if (year not in self.confright) and (self.confright != ""):
|
||
#修改conf.py中的年份
|
||
self.__ModifyYearofConfforDetail(year)
|
||
return
|
||
#开始修改conf.py中脚注的年份
|
||
if (self.latex_preamble!="") and (self.__IsModifyfootYear(year) is True):
|
||
#需要修改年份，走到这一步conf.py的copyright年份肯定修改过的，因此只修改foot中的年份即可
|
||
self.__ModifyYearofConfforDetail(year,True)
|
||
return
|
||
|
||
def CheckYearIsRight(self):
|
||
'''
|
||
检查年份是否正确
|
||
'''
|
||
#得到系统当前年份
|
||
today = dt.date.today()
|
||
year = today.strftime('%Y')
|
||
#开始检查conf.py中的年份
|
||
self.__ModifyYearofConf(year)
|
||
#开始检查copyright文件中的年份
|
||
self.__ModifyYearofCopyright(year)
|
||
|
||
def __AddAdSymbolForReplaceZh(self,content):
|
||
'''
|
||
解析是否需要替换，需要的话就进行替换。
|
||
替换的条件：1.被替换字符串全部为中文，2。被替换字符的首尾有一个不为英文
|
||
:param content: 要替换的内容
|
||
:return: 已替换或者未替换的字符串
|
||
'''
|
||
#用正则表达式解析出要替换的内容
|
||
searchstr = r"[\s\S]+ replace:: (?P<replace>[\s\S]+)"
|
||
match = re.search(searchstr,content)
|
||
if match is None:
|
||
return content
|
||
replacestr = match.group('replace').strip('\r')
|
||
#取得字符串的首和尾字符
|
||
#prochr = ord(replacestr[0])
|
||
#print(prochr)
|
||
#epichr = ord(replacestr[-1])
|
||
#print(epichr)
|
||
#if ((64 < prochr and prochr<91) or \
|
||
# (96 < prochr and prochr<123)) and \
|
||
# ((64 < epichr and epichr < 91) or \
|
||
# (96 < epichr and epichr < 123)):
|
||
# #首尾都为英文则无需替换空格，直接返回
|
||
# return content
|
||
newreplacestr = "@@"+replacestr+"@@"
|
||
return content.replace(replacestr,newreplacestr)
|
||
|
||
def __ParseReplaceList(self,contentlst):
|
||
'''
|
||
为中文替换词前后添加@@符号
|
||
:param contentlst: 需要替换的list内容
|
||
:return: 新生成列表，如果无需替换，返回None。
|
||
'''
|
||
if contentlst is None or len(contentlst)==0:
|
||
return None
|
||
|
||
for i in range(0,len(contentlst)):
|
||
content = contentlst[i]
|
||
if content=="":
|
||
continue
|
||
#进行替换
|
||
newcontent = self.__AddAdSymbolForReplaceZh(content)
|
||
contentlst[i] = newcontent
|
||
|
||
return contentlst
|
||
|
||
def CheckReplaceContent(self):
|
||
'''
|
||
该函数用来判断conf.py文件中是否包含rst_epilog或者rst_prolog的配置
|
||
如果有的话，修改这两个参数中的配置在需替换的名词前后都加@@符号，以方便在latex文件中删除前后的空格。
|
||
该修改为了解决sphinx对中文的替换前后都加空格的bug。
|
||
:return:
|
||
'''
|
||
epilogstr = self.app.config.rst_epilog
|
||
prologstr = self.app.config.rst_prolog
|
||
|
||
if self.app.config.language != "zh_CN":
|
||
'''
|
||
如果不是中文文档，则直接返回。
|
||
'''
|
||
return
|
||
|
||
if prologstr is not None:
|
||
# 为rst_prolog的中文替换前后添加@@符号
|
||
prologlst = prologstr.split('\n')
|
||
newlst = self.__ParseReplaceList(prologlst)
|
||
if newlst is not None:
|
||
self.app.config.rst_prolog = '\n'.join(newlst)
|
||
|
||
if epilogstr is not None:
|
||
#为rst_epilog的中文替换前后添加@@符号
|
||
epiloglst = epilogstr.split('\n')
|
||
newlst = self.__ParseReplaceList(epiloglst)
|
||
if newlst is not None:
|
||
self.app.config.rst_epilog = '\n'.join(newlst)
|
||
|
||
|
||
|
||
class clsCheckHtmlRule:
|
||
'''
|
||
检查html配置是否符合规范
|
||
'''
|
||
def __init__(self,app):
|
||
self.app=app
|
||
#错误描述模板
|
||
#配置参数错误
|
||
self.configparam_error="Parameter %(param)s configuration error!"
|
||
self.correctvalue="The correct value is %(value)s!"
|
||
self.config_error=self.configparam_error + self.correctvalue+"\n"
|
||
#工程名称配置不一致
|
||
self.inconsistent_error="The project names configured by conf.py and %(rootdoc)s.rst are inconsistent!\n"
|
||
#缺少custom.css文件
|
||
self.csslack_error="custom.css file not found!\n"
|
||
self.config_detail = "For detailed configuration, see wiki: pageId=46137795\n"
|
||
|
||
def __CheckCommonParamForHtml(self, theme):
|
||
'''
|
||
检查相关配置是否正确
|
||
:param theme:为主题文件，如果和配置的不一致返回错误。默认为sphinx_rtd_theme。
|
||
'''
|
||
error = ""
|
||
if self.app.config.html_theme != theme:
|
||
error = self.config_error % {
|
||
'param': 'html_theme',
|
||
'value': theme
|
||
}
|
||
if self.app.config.html_copy_source is True:
|
||
error = error + self.config_error % {
|
||
'param': 'html_copy_source',
|
||
'value': 'False'
|
||
}
|
||
# 判断配置的css文件是否存在
|
||
if len(self.app.config.html_css_files) == 0:
|
||
error = error + self.configparam_error % {
|
||
'param': 'html_css_files',
|
||
} + \
|
||
"Please configure a css file, such as custom.css."
|
||
"The css file needs to be found under the path specified by html_static_path!"
|
||
if len(self.app.config.html_static_path) == 0:
|
||
error = error + self.configparam_error % {
|
||
'param': 'html_static_path',
|
||
} + \
|
||
"Please configure the path of the file specified by html_css_files."
|
||
return error
|
||
|
||
def CheckProjectNameConsistent(self):
|
||
'''
|
||
检查conf.py中project配置工程名称和主索引文件index.rst中的标题是否一致
|
||
两者不一致返回错误。
|
||
该接口必须在builder-inited事件之后调用，否则得不到index.rst的标题，无法比较。
|
||
'''
|
||
#为了兼容性获取config对象的属性，没有的属性不做比较
|
||
cfgattrlst=dir(self.app.config)
|
||
#主索引文件名
|
||
if "master_doc" in cfgattrlst:
|
||
indexname = self.app.config.master_doc
|
||
elif "root_doc" in cfgattrlst:
|
||
indexname = self.app.config.root_doc
|
||
else:
|
||
return ""
|
||
|
||
#得到主索引文件的标题
|
||
indextitle = self.app.env.titles[indexname][0]
|
||
#得到配置的工程名称
|
||
projectname = self.app.config.project
|
||
if indextitle != projectname:
|
||
error = self.inconsistent_error % {
|
||
'rootdoc': indexname
|
||
}
|
||
return error
|
||
else:
|
||
return ""
|
||
|
||
def CheckCommConfigHtmlRule(self, theme):
|
||
'''
|
||
检查生成html前参数配置是否符合规范
|
||
'''
|
||
# 开始检查参数配置
|
||
error = self.__CheckCommonParamForHtml(theme)
|
||
return error
|
||
|
||
def CheckProjectNameIsConsistent(app):
|
||
'''
|
||
检查conf.py中配置的工程名称与主索引文件的标题是否一致
|
||
'''
|
||
checkDocobj = clsCheckHtmlRule(app)
|
||
return checkDocobj.CheckProjectNameConsistent()
|
||
|
||
def CheckHtmlConfigIsCorrect(app,theme='sphinx_rtd_theme'):
|
||
'''
|
||
检查html配置参数是否正确
|
||
'''
|
||
checkDocobj = clsCheckHtmlRule(app)
|
||
return checkDocobj.CheckCommConfigHtmlRule(theme)
|
||
|
||
def CheckCurrentYearAndModify(app,copyrightfile=""):
|
||
'''
|
||
检查conf.py和copyright中的年份是否为当前年份，如果不是当前年份则进行修改。
|
||
Conf.py主要检查latex_elements和copyright中的年份是否为当前年份
|
||
copyright主要检查copyright.rst文件最后一句的年份是否为当前系统年份。
|
||
:param app:
|
||
:param copyrightfile: 相对于conf.py的相对路径。
|
||
'''
|
||
checkDocobj = clsCheckDocCopyrightYear(app,copyrightfile)
|
||
#检查年份是否需要修改
|
||
checkDocobj.CheckYearIsRight()
|
||
#if (app.builder is not None) and \
|
||
# (app.builder.name=='latex' or app.builder.name=='latexpdf'):
|
||
# checkDocobj.CheckReplaceContent()
|
||
|
||
def __returnCfgDate(app):
|
||
'''
|
||
返回conf.py中配置的today的日期。如果today为空，则返回当前日期。
|
||
'''
|
||
if app.config.today != "":
|
||
return app.config.today
|
||
today = dt.date.today()
|
||
if app.config.language =="zh_CN":
|
||
return today.strftime('%Y年%m月%d日')
|
||
else:
|
||
return today.strftime('%b %d, %Y')
|
||
|
||
def CheckUpdateHistory(app,docname,source):
|
||
'''
|
||
检查是否需要添加更新历史，在source_read_handler这个事件里调用。
|
||
为了提高效率，不写在类里，减少创建和销毁对象的消耗。
|
||
:param app:
|
||
:param docname:
|
||
:param source: 源文件内容
|
||
'''
|
||
#判断文档中是否包含更新历史
|
||
# 默认为英文
|
||
title = "Update History"
|
||
update="Date:"
|
||
changes="Changes:"
|
||
language = app.config.language
|
||
if language == "zh_CN":
|
||
title = "更新历史"
|
||
update="更新时间："
|
||
changes="更新内容："
|
||
index = source.find(title)
|
||
if index==-1:
|
||
return source
|
||
|
||
#说明该文档中包含更新历史，判断是否为更新历史标题
|
||
precontent = source[0:index]
|
||
leftcontent = source[index:len(source)]
|
||
#按行读取剩余内容，理论上第2行为标题的下标，如果不是，则认为这个更新历史不是标题，直接忽略。
|
||
linelst = leftcontent.splitlines(True)
|
||
flagline = linelst[1]
|
||
search = r"([\x21-\x2f|\x3a-\x40|\x5b-\x60|\x7b-\x7d])\1+(?=[\r|\n|\r\n])"
|
||
matchobj=re.match(search,flagline)
|
||
if matchobj is None:
|
||
return source
|
||
#说明是更新历史章节，再比较版本号是否一致
|
||
search = r"\* \*\*V(?P<version>[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{1,2})\*\*"
|
||
matchobj=re.search(search,leftcontent)
|
||
if matchobj is None:
|
||
return source
|
||
version=matchobj.group('version')
|
||
if version==app.config.version:
|
||
return source
|
||
#如果版本不一致，自动添加新的版本内容
|
||
dateformat = __returnCfgDate(app)
|
||
updatehistory="\n* **V%(version)s**\n\n" \
|
||
" **%(date)s** %(dateformat)s\n\n" \
|
||
" **%(changes)s**\n\n" \
|
||
" - 无内容更新。\n"
|
||
|
||
upcontent= updatehistory % {
|
||
'version':app.config.version,
|
||
'date':update,
|
||
'dateformat':dateformat,
|
||
'changes':changes
|
||
}
|
||
#拆分列表
|
||
titlestr =''.join(linelst[0:2])
|
||
otherstr =''.join(linelst[2:len(linelst)+1])
|
||
newcontent = precontent + titlestr + upcontent + otherstr
|
||
#将新内容写入文档
|
||
filepath = app.project.doc2path(docname)
|
||
fw = codecs.open(filepath, "w+", encoding='utf-8')
|
||
fw.write(newcontent)
|
||
fw.close()
|
||
return newcontent
|
||
|
||
|
||
def __exe_command_forprint(command):
|
||
"""
|
||
执行 shell 命令并实时打印输出
|
||
:param command: shell 命令
|
||
:return: process, exitcode
|
||
"""
|
||
process = Popen(command, stdout=PIPE, stderr=STDOUT, shell=True)
|
||
with process.stdout:
|
||
for line in iter(process.stdout.readline, b''):
|
||
print(line.decode().strip())
|
||
exitcode = process.wait()
|
||
return process, exitcode
|
||
|
||
def CheckSensitiveWordsForLinux(app,docname,entext):
|
||
'''
|
||
该接口对外提供，可在conf.py的source_read_handler处理函数中调用。对sphinx工程中的文件检查敏感词。
|
||
|
||
**注意：**
|
||
|
||
因为检查敏感词使用的linux命令，如果敏感词中包含中文，则在不支持中文的linux系统下不能使用该接口，
|
||
否则无法完成敏感词。
|
||
|
||
:param app: sphinx环境变量，可以获取输出目录、文件后缀等相关信息。
|
||
:param docname: 需检查的文件路径。该路径是基于源目录的相对路径，而且不包含文件扩展名，
|
||
因此在检查时需要补充上扩展名，并转为绝对路径。
|
||
:param entext: 已加密的密文，如果为空，则只对conf.json中保存的敏感词做检查。
|
||
如何加密参考GetFullSensitiveWords的实现，加解密保持一致。
|
||
:return: 无返回值。
|
||
'''
|
||
#windows系统请使用工具组开发的sensitive-filter.exe工具
|
||
try:
|
||
if platform.system().lower() == 'windows':
|
||
return
|
||
|
||
filepath = app.project.doc2path(docname,True)
|
||
|
||
#print("Checking file:["+docname+"]")
|
||
sensitivewordsobj = clsSensitiveWords(entext)
|
||
sensitivewords = sensitivewordsobj.GetFullSensitiveWords()
|
||
#print(sensitivewords)
|
||
cmd = "egrep -rni --color=always '"+ sensitivewords + "' " + filepath
|
||
__exe_command_forprint(cmd)
|
||
except Exception as e:
|
||
print("Sensitive words check failed, the system may not support Chinese. "
|
||
"The detailed error information is as follows:")
|
||
print(e)
|
||
return
|
||
|
||
# 打开Makefile文件查找source和build文件夹
|
||
def OpenMakefile():
|
||
global source_dir
|
||
global build_dir
|
||
source_dir = ''
|
||
build_dir = ''
|
||
try:
|
||
if platform.system().lower() == 'windows':
|
||
with open('make.bat',"r") as f:
|
||
fstr = f.read()
|
||
|
||
#用正则表达式查找source和build文件夹具体路径
|
||
searchstr = r"set *SOURCEDIR *= *(\S+)"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
source_dir = m.group(1) #匹配到的第一个即为source所在目录
|
||
|
||
searchstr = r"set *BUILDDIR *= *(\S+)"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
build_dir = m.group(1) #匹配到的第一个即为build所在目录
|
||
else:
|
||
with open('Makefile',"r") as f:
|
||
fstr = f.read()
|
||
|
||
#用正则表达式查找source和build文件夹具体路径
|
||
searchstr = r"SOURCEDIR *= *(\S+)"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
source_dir = m.group(1) #匹配到的第一个即为源所在目录
|
||
|
||
searchstr = r"BUILDDIR *= *(\S+)"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
build_dir = m.group(1) #匹配到的第一个即为源所在目录
|
||
|
||
except Exception as e:
|
||
print(e)
|
||
return
|
||
|
||
def GetLatex_documents():
|
||
global source_dir
|
||
if source_dir == '':
|
||
return
|
||
#得到配置文件conf.py的路径
|
||
if source_dir == '.':
|
||
confdir = './conf.py'
|
||
else:
|
||
confdir = './' + source_dir +'/conf.py'
|
||
|
||
conffile = os.path.abspath(confdir)
|
||
#打开conf.py文件
|
||
with codecs.open(conffile,"r+",encoding='utf-8') as f:
|
||
fstr = f.read()
|
||
list = []
|
||
versioninfo = GetVersionInfo(fstr)
|
||
fileprefile = GetFilePreInfo(fstr)
|
||
if versioninfo=="" or fileprefile=="":
|
||
#根据正则表达式，找出latex_documents内容
|
||
searchstr = r"latex_documents *= *\[([\s\S]*?)\]"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
latex_documents = m.group(1) #匹配到的第一个即为源所在目录
|
||
#拆分二维数组，兼容多个情况
|
||
list = latex_documents.split(")")
|
||
for i in range(len(list)):
|
||
if IsComment(list[i]):
|
||
list[i]= list[i].split(",")
|
||
list.pop()
|
||
else:
|
||
#创建2维列表
|
||
for i in range(1):
|
||
list.append([])
|
||
for j in range(2):
|
||
list[i].append("")
|
||
list[0][0] = "comment" #为了兼容文件解析内容，进行补位。
|
||
list[0][1] = '"' + fileprefile + versioninfo + '.tex"' #为了兼容解析过程，添加双引号。
|
||
return list
|
||
|
||
#得到版本信息
|
||
def GetVersionInfo(fstr):
|
||
|
||
if releasever != '':
|
||
return releasever
|
||
|
||
versioninfo = ""
|
||
searchstr = r"version *= *(u*)'(.*?)'"
|
||
m = re.search(searchstr, fstr, re.I)
|
||
if m is not None:
|
||
versioninfo = m.group(2) #匹配到的第一个即为源所在目录
|
||
print("version = " + versioninfo)
|
||
return versioninfo
|
||
|
||
#得到文件前缀信息
|
||
def GetFilePreInfo(fstr):
|
||
filepre = ""
|
||
searchstr = r"curfnpre *= *(u*)'(.*?)'"
|
||
m = re.search(searchstr, fstr, re.M|re.I|re.U )
|
||
if m is not None:
|
||
filepre = m.group(2) #匹配到的第一个即为源所在目录
|
||
return filepre
|
||
|
||
#判断是否为注释行
|
||
def IsComment(instr):
|
||
|
||
if instr.strip() is None:
|
||
return False
|
||
|
||
rule = re.compile('^#.*$')
|
||
if rule.match(instr.strip()) is None:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
#根据正则表达式取单引号和双引号中的内容
|
||
def getquomarkcontent(strarr):
|
||
#根据正则表达式，找出双引号和单引号中的内容
|
||
searchstr = r"[\"|'](.*?)[\"|']"
|
||
m = re.search(searchstr, strarr, re.M|re.I|re.U )
|
||
if m is None:
|
||
return None
|
||
return m.group(1).strip() #匹配到的第一个即为源所在目录
|
||
|
||
def GetConfjsondict(app):
|
||
'''
|
||
得到配置文件conf.json的字典
|
||
:param app:
|
||
:return:
|
||
'''
|
||
global __load_dict__
|
||
|
||
|
||
if app is not None:
|
||
#先判断conf.json路径在配置文件中是否配置
|
||
if hasattr(app.config, "confjson_path") and len(app.config.confjson_path) > 0:
|
||
confpath = os.path.abspath(app.confdir + "/" + app.config.confjson_path)
|
||
else:
|
||
confpath = os.path.join(app.confdir ,"conf.json")
|
||
|
||
if os.path.exists(confpath):
|
||
__load_dict__ = __openconfjsonfile__(confpath)
|
||
else:
|
||
__load_dict__ = __openconfjsonfile__()
|
||
else:
|
||
__load_dict__ = __openconfjsonfile__()
|
||
|
||
|
||
def Modifylatex_main(build_dir,latexdocumentslst,app=None,language='zh_CN'):
|
||
|
||
global __load_dict__
|
||
global doc_language
|
||
doc_language=language
|
||
|
||
if len(__load_dict__) == 0:
|
||
GetConfjsondict(app)
|
||
|
||
|
||
doclen = len(latexdocumentslst)
|
||
for i in range(0,doclen):
|
||
#得到latex路径
|
||
latexpath = build_dir
|
||
desbkpaperfile= os.path.join(latexpath,'chapterbkpaper.pdf')
|
||
#copy 背景图到latex路径，背景图必须与该文件在同一个目录下
|
||
if (app is not None) and hasattr(app.config,'chapterbkpaper_image') and (app.config.chapterbkpaper_image!=""):
|
||
#转为绝对路径进行判断，兼容conf.py和parsejson.py不在同一目录的情况
|
||
bkpaperimage = os.path.abspath(os.path.join(app.confdir,app.config.chapterbkpaper_image))
|
||
if os.path.isfile (bkpaperimage):
|
||
shutil.copy(bkpaperimage,desbkpaperfile)
|
||
elif os.path.exists('./chapterbkpaper.pdf'):
|
||
shutil.copy('./chapterbkpaper.pdf', latexpath)
|
||
else:
|
||
#取配置文件所在目录下的chapterbkpaper.pdf,将其copy到latex文件夹
|
||
bkpaperimage = os.path.abspath(os.path.join(app.confdir,"chapterbkpaper.pdf"))
|
||
if os.path.isfile(bkpaperimage):
|
||
shutil.copy(bkpaperimage, latexpath)
|
||
|
||
#得到相对路径
|
||
filename = latexdocumentslst[i][1]
|
||
if filename is None:
|
||
continue
|
||
texfilepath = os.path.join(latexpath,filename)
|
||
#相对路径转绝对路径
|
||
texfile = os.path.abspath(texfilepath)
|
||
if not os.path.exists(texfile):
|
||
continue
|
||
fo = codecs.open(texfile, "r+",encoding = 'utf-8')
|
||
texcontent = fo.read()
|
||
fo.close()
|
||
|
||
#得到修改tex文件的对象
|
||
ModTexobj = clsModifyTex(texcontent)
|
||
ModTexobj.AddPackageToTex()
|
||
ModTexobj.AddOtherTocToTex()
|
||
ModTexobj.AddCustormOptionsToTex()
|
||
ModTexobj.ModifyReplacePackage()
|
||
ModTexobj.ModifyFunctionBackColor()
|
||
ModTexobj.ModifyTablesAttributes()
|
||
#if (app is not None) and \
|
||
# (app.builder.name=='latex' or app.builder.name=='latexpdf'):
|
||
# ModTexobj.ModifyReplaceContent()
|
||
|
||
fw = codecs.open(texfile, "w+",encoding = 'utf-8')
|
||
fw.write(ModTexobj.content)
|
||
fw.close()
|
||
|
||
def parseargv():
|
||
global source_dir
|
||
global latex_dir
|
||
if len(sys.argv) <= 1:
|
||
return
|
||
for i in range(1,len(sys.argv)):
|
||
param = sys.argv[i]
|
||
if param=='-c': #解析conf.py所在目录
|
||
source_dir = sys.argv[i+1] #保存相对路径
|
||
#print("argv source=" + source_dir)
|
||
i = i+2
|
||
elif param=='-l': #保存输出的latex目录
|
||
latex_dir = sys.argv[i+1] #保存相对路径
|
||
i = i+2
|
||
#print("latex_dir = "+latex_dir)
|
||
|
||
source_dir = '' #保存源文件所在目录
|
||
build_dir = '' #保存生成文件所在目录
|
||
releasever = ''
|
||
latex_dir = ''
|
||
doc_language =''
|
||
__load_dict__ = {}
|
||
|
||
if __name__ == '__main__':
|
||
|
||
parseargv() #解析系统参数
|
||
OpenMakefile()
|
||
|
||
latex_documents = GetLatex_documents() #保存latex文档所在数组
|
||
__load_dict__ = __openconfjsonfile__()
|
||
|
||
latexdir=""
|
||
if latex_dir == '':
|
||
latexdir = '/latex/'
|
||
else:
|
||
latexdir = '/' + latex_dir + '/'
|
||
|
||
doclen = len(latex_documents)
|
||
for i in range(0,doclen):
|
||
#得到latex路径
|
||
latexpath = './' + build_dir + latexdir
|
||
#copy 背景图到latex路径，背景图必须与该文件在同一个目录下
|
||
if os.path.exists('./chapterbkpaper.pdf'):
|
||
shutil.copy('./chapterbkpaper.pdf',latexpath)
|
||
#得到相对路径
|
||
if getquomarkcontent(latex_documents[i][1]) is None:
|
||
continue
|
||
texfilepath = latexpath + getquomarkcontent(latex_documents[i][1])
|
||
#相对路径转绝对路径
|
||
texfile = os.path.abspath(texfilepath)
|
||
if not os.path.exists(texfile):
|
||
continue
|
||
fo = codecs.open(texfile, "r+",encoding = 'utf-8')
|
||
texcontent = fo.read()
|
||
fo.close()
|
||
|
||
#得到修改tex文件的对象
|
||
ModTexobj = clsModifyTex(texcontent)
|
||
ModTexobj.AddPackageToTex()
|
||
ModTexobj.AddOtherTocToTex()
|
||
ModTexobj.AddCustormOptionsToTex()
|
||
ModTexobj.ModifyFunctionBackColor()
|
||
ModTexobj.ModifyTablesAttributes()
|
||
ModTexobj.ModifyReplacePackage()
|
||
|
||
fw = codecs.open(texfile, "w+",encoding = 'utf-8')
|
||
fw.write(ModTexobj.content)
|
||
fw.close()
|