qparse 0.1.0__py3-none-any.whl

qparse/markdwon_render.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+from enum import Enum
+import json,copy
+from pathlib import Path
+from .render_option import get_default_render_option,get_default_theme
+from .markdwon_loader import MarkdownLoader
+from .docx_render import DocxRender
+from .markdwon_document import MarkdwonDocument
+from bs4 import BeautifulSoup,element
+from typing import Union
+
+class RenderToEnum(Enum):
+    docx = 'docx'
+    markdwon = 'markdwon'
+
+class MarkdwonRender():
+
+    def __init__(self,src:str):
+        self._src = src
+        self.__initialize__()
+        
+    def __initialize__(self):
+        self._src = Path(self._src).resolve()
+        self._render_soup = MarkdownLoader(str(self._src)).get_soup().select_one('render')
+        self._mdsrc = self._resolve_path(self._render_soup.attrs['src'])
+        # 初始化主题
+        theme_src = self._render_soup.attrs.get("theme", None)
+        if theme_src:
+            theme_path = self._resolve_path(theme_src)
+            self._theme = json.load(theme_path.open(mode='r', encoding='utf-8'))
+        else:
+            self._theme = get_default_theme()
+        #初始化loader
+        self._markdwon_loader = MarkdownLoader(str(self._mdsrc))
+        self._markdwon_soup = self._markdwon_loader.get_soup()
+
+    def _resolve_path(self, raw: str) -> Path:
+        path = Path(raw)
+        if not path.is_absolute():
+            path = self._src.parent / path
+        return path.resolve()
+    @property
+    def soup(self):
+        return copy.deepcopy(self._markdwon_soup) 
+    def _parse_file_node(self,node:element.Tag):
+        source_soup = self.soup
+        output_soup = BeautifulSoup(
+            f'<markdwon src="{self._mdsrc.resolve()}"></markdwon>',
+            'html.parser'
+        )
+        output = output_soup.markdwon
+        doc_node = node.find('doc', recursive=False)
+
+        before = doc_node.find('before', recursive=False) if doc_node else None
+        after = doc_node.find('after', recursive=False) if doc_node else None
+
+        if before is not None:
+            output.extend(self._translate_content(before))
+
+        output.extend(list(source_soup.contents))
+
+        if after is not None:
+            output.extend(self._translate_content(after))
+
+        return output
+
+    def _translate_content(self, container:element.Tag):
+        contents = []
+        protector = self._markdwon_loader._protector
+
+        for child in container.contents:
+            if isinstance(child, element.Tag) and child.name == 'reference-answer':
+                reference_answer = (
+                    self._markdwon_loader.get_reference_answer_markdwon()
+                )
+                encoded = protector.encode(reference_answer)
+                decoded = protector.decode_to_html_entity(encoded)
+                contents.extend(
+                    BeautifulSoup(decoded, 'html.parser').contents
+                )
+            else:
+                contents.append(copy.deepcopy(child))
+
+        return contents
+
+    def render(self):
+        outputs = []
+        for file_node in self._render_soup.select('file'):
+            doc_node = file_node.find('doc', recursive=False)
+            if doc_node is None:
+                continue
+
+            theme_name = doc_node.get('theme')
+            render_option = copy.deepcopy(
+                self._theme.get(theme_name, self._theme)
+                if theme_name else self._theme
+            )
+            markdown_node = self._parse_file_node(file_node)
+            markdown_doc = MarkdwonDocument(
+                node=markdown_node,
+                render_option=render_option
+            )
+
+            dist = file_node.get('dist')
+            if dist:
+                dist_path = Path(dist)
+                if not dist_path.is_absolute():
+                    dist_path = Path(self._src).resolve().parent / dist_path
+            else:
+                dist_path = self._mdsrc.with_suffix('.docx')
+
+            with DocxRender(MdDoc=markdown_doc) as doc_render:
+                outputs.append(doc_render.render(dist=str(dist_path)))
+
+        return outputs
+
+    def dev(self):
+        return [
+            self._parse_file_node(filenode)
+            for filenode in self._render_soup.select('file')
+        ]
+        
+         

qparse/qmd_packer.py

@@ -0,0 +1,475 @@
+# -*- coding: utf-8 -*-
+"""将 workspace 中的教案资源打包为 .qmd 文件。"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+
+class QmdPacker:
+    """
+    根据 code-workspace 与入口 render.md 收集 Markdown、图片、主题和模板，
+    将二进制资源按 SHA-256 去重后写入 resources/，并打包成 .qmd。
+    """
+
+    IMAGE_PATTERN = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
+    IMPORT_PATTERN = re.compile(
+        r'^\s*@import\s+["\']([^"\']+)["\']\s*$',
+        re.MULTILINE,
+    )
+    HTML_IMG_PATTERN = re.compile(
+        r'<img\b[^>]*\bsrc\s*=\s*["\']([^"\']+)["\'][^>]*>',
+        re.IGNORECASE,
+    )
+    RENDER_SRC_PATTERN = re.compile(
+        r'(<render\b[^>]*\bsrc\s*=\s*["\'])([^"\']+)(["\'])',
+        re.IGNORECASE,
+    )
+    THEME_SRC_PATTERN = re.compile(
+        r'(theme\s*=\s*["\'])([^"\']+)(["\'])',
+        re.IGNORECASE,
+    )
+
+    TEXT_SUFFIXES = {".md", ".markdown", ".json", ".txt", ".html", ".htm"}
+    BINARY_SUFFIXES = {
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".bmp",
+        ".webp",
+        ".svg",
+        ".docx",
+        ".doc",
+        ".pdf",
+        ".ttf",
+        ".otf",
+        ".woff",
+        ".woff2",
+    }
+
+    def __init__(self, workspace: Optional[str] = None):
+        default_workspace = (
+            Path(__file__).resolve().parents[1] / "QParse.code-workspace"
+        )
+        self.workspace_path = Path(workspace or default_workspace).resolve()
+        if not self.workspace_path.exists():
+            raise FileNotFoundError(f"workspace 不存在: {self.workspace_path}")
+
+        self.workspace_root = self.workspace_path.parent
+        self.folders = self._load_workspace_folders()
+
+        self._resources: Dict[str, dict] = {}
+        self._documents: Dict[str, str] = {}
+        self._document_assets: Dict[str, List[str]] = {}
+        self._path_to_package: Dict[Path, str] = {}
+        self._sha_to_path: Dict[str, Path] = {}
+
+    def pack(
+        self,
+        entry: Optional[str] = None,
+        output: Optional[str] = None,
+    ) -> Path:
+        """
+        打包入口。
+
+        :param entry: render.md 路径，默认使用 workspace 根目录下的 render.md
+        :param output: 输出 .qmd 路径，默认与 entry 同名
+        """
+        entry_path = Path(entry or (self.workspace_root / "render.md")).resolve()
+        if not entry_path.exists():
+            raise FileNotFoundError(f"入口文件不存在: {entry_path}")
+
+        output_path = Path(
+            output or entry_path.with_suffix(".qmd")
+        ).resolve()
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        self._resources.clear()
+        self._documents.clear()
+        self._document_assets.clear()
+        self._path_to_package.clear()
+        self._sha_to_path.clear()
+
+        with tempfile.TemporaryDirectory(prefix="qmd_pack_") as temp_dir:
+            package_root = Path(temp_dir)
+            (package_root / "documents").mkdir(parents=True, exist_ok=True)
+            (package_root / "resources").mkdir(parents=True, exist_ok=True)
+            (package_root / "themes").mkdir(parents=True, exist_ok=True)
+            (package_root / "templates").mkdir(parents=True, exist_ok=True)
+
+            entry_text = entry_path.read_text(encoding="utf-8")
+            document_src = self._extract_render_src(entry_text, entry_path)
+            theme_src = self._extract_theme_src(entry_text, entry_path)
+
+            packaged_docs = self._collect_markdown_tree(document_src)
+            for md_path in packaged_docs:
+                self._package_markdown(md_path, package_root)
+
+            theme_package_path = None
+            if theme_src is not None and theme_src.exists():
+                theme_package_path = self._package_theme(theme_src, package_root)
+
+            template_package_path = self._package_default_template(package_root)
+
+            packaged_entry = self._rewrite_entry(
+                entry_text=entry_text,
+                entry_path=entry_path,
+                document_src=document_src,
+                theme_package_path=theme_package_path,
+            )
+            (package_root / "render.md").write_text(
+                packaged_entry,
+                encoding="utf-8",
+            )
+
+            manifest = {
+                "version": 1,
+                "entry": "render.md",
+                "workspace": {
+                    "path": self._to_posix(self.workspace_path),
+                    "folders": [
+                        {
+                            "name": folder["name"],
+                            "path": self._to_posix(folder["path"]),
+                        }
+                        for folder in self.folders
+                    ],
+                },
+                "documents": self._documents,
+                "document_assets": self._document_assets,
+                "resources": self._resources,
+                "theme": theme_package_path,
+                "template": template_package_path,
+            }
+            (package_root / "manifest.json").write_text(
+                json.dumps(manifest, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+
+            self._zip_directory(package_root, output_path)
+
+        return output_path
+
+    def _load_workspace_folders(self) -> List[dict]:
+        data = json.loads(self.workspace_path.read_text(encoding="utf-8"))
+        folders = []
+        for index, item in enumerate(data.get("folders", [])):
+            raw = item.get("path", ".")
+            folder_path = Path(raw)
+            if not folder_path.is_absolute():
+                folder_path = (self.workspace_root / folder_path).resolve()
+            else:
+                folder_path = folder_path.resolve()
+            name = item.get("name") or folder_path.name or f"folder-{index}"
+            folders.append(
+                {
+                    "name": name,
+                    "path": folder_path,
+                    "index": index,
+                }
+            )
+        if not folders:
+            folders.append(
+                {
+                    "name": self.workspace_root.name,
+                    "path": self.workspace_root,
+                    "index": 0,
+                }
+            )
+        return folders
+
+    def _extract_render_src(self, text: str, base: Path) -> Path:
+        match = re.search(
+            r'<render\b[^>]*\bsrc\s*=\s*["\']([^"\']+)["\']',
+            text,
+            re.IGNORECASE,
+        )
+        if not match:
+            raise ValueError(f"入口文件缺少 <render src=...>: {base}")
+        return self._resolve_path(match.group(1), base.parent)
+
+    def _extract_theme_src(self, text: str, base: Path) -> Optional[Path]:
+        match = re.search(
+            r'<render\b[^>]*\btheme\s*=\s*["\']([^"\']+)["\']',
+            text,
+            re.IGNORECASE,
+        )
+        if not match:
+            return None
+        return self._resolve_path(match.group(1), base.parent)
+
+    def _collect_markdown_tree(self, root: Path) -> List[Path]:
+        result: List[Path] = []
+        stack = [root.resolve()]
+        seen: Set[Path] = set()
+
+        while stack:
+            current = stack.pop()
+            if current in seen:
+                continue
+            seen.add(current)
+            if not current.exists():
+                continue
+            result.append(current)
+            text = current.read_text(encoding="utf-8")
+            for raw in self.IMPORT_PATTERN.findall(text):
+                imported = self._resolve_path(raw, current.parent)
+                if imported.suffix.lower() in {".md", ".markdown"}:
+                    stack.append(imported)
+        return result
+
+    def _package_markdown(self, md_path: Path, package_root: Path) -> str:
+        package_rel = self._document_package_path(md_path)
+        target = package_root / package_rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+        text = md_path.read_text(encoding="utf-8")
+        asset_shas: List[str] = []
+
+        def replace_image(match: re.Match) -> str:
+            alt = match.group(1)
+            raw_url = match.group(2).strip().strip('"').strip("'")
+            title = ""
+            url = raw_url
+            if " " in raw_url:
+                url, title_part = raw_url.split(" ", 1)
+                title = " " + title_part
+            if self._is_remote_url(url):
+                return match.group(0)
+
+            resource_path = self._resolve_path(url, md_path.parent)
+            if not resource_path.exists():
+                return match.group(0)
+
+            sha, package_resource = self._add_resource(resource_path, package_root)
+            if sha not in asset_shas:
+                asset_shas.append(sha)
+            asset_name = Path(package_resource).name
+            return f"![{alt}](./assets/{asset_name}{title})"
+
+        def replace_html_img(match: re.Match) -> str:
+            raw = match.group(0)
+            url = match.group(1)
+            if self._is_remote_url(url):
+                return raw
+            resource_path = self._resolve_path(url, md_path.parent)
+            if not resource_path.exists():
+                return raw
+            sha, package_resource = self._add_resource(resource_path, package_root)
+            if sha not in asset_shas:
+                asset_shas.append(sha)
+            asset_name = Path(package_resource).name
+            return re.sub(
+                r'(src\s*=\s*["\'])([^"\']+)(["\'])',
+                rf'\1./assets/{asset_name}\3',
+                raw,
+                count=1,
+                flags=re.IGNORECASE,
+            )
+
+        def replace_import(match: re.Match) -> str:
+            raw = match.group(1)
+            imported = self._resolve_path(raw, md_path.parent)
+            if not imported.exists():
+                return match.group(0)
+            package_import = self._document_package_path(imported)
+            relative = self._relative_posix(
+                Path(package_rel).parent,
+                Path(package_import),
+            )
+            quote = '"' if '"' in match.group(0) else "'"
+            # 保留原引号风格
+            original = match.group(0)
+            if "'" in original and '"' not in original:
+                quote = "'"
+            else:
+                quote = '"'
+            return f"@import {quote}{relative}{quote}"
+
+        text = self.IMAGE_PATTERN.sub(replace_image, text)
+        text = self.HTML_IMG_PATTERN.sub(replace_html_img, text)
+        text = self.IMPORT_PATTERN.sub(replace_import, text)
+
+        target.write_text(text, encoding="utf-8")
+        original_key = self._to_posix(md_path)
+        self._documents[original_key] = package_rel
+        self._document_assets[package_rel] = asset_shas
+        self._path_to_package[md_path.resolve()] = package_rel
+        return package_rel
+
+    def _package_theme(self, theme_path: Path, package_root: Path) -> str:
+        package_rel = f"themes/{theme_path.name}"
+        target = package_root / package_rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(theme_path, target)
+        return package_rel
+
+    def _package_default_template(self, package_root: Path) -> Optional[str]:
+        template = (
+            Path(__file__).resolve().parent
+            / "render_option"
+            / "referance.docx"
+        )
+        if not template.exists():
+            return None
+        sha, package_rel = self._add_resource(
+            template,
+            package_root,
+            preferred_dir="templates",
+            preferred_name="referance.docx",
+        )
+        return package_rel
+
+    def _add_resource(
+        self,
+        source: Path,
+        package_root: Path,
+        preferred_dir: str = "resources",
+        preferred_name: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        source = source.resolve()
+        data = source.read_bytes()
+        sha = hashlib.sha256(data).hexdigest()
+        if sha in self._resources:
+            return sha, self._resources[sha]["path"]
+
+        suffix = source.suffix.lower() or ""
+        file_name = preferred_name or f"{sha}{suffix}"
+        if preferred_dir == "resources" and preferred_name is None:
+            file_name = f"{sha}{suffix}"
+
+        package_rel = f"{preferred_dir}/{file_name}"
+        target = package_root / package_rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if not target.exists():
+            target.write_bytes(data)
+
+        self._resources[sha] = {
+            "path": package_rel,
+            "sha256": sha,
+            "name": source.name,
+            "original": self._to_posix(source),
+        }
+        self._sha_to_path[sha] = source
+        return sha, package_rel
+
+    def _document_package_path(self, path: Path) -> str:
+        path = path.resolve()
+        if path in self._path_to_package:
+            return self._path_to_package[path]
+
+        folder = self._find_workspace_folder(path)
+        if folder is not None:
+            relative = path.relative_to(folder["path"])
+            package_rel = self._to_posix(
+                Path("documents")
+                / f"{folder['index']}-{folder['name']}"
+                / relative
+            )
+        else:
+            digest = hashlib.sha256(self._to_posix(path).encode("utf-8")).hexdigest()[:12]
+            package_rel = self._to_posix(
+                Path("documents") / "_external" / digest / path.name
+            )
+        self._path_to_package[path] = package_rel
+        return package_rel
+
+    def _find_workspace_folder(self, path: Path) -> Optional[dict]:
+        path = path.resolve()
+        matched = None
+        for folder in self.folders:
+            root = folder["path"]
+            try:
+                path.relative_to(root)
+            except ValueError:
+                continue
+            if matched is None or len(str(root)) > len(str(matched["path"])):
+                matched = folder
+        return matched
+
+    def _rewrite_entry(
+        self,
+        entry_text: str,
+        entry_path: Path,
+        document_src: Path,
+        theme_package_path: Optional[str],
+    ) -> str:
+        document_package = self._document_package_path(document_src)
+
+        def replace_src(match: re.Match) -> str:
+            return f"{match.group(1)}{document_package}{match.group(3)}"
+
+        text = self.RENDER_SRC_PATTERN.sub(replace_src, entry_text, count=1)
+
+        if theme_package_path:
+
+            def replace_theme(match: re.Match) -> str:
+                return f"{match.group(1)}{theme_package_path}{match.group(3)}"
+
+            if re.search(r"\btheme\s*=", text, re.IGNORECASE):
+                text = self.THEME_SRC_PATTERN.sub(replace_theme, text, count=1)
+            else:
+                text = re.sub(
+                    r"(<render\b)",
+                    rf'\1 theme="{theme_package_path}"',
+                    text,
+                    count=1,
+                    flags=re.IGNORECASE,
+                )
+        return text
+
+    def _resolve_path(self, raw: str, base_dir: Path) -> Path:
+        value = raw.strip().strip('"').strip("'")
+        path = Path(value)
+        if path.is_absolute():
+            return path.resolve()
+        return (base_dir / path).resolve()
+
+    @staticmethod
+    def _is_remote_url(url: str) -> bool:
+        return bool(re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", url))
+
+    @staticmethod
+    def _to_posix(path: Path | str) -> str:
+        return Path(path).as_posix()
+
+    @staticmethod
+    def _relative_posix(from_dir: Path, to_path: Path) -> str:
+        from_parts = [part for part in Path(from_dir).as_posix().split("/") if part]
+        to_parts = [part for part in Path(to_path).as_posix().split("/") if part]
+        common = 0
+        for left, right in zip(from_parts, to_parts):
+            if left != right:
+                break
+            common += 1
+        ups = [".."] * (len(from_parts) - common)
+        downs = to_parts[common:]
+        parts = ups + downs
+        if not parts:
+            return "./" + Path(to_path).name
+        result = "/".join(parts)
+        if not result.startswith("."):
+            result = "./" + result
+        return result
+
+    @staticmethod
+    def _zip_directory(source_dir: Path, output_path: Path) -> None:
+        if output_path.exists():
+            output_path.unlink()
+        with zipfile.ZipFile(
+            output_path,
+            mode="w",
+            compression=zipfile.ZIP_DEFLATED,
+        ) as zf:
+            for file_path in sorted(source_dir.rglob("*")):
+                if file_path.is_file():
+                    arcname = file_path.relative_to(source_dir).as_posix()
+                    zf.write(file_path, arcname)