sticker-convert 2.8.12__py3-none-any.whl → 2.17.0.0__py3-none-any.whl

sticker_convert/job.py

@@ -8,12 +8,16 @@ from datetime import datetime
 from multiprocessing import Manager, Process, Value
 from pathlib import Path
 from threading import Thread
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union, cast
 from urllib.parse import urlparse
 
 from sticker_convert.converter import StickerConvert
+from sticker_convert.definitions import RUNTIME_STATE
+from sticker_convert.downloaders.download_band import DownloadBand
+from sticker_convert.downloaders.download_discord import DownloadDiscord
 from sticker_convert.downloaders.download_kakao import DownloadKakao
 from sticker_convert.downloaders.download_line import DownloadLine
+from sticker_convert.downloaders.download_ogq import DownloadOgq
 from sticker_convert.downloaders.download_signal import DownloadSignal
 from sticker_convert.downloaders.download_telegram import DownloadTelegram
 from sticker_convert.downloaders.download_viber import DownloadViber
@@ -21,27 +25,27 @@ from sticker_convert.job_option import CompOption, CredOption, InputOption, Outp
 from sticker_convert.uploaders.compress_wastickers import CompressWastickers
 from sticker_convert.uploaders.upload_signal import UploadSignal
 from sticker_convert.uploaders.upload_telegram import UploadTelegram
+from sticker_convert.uploaders.upload_viber import UploadViber
 from sticker_convert.uploaders.xcode_imessage import XcodeImessage
 from sticker_convert.utils.callback import CallbackReturn, CbQueueType, ResultsListType, WorkQueueType
-from sticker_convert.utils.files.json_resources_loader import OUTPUT_JSON
+from sticker_convert.utils.chrome_remotedebug import CRD
+from sticker_convert.utils.files.json_resources_loader import load_resource_json
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.media.codec_info import CodecInfo
+from sticker_convert.utils.translate import I
+
+if TYPE_CHECKING:
+    from sticker_convert.utils.callback import CallbackCli, CallbackGui
 
 
 class Executor:
-    def __init__(
-        self,
-        cb_msg: Callable[..., None],
-        cb_msg_block: Callable[..., None],
-        cb_bar: Callable[..., None],
-        cb_ask_bool: Callable[..., bool],
-        cb_ask_str: Callable[..., str],
-    ) -> None:
-        self.cb_msg = cb_msg
-        self.cb_msg_block = cb_msg_block
-        self.cb_bar = cb_bar
-        self.cb_ask_bool = cb_ask_bool
-        self.cb_ask_str = cb_ask_str
+    def __init__(self, cb: Union[CallbackGui, CallbackCli]) -> None:
+        self.cb_msg = cb.cb_msg
+        self.cb_msg_block = cb.cb_msg_block
+        self.cb_msg_dynamic = cb.cb_msg_dynamic
+        self.cb_bar = cb.cb_bar
+        self.cb_ask_bool = cb.cb_ask_bool
+        self.cb_ask_str = cb.cb_ask_str
 
         self.manager = Manager()
         self.work_queue: WorkQueueType = self.manager.Queue()
@@ -85,7 +89,7 @@ class Executor:
     def cb(
         self,
         action: Optional[str],
-        args: Optional[Tuple[str, ...]] = None,
+        args: Optional[Tuple[Any, ...]] = None,
         kwargs: Optional[Dict[str, Any]] = None,
     ) -> None:
         if args is None:
@@ -100,6 +104,8 @@ class Executor:
             self.cb_bar(update_bar=1)
         elif action == "msg_block":
             self.cb_return.set_response(self.cb_msg_block(*args, **kwargs))
+        elif action == "msg_dynamic":
+            self.cb_msg_dynamic(*args, **kwargs)
         elif action == "ask_bool":
             self.cb_return.set_response(self.cb_ask_bool(*args, **kwargs))
         elif action == "ask_str":
@@ -125,15 +131,24 @@ class Executor:
                         arg_dump.append("CredOption(REDACTED)")
                     else:
                         arg_dump.append(i)
-                e = "##### EXCEPTION #####\n"
-                e += "Function: " + repr(work_func) + "\n"
-                e += "Arguments: " + repr(arg_dump) + "\n"
-                e += traceback.format_exc()
-                e += "#####################"
+                e = I(
+                    "##### EXCEPTION #####\n"
+                    "Function: {function}\n"
+                    "Arguments: {args}\n"
+                    "{tb}\n"
+                    "#####################"
+                ).format(
+                    function=repr(work_func),
+                    args=repr(arg_dump),
+                    tb=traceback.format_exc(),
+                )
                 cb_queue.put(e)
 
         work_queue.put(None)
         cb_queue.put("__PROCESS_DONE__")
+        crd = cast(CRD, RUNTIME_STATE.get("crd"))
+        if crd:
+            crd.close()
 
     def start_workers(self, processes: int = 1) -> None:
         self.cb_thread_instance = Thread(
@@ -170,6 +185,12 @@ class Executor:
         try:
             for process in self.processes:
                 process.join()
+                if process.exitcode != 0 and self.is_cancel_job.value == 0:
+                    self.cb_msg(
+                        I("Warning: A process exited with error (code {})").format(
+                            process.exitcode
+                        )
+                    )
         except KeyboardInterrupt:
             pass
 
@@ -198,32 +219,16 @@ class Job:
         opt_comp: CompOption,
         opt_output: OutputOption,
         opt_cred: CredOption,
-        cb_msg: Callable[..., None],
-        cb_msg_block: Callable[..., None],
-        cb_bar: Callable[..., None],
-        cb_ask_bool: Callable[..., bool],
-        cb_ask_str: Callable[..., str],
+        cb: Union[CallbackCli, CallbackGui],
     ) -> None:
         self.opt_input = opt_input
         self.opt_comp = opt_comp
         self.opt_output = opt_output
         self.opt_cred = opt_cred
-        self.cb_msg = cb_msg
-        self.cb_msg_block = cb_msg_block
-        self.cb_bar = cb_bar
-        self.cb_ask_bool = cb_ask_bool
-        self.cb_ask_str = cb_ask_str
 
-        self.compress_fails: List[str] = []
         self.out_urls: List[str] = []
 
-        self.executor = Executor(
-            self.cb_msg,
-            self.cb_msg_block,
-            self.cb_bar,
-            self.cb_ask_bool,
-            self.cb_ask_str,
-        )
+        self.executor = Executor(cb)
 
     def start(self) -> int:
         if Path(self.opt_input.dir).is_dir() is False:
@@ -234,28 +239,44 @@ class Job:
 
         self.executor.cb("msg", kwargs={"cls": True})
 
-        tasks = (
+        tasks: Tuple[Callable[..., Tuple[bool, Optional[str]]], ...] = (
             self.verify_input,
             self.cleanup,
             self.download,
             self.compress,
             self.export,
-            self.report,
         )
 
         code = 0
+        summaries: List[str] = []
         for task in tasks:
             self.executor.cb("bar", kwargs={"set_progress_mode": "indeterminate"})
-            success = task()
+            success, summary = task()
+            if summary is not None:
+                summaries.append(summary)
 
             if self.executor.is_cancel_job.value == 1:  # type: ignore
                 code = 2
                 break
             if not success:
                 code = 1
-                self.executor.cb("An error occured during this run.")
+                self.executor.cb(I("An error occured during this run."))
                 break
 
+        msg = I("##########\nSummary:\n##########\n")
+
+        msg += "\n"
+        msg += "\n".join(summaries)
+        msg += "\n"
+
+        if self.out_urls:
+            msg += I("Export results:\n")
+            msg += "\n".join(self.out_urls)
+        else:
+            msg += I("Export result: None")
+
+        self.executor.cb(msg)
+
         self.executor.cleanup()
 
         return code
@@ -263,49 +284,63 @@ class Job:
     def cancel(self, *_: Any, **_kwargs: Any) -> None:
         self.executor.kill_workers()
 
-    def verify_input(self) -> bool:
+    def verify_input(self) -> Tuple[bool, None]:
         info_msg = ""
         error_msg = ""
 
-        save_to_local_tip = ""
-        save_to_local_tip += "    If you want to upload the results by yourself,\n"
-        save_to_local_tip += '    select "Save to local directory only" for output\n'
+        save_to_local_tip = I(
+            "\n"
+            "    If you want to upload the results by yourself,\n"
+            '    select "Save to local directory only" for output\n'
+        )
 
         if Path(self.opt_input.dir).resolve() == Path(self.opt_output.dir).resolve():
-            error_msg += "\n"
-            error_msg += "[X] Input and output directories cannot be the same\n"
+            error_msg += I("\n[X] Input and output directories cannot be the same\n")
 
         if self.opt_input.option == "auto":
-            error_msg += "\n"
-            error_msg += "[X] Unrecognized URL input source\n"
+            error_msg += I("\n[X] Unrecognized URL input source\n")
 
         if self.opt_input.option != "local" and not self.opt_input.url:
-            error_msg += "\n"
-            error_msg += "[X] URL address cannot be empty.\n"
-            error_msg += "    If you only want to use local files,\n"
-            error_msg += '    choose "Save to local directory only"\n'
-            error_msg += '    in "Input source"\n'
+            error_msg += I(
+                "\n"
+                "[X] URL address cannot be empty.\n"
+                "    If you only want to use local files,\n"
+                '    choose "Save to local directory only"\n'
+                '    in "Input source"\n'
+            )
 
         if (
             self.opt_input.option == "telegram" or self.opt_output.option == "telegram"
         ) and not self.opt_cred.telegram_token:
-            error_msg += (
+            error_msg += I(
                 "[X] Downloading from and uploading to telegram requires bot token.\n"
             )
             error_msg += save_to_local_tip
 
+        if (
+            self.opt_input.option.startswith("discord")
+            and not self.opt_cred.discord_token
+        ):
+            error_msg += I("[X] Downloading from Discord requires token.\n")
+
         if self.opt_output.option == "telegram" and not self.opt_cred.telegram_userid:
-            error_msg += "[X] Uploading to telegram requires user_id \n"
-            error_msg += "    (From real account, not bot account).\n"
+            error_msg += I(
+                "[X] Uploading to telegram requires user_id \n"
+                "    (From real account, not bot account).\n"
+            )
             error_msg += save_to_local_tip
 
         if self.opt_output.option == "signal" and not (
             self.opt_cred.signal_uuid and self.opt_cred.signal_password
         ):
-            error_msg += "[X] Uploading to signal requires uuid and password.\n"
+            error_msg += I("[X] Uploading to signal requires uuid and password.\n")
+            error_msg += save_to_local_tip
+
+        if self.opt_output.option == "viber" and not self.opt_cred.viber_auth:
+            error_msg += I("[X] Uploading to Viber requires auth data.\n")
             error_msg += save_to_local_tip
 
-        output_presets = OUTPUT_JSON
+        output_presets = load_resource_json("output")
 
         input_option = self.opt_input.option
         output_option = self.opt_output.option
@@ -317,30 +352,44 @@ class Job:
                 if not MetadataHandler.check_metadata_provided(
                     self.opt_input.dir, input_option, metadata
                 ):
-                    error_msg += f'[X] {output_presets[output_option]["full_name"]} requires {metadata}\n'
+                    error_msg += I("[X] {output_option} requires {metadata}\n").format(
+                        output_option=output_presets[output_option]["full_name"],
+                        metadata=metadata,
+                    )
                     if self.opt_input.option == "local":
-                        error_msg += f"    {metadata} was not supplied and {metadata}.txt is absent\n"
+                        error_msg += I(
+                            "    {metadata} was not supplied and {metadata}.txt is absent\n"
+                        ).format(metadata=metadata)
                     else:
-                        error_msg += f"    {metadata} was not supplied and input source will not provide {metadata}\n"
-                    error_msg += (
-                        f"    Supply the {metadata} by filling in the option, or\n"
-                    )
-                    error_msg += f"    Create {metadata}.txt with the {metadata} name\n"
+                        error_msg += I(
+                            "    {metadata} was not supplied and input source will not provide {metadata}\n"
+                        ).format(metadata=metadata)
+                    error_msg += I(
+                        "    Supply the {metadata} by filling in the option, or\n"
+                        "    Create {metadata}.txt with the {metadata} name\n"
+                    ).format(metadata=metadata)
                 else:
-                    info_msg += f'[!] {output_presets[output_option]["full_name"]} requires {metadata}\n'
+                    info_msg += I("[!] {output_option} requires {metadata}\n").format(
+                        output_option=output_presets[output_option]["full_name"],
+                        metadata=metadata,
+                    )
                     if self.opt_input.option == "local":
-                        info_msg += f"    {metadata} was not supplied but {metadata}.txt is present\n"
-                        info_msg += f"    Using {metadata} name in {metadata}.txt\n"
+                        info_msg += I(
+                            "    {metadata} was not supplied but {metadata}.txt is present\n"
+                            "    Using {metadata} name in {metadata}.txt\n"
+                        ).format(metadata=metadata)
                     else:
-                        info_msg += f"    {metadata} was not supplied but input source will provide {metadata}\n"
-                        info_msg += f"    Using {metadata} provided by input source\n"
+                        info_msg += I(
+                            f"    {metadata} was not supplied but input source will provide {metadata}\n"
+                            f"    Using {metadata} provided by input source\n"
+                        ).format(metadata=metadata)
 
         if info_msg != "":
             self.executor.cb(info_msg)
 
         if error_msg != "":
             self.executor.cb(error_msg)
-            return False
+            return False, None
 
         # Check if preset not equal to export option
         # Only warn if the compression option is available in export preset
@@ -350,17 +399,22 @@ class Job:
             not self.opt_comp.no_compress
             and self.opt_output.option != "local"
             and self.opt_comp.preset != "custom"
-            and self.opt_output.option not in self.opt_comp.preset
+            and (
+                self.opt_output.option not in self.opt_comp.preset
+                and self.opt_comp.preset not in self.opt_output.option
+            )
         ):
-            msg = "Compression preset does not match export option\n"
-            msg += "You may continue, but the files will need to be compressed again before export\n"
-            msg += "You are recommended to choose the matching option for compression and output. Continue?"
+            msg = I(
+                "Compression preset does not match export option\n"
+                "You may continue, but the files will need to be compressed again before export\n"
+                "You are recommended to choose the matching option for compression and output. Continue?"
+            )
 
             self.executor.cb("ask_bool", (msg,))
             response = self.executor.cb_return.get_response()
 
             if response is False:
-                return False
+                return False, None
 
         for param, value in (
             ("fps_power", self.opt_comp.fps_power),
@@ -369,8 +423,10 @@ class Job:
             ("color_power", self.opt_comp.color_power),
         ):
             if value < -1:
-                error_msg += "\n"
-                error_msg += f"[X] {param} should be between -1 and positive infinity. {value} was given."
+                error_msg += I(
+                    "\n"
+                    "[X] {param} should be between -1 and positive infinity. {value} was given."
+                ).format(param=param, value=value)
 
         if self.opt_comp.scale_filter not in (
             "nearest",
@@ -380,27 +436,32 @@ class Job:
             "bicubic",
             "lanczos",
         ):
-            error_msg += "\n"
-            error_msg += (
-                f"[X] scale_filter {self.opt_comp.scale_filter} is not valid option"
-            )
-            error_msg += (
+            error_msg += I(
+                "\n"
+                "[X] scale_filter {scale_filter} is not valid option\n"
                 "    Valid options: nearest, box, bilinear, hamming, bicubic, lanczos"
-            )
-
-        if self.opt_comp.quantize_method not in ("imagequant", "fastoctree", "none"):
-            error_msg += "\n"
-            error_msg += f"[X] quantize_method {self.opt_comp.quantize_method} is not valid option"
-            error_msg += "    Valid options: imagequant, fastoctree, none"
+            ).format(scale_filter=self.opt_comp.scale_filter)
+
+        if self.opt_comp.quantize_method not in (
+            "imagequant",
+            "fastoctree",
+            "maxcoverage",
+            "mediancut",
+            "none",
+        ):
+            I(
+                "\n"
+                "[X] quantize_method {quantize_method} is not valid option\n"
+                "    Valid options: imagequant, fastoctree, maxcoverage, mediancut, none"
+            ).format(quantize_method=self.opt_comp.quantize_method)
 
         if self.opt_comp.bg_color:
             try:
                 _, _, _ = bytes.fromhex(self.opt_comp.bg_color)
             except ValueError:
-                error_msg += "\n"
-                error_msg += (
-                    f"[X] bg_color {self.opt_comp.bg_color} is not valid color hex"
-                )
+                error_msg += I(
+                    "\n[X] bg_color {bg_color} is not valid color hex"
+                ).format(bg_color=self.opt_comp.bg_color)
 
         # Warn about unable to download animated Kakao stickers with such link
         if (
@@ -408,18 +469,20 @@ class Job:
             and urlparse(self.opt_input.url).netloc == "e.kakao.com"
             and not self.opt_cred.kakao_auth_token
         ):
-            msg = "To download ANIMATED stickers from e.kakao.com,\n"
-            msg += "you need to generate auth_token.\n"
-            msg += "Alternatively, you can generate share link (emoticon.kakao.com/items/xxxxx)\n"
-            msg += "from Kakao app on phone.\n"
-            msg += "You are adviced to read documentations.\n"
-            msg += "If you continue, you will only download static stickers. Continue?"
+            msg = I(
+                "To download ANIMATED stickers from e.kakao.com,\n"
+                "you need to generate auth_token.\n"
+                "Alternatively, you can generate share link (emoticon.kakao.com/items/xxxxx)\n"
+                "from Kakao app on phone.\n"
+                "You are adviced to read documentations.\n"
+                "If you continue, you will only download static stickers. Continue?"
+            )
 
             self.executor.cb("ask_bool", (msg,))
             response = self.executor.cb_return.get_response()
 
             if response is False:
-                return False
+                return False, None
 
         # Warn about in/output directories that might contain other files
         # Directory is safe if the name is stickers_input/stickers_output, or
@@ -443,26 +506,33 @@ class Job:
 
             related_files = MetadataHandler.get_files_related_to_sticker_convert(path)
             if any(i for i in path.iterdir() if i not in related_files):
-                msg = "WARNING: {} directory is set to {}.\n"
-                msg += 'It does not have default name of "{}",\n'
-                msg += "and It seems like it contains PERSONAL DATA.\n"
-                msg += "During execution, contents of this directory\n"
-                msg += 'maybe MOVED to "archive_*".\n'
-                msg += "THIS MAY CAUSE DAMAGE TO YOUR DATA. Continue?"
+                msg = I(
+                    "WARNING: {path_type} directory is set to {path}.\n"
+                    'It does not have default name of "{default_name}",\n'
+                    "and It seems like it contains PERSONAL DATA.\n"
+                    "During execution, contents of this directory\n"
+                    'maybe MOVED to "archive_*".\n'
+                    "THIS MAY CAUSE DAMAGE TO YOUR DATA. Continue?"
+                )
 
                 self.executor.cb(
-                    "ask_bool", (msg.format(path_type, path, default_name),)
+                    "ask_bool",
+                    (
+                        msg.format(
+                            path_type=path_type, path=path, default_name=default_name
+                        ),
+                    ),
                 )
                 response = self.executor.cb_return.get_response()
 
                 if response is False:
-                    return False
+                    return False, None
 
                 break
 
-        return True
+        return True, None
 
-    def cleanup(self) -> bool:
+    def cleanup(self) -> Tuple[bool, None]:
         # If input is 'From local directory', then we should keep files in input/output directory as it maybe edited by user
         # If input is not 'From local directory', then we should move files in input/output directory as new files will be downloaded
         # Output directory should be cleanup unless no_compress is true (meaning files in output directory might be edited by user)
@@ -479,16 +549,18 @@ class Job:
 
         if self.opt_input.option == "local":
             self.executor.cb(
-                "Skip moving old files in input directory as input source is local"
+                I("Skip moving old files in input directory as input source is local")
             )
         elif len(in_dir_files) == 0:
             self.executor.cb(
-                "Skip moving old files in input directory as input source is empty"
+                I("Skip moving old files in input directory as input source is empty")
             )
         else:
             archive_dir = Path(self.opt_input.dir, dir_name)
             self.executor.cb(
-                f"Moving old files in input directory to {archive_dir} as input source is not local"
+                I(
+                    "Moving old files in input directory to {archive_dir} as input source is not local"
+                ).format(archive_dir=archive_dir)
             )
             archive_dir.mkdir(exist_ok=True)
             for old_path in in_dir_files:
@@ -497,24 +569,28 @@ class Job:
 
         if self.opt_comp.no_compress:
             self.executor.cb(
-                "Skip moving old files in output directory as no_compress is True"
+                I("Skip moving old files in output directory as no_compress is True")
             )
         elif len(out_dir_files) == 0:
             self.executor.cb(
-                "Skip moving old files in output directory as output source is empty"
+                I("Skip moving old files in output directory as output source is empty")
             )
         else:
             archive_dir = Path(self.opt_output.dir, dir_name)
-            self.executor.cb(f"Moving old files in output directory to {archive_dir}")
+            self.executor.cb(
+                I("Moving old files in output directory to {archive_dir}").format(
+                    archive_dir=archive_dir
+                )
+            )
             os.makedirs(archive_dir)
             for old_path in out_dir_files:
                 new_path = Path(archive_dir, old_path.name)
                 old_path.rename(new_path)
 
-        return True
+        return True, None
 
-    def download(self) -> bool:
-        downloaders: List[Callable[..., bool]] = []
+    def download(self) -> Tuple[bool, str]:
+        downloaders: List[Callable[..., Tuple[int, int]]] = []
 
         if self.opt_input.option == "signal":
             downloaders.append(DownloadSignal.start)
@@ -522,41 +598,59 @@ class Job:
         if self.opt_input.option == "line":
             downloaders.append(DownloadLine.start)
 
-        if self.opt_input.option == "telegram":
+        if self.opt_input.option.startswith("telegram"):
             downloaders.append(DownloadTelegram.start)
 
         if self.opt_input.option == "kakao":
             downloaders.append(DownloadKakao.start)
 
+        if self.opt_input.option == "band":
+            downloaders.append(DownloadBand.start)
+
+        if self.opt_input.option == "ogq":
+            downloaders.append(DownloadOgq.start)
+
         if self.opt_input.option == "viber":
             downloaders.append(DownloadViber.start)
 
+        if self.opt_input.option.startswith("discord"):
+            downloaders.append(DownloadDiscord.start)
+
         if len(downloaders) > 0:
-            self.executor.cb("Downloading...")
+            self.executor.cb(I("Downloading..."))
         else:
-            self.executor.cb("Nothing to download")
-            return True
+            self.executor.cb(I("Skipped download (No files to download)"))
+            return True, I("Download: Skipped (No files to download)")
 
         self.executor.start_workers(processes=1)
 
         for downloader in downloaders:
             self.executor.add_work(
                 work_func=downloader,
-                work_args=(self.opt_input.url, self.opt_input.dir, self.opt_cred),
+                work_args=(self.opt_input, self.opt_cred),
             )
 
         self.executor.join_workers()
 
         # Return False if any of the job returns failure
+        stickers_ok = 0
+        stickers_total = 0
+        success = True
         for result in self.executor.results_list:
-            if result is False:
-                return False
+            stickers_ok += result[0]
+            stickers_total += result[1]
+            success = (
+                success if stickers_ok == stickers_total and stickers_ok > 0 else False
+            )
 
-        return True
+        return (
+            success,
+            f"Download: {stickers_ok}/{stickers_total} stickers success",
+        )
 
-    def compress(self) -> bool:
+    def compress(self) -> Tuple[bool, str]:
         if self.opt_comp.no_compress is True:
-            self.executor.cb("no_compress is set to True, skip compression")
+            self.executor.cb(I("Skipped compression (no_compress is set to True)"))
             in_dir_files = [
                 i
                 for i in sorted(self.opt_input.dir.iterdir())
@@ -569,21 +663,23 @@ class Job:
             ]
             if len(in_dir_files) == 0:
                 self.executor.cb(
-                    "Input directory is empty, nothing to copy to output directory"
+                    I("Input directory is empty, nothing to copy to output directory")
                 )
             elif len(out_dir_files) != 0:
                 self.executor.cb(
-                    "Output directory is not empty, not copying files from input directory"
+                    I(
+                        "Output directory is not empty, not copying files from input directory"
+                    )
                 )
             else:
                 self.executor.cb(
-                    "Output directory is empty, copying files from input directory"
+                    I("Output directory is empty, copying files from input directory")
                 )
                 for i in in_dir_files:
                     src_f = Path(self.opt_input.dir, i.name)
                     dst_f = Path(self.opt_output.dir, i.name)
                     shutil.copy(src_f, dst_f)
-            return True
+            return True, "Compress: Skipped (no_compress is set to True)"
         msg = "Compressing..."
 
         input_dir = Path(self.opt_input.dir)
@@ -598,15 +694,20 @@ class Job:
 
             if not in_f.is_file():
                 continue
-            if CodecInfo.get_file_ext(i) in (".txt", ".m4a") or Path(i).stem == "cover":
+            if (
+                CodecInfo.get_file_ext(i) in (".txt", ".m4a")
+                or (
+                    self.opt_comp.preset != "signal" and Path(i).stem == "cover"
+                )  # Signal cover has same spec as normal sticker
+            ):
                 shutil.copy(in_f, output_dir / i.name)
             else:
                 in_fs.append(i)
 
         in_fs_count = len(in_fs)
         if in_fs_count == 0:
-            self.executor.cb("No files to compress")
-            return True
+            self.executor.cb(I("Skipped compression (No files to compress)"))
+            return True, "Compress: Skipped (No files to compress)"
 
         self.executor.cb(msg)
         self.executor.cb(
@@ -625,21 +726,35 @@ class Job:
 
         self.executor.join_workers()
 
-        # Return False if any of the job returns failure
+        success = True
+        stickers_ok = 0
+        stickers_total = 0
+        fails: List[str] = []
         for result in self.executor.results_list:
+            stickers_total += 1
             if result[0] is False:
-                return False
+                success = False
+                fails.append(str(result[1]))
+            else:
+                stickers_ok += 1
 
-        return True
+        msg_append = ""
+        if success is False:
+            msg_append = " (Failed: " + ", ".join(fails) + ")"
 
-    def export(self) -> bool:
+        return (
+            success,
+            f"Compress: {stickers_ok}/{stickers_total} stickers success" + msg_append,
+        )
+
+    def export(self) -> Tuple[bool, str]:
         if self.opt_output.option == "local":
-            self.executor.cb("Saving to local directory only, nothing to export")
-            return True
+            self.executor.cb(I("Skipped export (Saving to local directory only)"))
+            return True, I("Export: Skipped (Saving to local directory only)")
 
-        self.executor.cb("Exporting...")
+        self.executor.cb(I("Exporting..."))
 
-        exporters: List[Callable[..., List[str]]] = []
+        exporters: List[Callable[..., Tuple[int, int, List[str]]]] = []
 
         if self.opt_output.option == "whatsapp":
             exporters.append(CompressWastickers.start)
@@ -647,15 +762,15 @@ class Job:
         if self.opt_output.option == "signal":
             exporters.append(UploadSignal.start)
 
-        if self.opt_output.option == "telegram":
-            exporters.append(UploadTelegram.start)
-
-        if self.opt_output.option == "telegram_emoji":
+        if self.opt_output.option.startswith("telegram"):
             exporters.append(UploadTelegram.start)
 
         if self.opt_output.option == "imessage":
             exporters.append(XcodeImessage.start)
 
+        if self.opt_output.option == "viber":
+            exporters.append(UploadViber.start)
+
         self.executor.start_workers(processes=1)
 
         for exporter in exporters:
@@ -666,8 +781,12 @@ class Job:
 
         self.executor.join_workers()
 
+        stickers_ok = 0
+        stickers_total = 0
         for result in self.executor.results_list:
-            self.out_urls.extend(result)
+            stickers_ok += result[0]
+            stickers_total += result[1]
+            self.out_urls.extend(result[2])
 
         if self.out_urls:
             with open(
@@ -675,30 +794,11 @@ class Job:
             ) as f:
                 f.write("\n".join(self.out_urls))
         else:
-            self.executor.cb("An error occured while exporting stickers")
-            return False
-
-        return True
-
-    def report(self) -> bool:
-        msg = "##########\n"
-        msg += "Summary:\n"
-        msg += "##########\n"
-        msg += "\n"
-
-        if self.compress_fails:
-            msg += f'Warning: Could not compress the following {len(self.compress_fails)} file{"s" if len(self.compress_fails) > 1 else ""}:\n'
-            msg += "\n".join(self.compress_fails)
-            msg += "\n"
-            msg += "\nConsider adjusting compression parameters"
-            msg += "\n"
-
-        if self.out_urls:
-            msg += "Export results:\n"
-            msg += "\n".join(self.out_urls)
-        else:
-            msg += "Export result: None"
-
-        self.executor.cb(msg)
-
-        return True
+            self.executor.cb(I("An error occured while exporting stickers"))
+            return False, I(
+                "Export: {stickers_ok}/{stickers_total} stickers success"
+            ).format(stickers_ok=stickers_ok, stickers_total=stickers_total)
+
+        return True, I(
+            "Export: {stickers_ok}/{stickers_total} stickers success"
+        ).format(stickers_ok=stickers_ok, stickers_total=stickers_total)