qparse 0.1.0__py3-none-any.whl

qparse/docx_render/write_buffer.py

@@ -0,0 +1,412 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+from typing import List,Union
+from pathlib import Path
+import re
+import pypandoc
+from docxcompose.composer import Composer
+from bs4 import BeautifulSoup
+from docx import Document
+from docx.enum.table import WD_CELL_VERTICAL_ALIGNMENT
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.shared import Inches
+
+class BaseBuffer():
+    
+    def __init__(self,render):
+        self._render = render
+    @property
+    def referance_path(self)->Path:
+        return self._render.referance_path
+    def validate_concatenate(self,value:BaseBuffer):
+        if type(value) is self.__class__:
+            return True
+    def create_temp_file_path(self,fext:str)->Path:
+        return self._render.create_temp_file_path(fext)
+
+    def create_docx_file_path(self):
+        return self.create_temp_file_path(f".{id(self)}.docx")
+    
+    def write_to_text_file(self):
+        fpath= self.create_temp_file_path(".md")
+        fpath.write_text(self.text,encoding='utf-8')
+        return fpath
+    def _restore_outer_blank_lines(self, docx_path):
+        lines = self.text.splitlines()
+        leading_count = next(
+            (index for index, line in enumerate(lines) if line.strip()),
+            len(lines)
+        )
+        trailing_count = next(
+            (index for index, line in enumerate(reversed(lines)) if line.strip()),
+            len(lines)
+        )
+        if not leading_count and not trailing_count:
+            return
+
+        document = Document(docx_path)
+        # first_paragraph = document.paragraphs[0] if document.paragraphs else None
+        # for _ in range(leading_count):
+        #     paragraph = document.add_paragraph()
+        #     if first_paragraph is not None:
+        #         first_paragraph._p.addprevious(paragraph._p)
+        for _ in range(trailing_count):
+            document.add_paragraph()
+        document.save(docx_path)
+
+    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._restore_outer_blank_lines(fpath)
+        return fpath
+class MarkdwonTextBuffer(BaseBuffer):
+    _allow_type = "markdwonText"
+    def __init__(self, render):
+        super().__init__(render)
+        self._text_list:List[str] = []
+        
+    
+    @property
+    def text_list(self):
+        return [*self._text_list]
+    @property
+    def type(self):
+        return 'markdwonText'
+
+    @property
+    def text(self):
+        return "".join(self._text_list)
+
+    def _adjust_tables(self, docx_path):
+        document = Document(docx_path)
+        options = self._render._mdoc.render_option.get("docx", {}).get(
+            "markdwon-table", {}
+        )
+        width_percent = float(options.get("width_percent", 100))
+        style = options.get("style")
+        header_bold = options.get("header_bold", True)
+        header_shading = options.get("header_shading")
+        border_color = options.get("border_color")
+        alignment = options.get("cell_alignment", "center")
+
+        for table in document.tables:
+            if style:
+                try:
+                    table.style = style
+                except KeyError:
+                    pass
+            table.autofit = False
+            if border_color:
+                table_properties = table._tbl.tblPr
+                borders = table_properties.find(qn("w:tblBorders"))
+                if borders is None:
+                    borders = OxmlElement("w:tblBorders")
+                    table_properties.append(borders)
+                for border_name in ("top", "left", "bottom", "right", "insideH", "insideV"):
+                    border = borders.find(qn(f"w:{border_name}"))
+                    if border is None:
+                        border = OxmlElement(f"w:{border_name}")
+                        borders.append(border)
+                    border.set(qn("w:val"), "single")
+                    border.set(qn("w:sz"), "4")
+                    border.set(qn("w:space"), "0")
+                    border.set(qn("w:color"), border_color)
+            table_width = sum(
+                section.page_width - section.left_margin - section.right_margin
+                for section in document.sections
+            ) / max(1, len(document.sections))
+            table_width = int(table_width * width_percent / 100)
+            for row_index, row in enumerate(table.rows):
+                row_width = max(1, len(row.cells))
+                for cell in row.cells:
+                    cell.width = Inches(table_width / 914400 / row_width)
+                    cell.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.CENTER
+                    if alignment == "center":
+                        for paragraph in cell.paragraphs:
+                            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+                    if row_index == 0:
+                        for paragraph in cell.paragraphs:
+                            for run in paragraph.runs:
+                                run.bold = header_bold
+                        if header_shading:
+                            properties = cell._tc.get_or_add_tcPr()
+                            shading = properties.find(qn("w:shd"))
+                            if shading is None:
+                                shading = OxmlElement("w:shd")
+                                properties.append(shading)
+                            shading.set(qn("w:fill"), header_shading)
+
+        document.save(docx_path)
+
+    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._restore_outer_blank_lines(fpath)
+        self._adjust_tables(fpath)
+        return fpath
+
+    def create(self,type:str,text:str,*kws):
+        if not type==self._allow_type:
+            raise TypeError(detail={"meg":"type={} not allow".format(type)})
+        self._text_list.append(text)
+        return self
+
+    def concatenate(self, value:MarkdwonTextBuffer):
+        if super().validate_concatenate(value):
+            self._text_list.extend(value.text_list)
+            return self
+        return False
+    
+    
+
+class HtmlTextBuffer(MarkdwonTextBuffer):
+    _allow_type = "htmlText"
+    def __init__(self, render):
+        super().__init__(render)
+        
+    
+    def append(self, text):
+        if len(self._text_list)==0:
+            return super().append(text)
+        raise "{}已经存在数据".format(self)
+    
+    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')
+        return fpath
+
+    def write_to_docx_file(self):
+        temp_html_file_path = self.write_to_text_file()
+        fpath = self.create_docx_file_path()
+        if fpath.exists():
+            fpath.unlink()
+        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"]
+        )
+        return fpath
+class TableHtmlTextBuffer(HtmlTextBuffer):
+    _allow_type = "tableHtmlText"
+
+    def __init__(self, render):
+        super().__init__(render)
+
+    def concatenate(self, value):
+        # 禁止合并
+        return False
+
+    def _column_widths(self):
+        soup = BeautifulSoup(self.text, "html.parser")
+        table = soup.find("table")
+        if table is None:
+            return []
+
+        rows = table.find_all("tr")
+        column_count = max(
+            (len(row.find_all(["td", "th"], recursive=False)) for row in rows),
+            default=0
+        )
+        if column_count == 0:
+            return []
+
+        widths = [None] * column_count
+        for row in rows:
+            cells = row.find_all(["td", "th"], recursive=False)
+            for index, cell in enumerate(cells):
+                if widths[index] is None and cell.has_attr("width"):
+                    value = re.search(r"[0-9]+(?:[.][0-9]+)?", cell["width"])
+                    if value:
+                        widths[index] = float(value.group())
+
+        missing = [index for index, width in enumerate(widths) if width is None]
+        remaining = max(0.0, 100.0 - sum(width or 0.0 for width in widths))
+        default_width = remaining / len(missing) if missing else 0.0
+        return [width if width is not None else default_width for width in widths]
+
+    def _adjust_docx(self, docx_path):
+        document = Document(docx_path)
+        widths = self._column_widths()
+        for table in document.tables:
+            if not table.columns:
+                continue
+            table.autofit = False
+            table_width = sum(
+                section.page_width - section.left_margin - section.right_margin
+                for section in document.sections
+            ) / max(1, len(document.sections))
+            for index, column in enumerate(table.columns):
+                width = widths[index] if index < len(widths) else 100 / len(table.columns)
+                column_width = Inches(table_width / 914400 * width / 100)
+                for cell in column.cells:
+                    cell.width = column_width
+                    cell.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.CENTER
+                    for paragraph in cell.paragraphs:
+                        for run in paragraph.runs:
+                            for shape in run._element.xpath(".//wp:inline"):
+                                extent = shape.find("{http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing}extent")
+                                if extent is not None:
+                                    extent.set("cx", str(int(column_width.inches * 914400 * 0.95)))
+                                    extent.set("cy", str(int(int(extent.get("cy")) * 0.95)))
+                        if any(run._element.xpath(".//wp:inline") for run in paragraph.runs):
+                            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        document.save(docx_path)
+
+    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._adjust_docx(fpath)
+        return fpath
+    
+        
+
+class DocumentBuffer(BaseBuffer):
+    _allow_type = "document"
+    
+   
+    
+        
+    def __init__(self, render):
+        super().__init__(render)
+        
+        self._handles = {
+            MarkdwonTextBuffer._allow_type:MarkdwonTextBuffer,
+            HtmlTextBuffer._allow_type:MarkdwonTextBuffer,
+            TableHtmlTextBuffer._allow_type:TableHtmlTextBuffer,
+            DocumentBuffer._allow_type:DocumentBuffer,
+        }
+        self.keep_together = False
+        self._children:List[Union[BaseBuffer,HtmlTextBuffer,MarkdwonTextBuffer,TableHtmlTextBuffer]] = []
+    @property  
+    def last_node(self)->BaseBuffer:
+        
+        if len(self._children)>0:
+            return self._children[-1]
+        return None
+    @property
+    def children(self):
+        return [*self._children]
+    
+    def validate_concatenate(self, value:DocumentBuffer):
+        return super().validate_concatenate(value) and value.keep_together==self.keep_together
+    
+    def concatenate(self,value:DocumentBuffer):
+        if self.validate_concatenate(value):
+            for c in value.children:
+                self.append(c)
+            return self
+        return None
+    
+    def append(self,value:Union[DocumentBuffer,HtmlTextBuffer,TableHtmlTextBuffer,BaseBuffer]):
+        if self.last_node:
+            if self.last_node.concatenate(value=value):
+                return None
+        self._children.append(value)
+    
+    def create(self,type:str,keep_together:bool,children:List[dict]):
+        if not self._allow_type==type:
+            raise TypeError()
+        self.keep_together = keep_together
+        
+        for child in children:
+            node_type = child['type']
+            if handle := self._handles.get(node_type,None):
+                node = handle(self._render).create(**child)
+                self.append(node)
+        return self
+    @property
+    def text(self):
+        
+        return "".join([c.text for c in self.children]) 
+    def _keep_content_together(self, docx_path):
+        document = Document(docx_path)
+        paragraphs = document.paragraphs
+        for paragraph in paragraphs[:-1]:
+            paragraph.paragraph_format.keep_with_next = True
+
+        for table in document.tables:
+            for row in table.rows:
+                row_properties = row._tr.get_or_add_trPr()
+                cant_split = row_properties.find(
+                    "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}cantSplit"
+                )
+                if cant_split is None:
+                    row_properties.append(
+                        OxmlElement("w:cantSplit")
+                    )
+                for cell in row.cells:
+                    for paragraph in cell.paragraphs:
+                        paragraph.paragraph_format.keep_with_next = True
+
+        document.save(docx_path)
+
+    def write_to_docx_file(self):
+        docx_paths = [c.write_to_docx_file() for c in self.children]
+        if not docx_paths:
+            return None
+        output_path = self.create_temp_file_path(".docx")
+
+        composer = Composer(Document(docx_paths[0]))
+        for docx_path in docx_paths[1:]:
+            composer.append(Document(docx_path))
+        composer.save(output_path)
+        if self.keep_together:
+            self._keep_content_together(output_path)
+        return output_path
+    
+
+
+    
+    
+    
+        
+
+
+        
+        
+    
+
+
+    

qparse/markdwon_document/__init__.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+from .nodes import *
+
+from .base_document import BaseDocument
+from .markdwon_document import MarkdwonDocument
+from .question_document import QuestionDocument
+from .analysis_document import AnalysisDocument
+from .stem_document import StemDocument
+from .table_document import TableDocument
+BaseDocument.register_node_parser('markdwon',MarkdwonDocument)
+
+
+
+BaseDocument.register_node_parser('choise',ChioseNode)
+BaseDocument.register_node_parser('multiple-choice',MultipleChoiceNode)
+BaseDocument.register_node_parser('blank',BlankNode)
+BaseDocument.register_node_parser('answer',AnswerNode)
+BaseDocument.register_node_parser('text',TextNode)
+BaseDocument.register_node_parser('br',BrNode)
+BaseDocument.register_node_parser('first-text-visible',FirstTextVisibleNode)
+BaseDocument.register_node_parser('img',ImgNode)
+
+
+BaseDocument.register_node_parser('question',QuestionDocument)
+BaseDocument.register_node_parser('analysis',AnalysisDocument)
+BaseDocument.register_node_parser('stem',StemDocument)
+
+BaseDocument.register_node_parser('table',TableDocument)

qparse/markdwon_document/analysis_document.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+from bs4 import BeautifulSoup,element
+from typing import Dict,Union
+from .base_document import BaseDocument
+from qparse.utils.html_full_protector import HtmlFullProtector
+from qparse.render_option import SafeGetRenderOption
+class AnalysisDocument(BaseDocument):
+    def __init__(self, node, render_option):
+        self.show = SafeGetRenderOption(option=render_option,path=['question','analysis','show'] ,default=False)
+        super().__init__(node, render_option)
+    htmlParser = HtmlFullProtector()
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+       
+        if node.name=="analysis":
+            # return cls(node=node,render_option=render_option)
+            for n in cls._iter_nodes(node):
+                if isinstance(n,element.NavigableString):
+                    text = cls.htmlParser.decode_to_unicode(n.get_text()).strip()
+                    if text:
+                        # s = element.NavigableString()
+                        tag = element.Tag(name="first-text-visible")
+                        tag.append(n.get_text())
+                        tag.attrs['include-by']= "analysis"
+                        n.replace_with(tag)
+                        break
+            return cls(node=node,render_option=render_option)
+        return None
+    
+    def dump_markdwon(self):
+        if self.show:
+            text= super().dump_markdwon()
+            
+            return text.strip("\n")+"\n"
+        return ''
+    def dump_docx_buffer(self):
+        if self.show:
+            return super().dump_docx_buffer()
+        return []
+        

qparse/markdwon_document/base_document.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+from bs4 import BeautifulSoup,element
+from typing import Dict,Union,List
+from qparse.utils.html_full_protector import HtmlFullProtector
+import copy
+class BaseDocument():
+    _registry: Dict[str, type["BaseDocument"]] = {}
+    htmlParser = HtmlFullProtector()
+    def __init__(self,node:element.Tag,render_option:dict):
+        
+        self._soup = node
+        self._render_option = render_option
+        self.children= []
+        self.create_document()
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        return None
+    
+    @classmethod
+    def register_node_parser(cls,name:str,sub_cls):
+        cls._registry[name] = sub_cls
+
+    def create_document(self):
+        stack = [*self._soup]
+        
+        while len(stack):
+            node = stack.pop(0)
+            
+            parsed = False
+            for name,sub_cls in self._registry.items():
+                if mDoc := sub_cls.create_by_node(node=node,render_option=self._render_option):
+                    self.children.append(mDoc)
+                    # print(mDoc,name,self.__class__.__name__)
+                    parsed = True
+                    break
+            
+            if not parsed:
+               
+                if isinstance(node,element.Tag):
+                    stack = [*node.children,*stack]
+                    
+                elif isinstance(node,element.NavigableString):
+                    pass
+            # else:
+            #     if isinstance(node,element.Tag):
+            #         print(node.select_one(".blank"))
+            
+    def dump_markdwon(self):
+        nodes = []
+        for c in self.children:
+            # text = self.htmlParser. c.dump_markdwon()
+            # if len(text.strip()) ==0:
+            text = c.dump_markdwon()
+            nodes.append(text)
+        return "".join(nodes)
+    def dump_docx_buffer(self):
+        nodes = []
+        
+        for c in self.children:
+           
+           
+            nodes.extend(c.dump_docx_buffer())
+        
+        return nodes
+    @classmethod
+    def _iter_nodes(cls,soup:element.Tag):
+        stack = [soup]
+        while len(stack):
+            node = stack.pop(0)
+            yield node
+            if isinstance(node,element.Tag):
+                stack = [*node,*stack]
+    def run(self):
+        mark = self.dump_markdwon()
+    @property
+    def attrs(self):
+        return getattr(self.soup,'attrs',{}) 
+    @property
+    def soup(self):
+        return copy.deepcopy(self._soup)
+    @property
+    def render_option(self):
+        return copy.deepcopy(self._render_option) 
+
+    
+    
+        

qparse/markdwon_document/markdwon_document.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+from bs4 import BeautifulSoup,element
+from typing import Dict,Union
+from .base_document import BaseDocument
+
+class MarkdwonDocument(BaseDocument):
+    def __init__(self, node, render_option):
+        super().__init__(node, render_option)
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        if node.name=="markdwon":
+            return cls(node=node,render_option=render_option)
+        return None
+    
+    
+

qparse/markdwon_document/nodes/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .base_node import BaseNode
+from .text_node import TextNode,FirstTextVisibleNode,BrNode
+from .img_node import ImgNode
+from .answer_node import *

qparse/markdwon_document/nodes/answer_node.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from bs4 import BeautifulSoup,element
+from typing import Union
+from qparse.render_option import SafeGetRenderOption,render_template
+from .text_node import TextNode
+
+class AnswerNode(TextNode):
+    
+    def __init__(self, node, render_option):
+        super().__init__(node, render_option)
+        self._show_answer = SafeGetRenderOption(
+            self._render_option,path=['question','show_answer'],default=False
+        )
+    
+    @property
+    def template_key(self):
+        k = ':show_answer' if self._show_answer else ":not_show_answer"
+        
+        return k
+    @property
+    def template(self):
+        
+        return SafeGetRenderOption(
+            self._render_option,path=['question','.answer',self.template_key,'template'],default=""
+        )
+    
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        if isinstance(node,element.Tag) and "answer" in node.attrs.get('class',[]):
+            return cls(node=node,render_option=render_option)
+        return None
+    def dump_markdwon(self):
+        
+        text = super().dump_markdwon()
+        
+        text= render_template(self.template,{"text":text})
+       
+        return text
+
+
+class ChioseNode(AnswerNode):
+    def __init__(self, node, render_option):
+        super().__init__(node, render_option)
+    @property
+    def template(self):
+        
+        return SafeGetRenderOption(
+            self._render_option,path=['question','.choise',self.template_key,'template'],default=r"[%text%]"
+        )
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        if isinstance(node,element.Tag) and "chiose" in node.attrs.get('class',[]):
+            return cls(node=node,render_option=render_option)
+        return None
+
+class MultipleChoiceNode(ChioseNode):
+    def __init__(self, node, render_option):
+        super().__init__(node, render_option)
+    
+    @property
+    def template(self):
+        
+        return SafeGetRenderOption(
+            self._render_option,path=['question','.multiple-choice',self.template_key,'template'],default=r"[% text %]"
+        )
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        if isinstance(node,element.Tag) and "multiple-choice" in node.attrs.get('class',[]):
+            return cls(node=node,render_option=render_option)
+        return None
+
+class BlankNode(AnswerNode):
+    def __init__(self, node, render_option):
+        super().__init__(node, render_option)
+    
+    @classmethod
+    def create_by_node(cls,node:element.Tag,render_option:dict):
+        
+        if isinstance(node,element.Tag) and "blank" in node.attrs.get('class',[]):
+            
+            return cls(node=node,render_option=render_option)
+        return None
+    @property
+    def template(self):
+        
+        return SafeGetRenderOption(
+            self._render_option,path=['question','.blank',self.template_key,'template'],default=r"[% text %]"
+        )
+    
+    def dump_markdwon(self):
+        text = super().dump_markdwon()
+        text= render_template(self.template,{'text':text})
+        return text
+    
+    
+        
+