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

sticker_convert/{utils → gui_components}/gui_utils.py

@@ -1,47 +1,64 @@
+#!/usr/bin/env python3
+from __future__ import annotations
 import platform
 from typing import Union, TYPE_CHECKING
 
 from ttkbootstrap import Frame, Canvas, Scrollbar, PhotoImage
+
 if TYPE_CHECKING:
-    from ..gui_windows.base_window import BaseWindow # type: ignore
-    from ..gui import GUI # type: ignore
+    from .windows.base_window import BaseWindow  # type: ignore
+    from ..gui import GUI  # type: ignore
+
 
 class GUIUtils:
     @staticmethod
     def set_icon(window: Union["BaseWindow", "GUI"]):
-        window.icon = PhotoImage(file='resources/appicon.png')
+        window.icon = PhotoImage(file="resources/appicon.png")
         window.iconphoto(1, window.icon)
-        if platform.system() == 'Darwin':
-            window.iconbitmap(bitmap='resources/appicon.icns')
-        elif platform.system() == 'Windows':
-            window.iconbitmap(bitmap='resources/appicon.ico')
-        window.tk.call('wm', 'iconphoto', window._w, window.icon)
+        if platform.system() == "Darwin":
+            window.iconbitmap(bitmap="resources/appicon.icns")
+        elif platform.system() == "Windows":
+            window.iconbitmap(bitmap="resources/appicon.ico")
+        window.tk.call("wm", "iconphoto", window._w, window.icon)
 
     @staticmethod
-    def create_scrollable_frame(window: Union["BaseWindow", "GUI"]) -> tuple[Frame, Frame, Canvas, Scrollbar, Scrollbar, Frame]:
+    def create_scrollable_frame(
+        window: Union["BaseWindow", "GUI"]
+    ) -> tuple[Frame, Frame, Canvas, Scrollbar, Scrollbar, Frame]:
         main_frame = Frame(window)
-        main_frame.pack(fill='both', expand=1)
+        main_frame.pack(fill="both", expand=1)
 
         horizontal_scrollbar_frame = Frame(main_frame)
-        horizontal_scrollbar_frame.pack(fill='x', side='bottom')
+        horizontal_scrollbar_frame.pack(fill="x", side="bottom")
 
         canvas = Canvas(main_frame)
-        canvas.pack(side='left', fill='both', expand=1)
+        canvas.pack(side="left", fill="both", expand=1)
 
-        x_scrollbar = Scrollbar(horizontal_scrollbar_frame, orient='horizontal', command=canvas.xview)
-        x_scrollbar.pack(side='bottom', fill='x')
+        x_scrollbar = Scrollbar(
+            horizontal_scrollbar_frame, orient="horizontal", command=canvas.xview
+        )
+        x_scrollbar.pack(side="bottom", fill="x")
 
-        y_scrollbar = Scrollbar(main_frame, orient='vertical', command=canvas.yview)
-        y_scrollbar.pack(side='right', fill='y')
+        y_scrollbar = Scrollbar(main_frame, orient="vertical", command=canvas.yview)
+        y_scrollbar.pack(side="right", fill="y")
 
         canvas.configure(xscrollcommand=x_scrollbar.set)
         canvas.configure(yscrollcommand=y_scrollbar.set)
-        canvas.bind("<Configure>",lambda e: canvas.config(scrollregion=canvas.bbox('all'))) 
+        canvas.bind(
+            "<Configure>", lambda e: canvas.config(scrollregion=canvas.bbox("all"))
+        )
 
         scrollable_frame = Frame(canvas)
-        canvas.create_window((0,0), window=scrollable_frame, anchor="nw")
+        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
 
-        return main_frame, horizontal_scrollbar_frame, canvas, x_scrollbar, y_scrollbar, scrollable_frame
+        return (
+            main_frame,
+            horizontal_scrollbar_frame,
+            canvas,
+            x_scrollbar,
+            y_scrollbar,
+            scrollable_frame,
+        )
 
     @staticmethod
     def finalize_window(window: Union["GUI", "BaseWindow"]):
@@ -62,7 +79,7 @@ class GUIUtils:
             window_width = screen_width
         if window_height > screen_height:
             window_height = screen_height
-        
+
         frame_width = window_width - window.y_scrollbar.winfo_width()
         frame_height = window_height - window.x_scrollbar.winfo_height()
 
@@ -73,4 +90,4 @@ class GUIUtils:
 
         window.attributes("-alpha", 1)
 
-        window.focus_force()
+        window.focus_force()

sticker_convert/{gui_windows → gui_components/windows}/advanced_compression_window.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
+from __future__ import annotations
 from functools import partial
 
 from PIL import Image, ImageTk, ImageDraw
 from ttkbootstrap import LabelFrame, Frame, OptionMenu, Button, Entry, Label, Checkbutton, Scrollbar, Canvas, StringVar # type: ignore
 from tkinter import Event
 
-from ..gui_frames.right_clicker import RightClicker # type: ignore
+from ..frames.right_clicker import RightClicker # type: ignore
 from .base_window import BaseWindow # type: ignore
-from ..utils.gui_utils import GUIUtils # type: ignore
+from ..gui_utils import GUIUtils # type: ignore
 
 class AdvancedCompressionWindow(BaseWindow):
     emoji_column_per_row = 10

sticker_convert/{gui_windows → gui_components/windows}/base_window.py

@@ -1,11 +1,12 @@
+#!/usr/bin/env python3
 import platform
 from typing import TYPE_CHECKING
 
 from ttkbootstrap import Toplevel # type: ignore
 
 if TYPE_CHECKING:
-    from ..gui import GUI # type: ignore
-from ..utils.gui_utils import GUIUtils # type: ignore
+    from ...gui import GUI # type: ignore
+from ..gui_utils import GUIUtils # type: ignore
 
 class BaseWindow(Toplevel):
     def __init__(self, gui: "GUI"):

sticker_convert/{gui_windows → gui_components/windows}/kakao_get_auth_window.py

@@ -4,10 +4,10 @@ from threading import Thread
 
 from ttkbootstrap import LabelFrame, Frame, Button, Entry, Label # type: ignore
 
-from ..auth.get_kakao_auth import GetKakaoAuth # type: ignore
-from ..gui_frames.right_clicker import RightClicker # type: ignore
+from ...utils.auth.get_kakao_auth import GetKakaoAuth # type: ignore
+from ..frames.right_clicker import RightClicker # type: ignore
 from .base_window import BaseWindow # type: ignore
-from ..utils.gui_utils import GUIUtils # type: ignore
+from ..gui_utils import GUIUtils # type: ignore
 
 class KakaoGetAuthWindow(BaseWindow):
     def __init__(self, *args, **kwargs):

sticker_convert/{gui_windows → gui_components/windows}/line_get_auth_window.py

@@ -5,9 +5,9 @@ from threading import Thread
 
 from ttkbootstrap import Frame, Button, Label # type: ignore
 
-from ..auth.get_line_auth import GetLineAuth # type: ignore
+from ...utils.auth.get_line_auth import GetLineAuth # type: ignore
 from .base_window import BaseWindow # type: ignore
-from ..utils.gui_utils import GUIUtils # type: ignore
+from ..gui_utils import GUIUtils # type: ignore
 
 class LineGetAuthWindow(BaseWindow):
     def __init__(self, *args, **kwargs):

sticker_convert/{gui_windows → gui_components/windows}/signal_get_auth_window.py

@@ -4,9 +4,9 @@ from threading import Thread
 
 from ttkbootstrap import Toplevel, Frame, Button, Label # type: ignore
 
-from ..auth.get_signal_auth import GetSignalAuth # type: ignore
+from ...utils.auth.get_signal_auth import GetSignalAuth # type: ignore
 from .base_window import BaseWindow # type: ignore
-from ..utils.gui_utils import GUIUtils # type: ignore
+from ..gui_utils import GUIUtils # type: ignore
 
 class SignalGetAuthWindow(BaseWindow):
     def __init__(self, *args, **kwargs):

sticker_convert/{flow.py → job.py}

@@ -1,12 +1,17 @@
 #!/usr/bin/env python3
+from __future__ import annotations
+
 import os
 import shutil
 from datetime import datetime
 from multiprocessing import Process, Queue, Value
+from multiprocessing.queues import Queue as QueueType
 from threading import Thread
 from urllib.parse import urlparse
 from typing import Optional
 
+from .job_option import InputOption, CompOption, OutputOption, CredOption  # type: ignore
+
 from .downloaders.download_line import DownloadLine # type: ignore
 from .downloaders.download_signal import DownloadSignal # type: ignore
 from .downloaders.download_telegram import DownloadTelegram # type: ignore
@@ -18,22 +23,21 @@ from .uploaders.upload_telegram import UploadTelegram # type: ignore
 from .uploaders.compress_wastickers import CompressWastickers # type: ignore
 from .uploaders.xcode_imessage import XcodeImessage # type: ignore
 
-from .utils.converter import StickerConvert # type: ignore
-from .utils.codec_info import CodecInfo # type: ignore
-from .utils.json_manager import JsonManager # type: ignore
-from .utils.metadata_handler import MetadataHandler # type: ignore
+from .converter import StickerConvert # type: ignore
+from .utils.media.codec_info import CodecInfo # type: ignore
+from .utils.files.json_manager import JsonManager # type: ignore
+from .utils.files.metadata_handler import MetadataHandler # type: ignore
 
-class Flow:
+class Job:
     def __init__(self,
-        opt_input: dict, opt_comp: dict, opt_output: dict, opt_cred: dict, 
-        input_presets: dict, output_presets: dict, cb_msg, cb_msg_block, cb_bar, cb_ask_bool):
+        opt_input: InputOption, opt_comp: CompOption,
+        opt_output: OutputOption, opt_cred: CredOption, 
+        cb_msg, cb_msg_block, cb_bar, cb_ask_bool):
 
         self.opt_input = opt_input
         self.opt_comp = opt_comp
         self.opt_output = opt_output
         self.opt_cred = opt_cred
-        self.input_presets = input_presets
-        self.output_presets = output_presets
         self.cb_msg = cb_msg
         self.cb_msg_block = cb_msg_block
         self.cb_bar = cb_bar
@@ -42,25 +46,24 @@ class Flow:
         self.compress_fails: list[str] = []
         self.out_urls: list[str] = []
 
-        self.jobs_queue: Queue[Optional[tuple[str, str, dict]]] = Queue()
-        self.results_queue: Queue[Optional[tuple[bool, str, str, int]]] = Queue()
-        self.cb_msg_queue: Queue[Optional[str]] = Queue()
+        self.jobs_queue: QueueType[Optional[tuple[str, str, CompOption]]] = Queue()
+        self.results_queue: QueueType[Optional[tuple[bool, str, str, int]]] = Queue()
+        self.cb_msg_queue: QueueType[Optional[str]] = Queue()
         self.processes: list[Process] = []
 
         self.is_cancel_job = Value('i', 0)
 
-        if os.path.isdir(self.opt_input['dir']) == False:
-            os.makedirs(self.opt_input['dir'])
+        if os.path.isdir(self.opt_input.dir) == False:
+            os.makedirs(self.opt_input.dir)
 
-        if os.path.isdir(self.opt_output['dir']) == False:
-            os.makedirs(self.opt_output['dir'])
+        if os.path.isdir(self.opt_output.dir) == False:
+            os.makedirs(self.opt_output.dir)
 
     def start(self) -> bool:
         self.cb_bar(set_progress_mode='indeterminate')
         self.cb_msg(cls=True)
 
         tasks = (
-            self.sanitize,
             self.verify_input,
             self.cleanup,
             self.download,
@@ -77,33 +80,6 @@ class Flow:
                 return 1
 
         return 0
-    
-    def sanitize(self) -> bool:
-        def to_int(i):
-            return i if i != None else None
-
-        try:
-            self.opt_comp['size_max']['img'] = to_int(self.opt_comp['size_max']['img'])
-            self.opt_comp['size_max']['vid'] = to_int(self.opt_comp['size_max']['vid'])
-            self.opt_comp['fps']['min'] = to_int(self.opt_comp['fps']['min'])
-            self.opt_comp['fps']['max'] = to_int(self.opt_comp['fps']['max'])
-            self.opt_comp['res']['w']['min'] = to_int(self.opt_comp['res']['w']['min'])
-            self.opt_comp['res']['w']['max'] = to_int(self.opt_comp['res']['w']['max'])
-            self.opt_comp['res']['h']['min'] = to_int(self.opt_comp['res']['h']['min'])
-            self.opt_comp['res']['h']['max'] = to_int(self.opt_comp['res']['h']['max'])
-            self.opt_comp['quality']['min'] = to_int(self.opt_comp['quality']['min'])
-            self.opt_comp['quality']['max'] = to_int(self.opt_comp['quality']['max'])
-            self.opt_comp['color']['min'] = to_int(self.opt_comp['color']['min'])
-            self.opt_comp['color']['max'] = to_int(self.opt_comp['color']['max'])
-            self.opt_comp['duration']['min'] = to_int(self.opt_comp['duration']['min'])
-            self.opt_comp['duration']['max'] = to_int(self.opt_comp['duration']['max'])
-            self.opt_comp['steps'] = to_int(self.opt_comp['steps'])
-            self.opt_comp['processes'] = to_int(self.opt_comp['processes'])
-        except ValueError:
-            self.cb_msg('Non-numbers found in field(s). Check your input and try again.')
-            return False
-
-        return True
 
     def verify_input(self) -> bool:
         info_msg = ''
@@ -113,12 +89,12 @@ class Flow:
         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'
 
-        if self.opt_input['option'] == 'auto':
+        if self.opt_input.option == 'auto':
             error_msg += '\n'
             error_msg += '[X] Unrecognized URL input source\n'
 
-        if (self.opt_input['option'] != 'local' and 
-            not self.opt_input.get('url')):
+        if (self.opt_input.option != 'local' and 
+            not self.opt_input.url):
 
             error_msg += '\n'
             error_msg += '[X] URL address cannot be empty.\n'
@@ -127,37 +103,37 @@ class Flow:
             error_msg += '    in "Input source"\n'
         
 
-        if ((self.opt_input.get('option') == 'telegram' or 
-            self.opt_output.get('option') == 'telegram') and 
-            not self.opt_cred.get('telegram', {}).get('token')):
+        if ((self.opt_input.option == 'telegram' or 
+            self.opt_output.option == 'telegram') and 
+            not self.opt_cred.telegram_token):
 
             error_msg += '[X] Downloading from and uploading to telegram requires bot token.\n'
             error_msg += save_to_local_tip
 
-        if (self.opt_output.get('option') == 'telegram' and 
-            not self.opt_cred.get('telegram', {}).get('userid')):
+        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 += save_to_local_tip
         
 
-        if (self.opt_output.get('option') == 'signal' and 
-            not (self.opt_cred.get('signal', {}).get('uuid') and self.opt_cred.get('signal', {}).get('password'))):
+        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 += save_to_local_tip
         
         output_presets = JsonManager.load_json('resources/output.json')
 
-        input_option = self.opt_input.get('option')
-        output_option = self.opt_output.get("option")
+        input_option = self.opt_input.option
+        output_option = self.opt_output.option
         
         for metadata in ('title', 'author'):
-            if MetadataHandler.check_metadata_required(output_option, metadata) and not self.opt_output.get(metadata): 
-                if not MetadataHandler.check_metadata_provided(self.opt_input['dir'], input_option, metadata):
+            if MetadataHandler.check_metadata_required(output_option, metadata) and not getattr(self.opt_output, metadata):
+                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'
-                    if self.opt_input.get('option') == 'local':
+                    if self.opt_input.option == 'local':
                         error_msg += f'    {metadata} was not supplied and {metadata}.txt is absent\n'
                     else:
                         error_msg += f'    {metadata} was not supplied and input source will not provide {metadata}\n'
@@ -165,7 +141,7 @@ class Flow:
                     error_msg += f'    Create {metadata}.txt with the {metadata} name\n'
                 else:
                     info_msg += f'[!] {output_presets[output_option]["full_name"]} requires {metadata}\n'
-                    if self.opt_input.get('option') == 'local':
+                    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'
                     else:
@@ -183,10 +159,10 @@ class Flow:
         # Only warn if the compression option is available in export preset
         # Only warn if export option is not local or custom
         # Do not warn if no_compress is true
-        if (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']):
+        if (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):
 
             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'
@@ -198,9 +174,9 @@ class Flow:
                 return False
         
         # Warn about unable to download animated Kakao stickers with such link
-        if (self.opt_output.get('option') == 'kakao' and 
-            urlparse(self.opt_input.get('url')).netloc == 'e.kakao.com' and
-            not self.opt_cred.get('kakao', {}).get('auth_token')):
+        if (self.opt_output.option == 'kakao' 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'
@@ -229,32 +205,32 @@ class Flow:
         timestamp = datetime.now().strftime('%Y-%d-%m_%H-%M-%S')
         dir_name = 'archive_' + timestamp
 
-        in_dir_files = [i for i in os.listdir(self.opt_input['dir']) if not i.startswith('archive_')]
-        out_dir_files = [i for i in os.listdir(self.opt_output['dir']) if not i.startswith('archive_')]
+        in_dir_files = [i for i in os.listdir(self.opt_input.dir) if not i.startswith('archive_')]
+        out_dir_files = [i for i in os.listdir(self.opt_output.dir) if not i.startswith('archive_')]
 
-        if self.opt_input['option'] == 'local':
+        if self.opt_input.option == 'local':
             self.cb_msg('Skip moving old files in input directory as input source is local')
         elif len(in_dir_files) == 0:
             self.cb_msg('Skip moving old files in input directory as input source is empty')
         else:
-            archive_dir = os.path.join(self.opt_input['dir'], dir_name)
+            archive_dir = os.path.join(self.opt_input.dir, dir_name)
             self.cb_msg(f"Moving old files in input directory to {archive_dir} as input source is not local")
             os.makedirs(archive_dir)
             for i in in_dir_files:
-                old_path = os.path.join(self.opt_input['dir'], i)
+                old_path = os.path.join(self.opt_input.dir, i)
                 new_path = os.path.join(archive_dir, i)
                 shutil.move(old_path, new_path)
 
-        if self.opt_comp['no_compress']:
+        if self.opt_comp.no_compress:
             self.cb_msg('Skip moving old files in output directory as no_compress is True')
         elif len(out_dir_files) == 0:
             self.cb_msg('Skip moving old files in output directory as output source is empty')
         else:
-            archive_dir = os.path.join(self.opt_output['dir'], dir_name)
+            archive_dir = os.path.join(self.opt_output.dir, dir_name)
             self.cb_msg(f"Moving old files in output directory to {archive_dir}")
             os.makedirs(archive_dir)
             for i in out_dir_files:
-                old_path = os.path.join(self.opt_output['dir'], i)
+                old_path = os.path.join(self.opt_output.dir, i)
                 new_path = os.path.join(archive_dir, i)
                 shutil.move(old_path, new_path)
         
@@ -263,16 +239,16 @@ class Flow:
     def download(self) -> bool:
         downloaders = []
 
-        if self.opt_input['option'] == 'signal':
+        if self.opt_input.option == 'signal':
             downloaders.append(DownloadSignal.start)
 
-        if self.opt_input['option'] == 'line':
+        if self.opt_input.option == 'line':
             downloaders.append(DownloadLine.start)
             
-        if self.opt_input['option'] == 'telegram':
+        if self.opt_input.option == 'telegram':
             downloaders.append(DownloadTelegram.start)
 
-        if self.opt_input['option'] == 'kakao':
+        if self.opt_input.option == 'kakao':
             downloaders.append(DownloadKakao.start)
         
         if len(downloaders) > 0:
@@ -283,8 +259,8 @@ class Flow:
         
         for downloader in downloaders:
             success = downloader(
-                url=self.opt_input['url'], 
-                out_dir=self.opt_input['dir'], 
+                url=self.opt_input.url, 
+                out_dir=self.opt_input.dir, 
                 opt_cred=self.opt_cred,
                 cb_msg=self.cb_msg, cb_msg_block=self.cb_msg_block, cb_bar=self.cb_bar)
             self.cb_bar(set_progress_mode='indeterminate')
@@ -294,10 +270,10 @@ class Flow:
         return True
 
     def compress(self) -> bool:
-        if self.opt_comp['no_compress'] == True:
+        if self.opt_comp.no_compress == True:
             self.cb_msg('no_compress is set to True, skip compression')
-            in_dir_files = [i for i in sorted(os.listdir(self.opt_input['dir'])) if os.path.isfile(os.path.join(self.opt_input['dir'], i))]
-            out_dir_files = [i for i in sorted(os.listdir(self.opt_output['dir'])) if os.path.isfile(os.path.join(self.opt_output['dir'], i))]
+            in_dir_files = [i for i in sorted(os.listdir(self.opt_input.dir)) if os.path.isfile(os.path.join(self.opt_input.dir, i))]
+            out_dir_files = [i for i in sorted(os.listdir(self.opt_output.dir)) if os.path.isfile(os.path.join(self.opt_output.dir, i))]
             if len(in_dir_files) == 0:
                 self.cb_msg('Input directory is empty, nothing to copy to output directory')
             elif len(out_dir_files) != 0:
@@ -305,14 +281,14 @@ class Flow:
             else:
                 self.cb_msg('Output directory is empty, copying files from input directory')
                 for i in in_dir_files:
-                    src_f = os.path.join(self.opt_input['dir'], i)
-                    dst_f = os.path.join(self.opt_output['dir'], i)
+                    src_f = os.path.join(self.opt_input.dir, i)
+                    dst_f = os.path.join(self.opt_output.dir, i)
                     shutil.copy(src_f, dst_f)
             return True
         msg = 'Compressing...'
 
-        input_dir = self.opt_input['dir']
-        output_dir = self.opt_output['dir']
+        input_dir = self.opt_input.dir
+        output_dir = self.opt_output.dir
         
         in_fs = []
 
@@ -338,9 +314,9 @@ class Flow:
         Thread(target=self.cb_msg_thread, args=(self.cb_msg_queue,)).start()
         Thread(target=self.processes_watcher_thread, args=(self.results_queue,)).start()
 
-        for i in range(min(self.opt_comp['processes'], in_fs_count)):
+        for i in range(min(self.opt_comp.processes, in_fs_count)):
             process = Process(
-                target=Flow.compress_worker,
+                target=Job.compress_worker,
                 args=(self.jobs_queue, self.results_queue, self.cb_msg_queue),
                 daemon=True
             )
@@ -351,10 +327,10 @@ class Flow:
         for i in in_fs:
             in_f = os.path.join(input_dir, i)
 
-            if CodecInfo.is_anim(in_f) or self.opt_comp['fake_vid']:
-                extension = self.opt_comp['format']['vid']
+            if CodecInfo.is_anim(in_f) or self.opt_comp.fake_vid:
+                extension = self.opt_comp.format_vid
             else:
-                extension = self.opt_comp['format']['img']
+                extension = self.opt_comp.format_img
 
             out_f = os.path.join(output_dir, os.path.splitext(i)[0] + extension)
 
@@ -370,19 +346,32 @@ class Flow:
 
         return True
     
-    def processes_watcher_thread(self, results_queue: Queue):
+    def processes_watcher_thread(
+            self, 
+            results_queue: QueueType[Optional[tuple[bool, str, str, int]]]
+            ):
+        
         for (success, in_f, out_f, size) in iter(results_queue.get, None): # type: ignore[misc]
             if success == False: # type: ignore
                 self.compress_fails.append(in_f) # type: ignore[has-type]
 
             self.cb_bar(update_bar=True)
     
-    def cb_msg_thread(self, cb_msg_queue: Queue):
+    def cb_msg_thread(
+            self, 
+            cb_msg_queue: QueueType[Optional[str]]
+            ):
+        
         for msg in iter(cb_msg_queue.get, None): # type: ignore
             self.cb_msg(msg)
 
     @staticmethod
-    def compress_worker(jobs_queue: Queue, results_queue: Queue, cb_msg_queue: Queue):
+    def compress_worker(
+        jobs_queue: QueueType[Optional[tuple[str, str, CompOption]]], 
+        results_queue: QueueType[Optional[tuple[bool, str, str, int]]], 
+        cb_msg_queue: QueueType[Optional[str]]
+        ):
+
         for (in_f, out_f, opt_comp) in iter(jobs_queue.get, None): # type: ignore[misc]
             sticker = StickerConvert(in_f, out_f, opt_comp, cb_msg_queue) # type: ignore
             success, in_f, out_f, size = sticker.convert()
@@ -394,7 +383,7 @@ class Flow:
     def export(self) -> bool:
         self.cb_bar(set_progress_mode='indeterminate')
 
-        if self.opt_output['option'] == 'local':
+        if self.opt_output.option == 'local':
             self.cb_msg('Saving to local directory only, nothing to export')
             return True
         
@@ -402,16 +391,16 @@ class Flow:
 
         exporters: list[UploadBase] = []
 
-        if self.opt_output['option'] == 'whatsapp':
+        if self.opt_output.option == 'whatsapp':
             exporters.append(CompressWastickers.start)
 
-        if self.opt_output['option'] == 'signal':
+        if self.opt_output.option == 'signal':
             exporters.append(UploadSignal.start)
 
-        if self.opt_output['option'] == 'telegram':
+        if self.opt_output.option == 'telegram':
             exporters.append(UploadTelegram.start)
 
-        if self.opt_output['option'] == 'imessage':
+        if self.opt_output.option == 'imessage':
             exporters.append(XcodeImessage.start)
         
         for exporter in exporters:
@@ -420,7 +409,7 @@ class Flow:
                 cb_msg=self.cb_msg, cb_msg_block=self.cb_msg_block, cb_ask_bool=self.cb_ask_bool, cb_bar=self.cb_bar)
         
         if self.out_urls:
-            with open(os.path.join(self.opt_output['dir'], 'export-result.txt'), 'w+') as f:
+            with open(os.path.join(self.opt_output.dir, 'export-result.txt'), 'w+') as f:
                 f.writelines(self.out_urls)
         else:
             self.cb_msg('An error occured while exporting stickers')