qparse 0.1.1__tar.gz → 0.1.2__tar.gz

{qparse-0.1.1/qparse.egg-info → qparse-0.1.2}/PKG-INFO

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

{qparse-0.1.1 → qparse-0.1.2}/pyproject.toml

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

{qparse-0.1.1 → qparse-0.1.2}/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.1"
+__version__ = "0.1.2"
 
 __all__ = [
     "MarkdownLoader",

{qparse-0.1.1 → qparse-0.1.2}/qparse/docx_render/docx_render.py

@@ -2,9 +2,8 @@
 
 from pathlib import Path
 from shutil import copy2, rmtree
-from uuid import uuid4
+from tempfile import mkdtemp
 from qparse.markdwon_document import *
-from typing import List
 from .write_buffer import *
 
 class DocxRender():
@@ -17,13 +16,9 @@ class DocxRender():
         self._run_time_dir = None
 
     def __enter__(self):
-        self._run_time_dir = self.src.parent.joinpath(
-            ".qmd_runtime",
-            uuid4().hex
-        )
-        self._run_time_dir.mkdir(parents=True, exist_ok=True)
+        # 用系统临时目录，避免中文工作区路径让 Windows pandoc 找不到图片
+        self._run_time_dir = Path(mkdtemp(prefix="qmd_runtime_"))
         self.render_buffer = DocumentBuffer(self)
-        
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
@@ -36,10 +31,7 @@ class DocxRender():
     @property
     def run_time_dir(self)->Path:
         if self._run_time_dir is None:
-            self._run_time_dir = self.src.parent.joinpath(
-                ".qmd_runtime",
-                uuid4().hex
-            )
+            self._run_time_dir = Path(mkdtemp(prefix="qmd_runtime_"))
         return self._run_time_dir
     @property
     def dist(self):

{qparse-0.1.1 → qparse-0.1.2}/qparse/docx_render/write_buffer.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 from typing import List,Union
 from pathlib import Path
+import os
 import re
 import pypandoc
 from docxcompose.composer import Composer
@@ -12,6 +13,7 @@ from docx.oxml import OxmlElement
 from docx.oxml.ns import qn
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.shared import Inches
+from qparse.utils.path_resolve import rewrite_local_images_for_pandoc
 
 class BaseBuffer():
     
@@ -29,9 +31,42 @@ class BaseBuffer():
     def create_docx_file_path(self):
         return self.create_temp_file_path(f".{id(self)}.docx")
     
+    def _localize_images(self, text: str) -> str:
+        cache = getattr(self._render, "_pandoc_image_cache", None)
+        if cache is None:
+            cache = {}
+            self._render._pandoc_image_cache = cache
+        return rewrite_local_images_for_pandoc(text, self._render.run_time_dir, cache)
+
+    def _pandoc_extra_args(self, with_reference: bool = False):
+        runtime = Path(self._render.run_time_dir).resolve()
+        args = [
+            "--mathjax",
+            "--no-highlight",
+            f"--resource-path={runtime}",
+        ]
+        if with_reference:
+            args.append(f"--reference-doc={Path(self.referance_path).as_posix()}")
+        return args
+
+    def _convert_with_pandoc(self, source_file: Path, outputfile: Path, fmt: str, extra_args):
+        old_cwd = os.getcwd()
+        runtime = Path(self._render.run_time_dir).resolve()
+        try:
+            os.chdir(str(runtime))
+            pypandoc.convert_file(
+                source_file=Path(source_file).name,
+                to="docx",
+                format=fmt,
+                outputfile=str(Path(outputfile).resolve()),
+                extra_args=extra_args,
+            )
+        finally:
+            os.chdir(old_cwd)
+
     def write_to_text_file(self):
         fpath= self.create_temp_file_path(".md")
-        fpath.write_text(self.text,encoding='utf-8')
+        fpath.write_text(self._localize_images(self.text), encoding='utf-8')
         return fpath
     def _restore_outer_blank_lines(self, docx_path):
         lines = self.text.splitlines()
@@ -59,16 +94,11 @@ class BaseBuffer():
     def write_to_docx_file(self):
         temp_md_file_path = self.write_to_text_file()
         fpath= self.create_temp_file_path(".docx")
-        pypandoc.convert_file(
-            source_file=temp_md_file_path.as_posix(),
-            to="docx",
-            format="markdown+tex_math_dollars+hard_line_breaks",
-            outputfile=fpath.as_posix(),
-            extra_args=[
-                "--mathjax",
-                "--no-highlight",
-                f"--reference-doc={Path(self.referance_path).as_posix()}"
-            ]
+        self._convert_with_pandoc(
+            temp_md_file_path,
+            fpath,
+            "markdown+tex_math_dollars+hard_line_breaks",
+            self._pandoc_extra_args(with_reference=True),
         )
         self._restore_outer_blank_lines(fpath)
         return fpath
@@ -154,16 +184,11 @@ class MarkdwonTextBuffer(BaseBuffer):
     def write_to_docx_file(self):
         temp_md_file_path = self.write_to_text_file()
         fpath= self.create_temp_file_path(".docx")
-        pypandoc.convert_file(
-            source_file=temp_md_file_path.as_posix(),
-            to="docx",
-            format="markdown+tex_math_dollars+hard_line_breaks",
-            outputfile=fpath.as_posix(),
-            extra_args=[
-                "--mathjax",
-                "--no-highlight",
-                f"--reference-doc={Path(self.referance_path).as_posix()}"
-            ]
+        self._convert_with_pandoc(
+            temp_md_file_path,
+            fpath,
+            "markdown+tex_math_dollars+hard_line_breaks",
+            self._pandoc_extra_args(with_reference=True),
         )
         self._restore_outer_blank_lines(fpath)
         self._adjust_tables(fpath)
@@ -196,12 +221,7 @@ class HtmlTextBuffer(MarkdwonTextBuffer):
     
     def write_to_text_file(self):
         fpath= self.create_temp_file_path(".html")
-        fpath.write_text(self.text,encoding='utf-8')
-        return fpath
-
-    def write_to_text_file(self):
-        fpath= self.create_temp_file_path(".html")
-        fpath.write_text(self.text,encoding='utf-8')
+        fpath.write_text(self._localize_images(self.text), encoding='utf-8')
         return fpath
 
     def write_to_docx_file(self):
@@ -214,7 +234,7 @@ class HtmlTextBuffer(MarkdwonTextBuffer):
             to="docx",
             format="html+tex_math_dollars",
             outputfile=fpath.as_posix(),
-            extra_args=["--mathjax", "--no-highlight"]
+            extra_args=self._pandoc_extra_args(with_reference=False),
         )
         return fpath
 class TableHtmlTextBuffer(HtmlTextBuffer):
@@ -286,16 +306,11 @@ class TableHtmlTextBuffer(HtmlTextBuffer):
     def write_to_docx_file(self):
         temp_html_file_path = self.write_to_text_file()
         fpath = self.create_docx_file_path()
-        pypandoc.convert_file(
-            source_file=temp_html_file_path.as_posix(),
-            to="docx",
-            format="html+tex_math_dollars",
-            outputfile=fpath.as_posix(),
-            extra_args=[
-                "--mathjax",
-                "--no-highlight",
-                f"--reference-doc={Path(self.referance_path).as_posix()}"
-            ]
+        self._convert_with_pandoc(
+            temp_html_file_path,
+            fpath,
+            "html+tex_math_dollars",
+            self._pandoc_extra_args(with_reference=True),
         )
         self._adjust_docx(fpath)
         return fpath

{qparse-0.1.1 → qparse-0.1.2}/qparse/markdwon_document/nodes/img_node.py

@@ -3,6 +3,7 @@ from bs4 import BeautifulSoup,element
 from typing import Union
 import copy
 from .base_node import BaseNode
+from qparse.utils.path_resolve import to_pandoc_local_url
 
 class ImgNode(BaseNode):
     def __init__(self, node, render_option):
@@ -14,7 +15,11 @@ class ImgNode(BaseNode):
         return None
     
     def dump_soup(self):
-        return copy.deepcopy(self._soup)
+        soup = copy.deepcopy(self._soup)
+        src = soup.attrs.get("src", "")
+        if src:
+            soup.attrs["src"] = to_pandoc_local_url(src)
+        return soup
     def dump_markdwon(self):
         alt = self._soup.attrs.get("alt", "")
         src = self._soup.attrs.get("src", "")
@@ -23,9 +28,17 @@ class ImgNode(BaseNode):
         if not src:
             return ""
 
+        src_out = to_pandoc_local_url(src)
+        src_out = f"<{src_out}>" if (" " in src_out or "\\" in src_out) else src_out
         if title:
-            return f'![{alt}]({src} "{title}")'
-        return f'![{alt}]({src})'
+            return f'![{alt}]({src_out} "{title}")'
+        return f'![{alt}]({src_out})'
+
+    def dump_docx_buffer(self):
+        text = self.dump_markdwon()
+        if not text:
+            return []
+        return [{'type': 'markdwonText', 'text': text}]
     
     
     

{qparse-0.1.1 → qparse-0.1.2}/qparse/markdwon_loader.py

@@ -1,189 +1,192 @@
-# -*- coding: utf-8 -*-
-from __future__ import annotations
-
-from cgitb import text
-import re,copy
-from pathlib import Path
-
-from bs4 import BeautifulSoup, element
-
-from .utils import HtmlFullProtector
-
-
-class MarkdownLoader:
-    def __init__(self, src: str):
-        self._src = Path(src)
-        self._protector = HtmlFullProtector()
-        self._reference_answer = BeautifulSoup("<div></div>", "html.parser").div
-
-    def _read_text(self, path: Path) -> str:
-        return path.read_text(encoding="utf-8")
-
-    def _to_absolute_url(self, raw_url: str, base_dir: Path) -> str:
-        url = raw_url.strip().strip('"').strip("'")
-        if re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", url) or url.startswith("/"):
-            return url
-        return str((base_dir / url).resolve())
-
-    def _replace_images(self, text: str, base_dir: Path) -> str:
-        pattern = re.compile(r'!\[([^\]]*)\]\(([^)]+)\)')
-
-        def repl(match: re.Match) -> str:
-            alt = match.group(1)
-            url = self._to_absolute_url(match.group(2), base_dir)
-            return f'<img alt="{alt}" src="{url}" />'
-
-        return pattern.sub(repl, text)
-
-    def _replace_imports(self, text: str, base_dir: Path) -> str:
-        pattern = re.compile(r'^\s*@import\s+["\']([^"\']+)["\']\s*$', re.MULTILINE)
-
-        def repl(match: re.Match) -> str:
-            url = self._to_absolute_url(match.group(1), base_dir)
-            return f'<markdwon src="{url}"></markdwon>'
-
-        return pattern.sub(repl, text)
-
-    def _load_markdown(self, path: Path) -> str:
-        base_dir = path.resolve().parent
-        text = self._read_text(path.resolve())
-        text = self._replace_images(text, base_dir)
-        text = self._replace_imports(text, base_dir)
-        return text
-
-    def _expand_imports(self, soup: BeautifulSoup, current_path: Path, stack: set[Path] | None = None, depth: int = 0) -> None:
-        stack = set() if stack is None else stack
-        current_resolved = current_path.resolve()
-        if current_resolved in stack:
-            return
-        stack.add(current_resolved)
-
-        # 给根 soup 加上 depth 属性！如果是根的话 depth 是 0！
-        if hasattr(soup, "markdwon_depth"):
-            soup.markdwon_depth = depth
-        else:
-            # 对于 BeautifulSoup 根，我们给根的标签（如果是 markdwon 的话）加 depth
-            if soup.contents and hasattr(soup.contents[0], "name") and soup.contents[0].name == "markdwon":
-                soup.contents[0]["depth"] = depth
-
-        for node in list(soup.find_all("markdwon")):
-            src = node.get("src")
-            if not src:
-                continue
-
-            imported_path = Path(src).resolve()
-            if imported_path in stack:
-                node["error"] = "circular import"
-                continue
-
-            if not imported_path.exists():
-                node["error"] = "import not found"
-                continue
-
-            # 这个 markdwon 标签应该是 depth + 1
-            node["depth"] = depth + 1
-            imported_markdown = self._load_markdown(imported_path)
-            protected = self._protector.encode(imported_markdown)
-            decoded = self._protector.decode_to_html_entity(protected)
-            imported_soup = BeautifulSoup(decoded, "html.parser")
-            self._expand_imports(imported_soup, imported_path, stack, depth + 1)
-            node.clear()
-            node.extend(list(imported_soup.contents))
-
-        stack.remove(current_resolved)
-
-    def _decorate_questions(self, soup: BeautifulSoup) -> None:
-        answer_class_map = {
-            "chiose": "choice",
-            "multiple-choice": "multiple-choice",
-            "multiple-chiose": "multiple-choice",
-            "blank": "blank",
-            "answer": "answer",
-        }
-
-        for question_id, question in enumerate(soup.find_all("question"), start=1):
-            answer_types = []
-            question["question_id"] = str(question_id)
-
-            for span in question.find_all("span"):
-                class_list = span.get("class", [])
-                for class_name in class_list:
-                    answer_type = answer_class_map.get(class_name)
-                    if not answer_type:
-                        continue
-                    span["type"] = "answer"
-                    if answer_type not in answer_types:
-                        answer_types.append(answer_type)
-
-            if answer_types:
-                question["answer_types"] = ",".join(answer_types)
-
-    def get_soup(self) -> BeautifulSoup:
-        markdown = self._load_markdown(self._src)
-        protected = self._protector.encode(markdown)
-        decoded = self._protector.decode_to_html_entity(protected)
-        root_src = str(self._src.resolve())
-        wrapped = f'<markdwon src="{root_src}" depth="0">{decoded}</markdwon>'
-        soup = BeautifulSoup(wrapped, "html.parser")
-        self._expand_imports(soup, self._src, set(), depth=0)
-        self._decorate_questions(soup)
-        
-        return copy.deepcopy(soup.select_one('markdwon'))
-
-    def get_reference_answer_markdwon(self) -> str:
-        lines = []
-        table_header = []
-        table_answers = []
-
-        def flush_table():
-            nonlocal table_header, table_answers
-            if not table_header:
-                return
-            lines.append("| " + " | ".join(table_header) + " |")
-            lines.append("| " + " | ".join(["---"] * len(table_header)) + " |")
-            lines.append("| " + " | ".join(table_answers) + " |")
-            lines.append("")
-            table_header = []
-            table_answers = []
-
-        soup = self.get_soup()
-
-        for question in soup.find_all("question"):
-            answer_nodes = question.find_all(
-                "span",
-                attrs={"type": "answer"}
-            )
-            if not answer_nodes:
-                continue
-
-            answer = "".join(
-                answer_node.get_text()
-                for answer_node in answer_nodes
-            )
-            answer_question = answer_nodes[0].find_parent("question")
-            if answer_question is None:
-                continue
-
-            question_id = answer_question.get("question_id", "")
-            answer_types = set(
-                answer_type.strip()
-                for answer_type in answer_question.get(
-                    "answer_types",
-                    ""
-                ).split(",")
-                if answer_type.strip()
-            )
-
-            if "answer" in answer_types:
-                flush_table()
-                lines.append(f"{question_id}、{answer}")
-                lines.append("")
-                continue
-
-            table_header.append(question_id)
-            table_answers.append(answer)
-
-        flush_table()
-        return "\n".join(lines).rstrip() + "\n"
-
-
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from cgitb import text
+import re,copy
+from pathlib import Path
+
+from bs4 import BeautifulSoup, element
+
+from .utils import HtmlFullProtector, is_remote_url, resolve_resource_path
+
+
+class MarkdownLoader:
+    def __init__(self, src: str):
+        self._src = Path(src)
+        self._protector = HtmlFullProtector()
+        self._reference_answer = BeautifulSoup("<div></div>", "html.parser").div
+
+    def _read_text(self, path: Path) -> str:
+        return path.read_text(encoding="utf-8")
+
+    def _to_absolute_url(self, raw_url: str, base_dir: Path) -> str:
+        url = raw_url.strip().strip('"').strip("'")
+        if is_remote_url(url):
+            return url
+        try:
+            return resolve_resource_path(url, base_dir).as_posix()
+        except ValueError:
+            return url
+
+    def _replace_images(self, text: str, base_dir: Path) -> str:
+        pattern = re.compile(r'!\[([^\]]*)\]\(([^)]+)\)')
+
+        def repl(match: re.Match) -> str:
+            alt = match.group(1)
+            url = self._to_absolute_url(match.group(2), base_dir)
+            return f'<img alt="{alt}" src="{url}" />'
+
+        return pattern.sub(repl, text)
+
+    def _replace_imports(self, text: str, base_dir: Path) -> str:
+        pattern = re.compile(r'^\s*@import\s+["\']([^"\']+)["\']\s*$', re.MULTILINE)
+
+        def repl(match: re.Match) -> str:
+            url = self._to_absolute_url(match.group(1), base_dir)
+            return f'<markdwon src="{url}"></markdwon>'
+
+        return pattern.sub(repl, text)
+
+    def _load_markdown(self, path: Path) -> str:
+        base_dir = path.resolve().parent
+        text = self._read_text(path.resolve())
+        text = self._replace_images(text, base_dir)
+        text = self._replace_imports(text, base_dir)
+        return text
+
+    def _expand_imports(self, soup: BeautifulSoup, current_path: Path, stack: set[Path] | None = None, depth: int = 0) -> None:
+        stack = set() if stack is None else stack
+        current_resolved = current_path.resolve()
+        if current_resolved in stack:
+            return
+        stack.add(current_resolved)
+
+        # 给根 soup 加上 depth 属性！如果是根的话 depth 是 0！
+        if hasattr(soup, "markdwon_depth"):
+            soup.markdwon_depth = depth
+        else:
+            # 对于 BeautifulSoup 根，我们给根的标签（如果是 markdwon 的话）加 depth
+            if soup.contents and hasattr(soup.contents[0], "name") and soup.contents[0].name == "markdwon":
+                soup.contents[0]["depth"] = depth
+
+        for node in list(soup.find_all("markdwon")):
+            src = node.get("src")
+            if not src:
+                continue
+
+            imported_path = Path(src).resolve()
+            if imported_path in stack:
+                node["error"] = "circular import"
+                continue
+
+            if not imported_path.exists():
+                node["error"] = "import not found"
+                continue
+
+            # 这个 markdwon 标签应该是 depth + 1
+            node["depth"] = depth + 1
+            imported_markdown = self._load_markdown(imported_path)
+            protected = self._protector.encode(imported_markdown)
+            decoded = self._protector.decode_to_html_entity(protected)
+            imported_soup = BeautifulSoup(decoded, "html.parser")
+            self._expand_imports(imported_soup, imported_path, stack, depth + 1)
+            node.clear()
+            node.extend(list(imported_soup.contents))
+
+        stack.remove(current_resolved)
+
+    def _decorate_questions(self, soup: BeautifulSoup) -> None:
+        answer_class_map = {
+            "chiose": "choice",
+            "multiple-choice": "multiple-choice",
+            "multiple-chiose": "multiple-choice",
+            "blank": "blank",
+            "answer": "answer",
+        }
+
+        for question_id, question in enumerate(soup.find_all("question"), start=1):
+            answer_types = []
+            question["question_id"] = str(question_id)
+
+            for span in question.find_all("span"):
+                class_list = span.get("class", [])
+                for class_name in class_list:
+                    answer_type = answer_class_map.get(class_name)
+                    if not answer_type:
+                        continue
+                    span["type"] = "answer"
+                    if answer_type not in answer_types:
+                        answer_types.append(answer_type)
+
+            if answer_types:
+                question["answer_types"] = ",".join(answer_types)
+
+    def get_soup(self) -> BeautifulSoup:
+        markdown = self._load_markdown(self._src)
+        protected = self._protector.encode(markdown)
+        decoded = self._protector.decode_to_html_entity(protected)
+        root_src = str(self._src.resolve())
+        wrapped = f'<markdwon src="{root_src}" depth="0">{decoded}</markdwon>'
+        soup = BeautifulSoup(wrapped, "html.parser")
+        self._expand_imports(soup, self._src, set(), depth=0)
+        self._decorate_questions(soup)
+        
+        return copy.deepcopy(soup.select_one('markdwon'))
+
+    def get_reference_answer_markdwon(self) -> str:
+        lines = []
+        table_header = []
+        table_answers = []
+
+        def flush_table():
+            nonlocal table_header, table_answers
+            if not table_header:
+                return
+            lines.append("| " + " | ".join(table_header) + " |")
+            lines.append("| " + " | ".join(["---"] * len(table_header)) + " |")
+            lines.append("| " + " | ".join(table_answers) + " |")
+            lines.append("")
+            table_header = []
+            table_answers = []
+
+        soup = self.get_soup()
+
+        for question in soup.find_all("question"):
+            answer_nodes = question.find_all(
+                "span",
+                attrs={"type": "answer"}
+            )
+            if not answer_nodes:
+                continue
+
+            answer = "".join(
+                answer_node.get_text()
+                for answer_node in answer_nodes
+            )
+            answer_question = answer_nodes[0].find_parent("question")
+            if answer_question is None:
+                continue
+
+            question_id = answer_question.get("question_id", "")
+            answer_types = set(
+                answer_type.strip()
+                for answer_type in answer_question.get(
+                    "answer_types",
+                    ""
+                ).split(",")
+                if answer_type.strip()
+            )
+
+            if "answer" in answer_types:
+                flush_table()
+                lines.append(f"{question_id}、{answer}")
+                lines.append("")
+                continue
+
+            table_header.append(question_id)
+            table_answers.append(answer)
+
+        flush_table()
+        return "\n".join(lines).rstrip() + "\n"
+
+

{qparse-0.1.1 → qparse-0.1.2}/qparse/markdwon_render.py

@@ -8,6 +8,7 @@ from .docx_render import DocxRender
 from .markdwon_document import MarkdwonDocument
 from bs4 import BeautifulSoup,element
 from typing import Union
+from .utils.path_resolve import resolve_resource_path
 
 class RenderToEnum(Enum):
     docx = 'docx'
@@ -35,10 +36,7 @@ class MarkdwonRender():
         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()
+        return resolve_resource_path(raw, self._src.parent)
     @property
     def soup(self):
         return copy.deepcopy(self._markdwon_soup) 

{qparse-0.1.1 → qparse-0.1.2}/qparse/qmd_packer.py

@@ -427,15 +427,11 @@ class QmdPacker:
         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()
+        return resolve_resource_path(raw, base_dir, workspace_root=self.workspace_root)
 
     @staticmethod
     def _is_remote_url(url: str) -> bool:
-        return bool(re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", url))
+        return is_remote_url(url)
 
     @staticmethod
     def _to_posix(path: Path | str) -> str:

qparse-0.1.2/qparse/utils/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+from .html_full_protector import HtmlFullProtector
+from .path_resolve import (
+    find_workspace_root,
+    is_posix_root_relative,
+    is_remote_url,
+    is_windows_absolute,
+    local_path_from_src,
+    resolve_resource_path,
+    rewrite_local_images_for_pandoc,
+    to_pandoc_local_url,
+)
+
+__all__ = [
+    "HtmlFullProtector",
+    "find_workspace_root",
+    "is_posix_root_relative",
+    "is_remote_url",
+    "is_windows_absolute",
+    "local_path_from_src",
+    "resolve_resource_path",
+    "rewrite_local_images_for_pandoc",
+    "to_pandoc_local_url",
+]
+

qparse-0.1.2/qparse/utils/path_resolve.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+"""解析 Markdown 资源路径。
+
+约定：
+- http(s):// 等协议 URL 视为远程，不解析成本地路径
+- Windows 盘符 / UNC 才是真正的绝对路径
+- 以 / 开头、无盘符的 POSIX 风格路径（如 /assets/foo.png）视为工作区根相对路径
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+_REMOTE_URL_RE = re.compile(r"^[a-zA-Z][a-zA-Z0-9+.-]*://")
+_WIN_DRIVE_RE = re.compile(r"^[a-zA-Z]:[\\/]")
+
+
+def is_remote_url(url: str) -> bool:
+    return bool(_REMOTE_URL_RE.match((url or "").strip()))
+
+
+def is_windows_absolute(url: str) -> bool:
+    value = (url or "").strip()
+    if _WIN_DRIVE_RE.match(value):
+        return True
+    return value.startswith("\\\\") or value.startswith("//")
+
+
+def is_posix_root_relative(url: str) -> bool:
+    value = (url or "").strip()
+    if not value.startswith("/"):
+        return False
+    if is_remote_url(value) or is_windows_absolute(value):
+        return False
+    return True
+
+
+def find_workspace_root(start: Path) -> Path:
+    """从当前文件/目录向上查找工作区根（含 render.md 或 *.code-workspace）。"""
+    start = Path(start).resolve()
+    if start.is_file():
+        start = start.parent
+    for parent in [start, *start.parents]:
+        if (parent / "render.md").is_file():
+            return parent
+        if any(parent.glob("*.code-workspace")):
+            return parent
+    return start
+
+
+def to_pandoc_local_url(raw: str) -> str:
+    """把本地绝对路径转成 pandoc 能识别的 file:/// URI。
+
+    Windows 上 ``E:/foo.png`` 会被 pandoc 当成协议 ``E:``，导致丢图。
+    注意：Windows pandoc 对百分号编码的 file:/// 仍可能失败，导出时应再走
+    ``rewrite_local_images_for_pandoc`` 拷到临时目录用相对路径。
+    """
+    value = (raw or "").strip().strip('"').strip("'").strip("<>")
+    if not value:
+        return raw or ""
+    if is_remote_url(value) or value.lower().startswith("file:"):
+        return value
+    if is_windows_absolute(value) or Path(value).is_absolute():
+        try:
+            return Path(value).resolve().as_uri()
+        except Exception:
+            posix = Path(value).as_posix()
+            if not posix.startswith("/"):
+                posix = "/" + posix
+            return "file://" + posix
+    return value
+
+
+def local_path_from_src(raw: str) -> Optional[Path]:
+    """从 markdown/html 的 src 解析出存在的本地文件路径。"""
+    value = (raw or "").strip().strip('"').strip("'").strip("<>")
+    if not value:
+        return None
+    try:
+        if value.lower().startswith("file:"):
+            from urllib.parse import unquote, urlparse
+
+            parsed = urlparse(value)
+            path = unquote(parsed.path or "")
+            netloc = unquote(parsed.netloc or "")
+            if netloc and netloc.lower() not in ("localhost", "127.0.0.1"):
+                path = f"//{netloc}{path}"
+            elif re.match(r"^/[A-Za-z]:", path):
+                path = path[1:]
+            candidate = Path(path)
+        elif is_remote_url(value):
+            return None
+        else:
+            candidate = Path(value)
+        if candidate.exists() and candidate.is_file():
+            return candidate.resolve()
+    except Exception:
+        return None
+    return None
+
+
+_MD_IMG_RE = re.compile(
+    r"!\[([^\]]*)\]\(\s*<?([^>\s)]+)>?(?:\s+\"([^\"]*)\")?\s*\)"
+)
+_HTML_SRC_RE = re.compile(
+    r'(<img\b[^>]*?\bsrc\s*=\s*["\'])([^"\']+)(["\'])',
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+def rewrite_local_images_for_pandoc(
+    text: str,
+    dest_dir: Path,
+    cache: Optional[dict] = None,
+) -> str:
+    """把文本里的本地图片拷到 dest_dir，并改成 ``img_0001.png`` 相对路径。
+
+    Windows 上 pandoc 无法可靠打开盘符路径或百分号编码的 file:/// URI。
+    """
+    from shutil import copy2
+
+    if not text:
+        return text
+    dest_dir = Path(dest_dir)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    copied = cache if cache is not None else {}
+
+    def localize(src: str) -> str:
+        path = local_path_from_src(src)
+        if path is None:
+            return src
+        key = str(path)
+        if key in copied:
+            return copied[key]
+        suffix = path.suffix.lower()
+        if not re.match(r"^\.[a-z0-9]{1,8}$", suffix):
+            suffix = ".png"
+        name = f"img_{len(copied) + 1:04d}{suffix}"
+        target = dest_dir / name
+        try:
+            copy2(path, target)
+        except Exception:
+            return src
+        # 不要带 ./ ：pandoc 会把 ./foo 只当成 cwd 相对路径，搜不到 --resource-path
+        copied[key] = name
+        return name
+
+    def md_repl(match: re.Match) -> str:
+        alt, src, title = match.group(1), match.group(2), match.group(3)
+        new_src = localize(src)
+        if title:
+            return f'![{alt}]({new_src} "{title}")'
+        return f"![{alt}]({new_src})"
+
+    def html_repl(match: re.Match) -> str:
+        return f"{match.group(1)}{localize(match.group(2))}{match.group(3)}"
+
+    text = _MD_IMG_RE.sub(md_repl, text)
+    text = _HTML_SRC_RE.sub(html_repl, text)
+    return text
+
+
+def resolve_resource_path(
+    raw: str,
+    base_dir: Path,
+    workspace_root: Optional[Path] = None,
+) -> Path:
+    """把 markdown 中的本地资源路径解析成绝对 Path。"""
+    value = (raw or "").strip().strip('"').strip("'")
+    if " " in value and not value.startswith("<"):
+        value = value.split(" ", 1)[0]
+    value = value.strip("<>")
+    if not value:
+        raise ValueError("empty resource path")
+    if is_remote_url(value):
+        raise ValueError(f"remote url: {value}")
+    if is_windows_absolute(value):
+        return Path(value).resolve()
+    if is_posix_root_relative(value):
+        root = Path(workspace_root).resolve() if workspace_root else find_workspace_root(base_dir)
+        candidate = (root / value.lstrip("/")).resolve()
+        if candidate.exists():
+            return candidate
+        alt = (Path(base_dir) / value.lstrip("/")).resolve()
+        if alt.exists():
+            return alt
+        return candidate
+    return (Path(base_dir) / value).resolve()

{qparse-0.1.1 → qparse-0.1.2/qparse.egg-info}/PKG-INFO

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

{qparse-0.1.1 → qparse-0.1.2}/qparse.egg-info/SOURCES.txt

@@ -36,4 +36,5 @@ qparse/render_option/default_render_template.md
 qparse/render_option/referance.docx
 qparse/render_option/theme.json
 qparse/utils/__init__.py
-qparse/utils/html_full_protector.py
+qparse/utils/html_full_protector.py
+qparse/utils/path_resolve.py

qparse-0.1.1/qparse/utils/__init__.py

@@ -1,3 +0,0 @@
-# -*- coding: utf-8 -*-
-from .html_full_protector import HtmlFullProtector
-