feat: 新增文档模型类，调整配置与解析逻辑，优化日志及导入

移除日志设置与冗余代码，优化导入、类型提示及OCR后端管理
统一调整各文件模块导入路径为绝对导入
调整导入路径，移除部分导入，优化日志及注释
升级文档解析器为 Docx2Parser，优化超时与图片处理逻辑

docreader/parser/parser.py

@@ -1,30 +1,19 @@
 import logging
-from dataclasses import dataclass, field
-from typing import Dict, Any, Optional, Type
+from typing import Dict, Type
 
-from .base_parser import BaseParser, ParseResult
-from .docx_parser import DocxParser
-from .doc_parser import DocParser
-from .pdf_parser import PDFParser
-from .markdown_parser import MarkdownParser
-from .text_parser import TextParser
-from .image_parser import ImageParser
-from .web_parser import WebParser
-from .config import ChunkingConfig
-import traceback
+from docreader.models.document import Document
+from docreader.models.read_config import ChunkingConfig
+from docreader.parser.base_parser import BaseParser
+from docreader.parser.doc_parser import DocParser
+from docreader.parser.docx2_parser import Docx2Parser
+from docreader.parser.image_parser import ImageParser
+from docreader.parser.markdown_parser import MarkdownParser
+from docreader.parser.pdf_parser import PDFParser
+from docreader.parser.text_parser import TextParser
+from docreader.parser.web_parser import WebParser
 
 logger = logging.getLogger(__name__)
 
-@dataclass
-class Chunk:
-    """
-    Represents a single text chunk with associated metadata.
-    Basic unit for document processing and embedding.
-    """
-
-    content: str  # Text content of the chunk
-    metadata: Dict[str, Any] = None  # Associated metadata (source, page number, etc.)
-
 
 class Parser:
     """
@@ -33,10 +22,9 @@ class Parser:
     """
 
     def __init__(self):
-        logger.info("Initializing document parser")
         # Initialize all parser types
         self.parsers: Dict[str, Type[BaseParser]] = {
-            "docx": DocxParser,
+            "docx": Docx2Parser,
             "doc": DocParser,
             "pdf": PDFParser,
             "md": MarkdownParser,
@@ -56,8 +44,7 @@ class Parser:
             ", ".join(self.parsers.keys()),
         )
 
-
-    def get_parser(self, file_type: str) -> Optional[Type[BaseParser]]:
+    def get_parser(self, file_type: str) -> Type[BaseParser]:
         """
         Get parser class for the specified file type.
 
@@ -67,12 +54,9 @@ class Parser:
         Returns:
             Parser class for the file type, or None if unsupported
         """
-        file_type = file_type.lower()
-        parser = self.parsers.get(file_type)
-        if parser:
-            logger.info(f"Found parser for file type: {file_type}")
-        else:
-            logger.warning(f"No parser found for file type: {file_type}")
+        parser = self.parsers.get(file_type.lower())
+        if not parser:
+            raise ValueError(f"Unsupported file type: {file_type}")
         return parser
 
     def parse_file(
@@ -81,7 +65,7 @@ class Parser:
         file_type: str,
         content: bytes,
         config: ChunkingConfig,
-    ) -> Optional[ParseResult]:
+    ) -> Document:
         """
         Parse file content using appropriate parser based on file type.
 
@@ -96,60 +80,41 @@ class Parser:
         """
         logger.info(f"Parsing file: {file_name} with type: {file_type}")
         logger.info(
-            f"Chunking config: size={config.chunk_size}, overlap={config.chunk_overlap}, "
+            f"Chunking config: size={config.chunk_size}, "
+            f"overlap={config.chunk_overlap}, "
             f"multimodal={config.enable_multimodal}"
         )
-        
-        parser_instance = None
-        
-        try:
-            # Get appropriate parser for file type
-            cls = self.get_parser(file_type)
-            if cls is None:
-                logger.error(f"Unsupported file type: {file_type}")
-                return None
 
-            # Parse file content
-            logger.info(f"Creating parser instance for {file_type} file")
-            parser_instance = cls(
-                file_name=file_name,
-                file_type=file_type,
-                chunk_size=config.chunk_size,
-                chunk_overlap=config.chunk_overlap,
-                separators=config.separators,
-                enable_multimodal=config.enable_multimodal,
-                max_image_size=1920,  # Limit image size to 1920px
-                max_concurrent_tasks=5,  # Limit concurrent tasks to 5
-                chunking_config=config,  # Pass the entire chunking config
-            )
+        # Get appropriate parser for file type
+        cls = self.get_parser(file_type)
 
-            logger.info(f"Starting to parse file content, size: {len(content)} bytes")
-            result = parser_instance.parse(content)
+        # Parse file content
+        logger.info(f"Creating parser instance for {file_type} file")
+        parser = cls(
+            file_name=file_name,
+            file_type=file_type,
+            chunk_size=config.chunk_size,
+            chunk_overlap=config.chunk_overlap,
+            separators=config.separators,
+            enable_multimodal=config.enable_multimodal,
+            max_image_size=1920,  # Limit image size to 1920px
+            max_concurrent_tasks=5,  # Limit concurrent tasks to 5
+            chunking_config=config,  # Pass the entire chunking config
+        )
 
-            if result:
-                logger.info(
-                    f"Successfully parsed file {file_name}, generated {len(result.chunks)} chunks"
-                )
-                if result.chunks and len(result.chunks) > 0:
-                    logger.info(
-                        f"First chunk content length: {len(result.chunks[0].content)}"
-                    )
-                else:
-                    logger.warning(f"Parser returned empty chunks for file: {file_name}")
-            else:
-                logger.warning(f"Parser returned None result for file: {file_name}")
+        logger.info(f"Starting to parse file content, size: {len(content)} bytes")
+        result = parser.parse(content)
 
-            # Return parse results
-            return result
+        if not result.content:
+            logger.warning(f"Parser returned empty content for file: {file_name}")
+        elif not result.chunks:
+            logger.warning(f"Parser returned empty chunks for file: {file_name}")
+        elif result.chunks[0]:
+            logger.info(f"First chunk content length: {len(result.chunks[0].content)}")
+        logger.info(f"Parsed file {file_name}, with {len(result.chunks)} chunks")
+        return result
 
-        except Exception as e:
-            logger.error(f"Error parsing file {file_name}: {str(e)}")
-            logger.info(f"Detailed traceback: {traceback.format_exc()}")
-            return None
-
-    def parse_url(
-        self, url: str, title: str, config: ChunkingConfig
-    ) -> Optional[ParseResult]:
+    def parse_url(self, url: str, title: str, config: ChunkingConfig) -> Document:
         """
         Parse content from a URL using the WebParser.
 
@@ -163,44 +128,31 @@ class Parser:
         """
         logger.info(f"Parsing URL: {url}, title: {title}")
         logger.info(
-            f"Chunking config: size={config.chunk_size}, overlap={config.chunk_overlap}, "
-            f"multimodal={config.enable_multimodal}"
+            f"Chunking config: size={config.chunk_size}, "
+            f"overlap={config.chunk_overlap}, multimodal={config.enable_multimodal}"
         )
-        
-        parser_instance = None
 
-        try:
-            # Create web parser instance
-            logger.info("Creating WebParser instance")
-            parser_instance = WebParser(
-                title=title,
-                chunk_size=config.chunk_size,
-                chunk_overlap=config.chunk_overlap,
-                separators=config.separators,
-                enable_multimodal=config.enable_multimodal,
-                max_image_size=1920,  # Limit image size
-                max_concurrent_tasks=5,  # Limit concurrent tasks
-                chunking_config=config,
-            )
+        # Create web parser instance
+        logger.info("Creating WebParser instance")
+        parser = WebParser(
+            title=title,
+            chunk_size=config.chunk_size,
+            chunk_overlap=config.chunk_overlap,
+            separators=config.separators,
+            enable_multimodal=config.enable_multimodal,
+            max_image_size=1920,  # Limit image size
+            max_concurrent_tasks=5,  # Limit concurrent tasks
+            chunking_config=config,
+        )
 
-            logger.info(f"Starting to parse URL content")
-            result = parser_instance.parse(url)
-
-            if result:
-                logger.info(
-                    f"Successfully parsed URL, generated {len(result.chunks)} chunks"
-                )
-                logger.info(
-                    f"First chunk content length: {len(result.chunks[0].content) if result.chunks else 0}"
-                )
-            else:
-                logger.warning(f"Parser returned empty result for URL: {url}")
-
-            # Return parse results
-            return result
-
-        except Exception as e:
-            logger.error(f"Error parsing URL {url}: {str(e)}")
-            logger.info(f"Detailed traceback: {traceback.format_exc()}")
-            return None
+        logger.info("Starting to parse URL content")
+        result = parser.parse(url.encode())
 
+        if not result.content:
+            logger.warning(f"Parser returned empty content for url: {url}")
+        elif not result.chunks:
+            logger.warning(f"Parser returned empty chunks for url: {url}")
+        elif result.chunks[0]:
+            logger.info(f"First chunk content length: {len(result.chunks[0].content)}")
+        logger.info(f"Parsed url {url}, with {len(result.chunks)} chunks")
+        return result