py-img-processor 1.0.1__tar.gz → 1.2.4__tar.gz

{py_img_processor-1.0.1/py_img_processor.egg-info → py_img_processor-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-img-processor
-Version: 1.0.1
+Version: 1.2.4
 Summary: Image editor using Python and Pillow.
 Home-page: https://github.com/SkylerHu/py-img-processor.git
 Author: SkylerHu
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: py-enum>=1.1.1
+Requires-Dist: py-enum>=2.1.1
 Requires-Dist: Pillow>=8
 
 # py-img-processor
@@ -54,7 +54,7 @@ Image editor using Python and Pillow.
 
 ## 2. 使用(Usage)
 
-具体使用说明查看 [readthedocs](https://py-img-processor.readthedocs.io) 。
+具体使用说明查看 [readthedocs](https://py-img-processor.readthedocs.io/) 。
 
 ## 2.1 运行配置
 可以通过指定环境变量`PY_SETTINGS_MODULE`加载配置文件：
@@ -71,6 +71,9 @@ Image editor using Python and Pillow.
 | PROCESSOR_MAX_PIXEL | int | width x height总像素3亿，处理前后的值都被此配置限制 | 300000000 |
 | PROCESSOR_DEFAULT_QUALITY | int | 图像处理后的默认质量 | 75 |
 | PROCESSOR_TEXT_FONT | str | 默认字体文件，默认从系统中寻找；也可以直接传递字体文件路径 | Arial Unicode.ttf |
+| PROCESSOR_WORKSPACES | tuple | 限制水印等资源路径 （startswith匹配）， 默认无限制 | `()` |
+| PROCESSOR_ALLOW_DOMAINS | tuple | 限制链接地址域名 （endswith匹配），默认无限制 | `()` |
+| PROCESSOR_TEMP_DIR | str | tmpfile使用的临时目录,不设置默认使用系统tmp目录 | `None` |
 
 > `注意`：`PROCESSOR_TEXT_FONT` 字体的设置是文字水印必要参数，需保证系统已安装该字体。默认值 `Arial Unicode.ttf` 是MacOS系统存在的字体，建议设置字体文件路径。
 
@@ -82,11 +85,15 @@ Image editor using Python and Pillow.
 
 
 ### 处理函数
-`process_image_by_path(input_path, out_path, params)`
+```python
+from imgprocessor.processor import process_image
+
+process_image(input_uri, out_path, params)
+```
 
 参数说明：
 
-- `input_path` str，输入图像文件路径
+- `input_uri` str，输入图像文件路径或者链接地址
 - `out_path` str, 输出图像保存路径
 - `params` str or json，图像处理参数，参数说明详见 [Reference.md](https://github.com/SkylerHu/py-img-processor/blob/master/docs/Reference.md)
 
@@ -100,9 +107,9 @@ Image editor using Python and Pillow.
 
 ```python
 from imgprocessor.utils import base64url_encode
-from imgprocessor.processor import process_image_by_path
+from imgprocessor.processor import process_image
 
-process_image_by_path(
+process_image(
     "docs/imgs/lenna-400x225.jpg",
     "/tmp/output.png",
     # 对图片缩放、裁剪、生成圆角、并转成png存储
@@ -120,7 +127,7 @@ process_image_by_path(
 - 其他参数都放在 `actions` 数组中；
 
 ```python
-process_image_by_path(
+process_image(
     "docs/imgs/lenna-400x225.jpg",
     "/tmp/output.png",
     {

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/README.md

@@ -28,7 +28,7 @@ Image editor using Python and Pillow.
 
 ## 2. 使用(Usage)
 
-具体使用说明查看 [readthedocs](https://py-img-processor.readthedocs.io) 。
+具体使用说明查看 [readthedocs](https://py-img-processor.readthedocs.io/) 。
 
 ## 2.1 运行配置
 可以通过指定环境变量`PY_SETTINGS_MODULE`加载配置文件：
@@ -45,6 +45,9 @@ Image editor using Python and Pillow.
 | PROCESSOR_MAX_PIXEL | int | width x height总像素3亿，处理前后的值都被此配置限制 | 300000000 |
 | PROCESSOR_DEFAULT_QUALITY | int | 图像处理后的默认质量 | 75 |
 | PROCESSOR_TEXT_FONT | str | 默认字体文件，默认从系统中寻找；也可以直接传递字体文件路径 | Arial Unicode.ttf |
+| PROCESSOR_WORKSPACES | tuple | 限制水印等资源路径 （startswith匹配）， 默认无限制 | `()` |
+| PROCESSOR_ALLOW_DOMAINS | tuple | 限制链接地址域名 （endswith匹配），默认无限制 | `()` |
+| PROCESSOR_TEMP_DIR | str | tmpfile使用的临时目录,不设置默认使用系统tmp目录 | `None` |
 
 > `注意`：`PROCESSOR_TEXT_FONT` 字体的设置是文字水印必要参数，需保证系统已安装该字体。默认值 `Arial Unicode.ttf` 是MacOS系统存在的字体，建议设置字体文件路径。
 
@@ -56,11 +59,15 @@ Image editor using Python and Pillow.
 
 
 ### 处理函数
-`process_image_by_path(input_path, out_path, params)`
+```python
+from imgprocessor.processor import process_image
+
+process_image(input_uri, out_path, params)
+```
 
 参数说明：
 
-- `input_path` str，输入图像文件路径
+- `input_uri` str，输入图像文件路径或者链接地址
 - `out_path` str, 输出图像保存路径
 - `params` str or json，图像处理参数，参数说明详见 [Reference.md](./docs/Reference.md)
 
@@ -74,9 +81,9 @@ Image editor using Python and Pillow.
 
 ```python
 from imgprocessor.utils import base64url_encode
-from imgprocessor.processor import process_image_by_path
+from imgprocessor.processor import process_image
 
-process_image_by_path(
+process_image(
     "docs/imgs/lenna-400x225.jpg",
     "/tmp/output.png",
     # 对图片缩放、裁剪、生成圆角、并转成png存储
@@ -94,7 +101,7 @@ process_image_by_path(
 - 其他参数都放在 `actions` 数组中；
 
 ```python
-process_image_by_path(
+process_image(
     "docs/imgs/lenna-400x225.jpg",
     "/tmp/output.png",
     {

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/__init__.py

@@ -5,7 +5,7 @@ import importlib
 
 
 __all__ = ["settings", "VERSION"]
-__version__ = "1.0.1"
+__version__ = "1.2.4"
 
 
 VERSION = __version__
@@ -41,6 +41,12 @@ class SettingsProxy(object):
     PROCESSOR_DEFAULT_QUALITY = 75
     # 默认字体文件; 默认配置了MacOS系统中的字体
     PROCESSOR_TEXT_FONT = "Arial Unicode.ttf"
+    # 工作目录列表：例如水印文件必须限制在设定的目录下，避免恶意访问文件
+    PROCESSOR_WORKSPACES = ()
+    # 当资源文件uri使用链接地址时，限制地址域名来源
+    PROCESSOR_ALLOW_DOMAINS = ()
+    # 临时文件目录
+    PROCESSOR_TEMP_DIR = None
 
     def __getattribute__(self, attr: str) -> typing.Any:
         try:

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/enums.py

@@ -51,8 +51,8 @@ class OpAction(ChoiceEnum):
 class ResizeMode(ChoiceEnum):
     """图像缩放的模式"""
 
-    LFIT = ("lfit", "等比缩放，缩放图限制为指定w与h的矩形内的最大图片")  # 类似ImageOps.contain
-    MFIT = ("mfit", "等比缩放，缩放图为延伸出指定w与h的矩形框外的最小图片")  # 类似ImageOps.cover
+    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", "固定宽高，强制缩放")
@@ -62,6 +62,8 @@ class ArgType(ChoiceEnum):
     STRING = ("str", "字符串")
     INTEGER = ("int", "整数")
     FLOAT = ("float", "浮点数")
+    URI = ("uri", "资源路径/链接")
+    ACTION = ("action", "对图像的操作")
 
 
 class Geography(ChoiceEnum):

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/main.py

@@ -7,7 +7,7 @@ import argparse
 import traceback
 
 from imgprocessor import VERSION
-from imgprocessor.processor import ProcessParams, process_image_by_path
+from imgprocessor.processor import ProcessParams, process_image
 
 
 def main(argv: typing.Optional[list[str]] = None) -> int:
@@ -95,7 +95,7 @@ def main(argv: typing.Optional[list[str]] = None) -> int:
             if not os.path.exists(cur_out_dir):
                 os.makedirs(cur_out_dir)
             try:
-                process_image_by_path(file_path, out_path, param_str)
+                process_image(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)

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/parsers/__init__.py

@@ -4,7 +4,8 @@ import typing
 
 from imgprocessor import enums
 from imgprocessor.exceptions import ParamParseException
-from .base import BaseParser, ImgSaveParser  # noqa: F401
+
+from .base import BaseParser, ImgSaveParser
 from .resize import ResizeParser
 from .crop import CropParser
 from .circle import CircleParser
@@ -16,16 +17,16 @@ 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
+_ACTION_PARASER_MAP: dict[str, typing.Any] = {
+    enums.OpAction.RESIZE.value: ResizeParser,
+    enums.OpAction.CROP.value: CropParser,
+    enums.OpAction.CIRCLE.value: CircleParser,
+    enums.OpAction.BLUR.value: BlurParser,
+    enums.OpAction.ROTATE.value: RotateParser,
+    enums.OpAction.ALPHA.value: AlphaParser,
+    enums.OpAction.GRAY.value: GrayParser,
+    enums.OpAction.WATERMARK.value: WatermarkParser,
+    enums.OpAction.MERGE.value: MergeParser,
 }
 
 
@@ -38,9 +39,9 @@ class ProcessParams(object):
         actions: typing.Optional[list] = None,
         **kwargs: typing.Any,
     ) -> None:
-        self.save_parser: ImgSaveParser = ImgSaveParser.init(kwargs, enable_base64=enable_base64)
+        self.save_parser: ImgSaveParser = ImgSaveParser.init(kwargs, enable_base64=enable_base64)  # type: ignore
 
-        _actions = []
+        _actions: list[BaseParser] = []
         for i in actions or []:
             key = i.get("key")
             cls = _ACTION_PARASER_MAP.get(key)
@@ -76,7 +77,7 @@ class ProcessParams(object):
                 key, param_str = info
             if not key:
                 raise ParamParseException(f"参数必须指定操作类型 [{item}]不符合参数要求")
-            if key in [enums.OpAction.FORMAT, enums.OpAction.QUALITY, enums.OpAction.INTERLACE]:
+            if key in [enums.OpAction.FORMAT.value, enums.OpAction.QUALITY.value, enums.OpAction.INTERLACE.value]:
                 save_args.append(f"{key}_{param_str}")
             else:
                 action_cls = _ACTION_PARASER_MAP.get(key)

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/parsers/alpha.py

@@ -10,10 +10,10 @@ from .base import BaseParser, pre_processing
 
 class AlphaParser(BaseParser):
 
-    KEY = enums.OpAction.ALPHA
+    KEY = enums.OpAction.ALPHA.value
     ARGS = {
         # 不透明度, 为100时，完全不透明，即原图; 为0时，完全透明
-        "value": {"type": enums.ArgType.INTEGER, "default": 100, "min": 0, "max": 100},
+        "value": {"type": enums.ArgType.INTEGER.value, "default": 100, "min": 0, "max": 100},
     }
 
     def __init__(

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/parsers/base.py

@@ -1,17 +1,22 @@
+#!/usr/bin/env python
+# coding=utf-8
 import typing
 
-try:
-    # python3.11只后
-    from typing import Self  # type: ignore
-except Exception:
-    from typing_extensions import Self
-
+import os
 import re
+import tempfile
+import urllib.parse
+from urllib.request import urlretrieve
+from contextlib import contextmanager
 
 from PIL import Image, ImageOps
 
-from imgprocessor import enums, utils
-from imgprocessor.exceptions import ParamValidateException, ParamParseException
+from py_enum import ChoiceEnum
+from imgprocessor import settings, enums, utils
+from imgprocessor.exceptions import ParamValidateException, ParamParseException, ProcessLimitException
+
+
+_ALLOW_SCHEMES = ("http", "https")
 
 
 class BaseParser(object):
@@ -23,14 +28,14 @@ class BaseParser(object):
         pass
 
     @classmethod
-    def init(cls, data: dict, enable_base64: bool = False) -> Self:
+    def init(cls, data: dict, enable_base64: bool = False) -> "BaseParser":
         params = cls.validate_args(enable_base64=enable_base64, **data)
         ins = cls(**params)
         ins.validate()
         return ins
 
     @classmethod
-    def init_by_str(cls, param_str: str) -> Self:
+    def init_by_str(cls, param_str: str) -> "BaseParser":
         data = cls.parse_str(param_str)
         return cls.init(data, enable_base64=True)
 
@@ -64,16 +69,23 @@ class BaseParser(object):
             else:
                 value = kwargs.get(key)
                 try:
-                    if _type == enums.ArgType.INTEGER:
+                    if _type == enums.ArgType.INTEGER.value:
                         value = cls._validate_number(value, **config)
-                    elif _type == enums.ArgType.FLOAT:
+                    elif _type == enums.ArgType.FLOAT.value:
                         value = cls._validate_number(value, use_float=True, **config)
-                    elif _type == enums.ArgType.STRING:
+                    elif _type == enums.ArgType.STRING.value:
                         value = cls._validate_str(value, enable_base64=enable_base64, **config)
+                    elif _type == enums.ArgType.URI.value:
+                        value = cls._validate_uri(value, enable_base64=enable_base64, **config)
+                    elif _type == enums.ArgType.ACTION.value:
+                        if value and isinstance(value, str):
+                            value = cls._validate_str(value, enable_base64=enable_base64, **config)
 
                     choices = config.get("choices")
+                    if isinstance(choices, ChoiceEnum):
+                        choices = choices.values
                     if choices and value not in choices:
-                        raise ParamValidateException(f"{key}枚举值只能是其中之一 {choices.values}")
+                        raise ParamValidateException(f"{key}枚举值只能是其中之一 {choices}")
                 except ParamValidateException as e:
                     raise ParamValidateException(f"参数 {key}={value} 不符合要求：{e}")
                 data[key] = value
@@ -88,7 +100,7 @@ class BaseParser(object):
         regex: typing.Optional[str] = None,
         base64_encode: bool = False,
         max_length: typing.Optional[int] = None,
-        **kwargs: dict,
+        **kwargs: typing.Any,
     ) -> str:
         if not isinstance(value, str):
             raise ParamValidateException("参数类型不符合要求，必须是字符串类型")
@@ -107,7 +119,7 @@ class BaseParser(object):
         min: typing.Optional[int] = None,
         max: typing.Optional[int] = None,
         use_float: bool = False,
-        **kwargs: dict,
+        **kwargs: typing.Any,
     ) -> typing.Union[int, float]:
         if isinstance(value, int) or (use_float and isinstance(value, (int, float))):
             v = value
@@ -131,6 +143,47 @@ class BaseParser(object):
 
         return v
 
+    @classmethod
+    def _validate_uri(cls, value: typing.Any, **kwargs: typing.Any) -> str:
+        """校验输入的资源，转换为本地绝对路径
+
+        Args:
+            value: 输入值
+            workspace: 限制资源路径，可传递空字符串忽略校验. Defaults to None.
+            allow_domains: 限制资源地址的域名，可传递空数组忽略校验. Defaults to None.
+
+        Raises:
+            ParamValidateException: 参数校验异常
+
+        Returns:
+            系统文件绝对路径
+        """
+        # 首先是字符串
+        value = cls._validate_str(value, **kwargs)
+        ori_value = value
+        # 判断是否是链接
+        parsed_url = urllib.parse.urlparse(value)
+        if parsed_url.scheme not in _ALLOW_SCHEMES:
+            value = os.path.realpath(os.fspath(value))
+            if not os.path.isfile(value):
+                raise ParamValidateException(f"系统文件不存在: {ori_value}")
+
+            workspaces: tuple = settings.PROCESSOR_WORKSPACES or ()
+            _workspace = [os.path.realpath(os.fspath(ws)) for ws in workspaces]
+            if _workspace and not value.startswith(tuple(_workspace)):
+                raise ParamValidateException(f"文件必须在 PROCESSOR_WORKSPACES={workspaces} 目录下: {ori_value}")
+        else:
+            # 是链接地址
+            domain = parsed_url.netloc
+            if not domain:
+                raise ParamValidateException(f"链接未解析出域名: {ori_value}")
+            allow_domains = settings.PROCESSOR_ALLOW_DOMAINS
+            if allow_domains and not parsed_url.netloc.endswith(tuple(allow_domains)):
+                raise ParamValidateException(
+                    f"域名不合法, {parsed_url.netloc} 不在 {allow_domains} 范围内: {ori_value}"
+                )
+        return value
+
     @classmethod
     def parse_str(cls, param_str: str) -> dict:
         """将字符串参数转化为json格式数据
@@ -192,33 +245,33 @@ def compute_by_geography(
     src_w: int, src_h: int, x: int, y: int, w: int, h: int, g: typing.Optional[str], pf: str
 ) -> tuple[int, int]:
     """计算 大小(w,h)的图像相对于(src_w, src_h)图像的原点(x,y)位置"""
-    if g == enums.Geography.NW:
+    if g == enums.Geography.NW.value:
         x, y = 0, 0
-    elif g == enums.Geography.NORTH:
+    elif g == enums.Geography.NORTH.value:
         x, y = int(src_w / 2 - w / 2), 0
-    elif g == enums.Geography.NE:
+    elif g == enums.Geography.NE.value:
         x, y = src_w - w, 0
-    elif g == enums.Geography.WEST:
+    elif g == enums.Geography.WEST.value:
         x, y = 0, int(src_h / 2 - h / 2)
-    elif g == enums.Geography.CENTER:
+    elif g == enums.Geography.CENTER.value:
         x, y = int(src_w / 2 - w / 2), int(src_h / 2 - h / 2)
-    elif g == enums.Geography.EAST:
+    elif g == enums.Geography.EAST.value:
         x, y = src_w - w, int(src_h / 2 - h / 2)
-    elif g == enums.Geography.SW:
+    elif g == enums.Geography.SW.value:
         x, y = 0, src_h - h
-    elif g == enums.Geography.SOUTH:
+    elif g == enums.Geography.SOUTH.value:
         x, y = int(src_w / 2 - w / 2), src_h - h
-    elif g == enums.Geography.SE:
+    elif g == enums.Geography.SE.value:
         x, y = src_w - w, src_h - h
     elif pf:
         if "x" in pf:
             if x < 0 or x > 100:
                 raise ParamValidateException(f"pf={pf}包含了x，所以x作为百分比取值范围为[0,100]")
-            x = int(src_w * x / 100)
+            x = round(src_w * x / 100)
         if "y" in pf:
             if y < 0 or y > 100:
                 raise ParamValidateException(f"pf={pf}包含了y，所以y作为百分比取值范围为[0,100]")
-            y = int(src_h * y / 100)
+            y = round(src_h * y / 100)
     return x, y
 
 
@@ -237,11 +290,11 @@ def compute_by_ratio(src_w: int, src_h: int, ratio: str) -> tuple[int, int]:
     wr, hr = int(w_r), int(h_r)
     if src_w * hr > src_h * wr:
         # 相对于目标比例，宽长了
-        w = int(src_h * wr / hr)
+        w = round(src_h * wr / hr)
         h = src_h
     elif src_w * hr < src_h * wr:
         w = src_w
-        h = int(src_w * hr / wr)
+        h = round(src_w * hr / wr)
     else:
         # 刚好符合比例
         w, h = src_w, src_h
@@ -253,8 +306,8 @@ def compute_splice_two_im(
     h1: int,
     w2: int,
     h2: int,
-    align: int = enums.PositionAlign.VERTIAL_CENTER,  # type: ignore
-    order: int = enums.PositionOrder.BEFORE,  # type: ignore
+    align: int = enums.PositionAlign.VERTIAL_CENTER.value,
+    order: int = enums.PositionOrder.BEFORE.value,
     interval: int = 0,
 ) -> tuple:
     """拼接2个图像，计算整体大小和元素原点位置；数值单位都是像素
@@ -276,33 +329,37 @@ def compute_splice_two_im(
         第2个元素的原点位置x2
         第2个元素的原点位置y2
     """
-    if align in [enums.PositionAlign.TOP, enums.PositionAlign.HORIZONTAL_CENTER, enums.PositionAlign.BOTTOM]:
+    if align in [
+        enums.PositionAlign.TOP.value,
+        enums.PositionAlign.HORIZONTAL_CENTER.value,
+        enums.PositionAlign.BOTTOM.value,
+    ]:
         # 水平顺序
         # 计算整体占位大小w,h
         w, h = w1 + w2 + interval, max(h1, h2)
 
-        if align == enums.PositionAlign.TOP:
+        if align == enums.PositionAlign.TOP.value:
             y1, y2 = 0, 0
-        elif align == enums.PositionAlign.BOTTOM:
+        elif align == enums.PositionAlign.BOTTOM.value:
             y1, y2 = h - h1, h - h2
         else:
             y1, y2 = int((h - h1) / 2), int((h - h2) / 2)
 
-        if order == enums.PositionOrder.BEFORE:
+        if order == enums.PositionOrder.BEFORE.value:
             x1, x2 = 0, w1 + interval
         else:
             x1, x2 = w2 + interval, 0
     else:
         # 垂直
         w, h = max(w1, w2), h1 + h2 + interval
-        if align == enums.PositionAlign.LEFT:
+        if align == enums.PositionAlign.LEFT.value:
             x1, x2 = 0, 0
-        elif align == enums.PositionAlign.RIGHT:
+        elif align == enums.PositionAlign.RIGHT.value:
             x1, x2 = w - w1, w - w2
         else:
             x1, x2 = int((w - w1) / 2), int((w - w2) / 2)
 
-        if order == enums.PositionOrder.BEFORE:
+        if order == enums.PositionOrder.BEFORE.value:
             y1, y2 = 0, h1 + interval
         else:
             y1, y2 = h2 + interval, 0
@@ -310,13 +367,77 @@ def compute_splice_two_im(
     return w, h, x1, y1, x2, y2
 
 
+def validate_ori_im(ori_im: Image) -> None:
+    src_w, src_h = ori_im.size
+    if src_w > settings.PROCESSOR_MAX_W_H or src_h > settings.PROCESSOR_MAX_W_H:
+        raise ProcessLimitException(
+            f"图像宽和高单边像素不能超过{settings.PROCESSOR_MAX_W_H}像素，输入图像({src_w}, {src_h})"
+        )
+    if src_w * src_h > settings.PROCESSOR_MAX_PIXEL:
+        raise ProcessLimitException(f"图像总像素不可超过{settings.PROCESSOR_MAX_PIXEL}像素，输入图像({src_w}, {src_h})")
+
+
+def copy_full_img(ori_im: Image) -> Image:
+    out_im = ori_im.copy()
+    # 复制格式信息
+    out_im.format = ori_im.format
+    # 复制info中的元数据（包括ICC配置文件等）
+    out_im.info = ori_im.info.copy()
+    return out_im
+
+
+@contextmanager
+def trans_uri_to_im(uri: str, use_copy: bool = False) -> typing.Generator:
+    """将输入资源转换成Image对象
+
+    Args:
+        uri: 文件路径 或者 可下载的链接地址
+        use_copy: 是否复制图像，使其不依赖打开的文件
+
+    Raises:
+        ProcessLimitException: 处理图像大小/像素限制
+
+    Returns:
+        Image对象
+    """
+    parsed_url = urllib.parse.urlparse(uri)
+    if parsed_url.scheme in _ALLOW_SCHEMES:
+        # 可能包含 %20 (空格) 等编码，需要 unquote
+        filename = os.path.basename(urllib.parse.unquote(parsed_url.path))
+        _, suffix = os.path.splitext(filename)
+        with tempfile.NamedTemporaryFile(suffix=suffix, dir=settings.PROCESSOR_TEMP_DIR) as fp:
+            # 输入值计算md5作为文件名；重复地址本地若存在不下载多次
+            urlretrieve(uri, filename=fp.name)
+            fp.seek(0)
+
+            size = os.path.getsize(fp.name)
+            if size > settings.PROCESSOR_MAX_FILE_SIZE * 1024 * 1024:
+                raise ProcessLimitException(f"图像文件大小不得超过{settings.PROCESSOR_MAX_FILE_SIZE}MB")
+
+            with Image.open(fp) as uri_im:
+                validate_ori_im(uri_im)
+                # 解决临时文件close后im对象不能正常使用得问题
+                ori_im = copy_full_img(uri_im)
+                yield ori_im
+    else:
+        size = os.path.getsize(uri)
+        if size > settings.PROCESSOR_MAX_FILE_SIZE * 1024 * 1024:
+            raise ProcessLimitException(f"图像文件大小不得超过{settings.PROCESSOR_MAX_FILE_SIZE}MB")
+        with Image.open(uri) as uri_im:
+            validate_ori_im(uri_im)
+            ori_im = uri_im
+            if use_copy:
+                ori_im = copy_full_img(ori_im)
+            yield ori_im
+
+
 class ImgSaveParser(BaseParser):
     KEY = ""
     ARGS = {
-        "format": {"type": enums.ArgType.STRING, "default": None},
-        "quality": {"type": enums.ArgType.INTEGER, "default": None, "min": 1, "max": 100},
+        "format": {"type": enums.ArgType.STRING.value, "default": None},
+        "quality": {"type": enums.ArgType.INTEGER.value, "default": None, "min": 1, "max": 100},
         # 1 表示将原图设置成渐进显示
-        "interlace": {"type": enums.ArgType.INTEGER, "default": 0, "choices": [0, 1]},
+        "interlace": {"type": enums.ArgType.INTEGER.value, "default": 0, "choices": [0, 1]},
     }
 
     def __init__(

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/parsers/blur.py

@@ -10,10 +10,10 @@ from .base import BaseParser, pre_processing
 
 class BlurParser(BaseParser):
 
-    KEY = enums.OpAction.BLUR
+    KEY = enums.OpAction.BLUR.value
     ARGS = {
         # 模糊半径，值越大，图片越模糊
-        "r": {"type": enums.ArgType.INTEGER, "required": True, "min": 1, "max": 50},
+        "r": {"type": enums.ArgType.INTEGER.value, "required": True, "min": 1, "max": 50},
     }
 
     def __init__(

{py_img_processor-1.0.1 → py_img_processor-1.2.4}/imgprocessor/parsers/circle.py

@@ -10,9 +10,9 @@ from .base import BaseParser, pre_processing
 
 class CircleParser(BaseParser):
 
-    KEY = enums.OpAction.CIRCLE
+    KEY = enums.OpAction.CIRCLE.value
     ARGS = {
-        "r": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
+        "r": {"type": enums.ArgType.INTEGER.value, "default": 0, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
     }
 
     def __init__(