File size: 8,623 Bytes
b4f2238
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
"""Business logic services."""

import ast
import logging
import re
from functools import lru_cache
from pathlib import Path
from typing import Any

from .registry import CodePlaceholderDefinition, CodePlaceholderRegistry

logger = logging.getLogger(__name__)


class CodePlaceholderCatalogService:
    _KEY_PATTERN = re.compile(r"^[\w\u4e00-\u9fff][\w\u4e00-\u9fff\.\(\)]*$")

    def list_definitions(self) -> list[CodePlaceholderDefinition]:
        definitions: dict[str, CodePlaceholderDefinition] = {}

        for definition in self._from_code_registry():
            definitions.setdefault(definition.key, definition)

        for definition in self._from_registry():
            definitions.setdefault(definition.key, definition)

        for definition in self._from_spec_files_scan():
            definitions.setdefault(definition.key, definition)

        for definition in self._from_evidence_list():
            definitions.setdefault(definition.key, definition)

        for definition in self._from_generation_ast_scan():
            definitions.setdefault(definition.key, definition)

        return sorted(definitions.values(), key=lambda d: d.key)

    def get_definition(self, key: str) -> CodePlaceholderDefinition | None:
        for definition in self.list_definitions():
            if definition.key == key:
                return definition
        return None

    def list_keys(self) -> list[str]:
        return [d.key for d in self.list_definitions()]

    def _from_code_registry(self) -> list[CodePlaceholderDefinition]:
        return CodePlaceholderRegistry().list_definitions()

    def _from_registry(self) -> list[CodePlaceholderDefinition]:
        from apps.documents.services.placeholders import PlaceholderRegistry

        registry = PlaceholderRegistry()
        result: list[CodePlaceholderDefinition] = []
        for service in registry.get_all_services():
            source = getattr(service, "display_name", "") or getattr(service, "name", "") or service.__class__.__name__
            category = getattr(service, "category", "") or "general"
            service_description = getattr(service, "description", "") or ""
            metadata: dict[str, Any] = {}
            if hasattr(service, "get_placeholder_metadata"):
                metadata = service.get_placeholder_metadata() or {}
            for key in service.get_placeholder_keys():
                key_meta = metadata.get(key, {}) or {}
                result.append(
                    CodePlaceholderDefinition(
                        key=key,
                        source=source,
                        category=category,
                        display_name=key_meta.get("display_name") or "",
                        description=key_meta.get("description") or service_description,
                        example_value=key_meta.get("example_value") or "",
                    )
                )
        return result

    def _from_spec_files_scan(self) -> list[CodePlaceholderDefinition]:
        apps_root = Path(__file__).resolve().parents[2]
        if not apps_root.exists():
            return []
        return _scan_placeholder_spec_files(apps_root)

    def _from_evidence_list(self) -> list[CodePlaceholderDefinition]:
        from apps.documents.services.evidence.evidence_list_placeholder_service import EvidenceListPlaceholderService

        service = EvidenceListPlaceholderService()
        keys = list(service.get_placeholder_keys() or [])

        return [
            CodePlaceholderDefinition(
                key=key,
                source="证据清单",
                category="evidence",
                display_name=key,
                description="证据清单导出占位符",
            )
            for key in keys
        ]

    def _from_generation_ast_scan(self) -> list[CodePlaceholderDefinition]:
        root = Path(__file__).resolve().parents[1] / "services"
        if not root.exists():
            return []

        keys = self._scan_python_files_for_context_keys(root)
        result: list[CodePlaceholderDefinition] = []
        for key in sorted(keys):
            result.append(
                CodePlaceholderDefinition(
                    key=key,
                    source="生成器扫描",
                    category="generated",
                    display_name=key,
                    description="从生成器代码中自动提取的上下文键",
                )
            )
        return result

    def _scan_python_files_for_context_keys(self, root: Path) -> set[str]:
        collected: set[str] = set()
        for file_path in root.rglob("*.py"):
            try:
                content = file_path.read_text(encoding="utf-8")
            except Exception:
                logger.exception("操作失败")

                continue
            if "DocxTemplate" not in content and "docxtpl" not in content:
                continue
            try:
                tree = ast.parse(content, filename=str(file_path))
            except SyntaxError:
                continue

            visitor = _ContextDictKeyVisitor()
            visitor.visit(tree)
            for key in visitor.keys:
                if not self._is_placeholder_key_candidate(key):
                    continue
                if not self._looks_like_template_placeholder(key):
                    continue
                collected.add(key)

        return collected

    def _is_placeholder_key_candidate(self, key: str) -> bool:
        return bool(key and self._KEY_PATTERN.match(key))

    def _looks_like_template_placeholder(self, key: str) -> bool:
        return any("\u4e00" <= ch <= "\u9fff" for ch in key)


class _ContextDictKeyVisitor(ast.NodeVisitor):
    def __init__(self) -> None:
        self.keys: set[str] = set()

    def visit_Return(self, node: ast.Return) -> None:
        self._collect_from_value(node.value)
        self.generic_visit(node)

    def visit_Assign(self, node: ast.Assign) -> None:
        for target in node.targets:
            if isinstance(target, ast.Name) and target.id == "context":
                self._collect_from_value(node.value)
        self.generic_visit(node)

    def _collect_from_value(self, value: ast.AST | None) -> None:
        if isinstance(value, ast.Dict):
            for k in value.keys:
                if isinstance(k, ast.Constant) and isinstance(k.value, str):
                    self.keys.add(k.value)


@lru_cache(maxsize=1)
def _scan_placeholder_spec_files(apps_root: Path) -> list[CodePlaceholderDefinition]:
    result: list[CodePlaceholderDefinition] = []

    for spec_path in apps_root.rglob("placeholders/spec.py"):
        result.extend(_extract_definitions_from_spec(spec_path))

    dedup: dict[str, CodePlaceholderDefinition] = {}
    for definition in result:
        dedup.setdefault(definition.key, definition)
    return list(dedup.values())


def _extract_definitions_from_spec(spec_path: Path) -> list[CodePlaceholderDefinition]:
    try:
        content = spec_path.read_text(encoding="utf-8")
    except Exception:
        logger.exception("操作失败")

        return []
    try:
        tree = ast.parse(content, filename=str(spec_path))
    except SyntaxError:
        return []

    source, category, description = _spec_metadata(spec_path)
    definitions: list[CodePlaceholderDefinition] = []

    for node in tree.body:
        if not isinstance(node, ast.ClassDef) or not node.name.endswith("PlaceholderKeys"):
            continue
        for stmt in node.body:
            key = _extract_string_assignment(stmt)
            if key:
                definitions.append(
                    CodePlaceholderDefinition(
                        key=key,
                        source=source,
                        category=category,
                        display_name=key,
                        description=description,
                    )
                )
    return definitions


def _spec_metadata(spec_path: Path) -> tuple[str, str, str]:
    app_name = spec_path.parts[-3] if len(spec_path.parts) >= 3 else "unknown"
    if app_name == "litigation_ai":
        return "诉讼文书", "litigation", "诉讼文书生成上下文占位符"
    return f"{app_name} 占位符", app_name, "从 placeholders/spec.py 自动发现的占位符键"


def _extract_string_assignment(stmt: ast.stmt) -> str | None:
    if not isinstance(stmt, ast.Assign) or not stmt.targets:
        return None
    if isinstance(stmt.value, ast.Constant) and isinstance(stmt.value.value, str) and stmt.value.value:
        return stmt.value.value
    return None