maque 0.2.1__py3-none-any.whl

maque/io/__init__.py

@@ -0,0 +1,29 @@
+from .core import *
+from .ops import *
+from subprocess import Popen, PIPE
+from pathlib import Path
+
+
+def run(cmd, **env):
+    cmd = cmd.split(" ") if isinstance(cmd, str) else cmd
+    p = Popen(cmd, cwd=str(Path(__file__).parent), env={**os.environ, **env})
+    p.communicate()
+    return p.returncode
+
+def replace_in_file(file, old, new):
+    with open(file, "r") as f:
+        content = f.read()
+    content = content.replace(old, new)
+    with open(file, "w") as f:
+        f.write(content)
+
+def replace_var_in_file(filename, var, new, from_line=0, to_line=-1):
+    with open(filename, 'r') as fr:
+        init_list = fr.readlines()
+    for idx, line in enumerate(init_list[from_line:to_line]):
+        if "__version__" in line:
+            new_line = f"""{var} = {new}\n"""
+            init_list[idx] = new_line
+            break
+    with open(filename, 'w') as fw:
+        fw.writelines(init_list)

maque/io/core.py

@@ -0,0 +1,38 @@
+from functools import wraps
+import pickle
+
+
+def save_var(filename, data):
+    with open(filename, "wb") as fw:
+        pickle.dump(data, fw)
+
+
+def load_var(filename):
+    with open(filename, "rb") as fi:
+        data = pickle.load(fi)
+    return data
+
+
+def broadcast(func):  # It can be replaced by `np.vectorize`
+    """Only for a functions with a single argument
+    example:
+    @broadcast
+    def f(x):
+        # A function that can map only a single element
+        if x==1 or x==0:
+            return x
+        else:
+            return f(x-1)+f(x-2)
+
+    >> f([2,4,10])
+    >> (1, 3, 832040)
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        value_list = []
+        for arg in args:
+            value_list.append(func(arg, **kwargs))
+        return tuple(value_list)
+
+    return wrapper

maque/io/ops.py

@@ -0,0 +1,194 @@
+from maque.utils.path import rel_to_abs, ls
+import pickle
+from typing import Union, List, Dict
+import shutil
+import os
+import yaml
+import orjson
+
+
+def rm(*file_pattern: str, rel=False):
+    """Remove files or directories.
+    Example:
+    --------
+        >>> rm("*.jpg", "*.png")
+        >>> rm("*.jpg", "*.png", rel=True)
+    """
+    path_list = ls(".", *file_pattern, relp=rel, concat="extend")
+    for file in path_list:
+        if os.path.isfile(file):
+            os.remove(file)
+        elif os.path.isdir(file):
+            shutil.rmtree(file, ignore_errors=True)
+
+
+def save(filename, data):
+    import pickle
+
+    with open(filename, "wb") as fw:
+        pickle.dump(data, fw)
+
+
+def load(filename):
+    import pickle
+
+    with open(filename, "rb") as fi:
+        file = pickle.load(fi)
+    return file
+
+
+def json_load(filepath: str, rel=False, mode="rb"):
+    abs_path = rel_to_abs(filepath, parents=1) if rel else filepath
+    with open(abs_path, mode=mode) as f:
+        return orjson.loads(f.read())
+
+
+def json_dump(
+    data: Union[List, Dict], filepath: str, rel=False, indent_2=False, mode="wb"
+):
+    orjson_option = 0
+    if indent_2:
+        orjson_option = orjson.OPT_INDENT_2
+    abs_path = rel_to_abs(filepath, parents=1) if rel else filepath
+    with open(abs_path, mode=mode) as f:
+        f.write(orjson.dumps(data, option=orjson_option))
+
+
+def jsonl_load(
+    filepath: str,
+    rel=False,
+    mode="rb",
+    on_error: str = "warn",
+) -> list:
+    """Load JSONL file.
+
+    Args:
+        filepath: Path to the JSONL file.
+        rel: If True, treat filepath as relative to caller's directory.
+        mode: File open mode.
+        on_error: Error handling strategy for malformed lines:
+            - "warn": Skip malformed lines but print warning (default)
+            - "raise": Raise exception on first error
+            - "skip": Silently skip malformed lines
+
+    Returns:
+        List of parsed JSON objects.
+    """
+    abs_path = rel_to_abs(filepath, parents=1) if rel else filepath
+    results = []
+    errors = []
+
+    with open(abs_path, mode=mode) as f:
+        for line_num, line in enumerate(f, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                results.append(orjson.loads(line))
+            except orjson.JSONDecodeError as e:
+                if on_error == "raise":
+                    raise ValueError(
+                        f"Failed to parse line {line_num} in {filepath}: {e}"
+                    ) from e
+                errors.append((line_num, str(e)))
+
+    if errors and on_error == "warn":
+        import warnings
+
+        warnings.warn(
+            f"jsonl_load: Skipped {len(errors)} malformed line(s) in {filepath}. "
+            f"First error at line {errors[0][0]}: {errors[0][1]}"
+        )
+
+    return results
+
+
+def jsonl_dump(data: List[Dict], filepath: str, rel=False, mode="wb"):
+    abs_path = rel_to_abs(filepath, parents=1) if rel else filepath
+    with open(abs_path, mode=mode) as f:
+        for item in data:
+            f.write(orjson.dumps(item) + b"\n")
+
+
+# 自定义多行字符串的显示方式，去除行尾空格
+def str_presenter(dumper, data):
+    """ """
+    # 去除每一行的行尾空格
+    data = "\n".join([line.rstrip() for line in data.splitlines()])
+    if "\n" in data:
+        return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+
+# 添加自定义表示器
+yaml.add_representer(str, str_presenter)
+
+
+def yaml_dump(filepath, data, rel_path=False, mode="w"):
+    """Yaml dump"""
+    abs_path = rel_to_abs(filepath, parents=1) if rel_path else filepath
+
+    with open(abs_path, mode=mode, encoding="utf-8") as fw:
+        yaml.dump(
+            data,
+            fw,
+            allow_unicode=True,
+            indent=4,
+            sort_keys=False,
+            default_flow_style=False,
+        )
+
+
+def yaml_load(filepath, rel_path=False, mode="r"):
+    import yaml
+
+    abs_path = rel_to_abs(filepath, parents=1) if rel_path else filepath
+    with open(abs_path, mode=mode, encoding="utf-8") as stream:
+        content = yaml.safe_load(stream)
+    return content
+
+
+def split_file(file_path, chunk_size=1024 * 1024 * 1024):
+    """将大文件分割成多个块。
+
+    Args:
+        file_path (str): 原始文件的路径。
+        chunk_size (int): 每个块的大小（字节）。
+    """
+    with open(file_path, "rb") as f:
+        chunk_number = 0
+        while True:
+            chunk = f.read(int(chunk_size))
+            if not chunk:
+                break
+            with open(f"{file_path}_part_{chunk_number:03}", "wb") as chunk_file:
+                chunk_file.write(chunk)
+            chunk_number += 1
+
+
+def join_files(input_prefix, input_dir, output_path=None):
+    """将分割后的文件块拼接回一个文件。
+
+    Args:
+        input_prefix (str): 分割文件的前缀。
+        output_path (str): 拼接后的文件路径。
+    """
+    import glob
+
+    if output_path is None:
+        output_path = os.path.join(input_dir, input_prefix)
+
+    parts = sorted(glob.glob(f"{input_prefix}_part_*", root_dir=input_dir))
+    with open(output_path, "wb") as output_file:
+        for part in parts:
+            with open(os.path.join(input_dir, part), "rb") as part_file:
+                output_file.write(part_file.read())
+
+
+def find_free_port():
+    """Find a free port to use for the server."""
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]

maque/llm/__init__.py

@@ -0,0 +1,111 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+LLM 模块 - 提供 LLM/MLLM 推理服务
+
+模块结构:
+- base: 抽象基类 BaseLLMBackend，可继承实现自定义后端
+- backend: Transformers 后端实现
+- server: FastAPI HTTP 服务
+
+使用示例:
+
+1. 启动服务 (CLI):
+    ```bash
+    # 标准 LLM
+    maque llm serve Qwen/Qwen2.5-7B-Instruct
+
+    # 多模态 VL 模型
+    maque llm serve Qwen/Qwen2.5-VL-3B-Instruct --port=8001
+
+    # 自定义模型类 (如 HunyuanOCR)
+    maque llm serve tencent/HunyuanOCR \\
+        --model_class=HunYuanVLForConditionalGeneration \\
+        --vision_processor=general
+
+    # Qwen3 带 thinking 模式
+    maque llm serve Qwen/Qwen3-0.6B --enable_thinking
+    ```
+
+2. 编程方式启动:
+    ```python
+    from maque.llm import create_server, ModelConfig
+
+    # 简单启动
+    server = create_server(model="Qwen/Qwen2.5-7B-Instruct")
+    server.run(port=8000)
+
+    # 带自定义配置
+    server = create_server(
+        model="tencent/HunyuanOCR",
+        model_class="HunYuanVLForConditionalGeneration",
+        vision_processor="general",
+        chat_template_kwargs={"enable_thinking": True},
+    )
+    ```
+
+3. 自定义后端:
+    ```python
+    from maque.llm import BaseLLMBackend, ModelConfig, GenerateConfig
+
+    class MyBackend(BaseLLMBackend):
+        def _load_model_impl(self, model_path, config):
+            # 自定义加载逻辑
+            pass
+
+        def _generate_impl(self, messages, config):
+            # 自定义生成逻辑
+            return "response", 10, 20
+
+    # 使用自定义后端
+    from maque.llm import LLMServer
+    server = LLMServer(backend=MyBackend(), model="my-model")
+    server.run()
+    ```
+
+ModelConfig 配置说明:
+- model_id: 模型名称或路径
+- model_class: 模型类名 (如 "AutoModelForCausalLM", "HunYuanVLForConditionalGeneration")
+- processor_class: 处理器类名 (如 "AutoTokenizer", "AutoProcessor")
+- vision_processor: 视觉处理器类型 ("qwen_vl" 或 "general")
+- chat_template_kwargs: chat template 额外参数 (如 {"enable_thinking": True})
+"""
+
+# 基类和数据模型
+from .base import (
+    BaseLLMBackend,
+    ModelConfig,
+    GenerateConfig,
+    ChatMessage,
+    ContentPart,
+    ImageURL,
+)
+
+# 后端实现
+from .backend import TransformersBackend, LLMBackend
+
+# 服务端 (延迟导入，避免强依赖 fastapi)
+def __getattr__(name):
+    if name in ("LLMServer", "create_server"):
+        from .server import LLMServer, create_server
+        return {"LLMServer": LLMServer, "create_server": create_server}[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    # 基类
+    "BaseLLMBackend",
+    # 数据模型
+    "ModelConfig",
+    "GenerateConfig",
+    "ChatMessage",
+    "ContentPart",
+    "ImageURL",
+    # 后端
+    "TransformersBackend",
+    "LLMBackend",  # 别名
+    # 服务端
+    "LLMServer",
+    "create_server",
+]