triclick-doc-toolset 1.0.0__tar.gz

triclick_doc_toolset-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish to PyPI
+
+on:
+  pull_request:
+    branches:
+      - main
+    types: [closed]
+
+jobs:
+  publish:
+    # 只在PR合并到main分支时执行
+    if: github.event_name == 'push' || (github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'main')
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.12'
+        
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      
+    - name: Install dependencies
+      run: |
+        uv sync
+        uv add --group dev build twine
+        
+    - name: Clean previous builds
+      run: |
+        rm -rf dist/ build/ *.egg-info/
+        
+    - name: Build package
+      run: |
+        uv run python -m build
+        
+    - name: Check package
+      run: |
+        uv run twine check dist/*
+        
+    - name: Publish to PyPI
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        uv run twine upload dist/*

triclick_doc_toolset-1.0.0/.gitignore

@@ -0,0 +1,22 @@
+# os 
+.DS_Store
+
+# IDE
+.idea
+.vscode
+
+# Virtual environments
+.venv
+
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+output
+data.output
+*.egg-info
+
+# project-specific files
+data.output

triclick_doc_toolset-1.0.0/.python-version

@@ -0,0 +1 @@
+3.12

triclick_doc_toolset-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: triclick-doc-toolset
+Version: 1.0.0
+Summary: Advanced document partitioning and processing toolset
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: python-docx>=1.2.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest<9.0,>=8.0; extra == 'dev'

triclick_doc_toolset-1.0.0/pipelines/generation.yaml

@@ -0,0 +1,36 @@
+# Generation流水线：文档类型识别 -> 解析 -> 拆分
+
+pipeline:
+  strategies:
+    # 文件类型识别
+    - name: detect_file_type
+      exec_mode: sequential
+      priority: 1
+      commands:
+        - type: FileTypeIdentificationCommand
+          name: detect_file_type
+          priority: 1
+
+    # 按类型解析
+    - name: parse_by_type
+      exec_mode: sequential
+      priority: 2
+      commands:
+        - type: DocxFileParseCommand
+          name: parse_docx_title_table_footnote
+          priority: 1
+          condition: "doc_type == 'docx'"
+        - type: RTFFileParseCommand
+          name: parse_rtf_title_table_footnote
+          priority: 2
+          condition: "doc_type == 'rtf'"
+
+    # 文档拆分
+    - name: split_docx_tables
+      exec_mode: sequential
+      priority: 3
+      commands:
+        - type: DocxFilePartitionCommand
+          name: split_docx_to_single_tables
+          priority: 3
+          condition: "doc_type == 'docx'"

triclick_doc_toolset-1.0.0/pipelines/review.yaml

@@ -0,0 +1,35 @@
+# Review流水线：文档类型识别 -> 解析 -> 拆分（小优先级先执行）
+pipeline:
+  strategies:
+    # 文件类型识别，单独策略
+    - name: detect_file_type
+      exec_mode: sequential
+      priority: 1
+      commands:
+        - type: FileTypeIdentificationCommand
+          name: detect_file_type
+          priority: 1
+
+    # 按类型解析，单独策略
+    - name: parse_by_type
+      exec_mode: sequential
+      priority: 2
+      commands:
+        - type: DocxFileParseCommand
+          name: parse_docx_title_table_footnote
+          priority: 1
+          condition: "doc_type == 'docx'"
+        - type: RTFFileParseCommand
+          name: parse_rtf_title_table_footnote
+          priority: 2
+          condition: "doc_type == 'rtf'"
+
+    # DOCX拆分，单独策略
+    - name: split_docx_tables
+      exec_mode: sequential
+      priority: 3
+      commands:
+        - type: DocxFilePartitionCommand
+          name: split_docx_tables_with_copy
+          priority: 3
+          condition: "doc_type == 'docx'"

triclick_doc_toolset-1.0.0/pipelines/title_table_footnote_patterns.yaml

@@ -0,0 +1,19 @@
+# 用于从标题文本中提取用于命名的最小标签（前缀+编号），保持最小可表达
+# 例如："Table 2.3"、"Listing 1"。不包含后续描述。
+# 参考上面的列表样式进行拆分
+label_patterns:
+  - '^\s*(?:Table)\s+[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*(?=\s|$|[:：])'
+  - '^\s*(?:Listing)\s+[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*(?=\s|$|[:：])'
+
+footnote_patterns:
+  - '^same\s+as\s+table\s+[0-9]+(\.[0-9]+)*'
+
+# 可配置的标题最小正则列表
+# 你可以根据文档风格增删这些规则；按序匹配，忽略大小写。
+# 示例：匹配以 Table 或 Listing 开头，并跟随编号或编号+字母等形式。
+title_patterns:
+  - '^(?:Table)\s+\S+'
+  - '^(?:Listing)\s+\S+'
+  - '^\s*(?:Table|Listing)\s+[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*(?=\s|$|[:：])'
+
+

triclick_doc_toolset-1.0.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "triclick-doc-toolset"
+version = "1.0.0"
+description = "Advanced document partitioning and processing toolset"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pyyaml>=6.0",
+    "pydantic>=2.12.3",
+    "python-docx>=1.2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0,<9.0"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[[tool.uv.index]]
+url = "https://pypi.org/simple/"
+default = true
+
+[tool.uv]
+index-url = "https://pypi.org/simple/"
+
+[tool.ruff]
+line-length = 100
+
+[tool.pyright]
+pythonVersion = "3.12"
+typeCheckingMode = "standard"
+
+[dependency-groups]
+dev = [
+    "build>=1.3.0",
+    "twine>=6.2.0",
+]

triclick_doc_toolset-1.0.0/src/__init__.py

@@ -0,0 +1,13 @@
+from .framework import Pipeline, Strategy, Command, Context 
+from .service import run_pipeline, run_generation, run_review
+
+
+__all__ = [
+    "Pipeline",
+    "Strategy",
+    "Command",
+    "Context",
+    "run_pipeline",
+    "run_generation",
+    "run_review",
+]

triclick_doc_toolset-1.0.0/src/commands/__init__.py

@@ -0,0 +1,5 @@
+# 确保命令模块被导入，从而完成注册到 CommandRegistry
+from .docx_file_parse_cmd import DocxFileParseCommand  # noqa: F401
+from .docx_file_partition_cmd import DocxFilePartitionCommand  # noqa: F401
+from .file_type_identification_cmd import FileTypeIdentificationCommand  # noqa: F401
+from .rtf_file_parse_cmd import RTFFileParseCommand  # noqa: F401

triclick_doc_toolset-1.0.0/src/commands/docx_file_parse_cmd.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import List, Dict
+from dataclasses import asdict
+
+# 框架依赖
+from ..framework.command import Command
+from ..framework.context import Context
+from ..framework.command_registry import CommandRegistry
+
+# 解析工具方法（仅保留元数据解析）
+from ..common.word.docx_file_parse_util import (
+    extract_docx_content_with_metadata,
+)
+
+
+class DocxFileParseCommand(Command):
+    """
+    框架命令子类：按“标题-表格-脚注/段落”分块（仅元数据）。
+    仅使用 `extract_docx_content_with_metadata` 进行解析。
+    """
+
+    def is_satisfied(self, context: Context) -> bool:
+        return context.has_document()
+
+    def execute(self, context: Context) -> Context:
+        # 解析输入路径（支持文件或文件夹），仅处理 .docx
+        paths = context.resolve_document_paths(patterns=["*.docx"])
+        if not paths:
+            context.add_error("No DOCX files resolved from context")
+            return context
+
+        # 将解析得到的 TableItem 列表转为结构化字典，并写入 Context.sections
+        parsed_sections: List[Dict] = []
+        for p in paths:
+            sections = extract_docx_content_with_metadata(str(p))
+            for sec in sections:
+                d = asdict(sec)
+                d["source_file"] = str(p)
+                parsed_sections.append(d)
+
+        # 更新上下文
+        context.doc_type = "docx"
+        context.sections = parsed_sections
+        context.processing_summary["title_table_footnote_partition"] = {
+            "files_processed": len(paths),
+            "sections_extracted": len(parsed_sections),
+            "mode": "metadata_only",
+        }
+        return context
+
+
+# 注册到命令注册表，便于 Pipeline 通过 YAML 创建
+CommandRegistry.register("DocxFileParseCommand", DocxFileParseCommand)

triclick_doc_toolset-1.0.0/src/commands/docx_file_partition_cmd.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Dict
+from dataclasses import asdict
+
+# 框架依赖
+from ..framework.command import Command
+from ..framework.context import Context
+from ..framework.command_registry import CommandRegistry
+
+# 仅对接拆分工具方法
+from ..common.word.docx_file_partition_util import (
+    split_docx_into_tables_with_copy,
+)
+from ..common.models import TableItem
+
+
+class DocxFilePartitionCommand(Command):
+    """
+    基于“标题-表格-脚注”元数据拆分 DOCX，保留原样式。
+    只对接 `split_docx_into_tables_with_copy`，从 Context.sections 读取解析结果，
+    处理完后覆盖写回 Context.sections。
+    输出目录仅从 Context.metadata['output_dir'] 读取。
+    """
+
+    def is_satisfied(self, context: Context) -> bool:
+        return context.has_document()
+
+    def _to_table_item(self, d: Dict) -> TableItem:
+        ti = TableItem(
+            level=int(d.get("level", 0) or 0),
+            table_index=d.get("table_index"),
+            label=d.get("label"),
+            title=d.get("title"),
+        )
+        # 安全过滤 None
+        ti.title_indices = [int(i) for i in (d.get("title_indices") or []) if isinstance(i, int)]
+        ti.footnote = d.get("footnote")
+        ti.footnote_indices = [int(i) for i in (d.get("footnote_indices") or []) if isinstance(i, int)]
+        ti.local_path = d.get("local_path")
+        return ti
+
+    def execute(self, context: Context) -> Context:
+        # 从 Context.sections 读取解析结果
+        sections_in = context.sections or []
+        if not sections_in:
+            context.add_error("No parsed sections found in context; run partition first")
+            return context
+
+        # 按 source_file 分组
+        grouped: Dict[str, List[TableItem]] = {}
+        for d in sections_in:
+            src = d.get("source_file")
+            if not src:
+                # 无来源则跳过
+                continue
+            grouped.setdefault(src, []).append(self._to_table_item(d))
+
+        out_dirs: List[str] = []
+        generated_files: List[str] = []
+        sections_out: List[dict] = []
+
+        for src_str, items in grouped.items():
+            src = Path(src_str)
+            base_out = context.metadata.get("output_dir")
+            if not base_out:
+                context.add_error("DocxFilePartitionCommand requires context.metadata['output_dir']")
+                return context
+            out_dir_str = str(base_out)
+
+            updated_items = split_docx_into_tables_with_copy(str(src), items, output_dir=out_dir_str)
+            out_dirs.append(out_dir_str)
+
+            # 写入 Context.sections（结构化 dict），附带 source_file
+            for sec in updated_items:
+                d = asdict(sec)
+                d["source_file"] = src_str
+                sections_out.append(d)
+                if d.get("local_path"):
+                    generated_files.append(d["local_path"])
+
+        context.doc_type = "docx"
+        # 覆盖写回拆分后的分段到 Context
+        context.sections = sections_out
+        # 记录输出摘要
+        tables_processed = sum(1 for d in sections_out if d.get("local_path"))
+        context.processing_summary["title_table_footnote_split"] = {
+            "files_processed": len(grouped),
+            "tables_processed": tables_processed,
+            "generated_files_count": len(generated_files),
+            "output_dirs": out_dirs,
+            "mode": "copy_elements",
+        }
+        # 附加生成文件（可用于后续输出或验证）
+        context.generated_files.extend(generated_files)
+        return context
+
+
+# 注册到命令注册表，便于 Pipeline 通过 YAML 创建
+CommandRegistry.register("DocxFilePartitionCommand", DocxFilePartitionCommand)

triclick_doc_toolset-1.0.0/src/commands/file_type_identification_cmd.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ..framework.command import Command
+from ..framework.context import Context
+from ..framework.command_registry import CommandRegistry
+
+
+class FileTypeIdentificationCommand(Command):
+    """
+    文档类型识别命令：根据输入的文件或文件夹，识别主要文档类型。
+
+    规则：
+    - 单文件：按扩展名识别（docx/doc/rtf）。
+    - 文件夹：优先选择包含文件数量最多的已支持类型（docx > rtf > doc）。
+    - 识别结果写入 `context.doc_type`，并在 processing_summary 中记录统计。
+    """
+
+    SUPPORTED_EXTS = {"docx": "docx", "doc": "doc", "rtf": "rtf"}
+
+    def is_satisfied(self, context: Context) -> bool:
+        return context.document_uri is not None
+
+    def _count_types(self, paths: List[Path]) -> Dict[str, int]:
+        counts: Dict[str, int] = {"docx": 0, "doc": 0, "rtf": 0}
+        for p in paths:
+            ext = p.suffix.lower().lstrip(".")
+            if ext in counts:
+                counts[ext] += 1
+        return counts
+
+    def execute(self, context: Context) -> Context:
+        uri = context.document_uri
+        if uri is None:
+            context.add_error("No document_uri set in context")
+            return context
+
+        # 单文件识别
+        if isinstance(uri, (str, Path)) and Path(uri).is_file():
+            ext = Path(uri).suffix.lower().lstrip(".")
+            doc_type = self.SUPPORTED_EXTS.get(ext, None)
+            context.doc_type = doc_type
+            context.processing_summary["file_type_identification"] = {
+                "source": str(Path(uri)),
+                "doc_type": doc_type or "unknown",
+            }
+            return context
+
+        # 目录或列表识别
+        paths = context.resolve_document_paths(patterns=["*.docx", "*.doc", "*.rtf"])
+        counts = self._count_types(paths)
+        # 选择规则：docx 优先，其次 rtf，再次 doc
+        doc_type: Optional[str] = None
+        if counts["docx"] > 0:
+            doc_type = "docx"
+        elif counts["rtf"] > 0:
+            doc_type = "rtf"
+        elif counts["doc"] > 0:
+            doc_type = "doc"
+        else:
+            doc_type = None
+        context.doc_type = doc_type
+        context.processing_summary["file_type_identification"] = {
+            "counts": counts,
+            "doc_type": doc_type or "unknown",
+        }
+        return context
+
+# 注册到命令注册表
+CommandRegistry.register("FileTypeIdentificationCommand", FileTypeIdentificationCommand)

triclick_doc_toolset-1.0.0/src/commands/rtf_file_parse_cmd.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import re
+from dataclasses import asdict
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from ..framework.command import Command
+from ..framework.context import Context
+from ..framework.command_registry import CommandRegistry
+
+from ..common.models import TableItem
+from ..common.utils.title_table_footnote_patterns_loader import (
+    load_title_patterns, load_label_patterns, load_footnote_patterns
+)
+
+
+TITLE_PATTERNS = load_title_patterns()
+LABEL_PATTERNS = load_label_patterns()
+FOOTNOTE_PATTERNS = load_footnote_patterns()
+
+
+def _extract_label(text: str) -> Optional[str]:
+    text = (text or "").strip()
+    for pat in LABEL_PATTERNS:
+        m = pat.match(text)
+        if m:
+            label = m.group(0).strip()
+            label = re.sub(r"\s+", " ", label)
+            label = re.sub(r"^(table|listing)", lambda m: m.group(1).capitalize(), label)
+            return label
+    return None
+
+
+def _compute_level(label: Optional[str]) -> int:
+    if not label:
+        return 0
+    parts = label.split(None, 1)
+    number_part = parts[1] if len(parts) == 2 else parts[0]
+    return number_part.count('.')
+
+
+def _rtf_to_text(rtf_path: Path) -> str:
+    # 朴素的 RTF 文本提取：去除控制词与分组，保留 \par 作为换行
+    data = rtf_path.read_bytes()
+    try:
+        s = data.decode('utf-8', errors='ignore')
+    except Exception:
+        s = data.decode('latin-1', errors='ignore')
+    # 将段落分隔转换为换行
+    s = s.replace("\\par", "\n").replace("\\line", "\n")
+    s = s.replace("\\tab", "\t")
+    # 移除转义的 16 进制字符（简化处理）
+    s = re.sub(r"\\'[0-9a-fA-F]{2}", " ", s)
+    # 移除控制词（如 \\b、\\fs24 等）
+    s = re.sub(r"\\[a-zA-Z]+(?:-?\d+)?\s?", "", s)
+    # 移除分组的大括号
+    s = s.replace('{', '').replace('}', '')
+    # 归一化换行
+    s = re.sub(r"\r\n|\r", "\n", s)
+    # 压缩多行空白
+    s = re.sub(r"\n{3,}", "\n\n", s)
+    return s
+
+
+class RTFFileParseCommand(Command):
+    """
+    简易 RTF 解析命令：
+    - 逐行匹配标题模式，生成 TableItem；
+    - 尝试收集紧随标题后的脚注行（基于 footnote_patterns），直到遇到下一个标题；
+    - 不支持表格索引（table_index 始终为 None）。
+    """
+
+    def is_satisfied(self, context: Context) -> bool:
+        return context.has_document()
+
+    def execute(self, context: Context) -> Context:
+        paths = context.resolve_document_paths(patterns=["*.rtf"])
+        if not paths:
+            # 若无 RTF 文件，直接返回，不记为错误（由条件控制是否运行）
+            return context
+
+        sections_out: List[Dict] = []
+        for p in paths:
+            txt = _rtf_to_text(Path(p))
+            lines = [ln.strip() for ln in txt.splitlines()]
+            current: Optional[TableItem] = None
+            for idx, line in enumerate(lines):
+                if not line:
+                    continue
+                # 新标题开始
+                if any(pat.match(line) for pat in TITLE_PATTERNS):
+                    if current:
+                        d = asdict(current)
+                        d["source_file"] = str(p)
+                        sections_out.append(d)
+                    label = _extract_label(line)
+                    current = TableItem(
+                        label=label,
+                        title=line,
+                        level=_compute_level(label),
+                        title_indices=[idx],
+                    )
+                    continue
+                # 收集脚注（仅当已有当前标题且匹配脚注规则）
+                if current and any(pat.search(line) for pat in FOOTNOTE_PATTERNS):
+                    current.add_footnote_index(idx)
+                    current.append_footnote_text(line)
+            # 收尾：追加最后一个段
+            if current:
+                d = asdict(current)
+                d["source_file"] = str(p)
+                sections_out.append(d)
+
+        context.doc_type = "rtf"
+        context.sections = sections_out
+        context.processing_summary["rtf_title_table_footnote_partition"] = {
+            "files_processed": len(paths),
+            "sections_extracted": len(sections_out),
+            "mode": "rtf_text_only",
+        }
+        return context
+
+
+# 注册到命令注册表
+CommandRegistry.register("RTFFileParseCommand", RTFFileParseCommand)

triclick_doc_toolset-1.0.0/src/common/models/__init__.py

@@ -0,0 +1,5 @@
+"""Common data models for the triclick document toolset."""
+
+from .table_item import TableItem
+
+__all__ = ['TableItem']

triclick_doc_toolset-1.0.0/src/common/models/table_item.py

@@ -0,0 +1,41 @@
+"""Data models for table parsing and processing."""
+
+from __future__ import annotations
+from typing import List, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TableItem:
+    """表格项数据结构，包含标题、层级、索引和表格信息。"""
+    level: int = 0
+    table_index: Optional[int] = None
+    label: Optional[str] = None
+    title: Optional[str] = None
+    title_indices: List[int] = field(default_factory=list)
+    footnote: Optional[str] = None
+    footnote_indices: List[int] = field(default_factory=list)
+    local_path: Optional[str] = None
+    
+    def set_table(self, table_index: int):
+        """设置当前 section 的表格索引。"""
+        self.table_index = table_index
+    
+    def add_footnote_index(self, para_index: int):
+        """为当前 section 的表格追加脚注段落索引。"""
+        self.footnote_indices.append(para_index)
+    
+    def append_footnote_text(self, text: str):
+        """追加脚注文本（按段落累积，以换行分隔）。"""
+        text = (text or "").strip()
+        if not text:
+            return
+        if self.footnote:
+            # 以换行分隔追加，保持原段落边界
+            self.footnote += ("\n" if not self.footnote.endswith("\n") else "") + text
+        else:
+            self.footnote = text
+    
+    def get_section_label(self) -> str:
+        """获取用于文件命名的标签，若无标签则返回默认值。"""
+        return (self.label or 'Table')