deepdoc-lib 0.2.0__py3-none-any.whl

deepdoc/depend/simple_cv_model.py

@@ -0,0 +1,469 @@
+import base64
+import io
+import json
+import os
+import uuid
+from abc import ABC
+from io import BytesIO
+from urllib.parse import urljoin
+
+import requests
+from openai import OpenAI
+from openai.lib.azure import AzureOpenAI
+from PIL import Image
+from zhipuai import ZhipuAI
+
+# 可选导入 ollama
+try:
+    from ollama import Client
+    OLLAMA_AVAILABLE = True
+except ImportError:
+    OLLAMA_AVAILABLE = False
+    Client = None
+
+# 修复导入路径问题
+try:
+    from .prompts import vision_llm_describe_prompt
+except ImportError:
+    try:
+        from ..depend.prompts import vision_llm_describe_prompt
+    except ImportError:
+        # 如果都失败，提供默认提示词
+        vision_llm_describe_prompt = """请详细描述这张图片的内容，包括：
+1. 图片中的主要对象和场景
+2. 任何可见的文字内容
+3. 图片的布局和结构
+4. 如果有表格，请描述表格的结构和内容
+5. 如果有图表，请描述图表的数据和趋势
+
+请用中文回答，描述要准确、详细。"""
+
+
+class Base(ABC):
+    def __init__(self, key, model_name, lang="Chinese"):
+        self.key = key
+        self.model_name = model_name
+        self.lang = lang
+
+    def image2base64(self, binary):
+        """将图片转换为base64编码"""
+        if isinstance(binary, BytesIO):
+            binary.seek(0)
+            img_data = binary.read()
+        elif isinstance(binary, bytes):
+            img_data = binary
+        else:
+            raise ValueError("binary must be BytesIO or bytes")
+        
+        return base64.b64encode(img_data).decode('utf-8')
+
+    def prompt(self, image):
+        """生成提示词"""
+        return self.vision_llm_prompt(image)
+
+    def vision_llm_prompt(self, image):
+        """生成视觉LLM提示词"""
+        if self.lang.lower() == "chinese":
+            prompt_text = vision_llm_describe_prompt()
+        else:
+            prompt_text = "Please describe this image in detail."
+        
+        return prompt_text
+
+
+class GptV4(Base):
+    _FACTORY_NAME = "OpenAI"
+
+    def __init__(self, key, model_name="gpt-4-vision-preview", lang="Chinese", **kwargs):
+        super().__init__(key, model_name, lang)
+        self.client = OpenAI(api_key=key)
+
+    def describe_with_prompt(self, image, prompt=None):
+        """使用OpenAI GPT-4 Vision模型描述图片"""
+        try:
+            base64_image = self.image2base64(image)
+            
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt or self.prompt(image)
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}"
+                            }
+                        }
+                    ]
+                }
+            ]
+
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                max_tokens=1000
+            )
+
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            return "**ERROR**: " + str(e)
+
+
+class QWenCV(Base):
+    _FACTORY_NAME = "Tongyi-Qianwen"
+
+    def __init__(self, key, model_name="qwen-vl-max", lang="Chinese", **kwargs):
+        super().__init__(key, model_name, lang)
+        # 使用兼容模式的OpenAI API
+        self.client = OpenAI(
+            api_key=key,
+            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+        )
+
+    def describe_with_prompt(self, image, prompt=None):
+        """使用通义千问视觉模型描述图片"""
+        try:
+            base64_image = self.image2base64(image)
+            
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt or self.prompt(image)
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}"
+                            }
+                        }
+                    ]
+                }
+            ]
+
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                max_tokens=1000
+            )
+
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            return "**ERROR**: " + str(e)
+
+
+class Zhipu4V(Base):
+    _FACTORY_NAME = "ZhipuAI"
+
+    def __init__(self, key, model_name="glm-4v", lang="Chinese", **kwargs):
+        super().__init__(key, model_name, lang)
+        self.client = ZhipuAI(api_key=key)
+
+    def describe_with_prompt(self, image, prompt=None):
+        """使用智谱AI视觉模型描述图片"""
+        try:
+            base64_image = self.image2base64(image)
+            
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": prompt or self.prompt(image)
+                            },
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{base64_image}"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                max_tokens=1000
+            )
+
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            return "**ERROR**: " + str(e)
+
+
+class OllamaCV(Base):
+    _FACTORY_NAME = "Ollama"
+
+    def __init__(self, key, model_name, lang="Chinese", **kwargs):
+        if not OLLAMA_AVAILABLE:
+            raise ImportError("Ollama客户端未安装，请运行: pip install ollama")
+        self.client = Client(host=kwargs.get("base_url", "http://localhost:11434"))
+        self.model_name = model_name
+        self.lang = lang
+
+    def describe(self, image):
+        prompt = self.prompt("")
+        try:
+            response = self.client.generate(
+                model=self.model_name,
+                prompt=prompt[0]["content"][1]["text"],
+                images=[image],
+            )
+            ans = response["response"].strip()
+            return ans, 128
+        except Exception as e:
+            return "**ERROR**: " + str(e), 0
+
+    def describe_with_prompt(self, image, prompt=None):
+        vision_prompt = self.vision_llm_prompt("", prompt) if prompt else self.vision_llm_prompt("")
+        try:
+            response = self.client.generate(
+                model=self.model_name,
+                prompt=vision_prompt[0]["content"][1]["text"],
+                images=[image],
+            )
+            ans = response["response"].strip()
+            return ans, 128
+        except Exception as e:
+            return "**ERROR**: " + str(e), 0
+
+    def chat(self, system, history, gen_conf, image=""):
+        if system:
+            history[-1]["content"] = system + history[-1]["content"] + "user query: " + history[-1]["content"]
+
+        try:
+            for his in history:
+                if his["role"] == "user":
+                    his["images"] = [image]
+            options = {}
+            if "temperature" in gen_conf:
+                options["temperature"] = gen_conf["temperature"]
+            if "top_p" in gen_conf:
+                options["top_k"] = gen_conf["top_p"]
+            if "presence_penalty" in gen_conf:
+                options["presence_penalty"] = gen_conf["presence_penalty"]
+            if "frequency_penalty" in gen_conf:
+                options["frequency_penalty"] = gen_conf["frequency_penalty"]
+            response = self.client.chat(
+                model=self.model_name,
+                messages=history,
+                options=options,
+                keep_alive=-1,
+            )
+
+            ans = response["message"]["content"].strip()
+            return ans, response["eval_count"] + response.get("prompt_eval_count", 0)
+        except Exception as e:
+            return "**ERROR**: " + str(e), 0
+
+    def chat_streamly(self, system, history, gen_conf, image=""):
+        if system:
+            history[-1]["content"] = system + history[-1]["content"] + "user query: " + history[-1]["content"]
+
+        for his in history:
+            if his["role"] == "user":
+                his["images"] = [image]
+        options = {}
+        if "temperature" in gen_conf:
+            options["temperature"] = gen_conf["temperature"]
+        if "top_p" in gen_conf:
+            options["top_k"] = gen_conf["top_p"]
+        if "presence_penalty" in gen_conf:
+            options["presence_penalty"] = gen_conf["presence_penalty"]
+        if "frequency_penalty" in gen_conf:
+            options["frequency_penalty"] = gen_conf["frequency_penalty"]
+        ans = ""
+        try:
+            response = self.client.chat(
+                model=self.model_name,
+                messages=history,
+                stream=True,
+                options=options,
+                keep_alive=-1,
+            )
+            for resp in response:
+                if resp["done"]:
+                    yield resp.get("prompt_eval_count", 0) + resp.get("eval_count", 0)
+                ans += resp["message"]["content"]
+                yield ans
+        except Exception as e:
+            yield ans + "\n**ERROR**: " + str(e)
+        yield 0
+
+
+class GeminiCV(Base):
+    _FACTORY_NAME = "Google-Gemini"
+
+    def __init__(self, key, model_name="gemini-pro-vision", lang="Chinese", **kwargs):
+        super().__init__(key, model_name, lang)
+        import google.generativeai as genai
+        genai.configure(api_key=key)
+        self.model = genai.GenerativeModel(model_name)
+
+    def describe_with_prompt(self, image, prompt=None):
+        """使用Google Gemini模型描述图片"""
+        try:
+            if isinstance(image, BytesIO):
+                image.seek(0)
+                img_data = image.read()
+            elif isinstance(image, bytes):
+                img_data = image
+            else:
+                raise ValueError("image must be BytesIO or bytes")
+            
+            pil_image = Image.open(BytesIO(img_data))
+            
+            response = self.model.generate_content([
+                prompt or self.prompt(image),
+                pil_image
+            ])
+
+            return response.text.strip()
+        except Exception as e:
+            return "**ERROR**: " + str(e)
+
+
+class AnthropicCV(Base):
+    _FACTORY_NAME = "Anthropic"
+
+    def __init__(self, key, model_name="claude-3-sonnet-20240229", lang="Chinese", **kwargs):
+        super().__init__(key, model_name, lang)
+        import anthropic
+        self.client = anthropic.Anthropic(api_key=key)
+
+    def describe_with_prompt(self, image, prompt=None):
+        """使用Anthropic Claude模型描述图片"""
+        try:
+            base64_image = self.image2base64(image)
+            
+            message = self.client.messages.create(
+                model=self.model_name,
+                max_tokens=1000,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": prompt or self.prompt(image)
+                            },
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": "image/jpeg",
+                                    "data": base64_image
+                                }
+                            }
+                        ]
+                    }
+                ]
+            )
+
+            return message.content[0].text.strip()
+        except Exception as e:
+            return "**ERROR**: " + str(e)
+
+
+class VisionModelFactory:
+    """视觉模型工厂类"""
+    
+    _PROVIDERS = {
+        "openai": GptV4,
+        "qwen": QWenCV,
+        "zhipu": Zhipu4V,
+        "ollama": OllamaCV,
+        "gemini": GeminiCV,
+        "anthropic": AnthropicCV,
+    }
+
+    @classmethod
+    def create_model(cls, config):
+        """根据配置创建视觉模型实例"""
+        provider = config.get("provider", "openai").lower()
+        model_name = config.get("model_name", "")
+        api_key = config.get("api_key", "")
+        lang = config.get("lang", "Chinese")
+        base_url = config.get("base_url", "")
+        
+        if provider not in cls._PROVIDERS:
+            raise ValueError(f"不支持的提供商: {provider}")
+        
+        model_class = cls._PROVIDERS[provider]
+        
+        # 根据提供商设置默认模型名称
+        if not model_name:
+            if provider == "openai":
+                model_name = "gpt-4-vision-preview"
+            elif provider == "qwen":
+                model_name = "qwen-vl-max"
+            elif provider == "zhipu":
+                model_name = "glm-4v"
+            elif provider == "gemini":
+                model_name = "gemini-pro-vision"
+            elif provider == "anthropic":
+                model_name = "claude-3-sonnet-20240229"
+        
+        kwargs = {"lang": lang}
+        if base_url:
+            kwargs["base_url"] = base_url
+        
+        return model_class(api_key, model_name, **kwargs)
+
+    @classmethod
+    def create_from_env(cls):
+        """从环境变量创建模型"""
+        config = {
+            "provider": os.getenv("DEEPDOC_VISION_PROVIDER", "openai"),
+            "model_name": os.getenv("DEEPDOC_VISION_MODEL", ""),
+            "api_key": os.getenv("DEEPDOC_VISION_API_KEY", ""),
+            "lang": os.getenv("DEEPDOC_VISION_LANG", "Chinese"),
+            "base_url": os.getenv("DEEPDOC_VISION_BASE_URL", ""),
+        }
+        return cls.create_model(config)
+
+    @classmethod
+    def create_from_config_file(cls, config_file="deepdoc_config.yaml"):
+        """从配置文件创建模型"""
+        try:
+            import yaml
+            with open(config_file, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+            vision_config = config.get("vision_model", {})
+            return cls.create_model(vision_config)
+        except Exception as e:
+            raise ValueError(f"Failed to load config from {config_file}: {e}")
+
+
+def create_vision_model(config=None):
+    """创建视觉模型 - 支持多种配置方式"""
+    if config is None:
+        # 方式1：从环境变量创建
+        return VisionModelFactory.create_from_env()
+    
+    elif isinstance(config, str):
+        # 方式2：字符串配置
+        if config.lower() in VisionModelFactory._PROVIDERS:
+            # 字符串是提供商名称
+            return VisionModelFactory.create_model({"provider": config.lower()})
+        elif config.endswith(('.yaml', '.yml', '.json')):
+            # 字符串是配置文件路径
+            return VisionModelFactory.create_from_config_file(config)
+        else:
+            # 尝试作为配置文件路径处理
+            try:
+                return VisionModelFactory.create_from_config_file(config)
+            except:
+                raise ValueError(f"无效的配置: {config}。支持的提供商: {list(VisionModelFactory._PROVIDERS.keys())}")
+    
+    elif isinstance(config, dict):
+        # 方式3：字典配置
+        return VisionModelFactory.create_model(config)
+    
+    else:
+        raise ValueError(f"不支持的配置类型: {type(config)}")

deepdoc/depend/surname.py

@@ -0,0 +1,91 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+"""
+Simple Chinese surname detection utility for resume parsing.
+"""
+
+# Common Chinese surnames (most frequent ones)
+CHINESE_SURNAMES = {
+    # Single character surnames (most common)
+    '王', '李', '张', '刘', '陈', '杨', '赵', '黄', '周', '吴',
+    '徐', '孙', '胡', '朱', '高', '林', '何', '郭', '马', '罗',
+    '梁', '宋', '郑', '谢', '韩', '唐', '冯', '于', '董', '萧',
+    '程', '曹', '袁', '邓', '许', '傅', '沈', '曾', '彭', '吕',
+    '苏', '卢', '蒋', '蔡', '贾', '丁', '魏', '薛', '叶', '阎',
+    '余', '潘', '杜', '戴', '夏', '钟', '汪', '田', '任', '姜',
+    '范', '方', '石', '姚', '谭', '廖', '邹', '熊', '金', '陆',
+    '郝', '孔', '白', '崔', '康', '毛', '邱', '秦', '江', '史',
+    '顾', '侯', '邵', '孟', '龙', '万', '段', '漕', '钱', '汤',
+    '尹', '黎', '易', '常', '武', '乔', '贺', '赖', '龚', '文',
+
+    # Double character surnames (common compound surnames)
+    '欧阳', '太史', '端木', '上官', '司马', '东方', '公孙', '万俟', '闻人',
+    '夏侯', '诸葛', '尉迟', '公西', '澹台', '赫连', '皇甫', '宗政', '濮阳',
+    '公冶', '太叔', '申屠', '公孙', '慕容', '仲孙', '钟离', '长孙', '司徒',
+    '鲜于', '司空', '宇文', '长孙', '慕容', '司徒'
+}
+
+
+class SurnameChecker:
+    """Chinese surname checker utility"""
+
+    def __init__(self):
+        self.surnames = CHINESE_SURNAMES
+
+    def isit(self, text: str) -> bool:
+        """
+        Check if the given text starts with a Chinese surname.
+
+        Args:
+            text: Text to check
+
+        Returns:
+            bool: True if text starts with a Chinese surname
+        """
+        if not text or not isinstance(text, str):
+            return False
+
+        text = text.strip()
+
+        # Check single character surnames
+        if len(text) >= 1 and text[0] in self.surnames:
+            return True
+
+        # Check double character surnames
+        if len(text) >= 2:
+            double_surname = text[:2]
+            if double_surname in self.surnames:
+                return True
+
+        return False
+
+
+# Global instance for backward compatibility
+surname = SurnameChecker()
+
+
+def is_chinese_surname(text: str) -> bool:
+    """
+    Check if text starts with a Chinese surname.
+
+    Args:
+        text: Text to check
+
+    Returns:
+        bool: True if starts with Chinese surname
+    """
+    return surname.isit(text)

deepdoc/depend/timeout.py

@@ -0,0 +1,73 @@
+import asyncio
+import queue
+import trio
+import threading
+from functools import wraps
+from typing import Any, Callable, Coroutine, Optional, Type, Union
+
+TimeoutException = Union[Type[BaseException], BaseException]
+OnTimeoutCallback = Union[Callable[..., Any], Coroutine[Any, Any, Any]]
+
+def timeout(seconds: float | int = None, attempts: int = 2, *, exception: Optional[TimeoutException] = None, on_timeout: Optional[OnTimeoutCallback] = None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            result_queue = queue.Queue(maxsize=1)
+
+            def target():
+                try:
+                    result = func(*args, **kwargs)
+                    result_queue.put(result)
+                except Exception as e:
+                    result_queue.put(e)
+
+            thread = threading.Thread(target=target)
+            thread.daemon = True
+            thread.start()
+
+            for a in range(attempts):
+                try:
+                    result = result_queue.get(timeout=seconds)
+                    if isinstance(result, Exception):
+                        raise result
+                    return result
+                except queue.Empty:
+                    pass
+            raise TimeoutError(f"Function '{func.__name__}' timed out after {seconds} seconds and {attempts} attempts.")
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            if seconds is None:
+                return await func(*args, **kwargs)
+
+            for a in range(attempts):
+                try:
+                    with trio.fail_after(seconds):
+                        return await func(*args, **kwargs)
+                except trio.TooSlowError:
+                    if a < attempts - 1:
+                        continue
+                    if on_timeout is not None:
+                        if callable(on_timeout):
+                            result = on_timeout()
+                            if isinstance(result, Coroutine):
+                                return await result
+                            return result
+                        return on_timeout
+
+                    if exception is None:
+                        raise TimeoutError(f"Operation timed out after {seconds} seconds and {attempts} attempts.")
+
+                    if isinstance(exception, BaseException):
+                        raise exception
+
+                    if isinstance(exception, type) and issubclass(exception, BaseException):
+                        raise exception(f"Operation timed out after {seconds} seconds and {attempts} attempts.")
+
+                    raise RuntimeError("Invalid exception type provided")
+
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return wrapper
+
+    return decorator

deepdoc/depend/vision_llm_chunk.py

@@ -0,0 +1,35 @@
+import io
+import re
+
+def clean_markdown_block(text):
+    text = re.sub(r'^\s*```markdown\s*\n?', '', text)
+    text = re.sub(r'\n?\s*```\s*$', '', text)
+    return text.strip()
+
+def vision_llm_chunk(binary, vision_model, prompt=None, callback=None):
+    """
+    A simple wrapper to process image to markdown texts via VLM.
+
+    Returns:
+        Simple markdown texts generated by VLM.
+    """
+    callback = callback or (lambda prog, msg: None)
+
+    img = binary
+    txt = ""
+
+    try:
+        img_binary = io.BytesIO()
+        img.save(img_binary, format='JPEG')
+        img_binary.seek(0)
+
+        ans = clean_markdown_block(vision_model.describe_with_prompt(img_binary.read(), prompt))
+
+        txt += "\n" + ans
+
+        return txt
+
+    except Exception as e:
+        callback(-1, str(e))
+
+    return ""

deepdoc/dict/README.md

@@ -0,0 +1,19 @@
+---
+license: apache-2.0
+---
+
+### Model Loading
+```python
+import xgboost as xgb
+import torch
+
+model = xgb.Booster()
+if torch.cuda.is_available():
+model.set_param({"device": "cuda"})
+model.load_model('InfiniFlow/text_concat_xgb_v1.0')
+```
+
+### Prediction
+```python
+model.predict(xgb.DMatrix([feature]))[0]
+```