meme-generator-next 0.2.0__py3-none-any.whl

meme_generator/__init__.py

@@ -0,0 +1,59 @@
+import argparse
+import os
+import sys
+from pathlib import Path
+
+CONFIG_FILE_ENV = "MEME_GENERATOR_CONFIG_FILE"
+
+
+def _is_module_invocation(module_name: str) -> bool:
+    orig_argv = getattr(sys, "orig_argv", [])
+    try:
+        option_index = orig_argv.index("-m")
+    except ValueError:
+        return False
+    return (
+        option_index + 1 < len(orig_argv) and orig_argv[option_index + 1] == module_name
+    )
+
+
+def _apply_config_file_option() -> None:
+    if not _is_module_invocation("meme_generator.app"):
+        return
+
+    parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
+    parser.add_argument("--config-file", dest="config_file")
+    args, remaining = parser.parse_known_args(sys.argv[1:])
+
+    if args.config_file is None:
+        return
+    if not args.config_file:
+        parser.error("--config-file must not be empty")
+
+    os.environ[CONFIG_FILE_ENV] = str(Path(args.config_file).expanduser())
+    sys.argv[:] = [sys.argv[0], *remaining]
+
+
+_apply_config_file_option()
+
+from meme_generator.config import meme_config as config
+from meme_generator.manager import add_meme as add_meme
+from meme_generator.manager import get_meme as get_meme
+from meme_generator.manager import get_meme_keys as get_meme_keys
+from meme_generator.manager import get_memes as get_memes
+from meme_generator.manager import load_meme as load_meme
+from meme_generator.manager import load_memes as load_memes
+from meme_generator.meme import CommandShortcut as CommandShortcut
+from meme_generator.meme import Meme as Meme
+from meme_generator.meme import MemeArgsModel as MemeArgsModel
+from meme_generator.meme import MemeArgsType as MemeArgsType
+from meme_generator.meme import MemeParamsType as MemeParamsType
+from meme_generator.meme import ParserArg as ParserArg
+from meme_generator.meme import ParserOption as ParserOption
+from meme_generator.version import __version__ as __version__
+
+if config.meme.load_builtin_memes:
+    for path in (Path(__file__).parent / "memes").iterdir():
+        load_meme(f"meme_generator.memes.{path.name}")
+for meme_dir in config.meme.meme_dirs:
+    load_memes(meme_dir)

meme_generator/app.py

@@ -0,0 +1,322 @@
+import json
+from datetime import datetime
+from typing import Any, Literal, Optional
+
+import filetype
+from fastapi import Depends, FastAPI, Form, HTTPException, Response, UploadFile
+from pydantic import BaseModel, ValidationError
+from redis.exceptions import RedisError
+
+from meme_generator.compat import model_dump, model_json_schema, type_validate_python
+from meme_generator.config import meme_config
+from meme_generator.exception import (
+    ArgModelMismatch,
+    MemeGeneratorException,
+    NoSuchMeme,
+    RedisCacheError,
+    S3StorageError,
+)
+from meme_generator.log import LOGGING_CONFIG, setup_logger
+from meme_generator.manager import get_meme, get_meme_keys, get_memes
+from meme_generator.meme import CommandShortcut, Meme, MemeArgsModel, ParserOption
+from meme_generator.redis_cache import (
+    cache_preview_url,
+    create_redis_client,
+    get_cached_preview_url,
+)
+from meme_generator.storage import upload_to_s3
+from meme_generator.utils import MemeProperties, render_meme_list, run_sync
+from meme_generator.version import __version__
+
+app = FastAPI()
+
+
+class MemeArgsResponse(BaseModel):
+    args_model: dict[str, Any]
+    args_examples: list[dict[str, Any]]
+    parser_options: list[ParserOption]
+
+
+class MemeParamsResponse(BaseModel):
+    min_images: int
+    max_images: int
+    min_texts: int
+    max_texts: int
+    default_texts: list[str]
+    args_type: Optional[MemeArgsResponse] = None
+
+
+class MemeUrlResponse(BaseModel):
+    url: str
+    meme_key: str
+    object_key: str
+
+
+class MemePreviewUrlResponse(BaseModel):
+    url: str
+    meme_key: str
+
+
+class MemeInfoResponse(BaseModel):
+    key: str
+    params_type: MemeParamsResponse
+    keywords: list[str]
+    shortcuts: list[CommandShortcut]
+    tags: set[str]
+    date_created: datetime
+    date_modified: datetime
+
+
+async def generate_meme(
+    meme: Meme, images: list[bytes], texts: list[str], args: Any
+) -> tuple[bytes, str]:
+    try:
+        result = await run_sync(meme)(images=images, texts=texts, args=model_dump(args))
+    except MemeGeneratorException as e:
+        raise HTTPException(status_code=e.status_code, detail=e.message)
+
+    content = result.getvalue()
+    media_type = str(filetype.guess_mime(content)) or "text/plain"
+    return content, media_type
+
+
+def register_router(meme: Meme):
+    if args_type := meme.params_type.args_type:
+        args_model = args_type.args_model
+    else:
+        args_model = MemeArgsModel
+
+    def args_checker(
+        args: Optional[str] = Form(default=json.dumps(model_dump(args_model()))),
+    ):
+        if not args:
+            return MemeArgsModel()
+        try:
+            model = type_validate_python(args_model, json.loads(args))
+        except ValidationError as e:
+            e = ArgModelMismatch(str(e))
+            raise HTTPException(status_code=552, detail=e.message)
+        return model
+
+    @app.post(f"/memes/{meme.key}/")
+    async def _(
+        images: list[UploadFile] = [],
+        texts: list[str] = meme.params_type.default_texts,
+        args: args_model = Depends(args_checker),  # type: ignore
+    ):
+        imgs: list[bytes] = []
+        for image in images:
+            imgs.append(await image.read())
+
+        texts = [text for text in texts if text]
+
+        assert isinstance(args, args_model)
+
+        content, media_type = await generate_meme(meme, imgs, texts, args)
+
+        return Response(content=content, media_type=media_type)
+
+    @app.post(f"/memes/{meme.key}/url/")
+    async def _(
+        images: list[UploadFile] = [],
+        texts: list[str] = meme.params_type.default_texts,
+        args: args_model = Depends(args_checker),  # type: ignore
+    ):
+        imgs: list[bytes] = []
+        for image in images:
+            imgs.append(await image.read())
+
+        texts = [text for text in texts if text]
+
+        assert isinstance(args, args_model)
+
+        content, media_type = await generate_meme(meme, imgs, texts, args)
+
+        try:
+            upload_result = await run_sync(upload_to_s3)(
+                content=content,
+                media_type=media_type,
+                meme_key=meme.key,
+                config=meme_config.storage.s3,
+                upload_kind="result",
+            )
+        except S3StorageError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+
+        return MemeUrlResponse(
+            url=upload_result.url,
+            meme_key=meme.key,
+            object_key=upload_result.object_key,
+        )
+
+    @app.get(f"/memes/{meme.key}/preview/url/")
+    async def _():
+        redis_config = meme_config.storage.redis
+        if not redis_config.enabled:
+            error = RedisCacheError(
+                "Redis 缓存未启用，请在 config.toml 中配置 storage.redis"
+            )
+            raise HTTPException(status_code=error.status_code, detail=error.message)
+
+        try:
+            redis_client = create_redis_client(redis_config)
+        except RedisCacheError as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+
+        try:
+            cached_url = await get_cached_preview_url(
+                redis_client, redis_config, meme.key
+            )
+            if cached_url:
+                return MemePreviewUrlResponse(url=cached_url, meme_key=meme.key)
+
+            try:
+                result = await run_sync(meme.generate_preview)()
+            except MemeGeneratorException as e:
+                raise HTTPException(status_code=e.status_code, detail=e.message)
+
+            content = result.getvalue()
+            media_type = str(filetype.guess_mime(content)) or "text/plain"
+
+            try:
+                upload_result = await run_sync(upload_to_s3)(
+                    content=content,
+                    media_type=media_type,
+                    meme_key=meme.key,
+                    config=meme_config.storage.s3,
+                    upload_kind="preview",
+                )
+            except S3StorageError as e:
+                raise HTTPException(status_code=e.status_code, detail=e.message)
+
+            try:
+                await cache_preview_url(
+                    redis_client, redis_config, meme.key, upload_result.url
+                )
+            except RedisError as e:
+                error = RedisCacheError(f"Redis 缓存写入失败：{e}")
+                raise HTTPException(status_code=error.status_code, detail=error.message)
+
+            return MemePreviewUrlResponse(url=upload_result.url, meme_key=meme.key)
+        except RedisError as e:
+            error = RedisCacheError(f"Redis 缓存读取失败：{e}")
+            raise HTTPException(status_code=error.status_code, detail=error.message)
+        finally:
+            await redis_client.aclose()
+
+
+class MemeKeyWithProperties(BaseModel):
+    meme_key: str
+    disabled: bool = False
+    labels: list[Literal["new", "hot"]] = []
+
+
+default_meme_list = [
+    MemeKeyWithProperties(meme_key=meme.key)
+    for meme in sorted(get_memes(), key=lambda meme: meme.key)
+]
+
+
+class RenderMemeListRequest(BaseModel):
+    meme_list: list[MemeKeyWithProperties] = default_meme_list
+    text_template: str = "{keywords}"
+    add_category_icon: bool = True
+
+
+def register_routers():
+    @app.post("/memes/render_list")
+    def _(params: RenderMemeListRequest = RenderMemeListRequest()):
+        try:
+            meme_list = [
+                (
+                    get_meme(p.meme_key),
+                    MemeProperties(disabled=p.disabled, labels=p.labels),
+                )
+                for p in params.meme_list
+            ]
+        except NoSuchMeme as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+
+        result = render_meme_list(
+            meme_list,
+            text_template=params.text_template,
+            add_category_icon=params.add_category_icon,
+        )
+        content = result.getvalue()
+        media_type = str(filetype.guess_mime(content)) or "text/plain"
+        return Response(content=content, media_type=media_type)
+
+    @app.get("/meme/version")
+    def _():
+        return __version__
+
+    @app.get("/memes/keys")
+    def _():
+        return get_meme_keys()
+
+    @app.get("/memes/{key}/info")
+    def _(key: str):
+        try:
+            meme = get_meme(key)
+        except NoSuchMeme as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+
+        args_type_response = None
+        if args_type := meme.params_type.args_type:
+            args_model = args_type.args_model
+            args_type_response = MemeArgsResponse(
+                args_model=model_json_schema(args_model),
+                args_examples=[
+                    model_dump(example) for example in args_type.args_examples
+                ],
+                parser_options=args_type.parser_options,
+            )
+
+        return MemeInfoResponse(
+            key=meme.key,
+            params_type=MemeParamsResponse(
+                min_images=meme.params_type.min_images,
+                max_images=meme.params_type.max_images,
+                min_texts=meme.params_type.min_texts,
+                max_texts=meme.params_type.max_texts,
+                default_texts=meme.params_type.default_texts,
+                args_type=args_type_response,
+            ),
+            keywords=meme.keywords,
+            shortcuts=meme.shortcuts,
+            tags=meme.tags,
+            date_created=meme.date_created,
+            date_modified=meme.date_modified,
+        )
+
+    @app.get("/memes/{key}/preview")
+    async def _(key: str):
+        try:
+            meme = get_meme(key)
+            result = await run_sync(meme.generate_preview)()
+        except MemeGeneratorException as e:
+            raise HTTPException(status_code=e.status_code, detail=e.message)
+
+        content = result.getvalue()
+        media_type = str(filetype.guess_mime(content)) or "text/plain"
+        return Response(content=content, media_type=media_type)
+
+    for meme in sorted(get_memes(), key=lambda meme: meme.key):
+        register_router(meme)
+
+
+def run_server():
+    import uvicorn
+
+    register_routers()
+    uvicorn.run(
+        app,
+        host=meme_config.server.host,
+        port=meme_config.server.port,
+        log_config=LOGGING_CONFIG,
+    )
+
+
+if __name__ == "__main__":
+    setup_logger()
+    run_server()

meme_generator/cli.py

@@ -0,0 +1,238 @@
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import filetype
+from arclet.alconna import (
+    Alconna,
+    Args,
+    CommandMeta,
+    MultiVar,
+    Option,
+    Subcommand,
+    TextFormatter,
+)
+from arclet.alconna.exceptions import SpecialOptionTriggered
+from arclet.alconna.tools import RichConsoleFormatter
+
+from meme_generator.app import run_server
+from meme_generator.config import meme_config
+from meme_generator.download import check_resources
+from meme_generator.exception import MemeGeneratorException, NoSuchMeme
+from meme_generator.log import setup_logger
+from meme_generator.manager import get_meme, get_memes
+
+
+def construct_parser() -> Alconna:
+    sub_commands: list[Subcommand] = []
+    for meme in get_memes():
+        options: list[Option] = []
+        if args_type := meme.params_type.args_type:
+            for option in args_type.parser_options:
+                options.append(option.option())
+        sub_command = Subcommand(
+            meme.key,
+            *options,
+            Option(
+                "--images",
+                Args["images", MultiVar(str, "+")],
+                help_text="输入图片路径",
+            ),
+            Option("--texts", Args["texts", MultiVar(str, "+")], help_text="输入文字"),
+            help_text="/".join(meme.keywords),
+        )
+        sub_commands.append(sub_command)
+
+    parser = Alconna(
+        "meme",
+        Option(
+            "--config-file",
+            Args["config_file", str],
+            help_text="指定 config.toml 文件路径",
+        ),
+        Subcommand("list", alias=["ls"], help_text="查看表情列表"),
+        Subcommand(
+            "info", Args["key#表情名", str], alias=["show"], help_text="查看表情详情"
+        ),
+        Subcommand("preview", Args["key#表情名", str], help_text="生成表情预览"),
+        Subcommand("generate", *sub_commands, alias=["make"], help_text="制作表情"),
+        Subcommand(
+            "run",
+            Option(
+                "--config-file",
+                Args["config_file", str],
+                help_text="指定 config.toml 文件路径",
+            ),
+            alias=["start"],
+            help_text="启动 web server",
+        ),
+        Subcommand(
+            "download",
+            Option("--url", Args["url", str], help_text="指定资源链接"),
+            help_text="下载内置表情图片",
+        ),
+        meta=CommandMeta(
+            description="表情包生成器",
+            example="meme generate petpet --images /path/to/image/file",
+        ),
+        formatter_type=RichConsoleFormatter,
+    )
+    return parser
+
+
+def list_memes() -> str:
+    memes = sorted(get_memes(), key=lambda meme: meme.key)
+    return "\n".join(
+        f"{i}. {meme.key} ({'/'.join(meme.keywords)})"
+        for i, meme in enumerate(memes, start=1)
+    )
+
+
+def meme_info(key: str) -> str:
+    try:
+        meme = get_meme(key)
+    except NoSuchMeme:
+        return f'表情 "{key}" 不存在！'
+
+    keywords = "、".join([f'"{keyword}"' for keyword in meme.keywords])
+    shortcuts = "、".join(
+        [f'"{shortcut.humanized or shortcut.key}"' for shortcut in meme.shortcuts]
+    )
+    tags = "、".join([f'"{tag}"' for tag in sorted(meme.tags)])
+
+    image_num = f"{meme.params_type.min_images}"
+    if meme.params_type.max_images > meme.params_type.min_images:
+        image_num += f" ~ {meme.params_type.max_images}"
+
+    text_num = f"{meme.params_type.min_texts}"
+    if meme.params_type.max_texts > meme.params_type.min_texts:
+        text_num += f" ~ {meme.params_type.max_texts}"
+
+    default_texts = ", ".join([f'"{text}"' for text in meme.params_type.default_texts])
+
+    args_info = ""
+    if args_type := meme.params_type.args_type:
+        formater = TextFormatter()
+        for option in args_type.parser_options:
+            opt = option.option()
+            alias_text = (
+                " ".join(opt.requires)
+                + (" " if opt.requires else "")
+                + "│".join(sorted(opt.aliases, key=len))
+            )
+            args_info += (
+                f"\n  * {alias_text}{opt.separators[0]}"
+                f"{formater.parameters(opt.args)} {opt.help_text}"
+            )
+
+    return (
+        f"表情名：{meme.key}\n"
+        + f"关键词：{keywords}\n"
+        + (f"快捷指令：{shortcuts}\n" if shortcuts else "")
+        + (f"标签：{tags}\n" if tags else "")
+        + f"需要图片数目：{image_num}\n"
+        + f"需要文字数目：{text_num}\n"
+        + (f"默认文字：[{default_texts}]\n" if default_texts else "")
+        + (f"其他参数：{args_info}" if args_info else "")
+    )
+
+
+def generate_meme_preview(key: str) -> str:
+    try:
+        meme = get_meme(key)
+    except NoSuchMeme:
+        return f'表情 "{key}" 不存在！'
+
+    try:
+        result = meme.generate_preview()
+        content = result.getvalue()
+        ext = filetype.guess_extension(content)
+        filename = f"result.{ext}"
+        with open(filename, "wb") as f:
+            f.write(content)
+        return f'表情制作成功！生成的表情文件为 "{filename}"'
+    except MemeGeneratorException as e:
+        return str(e)
+
+
+def generate_meme(
+    key: str, images: list[str], texts: list[str], args: dict[str, Any]
+) -> str:
+    try:
+        meme = get_meme(key)
+    except NoSuchMeme:
+        return f'表情 "{key}" 不存在！'
+
+    for image in images:
+        if not Path(image).exists():
+            return f'图片路径 "{image}" 不存在！'
+
+    try:
+        result = meme(images=images, texts=texts, args=args)
+        content = result.getvalue()
+        ext = filetype.guess_extension(content)
+        filename = f"result.{ext}"
+        with open(filename, "wb") as f:
+            f.write(content)
+        return f'表情制作成功！生成的表情文件为 "{filename}"'
+    except MemeGeneratorException as e:
+        return str(e)
+
+
+def main():
+    setup_logger()
+    parser = construct_parser()
+    result = parser()
+
+    if not result.matched:
+        if not isinstance(result.error_info, SpecialOptionTriggered):
+            print(result.error_info)  # noqa: T201
+        return
+
+    if not result.subcommands:
+        print(parser.get_help())  # noqa: T201
+
+    for subcommand, sub_result in result.subcommands.items():
+        if subcommand == "list":
+            print(list_memes())  # noqa: T201
+
+        elif subcommand == "info":
+            key = str(sub_result.args["key"])
+            print(meme_info(key))  # noqa: T201
+
+        elif subcommand == "preview":
+            key = str(sub_result.args["key"])
+            print(generate_meme_preview(key))  # noqa: T201
+
+        elif subcommand == "generate":
+            for key, subsub_result in sub_result.subcommands.items():
+                images = (
+                    list(subsub_result.options["images"].args["images"])
+                    if "images" in subsub_result.options
+                    else []
+                )
+                texts = (
+                    list(subsub_result.options["texts"].args["texts"])
+                    if "texts" in subsub_result.options
+                    else []
+                )
+                options = subsub_result.options
+                options.pop("images", None)
+                options.pop("texts", None)
+                args = {}
+                for option, option_result in options.items():
+                    if option_result.value is None:
+                        args.update(option_result.args)
+                    else:
+                        args[option] = option_result.value
+                print(generate_meme(key, images, texts, args))  # noqa: T201
+
+        elif subcommand == "run":
+            run_server()
+
+        elif subcommand == "download":
+            if "url" in sub_result.options:
+                url = sub_result.options["url"].args["url"]
+                meme_config.resource.resource_url = url
+            loop = asyncio.new_event_loop()
+            loop.run_until_complete(check_resources())