使用Python为Web端集成Markdown功能的完整步骤

pip install markdown pygments python-frontmatter

import markdown
import logging
from typing import dict, any, optional

class basicmarkdownconverter:
    """
    基础markdown转换器类
    提供markdown到html的基本转换功能
    """
    
    def __init__(self, extensions: list = none, extension_configs: dict = none):
        """
        初始化转换器
        
        args:
            extensions: markdown扩展列表
            extension_configs: 扩展配置字典
        """
        self.logger = logging.getlogger(__name__)
        
        # 默认扩展
        self.default_extensions = [
            'extra',          # 额外语法支持
            'codehilite',     # 代码高亮
            'toc',            # 目录生成
            'tables',         # 表格支持
        ]
        
        self.extensions = extensions or self.default_extensions
        self.extension_configs = extension_configs or {}
        
        self.logger.info("markdown转换器初始化完成")
    
    def convert(self, markdown_text: str, **kwargs) -> str:
        """
        将markdown文本转换为html
        
        args:
            markdown_text: markdown格式文本
            **kwargs: 额外参数
            
        returns:
            str: 转换后的html
        """
        try:
            if not markdown_text:
                return ""
            
            # 使用markdown库进行转换
            html_content = markdown.markdown(
                markdown_text,
                extensions=self.extensions,
                extension_configs=self.extension_configs,
                **kwargs
            )
            
            self.logger.debug(f"成功转换markdown文本，长度: {len(markdown_text)}")
            return html_content
            
        except exception as e:
            self.logger.error(f"markdown转换失败: {str(e)}")
            return f"<p>转换错误: {str(e)}</p>"
    
    def convert_file(self, file_path: str, encoding: str = 'utf-8') -> str:
        """
        转换markdown文件为html
        
        args:
            file_path: 文件路径
            encoding: 文件编码
            
        returns:
            str: 转换后的html
        """
        try:
            with open(file_path, 'r', encoding=encoding) as f:
                markdown_content = f.read()
            
            return self.convert(markdown_content)
            
        except filenotfounderror:
            self.logger.error(f"文件未找到: {file_path}")
            return f"<p>文件未找到: {file_path}</p>"
        except exception as e:
            self.logger.error(f"文件转换失败: {str(e)}")
            return f"<p>文件转换错误: {str(e)}</p>"

def demo_basic_conversion():
    """演示基础转换功能"""
    
    # 创建转换器实例
    converter = basicmarkdownconverter()
    
    # 示例markdown文本
    sample_markdown = """
# 这是一个标题

这是一个段落，包含**粗体**和*斜体*文本。

## 列表示例

- 项目1
- 项目2
- 项目3

### 代码示例

```python
def hello_world():
    print("hello, world!")

# 执行转换
html_result = converter.convert(sample_markdown)

print("原始markdown:")
print(sample_markdown)
print("\n转换后的html:")
print(html_result)

return html_result

## 4. 高级markdown功能集成

### 4.1 数学公式支持

数学公式是技术文档中的重要组成部分，我们通过mathjax集成数学公式支持。

```python
import re

class advancedmarkdownconverter(basicmarkdownconverter):
    """
    高级markdown转换器
    支持数学公式、流程图等高级功能
    """
    
    def __init__(self, enable_math: bool = true, enable_diagrams: bool = true):
        """
        初始化高级转换器
        
        args:
            enable_math: 是否启用数学公式支持
            enable_diagrams: 是否启用图表支持
        """
        extensions = [
            'extra',
            'codehilite',
            'toc',
            'tables',
            'mdx_math',  # 数学公式支持
        ]
        
        extension_configs = {
            'codehilite': {
                'css_class': 'highlight',
                'linenums': true,
            },
            'toc': {
                'title': '目录',
                'permalink': true,
            },
            'mdx_math': {
                'enable_dollar_delimiter': true,
            }
        }
        
        super().__init__(extensions, extension_configs)
        
        self.enable_math = enable_math
        self.enable_diagrams = enable_diagrams
        
    def _inject_mathjax_support(self, html_content: str) -> str:
        """
        注入mathjax支持代码
        
        args:
            html_content: html内容
            
        returns:
            str: 注入mathjax后的html
        """
        if not self.enable_math:
            return html_content
            
        mathjax_script = """
        <script>
        mathjax = {
            tex: {
                inlinemath: [['$', '$'], ['\\(', '\\)']],
                displaymath: [['$$', '$$'], ['\\[', '\\]']]
            },
            svg: {
                fontcache: 'global'
            }
        };
        </script>
        <script type="text/javascript" id="mathjax-script" async
            src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js">
        </script>
        """
        
        # 将mathjax脚本注入到head标签前
        if '</head>' in html_content:
            return html_content.replace('</head>', mathjax_script + '</head>')
        else:
            return mathjax_script + html_content
    
    def _process_mermaid_diagrams(self, html_content: str) -> str:
        """
        处理mermaid流程图
        
        args:
            html_content: html内容
            
        returns:
            str: 处理后的html
        """
        if not self.enable_diagrams:
            return html_content
            
        # 查找mermaid代码块
        pattern = r'<pre><code class="language-mermaid">(.*?)</code></pre>'
        
        def replace_mermaid(match):
            mermaid_code = match.group(1)
            # 对html实体进行解码
            import html
            mermaid_code = html.unescape(mermaid_code)
            return f'<div class="mermaid">{mermaid_code}</div>'
        
        processed_html = re.sub(pattern, replace_mermaid, html_content, flags=re.dotall)
        
        # 注入mermaid支持
        mermaid_script = """
        <script src="https://cdn.jsdelivr.net/npm/mermaid@9/dist/mermaid.min.js"></script>
        <script>mermaid.initialize({startonload:true});</script>
        """
        
        if '</body>' in processed_html:
            return processed_html.replace('</body>', mermaid_script + '</body>')
        else:
            return processed_html + mermaid_script
    
    def convert(self, markdown_text: str, **kwargs) -> str:
        """
        高级markdown转换
        
        args:
            markdown_text: markdown文本
            **kwargs: 额外参数
            
        returns:
            str: 转换后的html
        """
        basic_html = super().convert(markdown_text, **kwargs)
        
        # 应用高级处理
        html_with_math = self._inject_mathjax_support(basic_html)
        final_html = self._process_mermaid_diagrams(html_with_math)
        
        return final_html

def create_mermaid_diagram(diagram_type: str, content: str) -> str:
    """
    创建mermaid图表
    
    args:
        diagram_type: 图表类型（flowchart, sequence, gantt等）
        content: 图表内容
        
    returns:
        str: mermaid代码块
    """
    mermaid_template = f"""
```mermaid
{diagram_type}
{content}

## 5. web框架集成

### 5.1 flask集成示例

flask是一个轻量级的python web框架，适合快速开发web应用。

```python
from flask import flask, render_template, request, jsonify
import os
from datetime import datetime

app = flask(__name__)

# 初始化markdown转换器
markdown_converter = advancedmarkdownconverter()

class markdownmanager:
    """markdown内容管理器"""
    
    def __init__(self, storage_dir: str = "content"):
        self.storage_dir = storage_dir
        os.makedirs(storage_dir, exist_ok=true)
    
    def save_markdown(self, filename: str, content: str) -> str:
        """保存markdown内容到文件"""
        filepath = os.path.join(self.storage_dir, f"{filename}.md")
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return filepath
    
    def load_markdown(self, filename: str) -> optional[str]:
        """从文件加载markdown内容"""
        filepath = os.path.join(self.storage_dir, f"{filename}.md")
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                return f.read()
        except filenotfounderror:
            return none

# 初始化管理器
md_manager = markdownmanager()

@app.route('/')
def index():
    """首页"""
    return render_template('index.html')

@app.route('/preview', methods=['post'])
def preview_markdown():
    """markdown实时预览接口"""
    markdown_text = request.json.get('content', '')
    
    if not markdown_text:
        return jsonify({'html': '', 'error': '内容为空'})
    
    try:
        html_content = markdown_converter.convert(markdown_text)
        return jsonify({'html': html_content, 'error': ''})
    except exception as e:
        return jsonify({'html': '', 'error': str(e)})

@app.route('/save', methods=['post'])
def save_document():
    """保存markdown文档"""
    filename = request.json.get('filename', '')
    content = request.json.get('content', '')
    
    if not filename or not content:
        return jsonify({'success': false, 'error': '文件名和内容不能为空'})
    
    try:
        filepath = md_manager.save_markdown(filename, content)
        return jsonify({
            'success': true, 
            'message': f'文档已保存: {filepath}'
        })
    except exception as e:
        return jsonify({'success': false, 'error': str(e)})

@app.route('/document/<filename>')
def view_document(filename):
    """查看markdown文档"""
    content = md_manager.load_markdown(filename)
    
    if content is none:
        return render_template('error.html', message='文档不存在')
    
    html_content = markdown_converter.convert(content)
    return render_template('viewer.html', 
                         title=filename,
                         content=html_content)

if __name__ == '__main__':
    app.run(debug=true, host='0.0.0.0', port=5000)

# views.py
from django.shortcuts import render
from django.http import jsonresponse
from django.views.decorators.csrf import csrf_exempt
import json

from .markdown_utils import advancedmarkdownconverter

converter = advancedmarkdownconverter()

@csrf_exempt
def markdown_preview(request):
    """markdown预览视图"""
    if request.method == 'post':
        try:
            data = json.loads(request.body)
            markdown_text = data.get('content', '')
            
            html_content = converter.convert(markdown_text)
            
            return jsonresponse({
                'success': true,
                'html': html_content
            })
        except exception as e:
            return jsonresponse({
                'success': false,
                'error': str(e)
            })
    
    return jsonresponse({'error': '仅支持post请求'})

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('preview/', views.markdown_preview, name='markdown_preview'),
]

<!doctype html>
<html lang="zh-cn">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>markdown编辑器</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'segoe ui', tahoma, geneva, verdana, sans-serif;
            background-color: #f5f5f5;
            color: #333;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        
        .editor-container {
            display: flex;
            gap: 20px;
            height: 80vh;
        }
        
        @media (max-width: 768px) {
            .editor-container {
                flex-direction: column;
                height: auto;
            }
        }
        
        .editor-panel, .preview-panel {
            flex: 1;
            background: white;
            border-radius: 8px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
            overflow: hidden;
        }
        
        .panel-header {
            background: #2c3e50;
            color: white;
            padding: 15px 20px;
            font-weight: bold;
        }
        
        .editor-textarea {
            width: 100%;
            height: calc(100% - 60px);
            border: none;
            padding: 20px;
            font-family: 'monaco', 'menlo', 'ubuntu mono', monospace;
            font-size: 14px;
            line-height: 1.5;
            resize: none;
            outline: none;
        }
        
        .preview-content {
            padding: 20px;
            height: calc(100% - 60px);
            overflow-y: auto;
        }
        
        .toolbar {
            background: #34495e;
            padding: 10px 20px;
            display: flex;
            gap: 10px;
        }
        
        .btn {
            background: #3498db;
            color: white;
            border: none;
            padding: 8px 16px;
            border-radius: 4px;
            cursor: pointer;
            transition: background 0.3s;
        }
        
        .btn:hover {
            background: #2980b9;
        }
        
        .btn-save {
            background: #27ae60;
        }
        
        .btn-save:hover {
            background: #219a52;
        }
        
        /* markdown预览样式 */
        .preview-content h1, .preview-content h2, .preview-content h3 {
            margin-top: 1.5em;
            margin-bottom: 0.5em;
            color: #2c3e50;
        }
        
        .preview-content code {
            background: #f8f9fa;
            padding: 2px 6px;
            border-radius: 3px;
            font-family: monospace;
        }
        
        .preview-content pre {
            background: #f8f9fa;
            padding: 15px;
            border-radius: 5px;
            overflow-x: auto;
        }
        
        .preview-content blockquote {
            border-left: 4px solid #3498db;
            padding-left: 15px;
            margin-left: 0;
            color: #7f8c8d;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>markdown编辑器</h1>
        
        <div class="toolbar">
            <button class="btn" onclick="inserttext('# 标题\\n')">标题</button>
            <button class="btn" onclick="inserttext('**粗体**')">粗体</button>
            <button class="btn" onclick="inserttext('*斜体*')">斜体</button>
            <button class="btn" onclick="inserttext('- 列表项')">列表</button>
            <button class="btn" onclick="inserttext('`代码`')">代码</button>
            <button class="btn" onclick="inserttext('[链接](http://)')">链接</button>
            <button class="btn btn-save" onclick="savedocument()">保存</button>
        </div>
        
        <div class="editor-container">
            <div class="editor-panel">
                <div class="panel-header">编辑器</div>
                <textarea id="markdowneditor" class="editor-textarea" 
                          placeholder="在此输入markdown内容..."># 欢迎使用markdown编辑器

这是一个**示例文档**，支持以下功能：

## 功能特性
- 实时预览
- 代码高亮
- 数学公式
- 流程图

### 数学公式示例
行内公式：$e = mc^2$

块级公式：
$$
\\nabla \\cdot \\mathbf{e} = \\frac{\\rho}{\\epsilon_0}
$$

### 代码示例
```python
def hello_world():
    print("hello, markdown!")

        <div class="preview-panel">
            <div class="panel-header">预览</div>
            <div id="preview" class="preview-content"></div>
        </div>
    </div>
</div>

<script>
    const editor = document.getelementbyid('markdowneditor');
    const preview = document.getelementbyid('preview');
    
    // 实时预览
    editor.addeventlistener('input', updatepreview);
    
    // 初始预览
    updatepreview();
    
    function updatepreview() {
        const content = editor.value;
        
        fetch('/preview', {
            method: 'post',
            headers: {
                'content-type': 'application/json',
            },
            body: json.stringify({ content: content })
        })
        .then(response => response.json())
        .then(data => {
            if (data.error) {
                preview.innerhtml = `<div class="error">错误: ${data.error}</div>`;
            } else {
                preview.innerhtml = data.html;
                // 重新初始化mermaid
                if (typeof mermaid !== 'undefined') {
                    mermaid.init();
                }
            }
        })
        .catch(error => {
            preview.innerhtml = `<div class="error">请求失败: ${error}</div>`;
        });
    }
    
    function inserttext(text) {
        const start = editor.selectionstart;
        const end = editor.selectionend;
        const selectedtext = editor.value.substring(start, end);
        
        editor.setrangetext(text);
        editor.focus();
        editor.setselectionrange(start + text.length, start + text.length);
        updatepreview();
    }
    
    function savedocument() {
        const filename = prompt('请输入文件名:');
        if (!filename) return;
        
        const content = editor.value;
        
        fetch('/save', {
            method: 'post',
            headers: {
                'content-type': 'application/json',
            },
            body: json.stringify({
                filename: filename,
                content: content
            })
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert('保存成功!');
            } else {
                alert('保存失败: ' + data.error);
            }
        })
        .catch(error => {
            alert('保存失败: ' + error);
        });
    }
    
    // 快捷键支持
    editor.addeventlistener('keydown', function(e) {
        if (e.ctrlkey || e.metakey) {
            switch(e.key) {
                case 's':
                    e.preventdefault();
                    savedocument();
                    break;
                case 'b':
                    e.preventdefault();
                    inserttext('**');
                    break;
                case 'i':
                    e.preventdefault();
                    inserttext('*');
                    break;
            }
        }
    });
</script>

#!/usr/bin/env python3
"""
markdown编辑器web应用
"""

import os
import logging
from datetime import datetime
from typing import dict, any, optional, list
from flask import flask, render_template, request, jsonify, send_from_directory

# markdown处理相关库
import markdown
from markdown.extensions import extension
from markdown.preprocessors import preprocessor
import pygments
from pygments import highlight
from pygments.lexers import get_lexer_by_name, textlexer
from pygments.formatters import htmlformatter

# 配置日志
logging.basicconfig(
    level=logging.info,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

class enhancedmarkdownconverter:
    """
    增强型markdown转换器
    支持代码高亮、数学公式、流程图等高级功能
    """
    
    def __init__(self):
        """初始化转换器"""
        self.logger = logging.getlogger(__name__)
        
        # 配置扩展
        self.extensions = [
            'markdown.extensions.extra',
            'markdown.extensions.toc',
            'markdown.extensions.tables',
            'markdown.extensions.codehilite',
            'markdown.extensions.fenced_code',
        ]
        
        self.extension_configs = {
            'markdown.extensions.codehilite': {
                'css_class': 'highlight',
                'linenums': true,
                'use_pygments': true,
            },
            'markdown.extensions.toc': {
                'title': '目录',
                'permalink': true,
            }
        }
        
        self.logger.info("增强型markdown转换器初始化完成")
    
    def convert(self, markdown_text: str) -> str:
        """
        转换markdown文本为html
        
        args:
            markdown_text: markdown格式文本
            
        returns:
            str: 转换后的html
        """
        try:
            if not markdown_text:
                return ""
            
            # 转换markdown
            html_content = markdown.markdown(
                markdown_text,
                extensions=self.extensions,
                extension_configs=self.extension_configs,
                output_format='html5'
            )
            
            # 添加样式支持
            html_content = self._wrap_with_styles(html_content)
            
            self.logger.debug(f"成功转换markdown文本")
            return html_content
            
        except exception as e:
            self.logger.error(f"markdown转换失败: {str(e)}")
            return f'<div class="error">转换错误: {str(e)}</div>'
    
    def _wrap_with_styles(self, html_content: str) -> str:
        """
        为html内容添加css样式包装
        
        args:
            html_content: html内容
            
        returns:
            str: 带样式的html
        """
        styles = """
        <style>
        .markdown-content {
            font-family: -apple-system, blinkmacsystemfont, 'segoe ui', roboto, sans-serif;
            line-height: 1.6;
            color: #333;
            max-width: 100%;
        }
        
        .markdown-content h1, .markdown-content h2, .markdown-content h3 {
            border-bottom: 1px solid #eaecef;
            padding-bottom: 0.3em;
            margin-top: 1.5em;
        }
        
        .markdown-content code {
            background-color: #f6f8fa;
            padding: 0.2em 0.4em;
            border-radius: 3px;
            font-size: 0.9em;
        }
        
        .markdown-content pre {
            background-color: #f6f8fa;
            padding: 1em;
            border-radius: 5px;
            overflow-x: auto;
        }
        
        .markdown-content blockquote {
            border-left: 4px solid #dfe2e5;
            padding-left: 1em;
            margin-left: 0;
            color: #6a737d;
        }
        
        .markdown-content table {
            border-collapse: collapse;
            width: 100%;
        }
        
        .markdown-content table th, .markdown-content table td {
            border: 1px solid #dfe2e5;
            padding: 0.5em;
        }
        
        .markdown-content table th {
            background-color: #f6f8fa;
        }
        
        .error {
            color: #d73a49;
            background-color: #ffebef;
            padding: 1em;
            border-radius: 5px;
        }
        </style>
        """
        
        return f'<div class="markdown-content">{html_content}</div>'

class markdownfilemanager:
    """markdown文件管理器"""
    
    def __init__(self, base_dir: str = "markdown_docs"):
        """
        初始化文件管理器
        
        args:
            base_dir: 文档存储基础目录
        """
        self.base_dir = base_dir
        os.makedirs(base_dir, exist_ok=true)
        self.logger = logging.getlogger(__name__)
    
    def list_documents(self) -> list[dict[str, any]]:
        """列出所有文档"""
        documents = []
        
        try:
            for filename in os.listdir(self.base_dir):
                if filename.endswith('.md'):
                    filepath = os.path.join(self.base_dir, filename)
                    stat = os.stat(filepath)
                    
                    documents.append({
                        'name': filename[:-3],  # 移除.md扩展名
                        'path': filepath,
                        'size': stat.st_size,
                        'modified': datetime.fromtimestamp(stat.st_mtime)
                    })
        except exception as e:
            self.logger.error(f"列出文档失败: {str(e)}")
        
        return sorted(documents, key=lambda x: x['modified'], reverse=true)
    
    def save_document(self, name: str, content: str) -> bool:
        """
        保存文档
        
        args:
            name: 文档名称
            content: 文档内容
            
        returns:
            bool: 是否保存成功
        """
        try:
            # 确保名称安全
            safe_name = "".join(c for c in name if c.isalnum() or c in ('-', '_'))
            if not safe_name:
                safe_name = "untitled"
            
            filepath = os.path.join(self.base_dir, f"{safe_name}.md")
            
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(content)
            
            self.logger.info(f"文档保存成功: {filepath}")
            return true
            
        except exception as e:
            self.logger.error(f"保存文档失败: {str(e)}")
            return false
    
    def load_document(self, name: str) -> optional[str]:
        """
        加载文档
        
        args:
            name: 文档名称
            
        returns:
            optional[str]: 文档内容，如果不存在返回none
        """
        try:
            filepath = os.path.join(self.base_dir, f"{name}.md")
            
            with open(filepath, 'r', encoding='utf-8') as f:
                return f.read()
                
        except filenotfounderror:
            self.logger.warning(f"文档不存在: {name}")
            return none
        except exception as e:
            self.logger.error(f"加载文档失败: {str(e)}")
            return none

# 创建flask应用
app = flask(__name__)
app.config['secret_key'] = 'your-secret-key-here'

# 初始化组件
markdown_converter = enhancedmarkdownconverter()
file_manager = markdownfilemanager()

@app.route('/')
def index():
    """首页"""
    documents = file_manager.list_documents()
    return render_template('index.html', documents=documents)

@app.route('/editor')
def editor():
    """编辑器页面"""
    doc_name = request.args.get('doc', '')
    content = ""
    
    if doc_name:
        content = file_manager.load_document(doc_name) or ""
    
    return render_template('editor.html', doc_name=doc_name, initial_content=content)

@app.route('/api/preview', methods=['post'])
def api_preview():
    """markdown预览api"""
    data = request.get_json()
    
    if not data or 'content' not in data:
        return jsonify({'error': '缺少内容参数'}), 400
    
    content = data['content']
    html_content = markdown_converter.convert(content)
    
    return jsonify({'html': html_content})

@app.route('/api/save', methods=['post'])
def api_save():
    """保存文档api"""
    data = request.get_json()
    
    if not data or 'name' not in data or 'content' not in data:
        return jsonify({'success': false, 'error': '缺少参数'}), 400
    
    name = data['name']
    content = data['content']
    
    if not name.strip():
        return jsonify({'success': false, 'error': '文档名称不能为空'})
    
    success = file_manager.save_document(name, content)
    
    if success:
        return jsonify({'success': true, 'message': '文档保存成功'})
    else:
        return jsonify({'success': false, 'error': '保存失败'})

@app.route('/api/documents')
def api_documents():
    """获取文档列表api"""
    documents = file_manager.list_documents()
    return jsonify({'documents': documents})

@app.route('/view/<doc_name>')
def view_document(doc_name):
    """查看文档页面"""
    content = file_manager.load_document(doc_name)
    
    if content is none:
        return render_template('error.html', message='文档不存在')
    
    html_content = markdown_converter.convert(content)
    return render_template('viewer.html', title=doc_name, content=html_content)

@app.route('/static/<path:filename>')
def static_files(filename):
    """静态文件服务"""
    return send_from_directory('static', filename)

# 错误处理
@app.errorhandler(404)
def not_found(error):
    return render_template('error.html', message='页面未找到'), 404

@app.errorhandler(500)
def internal_error(error):
    return render_template('error.html', message='服务器内部错误'), 500

if __name__ == '__main__':
    # 创建模板目录（如果不存在）
    os.makedirs('templates', exist_ok=true)
    os.makedirs('static', exist_ok=true)
    
    # 运行应用
    app.run(
        host='0.0.0.0',
        port=5000,
        debug=true
    )

<!doctype html>
<html lang="zh-cn">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}markdown编辑器{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}" rel="external nofollow" >
</head>
<body>
    <nav class="navbar">
        <div class="nav-container">
            <h1 class="nav-brand">markdown编辑器</h1>
            <div class="nav-links">
                <a href="{{ url_for('index') }}" rel="external nofollow" >首页</a>
                <a href="{{ url_for('editor') }}" rel="external nofollow"  rel="external nofollow" >新建文档</a>
            </div>
        </div>
    </nav>
    
    <main class="main-content">
        {% block content %}{% endblock %}
    </main>
    
    <footer class="footer">
        <p>&copy; 2024 markdown编辑器. 基于python和flask构建.</p>
    </footer>
    
    {% block scripts %}{% endblock %}
</body>
</html>

{% extends "base.html" %}

{% block content %}
<div class="container">
    <div class="header">
        <h2>我的文档</h2>
        <a href="{{ url_for('editor') }}" rel="external nofollow"  rel="external nofollow"  class="btn btn-primary">新建文档</a>
    </div>
    
    <div class="document-list">
        {% if documents %}
            {% for doc in documents %}
            <div class="document-card">
                <h3>{{ doc.name }}</h3>
                <p>修改时间: {{ doc.modified.strftime('%y-%m-%d %h:%m') }}</p>
                <p>大小: {{ (doc.size / 1024)|round(2) }} kb</p>
                <div class="document-actions">
                    <a href="{{ url_for('editor', doc=doc.name) }}" rel="external nofollow"  class="btn">编辑</a>
                    <a href="{{ url_for('view_document', doc_name=doc.name) }}" rel="external nofollow"  class="btn">查看</a>
                </div>
            </div>
            {% endfor %}
        {% else %}
            <div class="empty-state">
                <p>还没有文档，点击"新建文档"开始创作吧！</p>
            </div>
        {% endif %}
    </div>
</div>
{% endblock %}

import unittest
import tempfile
import os
from your_app import enhancedmarkdownconverter, markdownfilemanager

class testmarkdownconverter(unittest.testcase):
    """markdown转换器测试"""
    
    def setup(self):
        self.converter = enhancedmarkdownconverter()
    
    def test_basic_conversion(self):
        """测试基础转换"""
        markdown = "# 标题\n\n这是一个段落"
        result = self.converter.convert(markdown)
        self.assertin("<h1>标题</h1>", result)
        self.assertin("<p>这是一个段落</p>", result)
    
    def test_code_highlighting(self):
        """测试代码高亮"""
        markdown = "```python\nprint('hello')\n```"
        result = self.converter.convert(markdown)
        self.assertin("highlight", result)

class testfilemanager(unittest.testcase):
    """文件管理器测试"""
    
    def setup(self):
        self.temp_dir = tempfile.mkdtemp()
        self.manager = markdownfilemanager(self.temp_dir)
    
    def test_save_and_load(self):
        """测试保存和加载"""
        test_content = "# 测试文档\n\n内容"
        self.manager.save_document("test", test_content)
        
        loaded = self.manager.load_document("test")
        self.assertequal(loaded, test_content)
    
    def teardown(self):
        import shutil
        shutil.rmtree(self.temp_dir)

if __name__ == '__main__':
    unittest.main()

import time
import random
import string

def generate_random_markdown(length=1000):
    """生成随机markdown内容"""
    sections = []
    
    for _ in range(length // 100):
        # 标题
        title_level = random.randint(1, 3)
        title = ''.join(random.choices(string.ascii_letters, k=10))
        sections.append('#' * title_level + ' ' + title)
        
        # 段落
        paragraph = ' '.join(''.join(random.choices(string.ascii_letters, k=5)) 
                           for _ in range(20))
        sections.append(paragraph)
        
        # 代码块
        if random.random() > 0.7:
            code = '\n'.join(''.join(random.choices(string.printable, k=30)) 
                           for _ in range(5))
            sections.append(f"```python\n[code]\n```")
    
    return '\n\n'.join(sections)

def performance_test():
    """性能测试"""
    converter = enhancedmarkdownconverter()
    
    # 生成测试数据
    test_data = generate_random_markdown(5000)
    
    # 测试转换性能
    start_time = time.time()
    result = converter.convert(test_data)
    end_time = time.time()
    
    print(f"转换性能: {len(test_data)} 字符 -> {len(result)} 字符")
    print(f"耗时: {end_time - start_time:.4f} 秒")
    print(f"速度: {len(test_data) / (end_time - start_time) / 1000:.2f} k字符/秒")

if __name__ == "__main__":
    performance_test()

# wsgi.py
from your_app import app

if __name__ == "__main__":
    app.run()

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:5000 wsgi:app

from flask import flask
from flask_limiter import limiter
from flask_limiter.util import get_remote_address

app = flask(__name__)
limiter = limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route('/api/preview', methods=['post'])
@limiter.limit("10 per minute")  # 限制预览频率
def api_preview():
    # ... 原有代码