sticker-convert 2.7.2__py3-none-any.whl → 2.7.4__py3-none-any.whl

sticker_convert/uploaders/upload_base.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 from queue import Queue
-from typing import Optional, Union
+from typing import Union
 
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 
 
 class UploadBase:
@@ -12,18 +12,9 @@ class UploadBase:
         opt_output: OutputOption,
         opt_comp: CompOption,
         opt_cred: CredOption,
-        cb: Union[
-            Queue[
-                Union[
-                    tuple[str, Optional[tuple[str]], Optional[dict[str, str]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ],
+        cb: "Union[Queue[CbQueueItemType], Callback]",
         cb_return: CallbackReturn,
-    ):
+    ) -> None:
         if not cb:
             cb = Callback(silent=True)
             cb_return = CallbackReturn()
@@ -33,3 +24,18 @@ class UploadBase:
         self.opt_cred = opt_cred
         self.cb = cb
         self.cb_return = cb_return
+
+        self.base_spec = CompOption(
+            fps_power=self.opt_comp.fps_power,
+            res_power=self.opt_comp.res_power,
+            quality_min=self.opt_comp.quality_min,
+            quality_max=self.opt_comp.quality_max,
+            quality_power=self.opt_comp.quality_power,
+            color_min=self.opt_comp.color_min,
+            color_max=self.opt_comp.color_max,
+            color_power=self.opt_comp.color_power,
+            quantize_method=self.opt_comp.quantize_method,
+            scale_filter=self.opt_comp.scale_filter,
+            steps=self.opt_comp.steps,
+            cache_dir=self.opt_comp.cache_dir,
+        )

sticker_convert/uploaders/upload_signal.py

@@ -2,47 +2,43 @@
 import copy
 from pathlib import Path
 from queue import Queue
-from typing import Any, Optional, Union
+from typing import Any, Dict, List, Union
 
 import anyio
 from signalstickers_client import StickersClient  # type: ignore
 from signalstickers_client.errors import SignalException  # type: ignore
-from signalstickers_client.models import (  # type: ignore
-    LocalStickerPack,
-    Sticker,
-)
+from signalstickers_client.models import LocalStickerPack, Sticker  # type: ignore
 
 from sticker_convert.converter import StickerConvert
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
 from sticker_convert.uploaders.upload_base import UploadBase
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.media.codec_info import CodecInfo
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 
 class UploadSignal(UploadBase):
-    def __init__(self, *args: Any, **kwargs: Any):
-        super(UploadSignal, self).__init__(*args, **kwargs)
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
-        base_spec = CompOption()
-        base_spec.set_size_max(300000)
-        base_spec.set_res_max(512)
-        base_spec.duration_max = 3000
-        base_spec.square = True
+        self.base_spec.set_size_max(300000)
+        self.base_spec.set_res_max(512)
+        self.base_spec.duration_max = 3000
+        self.base_spec.square = True
 
-        self.png_spec = copy.deepcopy(base_spec)
+        self.png_spec = copy.deepcopy(self.base_spec)
         self.png_spec.set_format((".apng",))
 
-        self.webp_spec = copy.deepcopy(base_spec)
+        self.webp_spec = copy.deepcopy(self.base_spec)
         self.webp_spec.format_img = (".webp",)
         self.webp_spec.animated = False
 
         self.opt_comp_merged = copy.deepcopy(self.opt_comp)
-        self.opt_comp_merged.merge(base_spec)
+        self.opt_comp_merged.merge(self.base_spec)
 
     @staticmethod
-    async def upload_pack(pack: LocalStickerPack, uuid: str, password: str):
+    async def upload_pack(pack: LocalStickerPack, uuid: str, password: str) -> str:
         async with StickersClient(uuid, password) as client:
             pack_id, pack_key = await client.upload_pack(pack)  # type: ignore
 
@@ -52,8 +48,8 @@ class UploadSignal(UploadBase):
         return result
 
     def add_stickers_to_pack(
-        self, pack: LocalStickerPack, stickers: list[Path], emoji_dict: dict[str, str]
-    ):
+        self, pack: LocalStickerPack, stickers: List[Path], emoji_dict: Dict[str, str]
+    ) -> None:
         for src in stickers:
             self.cb.put(f"Verifying {src} for uploading to signal")
 
@@ -96,8 +92,8 @@ class UploadSignal(UploadBase):
 
             pack._addsticker(sticker)  # type: ignore
 
-    def upload_stickers_signal(self) -> list[str]:
-        urls: list[str] = []
+    def upload_stickers_signal(self) -> List[str]:
+        urls: List[str] = []
 
         if not self.opt_cred.signal_uuid:
             self.cb.put("uuid required for uploading to Signal")
@@ -121,7 +117,7 @@ class UploadSignal(UploadBase):
             msg_block += f"Default emoji is set to {self.opt_comp.default_emoji}.\n"
             msg_block += "Please edit emoji.txt now, then continue"
             MetadataHandler.generate_emoji_file(
-                dir=self.opt_output.dir, default_emoji=self.opt_comp.default_emoji
+                directory=self.opt_output.dir, default_emoji=self.opt_comp.default_emoji
             )
 
             self.cb.put(("msg_block", (msg_block,), None))
@@ -171,17 +167,8 @@ class UploadSignal(UploadBase):
         opt_output: OutputOption,
         opt_comp: CompOption,
         opt_cred: CredOption,
-        cb: Union[
-            Queue[
-                Union[
-                    tuple[str, Optional[tuple[str]], Optional[dict[str, str]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ],
+        cb: "Union[Queue[CbQueueItemType], Callback]",
         cb_return: CallbackReturn,
-    ) -> list[str]:
+    ) -> List[str]:
         exporter = UploadSignal(opt_output, opt_comp, opt_cred, cb, cb_return)
         return exporter.upload_stickers_signal()

sticker_convert/uploaders/upload_telegram.py

@@ -3,7 +3,7 @@ import copy
 import re
 from pathlib import Path
 from queue import Queue
-from typing import Any, Optional, Union, cast
+from typing import Any, Dict, List, Union, cast
 
 import anyio
 from telegram import Bot, InputSticker, Sticker
@@ -12,38 +12,39 @@ from telegram.error import TelegramError
 from sticker_convert.converter import StickerConvert
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
 from sticker_convert.uploaders.upload_base import UploadBase
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.metadata_handler import MetadataHandler
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 
 class UploadTelegram(UploadBase):
-    def __init__(self, *args: Any, **kwargs: Any):
-        super(UploadTelegram, self).__init__(*args, **kwargs)
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
-        base_spec = CompOption(
-            size_max_img=512000, size_max_vid=256000, square=True, duration_max=3000
-        )
-        base_spec.set_res(512)
+        self.base_spec.size_max_img = 512000
+        self.base_spec.size_max_vid = 256000
+        self.base_spec.square = True
+        self.base_spec.duration_max = 3000
+        self.base_spec.set_res(512)
 
-        self.png_spec = copy.deepcopy(base_spec)
+        self.png_spec = copy.deepcopy(self.base_spec)
         self.png_spec.set_format((".png",))
         self.png_spec.animated = False
 
-        self.tgs_spec = copy.deepcopy(base_spec)
+        self.tgs_spec = copy.deepcopy(self.base_spec)
         self.tgs_spec.set_format((".tgs",))
         self.tgs_spec.fps_min = 60
         self.tgs_spec.fps_max = 60
         self.tgs_spec.size_max_img = 64000
         self.tgs_spec.size_max_vid = 64000
 
-        self.webm_spec = copy.deepcopy(base_spec)
+        self.webm_spec = copy.deepcopy(self.base_spec)
         self.webm_spec.set_format((".webm",))
         self.webm_spec.fps_max = 30
         self.webm_spec.animated = None if self.opt_comp.fake_vid else True
 
         self.opt_comp_merged = copy.deepcopy(self.opt_comp)
-        self.opt_comp_merged.merge(base_spec)
+        self.opt_comp_merged.merge(self.base_spec)
 
         base_cover_spec = CompOption(
             size_max_img=128000, size_max_vid=32000, square=True, duration_max=3000
@@ -65,10 +66,10 @@ class UploadTelegram(UploadBase):
         self.webm_cover_spec.animated = True
 
         self.opt_comp_cover_merged = copy.deepcopy(self.opt_comp)
-        self.opt_comp_cover_merged.merge(base_spec)
+        self.opt_comp_cover_merged.merge(self.base_spec)
 
     async def upload_pack(
-        self, pack_title: str, stickers: list[Path], emoji_dict: dict[str, str]
+        self, pack_title: str, stickers: List[Path], emoji_dict: Dict[str, str]
     ) -> str:
         assert self.opt_cred.telegram_token
         bot = Bot(self.opt_cred.telegram_token.strip())
@@ -208,6 +209,7 @@ class UploadTelegram(UploadBase):
                         Path(f"bytes{ext}"),  # type: ignore
                         self.opt_comp_cover_merged,
                         self.cb,
+                        self.cb_return,
                     )
 
                 try:
@@ -227,8 +229,8 @@ class UploadTelegram(UploadBase):
             result = f"https://t.me/addstickers/{pack_short_name}"
         return result
 
-    def upload_stickers_telegram(self) -> list[str]:
-        urls: list[str] = []
+    def upload_stickers_telegram(self) -> List[str]:
+        urls: List[str] = []
 
         if not (self.opt_cred.telegram_token and self.opt_cred.telegram_userid):
             self.cb.put("Token and userid required for uploading to telegram")
@@ -247,7 +249,7 @@ class UploadTelegram(UploadBase):
             msg_block += f"Default emoji is set to {self.opt_comp.default_emoji}.\n"
             msg_block += "Please edit emoji.txt now, then continue"
             MetadataHandler.generate_emoji_file(
-                dir=self.opt_output.dir, default_emoji=self.opt_comp.default_emoji
+                directory=self.opt_output.dir, default_emoji=self.opt_comp.default_emoji
             )
 
             self.cb.put(("msg_block", (msg_block,), None))
@@ -281,18 +283,9 @@ class UploadTelegram(UploadBase):
         opt_output: OutputOption,
         opt_comp: CompOption,
         opt_cred: CredOption,
-        cb: Union[
-            Queue[
-                Union[
-                    tuple[str, Optional[tuple[str]], Optional[dict[str, str]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ],
+        cb: "Union[Queue[CbQueueItemType], Callback]",
         cb_return: CallbackReturn,
-    ) -> list[str]:
+    ) -> List[str]:
         exporter = UploadTelegram(
             opt_output,
             opt_comp,

sticker_convert/uploaders/xcode_imessage.py

@@ -7,93 +7,37 @@ import shutil
 import zipfile
 from pathlib import Path
 from queue import Queue
-from typing import Any, Optional, Union
+from typing import Any, Dict, List, Union
 
 from sticker_convert.converter import StickerConvert
 from sticker_convert.definitions import ROOT_DIR
 from sticker_convert.job_option import CompOption, CredOption, OutputOption
 from sticker_convert.uploaders.upload_base import UploadBase
-from sticker_convert.utils.callback import Callback, CallbackReturn
-from sticker_convert.utils.files.metadata_handler import MetadataHandler
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
+from sticker_convert.utils.files.metadata_handler import XCODE_IMESSAGE_ICONSET, MetadataHandler
 from sticker_convert.utils.files.sanitize_filename import sanitize_filename
 from sticker_convert.utils.media.codec_info import CodecInfo
 from sticker_convert.utils.media.format_verify import FormatVerify
 
 
-class XcodeImessageIconset:
-    iconset: dict[str, tuple[int, int]] = {}
-
-    def __init__(self):
-        if self.iconset != {}:
-            return
-
-        if (ROOT_DIR / "ios-message-stickers-template").is_dir():
-            with open(
-                ROOT_DIR
-                / "ios-message-stickers-template/stickers StickerPackExtension/Stickers.xcstickers/iMessage App Icon.stickersiconset/Contents.json"
-            ) as f:
-                dict = json.load(f)
-        elif (ROOT_DIR / "ios-message-stickers-template.zip").is_file():
-            with zipfile.ZipFile(
-                (ROOT_DIR / "ios-message-stickers-template.zip"), "r"
-            ) as f:
-                dict = json.loads(
-                    f.read(
-                        "stickers StickerPackExtension/Stickers.xcstickers/iMessage App Icon.stickersiconset/Contents.json"
-                    ).decode()
-                )
-        else:
-            raise FileNotFoundError("ios-message-stickers-template not found")
-
-        for i in dict["images"]:
-            filename = i["filename"]
-            size = i["size"]
-            size_w = int(size.split("x")[0])
-            size_h = int(size.split("x")[1])
-            scale = int(i["scale"].replace("x", ""))
-            size_w_scaled = size_w * scale
-            size_h_scaled = size_h * scale
-
-            self.iconset[filename] = (size_w_scaled, size_h_scaled)
-
-        # self.iconset = {
-        #     'App-Store-1024x1024pt.png': (1024, 1024),
-        #     'iPad-Settings-29pt@2x.png': (58, 58),
-        #     'iPhone-settings-29pt@2x.png': (58, 58),
-        #     'iPhone-settings-29pt@3x.png': (87, 87),
-        #     'Messages27x20pt@2x.png': (54, 40),
-        #     'Messages27x20pt@3x.png': (81, 60),
-        #     'Messages32x24pt@2x.png': (64, 48),
-        #     'Messages32x24pt@3x.png': (96, 72),
-        #     'Messages-App-Store-1024x768pt.png': (1024, 768),
-        #     'Messages-iPad-67x50pt@2x.png': (134, 100),
-        #     'Messages-iPad-Pro-74x55pt@2x.png': (148, 110),
-        #     'Messages-iPhone-60x45pt@2x.png': (120, 90),
-        #     'Messages-iPhone-60x45pt@3x.png': (180, 135)
-        # }
-
-
 class XcodeImessage(UploadBase):
-    def __init__(self, *args: Any, **kwargs: Any):
-        super(XcodeImessage, self).__init__(*args, **kwargs)
-        self.iconset = XcodeImessageIconset().iconset
-
-        base_spec = CompOption()
-        base_spec.set_size_max(500000)
-        base_spec.set_res(300)
-        base_spec.set_format(("png", ".apng", ".gif", ".jpeg", "jpg"))
-        base_spec.square = True
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.base_spec.set_size_max(500000)
+        self.base_spec.set_res(300)
+        self.base_spec.set_format(("png", ".apng", ".gif", ".jpeg", "jpg"))
+        self.base_spec.square = True
 
-        self.small_spec = copy.deepcopy(base_spec)
+        self.small_spec = copy.deepcopy(self.base_spec)
 
-        self.medium_spec = copy.deepcopy(base_spec)
+        self.medium_spec = copy.deepcopy(self.base_spec)
         self.medium_spec.set_res(408)
 
-        self.large_spec = copy.deepcopy(base_spec)
+        self.large_spec = copy.deepcopy(self.base_spec)
         self.large_spec.set_res(618)
 
-    def create_imessage_xcode(self) -> list[str]:
-        urls: list[str] = []
+    def create_imessage_xcode(self) -> List[str]:
+        urls: List[str] = []
         title, author, _ = MetadataHandler.get_metadata(
             self.opt_output.dir,
             title=self.opt_output.title,
@@ -155,7 +99,7 @@ class XcodeImessage(UploadBase):
 
         return urls
 
-    def add_metadata(self, author: str, title: str):
+    def add_metadata(self, author: str, title: str) -> None:
         first_image_path = Path(
             self.opt_output.dir,
             [
@@ -170,16 +114,16 @@ class XcodeImessage(UploadBase):
         else:
             icon_source = first_image_path
 
-        for icon, res in self.iconset.items():
+        for icon, res in XCODE_IMESSAGE_ICONSET.items():
             spec_cover = CompOption()
             spec_cover.set_res_w(res[0])
             spec_cover.set_res_h(res[1])
             spec_cover.set_fps(0)
 
             icon_path = self.opt_output.dir / icon
-            if Path(icon) in [
-                i for i in self.opt_output.dir.iterdir()
-            ] and not FormatVerify.check_file(icon_path, spec=spec_cover):
+            if Path(icon) in list(
+                self.opt_output.dir.iterdir()
+            ) and not FormatVerify.check_file(icon_path, spec=spec_cover):
                 StickerConvert.convert(
                     icon_path, icon_path, spec_cover, self.cb, self.cb_return
                 )
@@ -190,7 +134,7 @@ class XcodeImessage(UploadBase):
 
         MetadataHandler.set_metadata(self.opt_output.dir, author=author, title=title)
 
-    def create_xcode_proj(self, author: str, title: str):
+    def create_xcode_proj(self, author: str, title: str) -> None:
         pack_path = self.opt_output.dir / title
         if (ROOT_DIR / "ios-message-stickers-template.zip").is_file():
             with zipfile.ZipFile(
@@ -260,12 +204,12 @@ class XcodeImessage(UploadBase):
             if i.suffix == ".sticker":
                 shutil.rmtree(stickers_path / i)
 
-        stickers_lst: list[str] = []
+        stickers_lst: List[str] = []
         for i in sorted(self.opt_output.dir.iterdir()):
             if (
                 CodecInfo.get_file_ext(i) == ".png"
                 and i.stem != "cover"
-                and i.name not in self.iconset
+                and i.name not in XCODE_IMESSAGE_ICONSET
             ):
                 sticker_dir = f"{i.stem}.sticker"  # 0.sticker
                 stickers_lst.append(sticker_dir)
@@ -284,18 +228,18 @@ class XcodeImessage(UploadBase):
                 }
 
                 # packname StickerPackExtension/Stickers.xcstickers/Sticker Pack.stickerpack/0.sticker/Contents.json
-                with open(sticker_path / "Contents.json", "w+") as f:
+                with open(sticker_path / "Contents.json", "w+", encoding="utf-8") as f:
                     json.dump(sticker_json_content, f, indent=2)
 
         # packname StickerPackExtension/Stickers.xcstickers/Sticker Pack.stickerpack/Contents.json
-        with open(stickers_path / "Contents.json") as f:
-            stickerpack_json_content: dict[str, list[dict[str, str]]] = json.load(f)
+        with open(stickers_path / "Contents.json", encoding="utf-8") as f:
+            stickerpack_json_content: Dict[str, List[Dict[str, str]]] = json.load(f)
 
         stickerpack_json_content["stickers"] = []
         for sticker in stickers_lst:
             stickerpack_json_content["stickers"].append({"filename": sticker})
 
-        with open(stickers_path / "Contents.json", "w+") as f:
+        with open(stickers_path / "Contents.json", "w+", encoding="utf-8") as f:
             json.dump(stickerpack_json_content, f, indent=2)
 
         # packname StickerPackExtension/Stickers.xcstickers/iMessage App Icon.stickersiconset
@@ -308,8 +252,8 @@ class XcodeImessage(UploadBase):
             if Path(iconfile_name).suffix == ".png":
                 os.remove(iconset_path / iconfile_name)
 
-        icons_lst: list[str] = []
-        for icon in self.iconset:
+        icons_lst: List[str] = []
+        for icon in XCODE_IMESSAGE_ICONSET:
             shutil.copy(self.opt_output.dir / icon, iconset_path / icon)
             icons_lst.append(icon)
 
@@ -335,17 +279,8 @@ class XcodeImessage(UploadBase):
         opt_output: OutputOption,
         opt_comp: CompOption,
         opt_cred: CredOption,
-        cb: Union[
-            Queue[
-                Union[
-                    tuple[str, Optional[tuple[str]], Optional[dict[str, str]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ],
+        cb: "Union[Queue[CbQueueItemType], Callback]",
         cb_return: CallbackReturn,
-    ) -> list[str]:
+    ) -> List[str]:
         exporter = XcodeImessage(opt_output, opt_comp, opt_cred, cb, cb_return)
         return exporter.create_imessage_xcode()

sticker_convert/utils/auth/get_kakao_auth.py

@@ -2,7 +2,7 @@
 import json
 import secrets
 import uuid
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Dict, Optional
 from urllib.parse import parse_qs, urlparse
 
 import requests
@@ -17,7 +17,7 @@ class GetKakaoAuth:
         cb_msg: Callable[..., None] = print,
         cb_msg_block: Callable[..., Any] = input,
         cb_ask_str: Callable[..., str] = input,
-    ):
+    ) -> None:
         self.username = opt_cred.kakao_username
         self.password = opt_cred.kakao_password
         self.country_code = opt_cred.kakao_country_code
@@ -92,7 +92,7 @@ class GetKakaoAuth:
     def enter_phone(self) -> bool:
         self.cb_msg("Submitting phone number")
 
-        json_data: dict[str, Any] = {
+        json_data: Dict[str, Any] = {
             "countryCode": self.country_code,
             "countryIso": self.country_iso,
             "phoneNumber": self.phone_number,
@@ -117,13 +117,12 @@ class GetKakaoAuth:
 
         if self.verify_method == "passcode":
             return self.verify_receive_sms()
-        elif self.verify_method == "mo-send":
+        if self.verify_method == "mo-send":
             dest_number = response_json["viewData"]["moNumber"]
             msg = response_json["viewData"]["moMessage"]
             return self.verify_send_sms(dest_number, msg)
-        else:
-            self.cb_msg_block(f"Unknown verification method: {response.text}")
-            return False
+        self.cb_msg_block(f"Unknown verification method: {response.text}")
+        return False
 
     def verify_send_sms(self, dest_number: str, msg: str) -> bool:
         self.cb_msg("Verification by sending SMS")
@@ -210,7 +209,7 @@ class GetKakaoAuth:
             "Connection": "close",
         }
 
-        json_data: dict[str, str] = {
+        json_data: Dict[str, str] = {
             "decision": "continue",
             "lang": self.app_language,
             "sessionToken": session_token,

sticker_convert/utils/auth/get_line_auth.py

@@ -2,15 +2,15 @@
 import json
 import platform
 from http.cookiejar import CookieJar
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 import requests
-import rookiepy
+import rookiepy  # type: ignore
 
 
 class GetLineAuth:
     def get_cred(self) -> Optional[str]:
-        browsers: list[Callable[..., Any]] = [
+        browsers: List[Callable[..., Any]] = [
             rookiepy.load,  # type: ignore # Supposed to load from any browser, but may fail
             rookiepy.firefox,  # type: ignore
             rookiepy.libre_wolf,  # type: ignore
@@ -59,7 +59,7 @@ class GetLineAuth:
         return cookies
 
     @staticmethod
-    def validate_cookies(cookies: Union[CookieJar, dict[str, str]]) -> bool:
+    def validate_cookies(cookies: Union[CookieJar, Dict[str, str]]) -> bool:
         headers = {
             "x-requested-with": "XMLHttpRequest",
         }
@@ -77,5 +77,4 @@ class GetLineAuth:
 
         if response_dict["errorMessage"]:
             return False
-        else:
-            return True
+        return True

sticker_convert/utils/auth/get_signal_auth.py

@@ -4,13 +4,13 @@ import os
 import platform
 import shutil
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 
 from sqlcipher3 import dbapi2 as sqlite3
 
 
 class GetSignalAuth:
-    def get_signal_desktop(self) -> tuple[Optional[str], Optional[str]]:
+    def get_signal_desktop(self) -> Tuple[Optional[str], Optional[str]]:
         if platform.system() == "Windows":
             signal_bin_path_prod = os.path.expandvars(
                 "%localappdata%/Programs/signal-desktop/Signal.exe"
@@ -45,16 +45,16 @@ class GetSignalAuth:
 
         if Path(signal_bin_path_prod).is_file():
             return signal_bin_path_prod, signal_user_data_dir_prod
-        elif Path(signal_bin_path_beta).is_file():
+        if Path(signal_bin_path_beta).is_file():
             return signal_bin_path_beta, signal_user_data_dir_beta
-        else:
-            return None, None
+
+        return None, None
 
     def get_cred(
         self,
         signal_bin_path: Optional[str] = None,
         signal_user_data_dir: Optional[str] = None,
-    ) -> tuple[Optional[str], Optional[str], str]:
+    ) -> Tuple[Optional[str], Optional[str], str]:
         if not (signal_bin_path and signal_user_data_dir):
             signal_bin_path, signal_user_data_dir = self.get_signal_desktop()
 
@@ -76,7 +76,7 @@ class GetSignalAuth:
             msg += f"{signal_user_data_dir=}\n"
             return None, None, msg
 
-        with open(signal_config) as f:
+        with open(signal_config, encoding="utf-8") as f:
             config = json.load(f)
         key = config.get("key")
         db_key = f"x'{key}'"