OpenAl之Translator
1、使用pdfplumber解析PDF文件
1.1 pdfplumber简介
- pdfplumber项目(基于pdfminer.six开发)，支持解析PDF文件，获取每个文本字符、矩形和线条的详细信息。此外还支持表格提取和可视化调试。
- 对于机器生成的PDF而言效果最佳，不适用于扫描得到的PDF。
- 支持：Python 3.8~3.11
1.2 加载PDF文件
要开始处理PDF，请调用
pdfplumber.open(x)方法，其中x可以是：- PDF 文件路径
- 作为字节加载的文件对象
- 作为字节加载的类似文件的对象
open方法将返回一个
pdfplumber.PDF类的实例。高级加载参数
- 要加载受密码保护的PDF，请传递
password关键字参数，例如：pdfplumber.open("file.pdf", password="test")。 - 要设置布局分析参数到
pdfminer.six的布局引擎中，请传递laparams关键字参数，例如：pdfplumber.open("file.pdf", laparams={"line_overlap": 0.7})。
- 要加载受密码保护的PDF，请传递
1 | !pip install pdfplumber |
pdfplumber.PDF 类(Top-level)
pdfplumber.PDF类表示一个独立的PDF文件，两个主要成员变量：属性 描述 .metadata一个由PDF的 Info尾部信息中的元数据键/值对组成的字典。通常包括 “CreationDate,” “ModDate,” “Producer,” 等等。.pages包含每个已加载页面的 pdfplumber.Page实例的列表。一个主要成员方法：
方法 描述 .close()默认情况下， Page对象会缓存其布局和对象信息，以避免重新处理。然而，在解析大型PDF时，这些缓存的属性可能需要大量内存。你可以使用此方法来清除缓存并释放内存。（在<= 0.5.25版本中，使用.flush_cache()。）
1 | import pdfplumber |
pdfplumber.Page 类
pdfplumber.Page类是pdfplumber的核心，表示PDF文件中一页单独的内容。当我们使用
pdfplumber时，大部分操作都会围绕这个类展开。主要成员变量如下：
属性 描述 .page_number顺序页码，从第一页开始为 1，第二页为2，以此类推。.width页面的宽度。 .height页面的高度。 .objects/.chars/.lines/.rects/.curves/.images这些属性都是列表，每个列表包含页面上嵌入的每个此类对象的一个字典。
1 | pdf = pdfplumber.open("test.pdf") |
1 | # 可视化第2页（尝试调整分辨率和抗锯齿） |
提取单页文本
pdfplumber库支持从任何给定的页面(pdfplumber.Page)中提取文本（包括裁剪和派生页面）。在提取文本的基础功能外，同时支持保留文本布局，识别单词和搜索页面中的文本。
pdfplumber.Page对象可以调用以下方法：方法 描述 .extract_text(x_tolerance=3, y_tolerance=3, layout=False, x_density=7.25, y_density=13, **kwargs)将页面的所有字符对象汇集成一个单一的字符串。当 layout=False时：在一个字符的x1和下一个字符的x0之间的差异大于x_tolerance时添加空格。在一个字符的doctop和下一个字符的doctop之间的差异大于y_tolerance时添加换行符。当layout=True（实验性功能）时：尝试模仿页面上文本的结构布局，使用x_density和y_density来确定每个”点”（PDF的度量单位）的最小字符/换行符数量。所有剩余的**kwargs都传递给.extract_words(...)（见下文），这是计算布局的第一步。.extract_text_simple(x_tolerance=3, y_tolerance=3).extract_text(...)的稍快但不太灵活的版本，使用更简单的逻辑。.extract_words(x_tolerance=3, y_tolerance=3, keep_blank_chars=False, use_text_flow=False, horizontal_ltr=True, vertical_ttb=True, extra_attrs=[], split_at_punctuation=False, expand_ligatures=True)返回所有看起来像单词的东西及其边界框的列表。单词被认为是字符序列，其中（对于”直立”字符）一个字符的 x1和下一个字符的x0之间的差异小于或等于x_tolerance并且 一个字符的doctop和下一个字符的doctop之间的差异小于或等于y_tolerance。对于非直立字符，采取类似的方法，但是测量它们之间的垂直距离，而不是水平距离。参数horizontal_ltr和vertical_ttb表示是否应从左到右阅读单词（对于水平单词）/从上到下（对于垂直单词）。将keep_blank_chars更改为True将意味着空白字符被视为单词的一部分，而不是单词之间的空格。将use_text_flow更改为True将使用PDF的底层字符流作为排序和划分单词的指南，而不是预先按x/y位置排序字符。（这模仿了在PDF中拖动光标突出显示文本的方式；就像那样，顺序并不总是看起来逻辑。）传递extra_attrs列表（例如，["fontname", "size"]将限制每个单词的字符具有完全相同的值，对于这些属性，并且结果的单词dicts将指示这些属性。将split_at_punctuation设置为True将在string.punctuation指定的标点处强制分割标记；或者你可以通过传递一个字符串来指定分隔标点的列表，例如，split_at_punctuation='!"&'()*+,.:;<=>?@[]^{.extract_text_lines(layout=False, strip=True, return_chars=True, **kwargs)实验性功能，返回代表页面上文本行的字典列表。 strip参数类似于Python的str.strip()方法，并返回没有周围空白的text属性。（只有当layout = True时才相关。）将return_chars设置为False将排除从返回的文本行dicts中添加单个字符对象。剩余的**kwargs是你将传递给.extract_text(layout=True, ...)的参数。.search(pattern, regex=True, case=True, main_group=0, return_groups=True, return_chars=True, layout=False, **kwargs)实验性功能，允许你搜索页面的文本，返回匹配查询的所有实例的列表。对于每个实例，响应字典对象包含匹配的文本、任何正则表达式组匹配、边界框坐标和字符对象本身。 pattern可以是编译的正则表达式、未编译的正则表达式或非正则字符串。如果regex是False，则将模式视为非正则字符串。如果case是False，则以不区分大小写的方式执行搜索。设置main_group将结果限制为pattern中的特定正则组（0的默认值表示整个匹配）。将return_groups和/或return_chars设置为False将排除添加匹配的正则组和/或字符的列表（作为"groups"和"chars"添加到返回的dicts）。layout参数的操作方式与.extract_text(...)相同。剩余的**kwargs是你将传递给.extract_text(layout=True, ...)的参数。 注意：零宽度和全空白匹配被丢弃，因为它们（通常）在页面上没有明确的位置。.dedupe_chars(tolerance=1)返回页面的版本，其中删除了重复的字符 — 那些与其他字符共享相同的文本、字体名、大小和位置（在 tolerancex/y 内）的字符。（参见 Issue #71 以理解动机。）1
2
3# 获取单页文本
p1_text = pages[0].extract_text()
print(p1_text)![]( "image-20250322132517945")
1
2
3# 获取单页文本（保留布局）
p1_text = pages[0].extract_text(layout=True)
print(p1_text)![]( "image-20250322132535702")
提取单页表格
pdfplumber对表格提取的方法大量借鉴了 Anssi Nurminen 的硕士论文，并受到 Tabula 的启发。它的工作原理如下：- 对于任何给定的PDF页面，找到那些（a）明确定义的线条和/或（b）由页面上单词的对齐方式暗示的线条。
- 合并重叠的，或几乎重叠的，线条。
- 找到所有这些线条的交点。
- 找到使用这些交点作为顶点的最精细的矩形集合（即，单元格）。
- 将连续的单元格分组成表格。
pdfplumber.Page对象可以调用以下方法：方法 描述 .find_tables(table_settings={})返回一个 Table对象的列表。Table对象提供对.cells，.rows，和.bbox属性的访问，以及.extract(x_tolerance=3, y_tolerance=3)方法。.find_table(table_settings={})类似于 .find_tables(...)，但返回页面上 最大 的表格，作为一个Table对象。如果多个表格的大小相同 —— 以单元格数量衡量 —— 此方法返回最接近页面顶部的表格。.extract_tables(table_settings={})返回从页面上找到的 所有 表格中提取的文本，表示为一个列表的列表的列表，结构为 table -> row -> cell。.extract_table(table_settings={})返回从页面上 最大 的表格中提取的文本（参见上面的 .find_table(...)），表示为一个列表的列表，结构为row -> cell。.debug_tablefinder(table_settings={})返回 TableFinder类的一个实例，可以访问.edges，.intersections，.cells，和.tables属性。1
2
3# 获取单页表格
p1_table = pages[0].extract_table()
p1_table![]( "image-20250322132907906")
1
2
3
4# 获取单页所有表格
tables = pages[0].extract_tables()
len(tables) # 1
tables![]( "image-20250322133039759")
1
2
3p1_debug_table = pages[0].debug_tablefinder()
type(p1_debug_table) # pdfplumber.table.TableFinder
p1_debug_table.tables # [<pdfplumber.table.Table at 0x103fa6660>]
使用 Pandas.DataFrame 来展示和存储表格
1 | import pandas as pd |
可视化调试页面
pdfplumber可视化调试工具可以帮助我们理解PDF文件的内容和结构，以及从中提取出来的对象。pdfplumber.Page对象可以使用.to_image()方法，将任何页面（包括裁剪后的页面）转换为PageImage对象。pdfplumber.Page.to_image()方法主要参数：- resolution：所需每英寸像素数。默认值：72。类型：整数。
- width：所需图像宽度（以像素为单位）。默认值：未设置，由分辨率确定。类型：整数。
- height：所需图像高度（以像素为单位）。默认值：未设置，由分辨率确定。类型：整数。
- antialias: 是否在创建图像时使用抗锯齿。将其设置为True可以创建具有较少锯齿的文本和图形，但文件大小会更大。默认值：False。类型：布尔值。
1
2# 可视化第一页
pages[0].to_image()
提取页面图像
pdfplumber.Page对象没有 extract_images 方法，所以不能直接从 PDF 页面中提取图像。但是，可以通过页面操作来截取和获取图像，pdfplumber.Page类相关成员变量如下：属性 描述 .width页面的宽度。 .height页面的高度。 .objects/.chars/.lines/.rects/.curves/.images这些属性都是列表，每个列表包含页面上嵌入的每个此类对象的一个字典。 相关成员方法：
方法 描述 .crop(bounding_box, relative=False, strict=True)返回裁剪到边界框的页面版本，边界框应表示为4元组，值为 (x0, top, x1, bottom)。裁剪的页面保留至少部分在边界框内的对象。如果对象只部分在框内，其尺寸将被切割以适应边界框。如果relative=True，则边界框是从页面边界框的左上角偏移计算的，而不是绝对定位。（请参见 Issue #245 以获取视觉示例和解释。）当strict=True（默认值）时，裁剪的边界框必须完全在页面的边界框内。.within_bbox(bounding_box, relative=False, strict=True)类似于 .crop，但只保留 完全在 边界框内的对象。.outside_bbox(bounding_box, relative=False, strict=True)类似于 .crop和.within_bbox，但只保留 完全在 边界框外的对象。.filter(test_function)返回只有 test_function(obj)返回True的.objects的页面版本。
1 | # 从 PageImage 中获取页面图像分辨率 |
1 | img = pages[1].images[0] |
1 | # 可视化裁剪后的第二页+抗锯齿 |
1 | cropped_page.to_image(resolution=1080) |
1 | im = cropped_page.to_image(antialias=True) |
2、Translator模块设计
2.1 book
book.py
1
2
3
4
5
6
7
8
9from .page import Page
class Book:
def __init__(self, pdf_file_path):
self.pdf_file_path = pdf_file_path
self.pages = []
def add_page(self, page: Page):
self.pages.append(page)content.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77import pandas as pd
from enum import Enum, auto
from PIL import Image as PILImage
from utils import LOG
class ContentType(Enum):
TEXT = auto()
TABLE = auto()
IMAGE = auto()
class Content:
def __init__(self, content_type, original, translation=None):
self.content_type = content_type
self.original = original
self.translation = translation
self.status = False
def set_translation(self, translation, status):
if not self.check_translation_type(translation):
raise ValueError(f"Invalid translation type. Expected {self.content_type}, but got {type(translation)}")
self.translation = translation
self.status = status
def check_translation_type(self, translation):
if self.content_type == ContentType.TEXT and isinstance(translation, str):
return True
elif self.content_type == ContentType.TABLE and isinstance(translation, list):
return True
elif self.content_type == ContentType.IMAGE and isinstance(translation, PILImage.Image):
return True
return False
class TableContent(Content):
def __init__(self, data, translation=None):
df = pd.DataFrame(data)
# Verify if the number of rows and columns in the data and DataFrame object match
if len(data) != len(df) or len(data[0]) != len(df.columns):
raise ValueError("The number of rows and columns in the extracted table data and DataFrame object do not match.")
super().__init__(ContentType.TABLE, df)
def set_translation(self, translation, status):
try:
if not isinstance(translation, str):
raise ValueError(f"Invalid translation type. Expected str, but got {type(translation)}")
LOG.debug(translation)
# Convert the string to a list of lists
table_data = [row.strip().split() for row in translation.strip().split('\n')]
LOG.debug(table_data)
# Create a DataFrame from the table_data
translated_df = pd.DataFrame(table_data[1:], columns=table_data[0])
LOG.debug(translated_df)
self.translation = translated_df
self.status = status
except Exception as e:
LOG.error(f"An error occurred during table translation: {e}")
self.translation = None
self.status = False
def __str__(self):
return self.original.to_string(header=False, index=False)
def iter_items(self, translated=False):
target_df = self.translation if translated else self.original
for row_idx, row in target_df.iterrows():
for col_idx, item in enumerate(row):
yield (row_idx, col_idx, item)
def update_item(self, row_idx, col_idx, new_value, translated=False):
target_df = self.translation if translated else self.original
target_df.at[row_idx, col_idx] = new_value
def get_original_as_str(self):
return self.original.to_string(header=False, index=False)page.py
1
2
3
4
5
6
7
8from .content import Content
class Page:
def __init__(self):
self.contents = []
def add_content(self, content: Content):
self.contents.append(content)__init__.py
1
2
3from .book import Book
from .page import Page
from .content import ContentType, Content, TableContent
2.2 model
model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18from book import ContentType
class Model:
def make_text_prompt(self, text: str, target_language: str) -> str:
return f"翻译为{target_language}：{text}"
def make_table_prompt(self, table: str, target_language: str) -> str:
# return f"翻译为{target_language}，保持间距（空格，分隔符），以表格形式返回：\n{table}"
return f"翻译为{target_language}，以空格和换行符表示表格：\n{table}"
def translate_prompt(self, content, target_language: str) -> str:
if content.content_type == ContentType.TEXT:
return self.make_text_prompt(content.original, target_language)
elif content.content_type == ContentType.TABLE:
return self.make_table_prompt(content.get_original_as_str(), target_language)
def make_request(self, prompt):
raise NotImplementedError("子类必须实现 make_request 方法")glm_model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import requests
import simplejson
from model import Model
class GLMModel(Model):
def __init__(self, model_url: str, timeout: int):
self.model_url = model_url
self.timeout = timeout
def make_request(self, prompt):
try:
payload = {
"prompt": prompt,
"history": []
}
response = requests.post(self.model_url, json=payload, timeout=self.timeout)
response.raise_for_status()
response_dict = response.json()
translation = response_dict["response"]
return translation, True
except requests.exceptions.RequestException as e:
raise Exception(f"请求异常：{e}")
except requests.exceptions.Timeout as e:
raise Exception(f"请求超时：{e}")
except simplejson.errors.JSONDecodeError as e:
raise Exception("Error: response is not valid JSON format.")
except Exception as e:
raise Exception(f"发生了未知错误：{e}")
return "", Falseopenai_model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54import requests
import simplejson
import time
import os
import openai
from model import Model
from utils import LOG
from openai import OpenAI
class OpenAIModel(Model):
def __init__(self, model: str, api_key: str):
self.model = model
self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def make_request(self, prompt):
attempts = 0
while attempts < 3:
try:
if self.model == "gpt-3.5-turbo":
response = self.client.chat.completions.create(
model=self.model,
messages=[
{"role": "user", "content": prompt}
]
)
translation = response.choices[0].message.content.strip()
else:
response = self.client.completions.create(
model=self.model,
prompt=prompt,
max_tokens=150,
temperature=0
)
translation = response.choices[0].text.strip()
return translation, True
except openai.RateLimitError as e:
attempts += 1
if attempts < 3:
LOG.warning("Rate limit reached. Waiting for 60 seconds before retrying.")
time.sleep(60)
else:
raise Exception("Rate limit reached. Maximum attempts exceeded.")
except openai.APIConnectionError as e:
print("The server could not be reached")
print(e.__cause__) # an underlying Exception, likely raised within httpx. except requests.exceptions.Timeout as e:
except openai.APIStatusError as e:
print("Another non-200-range status code was received")
print(e.status_code)
print(e.response)
except Exception as e:
raise Exception(f"发生了未知错误：{e}")
return "", False__init__.py
1
2
3from .model import Model
from .glm_model import GLMModel
from .openai_model import OpenAIModel
2.3 translator
pdf_parser.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58import pdfplumber
from typing import Optional
from book import Book, Page, Content, ContentType, TableContent
from translator.exceptions import PageOutOfRangeException
from utils import LOG
class PDFParser:
def __init__(self):
pass
def parse_pdf(self, pdf_file_path: str, pages: Optional[int] = None) -> Book:
book = Book(pdf_file_path)
with pdfplumber.open(pdf_file_path) as pdf:
if pages is not None and pages > len(pdf.pages):
raise PageOutOfRangeException(len(pdf.pages), pages)
if pages is None:
pages_to_parse = pdf.pages
else:
pages_to_parse = pdf.pages[:pages]
for pdf_page in pages_to_parse:
page = Page()
# Store the original text content
raw_text = pdf_page.extract_text()
tables = pdf_page.extract_tables()
# Remove each cell's content from the original text
for table_data in tables:
for row in table_data:
for cell in row:
raw_text = raw_text.replace(cell, "", 1)
# Handling text
if raw_text:
# Remove empty lines and leading/trailing whitespaces
raw_text_lines = raw_text.splitlines()
cleaned_raw_text_lines = [line.strip() for line in raw_text_lines if line.strip()]
cleaned_raw_text = "\n".join(cleaned_raw_text_lines)
text_content = Content(content_type=ContentType.TEXT, original=cleaned_raw_text)
page.add_content(text_content)
LOG.debug(f"[raw_text]\n {cleaned_raw_text}")
# Handling tables
if tables:
table = TableContent(tables)
page.add_content(table)
LOG.debug(f"[table]\n{table}")
book.add_page(page)
return bookpdf_translator.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26from typing import Optional
from model import Model
from translator.pdf_parser import PDFParser
from translator.writer import Writer
from utils import LOG
class PDFTranslator:
def __init__(self, model: Model):
self.model = model
self.pdf_parser = PDFParser()
self.writer = Writer()
def translate_pdf(self, pdf_file_path: str, file_format: str = 'PDF', target_language: str = '中文', output_file_path: str = None, pages: Optional[int] = None):
self.book = self.pdf_parser.parse_pdf(pdf_file_path, pages)
for page_idx, page in enumerate(self.book.pages):
for content_idx, content in enumerate(page.contents):
prompt = self.model.translate_prompt(content, target_language)
LOG.debug(prompt)
translation, status = self.model.make_request(prompt)
LOG.info(translation)
# Update the content in self.book.pages directly
self.book.pages[page_idx].contents[content_idx].set_translation(translation, status)
self.writer.save_translated_book(self.book, output_file_path, file_format)writer.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108import os
from reportlab.lib import colors, pagesizes, units
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.platypus import (
SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
)
from book import Book, ContentType
from utils import LOG
class Writer:
def __init__(self):
pass
def save_translated_book(self, book: Book, output_file_path: str = None, file_format: str = "PDF"):
if file_format.lower() == "pdf":
self._save_translated_book_pdf(book, output_file_path)
elif file_format.lower() == "markdown":
self._save_translated_book_markdown(book, output_file_path)
else:
raise ValueError(f"Unsupported file format: {file_format}")
def _save_translated_book_pdf(self, book: Book, output_file_path: str = None):
if output_file_path is None:
output_file_path = book.pdf_file_path.replace('.pdf', f'_translated.pdf')
LOG.info(f"pdf_file_path: {book.pdf_file_path}")
LOG.info(f"开始翻译: {output_file_path}")
# Register Chinese font
font_path = "../fonts/simsun.ttc" # 请将此路径替换为您的字体文件路径
pdfmetrics.registerFont(TTFont("SimSun", font_path))
# Create a new ParagraphStyle with the SimSun font
simsun_style = ParagraphStyle('SimSun', fontName='SimSun', fontSize=12, leading=14)
# Create a PDF document
doc = SimpleDocTemplate(output_file_path, pagesize=pagesizes.letter)
styles = getSampleStyleSheet()
story = []
# Iterate over the pages and contents
for page in book.pages:
for content in page.contents:
if content.status:
if content.content_type == ContentType.TEXT:
# Add translated text to the PDF
text = content.translation
para = Paragraph(text, simsun_style)
story.append(para)
elif content.content_type == ContentType.TABLE:
# Add table to the PDF
table = content.translation
table_style = TableStyle([
('BACKGROUND', (0, 0), (-1, 0), colors.grey),
('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
('ALIGN', (0, 0), (-1, -1), 'CENTER'),
('FONTNAME', (0, 0), (-1, 0), 'SimSun'), # 更改表头字体为 "SimSun"
('FONTSIZE', (0, 0), (-1, 0), 14),
('BOTTOMPADDING', (0, 0), (-1, 0), 12),
('BACKGROUND', (0, 1), (-1, -1), colors.beige),
('FONTNAME', (0, 1), (-1, -1), 'SimSun'), # 更改表格中的字体为 "SimSun"
('GRID', (0, 0), (-1, -1), 1, colors.black)
])
pdf_table = Table(table.values.tolist())
pdf_table.setStyle(table_style)
story.append(pdf_table)
# Add a page break after each page except the last one
if page != book.pages[-1]:
story.append(PageBreak())
# Save the translated book as a new PDF file
doc.build(story)
LOG.info(f"翻译完成: {output_file_path}")
def _save_translated_book_markdown(self, book: Book, output_file_path: str = None):
if output_file_path is None:
output_file_path = book.pdf_file_path.replace('.pdf', f'_translated.md')
LOG.info(f"pdf_file_path: {book.pdf_file_path}")
LOG.info(f"开始翻译: {output_file_path}")
with open(output_file_path, 'w', encoding='utf-8') as output_file:
# Iterate over the pages and contents
for page in book.pages:
for content in page.contents:
if content.status:
if content.content_type == ContentType.TEXT:
# Add translated text to the Markdown file
text = content.translation
output_file.write(text + '\n\n')
elif content.content_type == ContentType.TABLE:
# Add table to the Markdown file
table = content.translation
header = '| ' + ' | '.join(str(column) for column in table.columns) + ' |' + '\n'
separator = '| ' + ' | '.join(['---'] * len(table.columns)) + ' |' + '\n'
# body = '\n'.join(['| ' + ' | '.join(row) + ' |' for row in table.values.tolist()]) + '\n\n'
body = '\n'.join(['| ' + ' | '.join(str(cell) for cell in row) + ' |' for row in table.values.tolist()]) + '\n\n'
output_file.write(header + separator + body)
# Add a page break (horizontal rule) after each page except the last one
if page != book.pages[-1]:
output_file.write('---\n\n')
LOG.info(f"翻译完成: {output_file_path}")exceptions.py
1
2
3
4
5class PageOutOfRangeException(Exception):
def __init__(self, book_pages, requested_pages):
self.book_pages = book_pages
self.requested_pages = requested_pages
super().__init__(f"Page out of range: Book has {book_pages} pages, but {requested_pages} pages were requested.")__init__.py
1
from .pdf_translator import PDFTranslator
2.4 utils
argument_parser.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import argparse
class ArgumentParser:
def __init__(self):
self.parser = argparse.ArgumentParser(description='Translate English PDF book to Chinese.')
self.parser.add_argument('--config', type=str, default='config.yaml', help='Configuration file with model and API settings.')
self.parser.add_argument('--model_type', type=str, required=True, choices=['GLMModel', 'OpenAIModel'], help='The type of translation model to use. Choose between "GLMModel" and "OpenAIModel".')
self.parser.add_argument('--glm_model_url', type=str, help='The URL of the ChatGLM model URL.')
self.parser.add_argument('--timeout', type=int, help='Timeout for the API request in seconds.')
self.parser.add_argument('--openai_model', type=str, help='The model name of OpenAI Model. Required if model_type is "OpenAIModel".')
self.parser.add_argument('--openai_api_key', type=str, help='The API key for OpenAIModel. Required if model_type is "OpenAIModel".')
self.parser.add_argument('--book', type=str, help='PDF file to translate.')
self.parser.add_argument('--file_format', type=str, help='The file format of translated book. Now supporting PDF and Markdown')
def parse_arguments(self):
args = self.parser.parse_args()
if args.model_type == 'OpenAIModel' and not args.openai_model and not args.openai_api_key:
self.parser.error("--openai_model and --openai_api_key is required when using OpenAIModel")
return argsconfig_loader.py
1
2
3
4
5
6
7
8
9
10import yaml
class ConfigLoader:
def __init__(self, config_path):
self.config_path = config_path
def load_config(self):
with open(self.config_path, "r") as f:
config = yaml.safe_load(f)
return configlogger.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32from loguru import logger
import os
import sys
LOG_FILE = "translation.log"
ROTATION_TIME = "02:00"
class Logger:
def __init__(self, name="translation", log_dir="logs", debug=False):
if not os.path.exists(log_dir):
os.makedirs(log_dir)
log_file_path = os.path.join(log_dir, LOG_FILE)
# Remove default loguru handler
logger.remove()
# Add console handler with a specific log level
level = "DEBUG" if debug else "INFO"
logger.add(sys.stdout, level=level)
# Add file handler with a specific log level and timed rotation
logger.add(log_file_path, rotation=ROTATION_TIME, level="DEBUG")
self.logger = logger
LOG = Logger(debug=True).logger
if __name__ == "__main__":
log = Logger().logger
log.debug("This is a debug message.")
log.info("This is an info message.")
log.warning("This is a warning message.")
log.error("This is an error message.")1
2
3from .argument_parser import ArgumentParser
from .config_loader import ConfigLoader
from .logger import LOG
2.5 main
main.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import sys
import os
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from utils import ArgumentParser, ConfigLoader, LOG
from model import GLMModel, OpenAIModel
from translator import PDFTranslator
if __name__ == "__main__":
argument_parser = ArgumentParser()
args = argument_parser.parse_arguments()
config_loader = ConfigLoader(args.config)
config = config_loader.load_config()
model_name = args.openai_model if args.openai_model else config['OpenAIModel']['model']
api_key = args.openai_api_key if args.openai_api_key else config['OpenAIModel']['api_key']
model = OpenAIModel(model=model_name, api_key=api_key)
pdf_file_path = args.book if args.book else config['common']['book']
file_format = args.file_format if args.file_format else config['common']['file_format']
# 实例化 PDFTranslator 类，并调用 translate_pdf() 方法
translator = PDFTranslator(model)
translator.translate_pdf(pdf_file_path, file_format)