py-img-processor 1.0.0__py3-none-any.whl

imgprocessor/__init__.py

@@ -0,0 +1,68 @@
+import typing
+import os
+import traceback
+import importlib
+
+
+__all__ = ["settings", "VERSION"]
+__version__ = "1.0.0"
+
+
+VERSION = __version__
+
+_BLACK_ATTRS = ["_settings", "__dict__"]
+
+
+class SettingsProxy(object):
+
+    def __init__(self) -> None:
+        _settings = None
+        # 兼容在Django项目中的使用
+        _settings_module = os.environ.get("PY_SETTINGS_MODULE") or os.environ.get("DJANGO_SETTINGS_MODULE")
+        try:
+            if _settings_module:
+                _settings = importlib.import_module(_settings_module)
+        except Exception:
+            traceback.print_exc()
+            print('Please set the correct "PY_SETTINGS_MODULE".')
+
+        self._settings = _settings
+
+    # 是否调试模式
+    DEBUG = False
+
+    # 处理原图的大小限制， 单位 MB
+    PROCESSOR_MAX_FILE_SIZE = 20
+    # 处理图像，原图宽高像素限制
+    PROCESSOR_MAX_W_H = 30000
+    # width x height总像素3亿，处理前后的值都被此配置限制
+    PROCESSOR_MAX_PIXEL = 300000000
+    # 图像处理后的默认质量
+    PROCESSOR_DEFAULT_QUALITY = 75
+    # 默认字体文件; 默认配置了MacOS系统中的字体
+    PROCESSOR_TEXT_FONT = "Arial Unicode.ttf"
+
+    def __getattribute__(self, attr: str) -> typing.Any:
+        try:
+            if attr in _BLACK_ATTRS:
+                # 白名单，内置属性直接返回
+                return super(SettingsProxy, self).__getattribute__(attr)
+
+            if self._settings is not None and hasattr(self._settings, attr):
+                value = getattr(self._settings, attr)
+            else:
+                value = super(SettingsProxy, self).__getattribute__(attr)
+        except AttributeError:
+            raise AttributeError('settings has no attribute "{}"'.format(attr))
+        return value
+
+    def __setattr__(self, name: str, value: typing.Any) -> None:
+        if name in _BLACK_ATTRS and not hasattr(self, name):
+            return super(SettingsProxy, self).__setattr__(name, value)
+        raise AttributeError("All properties of settings are not allowed to be changed.")
+
+    def __delattr__(self, name: str) -> None:
+        raise AttributeError("All properties of settings are not allowed to be changed.")
+
+
+settings = SettingsProxy()

imgprocessor/enums.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+# coding=utf-8
+from py_enum import ChoiceEnum
+
+
+class ImageFormat(ChoiceEnum):
+    """图像转换的格式"""
+
+    JPEG = ("JPEG", "JPEG")
+    PNG = ("PNG", "PNG")
+    WEBP = ("WebP", "WebP")
+
+
+class ImageOrientation(ChoiceEnum):
+    """
+    图片EXIF中的方向枚举，第0行0列的位置(即图像正常显示右上角的位置)
+
+    see http://sylvana.net/jpegcrop/exif_orientation.html
+    """
+
+    TOP_LEFT = (1, "0度：正确方向，无需调整")
+    TOP_RIGHT = (2, "水平翻转")
+    BOTTOM_RIGHT = (3, "180度旋转")
+    BOTTOM_LEFT = (4, "水平翻转+180度旋转")  # 垂直翻转
+    LEFT_TOP = (5, "水平翻转+顺时针270度")
+    RIGHT_TOP = (6, "顺时针270度")
+    RIGHT_BOTTOM = (7, "水平翻转+顺时针90度")
+    LEFT_BOTTOM = (8, "顺时针90°")
+
+
+class OpAction(ChoiceEnum):
+    """支持的操作类型"""
+
+    # 以下几个比较特殊，在保存文件时使用
+    FORMAT = ("format", "格式")
+    QUALITY = ("quality", "质量")
+    INTERLACE = ("interlace", "渐进显示")
+    # 其他
+    RESIZE = ("resize", "缩放")
+    CROP = ("crop", "裁剪")
+    CIRCLE = ("circle", "圆角")
+    BLUR = ("blur", "模糊效果")
+    ROTATE = ("rotate", "旋转")
+    ALPHA = ("alpha", "透明度")
+    GRAY = ("gray", "灰度图")
+    WATERMARK = ("watermark", "水印")
+    # 特殊操作
+    MERGE = ("merge", "合并图像")
+
+
+class ResizeMode(ChoiceEnum):
+    """图像缩放的模式"""
+
+    LFIT = ("lfit", "等比缩放，缩放图限制为指定w与h的矩形内的最大图片")  # 类似ImageOps.contain
+    MFIT = ("mfit", "等比缩放，缩放图为延伸出指定w与h的矩形框外的最小图片")  # 类似ImageOps.cover
+    FIT = ("fit", "将原图等比缩放为延伸出指定w与h的矩形框外的最小图片，然后将超出的部分进行居中裁剪")  # ImageOps.fit
+    PAD = ("pad", "将原图缩放为指定w与h的矩形内的最大图片，然后使用指定颜色居中填充空白部分")  # ImageOps.pad
+    FIXED = ("fixed", "固定宽高，强制缩放")
+
+
+class ArgType(ChoiceEnum):
+    STRING = ("str", "字符串")
+    INTEGER = ("int", "整数")
+    FLOAT = ("float", "浮点数")
+
+
+class Geography(ChoiceEnum):
+    """图像中的九宫格位置"""
+
+    NW = ("nw", "左上")
+    NORTH = ("north", "中上")
+    NE = ("ne", "右上")
+    WEST = ("west", "左中")
+    CENTER = ("center", "中部")
+    EAST = ("east", "右中")
+    SW = ("sw", "左下")
+    SOUTH = ("south", "中下")
+    SE = ("se", "右下")
+
+
+class PositionOrder(ChoiceEnum):
+    """两个元素的前后顺序"""
+
+    BEFORE = (0, "第一输入元素在前/在上")  # 图片在前
+    AFTER = (1, "第一个输入元素在后/在下")  # 文字在前
+
+
+class PositionAlign(ChoiceEnum):
+    """两个元素的对齐方式"""
+
+    TOP = (0, "水平上对齐")
+    HORIZONTAL_CENTER = (1, "水平居中对齐")
+    BOTTOM = (2, "水平下对齐")
+    LEFT = (3, "垂直左对齐")
+    VERTIAL_CENTER = (4, "垂直居中对齐")
+    RIGHT = (5, "垂直右对齐")

imgprocessor/exceptions.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+
+class ProcessException(Exception):
+    """图像处理异常基类"""
+
+    pass
+
+
+class ProcessLimitException(Exception):
+    """图像处理限制"""
+
+    pass
+
+
+class ParamParseException(ProcessException):
+    """解析参数出现错误"""
+
+    pass
+
+
+class ParamValidateException(ProcessException):
+    """对参数进行校验"""
+
+    pass

imgprocessor/main.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+import os
+import sys
+import argparse
+import traceback
+
+from imgprocessor import VERSION
+from imgprocessor.processor import process_image_by_path
+
+
+def main(argv: typing.Optional[list[str]] = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+    parser = argparse.ArgumentParser(
+        prog="img-processor",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="图像处理",
+    )
+
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {VERSION}")
+    parser.add_argument(
+        "-P", "--path", type=str, required=True, help="输入图像的文件路径/目录，若是目录则批量处理目录下所有图像"
+    )
+    parser.add_argument("--action", type=str, nargs="+", help="操作参数，可对同一个文件多组操作")
+    parser.add_argument(
+        "-O", "--output", type=str, required=True, help="输出图像路径，多个图像或多个操作时请设置已存在的目录"
+    )
+    parser.add_argument("--overwrite", action="store_true", help="是否覆盖输出路径中已有文件")
+
+    args = parser.parse_args(argv)
+
+    # 输入
+    path = args.path
+    base_dir = path
+    # 初始化输入图像文件列表
+    file_paths = []
+    if os.path.isdir(path):
+        for path, dir_list, file_list in os.walk(path):
+            for file_name in file_list:
+                p = os.path.join(path, file_name)
+                file_paths.append(p)
+    else:
+        file_paths = [path]
+        base_dir = os.path.dirname(path)
+
+    total = len(file_paths)
+    ac_num = len(args.action)
+
+    # 输出目录
+    output = args.output
+    if (total > 1 or ac_num > 1) and not os.path.isdir(output):
+        print("\033[31m参数output目录不存在,请先创建\033[0m", file=sys.stderr, flush=True)
+        return 1
+    count = 0
+    for file_path in file_paths:
+        count += 1
+        f_tag = f"{count}/{total}\t处理 {file_path}"
+        print(f_tag, flush=True, end="\r")
+        # 相对path的相对路径
+        if not base_dir or base_dir in [".", "./"]:
+            relative_path = file_path
+        else:
+            relative_path = file_path.split(base_dir, 1)[-1]
+        relative_path = relative_path.strip("/")
+
+        prefix, ext = os.path.splitext(relative_path)
+        for idx, param_str in enumerate(args.action):
+            # 初始化目标文件路径
+            if total == 1 and ac_num == 1 and os.path.splitext(output)[-1]:
+                out_path = output
+            else:
+                if ac_num == 1:
+                    target_name = relative_path
+                else:
+                    target_name = f"{prefix}-{idx}.{ext}"
+                out_path = os.path.join(output, target_name)
+
+            tag = f"{f_tag}\t action={idx + 1}\t 保存于 {out_path}"
+            print(f"{tag}\t ...", flush=True, end="\r")
+
+            # 判断目标文件是否存在
+            if os.path.exists(out_path):
+                if not args.overwrite:
+                    print(f"\033[31m{tag} 目标文件已存在\033[0m", file=sys.stderr, flush=True)
+                    print("处理中断，可以添加参数 \033[33m--overwrite\033[0m 覆盖现有文件", file=sys.stderr, flush=True)
+                    return 1
+
+                tag = f"{tag}\t \033[33moverwrite\033[0m"
+
+            cur_out_dir = os.path.dirname(out_path)
+            if not os.path.exists(cur_out_dir):
+                os.makedirs(cur_out_dir)
+            try:
+                process_image_by_path(file_path, out_path, param_str)
+                print(f"{tag}\t 成功", flush=True)
+            except Exception as e:
+                print(f"{tag}\t \033[31m失败：{e}\033[0m", file=sys.stderr, flush=True)
+                print(traceback.format_exc(), file=sys.stderr, flush=True)
+                return 1
+
+    return 0
+
+
+# if __name__ == "__main__":
+#     raise SystemExit(main())

imgprocessor/parsers/__init__.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from imgprocessor import enums
+from imgprocessor.exceptions import ParamParseException
+from .base import BaseParser, ImgSaveParser  # noqa: F401
+from .resize import ResizeParser
+from .crop import CropParser
+from .circle import CircleParser
+from .blur import BlurParser
+from .rotate import RotateParser
+from .alpha import AlphaParser
+from .gray import GrayParser
+from .watermark import WatermarkParser
+from .merge import MergeParser
+
+
+_ACTION_PARASER_MAP: dict[str, BaseParser] = {
+    enums.OpAction.RESIZE: ResizeParser,  # type: ignore
+    enums.OpAction.CROP: CropParser,  # type: ignore
+    enums.OpAction.CIRCLE: CircleParser,  # type: ignore
+    enums.OpAction.BLUR: BlurParser,  # type: ignore
+    enums.OpAction.ROTATE: RotateParser,  # type: ignore
+    enums.OpAction.ALPHA: AlphaParser,  # type: ignore
+    enums.OpAction.GRAY: GrayParser,  # type: ignore
+    enums.OpAction.WATERMARK: WatermarkParser,  # type: ignore
+    enums.OpAction.MERGE: MergeParser,  # type: ignore
+}
+
+
+class ProcessParams(object):
+    """图像处理输入参数"""
+
+    def __init__(
+        self,
+        enable_base64: bool = False,
+        actions: typing.Optional[list] = None,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.save_parser: ImgSaveParser = ImgSaveParser.init(kwargs, enable_base64=enable_base64)
+
+        _actions = []
+        for i in actions or []:
+            key = i.get("key")
+            cls = _ACTION_PARASER_MAP.get(key)
+            if not cls:
+                continue
+            _actions.append(cls.init(i, enable_base64=enable_base64))
+        self.actions = _actions
+
+    @classmethod
+    def parse_str(cls, value: str) -> "ProcessParams":
+        """
+        仅将字符串解析成json参数，不对参数合法性做校验
+
+        Args:
+            value: 输入参数，示例 crop,x_800,y_50/resize,h_100,m_lfit
+
+        Returns:
+            实例化TransferConfig
+
+        """
+        actions: list = []
+
+        save_args = [""]  # 加空字符串，是为了保证解析出key
+
+        for item in value.split("/"):
+            if not item:
+                continue
+            info = item.split(",", 1)
+            if len(info) == 1:
+                key = info[0]
+                param_str = ""
+            else:
+                key, param_str = info
+            if not key:
+                raise ParamParseException(f"参数必须指定操作类型 [{item}]不符合参数要求")
+            if key in [enums.OpAction.FORMAT, enums.OpAction.QUALITY, enums.OpAction.INTERLACE]:
+                save_args.append(f"{key}_{param_str}")
+            else:
+                action_cls = _ACTION_PARASER_MAP.get(key)
+                if not action_cls:
+                    continue
+                action = action_cls.parse_str(item)
+                actions.append(action)
+
+        kwargs = ImgSaveParser.parse_str(",".join(save_args))
+        return cls(enable_base64=True, actions=actions, **kwargs)

imgprocessor/parsers/alpha.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+
+from PIL import Image
+
+from imgprocessor import enums
+from .base import BaseParser, pre_processing
+
+
+class AlphaParser(BaseParser):
+
+    KEY = enums.OpAction.ALPHA
+    ARGS = {
+        # 不透明度, 为100时，完全不透明，即原图; 为0时，完全透明
+        "value": {"type": enums.ArgType.INTEGER, "default": 100, "min": 0, "max": 100},
+    }
+
+    def __init__(
+        self,
+        value: int = 100,
+        **kwargs: typing.Any,
+    ) -> None:
+        self.value = value
+
+    def do_action(self, im: Image) -> Image:
+        im = pre_processing(im, use_alpha=True)
+        if self.value < 100:
+            _, _, _, alpha_channel = im.split()
+            alpha_channel = alpha_channel.point(lambda i: min(int(255 * self.value / 100), i))
+            im.putalpha(alpha_channel)
+        return im