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

sticker_convert/__init__.py

@@ -1,3 +1,4 @@
 #!/usr/bin/env python3
 """sticker-convert"""
+
 from sticker_convert.version import __version__  # noqa

sticker_convert/__main__.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python3
-def main():
+
+
+def main() -> None:
     import multiprocessing
     import sys
 

sticker_convert/cli.py

@@ -1,14 +1,15 @@
 #!/usr/bin/env python3
 import argparse
 import signal
+import sys
 from argparse import Namespace
 from json.decoder import JSONDecodeError
 from math import ceil
 from multiprocessing import cpu_count
 from pathlib import Path
-from typing import Any
+from typing import Any, Dict
 
-from sticker_convert.definitions import CONFIG_DIR, DEFAULT_DIR, ROOT_DIR
+from sticker_convert.definitions import CONFIG_DIR, DEFAULT_DIR
 from sticker_convert.job import Job
 from sticker_convert.job_option import CompOption, CredOption, InputOption, OutputOption
 from sticker_convert.utils.auth.get_kakao_auth import GetKakaoAuth
@@ -21,27 +22,22 @@ from sticker_convert.version import __version__
 
 
 class CLI:
-    def __init__(self):
+    def __init__(self) -> None:
         self.cb = Callback()
 
-    def cli(self):
+    def cli(self) -> None:
         try:
-            self.help: dict[str, dict[str, str]] = JsonManager.load_json(
-                ROOT_DIR / "resources/help.json"
-            )
-            self.input_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/input.json"
-            )
-            self.compression_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/compression.json"
-            )
-            self.output_presets = JsonManager.load_json(
-                ROOT_DIR / "resources/output.json"
-            )
+            from sticker_convert.utils.files.json_resources_loader import COMPRESSION_JSON, EMOJI_JSON, HELP_JSON, INPUT_JSON, OUTPUT_JSON
         except RuntimeError as e:
-            self.cb.msg(e.__str__)
+            self.cb.msg(str(e))
             return
 
+        self.help = HELP_JSON
+        self.input_presets = INPUT_JSON
+        self.compression_presets = COMPRESSION_JSON
+        self.output_presets = OUTPUT_JSON
+        self.emoji_list = EMOJI_JSON
+
         parser = argparse.ArgumentParser(
             description="CLI for stickers-convert",
             formatter_class=argparse.RawTextHelpFormatter,
@@ -125,7 +121,7 @@ class CLI:
             "quantize_method",
         )
         flags_comp_bool = ("fake_vid",)
-        keyword_args: dict[str, Any]
+        keyword_args: Dict[str, Any]
         for k, v in self.help["comp"].items():
             if k in flags_comp_int:
                 keyword_args = {"type": int, "default": None}
@@ -186,7 +182,7 @@ class CLI:
 
         signal.signal(signal.SIGINT, job.cancel)
         status = job.start()
-        exit(status)
+        sys.exit(status)
 
     def get_opt_input(self, args: Namespace) -> InputOption:
         download_options = {
@@ -212,7 +208,7 @@ class CLI:
                 self.cb.msg(f"Detected URL input source: {download_option}")
             else:
                 self.cb.msg(f"Error: Unrecognied URL input source for url: {url}")
-                exit()
+                sys.exit()
 
         opt_input = InputOption(
             option=download_option,
@@ -296,15 +292,15 @@ class CLI:
             size_max_vid=self.compression_presets[preset]["size_max"]["vid"]
             if args.vid_size_max is None
             else args.vid_size_max,
-            format_img=tuple(
+            format_img=(
                 self.compression_presets[preset]["format"]["img"]
                 if args.img_format is None
-                else args.img_format
+                else args.img_format,
             ),
-            format_vid=tuple(
+            format_vid=(
                 self.compression_presets[preset]["format"]["vid"]
                 if args.vid_format is None
-                else args.vid_format
+                else args.vid_format,
             ),
             fps_min=self.compression_presets[preset]["fps"]["min"]
             if args.fps_min is None

sticker_convert/converter.py

@@ -6,26 +6,41 @@ from io import BytesIO
 from math import ceil, floor
 from pathlib import Path
 from queue import Queue
-from typing import TYPE_CHECKING, Any, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, List, Literal, Optional, Tuple, Union, cast
 
 import numpy as np
 from PIL import Image
 
-if TYPE_CHECKING:
-    from av.video.plane import VideoPlane
-
 from sticker_convert.job_option import CompOption
-from sticker_convert.utils.callback import Callback, CallbackReturn
+from sticker_convert.utils.callback import Callback, CallbackReturn, CbQueueItemType
 from sticker_convert.utils.files.cache_store import CacheStore
 from sticker_convert.utils.media.codec_info import CodecInfo
 from sticker_convert.utils.media.format_verify import FormatVerify
 
+if TYPE_CHECKING:
+    from av.video.plane import VideoPlane  # type: ignore
+
+MSG_START_COMP = "[I] Start compressing {} -> {}"
+MSG_SKIP_COMP = "[S] Compatible file found, skip compress and just copy {} -> {}"
+MSG_COMP = (
+    "[C] Compressing {} -> {} res={}x{}, "
+    "quality={}, fps={}, color={} (step {}-{}-{})"
+)
+MSG_REDO_COMP = "[{}] Compressed {} -> {} but size {} {} limit {}, recompressing"
+MSG_DONE_COMP = "[S] Successful compression {} -> {} size {} (step {})"
+MSG_FAIL_COMP = (
+    "[F] Failed Compression {} -> {}, "
+    "cannot get below limit {} with lowest quality under current settings (Best size: {})"
+)
+
+
 def rounding(value: float) -> Decimal:
     return Decimal(value).quantize(0, ROUND_HALF_UP)
 
+
 def get_step_value(
-    max: Optional[int],
-    min: Optional[int],
+    max_step: Optional[int],
+    min_step: Optional[int],
     step: int,
     steps: int,
     power: float = 1.0,
@@ -41,58 +56,34 @@ def get_step_value(
     else:
         factor = 0
 
-    if max is not None and min is not None:
-        v = round((max - min) * step / steps * factor + min)
+    if max_step is not None and min_step is not None:
+        v = round((max_step - min_step) * step / steps * factor + min_step)
         if even is True and v % 2 == 1:
             return v + 1
-        else:
-            return v
-    else:
-        return None
+        return v
+    return None
 
 
 def useful_array(
     plane: "VideoPlane", bytes_per_pixel: int = 1, dtype: str = "uint8"
-) -> np.ndarray[Any, Any]:
+) -> "np.ndarray[Any, Any]":
     total_line_size = abs(plane.line_size)
     useful_line_size = plane.width * bytes_per_pixel
-    arr: np.ndarray[Any, Any] = np.frombuffer(cast(bytes, plane), np.uint8)
+    arr: "np.ndarray[Any, Any]" = np.frombuffer(cast(bytes, plane), np.uint8)
     if total_line_size != useful_line_size:
         arr = arr.reshape(-1, total_line_size)[:, 0:useful_line_size].reshape(-1)
     return arr.view(np.dtype(dtype))
 
 
 class StickerConvert:
-    MSG_START_COMP = "[I] Start compressing {} -> {}"
-    MSG_SKIP_COMP = "[S] Compatible file found, skip compress and just copy {} -> {}"
-    MSG_COMP = (
-        "[C] Compressing {} -> {} res={}x{}, "
-        "quality={}, fps={}, color={} (step {}-{}-{})"
-    )
-    MSG_REDO_COMP = "[{}] Compressed {} -> {} but size {} {} limit {}, recompressing"
-    MSG_DONE_COMP = "[S] Successful compression {} -> {} size {} (step {})"
-    MSG_FAIL_COMP = (
-        "[F] Failed Compression {} -> {}, "
-        "cannot get below limit {} with lowest quality under current settings (Best size: {})"
-    )
-
     def __init__(
         self,
-        in_f: Union[Path, tuple[Path, bytes]],
+        in_f: Union[Path, Tuple[Path, bytes]],
         out_f: Path,
         opt_comp: CompOption,
-        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:
         self.in_f: Union[bytes, Path]
         if isinstance(in_f, Path):
             self.in_f = in_f
@@ -105,7 +96,7 @@ class StickerConvert:
             self.in_f_path = in_f[0]
             self.codec_info_orig = CodecInfo(in_f[1], Path(in_f[0]).suffix)
 
-        valid_formats: list[str] = []
+        valid_formats: List[str] = []
         for i in opt_comp.get_format():
             valid_formats.extend(i)
 
@@ -125,8 +116,8 @@ class StickerConvert:
         self.out_f_name: str = self.out_f.name
 
         self.cb = cb
-        self.frames_raw: list[np.ndarray[Any, Any]] = []
-        self.frames_processed: list[np.ndarray[Any, Any]] = []
+        self.frames_raw: "List[np.ndarray[Any, Any]]" = []
+        self.frames_processed: "List[np.ndarray[Any, Any]]" = []
         self.opt_comp: CompOption = opt_comp
         if not self.opt_comp.steps:
             self.opt_comp.steps = 1
@@ -148,32 +139,23 @@ class StickerConvert:
 
     @staticmethod
     def convert(
-        in_f: Union[Path, tuple[Path, bytes]],
+        in_f: Union[Path, Tuple[Path, bytes]],
         out_f: Path,
         opt_comp: CompOption,
-        cb: Union[
-            Queue[
-                Union[
-                    tuple[str, Optional[tuple[str]], Optional[dict[str, str]]],
-                    str,
-                    None,
-                ]
-            ],
-            Callback,
-        ],
-        cb_return: CallbackReturn,
-    ) -> tuple[bool, Path, Union[None, bytes, Path], int]:
+        cb: "Union[Queue[CbQueueItemType], Callback]",
+        _cb_return: CallbackReturn,
+    ) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
         sticker = StickerConvert(in_f, out_f, opt_comp, cb)
         result = sticker._convert()
         cb.put("update_bar")
         return result
 
-    def _convert(self) -> tuple[bool, Path, Union[None, bytes, Path], int]:
+    def _convert(self) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
         result = self.check_if_compatible()
         if result:
             return self.compress_done(result)
 
-        self.cb.put((self.MSG_START_COMP.format(self.in_f_name, self.out_f_name)))
+        self.cb.put((MSG_START_COMP.format(self.in_f_name, self.out_f_name)))
 
         steps_list = self.generate_steps_list()
 
@@ -205,7 +187,7 @@ class StickerConvert:
             self.color = param[4]
 
             self.tmp_f = BytesIO()
-            msg = self.MSG_COMP.format(
+            msg = MSG_COMP.format(
                 self.in_f_name,
                 self.out_f_name,
                 self.res_w,
@@ -271,7 +253,7 @@ class StickerConvert:
                 file_info=self.codec_info_orig,
             )
         ):
-            self.cb.put((self.MSG_SKIP_COMP.format(self.in_f_name, self.out_f_name)))
+            self.cb.put((MSG_SKIP_COMP.format(self.in_f_name, self.out_f_name)))
 
             if isinstance(self.in_f, Path):
                 with open(self.in_f, "rb") as f:
@@ -282,11 +264,11 @@ class StickerConvert:
                 self.result_size = len(self.in_f)
 
             return result
-        else:
-            return None
 
-    def generate_steps_list(self) -> list[tuple[Optional[int], ...]]:
-        steps_list: list[tuple[Optional[int], ...]] = []
+        return None
+
+    def generate_steps_list(self) -> List[Tuple[Optional[int], ...]]:
+        steps_list: List[Tuple[Optional[int], ...]] = []
         for step in range(self.opt_comp.steps, -1, -1):
             steps_list.append(
                 (
@@ -332,16 +314,16 @@ class StickerConvert:
 
         return steps_list
 
-    def recompress(self, sign: str):
-        msg = self.MSG_REDO_COMP.format(
+    def recompress(self, sign: str) -> None:
+        msg = MSG_REDO_COMP.format(
             sign, self.in_f_name, self.out_f_name, self.size, sign, self.size_max
         )
         self.cb.put(msg)
 
     def compress_fail(
         self,
-    ) -> tuple[bool, Path, Union[None, bytes, Path], int]:
-        msg = self.MSG_FAIL_COMP.format(
+    ) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
+        msg = MSG_FAIL_COMP.format(
             self.in_f_name, self.out_f_name, self.size_max, self.size
         )
         self.cb.put(msg)
@@ -350,7 +332,7 @@ class StickerConvert:
 
     def compress_done(
         self, data: bytes, result_step: Optional[int] = None
-    ) -> tuple[bool, Path, Union[None, bytes, Path], int]:
+    ) -> Tuple[bool, Path, Union[None, bytes, Path], int]:
         out_f: Union[None, bytes, Path]
 
         if self.out_f.stem == "none":
@@ -363,14 +345,14 @@ class StickerConvert:
                 f.write(data)
 
         if result_step:
-            msg = self.MSG_DONE_COMP.format(
+            msg = MSG_DONE_COMP.format(
                 self.in_f_name, self.out_f_name, self.result_size, result_step
             )
             self.cb.put(msg)
 
         return True, self.in_f_path, out_f, self.result_size
 
-    def frames_import(self):
+    def frames_import(self) -> None:
         if isinstance(self.in_f, Path):
             suffix = self.in_f.suffix
         else:
@@ -385,21 +367,21 @@ class StickerConvert:
         else:
             self._frames_import_pyav()
 
-    def _frames_import_pillow(self):
+    def _frames_import_pillow(self) -> None:
         with Image.open(self.in_f) as im:
             # Note: im.convert("RGBA") would return rgba image of current frame only
-            if "n_frames" in im.__dir__():
+            if "n_frames" in dir(im):
                 for i in range(im.n_frames):
                     im.seek(i)
                     self.frames_raw.append(np.asarray(im.convert("RGBA")))
             else:
                 self.frames_raw.append(np.asarray(im.convert("RGBA")))
 
-    def _frames_import_pyav(self):
-        import av
-        from av.codec.context import CodecContext
-        from av.container.input import InputContainer
-        from av.video.codeccontext import VideoCodecContext
+    def _frames_import_pyav(self) -> None:
+        import av  # type: ignore
+        from av.codec.context import CodecContext  # type: ignore
+        from av.container.input import InputContainer  # type: ignore
+        from av.video.codeccontext import VideoCodecContext  # type: ignore
 
         # Crashes when handling some webm in yuv420p and convert to rgba
         # https://github.com/PyAV-Org/PyAV/issues/1166
@@ -429,7 +411,7 @@ class StickerConvert:
                         height = frame.height
                     if frame.format.name == "yuv420p":
                         rgb_array = frame.to_ndarray(format="rgb24")  # type: ignore
-                        cast(np.ndarray[Any, Any], rgb_array)
+                        cast("np.ndarray[Any, Any]", rgb_array)
                         rgba_array = np.dstack(
                             (
                                 rgb_array,
@@ -443,7 +425,7 @@ class StickerConvert:
                             width=width,
                             height=height,
                             format="yuva420p",
-                            dst_colorspace=1,
+                            dst_colorspace=1,  # type: ignore
                         )
 
                         # https://stackoverflow.com/questions/72308308/converting-yuv-to-rgb-in-python-coefficients-work-with-array-dont-work-with-n
@@ -470,11 +452,11 @@ class StickerConvert:
 
                         yuv_array = yuv_array.astype(np.float32)
                         yuv_array[:, :, 0] = (
-                            yuv_array[:, :, 0].clip(16, 235).astype(yuv_array.dtype)
+                            yuv_array[:, :, 0].clip(16, 235).astype(yuv_array.dtype)  # type: ignore
                             - 16
                         )
                         yuv_array[:, :, 1:] = (
-                            yuv_array[:, :, 1:].clip(16, 240).astype(yuv_array.dtype)
+                            yuv_array[:, :, 1:].clip(16, 240).astype(yuv_array.dtype)  # type: ignore
                             - 128
                         )
 
@@ -492,7 +474,7 @@ class StickerConvert:
 
                     self.frames_raw.append(rgba_array)
 
-    def _frames_import_lottie(self):
+    def _frames_import_lottie(self) -> None:
         from rlottie_python.rlottie_wrapper import LottieAnimation
 
         if isinstance(self.in_f, Path):
@@ -522,15 +504,19 @@ class StickerConvert:
         anim.lottie_animation_destroy()
 
     def frames_resize(
-        self, frames_in: list[np.ndarray[Any, Any]]
-    ) -> list[np.ndarray[Any, Any]]:
-        frames_out: list[np.ndarray[Any, Any]] = []
+        self, frames_in: "List[np.ndarray[Any, Any]]"
+    ) -> "List[np.ndarray[Any, Any]]":
+        frames_out: "List[np.ndarray[Any, Any]]" = []
 
-        resample: Literal[0, 1, 2, 3]
+        resample: Literal[0, 1, 2, 3, 4, 5]
         if self.opt_comp.scale_filter == "nearest":
             resample = Image.NEAREST
+        elif self.opt_comp.scale_filter == "box":
+            resample = Image.BOX
         elif self.opt_comp.scale_filter == "bilinear":
             resample = Image.BILINEAR
+        elif self.opt_comp.scale_filter == "hamming":
+            resample = Image.HAMMING
         elif self.opt_comp.scale_filter == "bicubic":
             resample = Image.BICUBIC
         elif self.opt_comp.scale_filter == "lanczos":
@@ -542,22 +528,22 @@ class StickerConvert:
             with Image.fromarray(frame, "RGBA") as im:  # type: ignore
                 width, height = im.size
 
-                if self.res_w is None:
-                    self.res_w = width
-                if self.res_h is None:
-                    self.res_h = height
+            if self.res_w is None:
+                self.res_w = width
+            if self.res_h is None:
+                self.res_h = height
 
-                if width > height:
-                    width_new = self.res_w
-                    height_new = height * self.res_w // width
-                else:
-                    height_new = self.res_h
-                    width_new = width * self.res_h // height
+            if width > height:
+                width_new = self.res_w
+                height_new = height * self.res_w // width
+            else:
+                height_new = self.res_h
+                width_new = width * self.res_h // height
 
-                with (
-                    im.resize((width_new, height_new), resample=resample) as im_resized,
-                    Image.new("RGBA", (self.res_w, self.res_h), (0, 0, 0, 0)) as im_new,
-                ):
+            with im.resize((width_new, height_new), resample=resample) as im_resized:
+                with Image.new(
+                    "RGBA", (self.res_w, self.res_h), (0, 0, 0, 0)
+                ) as im_new:
                     im_new.paste(
                         im_resized,
                         ((self.res_w - width_new) // 2, (self.res_h - height_new) // 2),
@@ -567,8 +553,8 @@ class StickerConvert:
         return frames_out
 
     def frames_drop(
-        self, frames_in: list[np.ndarray[Any, Any]]
-    ) -> list[np.ndarray[Any, Any]]:
+        self, frames_in: "List[np.ndarray[Any, Any]]"
+    ) -> "List[np.ndarray[Any, Any]]":
         if (
             not self.codec_info_orig.is_animated
             or not self.fps
@@ -576,7 +562,7 @@ class StickerConvert:
         ):
             return [frames_in[0]]
 
-        frames_out: list[np.ndarray[Any, Any]] = []
+        frames_out: "List[np.ndarray[Any, Any]]" = []
 
         # fps_ratio: 1 frame in new anim equal to how many frame in old anim
         # speed_ratio: How much to speed up / slow down
@@ -620,7 +606,7 @@ class StickerConvert:
                     frames_out.append(frames_in[-1])
                 return frames_out
 
-    def frames_export(self):
+    def frames_export(self) -> None:
         is_animated = len(self.frames_processed) > 1 and self.fps
         if self.out_f.suffix in (".apng", ".png"):
             if is_animated:
@@ -634,7 +620,7 @@ class StickerConvert:
         else:
             self._frames_export_pil()
 
-    def _frames_export_pil(self):
+    def _frames_export_pil(self) -> None:
         with Image.fromarray(self.frames_processed[0]) as im:  # type: ignore
             im.save(
                 self.tmp_f,
@@ -642,9 +628,10 @@ class StickerConvert:
                 quality=self.quality,
             )
 
-    def _frames_export_pyav(self):
-        import av
-        from av.container import OutputContainer
+    def _frames_export_pyav(self) -> None:
+        import av  # type: ignore
+        from av.container import OutputContainer  # type: ignore
+        from av.video.stream import VideoStream  # type: ignore
 
         options = {}
 
@@ -675,6 +662,8 @@ class StickerConvert:
         ) as output:
             output = cast(OutputContainer, output)  # type: ignore
             out_stream = output.add_stream(codec, rate=self.fps, options=options)  # type: ignore
+            out_stream = cast(VideoStream, out_stream)
+            assert isinstance(self.res_w, int) and isinstance(self.res_h, int)
             out_stream.width = self.res_w
             out_stream.height = self.res_h
             out_stream.pix_fmt = pixel_format
@@ -687,7 +676,7 @@ class StickerConvert:
             for packet in out_stream.encode():  # type: ignore
                 output.mux(packet)  # type: ignore
 
-    def _frames_export_webp(self):
+    def _frames_export_webp(self) -> None:
         import webp  # type: ignore
 
         assert self.fps
@@ -702,7 +691,7 @@ class StickerConvert:
         anim_data = enc.assemble(timestamp_ms)  # type: ignore
         self.tmp_f.write(anim_data.buffer())  # type: ignore
 
-    def _frames_export_png(self):
+    def _frames_export_png(self) -> None:
         with Image.fromarray(self.frames_processed[0], "RGBA") as image:  # type: ignore
             image_quant = self.quantize(image)
 
@@ -712,7 +701,7 @@ class StickerConvert:
             frame_optimized = self.optimize_png(f.read())
             self.tmp_f.write(frame_optimized)
 
-    def _frames_export_apng(self):
+    def _frames_export_apng(self) -> None:
         from apngasm_python._apngasm_python import APNGAsm, create_frame_from_rgba  # type: ignore
 
         assert self.fps
@@ -771,10 +760,10 @@ class StickerConvert:
             return image.copy()
         if self.opt_comp.quantize_method == "imagequant":
             return self._quantize_by_imagequant(image)
-        elif self.opt_comp.quantize_method == "fastoctree":
+        if self.opt_comp.quantize_method == "fastoctree":
             return self._quantize_by_fastoctree(image)
-        else:
-            return image
+
+        return image
 
     def _quantize_by_imagequant(self, image: Image.Image) -> Image.Image:
         import imagequant  # type: ignore
@@ -819,17 +808,17 @@ class StickerConvert:
             #
             # For GIF, we need to adjust fps such that delay is matching to hundreths of second
             return self._fix_fps_duration(fps, 100)
-        elif self.out_f.suffix in (".webp", ".apng", ".png"):
+        if self.out_f.suffix in (".webp", ".apng", ".png"):
             return self._fix_fps_duration(fps, 1000)
-        else:
-            return self._fix_fps_pyav(fps)
+
+        return self._fix_fps_pyav(fps)
 
     def _fix_fps_duration(self, fps: float, denominator: int) -> Fraction:
         delay = int(rounding(denominator / fps))
         fps_fraction = Fraction(denominator, delay)
         if self.opt_comp.fps_max and fps_fraction > self.opt_comp.fps_max:
             return Fraction(denominator, (delay + 1))
-        elif self.opt_comp.fps_min and fps_fraction < self.opt_comp.fps_min:
+        if self.opt_comp.fps_min and fps_fraction < self.opt_comp.fps_min:
             return Fraction(denominator, (delay - 1))
         return fps_fraction
 

sticker_convert/definitions.py

@@ -48,8 +48,7 @@ def check_root_dir_exe_writable() -> bool:
         or "site-packages" in ROOT_DIR_EXE.as_posix()
     ):
         return False
-    else:
-        return True
+    return True
 
 
 ROOT_DIR_EXE_WRITABLE = check_root_dir_exe_writable()
@@ -58,13 +57,11 @@ ROOT_DIR_EXE_WRITABLE = check_root_dir_exe_writable()
 def get_default_dir() -> Path:
     if ROOT_DIR_EXE_WRITABLE:
         return ROOT_DIR_EXE
-    else:
-        home_dir = Path.home()
-        desktop_dir = home_dir / "Desktop"
-        if desktop_dir.is_dir():
-            return desktop_dir
-        else:
-            return home_dir
+    home_dir = Path.home()
+    desktop_dir = home_dir / "Desktop"
+    if desktop_dir.is_dir():
+        return desktop_dir
+    return home_dir
 
 
 # Default directory for stickers_input and stickers_output
@@ -79,9 +76,8 @@ def get_config_dir() -> Path:
 
     if ROOT_DIR_EXE_WRITABLE:
         return ROOT_DIR_EXE
-    else:
-        os.makedirs(fallback_dir, exist_ok=True)
-        return fallback_dir
+    os.makedirs(fallback_dir, exist_ok=True)
+    return fallback_dir
 
 
 # Directory for saving configs