xl-docx 0.6.7__tar.gz

xl_docx-0.6.7/.gitignore

@@ -0,0 +1,3 @@
+dist
+build
+

xl_docx-0.6.7/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: xl-docx
+Version: 0.6.7
+Summary: generate word documents in a sexy way
+Project-URL: Homepage, https://github.com/inspirare6/xl-docx
+Project-URL: Bug Tracker, https://github.com/inspirare6/xl-docx/issues
+Author-email: inspirare6 <inspirare6@163.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: cssselect==1.2.0
+Requires-Dist: jinja2==3.1.2
+Requires-Dist: lxml==4.9.2

xl_docx-0.6.7/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "xl-docx"
+version = "0.6.7"
+authors = [
+  { name="inspirare6", email="inspirare6@163.com" },
+]
+description = "generate word documents in a sexy way"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+  "jinja2==3.1.2",
+  "lxml==4.9.2",
+  "cssselect==1.2.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/inspirare6/xl-docx"
+"Bug Tracker" = "https://github.com/inspirare6/xl-docx/issues"

xl_docx-0.6.7/src/xl_word/__init__.py

@@ -0,0 +1,4 @@
+from xl_word.utils.fake_zip import FakeZip
+from xl_word.word_file import WordFile
+from xl_word.sheet import Sheet
+from xl_word.document import Document

xl_docx-0.6.7/src/xl_word/__main__.py

@@ -0,0 +1,5 @@
+from xl_word.tool import WordTemplateEditor
+
+
+editor = WordTemplateEditor()
+editor.run()

xl_docx-0.6.7/src/xl_word/compiler/__init__.py

@@ -0,0 +1,79 @@
+from jinja2 import Environment, BaseLoader, TemplateNotFound
+from typing import Dict, Any
+from xl_word.compiler.processors import BaseProcessor, StyleProcessor, DirectiveProcessor, \
+TableProcessor, ParagraphProcessor, PagerProcessor
+
+
+class ImageProcessor(BaseProcessor):
+    """处理图片相关的XML标签"""
+    def compile(self, xml: str) -> str:
+        def process_image(match):
+            attrs = self._extract_attrs(match.group(0), ['src', 'width', 'height'])
+            rid = attrs['src']
+            width = attrs['width']
+            height = attrs['height']
+            
+            return f'''<w:pict>
+                            <v:shape style="width:{width}px;height:{height}px">
+                                <v:imagedata r:id="{rid}"/>
+                            </v:shape>
+                        </w:pict>'''
+            
+        return self._process_tag(xml, r'<xl-img[^>]+/>', process_image)
+
+
+class XMLTemplateLoader(BaseLoader):
+    def __init__(self, template_str: str):
+        self.template_str = template_str
+
+    def get_source(self, environment: Environment, template: str) -> tuple:
+        if template == 'root':
+            return self.template_str, None, lambda: True
+        raise TemplateNotFound(template)
+
+class XMLCompiler:
+    """XML编译器主类"""
+    def __init__(self):
+        self.processors = [
+            StyleProcessor(),
+            DirectiveProcessor(), 
+            TableProcessor(),
+            ParagraphProcessor(),
+            ImageProcessor(),
+            PagerProcessor()
+        ]
+        self.env = Environment(
+            loader=XMLTemplateLoader(""),
+            autoescape=False,
+            trim_blocks=True,
+            lstrip_blocks=True
+        )
+
+    def compile_template(self, template: str) -> str:
+        for processor in self.processors:
+            if hasattr(processor, 'compile'):
+                template = processor.compile(template)
+            
+        return template
+    
+    def decompile_template(self, template: str) -> str:
+        for processor in self.processors:
+            if hasattr(processor, 'decompile'):
+                template = processor.decompile(template)
+            
+        return template
+    
+
+    def render_template(self, template: str, data: Dict[str, Any]) -> str:
+        processed_template = self.compile_template(template)
+        env = Environment(
+            loader=XMLTemplateLoader(processed_template),
+            autoescape=False,
+            trim_blocks=True,
+            lstrip_blocks=True
+        )
+        
+        template = env.get_template('root')
+        result = template.render(**data)
+        
+        return result

xl_docx-0.6.7/src/xl_word/compiler/processors/__init__.py

@@ -0,0 +1,6 @@
+from xl_word.compiler.processors.base import BaseProcessor
+from xl_word.compiler.processors.style import StyleProcessor
+from xl_word.compiler.processors.directive import DirectiveProcessor
+from xl_word.compiler.processors.table import TableProcessor
+from xl_word.compiler.processors.paragraph import ParagraphProcessor
+from xl_word.compiler.processors.pager import PagerProcessor

xl_docx-0.6.7/src/xl_word/compiler/processors/base.py

@@ -0,0 +1,73 @@
+import re
+
+
+class BaseProcessor:
+    """XML处理器基类"""
+    @classmethod
+    def compile(cls, xml):
+        raise NotImplementedError
+
+    @staticmethod
+    def retrieve(dict_, keys):
+        """字典解构赋值
+        params = {'a': 1, 'b': 2}
+        a, b = get(params, ['a', 'b'])
+        a, c = get(params, ['a', 'c'])
+        """
+        tmp = ()
+        for key in keys:
+            tmp += (dict_.get(key),)
+        return tmp
+
+    @classmethod
+    def _process_tag(cls, xml, pattern, process_func):
+        """通用标签处理方法"""
+        return re.sub(pattern, process_func, xml, flags=re.DOTALL)
+
+    @classmethod
+    def _extract_attrs(cls, attrs_str, attr_names):
+        """提取属性值"""
+        result = []
+        for name in attr_names:
+            match = re.search(f'{name}="([^"]*)"', attrs_str)
+            result.append(match.group(1) if match else None)
+        return tuple(result)
+    
+    @classmethod
+    def _get_value(cls, pattern, xml):
+        match = re.search(pattern, xml)
+        return match.group(1) if match else None
+    
+    @classmethod
+    def _build_props(cls, props, indent=''):
+        """构建属性字符串"""
+        if not props:
+            return ''
+        return f'\n{indent}' + f'\n{indent}'.join(props) + f'\n{indent}'
+    
+    @classmethod
+    def _parse_style_str(cls, style_str):
+        """解析样式字符串为字典
+        例如: "font-size:12px;color:red" -> {"font-size": "12px", "color": "red"}
+        """
+        if not style_str:
+            return {}
+        return dict(pair.split(':') for pair in style_str.split(';') if pair.strip())
+    
+    @classmethod
+    def _build_style_str(cls, styles):
+        """将样式字典转换为字符串
+        例如: {"font-size": "12px", "color": "red"} -> "font-size:12px;color:red"
+        """
+        if not styles:
+            return ''
+        return ';'.join(f"{k}:{v}" for k, v in styles.items())
+
+    @classmethod
+    def _build_attr_str(cls, attrs):
+        """将属性字典转换为字符串
+        例如: {"font-size": "12px", "color": "red"} -> "font-size:12px;color:red"
+        """
+        if not attrs:
+            return ''
+        return ' '.join(f"{k}='{v}'" for k, v in attrs.items())

xl_docx-0.6.7/src/xl_word/compiler/processors/directive.py

@@ -0,0 +1,75 @@
+from xl_word.compiler.processors.base import BaseProcessor
+import re
+
+
+class DirectiveProcessor(BaseProcessor):
+    """处理Vue指令相关的XML标签"""
+    @classmethod
+    def compile(cls, xml: str) -> str:
+        xml = cls._process_v_if(xml)
+        xml = cls._process_v_for(xml)
+        return xml
+        
+    @classmethod
+    def _process_v_if(cls, xml: str) -> str:
+        def process_if(match):
+            tag_name, condition, remaining_attrs = match.groups()
+            close_tag_pattern = f'</\s*{tag_name}\s*>'
+            close_match = re.search(close_tag_pattern, xml[match.end():])
+            if close_match:
+                content_between = xml[match.end():match.end() + close_match.start()]
+                return f'{{% if {condition} %}}<{tag_name}{remaining_attrs}>{content_between}</{tag_name}>{{% endif %}}'
+            return match.group(0)
+            
+        return cls._process_tag(xml, r'<([^>]*)\s+v-if="([^"]*)"([^>]*)>', process_if)
+
+    @classmethod
+    def _process_v_for(cls, xml: str) -> str:
+        def process_for(match):
+            tag_name, loop_expr, remaining_attrs = match.groups()
+            item, items = loop_expr.split(' in ')
+            item = item.strip()
+            items = items.strip()
+            
+            close_tag_pattern = f'</\s*{tag_name}\s*>'
+            close_match = re.search(close_tag_pattern, xml[match.end():])
+            if close_match:
+                content_between = xml[match.end():match.end() + close_match.start()]
+                return f'{{% for {item} in {items} %}}<{tag_name}{remaining_attrs}>{content_between}</{tag_name}>{{% endfor %}}'
+            return match.group(0)
+            
+        return cls._process_tag(xml, r'<([^>]*)\s+v-for="([^"]*)"([^>]*)>', process_for)
+
+    @classmethod
+    def decompile2222222222222222222222(cls, xml: str) -> str:
+        """将Jinja2模板转换回Vue指令"""
+        xml = cls._decompile_v_if(xml)
+        xml = cls._decompile_v_for(xml)
+        return xml
+
+    @classmethod
+    def _decompile_v_if(cls, xml: str) -> str:
+        def process_if(match):
+            condition, tag_content = match.groups()
+            # 提取标签名和属性
+            tag_match = re.match(r'<([^\s>]+)([^>]*)>(.*)</\1>', tag_content)
+            if tag_match:
+                tag_name, attrs, content = tag_match.groups()
+                return f'<{tag_name} v-if="{condition}"{attrs}>{content}</{tag_name}>'
+            return match.group(0)
+
+        return cls._process_tag(xml, r'{%\s*if\s+([^%]+)\s*%}(.*?){%\s*endif\s*%}', process_if)
+
+    @classmethod
+    def _decompile_v_for(cls, xml: str) -> str:
+        def process_for(match):
+            loop_expr, tag_content = match.groups()
+            # 提取标签名和属性
+            tag_match = re.match(r'<([^\s>]+)([^>]*)>(.*)</\1>', tag_content)
+            if tag_match:
+                tag_name, attrs, content = tag_match.groups()
+                item, items = loop_expr.split(' in ')
+                return f'<{tag_name} v-for="{item.strip()} in {items.strip()}"{attrs}>{content}</{tag_name}>'
+            return match.group(0)
+
+        return cls._process_tag(xml, r'{%\s*for\s+([^%]+)\s*%}(.*?){%\s*endfor\s*%}', process_for)

xl_docx-0.6.7/src/xl_word/compiler/processors/pager.py

@@ -0,0 +1,196 @@
+from xl_word.compiler.processors.base import BaseProcessor
+import re
+
+
+class PagerProcessor(BaseProcessor):
+    """处理页码相关的XML标签"""
+    def compile(self, xml: str) -> str:
+
+        def process_pager(match):
+            style, = self._extract_attrs(match.group(0), ['style'])
+            styles = self._parse_style_str(style)
+            
+            font_size = styles.get('font-size', '21')
+            english_font = styles.get('english', 'Times New Roman')
+            chinese_font = styles.get('chinese', 'SimSun')
+
+            return f'''<w:sdt>
+						<w:sdtPr>
+							<w:id w:val="98381352"/>
+							<w:docPartObj>
+								<w:docPartGallery w:val="Page Numbers (Top of Page)"/>
+								<w:docPartUnique/>
+							</w:docPartObj>
+						</w:sdtPr>
+						<w:sdtEndPr>
+							<w:rPr>
+								<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+								<w:szCs w:val="{font_size}"/>
+							</w:rPr>
+						</w:sdtEndPr>
+						<w:sdtContent>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="宋体" w:hint="eastAsia"/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:t>第</w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t xml:space="preserve"> </w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="begin"/>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:instrText>PAGE</w:instrText>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="separate"/>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:noProof/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:t>2</w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="end"/>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t xml:space="preserve"> </w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="宋体" w:hint="eastAsia"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t>页</w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t xml:space="preserve"> </w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="宋体" w:hint="eastAsia"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t>共</w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:szCs w:val="{font_size}"/>
+									<w:lang w:val="zh-CN"/>
+								</w:rPr>
+								<w:t xml:space="preserve"> </w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="begin"/>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:instrText>NUMPAGES</w:instrText>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="separate"/>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:noProof/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:t>2</w:t>
+							</w:r>
+							<w:r>
+								<w:rPr>
+									<w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+									<w:b/>
+									<w:bCs/>
+									<w:szCs w:val="{font_size}"/>
+								</w:rPr>
+								<w:fldChar w:fldCharType="end"/>
+							</w:r>
+                            <w:r>
+                                <w:rPr>
+                                    <w:rFonts w:ascii="{english_font}" w:hAnsi="{chinese_font}"/>
+                                    <w:szCs w:val="{font_size}"/>
+                                </w:rPr>
+                                <w:t xml:space="preserve"> </w:t>
+                            </w:r>
+                            <w:r>
+                                <w:rPr>
+                                    <w:rFonts w:ascii="{english_font}" w:hAnsi="宋体" w:hint="eastAsia"/>
+                                    <w:szCs w:val="{font_size}"/>
+                                </w:rPr>
+                                <w:t>页</w:t>
+                            </w:r>
+						</w:sdtContent>
+					</w:sdt>'''
+
+        return self._process_tag(xml, r'<xl-pager.*?/>', process_pager)

xl_docx-0.6.7/src/xl_word/compiler/processors/paragraph.py

@@ -0,0 +1,147 @@
+from xl_word.compiler.processors.base import BaseProcessor
+import re
+
+
+class ParagraphProcessor(BaseProcessor):
+    """处理段落相关的XML标签"""
+    @classmethod
+    def compile(cls, xml: str) -> str:
+        """将xl-p标签转换为w:p标签"""
+        def process_paragraph(match):
+            style_str = match.group(1) or ''
+            content = match.group(2).strip()
+            styles = cls._parse_style_str(style_str)
+
+            p_props_str = '<w:pPr>'
+            align, padding_top, padding_bottom, english, chinese, font_size, font_weight = cls.retrieve(styles, \
+                ['align', 'padding-top', 'padding-bottom', 'english', 'chinese', 'font-size', 'font-weight'])
+            p_props_str += f'<w:jc w:val="{align}"/>' if align else ''
+            spacing_attr_str = ''
+            spacing_attr_str += f'w:before="{padding_top}" ' if padding_top else ''
+            spacing_attr_str += f'w:after="{padding_bottom}"' if padding_bottom else ''
+            p_props_str += f'<w:spacing {spacing_attr_str}/>' if spacing_attr_str else ''
+            p_props_str += '</w:pPr>'
+            
+            r_props_str = '<w:rPr>'
+            r_props_str += f'<w:rFonts w:ascii="{english}" w:cs="{chinese}" w:eastAsia="{english}" w:hAnsi="{english}" w:hint="eastAsia"/>' if (english and chinese) else ''
+            r_props_str += f'<w:kern w:val="0"/>' if font_size else ''
+            r_props_str += f'<w:sz w:val="{font_size}"/>' if font_size else ''
+            r_props_str += f'<w:szCs w:val="{font_size}"/>' if font_size else ''
+            r_props_str += f'<w:b/>' if font_weight == 'bold' else ''
+            r_props_str += '</w:rPr>'
+
+            def process_span(match):
+                style_str = match.group(1) or ''
+                content = match.group(2).strip()
+                styles = cls._parse_style_str(style_str)
+                underline, font_size, font_weight = cls.retrieve(styles, ['underline', 'font-size', 'font-weight'])
+                r_props_str_ =  r_props_str
+                r_props_str_inner = f'<w:u w:val="{underline}"/>' if underline else ''
+                r_props_str_inner += f'<w:sz w:val="{font_size}"/>' if font_size else ''
+                r_props_str_inner += f'<w:b/>' if font_weight == 'bold' else ''
+                r_props_str_inner += '</w:rPr>'
+                r_props_str_inner = r_props_str_.replace('</w:rPr>', r_props_str_inner)
+
+                return f'<w:r>{r_props_str_inner}<w:t xml:space="preserve">{content}</w:t></w:r>'
+            
+            def process_signature(match):
+                data_var, height = match.groups()
+                height = height.replace('px', '')
+                
+                return f'''<w:r>
+                        <w:pict>
+                            <v:shape style="height:{height}px;width:{{{{ {height}*{data_var}['width']/{data_var}['height'] }}}}px">
+                                <v:imagedata r:id="{{{{%s['rid']}}}}"/>
+                            </v:shape>
+                        </w:pict> 
+                        </w:r>''' % data_var
+            
+            content = cls._process_tag(content, r'<xl-signature\s+data="([^"]+)"\s+height="([^"]+)"\s*></xl-signature>', process_signature)
+            content = cls._process_tag(content,r'<xl-span(?:[^>]*style="([^"]+)")?[^>]*>(.*?)</xl-span>', process_span)
+            data = f'<w:p>{p_props_str}{content}</w:p>'
+            return data
+        
+        data = cls._process_tag(xml, r'<xl-p(?:[^>]*style="([^"]+)")?[^>]*>(.*?)</xl-p>', process_paragraph)
+        return data
+    
+
+    @classmethod
+    def decompile(cls, xml: str) -> str:
+        """将Ww:p标签转换为xl-p标签"""
+        def process_word_paragraph(match):
+
+            full_p = match.group(0)
+            content = match.group(1)
+            if not '<w:r' in full_p:
+                return full_p
+            
+            
+            # 提取样式属性
+            styles = {}
+            
+            # 提取对齐方式
+            align_match = re.search(r'<w:jc\s+w:val="([^"]+)"/>', content)
+            if align_match:
+                styles['align'] = align_match.group(1)
+            
+            # 提取间距
+            spacing_match = re.search(r'<w:spacing\s+([^/>]+)/>', content)
+            if spacing_match:
+                spacing_attrs = spacing_match.group(1)
+                before_match = re.search(r'w:before="([^"]+)"', spacing_attrs)
+                after_match = re.search(r'w:after="([^"]+)"', spacing_attrs)
+                if before_match:
+                    styles['padding-top'] = before_match.group(1)
+                if after_match:
+                    styles['padding-bottom'] = after_match.group(1)
+            
+            # 提取字体信息
+            font_match = re.search(r'<w:rFonts\s+w:ascii="([^"]+)"[^/]+w:cs="([^"]+)"', content)
+            if font_match:
+                styles['english'] = font_match.group(1)
+                styles['chinese'] = font_match.group(2)
+            
+            # 提取字体大小
+            size_match = re.search(r'<w:sz\s+w:val="([^"]+)"/>', content)
+            if size_match:
+                styles['font-size'] = size_match.group(1)
+            
+            # 检查是否加粗
+            if '<w:b/>' in content:
+                styles['font-weight'] = 'bold'
+
+            def process_r(match):
+                content = match.group(1).strip()
+                r_styles = {}
+                underline_match = re.search(r'<w:u w:val="([^>]*)"/>', content)
+                if underline_match:
+                    underline = underline_match.group(1)
+                    r_styles['underline'] = underline
+                r_style_str = cls._build_style_str(r_styles)
+
+                def process_t(match):
+                    content = match.group(1).strip()
+                    return f'{content}'
+                
+                matches = list(re.finditer(r'<w:t(?:\s+[^>]*)?>(.*?)</w:t>', content, re.DOTALL))
+                content = ''
+                for match in matches:
+                    full_r = match.group(0)
+                    full_r = cls._process_tag(full_r, r'<w:t(?:\s+[^>]*)?>(.*?)</w:t>', process_t)
+                    content += full_r
+                return f'<xl-span style="{r_style_str}">{content}</xl-span>'
+            
+            matches = list(re.finditer(r'<w:r(?:\s+[^>]*)?>(.*?)</w:r>', content, re.DOTALL))
+            content = ''
+            for match in matches:
+                full_t = match.group(0)
+                full_t = cls._process_tag(full_t, r'<w:r(?:\s+[^>]*)?>(.*?)</w:r>', process_r)
+                content += full_t
+            
+            # 构建样式字符串
+            style_str = cls._build_style_str(styles)
+            style_attr = f' style="{style_str}"' if style_str else ""
+            
+            return f'<xl-p{style_attr}>{content}</xl-p>'
+        xml = re.sub(r'<w:p(?![a-zA-Z])([^>]*?)/>',r'<w:p\1></w:p>', xml)
+        return cls._process_tag(xml, r'<w:p[^>]*?>(.*?)</w:p>', process_word_paragraph)