imager-client 1.0.0__py3-none-any.whl

imager/Imager.py

@@ -0,0 +1,238 @@
+from .ImagerData import ImagerData
+from .ImagerFormat import GetFormat
+from .ImagerEncode import encode
+from typing import Mapping, Any, List, Union
+from typing_extensions import Self
+
+
+class Imager:
+    """Imager
+    Горячее создание миниатюр для картинок
+    @see https://github.com/pkg-ru/imager
+
+    Args:
+        thumb (str | Mapping[str, Any], optional): устанавливаем thumb или настройки по умолчанию. Defaults to "".
+    """
+
+    instance = {}
+
+    def __init__(self, thumb: Union[str, Mapping[str, Any]] = "") -> Self:
+        self.instance = ImagerData()
+
+        if isinstance(thumb, str):
+            self.thumb(thumb)
+        else:
+            self.setting(thumb)
+
+    def setting(self, setting: Mapping[str, Any]) -> Self:
+        """Настройки
+
+        Returns:
+                Imager: Imager
+        """
+        for key in setting:
+            if key in self.instance:
+                self.instance[key] = setting[key]
+        return self
+
+    def clone(self) -> "Imager":
+        """Клонируем, чтобы не вносить изменения в общий экземпляр
+
+        Returns:
+                Imager: Imager
+        """
+        my = Imager(self.instance)
+        my.instance = self.instance.copy()
+        return my
+
+    def copy(self) -> "Imager":
+        """Клонируем, чтобы не вносить изменения в общий экземпляр
+
+        Returns:
+                Imager: Imager
+        """
+        return self.clone()
+
+    def size(self, width: int = 0, height: int = 0) -> Self:
+        """Изменяем размер
+
+        Returns:
+                self: self
+        """
+        self.width(width)
+        return self.height(height)
+
+    def width(self, width: int = 0) -> Self:
+        """Ширина
+
+        Returns:
+                self: self
+        """
+        self.instance["width"] = width
+        return self
+
+    def height(self, height: int = 0) -> Self:
+        """Высота
+
+        Returns:
+                self: self
+        """
+        self.instance["height"] = height
+        return self
+
+    def quality(self, quality: int) -> Self:
+        """Качество
+
+        Returns:
+                self: self
+        """
+        self.instance["quality"] = quality
+        return self
+
+    def crop(self, crop: bool) -> Self:
+        """Кроп
+
+        Returns:
+                self: self
+        """
+        self.instance["crop"] = crop
+        return self
+
+    def color(self, r: int, g: int, b: int) -> Self:
+        """Цвет фона
+
+        Returns:
+                self: self
+        """
+        self.instance["color"] = [r, g, b]
+        return self
+
+    def loop(self, loop: bool) -> Self:
+        """Зацикливание анимации
+
+        Returns:
+                self: self
+        """
+        self.instance["loop"] = loop
+        return self
+
+    def thumb(self, thumb: str) -> Self:
+        """Шаблон настроек на сервере Imager
+
+        Returns:
+                self: self
+        """
+        self.instance["thumb"] = thumb
+        return self
+
+    def trim(self, active: bool, rate: int = 0, color: List[List[int]] = []) -> Self:
+        """Обрезать по краям прозрачные пиксели/рамку/и т.д.
+
+        Returns:
+                self: self
+        """
+        self.trimActive(active)
+        self.trimRate(rate)
+        return self.trimColors(color)
+
+    def trimActive(self, active: bool) -> Self:
+        """активность фильтра: Обрезать по краям прозрачные пиксели/рамку/и т.д.
+
+        Returns:
+                self: self
+        """
+        self.instance["trimActive"] = active
+        return self
+
+    def trimRate(self, rate: int = 0) -> Self:
+        """огрешность при сравнении цветов: Обрезать по краям прозрачные пиксели/рамку/и т.д.
+
+        Returns:
+                self: self
+        """
+        self.instance["trimRate"] = rate
+        return self
+
+    def trimColors(self, color: List[List[int]]) -> Self:
+        """список цветов: Обрезать по краям прозрачные пиксели/рамку/и т.д.
+
+        Returns:
+                self: self
+        """
+        if len(color) > 0:
+            newColors = []
+            for item in color:
+                if len(item) == 3:
+                    newColors.append(item)
+                else:
+                    break
+            self.instance["trimColor"] = newColors
+        return self
+
+    def convert(
+        self, file: str, format: str, setting: Union[None, Mapping[str, Any]] = None
+    ) -> str:
+        """Получаем ассет на миниатюру в указаном формате
+
+        Args:
+            file (str): путь к исходной картинке
+            format (str): формат файла миниатюры
+            setting (None | Mapping[str, Any], optional): Настройки. Defaults to None.
+
+        Returns:
+            str: asset path
+        """
+        if setting != None:
+            instance = self.clone().setting(setting).instance
+        else:
+            instance = self.instance
+
+        file_arr = file.split(".")
+        lastIndex = len(file_arr) - 1
+        instance["format"] = file_arr[lastIndex]
+        if GetFormat(instance["format"]) == False:
+            return file
+
+        if format == "":
+            format = str(instance["format"]).lower()
+
+        nf = GetFormat(format)
+        if nf == False:
+            return file
+
+        instance["formatTo"] = nf
+        if instance["format"] == format:
+            # если запрашиваемый формат совпадает с текущим то не пишем в данные
+            instance["format"] = ""
+
+        if (
+            instance["format"] != ""
+            and instance["format"] == str(instance["format"]).lower()
+        ):
+            # если формат файла в нижнем регистре, пишем в данные только 1 байт
+            nf = GetFormat(instance["format"])
+            if nf != False:
+                instance["formatFrom"] = nf
+                instance["format"] = ""
+
+        if instance["trimActive"] != True:
+            instance["trimColor"] = []
+            instance["trimRate"] = 0
+
+        code = encode(instance)
+        if code == "":
+            return file
+
+        return ".".join(file_arr[0:lastIndex]) + "/" + code + "." + format
+
+    def get(self, file: str, setting: Union[None, Mapping[str, Any]] = None) -> str:
+        """Получаем ассет на миниатюру в формате исходного файла
+
+        Args:
+            file (str): путь к исходной картинке
+            setting (None | Mapping[str, Any], optional): Настройки. Defaults to None.
+
+        Returns:
+            str: asset path
+        """
+        return self.convert(file, "", setting)

imager/ImagerData.py

@@ -0,0 +1,46 @@
+from typing import Mapping, Any, List
+
+
+def ImagerData() -> Mapping[str, Any]:
+    return {
+        "trimColor": [],
+        "format": "",
+        "thumb": "",
+        "color": [],
+        "width": 0,
+        "height": 0,
+        "formatTo": 0,
+        "formatFrom": 0,
+        "quality": 0,
+        "trimRate": False,
+        "loop": True,
+        "trimActive": False,
+        "crop": False,
+    }
+
+
+Flags: Mapping[str, int] = {
+    "width": 1 << 0,
+    "height": 1 << 1,
+    "quality": 1 << 2,
+    "format": 1 << 3,
+    "color": 1 << 4,
+    "loop": 1 << 5,
+    "thumb": 1 << 6,
+    "trimActive": 1 << 7,
+    "trimColor": 1 << 8,
+    "trimRate": 1 << 9,
+    "formatTo": 1 << 10,
+    "formatFrom": 1 << 11,
+    "crop": 1 << 12,
+}
+
+
+__flagsSorted = []
+
+def FlagsSorted() -> List[str]:
+    """Отсортированные ключи"""
+    global __flagsSorted
+    if len(__flagsSorted) == 0:
+        __flagsSorted = list({key: Flags[key] for key in sorted(Flags)}.keys())
+    return __flagsSorted

imager/ImagerEncode.py

@@ -0,0 +1,58 @@
+from typing import Mapping, Any
+from base64 import urlsafe_b64encode
+import struct
+from .ImagerData import Flags, FlagsSorted
+
+
+def encode(instance: Mapping[str, Any]) -> str:
+    if instance["thumb"] == "default":
+        instance["thumb"] = ""
+
+    myFlag = 0
+    newData = b""
+
+    for name in FlagsSorted():
+        flag = Flags[name] | 0
+
+        if name == "color" and len(list(instance[name])) > 0:
+            # [3]uint8
+            myFlag |= flag
+            newData += struct.pack(
+                ">BBB",
+                instance["color"][0],
+                instance["color"][1],
+                instance["color"][2],
+            )
+        elif name == "trimColor" and len(instance[name]) > 0:
+            # [][3]uint8
+            myFlag |= flag
+            newData += struct.pack(">B", len(instance["trimColor"]) * 3)
+            for color in instance["trimColor"]:
+                newData += struct.pack(
+                    ">BBB", color[0], color[1], color[2]
+                )
+        elif name in ["loop", "trimActive", "crop"] and instance[name]:
+            # bool
+            myFlag |= flag
+        elif (
+            name in ["formatTo", "formatFrom", "quality", "trimRate"]
+            and instance[name] > 0
+        ):
+            # uint8
+            myFlag |= flag
+            newData += struct.pack(">B", instance[name])
+        elif name in ["width", "height"] and instance[name] > 0:
+            # uint16
+            myFlag |= flag
+            newData += struct.pack(">H", instance[name])
+        elif name in ["format", "thumb"] and instance[name] and instance[name] != "":
+            # string
+            myFlag |= flag
+            newData += struct.pack(">B", len(str(instance[name])))
+            newData += str(instance[name]).encode("utf-8")
+
+    return (
+        urlsafe_b64encode(struct.pack(">H", myFlag) + newData)
+        .rstrip(b"=")
+        .decode("ascii")
+    )

imager/ImagerFormat.py

@@ -0,0 +1,39 @@
+from typing import Union
+
+FORMAT_JPG = 1
+FORMAT_JPEG = 2
+FORMAT_GIF = 3
+FORMAT_PNG = 4
+FORMAT_APNG = 5
+FORMAT_JPE = 6
+FORMAT_JIF = 7
+FORMAT_JFIF = 8
+FORMAT_JFI = 9
+FORMAT_WEBP = 10
+FORMAT_AVIF = 11
+FORMAT_HEIF = 12
+FORMAT_HEIC = 13
+
+FormatList = {
+    FORMAT_JPG: "jpg",
+    FORMAT_JPEG: "jpeg",
+    FORMAT_GIF: "gif",
+    FORMAT_PNG: "png",
+    FORMAT_APNG: "apng",
+    FORMAT_JPE: "jpe",
+    FORMAT_JIF: "jif",
+    FORMAT_JFIF: "jfif",
+    FORMAT_JFI: "jfi",
+    FORMAT_WEBP: "webp",
+    FORMAT_AVIF: "avif",
+    FORMAT_HEIF: "heif",
+    FORMAT_HEIC: "heic",
+}
+
+
+def GetFormat(format: str) -> Union[int, bool]:
+    format = format.lower()
+    for key in FormatList:
+        if FormatList[key] == format:
+            return key
+    return False

imager/__init__.py

@@ -0,0 +1,39 @@
+from typing import Mapping, Any, Union
+from .Imager import Imager
+from .ImagerFormat import FormatList
+from .ImagerData import Flags, FlagsSorted
+
+
+def ImagerGet(file: str, setting: Union[None, Mapping[str, Any]] = None) -> str:
+    """Получаем ассет на миниатюру в формате исходного файла
+
+    Args:
+        file (str): путь к исходной картинке
+        setting (None | Mapping[str, Any], optional): Настройки. Defaults to None.
+
+    Returns:
+        str: asset path
+    """
+    img = Imager()
+    if setting != None:
+        img.setting(setting)
+    return img.get(file)
+
+
+def ImagerConvert(
+    file: str, format: str, setting: Union[None, Mapping[str, Any]] = None
+) -> str:
+    """Получаем ассет на миниатюру в указаном формате
+
+    Args:
+        file (str): путь к исходной картинке
+        format (str): формат файла миниатюры
+        setting (None | Mapping[str, Any], optional): Настройки. Defaults to None.
+
+    Returns:
+        str: asset path
+    """
+    img = Imager()
+    if setting != None:
+        img.setting(setting)
+    return img.convert(file, format)