sticker-convert 2.7.12__py3-none-any.whl → 2.8.0__py3-none-any.whl

sticker_convert/converter.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 import os
-from decimal import ROUND_HALF_UP, Decimal
 from fractions import Fraction
 from io import BytesIO
 from math import ceil, floor
@@ -15,12 +14,12 @@ from PIL import __version__ as PillowVersion
 from sticker_convert.job_option import CompOption
 from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.cache_store import CacheStore
-from sticker_convert.utils.media.codec_info import CodecInfo
+from sticker_convert.utils.media.codec_info import CodecInfo, rounding
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 if TYPE_CHECKING:
-    from av.video.frame import VideoFrame  # type: ignore
-    from av.video.plane import VideoPlane  # type: ignore
+    from av.video.frame import VideoFrame
+    from av.video.plane import VideoPlane
 
 MSG_START_COMP = "[I] Start compressing {} -> {}"
 MSG_SKIP_COMP = "[S] Compatible file found, skip compress and just copy {} -> {}"
@@ -44,10 +43,6 @@ YUV_RGB_MATRIX = np.array(
 )
 
 
-def rounding(value: float) -> Decimal:
-    return Decimal(value).quantize(0, ROUND_HALF_UP)
-
-
 def get_step_value(
     max_step: Optional[int],
     min_step: Optional[int],
@@ -264,14 +259,21 @@ class StickerConvert:
                 self.result_size = self.size
                 self.result_step = step_current
 
-            if step_upper - step_lower > 1 and self.size_max:
+            if (
+                step_upper - step_lower > 0
+                and step_current != step_lower
+                and self.size_max
+            ):
                 if self.size <= self.size_max:
                     sign = "<"
                     step_upper = step_current
                 else:
                     sign = ">"
                     step_lower = step_current
-                step_current = int(rounding((step_lower + step_upper) / 2))
+                if step_current == step_lower + 1:
+                    step_current = step_lower
+                else:
+                    step_current = int(rounding((step_lower + step_upper) / 2))
                 self.recompress(sign)
             elif self.result:
                 return self.compress_done(self.result, self.result_step)
@@ -409,7 +411,7 @@ class StickerConvert:
 
         if suffix in (".tgs", ".lottie", ".json"):
             self._frames_import_lottie()
-        elif suffix in (".webp", ".apng", "png"):
+        elif suffix in (".webp", ".apng", ".png", ".gif"):
             # ffmpeg do not support webp decoding (yet)
             # ffmpeg could fail to decode apng if file is buggy
             self._frames_import_pillow()
@@ -419,10 +421,24 @@ class StickerConvert:
     def _frames_import_pillow(self) -> None:
         with Image.open(self.in_f) as im:
             # Note: im.convert("RGBA") would return rgba image of current frame only
-            if "n_frames" in dir(im):
-                for i in range(im.n_frames):
-                    im.seek(i)
+            if (
+                "n_frames" in dir(im)
+                and im.n_frames != 0
+                and self.codec_info_orig.fps != 0.0
+            ):
+                duration_ptr = 0.0
+                duration_inc = 1 / self.codec_info_orig.fps * 1000
+                next_frame_start_duration = im.info.get("duration", 1000)
+                frame = 0
+                while True:
                     self.frames_raw.append(np.asarray(im.convert("RGBA")))
+                    duration_ptr += duration_inc
+                    if duration_ptr >= next_frame_start_duration:
+                        if frame == im.n_frames:
+                            break
+                        im.seek(frame)
+                        next_frame_start_duration += im.info.get("duration", 1000)
+                        frame += 1
             else:
                 self.frames_raw.append(np.asarray(im.convert("RGBA")))
 
@@ -431,6 +447,7 @@ class StickerConvert:
         from av.codec.context import CodecContext
         from av.container.input import InputContainer
         from av.video.codeccontext import VideoCodecContext
+        from av.video.frame import VideoFrame
 
         # Crashes when handling some webm in yuv420p and convert to rgba
         # https://github.com/PyAV-Org/PyAV/issues/1166
@@ -451,19 +468,33 @@ class StickerConvert:
 
             for packet in container.demux(container.streams.video):
                 for frame in context.decode(packet):
-                    if frame.width % 2 != 0:
-                        width = frame.width - 1
-                    else:
-                        width = frame.width
+                    width_orig = frame.width
+                    height_orig = frame.height
+
+                    # Need to pad frame to even dimension first
+                    if width_orig % 2 == 1 or height_orig % 2 == 1:
+                        from av.filter import Graph
+
+                        width_new = width_orig + width_orig % 2
+                        height_new = height_orig + height_orig % 2
+
+                        graph = Graph()
+                        in_src = graph.add_buffer(template=container.streams.video[0])
+                        pad = graph.add(
+                            "pad", f"{width_new}:{height_new}:0:0:color=#00000000"
+                        )
+                        in_src.link_to(pad)
+                        sink = graph.add("buffersink")
+                        pad.link_to(sink)
+                        graph.configure()
 
-                    if frame.height % 2 != 0:
-                        height = frame.height - 1
+                        graph.push(frame)
+                        frame_resized = cast(VideoFrame, graph.pull())
                     else:
-                        height = frame.height
+                        frame_resized = frame
 
-                    if frame.format.name == "yuv420p":
-                        rgb_array = frame.to_ndarray(format="rgb24")
-                        cast("np.ndarray[Any, Any]", rgb_array)
+                    if frame_resized.format.name == "yuv420p":
+                        rgb_array = frame_resized.to_ndarray(format="rgb24")
                         rgba_array = np.dstack(
                             (
                                 rgb_array,
@@ -474,14 +505,14 @@ class StickerConvert:
                         # yuva420p may cause crash
                         # Not safe to directly call frame.to_ndarray(format="rgba")
                         # https://github.com/laggykiller/sticker-convert/issues/114
-                        frame = frame.reformat(
-                            width=width,
-                            height=height,
+                        frame_resized = frame_resized.reformat(
                             format="yuva420p",
                             dst_colorspace=1,
                         )
-                        rgba_array = yuva_to_rgba(frame)
+                        rgba_array = yuva_to_rgba(frame_resized)
 
+                    # Remove pixels that was added to make dimensions even
+                    rgba_array = rgba_array[0:width_orig, 0:height_orig]
                     self.frames_raw.append(rgba_array)
 
     def _frames_import_lottie(self) -> None:
@@ -514,25 +545,25 @@ class StickerConvert:
         anim.lottie_animation_destroy()
 
     def determine_bg_color(self) -> Tuple[int, int, int, int]:
+        mean_total = 0.0
         # Calculate average color of all frames for selecting background color
-        frames_raw_np = np.array(self.frames_raw)
-        s = frames_raw_np.shape
-        colors = frames_raw_np.reshape((-1, s[3]))  # type: ignore
-        # Do not count in alpha=0
-        # If alpha > 0, use alpha as weight
-        colors = colors[colors[:, 3] != 0]
-        if colors.shape[0] == 0:
-            return (0, 0, 0, 0)
+        for frame in self.frames_raw:
+            s = frame.shape
+            colors = frame.reshape((-1, s[2]))  # type: ignore
+            # Do not count in alpha=0
+            # If alpha > 0, use alpha as weight
+            colors = colors[colors[:, 3] != 0]
+            if colors.shape[0] != 0:
+                alphas = colors[:, 3] / 255
+                r_mean = np.mean(colors[:, 0] * alphas)
+                g_mean = np.mean(colors[:, 1] * alphas)
+                b_mean = np.mean(colors[:, 2] * alphas)
+                mean_total += (r_mean + g_mean + b_mean) / 3
+
+        if mean_total / len(self.frames_raw) < 128:
+            return (255, 255, 255, 0)
         else:
-            alphas = colors[:, 3] / 255
-            r_mean = np.mean(colors[:, 0] * alphas)
-            g_mean = np.mean(colors[:, 1] * alphas)
-            b_mean = np.mean(colors[:, 2] * alphas)
-            mean = (r_mean + g_mean + b_mean) / 3
-            if mean < 128:
-                return (255, 255, 255, 0)
-            else:
-                return (0, 0, 0, 0)
+            return (0, 0, 0, 0)
 
     def frames_resize(
         self, frames_in: "List[np.ndarray[Any, Any]]"
@@ -627,8 +658,6 @@ class StickerConvert:
         frame_current = 0
         frame_current_float = 0.0
         while True:
-            frame_current_float += frame_increment
-            frame_current = int(rounding(frame_current_float))
             if frame_current <= len(frames_in) - 1 and not (
                 frames_out_max and len(frames_out) == frames_out_max
             ):
@@ -639,6 +668,8 @@ class StickerConvert:
                 ):
                     frames_out.append(frames_in[-1])
                 return frames_out
+            frame_current_float += frame_increment
+            frame_current = int(rounding(frame_current_float))
 
     def frames_export(self) -> None:
         is_animated = len(self.frames_processed) > 1 and self.fps
@@ -727,10 +758,10 @@ class StickerConvert:
         if 0 in alpha:
             extra_kwargs["transparency"] = 0
             extra_kwargs["disposal"] = 2
-            im_out = [self.quantize(Image.fromarray(i)) for i in frames_processed]
+            im_out = [self.quantize(Image.fromarray(i)) for i in frames_processed]  # type: ignore
         else:
             im_out = [
-                self.quantize(Image.fromarray(i).convert("RGB")).convert("RGB")
+                self.quantize(Image.fromarray(i).convert("RGB")).convert("RGB")  # type: ignore
                 for i in frames_processed
             ]
 
@@ -755,10 +786,25 @@ class StickerConvert:
         config = webp.WebPConfig.new(quality=self.quality)  # type: ignore
         enc = webp.WebPAnimEncoder.new(self.res_w, self.res_h)  # type: ignore
         timestamp_ms = 0
-        for frame in self.frames_processed:
-            pic = webp.WebPPicture.from_numpy(frame)  # type: ignore
+        timestamp_inc = int(1000 / self.fps)
+
+        pic = webp.WebPPicture.from_numpy(self.frames_processed[0])  # type: ignore
+        enc.encode_frame(pic, 0, config=config)  # type: ignore
+
+        frame_num = 1
+        frame_num_prev = 1
+        frame_total = len(self.frames_processed)
+        while frame_num < frame_total - 1:
+            while frame_num < frame_total - 1 and np.array_equal(
+                self.frames_processed[frame_num_prev],
+                self.frames_processed[frame_num],
+            ):
+                timestamp_ms += timestamp_inc
+                frame_num += 1
+            pic = webp.WebPPicture.from_numpy(self.frames_processed[frame_num])  # type: ignore
             enc.encode_frame(pic, timestamp_ms, config=config)  # type: ignore
-            timestamp_ms += int(1000 / self.fps)
+            frame_num_prev = frame_num
+
         anim_data = enc.assemble(timestamp_ms)  # type: ignore
         self.tmp_f.write(anim_data.buffer())  # type: ignore
 

sticker_convert/utils/media/codec_info.py

@@ -3,13 +3,64 @@ from __future__ import annotations
 
 import mmap
 from decimal import ROUND_HALF_UP, Decimal
+from fractions import Fraction
 from io import BytesIO
+from math import gcd
 from pathlib import Path
-from typing import BinaryIO, Optional, Tuple, Union, cast
+from typing import BinaryIO, List, Optional, Tuple, Union, cast
 
 from PIL import Image, UnidentifiedImageError
 
 
+def lcm(a: int, b: int):
+    return abs(a * b) // gcd(a, b)
+
+
+def rounding(value: float) -> Decimal:
+    return Decimal(value).quantize(0, ROUND_HALF_UP)
+
+
+def fraction_gcd(x: Fraction, y: Fraction) -> Fraction:
+    a = x.numerator
+    b = x.denominator
+    c = y.numerator
+    d = y.denominator
+    return Fraction(gcd(a, c), lcm(b, d))
+
+
+def fractions_gcd(*fractions: Fraction) -> Fraction:
+    fractions_list = list(fractions)
+    gcd = fractions_list.pop(0)
+    for fraction in fractions_list:
+        gcd = fraction_gcd(gcd, fraction)
+
+    return gcd
+
+
+def get_five_dec_place(value: float) -> str:
+    return str(value).split(".")[1][:5].ljust(5, "0")
+
+
+def likely_int(value: float) -> bool:
+    if isinstance(value, int):
+        return True
+    return True if get_five_dec_place(value) in ("99999", "00000") else False
+
+
+def durations_gcd(*durations: Union[int, float]) -> Union[float, Fraction]:
+    if any(i for i in durations if isinstance(i, float)):
+        if all(i for i in durations if likely_int(i)):
+            return Fraction(gcd(*(int(rounding(i)) for i in durations)), 1)
+        # Test for denominators that can produce recurring decimal
+        for x in (3, 6, 7, 9, 11, 13):
+            if all(likely_int(i * x) for i in durations):
+                return Fraction(gcd(*(int(rounding(i * x)) for i in durations)), x)
+        else:
+            return min(durations)
+    else:
+        return Fraction(gcd(*durations), 1)  # type: ignore
+
+
 class CodecInfo:
     def __init__(
         self, file: Union[Path, bytes], file_ext: Optional[str] = None
@@ -29,8 +80,9 @@ class CodecInfo:
     @staticmethod
     def get_file_fps_frames_duration(
         file: Union[Path, bytes], file_ext: Optional[str] = None
-    ) -> Tuple[float, int, int]:
+    ) -> Tuple[float, int, float]:
         fps: float
+        duration: float
 
         if not file_ext and isinstance(file, Path):
             file_ext = CodecInfo.get_file_ext(file)
@@ -41,13 +93,12 @@ class CodecInfo:
                 duration = int(frames / fps * 1000)
             else:
                 duration = 0
+        elif file_ext == ".webp":
+            fps, frames, duration = CodecInfo._get_file_fps_frames_duration_webp(file)
+        elif file_ext in (".gif", ".apng", ".png"):
+            fps, frames, duration = CodecInfo._get_file_fps_frames_duration_pillow(file)
         else:
-            if file_ext == ".webp":
-                frames, duration = CodecInfo._get_file_frames_duration_webp(file)
-            elif file_ext in (".gif", ".apng", ".png"):
-                frames, duration = CodecInfo._get_file_frames_duration_pillow(file)
-            else:
-                frames, duration = CodecInfo._get_file_frames_duration_av(file)
+            frames, duration = CodecInfo._get_file_frames_duration_av(file)
 
             if duration > 0:
                 fps = frames / duration * 1000
@@ -63,14 +114,16 @@ class CodecInfo:
 
         if file_ext == ".tgs":
             return CodecInfo._get_file_fps_tgs(file)
-        if file_ext == ".webp":
-            frames, duration = CodecInfo._get_file_frames_duration_webp(file)
+        elif file_ext == ".webp":
+            fps, _, _ = CodecInfo._get_file_fps_frames_duration_webp(file)
+            return fps
         elif file_ext in (".gif", ".apng", ".png"):
-            frames, duration = CodecInfo._get_file_frames_duration_pillow(file)
-        else:
-            frames, duration = CodecInfo._get_file_frames_duration_av(
-                file, frames_to_iterate=10
-            )
+            fps, _, _ = CodecInfo._get_file_fps_frames_duration_pillow(file)
+            return fps
+
+        frames, duration = CodecInfo._get_file_frames_duration_av(
+            file, frames_to_iterate=10
+        )
 
         if duration > 0:
             return frames / duration * 1000
@@ -89,7 +142,7 @@ class CodecInfo:
         if file_ext == ".tgs":
             return CodecInfo._get_file_frames_tgs(file)
         if file_ext in (".gif", ".webp", ".png", ".apng"):
-            frames, _ = CodecInfo._get_file_frames_duration_pillow(
+            _, frames, _ = CodecInfo._get_file_fps_frames_duration_pillow(
                 file, frames_only=True
             )
         else:
@@ -106,7 +159,9 @@ class CodecInfo:
     @staticmethod
     def get_file_duration(
         file: Union[Path, bytes], file_ext: Optional[str] = None
-    ) -> int:
+    ) -> float:
+        duration: float
+
         # Return duration in miliseconds
         if not file_ext and isinstance(file, Path):
             file_ext = CodecInfo.get_file_ext(file)
@@ -118,9 +173,9 @@ class CodecInfo:
             else:
                 duration = 0
         elif file_ext == ".webp":
-            _, duration = CodecInfo._get_file_frames_duration_webp(file)
+            _, _, duration = CodecInfo._get_file_fps_frames_duration_webp(file)
         elif file_ext in (".gif", ".png", ".apng"):
-            _, duration = CodecInfo._get_file_frames_duration_pillow(file)
+            _, _, duration = CodecInfo._get_file_fps_frames_duration_pillow(file)
         else:
             _, duration = CodecInfo._get_file_frames_duration_av(file)
 
@@ -176,29 +231,46 @@ class CodecInfo:
         return fps, frames
 
     @staticmethod
-    def _get_file_frames_duration_pillow(
+    def _get_file_fps_frames_duration_pillow(
         file: Union[Path, bytes], frames_only: bool = False
-    ) -> Tuple[int, int]:
-        total_duration = 0
+    ) -> Tuple[float, int, float]:
+        total_duration = 0.0
+        durations: List[float] = []
 
         with Image.open(file) as im:
             if "n_frames" in dir(im):
                 frames = im.n_frames
                 if frames_only is True:
-                    return frames, 1
+                    return 0.0, frames, 1
                 for i in range(im.n_frames):
                     im.seek(i)
-                    total_duration += im.info.get("duration", 1000)
-                return frames, total_duration
-
-        return 1, 0
+                    frame_duration = cast(float, im.info.get("duration", 1000))
+                    if frame_duration not in durations and frame_duration != 0:
+                        durations.append(frame_duration)
+                    total_duration += frame_duration
+                if im.n_frames == 0 or total_duration == 0:
+                    fps = 0.0
+                elif len(durations) == 1:
+                    fps = frames / total_duration * 1000
+                else:
+                    duration_gcd = durations_gcd(*durations)
+                    frames_apparent = total_duration / duration_gcd
+                    fps = frames_apparent / total_duration * 1000
+                return fps, frames, total_duration
+
+        return (
+            0.0,
+            1,
+            0,
+        )
 
     @staticmethod
-    def _get_file_frames_duration_webp(
+    def _get_file_fps_frames_duration_webp(
         file: Union[Path, bytes],
-    ) -> Tuple[int, int]:
+    ) -> Tuple[float, int, int]:
         total_duration = 0
         frames = 0
+        durations: List[int] = []
 
         def _open_f(file: Union[Path, bytes]) -> BinaryIO:
             if isinstance(file, Path):
@@ -213,16 +285,26 @@ class CodecInfo:
                         break
                     mm.seek(anmf_pos + 20)
                     frame_duration_32 = mm.read(4)
-                    frame_duration = frame_duration_32[:-1] + bytes(
+                    frame_duration_bytes = frame_duration_32[:-1] + bytes(
                         int(frame_duration_32[-1]) & 0b11111100
                     )
-                    total_duration += int.from_bytes(frame_duration, "little")
+                    frame_duration = int.from_bytes(frame_duration_bytes, "little")
+                    if frame_duration not in durations and frame_duration != 0:
+                        durations.append(frame_duration)
+                    total_duration += frame_duration
                     frames += 1
 
         if frames == 0:
-            return 1, 0
+            return 0.0, 0, 0
+
+        if len(durations) == 1:
+            fps = frames / total_duration * 1000
+        else:
+            duration_gcd = durations_gcd(*durations)
+            frames_apparent = total_duration / duration_gcd
+            fps = float(frames_apparent / total_duration * 1000)
 
-        return frames, total_duration
+        return fps, frames, total_duration
 
     @staticmethod
     def _get_file_frames_duration_av(
@@ -246,9 +328,7 @@ class CodecInfo:
             container = cast(InputContainer, container)
             stream = container.streams.video[0]
             if container.duration:
-                duration_metadata = int(
-                    Decimal(container.duration / 1000).quantize(0, ROUND_HALF_UP)
-                )
+                duration_metadata = int(rounding(container.duration / 1000))
             else:
                 duration_metadata = 0
 
@@ -273,7 +353,7 @@ class CodecInfo:
             duration_n_minus_one = last_frame.pts * time_base_ms
             ms_per_frame = duration_n_minus_one / (frame_count - 1)
             duration = frame_count * ms_per_frame
-            return frame_count, int(Decimal(duration).quantize(0, ROUND_HALF_UP))
+            return frame_count, int(rounding(duration))
 
         return 0, 0
 

sticker_convert/version.py

@@ -1,3 +1,3 @@
 #!/usr/bin/env python3
 
-__version__ = "2.7.12"
+__version__ = "2.8.0"

{sticker_convert-2.7.12.dist-info → sticker_convert-2.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sticker-convert
-Version: 2.7.12
+Version: 2.8.0
 Summary: Convert (animated) stickers to/from WhatsApp, Telegram, Signal, Line, Kakao, iMessage. Written in Python.
 Author-email: laggykiller <chaudominic2@gmail.com>
 Maintainer-email: laggykiller <chaudominic2@gmail.com>

{sticker_convert-2.7.12.dist-info → sticker_convert-2.8.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 sticker_convert/__init__.py,sha256=iQnv6UOOA69c3soAn7ZOnAIubTIQSUxtq1Uhh8xRWvU,102
 sticker_convert/__main__.py,sha256=6RJauR-SCSSTT3TU7FFB6B6PVwsCxO2xZXtmZ3jc2Is,463
 sticker_convert/cli.py,sha256=kyfhvMoHq42uLZsYYLrr6b30xsNE93GVZlbGYPFjC2I,18385
-sticker_convert/converter.py,sha256=-BxUT-VCw-VbfbG7ZZxNTI4FIJcU3Pq2rzw0VuitiVI,32904
+sticker_convert/converter.py,sha256=Y0vVZhAxlTe_SDTbQq2_Z9vM8oY6VAJPToYji-S6J-E,35033
 sticker_convert/definitions.py,sha256=ZhP2ALCEud-w9ZZD4c3TDG9eHGPZyaAL7zPUsJAbjtE,2073
 sticker_convert/gui.py,sha256=TqdgFbHBRYgcXWWrsfxLUJ8Zu9WeE11vYyZMX6nalik,30599
 sticker_convert/job.py,sha256=J4e7dZ48t5EhM3fG-xF1BEQ10WYljx3wWamKXAJjCa8,26000
 sticker_convert/job_option.py,sha256=1YVhyTfu2cWz3qpAKbdIM11jbL0CJz0ksOYAeg8v6dc,7649
-sticker_convert/version.py,sha256=itLv7GvtbPZ961xSemMjepArEGEJR3yg6PpGH0MuovQ,47
+sticker_convert/version.py,sha256=M_a1EApD3NUMpL5LvuHWnryb8nvQLMKOHwpDKPiWPX4,46
 sticker_convert/downloaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sticker_convert/downloaders/download_base.py,sha256=5R7c8kwahAflOOYrtSQPnBVQ4T-DsprPUMP7G9wcJX4,2824
 sticker_convert/downloaders/download_kakao.py,sha256=RYrebTxEjKjXAr9xw18r0dMW0dFjSqZxzi8dpaq56TY,8581
@@ -89,12 +89,12 @@ sticker_convert/utils/files/metadata_handler.py,sha256=TJpQ-7KdnqQh09hwR6xB_scRL
 sticker_convert/utils/files/run_bin.py,sha256=QalA9je6liHxiOtxsjsFsIkc2t59quhcJCVpP1X3p50,1743
 sticker_convert/utils/files/sanitize_filename.py,sha256=HBklPGsHRJjFQUIC5rYTQsUrsuTtezZXIEA8CPhLP8A,2156
 sticker_convert/utils/media/apple_png_normalize.py,sha256=LbrQhc7LlYX4I9ek4XJsZE4l0MygBA1jB-PFiYLEkzk,3657
-sticker_convert/utils/media/codec_info.py,sha256=JHHlfCLSpepYFv6TSL1XqwUJoVOpOPFxurRtduplPGY,12856
+sticker_convert/utils/media/codec_info.py,sha256=yXjgGN3AwwFiwPHTlM9mqEtH3fH8VegZpKkgj3TvUNA,15611
 sticker_convert/utils/media/decrypt_kakao.py,sha256=4wq9ZDRnFkx1WmFZnyEogBofiLGsWQM_X69HlA36578,1947
 sticker_convert/utils/media/format_verify.py,sha256=Xf94jyqk_6M9IlFGMy0wYIgQKn_yg00nD4XW0CgAbew,5732
-sticker_convert-2.7.12.dist-info/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
-sticker_convert-2.7.12.dist-info/METADATA,sha256=tJ1IQvfsDyRiDDQSkHech1YhfhlB9U9HPeUEk5a15eY,49133
-sticker_convert-2.7.12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-sticker_convert-2.7.12.dist-info/entry_points.txt,sha256=MNJ7XyC--ugxi5jS1nzjDLGnxCyLuaGdsVLnJhDHCqs,66
-sticker_convert-2.7.12.dist-info/top_level.txt,sha256=r9vfnB0l1ZnH5pTH5RvkobnK3Ow9m0RsncaOMAtiAtk,16
-sticker_convert-2.7.12.dist-info/RECORD,,
+sticker_convert-2.8.0.dist-info/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+sticker_convert-2.8.0.dist-info/METADATA,sha256=M1OIHNyHntzmytdfECLmPnQ3r_veJG2y5W3JcoE845o,49132
+sticker_convert-2.8.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sticker_convert-2.8.0.dist-info/entry_points.txt,sha256=MNJ7XyC--ugxi5jS1nzjDLGnxCyLuaGdsVLnJhDHCqs,66
+sticker_convert-2.8.0.dist-info/top_level.txt,sha256=r9vfnB0l1ZnH5pTH5RvkobnK3Ow9m0RsncaOMAtiAtk,16
+sticker_convert-2.8.0.dist-info/RECORD,,