py-img-processor 1.0.3__tar.gz → 1.2.0__tar.gz

{py_img_processor-1.0.3/py_img_processor.egg-info → py_img_processor-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-img-processor
-Version: 1.0.3
+Version: 1.2.0
 Summary: Image editor using Python and Pillow.
 Home-page: https://github.com/SkylerHu/py-img-processor.git
 Author: SkylerHu
@@ -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,8 @@ 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_TEXT_FONT` 字体的设置是文字水印必要参数，需保证系统已安装该字体。默认值 `Arial Unicode.ttf` 是MacOS系统存在的字体，建议设置字体文件路径。
 
@@ -82,11 +84,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 +106,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 +126,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.3 → py_img_processor-1.2.0}/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,8 @@ 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_TEXT_FONT` 字体的设置是文字水印必要参数，需保证系统已安装该字体。默认值 `Arial Unicode.ttf` 是MacOS系统存在的字体，建议设置字体文件路径。
 
@@ -56,11 +58,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 +80,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 +100,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.3 → py_img_processor-1.2.0}/imgprocessor/__init__.py

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

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/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.3 → py_img_processor-1.2.0}/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.3 → py_img_processor-1.2.0}/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
@@ -40,7 +41,7 @@ class ProcessParams(object):
     ) -> None:
         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)

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/imgprocessor/parsers/base.py

@@ -1,11 +1,20 @@
+#!/usr/bin/env python
+# coding=utf-8
 import typing
 
+import os
 import re
+import tempfile
+import urllib.parse
+from urllib.request import urlretrieve
 
 from PIL import Image, ImageOps
 
-from imgprocessor import enums, utils
-from imgprocessor.exceptions import ParamValidateException, ParamParseException
+from imgprocessor import settings, enums, utils
+from imgprocessor.exceptions import ParamValidateException, ParamParseException, ProcessLimitException
+
+
+_ALLOW_SCHEMES = ("http", "https")
 
 
 class BaseParser(object):
@@ -64,6 +73,11 @@ class BaseParser(object):
                         value = cls._validate_number(value, use_float=True, **config)
                     elif _type == enums.ArgType.STRING:
                         value = cls._validate_str(value, enable_base64=enable_base64, **config)
+                    elif _type == enums.ArgType.URI:
+                        value = cls._validate_uri(value, enable_base64=enable_base64, **config)
+                    elif _type == enums.ArgType.ACTION:
+                        if value and isinstance(value, str):
+                            value = cls._validate_str(value, enable_base64=enable_base64, **config)
 
                     choices = config.get("choices")
                     if choices and value not in choices:
@@ -82,7 +96,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("参数类型不符合要求，必须是字符串类型")
@@ -101,7 +115,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
@@ -125,6 +139,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格式数据
@@ -208,11 +263,11 @@ def compute_by_geography(
         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
 
 
@@ -231,11 +286,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
@@ -304,6 +359,53 @@ 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 trans_uri_to_im(uri: str) -> Image:
+    """将输入资源转换成Image对象
+
+    Args:
+        uri: 文件路径 或者 可下载的链接地址
+
+    Raises:
+        ProcessLimitException: 处理图像大小/像素限制
+
+    Returns:
+        Image对象
+    """
+    parsed_url = urllib.parse.urlparse(uri)
+    if parsed_url.scheme in _ALLOW_SCHEMES:
+        with tempfile.NamedTemporaryFile() 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")
+
+            ori_im = Image.open(fp)
+            validate_ori_im(ori_im)
+            # 解决临时文件close后im对象不能正常使用得问题
+            ori_im = ori_im.copy()
+    else:
+        size = os.path.getsize(uri)
+        if size > settings.PROCESSOR_MAX_FILE_SIZE * 1024 * 1024:
+            raise ProcessLimitException(f"图像文件大小不得超过{settings.PROCESSOR_MAX_FILE_SIZE}MB")
+        ori_im = Image.open(uri)
+        validate_ori_im(ori_im)
+
+    return ori_im
+
+
 class ImgSaveParser(BaseParser):
     KEY = ""
     ARGS = {

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/imgprocessor/parsers/crop.py

@@ -64,14 +64,14 @@ class CropParser(BaseParser):
             if "w" in pf:
                 if w < 0 or w > 100:
                     raise ParamValidateException(f"pf={pf}包含了w，所以w作为百分比取值范围为[0,100]")
-                w = int(src_w * w / 100)
+                w = round(src_w * w / 100)
             elif not w:
                 w = src_w
 
             if "h" in pf:
                 if h < 0 or h > 100:
                     raise ParamValidateException(f"pf={pf}包含了h，所以h作为百分比取值范围为[0,100]")
-                h = int(src_h * h / 100)
+                h = round(src_h * h / 100)
             elif not h:
                 h = src_h
 

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/imgprocessor/parsers/merge.py

@@ -5,7 +5,8 @@ import typing
 from PIL import Image
 
 from imgprocessor import enums, settings
-from .base import BaseParser, pre_processing, compute_by_geography, compute_splice_two_im
+from imgprocessor.exceptions import ParamValidateException
+from .base import BaseParser, pre_processing, compute_by_geography, compute_splice_two_im, trans_uri_to_im
 
 
 class MergeParser(BaseParser):
@@ -13,11 +14,13 @@ class MergeParser(BaseParser):
     KEY = enums.OpAction.MERGE
     ARGS = {
         # 要处理的图片
-        "image": {"type": enums.ArgType.STRING, "required": True, "base64_encode": True},
+        "image": {"type": enums.ArgType.URI, "required": True, "base64_encode": True},
         # 对image的处理参数
-        "action": {"type": enums.ArgType.STRING, "base64_encode": True},
+        "actions": {"type": enums.ArgType.ACTION, "base64_encode": True},
         # 使用输入图像的大小作为参照进行缩放
         "p": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": 1000},
+        # 是否将imgae当做背景放在输入图像之下; 定义输入图像和image参数的拼接顺序
+        "bg": {"type": enums.ArgType.INTEGER, "default": 0, "choices": [0, 1]},
         # 对齐方式
         "order": {"type": enums.ArgType.INTEGER, "choices": enums.PositionOrder},
         "align": {"type": enums.ArgType.INTEGER, "default": enums.PositionAlign.BOTTOM, "choices": enums.PositionAlign},
@@ -30,38 +33,52 @@ class MergeParser(BaseParser):
         # 拼接后大小包含2个图像，空白区域使用color颜色填充
         "color": {
             "type": enums.ArgType.STRING,
-            "default": "FFFFFF",
+            "default": "0000",  # 为了保证透明背景
             "regex": r"^([0-9a-fA-F]{6}|[0-9a-fA-F]{8}|[0-9a-fA-F]{3,4})$",
         },
     }
 
     def __init__(
         self,
-        image: typing.Optional[str] = None,
-        action: typing.Optional[str] = None,
+        image: str = "",
+        actions: typing.Union[str, list] = "",
         p: int = 0,
         order: typing.Optional[int] = None,
         align: int = 2,
         interval: int = 0,
+        bg: int = 0,
         g: typing.Optional[str] = None,
         x: int = 0,
         y: int = 0,
         pf: str = "",
-        color: str = "FFFFFF",
+        color: str = "0000",
         **kwargs: typing.Any,
     ) -> None:
         self.image = image
-        self.action = action
         self.p = p
         self.order = order
         self.align = align
         self.interval = interval
+        self.bg = bg
         self.g = g
         self.x = x
         self.y = y
         self.pf = pf
         self.color = color
 
+        self.actions: list[BaseParser] = []
+        if actions:
+            from imgprocessor.processor import ProcessParams
+
+            try:
+                if isinstance(actions, str):
+                    params = ProcessParams.parse_str(actions)
+                else:
+                    params = ProcessParams(actions=actions)
+                self.actions = params.actions
+            except ParamValidateException as e:
+                raise ParamValidateException(f"merage操作中actions参数校验异常，其中 {e}")
+
     def compute(self, src_w: int, src_h: int, w2: int, h2: int) -> tuple:
         if self.order in enums.PositionOrder:  # type: ignore
             order = typing.cast(int, self.order)
@@ -92,18 +109,25 @@ class MergeParser(BaseParser):
         im = pre_processing(im, use_alpha=True)
         src_w, src_h = im.size
 
-        im2 = Image.open(self.image)
+        # 处理要合并的图像
+        im2 = trans_uri_to_im(self.image)
         im2 = pre_processing(im2, use_alpha=True)
-        if self.action:
-            from imgprocessor.processor import ProcessParams, handle_img_actions
+        if self.actions:
+            from imgprocessor.processor import ProcessorCtr
 
-            params = ProcessParams.parse_str(self.action)
-            im2 = handle_img_actions(im2, params.actions)
+            im2 = ProcessorCtr.handle_img_actions(im2, self.actions)
         if self.p:
-            w2, h2 = int(src_w * self.p / 100), int(src_h * self.p / 100)
+            w2, h2 = round(src_w * self.p / 100), round(src_h * self.p / 100)
             im2 = im2.resize((w2, h2), resample=Image.LANCZOS)
+
+        if self.bg:
+            # 调整拼接顺序
+            im, im2 = im2, im
+
+        src_w, src_h = im.size
         w2, h2 = im2.size
 
+        # 计算合并像素点
         w, h, x1, y1, x2, y2 = self.compute(src_w, src_h, w2, h2)
         out = Image.new("RGBA", (w, h), color=f"#{self.color}")
         out.paste(im, (x1, y1), im)

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/imgprocessor/parsers/resize.py

@@ -20,7 +20,7 @@ class ResizeParser(BaseParser):
         "limit": {"type": enums.ArgType.INTEGER, "default": 1, "choices": [0, 1]},
         "color": {
             "type": enums.ArgType.STRING,
-            "default": "FFFFFF",
+            "default": "FFFFFF",  # 默认白色
             "regex": r"^([0-9a-fA-F]{6}|[0-9a-fA-F]{8}|[0-9a-fA-F]{3,4})$",
         },
         "p": {"type": enums.ArgType.INTEGER, "default": 0, "min": 1, "max": 1000},
@@ -57,45 +57,46 @@ class ResizeParser(BaseParser):
                 # w,h按指定的即可，无需计算
                 w, h = self.w, self.h
             elif self.m == enums.ResizeMode.MFIT:
+                # 低版本Pillow未实现 ImageOps.cover 方法，自行处理
                 # 等比缩放
                 if self.w and self.h:
                     # 指定w与h的矩形外的最小图像
                     if self.w / self.h > src_w / src_h:
-                        w, h = self.w, int(self.w * src_h / src_w)
+                        w, h = self.w, round(self.w * src_h / src_w)
                     else:
-                        w, h = int(self.h * src_w / src_h), self.h
+                        w, h = round(self.h * src_w / src_h), self.h
                 elif self.w:
-                    w, h = self.w, int(self.w * src_h / src_w)
+                    w, h = self.w, round(self.w * src_h / src_w)
                 else:
-                    w, h = int(self.h * src_w / src_h), self.h
+                    w, h = round(self.h * src_w / src_h), self.h
             else:
                 # 默认 enums.ResizeMode.LFIT
                 # 等比缩放
                 if self.w and self.h:
                     # 指定w与h的矩形内的最大图像
                     if self.w / self.h > src_w / src_h:
-                        w, h = int(self.h * src_w / src_h), self.h
+                        w, h = round(self.h * src_w / src_h), self.h
                     else:
-                        w, h = self.w, int(self.w * src_h / src_w)
+                        w, h = self.w, round(self.w * src_h / src_w)
                 elif self.w:
-                    w, h = self.w, int(self.w * src_h / src_w)
+                    w, h = self.w, round(self.w * src_h / src_w)
                 else:
-                    w, h = int(self.h * src_w / src_h), self.h
+                    w, h = round(self.h * src_w / src_h), self.h
         elif self.l:
             # 按最长边缩放
             if src_w > src_h:
-                w, h = self.l, int(src_h * self.l / src_w)
+                w, h = self.l, round(src_h * self.l / src_w)
             else:
-                w, h = int(src_w * self.l / src_h), self.l
+                w, h = round(src_w * self.l / src_h), self.l
         elif self.s:
             # 按最短边缩放
             if src_w > src_h:
-                w, h = int(src_w * self.s / src_h), self.s
+                w, h = round(src_w * self.s / src_h), self.s
             else:
-                w, h = self.s, int(src_h * self.s / src_w)
+                w, h = self.s, round(src_h * self.s / src_w)
         elif self.p:
             # 按照比例缩放
-            w, h = int(src_w * self.p / 100), int(src_h * self.p / 100)
+            w, h = round(src_w * self.p / 100), round(src_h * self.p / 100)
         else:
             # 缺少参数
             raise ParamValidateException("resize操作缺少合法参数")

{py_img_processor-1.0.3 → py_img_processor-1.2.0}/imgprocessor/parsers/watermark.py

@@ -6,7 +6,7 @@ from PIL import Image, ImageFont, ImageDraw
 
 from imgprocessor import enums, settings, utils
 from imgprocessor.exceptions import ParamValidateException
-from .base import BaseParser, pre_processing, compute_splice_two_im, compute_by_geography
+from .base import BaseParser, pre_processing, compute_splice_two_im, compute_by_geography, trans_uri_to_im
 
 
 class WatermarkParser(BaseParser):
@@ -25,12 +25,13 @@ class WatermarkParser(BaseParser):
         "padx": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 4096},
         "pady": {"type": enums.ArgType.INTEGER, "default": 0, "min": 0, "max": 4096},
         # 图片水印路径
-        "image": {"type": enums.ArgType.STRING, "base64_encode": True},
+        "image": {"type": enums.ArgType.URI, "base64_encode": True},
         # 水印的原始设计参照尺寸，会根据原图大小缩放水印
         "design": {"type": enums.ArgType.INTEGER, "min": 1, "max": settings.PROCESSOR_MAX_W_H},
         # 文字
         "text": {"type": enums.ArgType.STRING, "base64_encode": True, "max_length": 64},
         "font": {"type": enums.ArgType.STRING, "base64_encode": True},
+        # 文字默认黑色
         "color": {"type": enums.ArgType.STRING, "default": "000000", "regex": "^([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$"},
         "size": {"type": enums.ArgType.INTEGER, "default": 40, "min": 1, "max": 1000},
         # 文字水印的阴影透明度, 0表示没有阴影
@@ -99,7 +100,7 @@ class WatermarkParser(BaseParser):
         w1, h1, w2, h2 = 0, 0, 0, 0
         icon = None
         if self.image:
-            icon = Image.open(self.image)
+            icon = trans_uri_to_im(self.image)
             icon = pre_processing(icon, use_alpha=True)
             if not self.text:
                 # 没有文字，直接返回
@@ -132,7 +133,7 @@ class WatermarkParser(BaseParser):
 
         # 阴影要单独处理透明度，放在文字之前处理
         if self.shadow:
-            offset = max(int(self.size / 20), 2)
+            offset = max(round(self.size / 20), 2)
             shadow_color = "#000000"
             # 左上到右下的阴影，只保留这一个
             draw.text((x2 + offset, y2 + offset), self.text, font=font, fill=shadow_color)
@@ -140,7 +141,7 @@ class WatermarkParser(BaseParser):
             # draw.text((x2 + offset, y2 - offset), self.text, font=font, fill=shadow_color)
             # draw.text((x2 - offset, y2 - offset), self.text, font=font, fill=shadow_color)
             _, _, _, alpha_channel = mark.split()
-            alpha_channel = alpha_channel.point(lambda i: min(int(255 * self.shadow / 100), i))
+            alpha_channel = alpha_channel.point(lambda i: min(round(255 * self.shadow / 100), i))
             mark.putalpha(alpha_channel)
 
         # 处理文字
@@ -168,7 +169,7 @@ class WatermarkParser(BaseParser):
             # 处理缩放
             rate = min(src_w, src_h) / self.design
             if rate != 1:
-                w, h = int(w * rate), int(h * rate)
+                w, h = round(w * rate), round(h * rate)
                 mark = mark.resize((w, h), resample=Image.LANCZOS)
 
         if 0 < self.rotate < 360:
@@ -180,17 +181,17 @@ class WatermarkParser(BaseParser):
         if w > src_w or h > src_h:
             # 水印大小超过原图了, 原图矩形内的最大图像
             if w / h > src_w / src_h:
-                w, h = src_w, int(src_w * h / w)
+                w, h = src_w, round(src_w * h / w)
                 self.x = 0
             else:
-                w, h = int(src_h * w / h), src_h
+                w, h = round(src_h * w / h), src_h
                 self.y = 0
             mark = mark.resize((w, h), resample=Image.LANCZOS)
 
         if self.t < 100:
             # 处理透明度
             _, _, _, alpha_channel = mark.split()
-            alpha_channel = alpha_channel.point(lambda i: min(int(255 * self.t / 100), i))
+            alpha_channel = alpha_channel.point(lambda i: min(round(255 * self.t / 100), i))
             mark.putalpha(alpha_channel)
 
         # 计算位置，粘贴水印

py_img_processor-1.2.0/imgprocessor/processor.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# coding=utf-8
+import typing
+import tempfile
+import colorsys
+
+from PIL import Image, ImageOps
+
+from imgprocessor import enums, settings
+from imgprocessor.parsers import BaseParser, ProcessParams
+from imgprocessor.parsers.base import trans_uri_to_im
+
+
+class ProcessorCtr(object):
+
+    def __init__(self, input_uri: str, out_path: str, params: typing.Union[ProcessParams, dict, str]) -> None:
+        # 输入文件检验路径
+        self.input_uri = BaseParser._validate_uri(input_uri)
+        self.out_path = out_path
+        # 初始化处理参数
+        if isinstance(params, dict):
+            params = ProcessParams(**params)
+        elif isinstance(params, str):
+            params = ProcessParams.parse_str(params)
+        params = typing.cast(ProcessParams, params)
+        self.params = params
+
+    def run(self) -> typing.Optional[typing.ByteString]:
+        # 初始化输入
+        ori_im = trans_uri_to_im(self.input_uri)
+        # 处理图像
+        im = self.handle_img_actions(ori_im, self.params.actions)
+        # 输出、保存
+        kwargs = self.params.save_parser.compute(ori_im, im)
+        return self.save_img_to_file(im, out_path=self.out_path, **kwargs)
+
+    @classmethod
+    def handle_img_actions(cls, ori_im: Image, actions: list[BaseParser]) -> Image:
+        im = ori_im
+        # 解决旋转问题
+        im = ImageOps.exif_transpose(im)
+        for parser in actions:
+            im = parser.do_action(im)
+        return im
+
+    @classmethod
+    def save_img_to_file(
+        cls,
+        im: Image,
+        out_path: typing.Optional[str] = None,
+        **kwargs: typing.Any,
+    ) -> typing.Optional[typing.ByteString]:
+        fmt = kwargs.get("format") or im.format
+        kwargs["format"] = fmt
+
+        if fmt.upper() == enums.ImageFormat.JPEG and im.mode == "RGBA":
+            im = im.convert("RGB")
+
+        if not kwargs.get("quality"):
+            if fmt.upper() == enums.ImageFormat.JPEG and im.format == enums.ImageFormat.JPEG:
+                kwargs["quality"] = "keep"
+            else:
+                kwargs["quality"] = settings.PROCESSOR_DEFAULT_QUALITY
+
+        if out_path:
+            # icc_profile 是为解决色域的问题
+            im.save(out_path, **kwargs)
+            return None
+
+        # 没有传递保存的路径，返回文件内容
+        suffix = fmt or "png"
+        with tempfile.NamedTemporaryFile(suffix=f".{suffix}") as fp:
+            im.save(fp.name, **kwargs)
+            fp.seek(0)
+            content = fp.read()
+        return content
+
+
+def process_image(
+    input_uri: str, out_path: str, params: typing.Union[ProcessParams, dict, str]
+) -> typing.Optional[typing.ByteString]:
+    """处理图像
+
+    Args:
+        input_uri: 输入图像路径
+        out_path: 输出图像保存路径
+        params: 图像处理参数
+
+    Raises:
+        ProcessLimitException: 超过处理限制会抛出异常
+
+    Returns:
+        默认输出直接存储无返回，仅当out_path为空时会返回处理后图像的二进制内容
+    """
+    ctr = ProcessorCtr(input_uri, out_path, params)
+    return ctr.run()
+
+
+def extract_main_color(img_path: str, delta_h: float = 0.3) -> str:
+    """获取图像主色调
+
+    Args:
+        img_path: 输入图像的路径
+        delta_h: 像素色相和平均色相做减法的绝对值小于该值，才用于计算主色调，取值范围[0,1]
+
+    Returns:
+        颜色值，eg: FFFFFF
+    """
+    r, g, b = 0, 0, 0
+    im = Image.open(img_path)
+    if im.mode != "RGB":
+        im = im.convert("RGB")
+    # 转换成HSV即 色相(Hue)、饱和度(Saturation)、明度(alue)，取值范围[0,1]
+    # 取H计算平均色相
+    all_h = [colorsys.rgb_to_hsv(*im.getpixel((x, y)))[0] for x in range(im.size[0]) for y in range(im.size[1])]
+    avg_h = sum(all_h) / (im.size[0] * im.size[1])
+    # 取与平均色相相近的像素色值rgb用于计算，像素值取值范围[0,255]
+    beyond = list(
+        filter(
+            lambda x: abs(colorsys.rgb_to_hsv(*x)[0] - avg_h) < delta_h,
+            [im.getpixel((x, y)) for x in range(im.size[0]) for y in range(im.size[1])],
+        )
+    )
+    if len(beyond):
+        r = int(sum(e[0] for e in beyond) / len(beyond))
+        g = int(sum(e[1] for e in beyond) / len(beyond))
+        b = int(sum(e[2] for e in beyond) / len(beyond))
+
+    color = "{}{}{}".format(hex(r)[2:].zfill(2), hex(g)[2:].zfill(2), hex(b)[2:].zfill(2))
+    return color.upper()

{py_img_processor-1.0.3 → py_img_processor-1.2.0/py_img_processor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-img-processor
-Version: 1.0.3
+Version: 1.2.0
 Summary: Image editor using Python and Pillow.
 Home-page: https://github.com/SkylerHu/py-img-processor.git
 Author: SkylerHu
@@ -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,8 @@ 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_TEXT_FONT` 字体的设置是文字水印必要参数，需保证系统已安装该字体。默认值 `Arial Unicode.ttf` 是MacOS系统存在的字体，建议设置字体文件路径。
 
@@ -82,11 +84,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 +106,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 +126,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.3/imgprocessor/processor.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python
-# coding=utf-8
-import typing
-import os
-import tempfile
-import colorsys
-
-from PIL import Image, ImageOps
-
-from imgprocessor import settings, enums
-from imgprocessor.exceptions import ProcessLimitException
-from imgprocessor.parsers import BaseParser, ProcessParams
-
-
-def handle_img_actions(ori_im: Image, actions: list[BaseParser]) -> Image:
-    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})")
-
-    im = ori_im
-    im = ImageOps.exif_transpose(im)
-
-    for parser in actions:
-        im = parser.do_action(im)
-
-    return im
-
-
-def save_img_to_file(
-    im: Image,
-    out_path: typing.Optional[str] = None,
-    **kwargs: typing.Any,
-) -> typing.Optional[typing.ByteString]:
-    fmt = kwargs.get("format") or im.format
-    kwargs["format"] = fmt
-
-    if fmt.upper() == enums.ImageFormat.JPEG and im.mode == "RGBA":
-        im = im.convert("RGB")
-
-    if not kwargs.get("quality"):
-        if fmt.upper() == enums.ImageFormat.JPEG and im.format == enums.ImageFormat.JPEG:
-            kwargs["quality"] = "keep"
-        else:
-            kwargs["quality"] = settings.PROCESSOR_DEFAULT_QUALITY
-
-    if out_path:
-        # icc_profile 是为解决色域的问题
-        im.save(out_path, **kwargs)
-        return None
-
-    # 没有传递保存的路径，返回文件内容
-    suffix = fmt or "png"
-    with tempfile.NamedTemporaryFile(suffix=f".{suffix}") as fp:
-        im.save(fp.name, **kwargs)
-        fp.seek(0)
-        content = fp.read()
-    return content
-
-
-def process_image_by_path(
-    input_path: str, out_path: str, params: typing.Union[ProcessParams, dict, str]
-) -> typing.Optional[typing.ByteString]:
-    """处理图像
-
-    Args:
-        input_path: 输入图像文件路径
-        out_path: 输出图像保存路径
-        params: 图像处理参数
-
-    Raises:
-        ProcessLimitException: 超过处理限制会抛出异常
-
-    Returns:
-        默认输出直接存储无返回，仅当out_path为空时会返回处理后图像的二进制内容
-    """
-    size = os.path.getsize(input_path)
-    if size > settings.PROCESSOR_MAX_FILE_SIZE * 1024 * 1024:
-        raise ProcessLimitException(f"图像文件大小不得超过{settings.PROCESSOR_MAX_FILE_SIZE}MB")
-    if isinstance(params, dict):
-        params = ProcessParams(**params)
-    elif isinstance(params, str):
-        params = ProcessParams.parse_str(params)
-    params = typing.cast(ProcessParams, params)
-
-    ori_im = Image.open(input_path)
-    # 处理图像
-    im = handle_img_actions(ori_im, params.actions)
-
-    kwargs = params.save_parser.compute(ori_im, im)
-    return save_img_to_file(im, out_path=out_path, **kwargs)
-
-
-def extract_main_color(img_path: str, delta_h: float = 0.3) -> str:
-    """获取图像主色调
-
-    Args:
-        img_path: 输入图像的路径
-        delta_h: 像素色相和平均色相做减法的绝对值小于该值，才用于计算主色调，取值范围[0,1]
-
-    Returns:
-        颜色值，eg: FFFFFF
-    """
-    r, g, b = 0, 0, 0
-    im = Image.open(img_path)
-    if im.mode != "RGB":
-        im = im.convert("RGB")
-    # 转换成HSV即 色相(Hue)、饱和度(Saturation)、明度(alue)，取值范围[0,1]
-    # 取H计算平均色相
-    all_h = [colorsys.rgb_to_hsv(*im.getpixel((x, y)))[0] for x in range(im.size[0]) for y in range(im.size[1])]
-    avg_h = sum(all_h) / (im.size[0] * im.size[1])
-    # 取与平均色相相近的像素色值rgb用于计算，像素值取值范围[0,255]
-    beyond = list(
-        filter(
-            lambda x: abs(colorsys.rgb_to_hsv(*x)[0] - avg_h) < delta_h,
-            [im.getpixel((x, y)) for x in range(im.size[0]) for y in range(im.size[1])],
-        )
-    )
-    if len(beyond):
-        r = int(sum(e[0] for e in beyond) / len(beyond))
-        g = int(sum(e[1] for e in beyond) / len(beyond))
-        b = int(sum(e[2] for e in beyond) / len(beyond))
-
-    color = "{}{}{}".format(hex(r)[2:].zfill(2), hex(g)[2:].zfill(2), hex(b)[2:].zfill(2))
-    return color.upper()