sticker-convert 2.1.5__py3-none-any.whl → 2.1.7__py3-none-any.whl

sticker_convert/utils/files/metadata_handler.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+import os
+import json
+from typing import Optional
+
+from ..media.codec_info import CodecInfo  # type: ignore
+from .json_manager import JsonManager  # type: ignore
+
+
+class MetadataHandler:
+    @staticmethod
+    def get_stickers_present(dir: str) -> list[str]:
+        from ...uploaders.xcode_imessage import XcodeImessageIconset  # type: ignore
+
+        blacklist_prefix = ('cover',)
+        blacklist_suffix = (".txt", ".m4a", ".wastickers", ".DS_Store", "._.DS_Store")
+        xcode_iconset = XcodeImessageIconset().iconset
+        
+        stickers_present = [
+            i
+            for i in sorted(os.listdir(dir))
+            if os.path.isfile(os.path.join(dir, i)) and
+            not i.startswith(blacklist_prefix) and
+            not i.endswith(blacklist_suffix) and
+            not i in xcode_iconset
+        ]
+
+        return stickers_present
+
+    @staticmethod
+    def get_cover(dir: str) -> Optional[str]:
+        stickers_present = sorted(os.listdir(dir))
+        for i in stickers_present:
+            if os.path.splitext(i)[0] == "cover":
+                return os.path.join(dir, i)
+
+        return None
+
+    @staticmethod
+    def get_metadata(
+        dir: str,
+        title: Optional[str] = None,
+        author: Optional[str] = None,
+        emoji_dict: Optional[dict[str, str]] = None,
+    ) -> tuple[Optional[str], Optional[str], Optional[dict[str, str]]]:
+        title_path = os.path.join(dir, "title.txt")
+        if not title and os.path.isfile(title_path):
+            with open(title_path, encoding="utf-8") as f:
+                title = f.read().strip()
+
+        author_path = os.path.join(dir, "author.txt")
+        if not author and os.path.isfile(author_path):
+            with open(author_path, encoding="utf-8") as f:
+                author = f.read().strip()
+
+        emoji_path = os.path.join(dir, "emoji.txt")
+        if not emoji_dict and os.path.isfile(emoji_path):
+            with open(emoji_path, "r", encoding="utf-8") as f:
+                emoji_dict = json.load(f)
+
+        return title, author, emoji_dict
+
+    @staticmethod
+    def set_metadata(
+        dir: str,
+        title: Optional[str] = None,
+        author: Optional[str] = None,
+        emoji_dict: Optional[dict[str, str]] = None,
+    ):
+        title_path = os.path.join(dir, "title.txt")
+        if title != None:
+            with open(title_path, "w+", encoding="utf-8") as f:
+                f.write(title)  # type: ignore[arg-type]
+
+        author_path = os.path.join(dir, "author.txt")
+        if author != None:
+            with open(author_path, "w+", encoding="utf-8") as f:
+                f.write(author)  # type: ignore[arg-type]
+
+        emoji_path = os.path.join(dir, "emoji.txt")
+        if emoji_dict != None:
+            with open(emoji_path, "w+", encoding="utf-8") as f:
+                json.dump(emoji_dict, f, indent=4, ensure_ascii=False)
+
+    @staticmethod
+    def check_metadata_provided(
+        input_dir: str, input_option: str, metadata: str
+    ) -> bool:
+        """
+        Check if metadata provided via .txt file (if from local)
+        or will be provided by input source (if not from local)
+        Does not check if metadata provided via user input in GUI or flag options
+        metadata = 'title' or 'author'
+        """
+        input_presets = JsonManager.load_json("resources/input.json")
+
+        if input_option == "local":
+            metadata_file_path = os.path.join(input_dir, f"{metadata}.txt")
+            metadata_provided = os.path.isfile(metadata_file_path)
+            if metadata_provided:
+                with open(metadata_file_path, encoding="utf-8") as f:
+                    metadata_provided = True if f.read() else False
+        else:
+            metadata_provided = input_presets[input_option]["metadata_provides"][
+                metadata
+            ]
+
+        return metadata_provided
+
+    @staticmethod
+    def check_metadata_required(output_option: str, metadata: str) -> bool:
+        # metadata = 'title' or 'author'
+        output_presets = JsonManager.load_json("resources/output.json")
+        return output_presets[output_option]["metadata_requirements"][metadata]
+
+    @staticmethod
+    def generate_emoji_file(dir: str, default_emoji: str = ""):
+        emoji_path = os.path.join(dir, "emoji.txt")
+        emoji_dict = None
+        if os.path.isfile(emoji_path):
+            with open(emoji_path, "r", encoding="utf-8") as f:
+                emoji_dict = json.load(f)
+
+        emoji_dict_new = {}
+        for file in sorted(os.listdir(dir)):
+            if not os.path.isfile(os.path.join(dir, file)) and CodecInfo.get_file_ext(
+                file
+            ) in (".txt", ".m4a"):
+                continue
+            file_name = os.path.splitext(file)[0]
+            if emoji_dict and file_name in emoji_dict:
+                emoji_dict_new[file_name] = emoji_dict[file_name]
+            else:
+                emoji_dict_new[file_name] = default_emoji
+
+        with open(emoji_path, "w+", encoding="utf-8") as f:
+            json.dump(emoji_dict_new, f, indent=4, ensure_ascii=False)
+
+    @staticmethod
+    def split_sticker_packs(
+        dir: str,
+        title: str,
+        file_per_pack: Optional[int] = None,
+        file_per_anim_pack: Optional[int] = None,
+        file_per_image_pack: Optional[int] = None,
+        separate_image_anim: bool = True,
+    ) -> dict:
+        # {pack_1: [sticker1_path, sticker2_path]}
+        packs = {}
+
+        if file_per_pack == None:
+            file_per_pack = (
+                file_per_anim_pack
+                if file_per_anim_pack != None
+                else file_per_image_pack
+            )
+        else:
+            file_per_anim_pack = file_per_pack
+            file_per_image_pack = file_per_pack
+
+        stickers_present = MetadataHandler.get_stickers_present(dir)
+
+        processed = 0
+
+        if separate_image_anim == True:
+            image_stickers = []
+            anim_stickers = []
+
+            image_pack_count = 0
+            anim_pack_count = 0
+
+            anim_present = False
+            image_present = False
+
+            for processed, file in enumerate(stickers_present):
+                file_path = os.path.join(dir, file)
+
+                if CodecInfo.is_anim(file_path):
+                    anim_stickers.append(file_path)
+                else:
+                    image_stickers.append(file_path)
+
+                anim_present = anim_present or len(anim_stickers) > 0
+                image_present = image_present or len(image_stickers) > 0
+
+                finished_all = True if processed == len(stickers_present) else False
+
+                if len(anim_stickers) == file_per_anim_pack or (
+                    finished_all and len(anim_stickers) > 0
+                ):
+                    suffix = f'{"-anim" if image_present else ""}{"-" + str(anim_pack_count) if anim_pack_count > 0 else ""}'
+                    title_current = str(title) + suffix
+                    packs[title_current] = anim_stickers.copy()
+                    anim_stickers = []
+                    anim_pack_count += 1
+                if len(image_stickers) == file_per_image_pack or (
+                    finished_all and len(image_stickers) > 0
+                ):
+                    suffix = f'{"-image" if anim_present else ""}{"-" + str(image_pack_count) if image_pack_count > 0 else ""}'
+                    title_current = str(title) + suffix
+                    packs[title_current] = image_stickers.copy()
+                    image_stickers = []
+                    image_pack_count += 1
+
+        else:
+            stickers = []
+            pack_count = 0
+
+            for processed, file in enumerate(stickers_present):
+                file_path = os.path.join(dir, file)
+
+                stickers.append(file_path)
+
+                finished_all = True if processed == len(stickers_present) else False
+
+                if len(stickers) == file_per_pack or (
+                    finished_all and len(stickers) > 0
+                ):
+                    suffix = f'{"-" + str(pack_count) if pack_count > 0 else ""}'
+                    title_current = str(title) + suffix
+                    packs[title_current] = stickers.copy()
+                    stickers = []
+                    pack_count += 1
+
+        return packs

sticker_convert/utils/files/run_bin.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import subprocess
+import os
+import shutil
+import platform
+from typing import Union, AnyStr
+
+
+class RunBin:
+    @staticmethod
+    def get_bin(
+        bin: str, silent: bool = False, cb_msg=print
+    ) -> Union[str, AnyStr, None]:
+        if os.path.isfile(bin):
+            return bin
+
+        if platform.system() == "Windows":
+            bin = bin + ".exe"
+
+        which_result = shutil.which(bin)
+        if which_result != None:
+            return os.path.abspath(which_result)  # type: ignore[type-var]
+        elif silent == False:
+            cb_msg(f"Warning: Cannot find binary file {bin}")
+
+        return None
+
+    @staticmethod
+    def run_cmd(
+        cmd_list: list[str], silence: bool = False, cb_msg=print
+    ) -> Union[bool, str]:
+        bin_path = RunBin.get_bin(cmd_list[0])  # type: ignore[assignment]
+
+        if bin_path:
+            cmd_list[0] = bin_path
+        else:
+            if silence == False:
+                cb_msg(
+                    f"Error while executing {' '.join(cmd_list)} : Command not found"
+                )
+            return False
+
+        # sp = subprocess.Popen(cmd_list, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+        sp = subprocess.run(
+            cmd_list,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        output_str = sp.stdout.decode()
+        error_str = sp.stderr.decode()
+
+        if silence == False and error_str != "":
+            cb_msg(f"Error while executing {' '.join(cmd_list)} : {error_str}")
+            return False
+
+        return output_str

sticker_convert/utils/{apple_png_normalize.py → media/apple_png_normalize.py}

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
-'''
+"""
 Required for pack_id < 775 (https://github.com/star-39/moe-sticker-bot/blob/ef2f06f3eb7a833e011e0a5201e007fc130978e7/pkg/msbimport/import_line.go#L68)
 Reference: https://stackoverflow.com/a/53622211
-'''
+"""
 import struct
 import zlib
 
+
 class ApplePngNormalize:
     @staticmethod
     def normalize(old_png: bytes) -> bytes:
@@ -23,15 +24,14 @@ class ApplePngNormalize:
 
         # For each chunk in the PNG file
         while chunk_pos < len(old_png):
-
             # Reading chunk
-            chunk_length = old_png[chunk_pos:chunk_pos+4]
+            chunk_length = old_png[chunk_pos : chunk_pos + 4]
             chunk_length = struct.unpack(">L", chunk_length)[0]
-            chunk_type = old_png[chunk_pos+4 : chunk_pos+8]
-            chunk_data = old_png[chunk_pos+8:chunk_pos+8+chunk_length] # type: ignore[operator]
-            chunk_crc = old_png[chunk_pos+chunk_length+8:chunk_pos+chunk_length+12] # type: ignore[operator]
+            chunk_type = old_png[chunk_pos + 4 : chunk_pos + 8]
+            chunk_data = old_png[chunk_pos + 8 : chunk_pos + 8 + chunk_length]  # type: ignore[operator]
+            chunk_crc = old_png[chunk_pos + chunk_length + 8 : chunk_pos + chunk_length + 12]  # type: ignore[operator]
             chunk_crc = struct.unpack(">L", chunk_crc)[0]
-            chunk_pos += chunk_length + 12 # type: ignore[operator]
+            chunk_pos += chunk_length + 12  # type: ignore[operator]
 
             # Parsing the header chunk
             if chunk_type == b"IHDR":
@@ -57,25 +57,28 @@ class ApplePngNormalize:
                 offset = 1
                 for y in range(height):
                     for x in range(width):
-                        chunk_data[offset+4*x],chunk_data[offset+4*x+2] = chunk_data[offset+4*x+2],chunk_data[offset+4*x]
-                    offset += 1+4*width
+                        chunk_data[offset + 4 * x], chunk_data[offset + 4 * x + 2] = (
+                            chunk_data[offset + 4 * x + 2],
+                            chunk_data[offset + 4 * x],
+                        )
+                    offset += 1 + 4 * width
 
                 # Compressing the image chunk
-                #chunk_data = newdata
+                # chunk_data = newdata
                 chunk_data = zlib.compress(chunk_data)
-                chunk_length = len(chunk_data) # type: ignore[assignment]
-                chunk_crc = zlib.crc32(b'IDAT') # type: ignore[assignment]
-                chunk_crc = zlib.crc32(chunk_data, chunk_crc) # type: ignore[assignment, arg-type]
-                chunk_crc = (chunk_crc + 0x100000000) % 0x100000000 # type: ignore[operator]
+                chunk_length = len(chunk_data)  # type: ignore[assignment]
+                chunk_crc = zlib.crc32(b"IDAT")  # type: ignore[assignment]
+                chunk_crc = zlib.crc32(chunk_data, chunk_crc)  # type: ignore[assignment, arg-type]
+                chunk_crc = (chunk_crc + 0x100000000) % 0x100000000  # type: ignore[operator]
 
                 new_png += struct.pack(">L", chunk_length)
-                new_png += b'IDAT'
+                new_png += b"IDAT"
                 new_png += chunk_data
                 new_png += struct.pack(">L", chunk_crc)
 
-                chunk_crc = zlib.crc32(chunk_type) # type: ignore[assignment]
+                chunk_crc = zlib.crc32(chunk_type)  # type: ignore[assignment]
                 new_png += struct.pack(">L", 0)
-                new_png += b'IEND'
+                new_png += b"IEND"
                 new_png += struct.pack(">L", chunk_crc)
                 break
 
@@ -85,8 +88,8 @@ class ApplePngNormalize:
             else:
                 new_png += struct.pack(">L", chunk_length)
                 new_png += chunk_type
-                if chunk_length > 0: # type: ignore[operator]
+                if chunk_length > 0:  # type: ignore[operator]
                     new_png += chunk_data
                 new_png += struct.pack(">L", chunk_crc)
 
-        return new_png
+        return new_png

sticker_convert/utils/{codec_info.py → media/codec_info.py}

@@ -1,103 +1,109 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 import os
 import mimetypes
 from typing import Optional
 
 import imageio.v3 as iio
-from rlottie_python import LottieAnimation # type: ignore
+from rlottie_python import LottieAnimation  # type: ignore
 from PIL import Image
 import mmap
 
+
 class CodecInfo:
     def __init__(self):
         mimetypes.init()
         vid_ext = []
         for ext in mimetypes.types_map:
-            if mimetypes.types_map[ext].split('/')[0] == 'video':
+            if mimetypes.types_map[ext].split("/")[0] == "video":
                 vid_ext.append(ext)
-        vid_ext.append('.webm')
-        vid_ext.append('.webp')
+        vid_ext.append(".webm")
+        vid_ext.append(".webp")
         self.vid_ext = tuple(vid_ext)
 
     @staticmethod
     def get_file_fps(file: str) -> float:
         file_ext = CodecInfo.get_file_ext(file)
 
-        if file_ext in '.tgs':
+        if file_ext in ".tgs":
             with LottieAnimation.from_tgs(file) as anim:
                 fps = anim.lottie_animation_get_framerate()
         else:
-            if file_ext == '.webp':
-                with open(file, 'r+b') as f:
+            if file_ext == ".webp":
+                with open(file, "r+b") as f:
                     mm = mmap.mmap(f.fileno(), 0)
-                    anmf_pos = mm.find(b'ANMF')
+                    anmf_pos = mm.find(b"ANMF")
                     if anmf_pos == -1:
                         return 1
-                    mm.seek(anmf_pos+20)
+                    mm.seek(anmf_pos + 20)
                     frame_duration_32 = mm.read(4)
-                    frame_duration = frame_duration_32[:-1] + bytes(int(frame_duration_32[-1]) & 0b11111100)
-                    fps = 1000 / int.from_bytes(frame_duration, 'little')
-            elif file_ext in ('.gif', '.apng', '.png'):
-                metadata = iio.immeta(file, index=0, plugin='pillow', exclude_applied=False)
-                fps = int(1000 / metadata.get('duration', 1000))
+                    frame_duration = frame_duration_32[:-1] + bytes(
+                        int(frame_duration_32[-1]) & 0b11111100
+                    )
+                    fps = 1000 / int.from_bytes(frame_duration, "little")
+            elif file_ext in (".gif", ".apng", ".png"):
+                metadata = iio.immeta(
+                    file, index=0, plugin="pillow", exclude_applied=False
+                )
+                fps = int(1000 / metadata.get("duration", 1000))
             else:
-                metadata = iio.immeta(file, plugin='pyav', exclude_applied=False)
-                fps = metadata.get('fps', 1)
+                metadata = iio.immeta(file, plugin="pyav", exclude_applied=False)
+                fps = metadata.get("fps", 1)
 
         return fps
-    
+
     @staticmethod
     def get_file_codec(file: str) -> Optional[str]:
         file_ext = CodecInfo.get_file_ext(file)
 
-        if file_ext == '.webp':
-            plugin = 'pillow'
+        if file_ext == ".webp":
+            plugin = "pillow"
         else:
-            plugin = 'pyav'
+            plugin = "pyav"
         metadata = iio.immeta(file, plugin=plugin, exclude_applied=False)
-        codec = metadata.get('codec', None)
+        codec = metadata.get("codec", None)
 
         return codec
-    
+
     @staticmethod
     def get_file_res(file: str) -> tuple[int, int]:
         file_ext = CodecInfo.get_file_ext(file)
 
-        if file_ext == '.tgs':
+        if file_ext == ".tgs":
             with LottieAnimation.from_tgs(file) as anim:
                 width, height = anim.lottie_animation_get_size()
         else:
-            if file_ext == '.webp':
-                plugin = 'pillow'
+            if file_ext == ".webp":
+                plugin = "pillow"
             else:
-                plugin = 'pyav'
+                plugin = "pyav"
             frame = iio.imread(file, plugin=plugin, index=0)
             width, height, _ = frame.shape
-        
+
         return width, height
-    
+
     @staticmethod
     def get_file_frames(file: str) -> int:
         file_ext = CodecInfo.get_file_ext(file)
 
         frames = None
 
-        if file_ext == '.tgs':
+        if file_ext == ".tgs":
             with LottieAnimation.from_tgs(file) as anim:
                 frames = anim.lottie_animation_get_totalframe()
         else:
-            if file_ext == '.webp':
+            if file_ext == ".webp":
                 frames = Image.open(file).n_frames
             else:
-                frames = len(iio.imread(file, plugin='pyav'))
-        
+                frames = len(iio.imread(file, plugin="pyav"))
+
         return frames
-    
+
     @staticmethod
     def get_file_duration(file: str) -> float:
         # Return duration in miliseconds
         return CodecInfo.get_file_frames(file) / CodecInfo.get_file_fps(file) * 1000
-    
+
     @staticmethod
     def get_file_ext(file: str) -> str:
         return os.path.splitext(file)[-1].lower()
@@ -107,4 +113,4 @@ class CodecInfo:
         if CodecInfo.get_file_frames(file) > 1:
             return True
         else:
-            return False
+            return False

sticker_convert/utils/media/decrypt_kakao.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+"""
+References:
+https://github.com/blluv/KakaoTalkEmoticonDownloader
+https://github.com/star-39/moe-sticker-bot
+"""
+
+class DecryptKakao:
+    @staticmethod
+    def generate_lfsr(key: str) -> list[int]:
+        d = list(key * 2)
+        seq = [0, 0, 0]
+
+        seq[0] = 301989938
+        seq[1] = 623357073
+        seq[2] = -2004086252
+
+        i = 0
+
+        for i in range(0, 4):
+            seq[0] = ord(d[i]) | (seq[0] << 8)
+            seq[1] = ord(d[4 + i]) | (seq[1] << 8)
+            seq[2] = ord(d[8 + i]) | (seq[2] << 8)
+
+        seq[0] = seq[0] & 0xFFFFFFFF
+        seq[1] = seq[1] & 0xFFFFFFFF
+        seq[2] = seq[2] & 0xFFFFFFFF
+
+        return seq
+
+    @staticmethod
+    def xor_byte(b: int, seq: list) -> int:
+        flag1 = 1
+        flag2 = 0
+        result = 0
+        for _ in range(0, 8):
+            v10 = seq[0] >> 1
+            if (seq[0] << 31) & 0xFFFFFFFF:
+                seq[0] = v10 ^ 0xC0000031
+                v12 = seq[1] >> 1
+                if (seq[1] << 31) & 0xFFFFFFFF:
+                    seq[1] = (v12 | 0xC0000000) ^ 0x20000010
+                    flag1 = 1
+                else:
+                    seq[1] = v12 & 0x3FFFFFFF
+                    flag1 = 0
+            else:
+                seq[0] = v10
+                v11 = seq[2] >> 1
+                if (seq[2] << 31) & 0xFFFFFFFF:
+                    seq[2] = (v11 | 0xF0000000) ^ 0x8000001
+                    flag2 = 1
+                else:
+                    seq[2] = v11 & 0xFFFFFFF
+                    flag2 = 0
+
+            result = flag1 ^ flag2 | 2 * result
+        return result ^ b
+
+    @staticmethod
+    def xor_data(data: bytes) -> bytes:
+        dat = list(data)
+        s = DecryptKakao.generate_lfsr("a271730728cbe141e47fd9d677e9006d")
+        for i in range(0, 128):
+            dat[i] = DecryptKakao.xor_byte(dat[i], s)
+        return bytes(dat)
+