qparse 0.1.6__tar.gz → 0.1.7__tar.gz

{qparse-0.1.6/qparse.egg-info → qparse-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qparse
-Version: 0.1.6
+Version: 0.1.7
 Summary: Structured Markdown lesson plans to DOCX, with .qmd pack/unpack tooling.
 Author: hanbuhuai
 License: MIT

{qparse-0.1.6 → qparse-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qparse"
-version = "0.1.6"
+version = "0.1.7"
 description = "Structured Markdown lesson plans to DOCX, with .qmd pack/unpack tooling."
 readme = "README.md"
 requires-python = ">=3.9"

{qparse-0.1.6 → qparse-0.1.7}/qparse/__init__.py

@@ -4,7 +4,7 @@ from .markdwon_render import MarkdwonRender
 from .qmd_packer import QmdPacker
 from .qmd_unpacker import QmdUnpacker
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 
 __all__ = [
     "MarkdownLoader",

qparse-0.1.7/qparse/qmd_unpacker.py

@@ -0,0 +1,451 @@
+# -*- coding: utf-8 -*-
+"""将 .qmd 文件解包为可编辑的工作目录。"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+from uuid import uuid4
+
+
+class QmdUnpacker:
+    """
+    解压 .qmd 包，并还原为编辑器工作区格式：
+    1. 去掉 documents/{index}-{name}/ 包装，内容提升到根目录
+    2. 图片落到 Markdown 同级 assets/，文件名用打包前的原名
+    3. 把正文里的 ./assets/{sha256} 改回原文件名
+    4. render.md 的 src 改回相对入口
+    5. 生成 QEditor.code-workspace，删除包内部件
+    """
+
+    IMAGE_PATTERN = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
+    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,
+    )
+    DOC_DIR_PATTERN = re.compile(r"^(\d+)-(.+)$")
+    PACKAGE_DIRS = ("documents", "resources", "templates", "themes")
+    PACKAGE_FILES = ("manifest.json",)
+
+    def __init__(self, package: str):
+        self.package_path = Path(package).resolve()
+        if not self.package_path.exists():
+            raise FileNotFoundError(f"qmd 包不存在: {self.package_path}")
+        if not zipfile.is_zipfile(self.package_path):
+            raise ValueError(f"不是有效的 qmd 压缩包: {self.package_path}")
+
+        self.manifest: dict = {}
+        self.target_dir: Optional[Path] = None
+
+    def unpack(self, target: Optional[str] = None) -> Path:
+        """
+        解包到目标目录，并还原成编辑器工作区布局。
+
+        :param target: 目标目录。为空时创建到包旁的 .qmd_runtime/<uuid>
+        :return: 解包后的根目录
+        """
+        if target:
+            self.target_dir = Path(target).resolve()
+        else:
+            self.target_dir = (
+                self.package_path.parent
+                / ".qmd_runtime"
+                / uuid4().hex
+            )
+
+        if self.target_dir.exists():
+            shutil.rmtree(self.target_dir)
+        self.target_dir.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(self.package_path, "r") as zf:
+            zf.extractall(self.target_dir)
+
+        manifest_path = self.target_dir / "manifest.json"
+        if not manifest_path.exists():
+            raise FileNotFoundError(
+                f"缺少 manifest.json: {manifest_path}"
+            )
+        self.manifest = json.loads(
+            manifest_path.read_text(encoding="utf-8")
+        )
+
+        self._restore_editor_layout()
+        return self.target_dir
+
+    @property
+    def entry_path(self) -> Path:
+        if self.target_dir is None:
+            raise RuntimeError("请先调用 unpack()")
+        entry = self.manifest.get("entry", "render.md")
+        path = self.target_dir / Path(entry).name
+        if not path.exists():
+            path = self.target_dir / entry
+        if not path.exists():
+            raise FileNotFoundError(f"入口文件不存在: {path}")
+        return path
+
+    @property
+    def resources_dir(self) -> Path:
+        if self.target_dir is None:
+            raise RuntimeError("请先调用 unpack()")
+        return self.target_dir / "resources"
+
+    def get_resource_path(self, sha256: str) -> Optional[Path]:
+        resources = self.manifest.get("resources", {})
+        item = resources.get(sha256)
+        if not item:
+            return None
+        original_name = item.get("name") or Path(item["path"]).name
+        if self.target_dir is not None:
+            matches = list(self.target_dir.rglob(original_name))
+            for match in matches:
+                if match.is_file() and "assets" in match.parts:
+                    return match
+            packaged = self.target_dir / item["path"]
+            if packaged.exists():
+                return packaged
+        return None
+
+    def _restore_editor_layout(self) -> None:
+        mapping = self._flatten_documents()
+        self._restore_document_assets(mapping)
+        self._restore_entry(mapping)
+        self._write_workspace_file()
+        self._cleanup_package_files()
+
+    def _flatten_documents(self) -> Dict[str, str]:
+        """
+        把 documents/{index}-{name}/ 的内容提升到工作区。
+        只有一个工作区文件夹时提到根目录；多个则提到 {name}/。
+        """
+        if self.target_dir is None:
+            return {}
+        documents = self.target_dir / "documents"
+        if not documents.is_dir():
+            return {}
+
+        roots = self._iter_document_roots(documents)
+        mapping: Dict[str, str] = {}
+        for pkg_name, src_root, dest_prefix in roots:
+            files = [path for path in src_root.rglob("*") if path.is_file()]
+            for file_path in files:
+                rel = file_path.relative_to(src_root).as_posix()
+                dest_rel = f"{dest_prefix}/{rel}" if dest_prefix else rel
+                dest_rel = dest_rel.lstrip("/")
+                mapping[f"documents/{pkg_name}/{rel}"] = dest_rel
+                dest = self.target_dir / dest_rel
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                if dest.exists():
+                    dest.unlink()
+                shutil.move(str(file_path), str(dest))
+        return mapping
+
+    def _iter_document_roots(
+        self, documents: Path
+    ) -> List[Tuple[str, Path, str]]:
+        named: List[Tuple[int, str, Path]] = []
+        external: Optional[Path] = None
+        for child in documents.iterdir():
+            if not child.is_dir():
+                continue
+            if child.name == "_external":
+                external = child
+                continue
+            match = self.DOC_DIR_PATTERN.match(child.name)
+            if match:
+                named.append((int(match.group(1)), match.group(2), child))
+            else:
+                named.append((10_000, child.name, child))
+        named.sort(key=lambda item: item[0])
+
+        lift_to_root = len(named) == 1
+        roots: List[Tuple[str, Path, str]] = []
+        for _index, name, child in named:
+            dest_prefix = "" if lift_to_root else name
+            roots.append((child.name, child, dest_prefix))
+        if external is not None:
+            roots.append(("_external", external, "_external"))
+        return roots
+
+    def _restore_document_assets(self, mapping: Dict[str, str]) -> None:
+        """按原文件名把 resources 拷到对应 Markdown 同级 assets/，并改写引用。"""
+        if self.target_dir is None:
+            return
+        resources: Dict[str, dict] = self.manifest.get("resources", {})
+        document_assets: Dict[str, List[str]] = self.manifest.get(
+            "document_assets",
+            {},
+        )
+        rename = self._build_asset_rename_map(resources)
+
+        if document_assets:
+            for doc_rel, sha_list in document_assets.items():
+                new_rel = mapping.get(doc_rel) or self._strip_documents_prefix(
+                    doc_rel
+                )
+                doc_path = self.target_dir / new_rel
+                if not doc_path.exists():
+                    continue
+                assets_dir = doc_path.parent / "assets"
+                for sha in sha_list:
+                    item = resources.get(sha)
+                    if not item:
+                        continue
+                    self._copy_resource_as_original(item, assets_dir)
+                self._rewrite_md_assets(doc_path, rename)
+            self._purge_packaged_asset_names(rename)
+            return
+
+        for md_path in self.target_dir.rglob("*.md"):
+            if self._is_package_path(md_path):
+                continue
+            names = self._asset_names_in_markdown(md_path)
+            if not names:
+                continue
+            assets_dir = md_path.parent / "assets"
+            for name in names:
+                source = self._find_packaged_resource(name, resources)
+                if source is None:
+                    continue
+                assets_dir.mkdir(parents=True, exist_ok=True)
+                original = rename.get(name, name)
+                target = assets_dir / original
+                if not target.exists():
+                    shutil.copy2(source, target)
+            self._rewrite_md_assets(md_path, rename)
+        self._purge_packaged_asset_names(rename)
+
+    def _copy_resource_as_original(self, item: dict, assets_dir: Path) -> None:
+        if self.target_dir is None:
+            return
+        packaged = (item.get("path") or "").replace("\\", "/")
+        if packaged.startswith("templates/") or packaged.startswith("themes/"):
+            return
+        source = self.target_dir / packaged
+        if not source.exists():
+            return
+        original_name = item.get("name") or Path(packaged).name
+        assets_dir.mkdir(parents=True, exist_ok=True)
+        target = assets_dir / original_name
+        if not target.exists():
+            shutil.copy2(source, target)
+
+    def _build_asset_rename_map(
+        self, resources: Dict[str, dict]
+    ) -> Dict[str, str]:
+        rename: Dict[str, str] = {}
+        for sha, item in resources.items():
+            packaged = (item.get("path") or "").replace("\\", "/")
+            if packaged.startswith("templates/") or packaged.startswith("themes/"):
+                continue
+            packaged_name = Path(packaged).name
+            original_name = item.get("name") or packaged_name
+            if packaged_name != original_name:
+                rename[packaged_name] = original_name
+            suffix = Path(packaged_name).suffix
+            sha_name = f"{sha}{suffix}"
+            if sha_name != original_name:
+                rename[sha_name] = original_name
+        return rename
+
+    def _rewrite_md_assets(self, md_path: Path, rename: Dict[str, str]) -> None:
+        if not rename:
+            return
+        text, newline = self._read_preserved(md_path)
+        rewritten = self._rewrite_asset_refs_in_text(text, rename)
+        if rewritten != text:
+            self._write_preserved(md_path, rewritten, newline)
+
+    def _rewrite_asset_refs_in_text(
+        self, text: str, rename: Dict[str, str]
+    ) -> str:
+        names = [name for name, original in rename.items() if name != original]
+        if not names:
+            return text
+        names.sort(key=len, reverse=True)
+        pattern = re.compile(
+            r"(?P<prefix>(?:\./)?assets[/\\])(?P<name>"
+            + "|".join(re.escape(name) for name in names)
+            + r")"
+        )
+
+        def repl(match: re.Match) -> str:
+            old = match.group("name")
+            return "./assets/" + rename.get(old, old)
+
+        return pattern.sub(repl, text)
+
+    def _purge_packaged_asset_names(self, rename: Dict[str, str]) -> None:
+        if self.target_dir is None or not rename:
+            return
+        packaged_names = set(rename.keys())
+        for assets_dir in self.target_dir.rglob("assets"):
+            if not assets_dir.is_dir() or self._is_package_path(assets_dir):
+                continue
+            for child in list(assets_dir.iterdir()):
+                if child.is_file() and child.name in packaged_names:
+                    child.unlink()
+
+    def _restore_entry(self, mapping: Dict[str, str]) -> None:
+        if self.target_dir is None:
+            return
+        render_path = self.target_dir / Path(
+            self.manifest.get("entry", "render.md")
+        ).name
+        if not render_path.exists():
+            render_path = self.target_dir / self.manifest.get("entry", "render.md")
+        if not render_path.exists():
+            return
+
+        text, newline = self._read_preserved(render_path)
+        original = text
+
+        def replace_src(match: re.Match) -> str:
+            old = match.group(2).replace("\\", "/")
+            new = mapping.get(old) or self._strip_documents_prefix(old)
+            return f"{match.group(1)}{new}{match.group(3)}"
+
+        text = self.RENDER_SRC_PATTERN.sub(replace_src, text, count=1)
+
+        theme_rel = self.manifest.get("theme")
+        if theme_rel:
+            theme_src = self.target_dir / theme_rel
+            if theme_src.exists():
+                dest = self.target_dir / theme_src.name
+                if dest.resolve() != theme_src.resolve():
+                    shutil.copy2(theme_src, dest)
+
+                def replace_theme(match: re.Match) -> str:
+                    old = match.group(2).replace("\\", "/")
+                    if old.startswith("themes/"):
+                        return f"{match.group(1)}{dest.name}{match.group(3)}"
+                    return match.group(0)
+
+                text = self.THEME_SRC_PATTERN.sub(replace_theme, text, count=1)
+
+        if text != original:
+            self._write_preserved(render_path, text, newline)
+
+    def _write_workspace_file(self) -> None:
+        if self.target_dir is None:
+            return
+        existing = list(self.target_dir.glob("*.code-workspace"))
+        if existing:
+            return
+        folders = (self.manifest.get("workspace") or {}).get("folders") or []
+        name = self.target_dir.name
+        if len(folders) == 1 and folders[0].get("name"):
+            name = folders[0]["name"]
+        payload = {
+            "folders": [{"path": str(self.target_dir), "name": name}],
+            "settings": {},
+        }
+        ws_path = self.target_dir / "QEditor.code-workspace"
+        ws_path.write_text(
+            json.dumps(payload, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    def _cleanup_package_files(self) -> None:
+        if self.target_dir is None:
+            return
+        for name in self.PACKAGE_DIRS:
+            path = self.target_dir / name
+            if path.is_dir():
+                shutil.rmtree(path, ignore_errors=True)
+            elif path.is_file():
+                path.unlink()
+        for name in self.PACKAGE_FILES:
+            path = self.target_dir / name
+            if path.exists():
+                path.unlink()
+
+    def _asset_names_in_markdown(self, md_path: Path) -> set:
+        text, _newline = self._read_preserved(md_path)
+        names = set()
+        for match in self.IMAGE_PATTERN.finditer(text):
+            url = match.group(2).strip().split(" ", 1)[0]
+            name = self._asset_name_from_url(url)
+            if name:
+                names.add(name)
+        for match in self.HTML_IMG_PATTERN.finditer(text):
+            name = self._asset_name_from_url(match.group(1))
+            if name:
+                names.add(name)
+        return names
+
+    def _find_packaged_resource(
+        self, name: str, resources: Dict[str, dict]
+    ) -> Optional[Path]:
+        if self.target_dir is None:
+            return None
+        direct = self.resources_dir / name
+        if direct.exists():
+            return direct
+        for _sha, item in resources.items():
+            packaged = (item.get("path") or "").replace("\\", "/")
+            original = item.get("name") or Path(packaged).name
+            if name in {original, Path(packaged).name}:
+                source = self.target_dir / packaged
+                if source.exists():
+                    return source
+        alt = self.target_dir / "templates" / name
+        return alt if alt.exists() else None
+
+    def _is_package_path(self, path: Path) -> bool:
+        if self.target_dir is None:
+            return False
+        try:
+            rel = path.relative_to(self.target_dir)
+        except ValueError:
+            return False
+        parts = rel.parts
+        return bool(parts) and parts[0] in self.PACKAGE_DIRS
+
+    @staticmethod
+    def _strip_documents_prefix(rel: str) -> str:
+        parts = [part for part in Path(rel).as_posix().split("/") if part]
+        if len(parts) >= 2 and parts[0] == "documents":
+            if parts[1] == "_external":
+                return "/".join(parts[1:])
+            return "/".join(parts[2:])
+        return Path(rel).as_posix()
+
+    @staticmethod
+    def _asset_name_from_url(url: str) -> Optional[str]:
+        value = url.strip().strip('"').strip("'")
+        if not value:
+            return None
+        if value.startswith("http://") or value.startswith("https://"):
+            return None
+        path = Path(value.replace("\\", "/"))
+        if path.parts and path.parts[0] in {".", "..", "assets"}:
+            return path.name
+        if "assets/" in value.replace("\\", "/"):
+            return path.name
+        return None
+
+    @staticmethod
+    def _read_preserved(path: Path) -> Tuple[str, str]:
+        data = path.read_bytes()
+        newline = "\r\n" if b"\r\n" in data else "\n"
+        return data.decode("utf-8"), newline
+
+    @staticmethod
+    def _write_preserved(path: Path, text: str, newline: str) -> None:
+        body = text.replace("\r\n", "\n").replace("\r", "\n")
+        if newline == "\r\n":
+            body = body.replace("\n", "\r\n")
+        path.write_bytes(body.encode("utf-8"))

{qparse-0.1.6 → qparse-0.1.7/qparse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qparse
-Version: 0.1.6
+Version: 0.1.7
 Summary: Structured Markdown lesson plans to DOCX, with .qmd pack/unpack tooling.
 Author: hanbuhuai
 License: MIT

qparse-0.1.6/qparse/qmd_unpacker.py

@@ -1,169 +0,0 @@
-# -*- coding: utf-8 -*-
-"""将 .qmd 文件解包为可编辑的工作目录。"""
-
-from __future__ import annotations
-
-import json
-import re
-import shutil
-import zipfile
-from pathlib import Path
-from typing import Dict, List, Optional
-from uuid import uuid4
-
-
-class QmdUnpacker:
-    """
-    解压 .qmd 包：
-    1. 展开 documents / resources / themes / templates
-    2. 按 manifest 将资源复制到对应 Markdown 同级的 assets/
-    3. 返回解包目录与入口 render.md 路径
-    """
-
-    IMAGE_PATTERN = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
-    HTML_IMG_PATTERN = re.compile(
-        r'<img\b[^>]*\bsrc\s*=\s*["\']([^"\']+)["\'][^>]*>',
-        re.IGNORECASE,
-    )
-
-    def __init__(self, package: str):
-        self.package_path = Path(package).resolve()
-        if not self.package_path.exists():
-            raise FileNotFoundError(f"qmd 包不存在: {self.package_path}")
-        if not zipfile.is_zipfile(self.package_path):
-            raise ValueError(f"不是有效的 qmd 压缩包: {self.package_path}")
-
-        self.manifest: dict = {}
-        self.target_dir: Optional[Path] = None
-
-    def unpack(self, target: Optional[str] = None) -> Path:
-        """
-        解包到目标目录。
-
-        :param target: 目标目录。为空时创建到包旁的 .qmd_runtime/<uuid>
-        :return: 解包后的根目录
-        """
-        if target:
-            self.target_dir = Path(target).resolve()
-        else:
-            self.target_dir = (
-                self.package_path.parent
-                / ".qmd_runtime"
-                / uuid4().hex
-            )
-
-        if self.target_dir.exists():
-            shutil.rmtree(self.target_dir)
-        self.target_dir.mkdir(parents=True, exist_ok=True)
-
-        with zipfile.ZipFile(self.package_path, "r") as zf:
-            zf.extractall(self.target_dir)
-
-        manifest_path = self.target_dir / "manifest.json"
-        if not manifest_path.exists():
-            raise FileNotFoundError(
-                f"缺少 manifest.json: {manifest_path}"
-            )
-        self.manifest = json.loads(
-            manifest_path.read_text(encoding="utf-8")
-        )
-
-        self._materialize_document_assets()
-        return self.target_dir
-
-    @property
-    def entry_path(self) -> Path:
-        if self.target_dir is None:
-            raise RuntimeError("请先调用 unpack()")
-        entry = self.manifest.get("entry", "render.md")
-        path = self.target_dir / entry
-        if not path.exists():
-            raise FileNotFoundError(f"入口文件不存在: {path}")
-        return path
-
-    @property
-    def resources_dir(self) -> Path:
-        if self.target_dir is None:
-            raise RuntimeError("请先调用 unpack()")
-        return self.target_dir / "resources"
-
-    def get_resource_path(self, sha256: str) -> Optional[Path]:
-        resources = self.manifest.get("resources", {})
-        item = resources.get(sha256)
-        if not item:
-            return None
-        path = self.target_dir / item["path"]
-        return path if path.exists() else None
-
-    def _materialize_document_assets(self) -> None:
-        """
-        按需将 resources 中的文件复制到文档同级 assets/，
-        方便编辑器直接预览图片。
-        """
-        document_assets: Dict[str, List[str]] = self.manifest.get(
-            "document_assets",
-            {},
-        )
-        resources: Dict[str, dict] = self.manifest.get("resources", {})
-
-        if document_assets:
-            for doc_rel, sha_list in document_assets.items():
-                doc_path = self.target_dir / doc_rel
-                if not doc_path.exists():
-                    continue
-                assets_dir = doc_path.parent / "assets"
-                assets_dir.mkdir(parents=True, exist_ok=True)
-                for sha in sha_list:
-                    item = resources.get(sha)
-                    if not item:
-                        continue
-                    source = self.target_dir / item["path"]
-                    if not source.exists():
-                        continue
-                    target = assets_dir / Path(item["path"]).name
-                    if not target.exists():
-                        shutil.copy2(source, target)
-            return
-
-        # 兼容没有 document_assets 字段的旧包：扫描 Markdown 中的 ./assets/ 引用
-        for md_path in self.target_dir.rglob("*.md"):
-            text = md_path.read_text(encoding="utf-8")
-            names = set()
-            for match in self.IMAGE_PATTERN.finditer(text):
-                url = match.group(2).strip().split(" ", 1)[0]
-                name = self._asset_name_from_url(url)
-                if name:
-                    names.add(name)
-            for match in self.HTML_IMG_PATTERN.finditer(text):
-                name = self._asset_name_from_url(match.group(1))
-                if name:
-                    names.add(name)
-            if not names:
-                continue
-
-            assets_dir = md_path.parent / "assets"
-            assets_dir.mkdir(parents=True, exist_ok=True)
-            for name in names:
-                source = self.resources_dir / name
-                if not source.exists():
-                    # 也可能在 templates/
-                    alt = self.target_dir / "templates" / name
-                    source = alt if alt.exists() else source
-                if source.exists():
-                    target = assets_dir / name
-                    if not target.exists():
-                        shutil.copy2(source, target)
-
-    @staticmethod
-    def _asset_name_from_url(url: str) -> Optional[str]:
-        value = url.strip().strip('"').strip("'")
-        if not value:
-            return None
-        if value.startswith("http://") or value.startswith("https://"):
-            return None
-        path = Path(value.replace("\\", "/"))
-        if path.parts and path.parts[0] in {".", "..", "assets"}:
-            return path.name
-        if "assets/" in value.replace("\\", "/"):
-            return path.name
-        return None