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

sticker_convert/job_option.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+from typing import Optional, Union
+
+
+def to_int(i) -> Optional[int]:
+    return int(i) if i != None else None
+
+class BaseOption:
+    def merge(self, config: "BaseOption"):
+        for k, v in vars(config).items():
+            if v != None:
+                setattr(self, k, v)
+
+class InputOption(BaseOption):
+    def __init__(self, input_config_dict: dict):
+        self.option = input_config_dict.get('option')
+        self.url = input_config_dict.get('url')
+        self.dir = input_config_dict.get('dir')
+        
+    def to_dict(self) -> dict:
+        return {
+            'option': self.option,
+            'url': self.url,
+            'dir': self.dir
+        }
+
+class CompOption(BaseOption):
+    def __init__(self, comp_config_dict: dict):
+        self.preset = comp_config_dict.get('preset')
+
+        size_max = comp_config_dict.get('size_max')
+        if isinstance(size_max, dict):
+            self.size_max_img = to_int(size_max.get('img'))
+            self.size_max_vid = to_int(size_max.get('vid'))
+        else:
+            self.size_max_img = to_int(size_max)
+            self.size_max_vid = to_int(size_max)
+        
+        fmt = comp_config_dict.get('format')
+        if isinstance(fmt, dict):
+            self.format_img = fmt.get('img')
+            self.format_vid = fmt.get('vid')
+        else:
+            self.format_img = fmt
+            self.format_vid = fmt
+        
+        fps = comp_config_dict.get('fps')
+        if isinstance(fps, dict):
+            self.fps_min = to_int(fps.get('min'))
+            self.fps_max = to_int(fps.get('max'))
+        else:
+            self.fps_min = to_int(fps)
+            self.fps_max = to_int(fps)
+        
+        self.res_w_min = None
+        self.res_w_max = None
+        self.res_h_min = None
+        self.res_h_max = None
+        if isinstance(res := comp_config_dict.get('res'), dict):
+            if res_w := res.get('w'):
+                if isinstance(res_w, dict):
+                    self.res_w_min = to_int(res_w.get('min'))
+                    self.res_w_max = to_int(res_w.get('max'))
+                else:
+                    self.res_w_min = res_w
+                    self.res_w_max = res_w
+            if res_h := res.get('h'):
+                if isinstance(res_h, dict):
+                    self.res_h_min = to_int(res_h.get('min', res_h))
+                    self.res_h_max = to_int(res_h.get('max', res_h))
+                else:
+                    self.res_h_min = res_h
+                    self.res_h_max = res_h
+            if res_min := res.get('min'):
+                if isinstance(res_min, dict):
+                    self.res_w_min = to_int(res_min.get('w', res_min))
+                    self.res_h_min = to_int(res_min.get('h', res_min))
+                else:
+                    self.res_w_min = res_min
+                    self.res_h_min = res_min
+            if res_max := res.get('max'):
+                if isinstance(res_max, dict):
+                    self.res_w_max = to_int(res_max.get('w', res_max))
+                    self.res_h_max = to_int(res_max.get('h', res_max))
+                else:
+                    self.res_w_max = res_max
+                    self.res_h_max = res_max
+        else:
+            self.res_w_min = to_int(res)
+            self.res_w_max = to_int(res)
+            self.res_h_min = to_int(res)
+            self.res_h_max = to_int(res)
+        
+        quality = comp_config_dict.get('quality')
+        if isinstance(quality, dict):
+            self.quality_min = to_int(quality.get('min'))
+            self.quality_max = to_int(quality.get('max'))
+        else:
+            self.quality_min = to_int(quality)
+            self.quality_max = to_int(quality)
+        
+        color = comp_config_dict.get('color')
+        if isinstance(color, dict):
+            self.color_min = to_int(color.get('min'))
+            self.color_max = to_int(color.get('max'))
+        else:
+            self.color_min = to_int(color)
+            self.color_max = to_int(color)
+        
+        duration = comp_config_dict.get('duration')
+        if isinstance(duration, dict):
+            self.duration_min = to_int(duration.get('min'))
+            self.duration_max = to_int(duration.get('max'))
+        else:
+            self.duration_min = to_int(duration)
+            self.duration_max = to_int(duration)
+        
+        self.steps = to_int(comp_config_dict.get('steps'))
+        self.fake_vid = comp_config_dict.get('fake_vid')
+        self.cache_dir = comp_config_dict.get('cache_dir')
+        self.default_emoji = comp_config_dict.get('default_emoji')
+        self.no_compress = comp_config_dict.get('no_compress')
+        self.processes = to_int(comp_config_dict.get('processes'))
+
+        # Only used for format verification
+        self.animated = comp_config_dict.get('animated')
+        self.square = comp_config_dict.get('square')
+
+    def to_dict(self) -> dict:
+        return {
+            'preset': self.preset,
+            'size_max': {
+                'img': self.size_max_img,
+                'vid': self.size_max_vid
+            },
+            'format': {
+                'img': self.format_img,
+                'vid': self.format_vid
+            },
+            'fps': {
+                'min': self.fps_min,
+                'max': self.fps_max
+            },
+            'res': {
+                'w': {
+                    'min': self.res_w_min,
+                    'max': self.res_w_max
+                },
+                'h': {
+                    'min': self.res_h_min,
+                    'max': self.res_h_max
+                }
+            },
+            'quality': {
+                'min': self.quality_min,
+                'max': self.quality_max
+            },
+            'color': {
+                'min': self.color_min,
+                'max': self.color_max
+            },
+            'duration': {
+                'min': self.duration_min,
+                'max': self.duration_max
+            },
+            'steps': self.steps,
+            'fake_vid': self.fake_vid,
+            'cache_dir': self.cache_dir,
+            'default_emoji': self.default_emoji,
+            'no_compress': self.no_compress,
+            'processes': self.processes,
+            'animated': self.animated,
+            'square': self.square
+        }
+        
+    @property
+    def size_max(self) -> list[Optional[int]]:
+        return [self.size_max_img, self.size_max_vid]
+    
+    @size_max.setter
+    def size_max(self, value: Optional[int]):
+        self.size_max_img, self.size_max_vid = to_int(value), to_int(value)
+        
+    @property
+    def format(self) -> list[Union[list[str], str, None]]:
+        return [self.format_img, self.format_vid]
+    
+    @format.setter
+    def format(self, value: Union[list[str], str, None]):
+        self.format_img, self.format_vid = value, value
+    
+    @property
+    def fps(self) -> list[Optional[int]]:
+        return [self.fps_min, self.fps_max]
+    
+    @fps.setter
+    def fps(self, value: Optional[int]):
+        self.fps_min, self.fps_max = to_int(value), to_int(value)
+        
+    @property
+    def res(self) -> list[Optional[list[Optional[int]]]]:
+        return [self.res_w, self.res_h]
+    
+    @res.setter
+    def res(self, value: Optional[int]):
+        self.res_w_min = to_int(value)
+        self.res_w_max = to_int(value)
+        self.res_h_min = to_int(value)
+        self.res_h_max = to_int(value)
+    
+    @property
+    def res_w(self) -> list[Optional[int]]:
+        return [self.res_w_min, self.res_w_max]
+    
+    @res_w.setter
+    def res_w(self, value: Optional[int]):
+        self.res_w_min, self.res_w_max = to_int(value), to_int(value)
+    
+    @property
+    def res_h(self) -> list[Optional[int]]:
+        return [self.res_h_min, self.res_h_max]
+    
+    @res_h.setter
+    def res_h(self, value: Optional[int]):
+        self.res_h_min, self.res_h_max = to_int(value), to_int(value)
+        
+    @property
+    def quality(self) -> list[Optional[int]]:
+        return [self.quality_min, self.quality_max]
+    
+    @quality.setter
+    def quality(self, value: Optional[int]):
+        self.quality_min, self.quality_max = to_int(value), to_int(value)
+    
+    @property
+    def color(self) -> list[Optional[int]]:
+        return [self.color_min, self.color_max]
+    
+    @color.setter
+    def color(self, value: Optional[int]):
+        self.color_min, self.color_max = to_int(value), to_int(value)
+    
+    @property
+    def duration(self) -> list[Optional[int]]:
+        return [self.duration_min, self.duration_max]
+    
+    @duration.setter
+    def duration(self, value: Optional[int]):
+        self.duration_min, self.duration_max = to_int(value), to_int(value)
+    
+
+class OutputOption(BaseOption):
+    def __init__(self, output_config_dict: dict):
+        self.option = output_config_dict.get('option')
+        self.dir = output_config_dict.get('dir')
+        self.title = output_config_dict.get('title')
+        self.author = output_config_dict.get('author')
+    
+    def to_dict(self) -> dict:
+        return {
+            'option': self.option,
+            'dir': self.dir,
+            'title': self.title,
+            'author': self.author
+        }
+    
+class CredOption(BaseOption):
+    def __init__(self, cred_config_dict: dict):
+        self.signal_uuid = cred_config_dict.get('signal', {}).get('uuid')
+        self.signal_password = cred_config_dict.get('signal', {}).get('password')
+        self.telegram_token = cred_config_dict.get('telegram', {}).get('token')
+        self.telegram_userid = cred_config_dict.get('telegram', {}).get('userid')
+        self.kakao_auth_token = cred_config_dict.get('kakao', {}).get('auth_token')
+        self.kakao_username = cred_config_dict.get('kakao', {}).get('username')
+        self.kakao_password = cred_config_dict.get('kakao', {}).get('password')
+        self.kakao_country_code = cred_config_dict.get('kakao', {}).get('country_code')
+        self.kakao_phone_number = cred_config_dict.get('kakao', {}).get('phone_number')
+        self.line_cookies = cred_config_dict.get('line', {}).get('cookies')
+
+    def to_dict(self) -> dict:
+        return {
+            'signal': {
+                'uuid': self.signal_uuid,
+                'password': self.signal_password
+            },
+            'telegram': {
+                'token': self.telegram_token,
+                'userid': self.telegram_userid
+            },
+            'kakao': {
+                'auth_token': self.kakao_auth_token,
+                'username': self.kakao_username,
+                'password': self.kakao_password,
+                'country_code': self.kakao_country_code,
+                'phone_number': self.kakao_phone_number
+            },
+            'line': {
+                'cookies': self.line_cookies
+            }
+        }

sticker_convert/resources/compression.json

@@ -44,7 +44,7 @@
             "vid": 300000
         },
         "format": {
-            "img": ".webp",
+            "img": ".png",
             "vid": ".apng"
         },
         "fps": {

sticker_convert/uploaders/compress_wastickers.py

@@ -5,98 +5,87 @@ import copy
 import zipfile
 from typing import Optional
 
-from mergedeep import merge # type: ignore
+from .upload_base import UploadBase  # type: ignore
+from ..converter import StickerConvert  # type: ignore
+from ..utils.media.format_verify import FormatVerify  # type: ignore
+from ..utils.files.metadata_handler import MetadataHandler  # type: ignore
+from ..utils.media.codec_info import CodecInfo  # type: ignore
+from ..utils.files.cache_store import CacheStore  # type: ignore
+from ..job_option import CompOption, OutputOption, CredOption # type: ignore
 
-from .upload_base import UploadBase # type: ignore
-from ..utils.converter import StickerConvert # type: ignore
-from ..utils.format_verify import FormatVerify # type: ignore
-from ..utils.metadata_handler import MetadataHandler # type: ignore
-from ..utils.codec_info import CodecInfo # type: ignore
-from ..utils.cache_store import CacheStore # type: ignore
 
 class CompressWastickers(UploadBase):
     def __init__(self, *args, **kwargs):
         super(CompressWastickers, self).__init__(*args, **kwargs)
-        base_spec = {
-            'size_max': {
-                "img": 100000,
-                "vid": 500000
-            },
-            'res': {
-                'w': {
-                    'min': 512,
-                    'max': 512
-                },
-                'h': {
-                    'min': 512,
-                    'max': 512
-                }
-            },
-            'duration': {
-                'min': 8,
-                'max': 10000
-            },
-            'format': '.webp',
-            'square': True
-        }
-
-        self.spec_cover = {
-            "size_max": {
-                "img": 50000,
-                "vid": 50000
-            },
-            "res": {
-                "w": {
-                    "min": 96,
-                    "max": 96
-                },
-                "h": {
-                    "min": 96,
-                    "max": 96
-                }
-            },
-            'format': '.png',
-            'animated': False
-        }
+        base_spec = CompOption({
+            "size_max": {"img": 100000, "vid": 500000},
+            "res": 512,
+            "duration": {"min": 8, "max": 10000},
+            "format": ".webp",
+            "square": True,
+        })
+
+        self.spec_cover = CompOption({
+            "size_max": {"img": 50000, "vid": 50000},
+            "res": 96,
+            "format": ".png",
+            "animated": False,
+        })
 
         self.webp_spec = copy.deepcopy(base_spec)
-        self.webp_spec['format'] = '.webp'
-        self.webp_spec['animated'] = None if self.fake_vid else True
+        self.webp_spec.format = ".webp"
+        self.webp_spec.animated = None if self.fake_vid else True
 
         self.png_spec = copy.deepcopy(base_spec)
-        self.png_spec['format'] = '.png'
-        self.png_spec['animated'] = False
+        self.png_spec.format = ".png"
+        self.png_spec.animated = False
 
-        self.opt_comp_merged = merge({}, self.opt_comp, base_spec)
+        self.opt_comp_merged = copy.deepcopy(self.opt_comp)
+        self.opt_comp_merged.merge(base_spec)
 
     def compress_wastickers(self) -> list[str]:
         urls = []
-        title, author, emoji_dict = MetadataHandler.get_metadata(self.in_dir, title=self.opt_output.get('title'), author=self.opt_output.get('author'))
-        packs = MetadataHandler.split_sticker_packs(self.in_dir, title=title, file_per_pack=30, separate_image_anim=not self.fake_vid)
+        title, author, emoji_dict = MetadataHandler.get_metadata(
+            self.in_dir,
+            title=self.opt_output.title,
+            author=self.opt_output.author,
+        )
+        packs = MetadataHandler.split_sticker_packs(
+            self.in_dir,
+            title=title,
+            file_per_pack=30,
+            separate_image_anim=not self.fake_vid,
+        )
 
         for pack_title, stickers in packs.items():
-            num = 0 # Originally the Sticker Maker application name the files with int(time.time())
-            with CacheStore.get_cache_store(path=self.opt_comp.get('cache_dir')) as tempdir:
+            num = 0  # Originally the Sticker Maker application name the files with int(time.time())
+            with CacheStore.get_cache_store(
+                path=self.opt_comp.cache_dir
+            ) as tempdir:
                 for src in stickers:
-                    self.cb_msg(f'Verifying {src} for compressing into .wastickers')
+                    self.cb_msg(f"Verifying {src} for compressing into .wastickers")
 
                     if self.fake_vid or CodecInfo.is_anim(src):
-                        ext = '.webp'
+                        ext = ".webp"
                     else:
-                        ext = '.png'
+                        ext = ".png"
 
                     dst = os.path.join(tempdir, str(num) + ext)
                     num += 1
 
-                    if FormatVerify.check_file(src, spec=self.webp_spec) or FormatVerify.check_file(src, spec=self.png_spec):
+                    if (FormatVerify.check_file(src, spec=self.webp_spec) or
+                        FormatVerify.check_file(src, spec=self.png_spec)):
                         shutil.copy(src, dst)
                     else:
                         StickerConvert(src, dst, self.opt_comp_merged, self.cb_msg).convert()
 
-                out_f = os.path.join(self.out_dir, FormatVerify.sanitize_filename(pack_title + '.wastickers'))
+                out_f = os.path.join(
+                    self.out_dir,
+                    FormatVerify.sanitize_filename(pack_title + ".wastickers"),
+                )
 
                 self.add_metadata(tempdir, pack_title, author)
-                with zipfile.ZipFile(out_f, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                with zipfile.ZipFile(out_f, "w", zipfile.ZIP_DEFLATED) as zipf:
                     for file in os.listdir(tempdir):
                         file_path = os.path.join(tempdir, file)
                         file_name = os.path.basename(file_path)
@@ -104,27 +93,59 @@ class CompressWastickers(UploadBase):
 
             self.cb_msg(out_f)
             urls.append(out_f)
-        
+
         return urls
 
     def add_metadata(self, pack_dir: str, title: str, author: str):
-        opt_comp_merged = merge({}, self.opt_comp, self.spec_cover)
+        opt_comp_merged = copy.deepcopy(self.opt_comp)
+        opt_comp_merged.merge(self.spec_cover)
 
         cover_path_old = MetadataHandler.get_cover(self.in_dir)
-        cover_path_new = os.path.join(pack_dir, '100.png')
+        cover_path_new = os.path.join(pack_dir, "100.png")
         if cover_path_old:
             if FormatVerify.check_file(cover_path_old, spec=self.spec_cover):
                 shutil.copy(cover_path_old, cover_path_new)
             else:
-                StickerConvert(cover_path_old, cover_path_new, opt_comp_merged, self.cb_msg).convert()
+                StickerConvert(
+                    cover_path_old, cover_path_new, opt_comp_merged, self.cb_msg
+                ).convert()
         else:
             # First image in the directory, extracting first frame
-            first_image = [i for i in sorted(os.listdir(self.in_dir)) if os.path.isfile(os.path.join(self.in_dir, i)) and not i.endswith(('.txt', '.m4a', '.wastickers'))][0]
-            StickerConvert(os.path.join(self.in_dir, f'{first_image}'), cover_path_new, opt_comp_merged, self.cb_msg).convert()
-        
+            first_image = [
+                i
+                for i in sorted(os.listdir(self.in_dir))
+                if os.path.isfile(os.path.join(self.in_dir, i))
+                and not i.endswith((".txt", ".m4a", ".wastickers"))
+            ][0]
+            StickerConvert(
+                os.path.join(self.in_dir, f"{first_image}"),
+                cover_path_new,
+                opt_comp_merged,
+                self.cb_msg,
+            ).convert()
+
         MetadataHandler.set_metadata(pack_dir, author=author, title=title)
-    
+
     @staticmethod
-    def start(opt_output: dict, opt_comp: dict, opt_cred: dict, cb_msg=print, cb_msg_block=input, cb_ask_bool=input, cb_bar=None, out_dir: Optional[str] = None, **kwargs) -> list[str]:
-        exporter = CompressWastickers(opt_output, opt_comp, opt_cred, cb_msg, cb_msg_block, cb_ask_bool, cb_bar, out_dir)
-        return exporter.compress_wastickers()
+    def start(
+        opt_output: OutputOption,
+        opt_comp: CompOption,
+        opt_cred: CredOption,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_ask_bool=input,
+        cb_bar=None,
+        out_dir: Optional[str] = None,
+        **kwargs,
+    ) -> list[str]:
+        exporter = CompressWastickers(
+            opt_output,
+            opt_comp,
+            opt_cred,
+            cb_msg,
+            cb_msg_block,
+            cb_ask_bool,
+            cb_bar,
+            out_dir,
+        )
+        return exporter.compress_wastickers()

sticker_convert/uploaders/upload_base.py

@@ -1,8 +1,20 @@
 #!/usr/bin/env python3
 from typing import Optional
+from ..job_option import CompOption, OutputOption, CredOption # type: ignore
+
 
 class UploadBase:
-    def __init__(self, opt_output: dict, opt_comp: dict, opt_cred: dict, cb_msg=print, cb_msg_block=input, cb_ask_bool=input, cb_bar=None, out_dir: Optional[str] = None):
+    def __init__(
+        self,
+        opt_output: OutputOption,
+        opt_comp: CompOption,
+        opt_cred: CredOption,
+        cb_msg=print,
+        cb_msg_block=input,
+        cb_ask_bool=input,
+        cb_bar=None,
+        out_dir: Optional[str] = None,
+    ):
         self.opt_output = opt_output
         self.opt_comp = opt_comp
         self.opt_cred = opt_cred
@@ -11,6 +23,6 @@ class UploadBase:
         self.cb_ask_bool = cb_ask_bool
         self.cb_bar = cb_bar
 
-        self.fake_vid = self.opt_comp.get('fake_vid', False)
-        self.in_dir = self.opt_output['dir']
-        self.out_dir = out_dir if out_dir else self.opt_output['dir']
+        self.fake_vid = self.opt_comp.fake_vid
+        self.in_dir = self.opt_output.dir
+        self.out_dir = out_dir if out_dir else self.opt_output.dir